*
* Description: This routine sets the delay used in OSProbe_Task()
*
* Argument(s): delay    is the delay, in milliseconds.
*
* Returns    : none.
*********************************************************************************************************
*/

#if OS_PROBE_TASK > 0
void    OSProbe_SetDelay (INT16U  delay)
{
    OSProbe_Delay = delay;
}
#endif


/*
*********************************************************************************************************
*********************************************************************************************************
**                                             TASK HOOKS
*********************************************************************************************************
*********************************************************************************************************
*/

/*
*********************************************************************************************************
*                               uC/Probe Plug-in for uC/OS-II TASK CREATE HOOK
*
* Description: This function MUST be called by uC/OS-II's Task Create Hook function: OSTaskCreateHook().
*********************************************************************************************************
*/

#if OS_PROBE_HOOKS_EN > 0
void  OSProbe_TaskCreateHook (OS_TCB *ptcb)
{
    ptcb->OSTCBCyclesStart = OSProbe_TimeGetCycles();               /* Get the current start time for this task.            */
    ptcb->OSTCBCyclesTot   = 0;                                     /* Update the task's total execution time               */
}
#endif


/*
*********************************************************************************************************
*                               uC/Probe Plug-in for uC/OS-II TASK SWITCH HOOK
*
* Description: This function MUST be called by uC/OS-II's Task Switch Hook function: OSTaskSwHook().
*********************************************************************************************************
*/

#if OS_PROBE_HOOKS_EN > 0
void  OSProbe_TaskSwHook (void)
{
    INT32U  cycles;


    cycles                         = OSProbe_TimeGetCycles();       /* This task is done                                    */
    OSTCBCur->OSTCBCyclesTot      += cycles - OSTCBCur->OSTCBCyclesStart;
    OSTCBHighRdy->OSTCBCyclesStart = cycles;                        /* Save absolute #cycles at task activation             */
}
#endif


/*
*********************************************************************************************************
*                               uC/Probe Plug-in for uC/OS-II TICK HOOK
*
* Description: This function is currently unused.
*
* Returns    : None
*********************************************************************************************************
*/

#if OS_PROBE_HOOKS_EN > 0
void  OSProbe_TickHook (void)
{
    (void)OSProbe_TimeGetCycles();
}
#endif


/*
*********************************************************************************************************
*                                           Get time [cycles]
*
* Description: This routine is required for task execution time measurement.  This function needs to
*              return time as accurately as possible and in a 32-bit variable.
*
* Returns    : A 32-bit representation of time.
*********************************************************************************************************
*/

#if OS_PROBE_HOOKS_EN > 0
INT32U   OSProbe_TimeGetCycles(void)
{
    INT32U     cycles;
#if OS_PROBE_TMR_32_BITS > 0
    INT32U     cnts32;
    INT32U     cnts32_delta;
#else
    INT16U     cnts16;
    INT16U     cnts16_delta;
#endif
#if OS_CRITICAL_METHOD == 3                                         /* Allocate storage for CPU status register             */
    OS_CPU_SR  cpu_sr = 0;
#endif


    OS_ENTER_CRITICAL();
#if OS_PROBE_TMR_32_BITS > 0
    cnts32               = OSProbe_TmrRd();                         /* Read current counts of the free running counter      */
    cnts32_delta         = cnts32 - OSProbe_TmrCntsPrev;
    OSProbe_TmrCntsPrev  = cnts32;                                  /* Save current counts for next time                    */
    OSProbe_CyclesCtr   += cnts32_delta;
#else
    cnts16               = (INT16U)OSProbe_TmrRd();                 /* Read current counts of the free running counter      */
    cnts16_delta         = cnts16 - OSProbe_TmrCntsPrev;
    OSProbe_TmrCntsPrev  = cnts16;                                  /* Save current counts for next time                    */
    OSProbe_CyclesCtr   += (INT32U)cnts16_delta;
#endif
    cycles               = OSProbe_CyclesCtr;
    OS_EXIT_CRITICAL();

    return (cycles);
}
#endif


/*
*********************************************************************************************************
*********************************************************************************************************
**                                          LOCAL FUNCTION
*********************************************************************************************************
*********************************************************************************************************
*/

/*
*********************************************************************************************************
*                                            uC/OS-II Task
*
* Description: This function updates OSProbe_TaskStkUsage[] and OSProbe_TaskCPUUsage[] and calls
*              a user-specified callback functions (OSProbe_CallbackFnct()), if the user sets this
*              function.
*
* Argument(s): p_arg    is the argument passed to OSProbe_Task() by 'OSTaskCreate()'.
*
* Returns    : None
*********************************************************************************************************
*/

#if OS_PROBE_TASK > 0
static  void  OSProbe_Task (void *p_arg)
{
            OS_TCB  *ptcb;
            INT16U   i;
            INT32U   cycles_tot;
    static  INT32U   cycles_dif[OS_MAX_TASKS];
    static  INT32U   cycles_tot_last[OS_MAX_TASKS];



    (void)p_arg;

                                                                    /* Initialize stored CyclesTot values                   */
    for (i = 0; i < OS_MAX_TASKS; i++) {
        cycles_tot_last[i]      = 0;
        OSProbe_TaskStkUsage[i] = 0;
        OSProbe_TaskCPUUsage[i] = 0;
    }

    while (1) {
        OSTimeDlyHMSM(0, 0, 0, OSProbe_Delay);
        if ((INT32U)OSProbe_CallbackFnct != 0) {
            OSProbe_CallbackFnct();
        }

                                                                    /* Update task CPU usage                                */
        i          = 0;
        cycles_tot = 0;
        ptcb       = &OSTCBTbl[0];                                  /*  ... Get pointer to first TCB ...                    */
        while (i < OS_MAX_TASKS) {
            if (ptcb == (OS_TCB *)0 || ptcb == (OS_TCB *)1) {
                break;                                              /*  ... If ptcb is NULL, then last TCB reached ...      */
            }

                                                                    /*  ... Calculate new CyclesDif, the number of cycles   */
                                                                    /*  ... used by the task since the last reading.  Half  */
                                                                    /*  ... the previous value is added to provide some     */
                                                                    /*  ... hysteresis, thereby reducing the natural        */
                                                                    /*  ... "jitter" in the data.                           */
            cycles_dif[i]       = (ptcb->OSTCBCyclesTot - cycles_tot_last[i]) / 2 + (cycles_dif[i] / 2);
            cycles_tot_last[i]  = ptcb->OSTCBCyclesTot;
            cycles_tot         += cycles_dif[i];

            if (ptcb->OSTCBStkSize == 0) {
                OSProbe_TaskStkUsage[i] = 0;
            } else {
#if OS_STK_GROWTH == 1
                OSProbe_TaskStkUsage[i] = (FP32)(((INT32U)(ptcb->OSTCBStkBase) - (INT32U)(ptcb->OSTCBStkPtr)) * 100)
                                        / ((ptcb->OSTCBStkSize) * sizeof (OS_STK));
#else
                OSProbe_TaskStkUsage[i] = (FP32)(((INT32U)(ptcb->OSTCBStkPtr) - (INT32U)(ptcb->OSTCBStkBase)) * 100)
                                        / ((ptcb->OSTCBStkSize) * sizeof (OS_STK));
#endif
            }

            ptcb = ptcb->OSTCBPrev;

            i++;
        }
                                                                    /*  ... For each task, calculate percent CPU usage.     */
        for (i = 0; i < OS_MAX_TASKS; i++) {
            OSProbe_TaskCPUUsage[i] = (FP32)(cycles_dif[i] * 100) / cycles_tot;
        }
    }
}
#endif