This will roughly work. The method with watchdogs also works most of the time.
If timing is critical then both of these approaches can suffer from drift and
even missed events. If the system clock is fast in the following example then
it may slip a tick now and then. The watchdog method also relies on getting
processing time in task level to allow the watchdog to be reset. The clock
tick may also not be suitable for achieving your timing accurately, there are
methods to deal with this too (basically you keep a list of delay times that
averages out or you work out the nearest number of ticks each time).

Try this:-

SEM_ID taskReleaseSem;

void myTimedFunc(void)
{
    semGive(taskReleaseSem);

void myTaskFunc(int tickParameter) // The clock tick passes a constant
{
    for(;;) // Pick your favorite forever method
    {
        // Wait for the semaphore to be given
        semTake(taskReleaseSem);
        // Your periodic stuff
    }

void initTimedFunc(void)
{
    // Create a semaphore to release the timed task
    taskReleaseSem = semBCreate(SEM_Q_PRIORITY,SEM_EMPTY);

    // Set the aux xloxk to the desired rate
    sysAuxClkRateSet(20);

    // Spawn the task that does the work
    taskSpawn(
         "timed",           /* name of new task (stored at pStackBase) */
         100,                /* priority of new task */
         0,                    /* task option word */
         4096,               /* size (bytes) of stack needed plus name */
         myTaskFunc,   /* entry point of new task */
         0,                    /* 1st of 10 req'd task args to pass to func */
         0, 0, 0, 0, 0, 0, 0, 0, 0
         )

    // Now connect the timer function to the aux clock
    sysAuxClkConnect(myTimedFunc,0);
    // And switch it on
    sysAuxClkEnable();

Now when the aux clock interrupt goes off the task is released, the timer is
free running so you don't depend on the sysClk rate or getting some time at
task level (not sure that's a fair criticism of the WD method but it is tied
to the sysClkRate, this is not).

HTH,
Paul

taskSpawn options are:-

     VX_FP_TASK (0x0008)
          execute with floating-point coprocessor support.

     VX_PRIVATE_ENV (0x0080)
          include private environment support (see envLib).

     VX_NO_STACK_FILL (0x0100)
          do not fill the stack for use by checkStack( ).

     VX_UNBREAKABLE (0x0002)
          do not allow breakpoint debugging.

In article <39668b38.19865...@news.swbell.net>, snaph...@southwesternbell.net