vxWorks的计数信号量和看门狗定时器联合使用的示例

#include "vxWorks.h"
#include "wdLib.h"
#include "stdio.h"
#include "semLib.h"
#include "taskLib.h"
#include "usrLib.h"
#include "sysLib.h"

/* defines */

#define TASK_WORK_TIME				2   /* 2 ticks */
#define NUM_OF_GIVES				3

/* globals */

LOCAL SEM_ID semId = NULL;		/* counting or binary semaphore ID */
LOCAL WDOG_ID wdId = NULL;              /* watchdog ID */
LOCAL int syncTaskTid = 0;              /* tid of syncTask */
LOCAL int numToGive = NUM_OF_GIVES;     /* Number of times semGive is called */

/* forward declaratiuon */
void syncISR(int);                      /* ISR to unblock syncTask */
void cleanUp ();                        /* cleanup routine */
void syncTask ();                       /* task that needs to be synchronized
* with external events */

/*****************************************************************************
* countingSemDemo - demonstrates task synchronization using counting
* semaphores. User can also select to use binary semaphore instead of
* counting semaphore in this demonstration, for comparision between the two
* semaphores.
*
*  RETURNS: OK or ERROR
*
*/

STATUS TestCSem (char semType
/* counting semaphore type 'c' or binary semaphore
* type 'b'
*/
)
{
switch (semType)
{
case 'c':
case 'C':
if ((semId = semCCreate (SEM_Q_PRIORITY, 0)) == NULL)
{
perror ("semCCreate");
return (ERROR);
}
break;

case 'b':
case 'B':
if ((semId = semBCreate(SEM_Q_PRIORITY, SEM_EMPTY)) == NULL)
{
perror ("semBCreate");
return (ERROR);
}
break;

default:
printf ("Unknown semType -- must be 'c' or 'b'\n");
return (ERROR);
}

if ((wdId = wdCreate()) == NULL)
{
perror ("wdCreate");
cleanUp ();
return (ERROR);
}

if ((syncTaskTid = taskSpawn ("tsyncTask", 101, 0,5000,(FUNCPTR) syncTask, 0,0,0,0,0,0,0,0,0,0)) == ERROR)
{
perror ("taskSpawn");
cleanUp();
return (ERROR);
}

/* watchdog simulates hardware interrupts */
if (wdStart (wdId, 1, (FUNCPTR) syncISR, numToGive)
== ERROR)
{
perror ("wdStart");
cleanUp ();
return (ERROR);
}

/* arbitrary delay to allow program to complete before clean up */
taskDelay (sysClkRateGet()  + ((TASK_WORK_TIME + 2) * numToGive));

cleanUp();
return (OK);
}

/*****************************************************************************
*  syncTask - synchronizes with interrupts using counting or binary
*             semaphores.
*/

void syncTask (void)
{
int eventCount = 0;

FOREVER
{
if (semTake (semId, WAIT_FOREVER) == ERROR)
{
perror ("syncTask semTake");
return;
}

/* Do "work" */
taskDelay (TASK_WORK_TIME);
semShow (semId, 1);

eventCount++;
printf ("semaphore taken %d times\n", eventCount);
}

}

/*****************************************************************************
* syncISR - simulates a hardware device which generates interrupts very
*           quickly and synchronizes with syncTask using semaphores.
*/
void syncISR(int times)
{
semGive (semId);
times--;

//看门狗定时器需要递归调用
if (times > 0)
{
wdStart (wdId, 1, (FUNCPTR) syncISR, times);
}
}

/*****************************************************************************
* cleanUP - deletes the syncTask, deletes the semaphore and the watchdog timer
*           previously created by countingSemDemo.
*/
void cleanUp ()
{
if (syncTaskTid)
taskDelete (syncTaskTid);
if (semId)
semDelete (semId);
if (wdId)
wdDelete (wdId);

}