/* countingSemDemo.c - Demonstrates task synchronization using counting  *                     semaphores. *//* Copyright 1984-1997 Wind River Systems, Inc. *//*modification history--------------------01c,06nov97,mm  added copyright.01b,16sep97,ram included files stdio.h, taskLib.h, usrLib.h, sysLib.h		 Used the semShow() function to display info about		 the semaphore inplace of the show() function.01a,27mar94,ms   cleaned up for VxDemo*//* * DESCRIPTION * Counting semaphore example.  Using binary semaphores for task  * synchronization may, if the events can occur rapidly enough, cause  * a loss of data, i.e. an event can be missed if the events can occur * faster then a task can process them.  Using counting semaphores may * solve this problem. This program demonstrates task synchronization using * counting semaphores. User can also select to use a binary semaphore instead  * of a counting semaphore in this demonstration, for comparision between the   * two semaphores. * * RETURNS: OK or ERROR * * EXAMPLE * *  -> sp countingSemDemo, typeOfSemaphore * *  where typeOfSemaphore is the value of the type of semaphore to be used *  for task synchronization in this demonstration. For using counting  *  semaphores use a value 'c' or 'C' for typeOfSemaphore parameter and for  *  using binary semaphores use a value 'b' or 'B' for typeOfSemaphore  *  parameter.  * *  example: *  -> sp countingSemDemo, 'c' *  -> sp countingSemDemo, 'b' * *//* include files */#include "vxWorks.h"#include "wdLib.h"#include "stdio.h"#include "semLib.h"#include "taskLib.h"#include "usrLib.h"#include "sysLib.h"/* defines */#define TASK_PRIORITY				101#define TASK_STACK_SIZE				5000#define TIME_BETWEEN_INTERRUPTS		        1   /* 1 tick */#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 countingSemDemo     (    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", TASK_PRIORITY, 0,TASK_STACK_SIZE,(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, TIME_BETWEEN_INTERRUPTS, (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, TIME_BETWEEN_INTERRUPTS, (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);    }