UCOS-II学习计划（2）

骑猪看日落 2022-05-30 11:59 105阅读 0赞

第二周

学习任务：

1. 熟练掌握ucos-ii的任务同步与通信机制：信号量、消息邮箱、消息队列

2. 了解ucos-ii的中断与时钟机制

参考：

嵌入式实时操作系统μCOS-II原理及应用 任哲编著

STM32F407 UCOS开发手册 正点原子

嵌入式实时操作系统uc/os-ii(第二版) 邵贝贝著

实验任务：

1.自己设计实验对共享资源的互斥访问；

思路：可创建一个开始函数，高、中、低三级优先级函数

高：闪烁LED0，有信号量，以进入先延时

中：闪烁LED1，无信号量

低：有信号量，长时间占用信号量不释放

结果：中运行—低运行—高等待—中运行—...—高运行

如何避免上述优先级反转现象——互斥信号量

1. 定义全局互斥信号量

2. start函数中创建一个互斥信号量及高、中、低任务

3. 高、中请求互斥信号量，中级任务不变，低的同样改成互斥的

结果：中运行—低运行—高等待（等很久）（与不用互斥的差别）—高运行

注：时间延时长短很重要

new\_task.c

#include "new_task.h"
    #include "bsp_gpio.h"
    #include "trace.h"
    
    
    OS_EVENT *Mutexp;   //互斥信号量定义
    INT8U err; 
    
    void init_new_task(void)
    {
    	INT8U  err1;
    	INT8U  err2;
    	INT8U  err3;
    
    	Mutexp = OSMutexCreate(1, &err);        //创建互斥信号量，第一个参数表示优先级，第一个参数不能与其他任务优先级相同，且要至少比这里创建的任务1的优先级高
    	
    	err1 = OSTaskCreateExt((void (*)(void *)) high_task,
                                (void 		 * ) 0,
                                (OS_STK		 * )&high_task_stk[HIGH_STK_SIZE-1],
                                (INT8U		   ) HIGH_TASK_PRIO,
                                (INT16U		   ) HIGH_TASK_PRIO,
                                (OS_STK		 * )&high_task_stk[0],
                                (INT32U		   ) HIGH_STK_SIZE,
                                (void 		 * ) 0,
                                (INT16U		   )(OS_TASK_OPT_STK_CLR | OS_TASK_OPT_STK_CHK));
        assert_param(OS_ERR_NONE == err1);
        OSTaskNameSet(HIGH_TASK_PRIO, (INT8U *)"high task", &err1);
    
    
        err2 = OSTaskCreateExt((void (*)(void *)) middle_task,
                                (void 		 * ) 0,
                                (OS_STK		 * )&middle_task_stk[MIDDLE_STK_SIZE-1],
                                (INT8U		   ) MIDDLE_TASK_PRIO,
                                (INT16U		   ) MIDDLE_TASK_PRIO,
                                (OS_STK		 * )&middle_task_stk[0],
                                (INT32U		   ) MIDDLE_STK_SIZE,
                                (void 		 * ) 0,
                                (INT16U		   )(OS_TASK_OPT_STK_CLR | OS_TASK_OPT_STK_CHK));
        assert_param(OS_ERR_NONE == err2);
        OSTaskNameSet(MIDDLE_TASK_PRIO, (INT8U *)"middle task", &err2);
    
    
        err3 = OSTaskCreateExt((void (*)(void *)) low_task,
                                (void 		 * ) 0,
                                (OS_STK		 * )&low_task_stk[LOW_STK_SIZE-1],
                                (INT8U		   ) LOW_TASK_PRIO,
                                (INT16U		   ) LOW_TASK_PRIO,
                                (OS_STK		 * )&low_task_stk[0],
                                (INT32U		   ) LOW_STK_SIZE,
                                (void 		 * ) 0,
                                (INT16U		   )(OS_TASK_OPT_STK_CLR | OS_TASK_OPT_STK_CHK));
        assert_param(OS_ERR_NONE == err3);
        OSTaskNameSet(LOW_TASK_PRIO, (INT8U *)"low task", &err3);
    
        
    }
    
    //优先级高的任务
    void high_task(void)
    { 
    	while(1)
    	{
    		OSTimeDlyHMSM(0, 0, 0, 200);
    		APP_TRACE("high task pending mutex\r\n");
    		OSMutexPend(Mutexp, 0, &err);              //等待一个互斥信号量，0表示一直等待
    		APP_TRACE("high task running!\r\n");     
    		led_trun_off(LED1);
    		OSMutexPost(Mutexp);              //发送一个互斥信号量
    		OSTimeDlyHMSM(0, 0, 0, 200);
    	}
    }
    
    
    void middle_task(void)
    { 
    	while(1)
    	{
    		APP_TRACE("middle task running!\r\n");
    		led_trun_off(LED2);
    		OSTimeDlyHMSM(0, 0, 0, 300);
    	}
    }
    
    
    void low_task(void)
    {
    	static u32 times;
    	while(1)
    	{		 
    		OSMutexPend(Mutexp, 0, &err);
    		APP_TRACE("low task running!\r\n");
    		for(times = 0; times < 20000000; times++)
    		{
    			OS_Sched();            //发起任务调度
    		}
    		OSMutexPost(Mutexp);  
    		OSTimeDlyHMSM(0, 0, 1, 0);
    	}
    }

2. 编写两个任务，task1用于接收PC通过can发送的指令，task1接收到指令后通过消息队列将指令发送给task2，task2接收到指令后控制步进电机的运行。

思路：两个任务、消息队列

task1用于接收 pc 通过 Can 发送的指令，且将指令通过消息队列发送给task2

task2接收到指令后控制步进电机的运行

我的开发板上，CAN1对应 PD0（RX）与 PD1（TX）

bsp\_can.h

#define CANn                        2
    
    #if defined(USE_OPEN_207V_BOARD) || defined(NO_RTOS_BOARD) || defined(USE_OPEN_207Z_MINI_BOARD) || defined(USE_OPEN_207Z_BOARD)
    
    //------------- CAN1 -------------
    #define CAN1_RX_PIN                 GPIO_Pin_0			//改了的
    #define CAN1_RX_PIN_SOURCE          GPIO_PinSource0     //改了的
    #define CAN1_TX_PIN                 GPIO_Pin_1			//改了的
    #define CAN1_TX_PIN_SOURCE          GPIO_PinSource1		//改了的
    #define CAN1_CLK                    RCC_APB1Periph_CAN1
    #define CAN1_GPIO_PORT              GPIOD   				//改了的
    #define CAN1_GPIO_CLK               RCC_AHB1Periph_GPIOD   //改了的

Motor.c

#include"stm32f2xx.h"
    #include"gpio.h"
    #include"pwm.h"
    #include"motor.h"
    
    void CTL_DIR(u8 DIR)
    {
    	switch(DIR)
    	{
    		case 0:    //0时设置为正向
    			GPIO_ResetBits(GPIOB, GPIO_Pin_9);
    			TIM10_PWM_Init(500);
    			break;
    		case 1:    //1时设置为反向
    			GPIO_SetBits(GPIOB, GPIO_Pin_9); 
    			TIM10_PWM_Init(500);
    			break;
    		default:
    			break;
    		
    	}
    }
    
    //电机开始转动函数
    void Start_Pwm(void)
    {
    	GPIO_SetBits(GPIOB, GPIO_Pin_9);
    	TIM10_PWM_Init(500);
    }
    
    //电机停止转动函数
    void Pause_Pwm(void)
    {
    	TIM_Cmd(TIM10, DISABLE);
    }

new\_task.c

#include "new_task.h"
    #include "bsp_gpio.h"
    #include "trace.h"
    #include "bsp_can.h"
    #include "kal_can.h"   //有can接收的相关函数
    #include "gpio.h"   //电机相关引脚
    #include "pwm.h"     //pwm波控制电机转动
    #include "motor.h"   //电机相关函数
    #include <string.h>
    
    #define CAN_QUEUE_MAX_NUM	 32          //消息队列的长度
    
    OS_EVENT *Can_Cmd_Queue;  				 //定义消息队列
    OS_EVENT *cmd_heat_q;
    
    //OS_EVENT *can_Recv_Data;    //不对，应该是一个结构体
    
    void *can_cmd_queue[CAN_QUEUE_MAX_NUM];   //定义消息的指针数组
    void *cmd_heat_queue[CAN_QUEUE_MAX_NUM];
    
    OS_MEM *Can_Cmd_Mem;      //定义内存分区指针
    INT8U can_cmd_buf[32][64];       //定义分区和内存块
    
    #define CAN_ID_MIN 0x1f411001
    #define CAN_ID_MAX 0x1f500000 
    
    //#define CAN_ID_MIN 0x10411001
    //#define CAN_ID_MAX 0x10500000 
    
    
    void init_new_task(void)
    {	
    	INT8U  err1;
    	INT8U  err2;
    	
    	init_can_kal_task();		  	//启动  接收 函数的任务函数
    	init_can_data_send_task();      //启动  发送 函数的任务函数
    	
    	//CAN_Config(USER_CAN_1);    //can1相关初始化及配置,init_can_recv_callback中有
    	GPIO9_Set_Init();          //PB9控制电机转动方向
    	GPIO12_Set_Init();			//PB12使能开关
    	GPIO_SetBits(GPIOB, GPIO_Pin_12);     //PB12使能开关    
    
    	err1 = OSTaskCreateExt((void (*)(void *)) Start_task1,
    								(void		 * ) 0,
    								(OS_STK 	 * )&TASK1[TASK1_STK_SIZE-1],
    								(INT8U		   ) TASK1_PRIO,
    								(INT16U 	   ) TASK1_PRIO,
    								(OS_STK 	 * )&TASK1[0],
    								(INT32U 	   ) TASK1_STK_SIZE,
    								(void		 * ) 0,
    								(INT16U 	   )(OS_TASK_OPT_STK_CLR | OS_TASK_OPT_STK_CHK));
    	assert_param(OS_ERR_NONE == err1);
    	OSTaskNameSet(TASK1_PRIO, (INT8U *)"task1", &err1);
    
    
    	err2 = OSTaskCreateExt((void (*)(void *)) Start_task2,
                                (void 		 * ) 0,
                                (OS_STK		 * )&TASK2[TASK2_STK_SIZE-1],
                                (INT8U		   ) TASK2_PRIO,
                                (INT16U		   ) TASK2_PRIO,
                                (OS_STK		 * )&TASK2[0],
                                (INT32U		   ) TASK2_STK_SIZE,
                                (void 		 * ) 0,
                                (INT16U		   )(OS_TASK_OPT_STK_CLR | OS_TASK_OPT_STK_CHK));
        assert_param(OS_ERR_NONE == err2);
        OSTaskNameSet(TASK2_PRIO, (INT8U *)"task2", &err2);
    	
    }
    
    void Start_task1(void)
    {	
    	INT8U err;
    	can_Recv_Data *can_recv_cmd = NULL;
    
    	//消息队列建立成功后，会返回一个指针，否则返回一个空指针，此指针用于以后对消息队列的操作
    	
    	Can_Cmd_Mem = OSMemCreate(can_cmd_buf, 32, 64, &err);      //内存分区
    	Can_Cmd_Queue = OSQCreate(&can_cmd_queue[0], CAN_QUEUE_MAX_NUM);       //创建消息队列   消息队列被初始化为空 
    	cmd_heat_q = OSQCreate(&cmd_heat_queue[0], CAN_QUEUE_MAX_NUM);          //Can_Cmd_Mem和cmd_heat_q?
    
    	init_can_recv_callback(USER_CAN_1, can_recv_callback);
    	
    	while(1)
    	{
    		
    		can_recv_cmd = (can_Recv_Data*)OSQPend(Can_Cmd_Queue,            //所请求的消息队列的指针
    											   0,
    											   &err);
       		err = OSQPost(cmd_heat_q,               //消息队列的指针
    					 (void*)can_recv_cmd);
    		
    		OSTimeDlyHMSM(0, 0, 2, 0);		
    	}	
    }
    
    
    u8 can_recv_callback(CanRxMsg* can_recv_data)             //回调函数
    {
    	INT8U m_err;
    	INT8U q_err;
    	int i = 0;
    	u32 can_id = 0;
    	can_Recv_Data *can_recv_buf = NULL;
    
    	if(can_recv_data)
    	{
    		switch(can_recv_data->IDE)
    		{
    			case CAN_Id_Standard:
    				can_id = can_recv_data->StdId;              //此时的can_id就是我们usb_can中的帧ID
    				APP_TRACE("can_id: %d\r\n", can_id);
    				break;
    			case CAN_Id_Extended:
    				can_id = can_recv_data->ExtId;
    				break;
    			default:
    				APP_TRACE("can_id error\r\n");
    				assert_param(0);
    				break;			
    		}
    	}
    	//if(can_id >= CAN_ID_MIN && can_id < CAN_ID_MAX)             //选特定区间的帧地址，为防止多外设情况
    	//{
    		can_recv_buf = (can_Recv_Data *)OSMemGet(Can_Cmd_Mem, &m_err);    //获取内存
    
    		memset(can_recv_buf, 0x00, sizeof(can_Recv_Data));        //将内存初始化
    
    		//获取数据并复制给内存
    		can_recv_buf->EXTID = can_id;
    		can_recv_buf->data_len = can_recv_data->DLC;    //长度
    		memcpy(can_recv_buf->p_data, can_recv_data->Data, can_recv_buf->data_len);   //数据
    
    		//发送消息
    		q_err = OSQPost(Can_Cmd_Queue, (void *)can_recv_buf);
    		assert_param(OS_ERR_NONE == q_err);	
    
    		can_send_data_packet(USER_CAN_1, EXTID, 0x12, 8, can_recv_data->Data);       //stm32发给USB_CAN，当USB_CAN发出数据,stm32接收数据做出的反馈
    		for(i = 0; i < 8; i++)                            //将接收的数据打印
    		{
    			APP_TRACE("data: %d\r\n", can_recv_data->Data[i]);
    		}
    		APP_TRACE("%d\r\n");
    	//}
    	//else
    	//{
    		m_err = OSMemPut(Can_Cmd_Mem, can_recv_buf);        //释放内存
    	//	APP_TRACE("error: unrecognized can id\r\n");
    	//}
    
    	return 0;
    }
    
    
    
    void Start_task2(void)
    {
    	//u8 *ss;
    	can_Recv_Data *ss;
    	INT8U err;
    	while(1)
    	{
    		//如果消息队列是空的，则调用本函数的任务被挂起，直到有别的任务通过消息队列发送了一则消息
    		ss = OSQPend(cmd_heat_q, 0, &err);    //用来等待接收task1发送的指令
    			
    		switch(*(ss->p_data))
    		{
    			case MOTOR_START:
    				Start_Pwm();
    				APP_TRACE("motor starting\r\n");
    				break;
    			case MOTOR_PAUSE:
    				Pause_Pwm();
    				APP_TRACE("motor stop\r\n");
    				break;
    			case MOTOR_FORWARD:
    				CTL_DIR(0);
    				APP_TRACE("motor cw\r\n");
    				break;
    			case MOTOR_INVERT:
    				CTL_DIR(1);
    				APP_TRACE("motor ccw\r\n");
    				break;
    			default:
    				led_trun_off(LED1);
    			 	break;
    		}
    		
    		OSTimeDlyHMSM(0, 0, 1, 0);
    	}	
    }