xpembeddemo.cpp

一个基于tornado开发环境的多任务的嵌入式仿真程序

/*include  */
#include <vxWorks.h>
#include <stdio.h>
#include <stdlib.h>
#include <semLib.h>
#include <taskLib.h>
#include <sysLib.h>
#include <msgQLib.h>
#include <errnoLib.h>
#include <sigLib.h>
#include <string.h>

/*   */
#define MAX_MSG		64		/* max number of messages in queue */
#define MSG_SIZE	64	/* size of message */
#define DELAY		100		/* 100 ticks */
#define STACK_SIZE  16384
static char TASK1_START_TEXT[MSG_SIZE] = "\nTask1 Start";
static char TASK2_START_TEXT[MSG_SIZE] = "\nTask2 Start";
static char TASK3_START_TEXT[MSG_SIZE] = "\nTask3 Start";
static char TASK4_START_TEXT[MSG_SIZE] = "\nTask4 Start";
static char TASK5_START_TEXT[MSG_SIZE] = "\nTask5 Start";
static char MSG_TASK1_WORKING[MSG_SIZE] = "\nTask1 is working";
static char MSG_TASK2_WORKING[MSG_SIZE] = "\nTask2 is working";
static char MSG_TASK3_WORKING[MSG_SIZE] = "\nTask3 is working";
static char MSG_TASK4_WORKING[MSG_SIZE] = "\nTask4 is working";
static char MSG_TASK5_WORKING[MSG_SIZE] = "\nTask5 is working";
static char TASK3_MSGQCRT_TEXT[MSG_SIZE] = "\nTask3 msgQCreate Error";
static char TASK4_MSGQCRT_TEXT[MSG_SIZE] = "\nTask4 msgQCreate Error";
static char TASK5_MSGQCRT_TEXT[MSG_SIZE] = "\nTask5 msgQCreate Error";
static char TASK3_TO_TASK4_TEXT[MSG_SIZE] = "\nTask3 send a message to Task4:I send a message";
static char TASK4_TO_TASK3_TEXT[MSG_SIZE] = "\nTask4 reply a message to Task3:I receive the message";
static char TASK2_TO_TASK3_TEXT[MSG_SIZE] = "\nTask3 start send message to Task4";
static char TASK2_TO_TASK4_TEXT[MSG_SIZE] = "\nTask4 start receive message from Task3";


/* globals*/
static int NO_REVEIVE = 0;
SEM_ID  semId;
MSG_Q_ID  msgQId1;
MSG_Q_ID  msgQId3;
MSG_Q_ID  msgQId4;
MSG_Q_ID  msgQId5; 
int  tidTask1;
int  tidTask2;
int  tidTask3;
int  tidTask4;
int  tidTask5;
int  flag = 1;


/* forward declarations */
STATUS progStart(void);
STATUS Task1(void);
void Task1Init(void);
STATUS Task2(void);
void Task2Init(void);
STATUS Task3(void);
STATUS Task3Hander(void);
void Task3Init(void);
STATUS Task4(void);
STATUS Task4Hander(void);
void Task4Init(void);
STATUS Task5(void);
void Task5Init(void);
STATUS progStop(void);
STATUS txSignal(void);

/**********************************************************
*
*   progStart
*/

STATUS progStart(void)
{
   semId = semBCreate(SEM_Q_FIFO, SEM_EMPTY);
   if(semId==NULL)
   {
      printf("semBCreate error");
	  return ERROR;
   }
   tidTask1 = taskSpawn("task1",240,0,STACK_SIZE,(FUNCPTR)Task1,
                        0,0,0,0,0,0,0,0,0,0);
   if(tidTask1 == ERROR)
   {
      printf("\nTask1 Start Error");
      return ERROR;
   }
   printf("the programm start\n");
   return OK;
}
/**********************************************************
*
*    Task1
*/

STATUS Task1(void)
{
   if(flag == 1)
   {
      int TaskCount=0;
      Task1Init();				
      char newMsg[MSG_SIZE];
     
      msgQId1 = msgQCreate(MAX_MSG,MSG_SIZE,MSG_Q_FIFO);
      msgQId3 = msgQCreate(MAX_MSG,MSG_SIZE,MSG_Q_FIFO);
      msgQId4 = msgQCreate(MAX_MSG,MSG_SIZE,MSG_Q_FIFO);
      msgQId5 = msgQCreate(MAX_MSG,MSG_SIZE,MSG_Q_FIFO);
      if(msgQId1==NULL||msgQId3==NULL||msgQId4==NULL||msgQId5==NULL)
      {
         printf("\nTask msgQCreate Error");
         return ERROR;
      }
      if(msgQSend(msgQId1,TASK1_START_TEXT, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL)==ERROR)
      {
         printf("\nTask1 SendMsg to MsgQueue1 Error\n");
         return ERROR;
      }
      tidTask2 = taskSpawn("task2",220,0,STACK_SIZE,(FUNCPTR)Task2,
                        0,0,0,0,0,0,0,0,0,0);
      tidTask3 = taskSpawn("task3",220,0,STACK_SIZE,(FUNCPTR)Task3,
                        0,0,0,0,0,0,0,0,0,0);
      tidTask4 = taskSpawn("task4",220,0,STACK_SIZE,(FUNCPTR)Task4,
                        0,0,0,0,0,0,0,0,0,0);
      tidTask5 = taskSpawn("task5",200,0,STACK_SIZE,(FUNCPTR)Task5,
                        0,0,0,0,0,0,0,0,0,0);
      if(tidTask2==ERROR||tidTask3==ERROR||tidTask4==ERROR||tidTask5==ERROR)
      {
         printf("\nTask1 Initiate Other Task Error");
         return ERROR;
      } 
      
      printf("\n************************************************************");/*start output*/
      
      while(1)
      {
         if(msgQReceive(msgQId1,(char *) newMsg,MSG_SIZE,WAIT_FOREVER)==ERROR)
         {
            printf("\nTask1 RecMsg from MsgQueue1 Error");
            return ERROR;
         }
         if(!strcmp(newMsg,TASK1_START_TEXT)||
            !strcmp(newMsg,TASK2_START_TEXT)||
            !strcmp(newMsg,TASK3_START_TEXT)||
            !strcmp(newMsg,TASK4_START_TEXT)||
            !strcmp(newMsg,TASK5_START_TEXT))
         {
            if(msgQSend(msgQId5,newMsg, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
            {
               printf("\nTask1 SendMsg to MsgQueue5 Error");
               return ERROR;
            }
            if(++TaskCount == 5)
            {
               
               semFlush(semId);
               if(msgQSend(msgQId5,MSG_TASK1_WORKING, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
               {
                  printf("\nTask1 SendMsg to MsgQueue5 Error");
                  return ERROR;
               }
               printf("*************Start send and receive message!***************\n");
            }
         }
      }
   }
   else if(flag ==0)
   {
      taskDelete(tidTask2);
      taskDelete(tidTask3);
      taskDelete(tidTask4);
      taskDelete(tidTask5);
      msgQDelete(msgQId1);
      msgQDelete(msgQId3);
      msgQDelete(msgQId4);
      msgQDelete(msgQId5);
   }
   return OK;
}

/**********************************************************
*
*     Task1Init
*/

void Task1Init(void)
{
   printf("\nInitial Task1");
   return;
}

/**********************************************************
*
*     Task2
*/

STATUS Task2(void)
{
   Task2Init();
   if(msgQSend(msgQId1,TASK2_START_TEXT, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
   {
      printf("\nTask2 SendMsg to msgQueue1 Error");
      return ERROR;
   }
   semTake(semId, WAIT_FOREVER);
   if(msgQSend(msgQId5,MSG_TASK2_WORKING, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
   {
      printf("\nTask2 SendMsg to msgQueue5 Error");
      return ERROR;
   }
   while(1)
   {
   
      if(msgQSend(msgQId3,TASK2_TO_TASK3_TEXT, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
      { 
         printf("\nTask2 SendMsg to msgQueue3 Error");
         return ERROR;
      }
      if(msgQSend(msgQId4,TASK2_TO_TASK4_TEXT, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
      { 
         printf("\nTask2 SendMsg to msgQueue4 Error");
         return ERROR;
      }
      taskDelay(60);
   }
   return OK;
}

/**********************************************************
*
*     Task2Init
*/

void Task2Init(void)
{
   printf("\nInitial Task2");
   return;
}



/**********************************************************
*
*     Task3
*/

STATUS Task3(void)
{
   Task3Init();
   
   if(msgQSend(msgQId1,TASK3_START_TEXT, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
   {
      printf("\nTask3 SendMsg to msgQueue1 Error");
      return ERROR;
   }
   semTake(semId,WAIT_FOREVER);
   if(msgQSend(msgQId5,MSG_TASK3_WORKING, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
   {
      printf("\nTask3 SendMsg to msgQueue5 Error");
      return ERROR;
   }
   while(1)
   { 
      Task3Hander();
   }
   return OK;
}

/*********************************************************
*
*     Task3SignalHander
*/

STATUS Task3Hander(void)
{
   char newMsg[MSG_SIZE];
   if(msgQReceive(msgQId3,newMsg,MSG_SIZE,WAIT_FOREVER)==ERROR)
   {
      printf("\nTask3 RecMsg from msgQueue3 Error");
      return ERROR;
   }
   if(!strcmp(newMsg,TASK2_TO_TASK3_TEXT))
   {
      if(msgQSend(msgQId5,TASK2_TO_TASK3_TEXT, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
      {
         printf("\nTask3 SendMsg to msgQueue5 Error");
	 return ERROR;
      }
      if(msgQSend(msgQId4,TASK3_TO_TASK4_TEXT, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
      {
         printf("\nTask3 SendMsg to msgQueue4 Error");
	 return ERROR;
      }
   }
   else if(!strcmp(newMsg,TASK4_TO_TASK3_TEXT))
   {
      if(msgQSend(msgQId5,TASK4_TO_TASK3_TEXT, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
      {
         printf("\nTask3 SendMsg to msgQueue5 Error");
	 return ERROR;
      }
   }
   return OK;
   
}
   

/*********************************************************
*
*    Task3Init
*/

void Task3Init(void)
{
   printf("\nInitial Task3");
   return;
}

/*********************************************************
*
*    Task4
*/

STATUS Task4(void)
{   
   Task4Init();
   if(msgQSend(msgQId1,TASK4_START_TEXT, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
   {
      printf("Task4 SendMsg to msgQueue1 Error");
      return ERROR;
   }
   semTake(semId,WAIT_FOREVER);
   if(msgQSend(msgQId5,MSG_TASK4_WORKING, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
   {
      printf("Task4 SendMsg to msgQueue5 Error");
      return ERROR;
   }
   while(1)
   { 
      Task4Hander();
   }
   return OK;
}

/*********************************************************
*
*    Task4SignalHander 
*/

STATUS Task4Hander(void) 
{
   char newMsg[MSG_SIZE];
   char newMsg2[MSG_SIZE];
   if(msgQReceive(msgQId4,newMsg,MSG_SIZE,WAIT_FOREVER)==ERROR)
   {
      printf("\nTask4 RecMsg from msgQueue4 Error");
      return ERROR;
   }
   if(!strcmp(newMsg,TASK2_TO_TASK4_TEXT))
   { 
      if(msgQSend(msgQId5,TASK2_TO_TASK4_TEXT, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
      {
         printf("\nTask4 SendMsg to msgQueue5 Error");
	 return ERROR;
      }
     
   }
   else if(!strcmp(newMsg,TASK3_TO_TASK4_TEXT))
   {
      if(msgQSend(msgQId3,TASK4_TO_TASK3_TEXT, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
      {
         printf("\nTask3 SendMsg to msgQueue4 Error");
	 return ERROR;
      }
      if(msgQSend(msgQId5,TASK3_TO_TASK4_TEXT, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
      {
         printf("\nTask3 SendMsg to msgQueue5 Error");
	 return ERROR;
      }
   }
   return OK;
}
   
 

/*********************************************************
*
*    Task4Init
*/

void Task4Init(void)
{
   printf("\nInitial Task4");
   return;
}

/*********************************************************
*
*    Task5
*/

STATUS Task5(void)
{
   char newMsg[MSG_SIZE];
   Task5Init();
   if(msgQSend(msgQId1,TASK5_START_TEXT, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
   {
      printf("Task5 SendMsg to msgQueue1 Error");
      return ERROR;
   }
   semTake(semId,WAIT_FOREVER);
   if(msgQSend(msgQId5,MSG_TASK5_WORKING, MSG_SIZE, WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
   {
      printf("Task5 SendMsg to msgQueue5 Error");
      return ERROR;
   }
   while(1)
   {
      if(msgQReceive(msgQId5,newMsg,MSG_SIZE,WAIT_FOREVER)==ERROR)
      {
	 printf("\nTask5 RecMsg from msgQueue5 Error");
	 return ERROR;
      }
	  printf("%s/n",newMsg);
   }
   return OK;
}

/*********************************************************
*
*    Task5Init
*/

void Task5Init(void)
{
   printf("\nInitial Task5");
   return;
}


   

/*********************************************************
*
*    progStop
*/

STATUS progStop(void)
{
   flag = 0;
   Task1();
   taskDelete(tidTask1);
   semDelete(semId);
   printf("Goodbye!\n");
   return OK;
}