wozenmehui.c

嵌入式系统（研）任务的调用实验

/*本系统实现以下功能：
1. Task1：管理Task。负责系统启动时同步系统中其他Task 的启动同步，利用信号量的semFlush()完成。同时接收各Task 的告警信息，告警信息需编号以logmsg 方式输出。本task 负责系统结束时的Task 删除处理。
2. Task2：console 命令行接收Task。接收并分析console 发来的命令行及参数。自行设置5 种以上命令，并根据命令的内容向Task3 发送激励消息。同时实现系统退出命令，使系统采用适当方式安全退出。收到非法命令向Task1 告警。
3. Task3：console 输出Task。接收需打印输出的字串消息（命令），输出到console。
收到长度为0 或超常字串向Task1 告警。
4.在原来要求的基础上，添加了一个数组，作为操作对象，供task2操作用，开始数组每一位都为0，task2主要对数组进行增加一个数在数组队尾，删除一个数在队首，删除数组，这里删除的意思就是把原来的数变为0，还有查找一个数。
而系统需要输入命令：0，1，2，3，4，5
0：表示要退出系统
1：表示要打印操作对象数组
2：表示要交换数组前两位
3：表示要删除数组首位
4：表示要反转整个数组
5：表示清空数组，慎用
其余命令将告警*/

#include "vxWorks.h"
#include "stdio.h"
#include "stdlib.h"
#include "semLib.h"
#include "taskLib.h"
#include "msgQLib.h"
#include "logLib.h"


int tidt1;int tidt2;int tidt3;/*定义taskID*/
SEM_ID semsyn1=NULL;/*定义同步信号量*/
MSG_Q_ID t1msq; MSG_Q_ID t2msq; MSG_Q_ID t3msq; /*分别作为task1 2 3的消息队列ID*/

int to_op_on[10];/*用于操作附加功能(*^__^*) */

STATUS progstart(void); /*用于初始化的函数，用于创建信号量，消息队列，任务*/
STATUS task1(void); /*任务一*/
STATUS task2(void); /*任务二*/
STATUS task3(void); /*任务三*/
    
   int i=0; int f=0;int m=0; int j=0; int k=0;int o=0;/*用于循环做变量*/
   int flag=0;/*用于标识消息队列一是否为空，0 表示空*/
   int aa;/*接受命令的字符*/
   char msgBuf1[10];/*用于缓存接受的告警信息*/
  
   char msgBuf3[30];/*接受消息队列3传来的信息，最大30*/
/*下面将对函数和任务进行实现*/
STATUS progstart(void) /*用于初始化的函数，用于创建信号量，消息队列，任务*/
{
    t1msq = msgQCreate(1,30,MSG_Q_PRIORITY);/*定义消息队列最大容量1，最长消息30个字符。这里定义长度为一是因为想实时输出task2传给task3的命令*/
    t2msq = msgQCreate(1,30,MSG_Q_PRIORITY);
    t3msq = msgQCreate(1,30,MSG_Q_PRIORITY);
    
    /*信号量创建，性质都是先进先出，赋值不可用*/
    semsyn1 = semBCreate(SEM_Q_FIFO,SEM_EMPTY);/*信号量1用来控制task2 3同步启动*/
    

    /*以下创建的任务，优先权逐渐降低，堆栈大小2000*/
    tidt1 = taskSpawn("ttask1",240,0,2000,(FUNCPTR)task1,0,0,0,0,0,0,0,0,0,0); /*task1*/ 
    tidt2 = taskSpawn("ttask2",220,0,2000,(FUNCPTR)task2,0,0,0,0,0,0,0,0,0,0); /*task2*/ 
    tidt3 = taskSpawn("ttask3",200,0,2000,(FUNCPTR)task3,0,0,0,0,0,0,0,0,0,0); /*task3*/ 
    /*以下将用于操作的数组初始化每个元素都为0 */   
    for(;i<10;i=i+1){ to_op_on[i]=i;}
    
    return OK;
}

STATUS task1(void) /*task1主要功能：负责同步启动task2 3，同时接受
                   来自task2 3的告警信息，并以logmsg方式输出，且
                   在系统结束时负责删除任务*/
{
   
   
   FOREVER
    {    semFlush(semsyn1);/*同步信号量可用，使task2 3同步启动*/
         memset(msgBuf1,0,10);/*每位都设为0*/
       
        if(flag!=0)
           { if(msgQReceive(t1msq,msgBuf1,10,WAIT_FOREVER)==ERROR) {return ERROR;}
              
               else
	 	   {  
			   if(!strcmp(msgBuf1,"exit"))/*如果收到的告警信息中含有e是通知系统要结束，删除task和消息队列*/
			   {   
                             taskDelete(tidt2);
                             taskDelete(tidt3);
                             msgQDelete(t1msq);  
                             msgQDelete(t2msq); 
                             msgQDelete(t3msq); 
                             taskDelete(tidt1);
               
				exit(0);
			    } 
                            else
			   { logMsg(msgBuf1,0,0,0,0,0,0);printf("\n");}
                           flag=flag-1;
                   }
        }
    }
     return OK;
}

STATUS task2(void) /*task2主要功能：负责从console接受命令行和参数，并给据命令向task3发送激励，
                    并能根据接受信息处理目标数组，有退出系统功能，非法命令向task1告警*/ 
{
    

    FOREVER
    {
         semTake(semsyn1,WAIT_FOREVER);/*接受同步启动信号量，启动*/
       
         printf("please enter command:\n");
         scanf("%d",&aa);
                
               if(aa==0) 
               {
                   /*退出*/
                         
                          if(msgQSend(t1msq,"exit",10,WAIT_FOREVER,
                                MSG_PRI_NORMAL)==ERROR)/*发送命令给task1,执行退出命令*/
                             { return ERROR;}
                             
			  else {flag=flag+1;}
                             
                }         
                 
                else if(aa==1)     /*打印数组*/
                          {if(msgQSend(t3msq,"print all number",30,WAIT_FOREVER,
                                     MSG_PRI_NORMAL)==ERROR) {return ERROR;}/*发送命令给task3*/
                             
                          }
                else if(aa==2)     /*交换前两位*/
                          { if(msgQSend(t3msq,"convet first two",30,WAIT_FOREVER,
                                     MSG_PRI_NORMAL)==ERROR) {return ERROR;}/*发送命令给task3*/
                         
                          }
                else if(aa==3)    /*删除首位*/
                          {if(msgQSend(t3msq,"delete first number",30,WAIT_FOREVER,
                                     MSG_PRI_NORMAL)==ERROR) {return ERROR;}/*发送命令给task3*/
                         
                          }
		else if(aa==4)    /*倒转数组*/
		         {if(msgQSend(t3msq,"convert all",30,WAIT_FOREVER,
                                     MSG_PRI_NORMAL)==ERROR) {return ERROR;}/*发送命令给task3*/
                         
		         }
   	        else if(aa==5)   /*清空数组*/  
			{ if(msgQSend(t3msq,"clear it",30,WAIT_FOREVER,
                                     MSG_PRI_NORMAL)==ERROR) {return ERROR;}/*发送命令给task3*/
                         
			}
                else if(aa<0||aa>5)           /*warn*/
                      {           
                         if(msgQSend(t1msq,"2 warn",10,WAIT_FOREVER,
                                     MSG_PRI_NORMAL)==ERROR) {return ERROR;}/*发送警告给task1*/
                          else flag=flag+1;
                       }
           
         }
               return OK;
                         
}

STATUS task3(void)/*接受task2传来的命令，并且输出到console。长度异常时向task1告警*/
{
    

    FOREVER
    {   semTake(semsyn1,WAIT_FOREVER);/*接受同步启动信号量，启动*/
        memset(msgBuf3,0,30);/*每位都设为0*/
       
        
        if(msgQReceive(t3msq,msgBuf3,30,WAIT_FOREVER)==ERROR)
            {return ERROR;}
        
	else if(0>sizeof(msgBuf3)||30<sizeof(msgBuf3)) /*长度异常时向task1告警*/
        {
           if(msgQSend(t1msq,"3 warn",10,WAIT_FOREVER,
                       MSG_PRI_NORMAL)==ERROR) {return ERROR;}/*发送警告给task1*/
		   else {flag=flag+1;}
        }
        else {printf(msgBuf3);printf("\n");}
/**************************具体功能*********************/
     
	   if(strcmp(msgBuf3,"print all number")==0)
	   {
		   for(f=0;f<10;f=f+1)
			   printf("%d",to_op_on[f]);
                     printf("\n");
	   }
	  
	  else
		  if(strcmp(msgBuf3,"convet first two")==0)
		  {
		   m=to_op_on[0];
                   to_op_on[0]=to_op_on[1];
                   to_op_on[1]=m;
		  }

          else 
		  if(strcmp(msgBuf3,"delete first number")==0)
		  {
		   for(j=0;j<9;j=j+1)
               to_op_on[j]=to_op_on[j+1];
		   to_op_on[9]=0;
		  }

	  else
		  if(strcmp(msgBuf3,"convert all")==0)
		  {
		   
		   for(o=0,k=9;o<5;o=o+1,k=k-1)
                   {
			   m=to_op_on[o];
			   to_op_on[o]=to_op_on[k];
			   to_op_on[k]=m;
		   }
		  }
	
                   
	   
     }   
      return OK;
}