vxWorksの2値信号量の例

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



SEM_ID semId; 
LOCAL SEM_ID semId1;            /* semaphore id of binary semaphore 1 */
LOCAL SEM_ID semId2;            /* semaphore id of binary semaphore 2 */


LOCAL BOOL notDone;                /* flag to indicate completion */
LOCAL STATUS taskA ();
LOCAL STATUS taskB ();


// 
STATUS TestBSem()
{
    notDone = TRUE;
 
    /* semaphore semId1 is availble  after creation*/
    if ((semId1 = semBCreate (SEM_Q_PRIORITY, SEM_FULL)) == NULL)
    {
        perror ("synchronizeDemo: Error in creating semId1 semaphore");
        return (ERROR);
    }

    /* semaphore semId2 is not available  after creation*/
    if ((semId2 = semBCreate (SEM_Q_PRIORITY, SEM_EMPTY)) == NULL)
    {
        perror ("synchronizeDemo: Error in creating semId2 semaphore");
        return (ERROR);
    }

    /* Spwan taskA*/
    if (taskSpawn ("tTaskA", 98, 0, 5000, (FUNCPTR) taskA, 0,
                    0, 0, 0, 0, 0, 0, 0, 0, 0) == ERROR)
    {
        perror ("synchronizeDemo: Error in spawning taskA");
        return (ERROR);
    }

    /* Spwan taskB*/
    if (taskSpawn ("tTaskB", 98, 0, 5000, (FUNCPTR) taskB, 0,
                   0, 0, 0, 0, 0, 0, 0, 0, 0) == ERROR)
    {
        perror ("synchronizeDemo: Error in spawning taskB");
        return (ERROR);
    }
    
    /* Polling is not recommended. But used for simple demonstration purpose */
    while (notDone) 
    {
        taskDelay (sysClkRateGet());  /* wait here until done */
    }
	
	
    /* Delete the created semaphores */
    if (semDelete (semId1) == ERROR)
    {
        perror ("syncronizeDemo: Error in deleting semId1 semaphore");
        return (ERROR);
    }
    if (semDelete (semId2) == ERROR)
    {
       perror ("syncronizeDemo: Error in deleting semId1 semaphore");
       return (ERROR);
    }
    printf ("

 synchronizeDemo now completed 
");
    
    return (OK);
}

/*****************************************************************************
 *  taskA - executes event A first and wakes up taskB to excute event B next
 *          using binary semaphores for synchronization.
 *
 *  RETURNS: OK or ERROR
 *
 */

LOCAL STATUS taskA ()
{
    int count;

    for (count = 0; count < 3; count++)
    {
        if (semTake (semId1, WAIT_FOREVER) == ERROR)
        {
            perror ("taskA: Error in semTake");
            return (ERROR);
        } 
        printf ("taskA: Started first by taking the semId1 semaphore - %d times
",
                (count + 1));
        printf("This is task  <%s> : Event A now done
", taskName(taskIdSelf()));
        printf("taskA: I'm done, taskB can now proceed; Releasing semId2 semaphore

");
        if (semGive (semId2) == ERROR)
        {
            perror ("taskA: Error in semGive");
            return (ERROR);
        }
    }
    return (OK);
}


/*****************************************************************************
 *  taskB - executes event B first and wakes up taskA to excute event A next
 *          using binary semaphores for synchronization.
 *
 *  RETURNS: OK or ERROR
 *
 */
LOCAL STATUS taskB()
    {
    int count;

    for (count = 0; count < 3; count++)
    {
        if (semTake (semId2,WAIT_FOREVER) == ERROR)
        {
            perror ("taskB: Error in semTake");
            return (ERROR);
        } 
        printf ("taskB: Synchronized with taskA's release of semId2 - %d times
",
                (count + 1 ));
        printf("This is task  <%s> : Event B now done
", taskName (taskIdSelf()));
        printf("taskB: I'm done, taskA can now proceed; Releasing semId1 semaphore


");
        if (semGive (semId1) == ERROR)
        {
            perror ("taskB: Error in semGive");
            return (ERROR);
        }
    }
    notDone = FALSE;
    return (OK);
}