test.c

陈向群老师主讲的嵌入式操作系统实验作业之经典生产者消费者程序

#if OS_TASK_STAT_EN > 0
    sprintf(s, "%3d", OSCPUUsage);                                 /* Display CPU usage in %               */
    PC_DispStr(36, 22, s, DISP_FGND_YELLOW + DISP_BGND_BLUE);
#endif

    sprintf(s, "%5d", OSCtxSwCtr);                                 /* Display #context switches per second */
    PC_DispStr(18, 23, s, DISP_FGND_YELLOW + DISP_BGND_BLUE);

    sprintf(s, "V%1d.%02d", OSVersion() / 100, OSVersion() % 100); /* Display uC/OS-II's version number    */
    PC_DispStr(75, 24, s, DISP_FGND_YELLOW + DISP_BGND_BLUE);

    switch (_8087) {                                               /* Display whether FPU present          */
        case 0:
             PC_DispStr(71, 22, " NO  FPU ", DISP_FGND_YELLOW + DISP_BGND_BLUE);
             break;

        case 1:
             PC_DispStr(71, 22, " 8087 FPU", DISP_FGND_YELLOW + DISP_BGND_BLUE);
             break;

        case 2:
             PC_DispStr(71, 22, "80287 FPU", DISP_FGND_YELLOW + DISP_BGND_BLUE);
             break;

        case 3:
             PC_DispStr(71, 22, "80387 FPU", DISP_FGND_YELLOW + DISP_BGND_BLUE);
             break;
    }
    
    for (i = 0; i < 10; i++) {
	//显示仓库状态
	if (buffer[i]){//显示仓库缓冲区状态0:无产品1:有产品
		sprintf(s, " buffer[%1d]: have ",i,OSTaskCtr);
	}else{
		sprintf(s, " buffer[%1d]: empty",i,OSTaskCtr);
	}
    	PC_DispStr(0, 3+i, s , DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
    	
    	//显示生产者状态
    	if (i<N_TASKS_PRODUCT){
    		switch (state_product[i]){
    			case 0://未生产
				sprintf(s, "product[%1d]: no product",i, OSTaskCtr);
			    	PC_DispStr(20, 3+i, s , DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
    				break;
    			case 1://生产中
				sprintf(s, "product[%1d]: producting",i, OSTaskCtr);
			    	PC_DispStr(20, 3+i, s , DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
    				break;
    			case 2://等待入库
				sprintf(s, "product[%1d]: wait inter",i, OSTaskCtr);
			    	PC_DispStr(20, 3+i, s , DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
    				break;
    			case 3://入库中
				sprintf(s, "product[%1d]: intering  ",i, OSTaskCtr);
			    	PC_DispStr(20, 3+i, s , DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
    				break;
    		}
    	}
    	
    	//显示消费者状态
    	if (i<N_TASKS_CONSUMER){
    		switch (state_consumer[i]){
    			case 0://未消费
				sprintf(s, "consumer[%1d]: no consume",i, OSTaskCtr);
			    	PC_DispStr(50, 3+i, s , DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
    				break;
    			case 1://等待消费
				sprintf(s, "consumer[%1d]: waiting   ",i, OSTaskCtr);
			    	PC_DispStr(50, 3+i, s , DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
    				break;
    			case 2://出库中
				sprintf(s, "consumer[%1d]: outing    ",i, OSTaskCtr);
			    	PC_DispStr(50, 3+i, s , DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
    				break;
    			case 3://消费中
				sprintf(s, "consumer[%1d]: consumeing",i, OSTaskCtr);
			    	PC_DispStr(50, 3+i, s , DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
    				break;
    		}
    	}
    	
    }
    
}

/*$PAGE*/
/*
*********************************************************************************************************
*                                             CREATE TASKS
*********************************************************************************************************
*/

//mod by jyt
//分别创建N_TASKS_PRODUCT个生产者和N_TASKS_CONSUMER个消费者
static  void  TaskStartCreateTasks (void)
{
    INT8U  i;

    p_product=0;
    p_consumer=0;

    for (i = 0; i < 10; i++) buffer[i]=0;                  /* 初始化仓库缓冲区                         */

    for (i = 0; i < N_TASKS_PRODUCT; i++) {                /* 创建N_TASKS_PRODUCT个同样的生产者任务    */
    	TaskData_PRODUCT[i]=i;                             /* 初始化生产者任务的参数                   */
    	state_product[i]=0;                                /* 初始化生产者任务的状态                   */
        OSTaskCreate(Task_product, (void *)&TaskData_PRODUCT[i], &TaskStk_PRODUCT[i][TASK_STK_SIZE - 1], i + 10);
    }
    
    for (i = 0; i < N_TASKS_CONSUMER; i++) {               /* 创建N_TASKS_CONSUMER个同样的消费者任务   */
    	TaskData_CONSUMER[i]=i;                            /* 初始化消费者任务的参数                   */
    	state_consumer[i]=0;                               /* 初始化消费者任务的状态                   */
        OSTaskCreate(Task_consumer, (void *)&TaskData_CONSUMER[i], &TaskStk_CONSUMER[i][TASK_STK_SIZE - 1], i + 10 + N_TASKS_PRODUCT);
    }
}

/*
*********************************************************************************************************
*                                                  TASKS
*********************************************************************************************************
*/

// mod by jyt
// 生产者任务
void  Task_product (void *pdata)
{
    INT8U  i;
    INT8U  err;

    for (;;) {
    	//生产中
    	state_product[(*(char *)pdata)]=1;       /* 设置生产中状态                                     */
    	OSTimeDly(random(10));                   /* 设定生产延时                                       */
    	//等待入库
    	state_product[(*(char *)pdata)]=2;       /* 设置等待入库状态                                   */
        OSSemPend(Sem_product, 0, &err);         /* 获取生产者信号量                                   */
        OSSemPend(Sem_buffer, 0, &err);          /* 获取仓库缓冲区信号量                               */
        //入库中
    	state_product[(*(char *)pdata)]=3;       /* 设置入库中状态                                     */
    	buffer[p_product++]=1;                   /* 根据当前生产指针入库                               */
    	p_product=p_product%10;                  /* 当前生产指针后移                                   */
    	
        OSSemPost(Sem_buffer);                   /* 释放仓库缓冲区信号量                               */
        OSSemPost(Sem_consumer);                 /* 释放消费者信号量                                   */
    	OSTimeDly(random(3));                    /* 设定入库延时                                       */
    	
    	state_product[(*(char *)pdata)]=0;       /* 设置未生产状态                                     */
    }
}

// mod by jyt
// 消费者任务
void  Task_consumer (void *pdata)
{
    INT8U  i;
    INT8U  err;

    for (;;) {
    	//等待中
    	state_consumer[(*(char *)pdata)]=1;       /* 设置等待中状态                                     */
        OSSemPend(Sem_consumer, 0, &err);         /* 获取消费者信号量                                   */
        OSSemPend(Sem_buffer, 0, &err);           /* 获取仓库缓冲区信号量                               */
        //出库中
    	state_consumer[(*(char *)pdata)]=2;       /* 设置出库中状态                                     */
    	buffer[p_consumer++]=0;                   /* 根据当前消费指针出库                               */
    	p_consumer=p_consumer%10;                 /* 当前消费指针后移                                   */
    	
        OSSemPost(Sem_buffer);                    /* 释放仓库缓冲区信号量                               */
        OSSemPost(Sem_product);                   /* 释放生产者信号量                                   */
    	OSTimeDly(random(3));                     /* 设定出库延时                                       */
    	
    	state_consumer[(*(char *)pdata)]=3;       /* 设置消费中状态                                     */
    	OSTimeDly(random(10));                    /* 设定消费中延时                                     */
        
    	state_consumer[(*(char *)pdata)]=0;       /* 设置未消费状态                                     */
    }
}