hw1.c

Tornado下的多任务间通信（五个task）！

#include "vxworks.h"
#include "stdio.h"
#include "stdlib.h"
#include "semlib.h"
#include "tasklib.h"
#include "msgQLib.h"
#include"string.h"


/*宏定义*/
#define DELAY_TICKS 100/*间隔时间*/
#define STACK_SIZE 20000/*分配给每个任务的堆栈大小*/
#define MAX_MSGS (20)/*消息队列长度（最大消息个数）*/
#define MAX_MSG_LEN (200)/*消息队列中消息的最大长度*/


/*全局变量*/
int tidtask1;/*任务ID定义*/
int tidtask2;
int tidtask3;
int tidtask4;
int tidtask5;
SEM_ID syncSemID;/*定义信号量ID,用于task1对其他task的semFlush动作*/
SEM_ID task33SemID;/*定义信号量ID,用于task2对task3、4的激励*/
SEM_ID task44SemID;
SEM_ID task4SemID;
SEM_ID task1SemID;
MSG_Q_ID task1MsgQID;/*定义各个task的消息队列*/
MSG_Q_ID task2MsgQID;
MSG_Q_ID task3MsgQID;
MSG_Q_ID task4MsgQID;
MSG_Q_ID task5MsgQID;
int allowkill=0;
int task5allow=0;
/*函数声明*/
STATUS progStart(void);
STATUS task1(void);
STATUS task2(void);
STATUS task3(void);
STATUS task4(void);
STATUS task5(void);
void progStop(void);


/*
progStart 启动程序


负责创建信号量，消息队列，任务
*/

STATUS progStart(void)
{allowkill=0;
task5allow=0;
 syncSemID=semBCreate(SEM_Q_FIFO, SEM_EMPTY);
 task33SemID=semBCreate(SEM_Q_FIFO, SEM_EMPTY);
task44SemID=semBCreate(SEM_Q_FIFO, SEM_EMPTY);

 task4SemID=semBCreate(SEM_Q_FIFO, SEM_EMPTY);
task1SemID=semBCreate(SEM_Q_FIFO, SEM_EMPTY);
 
task1MsgQID=msgQCreate(MAX_MSGS,MAX_MSG_LEN,MSG_Q_PRIORITY);
 
if(task1MsgQID==NULL)
{
return(ERROR);
}
task2MsgQID=msgQCreate(MAX_MSGS,MAX_MSG_LEN,MSG_Q_PRIORITY);
if(task2MsgQID==NULL)
{
return(ERROR);
}
task3MsgQID=msgQCreate(MAX_MSGS,MAX_MSG_LEN,MSG_Q_PRIORITY);
if(task3MsgQID==NULL)
{
return(ERROR);
}
task4MsgQID=msgQCreate(MAX_MSGS,MAX_MSG_LEN,MSG_Q_PRIORITY);
if(task4MsgQID==NULL)
{
return(ERROR);
}
task5MsgQID=msgQCreate(MAX_MSGS,MAX_MSG_LEN,MSG_Q_PRIORITY);
if(task5MsgQID==NULL)
{
return(ERROR);
}

 tidtask1= taskSpawn ("ttask1", 255, 0, STACK_SIZE,
        (FUNCPTR) task1,0,0,0,0,0,0,0,0,0,0);
 tidtask2= taskSpawn ("ttask2", 230, 0, STACK_SIZE,
        (FUNCPTR) task2,0,0,0,0,0,0,0,0,0,0);
 tidtask3= taskSpawn ("ttask3", 220, 0, STACK_SIZE,
        (FUNCPTR) task3,0,0,0,0,0,0,0,0,0,0);
tidtask4= taskSpawn ("ttask4", 210, 0, STACK_SIZE,
        (FUNCPTR) task4,0,0,0,0,0,0,0,0,0,0);
 tidtask5= taskSpawn ("ttask5", 200, 0, STACK_SIZE,
        (FUNCPTR) task5,0,0,0,0,0,0,0,0,0,0);

}

STATUS task1(void)
        {
int task1n=0;
int task1nn=0;
char b[]="task1 is running";
char bb[]="task1 will be pend because of waiting for ERROR and 255!!!";
int t1tot5;
     
char* msgBuf;
t1tot5=(int*)b;
logMsg("\nFlush every tasks!!!\n");
            msgBuf=(char *)malloc(20);
/*if(msgQSend(task5MsgQID,bb,sizeof(bb),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
{
return(ERROR);
} */
semFlush (syncSemID);
       FOREVER
         {  
if(msgQSend(task5MsgQID,b,sizeof(b),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
{
return(ERROR);
}
if(msgQSend(task5MsgQID,bb,sizeof(bb),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
{
return(ERROR);
} 
       


if(msgQReceive(task1MsgQID,msgBuf,20,WAIT_FOREVER)==ERROR)
               {
          return(ERROR);
               }
else
{
        logMsg("\n%s\n",msgBuf);
allowkill=1;
}


        if(allowkill==1)
        { 
msgQDelete(task1MsgQID);
          taskDelete (tidtask2);
msgQDelete(task2MsgQID);
          taskDelete (tidtask3);
msgQDelete(task3MsgQID);
          taskDelete (tidtask4);
msgQDelete(task4MsgQID);
         /*taskDelete (tidtask5);*/
/*杀不了task5是因为消息队列在task5被杀之前就先被杀了，这样task5在用到这个消息队列时就会出错，导致task5不能被杀！*/
task5allow=1;
/*logMsg("\n\n\n\n\n\ntask5allow is %d\n\n\n\n\n",task5allow);*/
taskDelete (tidtask1);
         }
/*logMsg("\ntry myself!!!\n");*/
/*semTake (task1SemID, WAIT_FOREVER);*/
          }
 return(OK);
         }
 




STATUS task2(void)
{int t2tot3;
int t2tot4;
int t2num=0;
int t2tot5;
char t2br[]="task2 is running!!!";
char t2b[]="I(task2) send a spur to task3!!  This is ";
char t2bb[]="I(task2) send a spur to task4!!  This is ";

char t2cp1[100];
char t2cp2[100];
char t2sdnum[]="1";

semTake (syncSemID, WAIT_FOREVER);
         FOREVER
            {

int t2temp;
t2num=t2num+1;
strcpy(t2cp1,t2b);
strcpy(t2cp2,t2bb);
t2temp=48+t2num;
t2sdnum[0]=(t2temp);
strcat(t2cp1,t2sdnum);
strcat(t2cp2,t2sdnum);
t2tot3=(int*)t2cp1;
t2tot4=(int*)t2cp2;

if(msgQSend(task5MsgQID,t2br,sizeof(t2br),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
{
msgQSend(task1MsgQID,"error from 2",sizeof("error from 2"),NO_WAIT,MSG_PRI_NORMAL);
				return ERROR;
}
/*taskResume(tidtask5);*/
/*taskPrioritySet(tidtask5,195);*/
/*taskPrioritySet(tidtask5,250);*/

if(msgQSend(task3MsgQID,&t2tot3,sizeof(t2tot3),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
{
msgQSend(task1MsgQID,"error from 2",sizeof("error from 2"),NO_WAIT,MSG_PRI_NORMAL);
				return ERROR;
}

if(msgQSend(task4MsgQID,&t2tot4,sizeof(t2tot3),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
{
msgQSend(task1MsgQID,"error from 2",sizeof("error from 2"),NO_WAIT,MSG_PRI_NORMAL);
				return ERROR;
}
/*logMsg("\n\n\n\n\n%s\n\n\n\n",t2tot3);*/

if(msgQSend(task5MsgQID,"task2 ready because of task3!!",sizeof("task2 ready because of task3!!"),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
{
msgQSend(task1MsgQID,"error from 2",sizeof("error from 2"),NO_WAIT,MSG_PRI_NORMAL);
				return ERROR;
}
/*taskResume(tidtask5);*/
/*taskPrioritySet(tidtask5,195);*/
/*taskPrioritySet(tidtask5,250);*/


semGive (task33SemID);
if(msgQSend(task5MsgQID,"task2 ready because of task4!!",sizeof("task2 ready because of task4!!"),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
{
msgQSend(task1MsgQID,"error from 2",sizeof("error from 2"),NO_WAIT,MSG_PRI_NORMAL);
				return ERROR;
}
/*taskResume(tidtask5);*/
/*taskPrioritySet(tidtask5,195);*/
/*taskPrioritySet(tidtask5,250);*/

semGive (task44SemID);

if(msgQSend(task5MsgQID,"task2 delay now!!!",sizeof("task2 delay now!!!"),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
{
msgQSend(task1MsgQID,"error from 2",sizeof("error from 2"),NO_WAIT,MSG_PRI_NORMAL);
				return ERROR;
}
/*taskResume(tidtask5);*/
/*taskPrioritySet(tidtask5,195);*/
/*taskPrioritySet(tidtask5,250);*/
taskDelay (DELAY_TICKS);
              }
return(OK);
}




STATUS task3(void)
{
int t3tot4;
int t3n=1;
int t3nn;
int* t3msgBuf;
char t3b[]="I(task3) send a msg to task4 after receiving a spur from task2! This is ";

char t3cp[100];
char t3sdnum[]="1";
int t3num=0;

t3nn=t3n;

t3msgBuf=(int *)malloc(4); 
semTake (syncSemID, WAIT_FOREVER);
 FOREVER
{
int t3temp;
if(msgQSend(task5MsgQID,"task3 pend now!!!",sizeof("task3 pend now!!!"),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
{
msgQSend(task1MsgQID,"error from 3",sizeof("error from 3"),NO_WAIT,MSG_PRI_NORMAL);
				return ERROR;
}
/*taskResume(tidtask5);*/
/*taskPrioritySet(tidtask5,195);*/
/*taskPrioritySet(tidtask5,250);*/

semTake (task33SemID, WAIT_FOREVER);
t3num=t3num+1;
strcpy(t3cp,t3b);
t3temp=48+t3num;
t3sdnum[0]=t3temp;
strcat(t3cp,t3sdnum);

t3tot4=(int*)t3cp;
/*semTake (task33SemID, WAIT_FOREVER);*/

if(msgQSend(task5MsgQID,"task3 is running!!!",sizeof("task3 is running!!!"),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
{
msgQSend(task1MsgQID,"error from 3",sizeof("error from 3"),NO_WAIT,MSG_PRI_NORMAL);
				return ERROR;
}
/*taskResume(tidtask5);*/
/*taskPrioritySet(tidtask5,195);*/
/*taskPrioritySet(tidtask5,250);*/

if(msgQNumMsgs(task3MsgQID)==0)
{
if(t3n==t3nn)
{
logMsg("\ntask3 have not Receive a msg!!!\n");
t3n++;
}
}
else
{int t3cs=1;
int t3Num=msgQNumMsgs(task3MsgQID);
for(;t3cs<=t3Num;t3cs++)
{if(msgQReceive(task3MsgQID,t3msgBuf,MAX_MSG_LEN,WAIT_FOREVER)==ERROR)
               {
msgQSend(task1MsgQID,"error from 3",sizeof("error from 3"),NO_WAIT,MSG_PRI_NORMAL);
				return ERROR;
}
logMsg("\n%s\n",*t3msgBuf);
}
t3n=t3nn-1;
}
if(msgQSend(task4MsgQID,&t3tot4,sizeof(t3tot4),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
{
msgQSend(task1MsgQID,"error from 3",sizeof("error from 3"),NO_WAIT,MSG_PRI_NORMAL);
				return ERROR;
}
/*logMsg("\n\n\n\n\n%s\n\n\n\n",t3tot4);*/
if(msgQSend(task5MsgQID,"task3 ready because of task4!!",sizeof("task2 ready because of task4!!"),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
{
msgQSend(task1MsgQID,"error from 3",sizeof("error from 3"),NO_WAIT,MSG_PRI_NORMAL);
				return ERROR;
}
/*taskResume(tidtask5);*/
/*taskPrioritySet(tidtask5,195);*/

/*taskPrioritySet(tidtask5,250);*/

semGive (task4SemID);
}
return(OK);
}


STATUS task4(void)
{
int t4tot3;
int t4n=1;
int t4nn;
int* t4msgBuf;
char t4b[]="I(task4) reply a msg to task3 after receiving a msg from task3!!!  This is ";

int t4num=0;
char t4cp[100];
char t4sdnum[]="1";

t4nn=t4n;
t4msgBuf=(int *)malloc(4); 
semTake (syncSemID, WAIT_FOREVER);
FOREVER
{int t4temp;

semTake (task4SemID, WAIT_FOREVER);
semTake (task44SemID, WAIT_FOREVER);
if(msgQSend(task5MsgQID,"task4 is running!!!",sizeof("task4 is running!!!"),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
{
msgQSend(task1MsgQID,"error from 4",sizeof("error from 4"),NO_WAIT,MSG_PRI_NORMAL);
				return ERROR;
}
/*taskResume(tidtask5);*/
/*taskPrioritySet(tidtask5,195);*/
/*taskPrioritySet(tidtask5,250);*/

t4num=t4num+1;
strcpy(t4cp,t4b);
t4sdnum[0]=(48+t4num);
strcat(t4cp,t4sdnum);
t4tot3=(int*)t4cp;
if(msgQNumMsgs(task4MsgQID)==0)
{
if(t4n==t4nn)
{
logMsg("\ntask4 have not Receive any msg!!!\n");
t4n++;
}
}
else
{int t4cs=1;
int t4Num=msgQNumMsgs(task4MsgQID);
for(;t4cs<=t4Num;t4cs++)
{if(msgQReceive(task4MsgQID,t4msgBuf,MAX_MSG_LEN,WAIT_FOREVER)==ERROR)
               {
msgQSend(task1MsgQID,"error from 4",sizeof("error from 4"),NO_WAIT,MSG_PRI_NORMAL);
				return ERROR;
}
logMsg("\n%s\n",*t4msgBuf);
}
t4n=t4nn-1;
}
if(msgQSend(task3MsgQID,&t4tot3,sizeof(t4tot3),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
{
msgQSend(task1MsgQID,"error from 4",sizeof("error from 4"),NO_WAIT,MSG_PRI_NORMAL);
				return ERROR;
}

if(msgQSend(task5MsgQID,"task4  pend now !!!",sizeof("task4  pend now !!!"),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
{
msgQSend(task1MsgQID,"error from 4",sizeof("error from 4"),NO_WAIT,MSG_PRI_NORMAL);
				return ERROR;
}
/*taskResume(tidtask5);*/
/*taskPrioritySet(tidtask5,195);*/
/*taskPrioritySet(tidtask5,250);*/

}
return(OK);
}


STATUS task5(void)
{
int t5n=1;
int t5nn;
char* t5msgBuf;
t5nn=t5n;

t5msgBuf=(char*)malloc(MAX_MSG_LEN); 
semTake (syncSemID, WAIT_FOREVER);
FOREVER
{/*logFdSet(4);*/


if(msgQReceive(task5MsgQID,t5msgBuf,MAX_MSG_LEN,WAIT_FOREVER)==ERROR)
               {
msgQSend(task1MsgQID,"error from 5",sizeof("error from 5"),NO_WAIT,MSG_PRI_NORMAL);
				return ERROR;
}
/*if(task5allow==1)
{
taskDelete (tidtask5);
msgQDelete(task5MsgQID);
}*/
logMsg("\n%s\n",t5msgBuf);
/*logFdSet(3);*/




/*taskPrioritySet(tidtask5,250);*/
if(task5allow==1)
{
semDelete (task1SemID);
semDelete (syncSemID);
semDelete (task33SemID);
semDelete (task44SemID);
semDelete (task4SemID);
msgQDelete(task5MsgQID);
taskDelete (tidtask5);
/*msgQDelete(task5MsgQID);*/
}
}
return(OK);
}


void progStop(void)
{
semGive (task1SemID);
allowkill=1;

taskPrioritySet(tidtask1,190);
msgQSend(task1MsgQID,"stop",sizeof("stop"),NO_WAIT,MSG_PRI_NORMAL);
			
/*taskDelete (tidtask5);*/
/*杀不了task5是因为消息队列在task5被杀之前就先被杀了，这样task5在用到这个消息队列时就会出错，导致task5不能被杀！*/
/*semDelete (task1SemID);
semDelete (syncSemID);
semDelete (task33SemID);
semDelete (task44SemID);
semDelete (task4SemID);*/
/*msgQDelete(task1MsgQID);*/
/*msgQDelete(task2MsgQID);
msgQDelete(task3MsgQID);
msgQDelete(task4MsgQID);*/
/*msgQDelete(task5MsgQID);*/
logMsg("BYE!TSCHUESS!ADIEU!\n");
    return;
}
/*
SEM_ID syncSemID;
SEM_ID task3SemID;
SEM_ID task4SemID;
MSG_Q_ID task1MsgQID;
MSG_Q_ID task2MsgQID;
MSG_Q_ID task3MsgQID;
MSG_Q_ID task4MsgQID;
MSG_Q_ID task5MsgQID;
int allowkill=0;
*/