Chapter 5

Time Management

We saw in section 3.10 that µC/OS-II (as do other kernels) requires that you provide a periodic interrupt to keep track of time delays and timeouts. This periodic time source is called a Clock Tick and should occur between 10 and 100 times per second, or Hertz. The actual frequency of the clock tick depends on the desired tick resolution of your application. However, the higher the frequency of the ticker, the higher the overhead.

Section 3.10 discussed the tick ISR (Interrupt Service Routine) as well as the function that it needs to call to notify µC/OS-II about the tick interrupt, OSTimeTick(). This chapter will describe five services that deal with time

issues:

1)OSTimeDly(),

2)OSTimeDlyHMSM(),

3)OSTimeDlyResume(),

4)OSTimeGet() and,

5)OSTimeSet().

The functions described in this chapter are found in the file OS_TIME.C.

5.00 Delaying a task, OSTimeDly()

µC/OS-II provides a service that allows the calling task to delay itself for a user specified number of clock ticks. This function is called OSTimeDly(). Calling this function causes a context switch and forces µC/OS -II to execute the next highest priority task that is ready-to-run. The task calling OSTimeDly() will be made ready-to-run as soon as the time specified expires o r, if another task cancels the delay by calling OSTimeDlyResume(). You should note that this task will run only when it’s the highest priority task.

Listing 5.1 shows the code for OSTimeDly(). As can be seen, your application calls this function by supplying the number of ticks to delay and can be a value between 1 and 65535. If you specify a value of zero L5.1(1), you are

indicating that you don’t want to delay the task and thus the function will immediately return to the caller. A non zero value will cause OSTimeDly() to remove the current task from the ready list L5.1(2). Next, the number of ticks are

stored in the OS_TCB of the current task L5.1(3) where it will be decremented on every clock tick by OSTimeTick(). Finally, since the task is no longer ready, the scheduler is called L5.1(4) so that the next highest priority task that is ready-to-run gets executed.

void OSTimeDly (INT16U ticks)

{

seconds (S) and milliseconds (M) which is more ‘natural’. Like OSTimeDly(), calling this function causes a context switch and forces µC/OS-II to execute the next highest priority task that is ready-to-run. The task calling OSTimeDlyHMSM() will be made ready-to-run as soon as the time specified expires or if another task cancels the delay by calling OSTimeDlyResume() (see section 5.02). Again, this task will run only when it’s the highest priority task.

Listing 5.2 shows the code for OSTimeDlyHMSM(). As can be seen, your application calls this function by supplying the delay in hours, minutes, seconds and milliseconds. In practice, you should avoid delaying a

task for long periods of time because, it’s always a good idea to get some ‘feedback activity’from a task (incrementing counter, blinking an LED, etc.). If however, you do need long delays, µC/OS-II can delay a task for 256 hours (close to 11 days)!

OSTimeDlyHMSM() starts by checking that you have specified valid values for its arguments L5.2(1). As with OSTimeDly(), OSTimeDlyHMSM() exits if you specify no delay L5.2(9). Because µC/OS-II only knows about ticks, the t otal number of ticks is computed from the specified time L5.2(3). The code shown in listing 5.2 is obviously not very inefficient. I just showed the equation this way so you can see how the total ticks are computed. The actual code efficiently factors in OS_TICKS_PER_SEC. L5.2(3) determines the number of ticks given the specified milliseconds with rounding to the nearest tick. The value 500/OS_TICKS_PER_SECOND basically correspond to 0.5 tick converted to milliseconds. For example, if the tick rate (i.e. OS_TICKS_PER_SEC) is set to 100 Hz (10 mS) then a delay of 4 mS would result in no delay! A delay of 5 mS would result in a delay of 10 mS, etc.

µC/OS-II only supports delays of 65535 ticks. To support potentially long delays obtained by L5.2(2), OSTimeDlyHMSM() determines how many times we need to delay for more than 65535 ticks L5.2(4) as well as the remaining number of ticks L5.2(5). For example, if OS_TICKS_PER_SEC was 100 and you wanted a delay of 15 minutes then OSTimeDlyHMSM() would have to d elay for 15 * 60 * 100 or, 90000 ticks. This delay is broken down into two delays of 32768 ticks (because we can’t do a delay of 65536 ticks, only 65535) and one delay of 24464 ticks. In this case, we would first take care of the remainder L5.2(6) and then, the number of times we exceeded 65536 L5.2(7)-(8) (i.e. done with two 32768 tick delays).

INT8U OSTimeDlyHMSM (INT8U hours, INT8U minutes, INT8U seconds, INT16U milli)

{

INT32U ticks; INT16U loops;