Content Comparison

void OSTimeDly (INT32U ticks)
{
    INT8U      y;
#if OS_CRITICAL_METHOD == 3u                     
    OS_CPU_SR  cpu_sr = 0u;
#endif

    if (OSIntNesting > 0u) {                     
        return;
    }
    if (OSLockNesting > 0u) {                    
        return;
    }

    if (ticks > 0) {                                                         (1)
        OS_ENTER_CRITICAL();
        y            =  OSTCBCur->OSTCBY;                                    (2)
        OSRdyTbl[y] &= (OS_PRIO)~OSTCBCur->OSTCBBitX;
        if (OSRdyTbl[y] == 0u) {
            OSRdyGrp &= (OS_PRIO)~OSTCBCur->OSTCBBitY;
        }

        OSTCBCur->OSTCBDly = ticks;                                          (3)
        OS_EXIT_CRITICAL();
        OSSched();                                                           (4)
    }
}

(1) If you specify a value of 0, you are indicating that you don’t want to delay the task, and the function returns immediately to the caller.

(2) A nonzero value causes OSTimeDly() to remove the current task from the ready list.

(3) Next, the number of ticks are stored in the OS_TCB of the current task, where it is decremented on every clock tick by OSTimeTick(). You should note that the calling task is not placed in any wait list. Simply having a non-zero value in .OSTCBDly is sufficient for OSTimeTick() to know that the task has been delayed.

(4) Finally, since the task is no longer ready, the scheduler is called so that the next highest priority task that is ready to run gets executed.

Image Added

(1) A tick interrupt occurs every 10ms.

(2) Assuming that you are not servicing any other interrupts and that you have interrupts enabled, the tick ISR will be invoked.

(3) You may have a few high-priority tasks (HPTs) waiting for time to expire, so they will execute next.

(4) The low-priority task (LPT) shown in Figure 5.1 then gets a chance to execute and, upon completion, calls OSTimeDly(1) at the moment shown. µC/OS-II puts the task to sleep until the next tick.

(5) & (6) When the next tick arrives, the tick ISR executes, but this time there are no HPTs to execute, and µC/OS-II executes the task that delayed itself for one tick. As you can see, the task actually delayed for less than one tick! On heavily loaded systems, the task may call OSTimeDly(1) a few tens of microseconds before the tick occurs and thus the delay results in almost no delay because the task is immediately rescheduled. If your application must delay for at least one tick, you must call OSTimeDly(2) , specifying a delay of two ticks!

INT8U OSTimeDlyHMSM (INT8U hours, INT8U minutes, INT8U seconds, INT16U milli)
{
    INT32U ticks;
 
 
    if (OSIntNesting > 0u) {                     
        return (OS_ERR_TIME_DLY_ISR);
    }
    if (OSLockNesting > 0u) {                    
        return (OS_ERR_SCHED_LOCKED);
    }
#if OS_ARG_CHK_EN > 0u
    if (hours == 0u) {                                                 (1)              
        if (minutes == 0u) {
            if (seconds == 0u) {
                if (ms == 0u) {
                    return (OS_ERR_TIME_ZERO_DLY);
                }
            }
        }
    }
    if (minutes > 59u) {                                               (2)
        return (OS_ERR_TIME_INVALID_MINUTES);    
    }
    if (seconds > 59u) {
        return (OS_ERR_TIME_INVALID_SECONDS);
    }
    if (ms > 999u) {
        return (OS_ERR_TIME_INVALID_MS);
    }
#endif
    ticks = (INT32U)hours    * 3600L * OS_TICKS_PER_SEC                (3)
          + (INT32U)minutes  *   60L * OS_TICKS_PER_SEC
          + (INT32U)seconds  *         OS_TICKS_PER_SEC
          + OS_TICKS_PER_SEC * ((INT32U)milli
          + 500L / OS_TICKS_PER_SEC) / 1000L;                          (4)
    OSTimeDly(ticks);                                                  
    return (OS_ERR_NONE);
}

(1) As with OSTimeDly(), OSTimeDlyHMSM() exits if you specify no delay.

(2) OSTimeDlyHMSM() then checks that you have specified valid values for its arguments.

(3) Because µC/OS-II only knows about ticks, the total number of ticks is computed from the specified time.

(4) This portion of the equation determines the number of ticks given the specified milliseconds with rounding to the nearest tick. The value 500/OS_TICKS_PER_SECOND basically corresponds to 0.5 ticks converted to milliseconds. For example, if the tick rate (OS_TICKS_PER_SEC) is set to 100Hz (10ms), a delay of 4ms would result in no delay! A delay of 5ms would result in a delay of 10ms, and so on.

INT8U  OSTimeDlyResume (INT8U prio)
{
#if OS_CRITICAL_METHOD == 3                      
    OS_CPU_SR  cpu_sr;
#endif    
    OS_TCB    *ptcb;
 
 
    if (prio >= OS_LOWEST_PRIO) {                                        (1)
        return (OS_ERR_PRIO_INVALID);
    }
    OS_ENTER_CRITICAL();
    ptcb = (OS_TCB *)OSTCBPrioTbl[prio];                   
    if (ptcb == (OS_TCB *)0) {                                           (2)
        OS_EXIT_CRITICAL();
        return (OS_ERR_TASK_NOT_EXIST);                        
    }
    if (ptcb == OS_TCB_RESERVED) {
        OS_EXIT_CRITICAL();
        return (OS_ERR_TASK_NOT_EXIST);                        
    }
    if (ptcb->OSTCBDly == 0u) {                                
        OS_EXIT_CRITICAL();
        return (OS_ERR_TIME_NOT_DLY);                          
    }
    ptcb->OSTCBDly = 0u;                                                 (4)
    if ((ptcb->OSTCBStat & OS_STAT_PEND_ANY) != OS_STAT_RDY) {
        ptcb->OSTCBStat     &= ~OS_STAT_PEND_ANY;              
        ptcb->OSTCBStatPend  =  OS_STAT_PEND_TO;               
    } else {
        ptcb->OSTCBStatPend  =  OS_STAT_PEND_OK;
    }
    if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY) {            (5)
        OSRdyGrp               |= ptcb->OSTCBBitY;                       (6)
        OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
        OS_EXIT_CRITICAL();
        OS_Sched();                                                      (7)
    } else {
        OS_EXIT_CRITICAL();                                    
    }
    return (OS_ERR_NONE);                           
}

(1) OSTimeDlyResume() begins by making sure the task has a valid priority.

(2) Next, OSTimeDlyResume() verifies that the task to resume does in fact exist.

(3) If the task exists, OSTimeDlyResume() checks to see if the task is waiting for time to expire. Whenever the OS_TCB field .OSTCBDly contains a nonzero value, the task is waiting for time to expire because the task called either OSTimeDly(), OSTimeDlyHMSM(), or any of the PEND functions described in subsequent chapters.

(4) The delay is then canceled by forcing .OSTCBDly to 0.

(5) A delayed task may also have been suspended; thus, the task is only made ready to run if the task was not suspended.

(6) The task is placed in the ready list when the time expired.

(7) At this point, OSTimeDlyResume() calls the scheduler to see if the resumed task has a higher priority than the current task. This would result in a context switch.

INT32U  OSTimeGet (void)
{
#if OS_CRITICAL_METHOD == 3  
    OS_CPU_SR  cpu_sr;
#endif    
    INT32U     ticks;
 
 
    OS_ENTER_CRITICAL();
    ticks = OSTime;
    OS_EXIT_CRITICAL();
    return (ticks);
}
 
void  OSTimeSet (INT32U ticks)
{
#if OS_CRITICAL_METHOD == 3 
    OS_CPU_SR  cpu_sr;
#endif    
 
 
    OS_ENTER_CRITICAL();
    OSTime = ticks;
    OS_EXIT_CRITICAL();
}