signal.c

一个信号量传递的例子

#include "signal.h"

/**********************************
*progStart - create task and signal
*rerurn   :                      
***********************************/

STATUS progStart(void)
{
  syncSemId     = semBCreate(SEM_Q_FIFO,SEM_EMPTY);
  dataSemId     = semBCreate(SEM_Q_FIFO,SEM_EMPTY);
  nodeListGuardSemId = semMCreate (SEM_Q_PRIORITY
                                   | SEM_INVERSION_SAFE
                                   | SEM_DELETE_SAFE);

  pCurrNode = NULL;

  tidCosmos = taskSpawn("tCosmos", 200, 0, STACK_SIZE,
                         (FUNCPTR)cosmos, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
  tidSchlep = taskSpawn("tSchlep", 220, 0, STACK_SIZE,
                         (FUNCPTR)schlep, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
  tidCrunch = taskSpawn("tCrunch", 240, 0, STACK_SIZE, 
                         (FUNCPTR)crunch, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 );
  tidMonitor= taskSpawn("tMonitor", 250, 0, STACK_SIZE,
                         (FUNCPTR)monitor, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
  return OK ;
}

/**********************************
* cosmos  - simulate receive data
* return  0411-84748200 
***********************************/
void cosmos (void)
{
  while(1)
  {
     cosmicData = rand();
     semGive(dataSemId);
     printf("cosmicData :%d \n",(int)cosmicData);
     taskDelay(DELAY_TICKS);
  }
  
  return;
}

/************************************
* nodeAdd - restor data
*return
*************************************/

void nodeAdd(int data)
{
  LIST_NODE *node;
  
  if((node = (LIST_NODE *)malloc(sizeof(LIST_NODE))) !=NULL)
  {
    node->data = data;
   
    semTake(nodeListGuardSemId, WAIT_FOREVER);
    node->pNextNode = pCurrNode;
    pCurrNode = node;
    semGive(nodeListGuardSemId);

  }
  else
  {
    printf("nodeAdd :out of menory.\n");
    taskSuspend(0);
  }
 
  return; 
}
 
/*************************************
*schlep - 
*return
**************************************/
void schlep (void)
{
  int i;
  FOREVER
  {
    for(i=0;i< NUM_SAMPLE;i++)
    {
       semTake(dataSemId, WAIT_FOREVER);
       nodeAdd(cosmicData);
    }
   semGive(syncSemId);
  }
 return;
}

/***************************************
*nodeScrap - deletnode
*return:
****************************************/

void nodeScrap (void)
{
  LIST_NODE *pTmpNode;
  
  semTake(nodeListGuardSemId,WAIT_FOREVER);
  if (pCurrNode != NULL)
  {
    pTmpNode = pCurrNode;
    pCurrNode = pCurrNode->pNextNode;
    free(pTmpNode);
  }  
  semGive(nodeListGuardSemId);
  
 
  return;
}

/****************************************
*crunch - deal with data
*return:
*****************************************/
void crunch(void)
{
  int sampleSum;
  FOREVER 
  {
    sampleSum = 0;
    semTake(syncSemId, WAIT_FOREVER);
    
    semTake(nodeListGuardSemId, WAIT_FOREVER);
    
    while (pCurrNode != NULL)
    {
       sampleSum += pCurrNode->data;
       nodeScrap();
    }
    semGive (nodeListGuardSemId);
    result = sampleSum;
  }
  
  return ;
}

/*****************************************
*monitor - 
*return :
*******************************************/
void monitor(void)
{
   BOOL isHot = FALSE;
   BOOL average = 0;
  
   average = RAND_MAX *NUM_SAMPLE/2;
   printf("average : %d\n", (int)average);
   FOREVER
   {
      if((!isHot)&&(result>=average))
      {
          isHot = TRUE;
          printf("HOT\n");

      }
      else if(isHot && (result< average)) 
      {
          isHot = FALSE;
          printf("COOL\n");
      } 
   }
  return;
}

/*******************************************
*progStop - 
*return - 
*********************************************/
void progStop(void)
{
   result = semTake(nodeListGuardSemId, WAIT_FOREVER);
   if (result == OK)
   {
      taskDelete(tidCosmos);
      taskDelete(tidSchlep);
      taskDelete(tidCrunch);
      taskDelete(tidMonitor);

      while (pCurrNode != NULL)
      {
          nodeScrap();
      }     
   }
   semDelete(dataSemId);
   semDelete(syncSemId);
   semDelete(nodeListGuardSemId);
   printf("END!\n");
   return;
}