UCOS-II学习计划（1）

拼搏现实的明天。 2022-05-30 11:57 120阅读 0赞

第一周

学习任务：

1. 熟悉207Base基础版本的使用：

(1) 207Base对不同开发板板以及芯片封装的配置，参考stm32f2xx\_conf.h文件；

(2) 207Base调试串口的修改与配置，参考stm32f2xx\_conf.h、bsp\_usart.c文件；

(3) 学会使用207Base版本中的TRACE、APP\_TRACE、DUMP\_DATA函数；

(4) 熟练掌握207Base版本中shell命令的编写，参考app\_shell.c文件。

2. 掌握ucos-ii任务

参考：

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

STM32F407 UCOS开发手册 正点原子

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

实验任务：

1. 在207Base基础版本上实现三个任务：

(1) task1实现LED闪烁，时间间隔为500ms，定时控制使用UCOS-II的延时函数实现；

(2) task2接收串口数据并解析，指令分别为A，B，C；

(3) task3根据task2中是串口指令控制PWM占空比，收到A指令PWM输出占空比10%，收到B指令PWM输出占空比输出20%，收到C指令PWM输出占空比50%。

思想：

pwm：原base中没有pwm，故我们需要自己创建，pwm（频率，占空比）

LED： -> Bsp\_gpio.h中，我的开发板上对应引脚 PD11、PD12， 改67行、190行

Usart3： \-> Bsp\_usart.c中，我的开发板上对应 PB10（TX）、PB11（RX），改86行

调用对应的初始化函数：Usart -> 273行      LED -> 216行（挂载AHB1）

多任务下，可以用创建的任务1来创建任务2和任务3，并且在任务1中实现 LED1 的闪烁，Bsp\_gpio.c 中286行用来打开LED1，用 OSTimeDlyHMsm（）实现延时，ms是函数最后一个空。

任务2用来接收串口数据并解析，指令为 A、B、C，触发中断，在中断服务函数中接收A、B、C指令并执行，在app\_shell.c中有串口3的中断服务函数。

结合任务调度、信号量、pending，将信号量的信号识别

BSRRH：置引脚为低电平

BSRRL：置引脚为高电平

代码实现：

Bsp\_gpio.c

#elif defined(USE_OPEN_207V_BOARD)
    
    #define LEDn                        2   //这里把4改成了2
    
    #define LED1_PIN                    GPIO_Pin_11     //LED1是PD11,LED2是PD12
    #define LED1_GPIO_PORT              GPIOD
    #define LED1_GPIO_CLK               RCC_AHB1Periph_GPIOD
    
    #define LED2_PIN                    GPIO_Pin_12
    #define LED2_GPIO_PORT              GPIOD
    #define LED2_GPIO_CLK               RCC_AHB1Periph_GPIOD

#elif defined(USE_OPEN_207V_BOARD)
    static GPIO_TypeDef* GPIO_PORT[LEDn] = {LED1_GPIO_PORT, LED2_GPIO_PORT};   //GPIOD
    static const uint16_t GPIO_PIN[LEDn] = {LED1_PIN, LED2_PIN};               //PD11,PD12

Bsp\_usart.c

/*#########################################
     *#                USART3                 #
     *#########################################*/
    
    #if defined(USE_OPEN_207V_BOARD) || defined(USE_ARM0_REV_0_1)
    /*
     * RX: PB11
     * TX: PB10
     */
    #define USART3_RX_GPIO_PORT          GPIOB
    #define USART3_RX_PIN                GPIO_Pin_11
    #define USART3_RX_SOURCE             GPIO_PinSource11
    #define USART3_RX_AF                 GPIO_AF_USART3
    #define USART3_RX_GPIO_CLK           RCC_AHB1Periph_GPIOB
    
    #define USART3_TX_GPIO_PORT          GPIOB
    #define USART3_TX_PIN                GPIO_Pin_10
    #define USART3_TX_SOURCE             GPIO_PinSource10
    #define USART3_TX_AF                 GPIO_AF_USART3
    #define USART3_TX_GPIO_CLK           RCC_AHB1Periph_GPIOB
    
    #define USART3_CLK                   RCC_APB1Periph_USART3

/********************************************************************************
     *                 HOW TO USE THIS DRIVER
     *
     * 1. init USART
     *    init_usart(COM1, 115200, 8, PARITY_NONE, USART_MODE_INT);
     * 2. If you want to use DMA feature you need to
     *    ...
     ********************************************************************************/
    
    
    /*
     * @brief: init usart
     * @param: COMx        which USART do you want to use
     * @param: baud_rate   USART baudrate
     * @param: word_length the number of data bits transmitted or received in a frame.
     * @param: parity      ODD or EVEN or NONE
     * @param: usart_mode  one byte interrupt or DMA mode
     * @return: 0 -- success
     *          1 -- fail
     */
    uint8_t init_usart(uart_num_def_t COMx, u32 baud_rate, u8 word_length, parity_mode parity, usart_mode_type usart_mode)
    {
    	USART_InitTypeDef USART_InitStructure;
    	GPIO_InitTypeDef  GPIO_InitStructure;
    	NVIC_InitTypeDef  NVIC_InitStructure;
    
    	// check com param
    	assert_param(IS_USART_COM_NUM(COMx));
    	assert_param(IS_USART_COM_PARITY(parity));
    	assert_param(word_length == 8 || word_length == 9);
    	assert_param(IS_USART_DMA_MODE(usart_mode));
    
    	// init usart param struct
    	USART_InitStructure.USART_BaudRate            = baud_rate;
    	USART_InitStructure.USART_StopBits            = USART_StopBits_1;
    	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    	USART_InitStructure.USART_Mode                = USART_Mode_Rx | USART_Mode_Tx;
    	switch (word_length)
    	{
    		case 8:
    			USART_InitStructure.USART_WordLength  = USART_WordLength_8b;
    			break;
    		case 9:
    			USART_InitStructure.USART_WordLength  = USART_WordLength_9b;
    			break;
    		default:
    			return 1;
    	}
    
    	switch (parity)
    	{
    		case PARITY_NONE:
    			USART_InitStructure.USART_Parity      = USART_Parity_No;
    			break;
    		case PARITY_EVEN:
    			USART_InitStructure.USART_Parity      = USART_Parity_Even;
    			break;
    		case PARITY_ODD:
    			USART_InitStructure.USART_Parity      = USART_Parity_Odd;
    			break;
    		default:
    			return 1;
    	}
    
    	USART_DeInit(USART_NUM[COMx]);
    
    	// USART1 and USART6 are mounted in APB2 BUS (60MHz)
    	// USART2 USART3 UART4 UART5 are mounted in APB1 BUS (30MHz)
    	switch (COMx)
    	{
    		case COM1:
    		case COM6:
    			RCC_APB2PeriphClockCmd(USART_CLK[COMx], ENABLE);
    			break;
    		case COM2:
    		case COM3:
    		case COM4:
    		case COM5:
    			RCC_APB1PeriphClockCmd(USART_CLK[COMx], ENABLE);
    			break;
    	}
    
    	// enable GPIO clock: RX and TX
    	RCC_AHB1PeriphClockCmd(USART_GPIO_CLK[0][COMx] | USART_GPIO_CLK[1][COMx], ENABLE);
    
    	// AF pin: RX and TX
    	GPIO_PinAFConfig(USART_PORT[0][COMx], USART_PIN_SOURCE[0][COMx], USART_AF[0][COMx]);
    	GPIO_PinAFConfig(USART_PORT[1][COMx], USART_PIN_SOURCE[1][COMx], USART_AF[1][COMx]);
    
    	// Configure USART RX and Tx as alternate function
    	GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
    	GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_UP; //GPIO_PuPd_NOPULL;
    	GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF;
    	GPIO_InitStructure.GPIO_Pin   = USART_PIN[0][COMx];
    	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    	GPIO_Init(USART_PORT[0][COMx], &GPIO_InitStructure);
    
    	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    	GPIO_InitStructure.GPIO_Pin = USART_PIN[1][COMx];
    	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    	GPIO_Init(USART_PORT[1][COMx], &GPIO_InitStructure);
    
    	/* USART configuration */
    	USART_Init(USART_NUM[COMx], &USART_InitStructure);
    
    	if (usart_mode == USART_MODE_INT)
    	{
    		USART_ITConfig(USART_NUM[COMx], USART_IT_RXNE, ENABLE);
    	}
    	else if (usart_mode == USART_MODE_DMA)
    	{
    		// USART IDLE interrupt
    		USART_ITConfig(USART_NUM[COMx], USART_IT_IDLE, ENABLE);
    	}
    
    	USART_ClearFlag(USART_NUM[COMx], USART_FLAG_TC);
    	/* Enable USART */
    	USART_Cmd(USART_NUM[COMx], ENABLE);
    
    	/* Enable the USARTx Interrupt */
    	NVIC_InitStructure.NVIC_IRQChannel                   = USART_IRQ[COMx];
    	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = USART_PRE_EMPTION[COMx];
    	NVIC_InitStructure.NVIC_IRQChannelSubPriority        = USART_SUB_LEVEL[COMx];
    	NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
    	NVIC_Init(&NVIC_InitStructure);
    
    	// init DMA feature
    	if (usart_mode == USART_MODE_DMA)
    	{
    		if (COMx == COM1 || COMx == COM6)
    		{
    			RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);
    		}
    		else
    		{
    			RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
    		}
    
    		init_usart_with_dma(COMx);
    	}
    
    	return 0;
    }

App\_led.c

#include "app_led.h"
    #include "bsp_gpio.h"
    
    
    static OS_STK led_task_stk[LED_TASK_STK_SIZE];
    
    static void led_task(void *p_arg);
    
    
    void init_led_task(void)
    {
        INT8U os_err;
    
        init_led_gpio(LED1);
    
    	/* LED task ************************************************************/
        os_err = OSTaskCreateExt((void (*)(void *)) led_task,
                                (void          * ) 0,
                                (OS_STK        * )&led_task_stk[LED_TASK_STK_SIZE - 1],
                                (INT8U           ) LED_TASK_PRIO,
                                (INT16U          ) LED_TASK_PRIO,
                                (OS_STK        * )&led_task_stk[0],
                                (INT32U          ) LED_TASK_STK_SIZE,
                                (void          * )0,
                                (INT16U          )(OS_TASK_OPT_STK_CLR | OS_TASK_OPT_STK_CHK));
        assert_param(OS_ERR_NONE == os_err);
        OSTaskNameSet(LED_TASK_PRIO, (INT8U *)"led", &os_err);
    }
    
    
    static void led_task(void *p_arg)
    {
        for (;;)
        {
            led_trun_on(LED1);
            OSTimeDlyHMSM(0, 0, 0, 50);
            led_trun_off(LED1);
            OSTimeDlyHMSM(0, 0, 0, 50);
        }
    }

pwm.c

#include"stm32f2xx.h"
    #include"pwm.h"
    
    void TIM4_PWM_Init(u32 frequency, u32 pulse)
    {
    	GPIO_InitTypeDef GPIO_InitStructure;
    	TIM_OCInitTypeDef TIM_OCInitStructure;
    	TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
    	
    	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);   //使能定时器4时钟
    	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);   //使能gpio时钟
    
    	GPIO_PinAFConfig(GPIOD, GPIO_PinSource12, GPIO_AF_TIM4);  //将GPIOD12复用为TIM4
    	
    	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
    	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //GPIO_OType_PP表示推挽方式输出，GPIO_OType_OD表示开漏
    	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    	GPIO_Init(GPIOD, &GPIO_InitStructure);
    	
    
    	//初始化TIM4  输出通道  初始化输出比较参数
    	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;    //模式1决定，当cnt<ccr1时，通道1为有效电平
    	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;  //输出使能
    	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;  //极性，有效电平是高电平还是低电平
    	TIM_OCInitStructure.TIM_Pulse = pulse;     //ccr1的值，决定占空比
    	TIM_OC1Init(TIM4, &TIM_OCInitStructure);
    
    	//初始化TIM4初始化 pwm模式
    	TIM_TimeBaseInitStructure.TIM_Period = frequency - 1;    //自动装载值，决定频率
    	TIM_TimeBaseInitStructure.TIM_Prescaler = 29;  //预分频系数
    	TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up; //计数器模式
    	TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;  //分频器系数
    	TIM_TimeBaseInit(TIM4, &TIM_TimeBaseInitStructure);
    	
        TIM_Cmd(TIM4, ENABLE);  //使能TIM14
    
    	TIM_OC1PreloadConfig(TIM4, TIM_OCPreload_Enable);  //使能输出比较预装载，使能tim14在ccr1上的预装载寄存器
    	TIM_ARRPreloadConfig(TIM4, ENABLE);    // 使能自动重装载的预装载寄存器的允许位， ARPE使能
    	
    }

main.c

#include "includes.h"
    #include "trace.h"
    #include "stm32f2xx_conf.h"
    #include "bsp_gpio.h"
    #include "bsp_usart.h"
    #include "pwm.h"
    
    #define A 01
    #define B 02
    #define C 03
    
    //1.宏定义，任务1
    #define TASK1_PRIO 9            //任务优先级
    #define TASK1_STK_SIZE 128      //任务堆栈大小
    //OS_TCB task1;                   //任务控制块儿，OS_TCB结构体
    OS_STK TASK1[TASK1_STK_SIZE];  //任务堆栈
    void Start_task1(void);
    
    //2.宏定义，任务2
    #define TASK2_PRIO 10            //任务优先级
    #define TASK2_STK_SIZE 128      //任务堆栈大小
    OS_STK TASK2[TASK2_STK_SIZE];  //任务堆栈
    void Start_task2(void);
    
    //3.宏定义，任务3
    #define TASK3_PRIO 11            //任务优先级
    #define TASK3_STK_SIZE 128      //任务堆栈大小
    OS_STK TASK3[TASK3_STK_SIZE];  //任务堆栈
    void Start_task3(void);
    
    uint16_t ch;
    OS_EVENT *My_sem;               //信号量定义
    
    int main(void)
    {
    	INT8U  os_err = 0;
    	init_led_gpio(LED1);    //初始化led灯1  不亮
    	init_led_gpio(LED2);     //只初始化，也亮
    
    	//init_trace();	    	//包含了串口初始化，不能放在此处?
    	//init_usart(COM3, 115200, 8, PARITY_NONE, USART_MODE_INT);
    	//My_sem = OSSemCreate(1);
        OSInit();              //初始化ucosII
        
        os_err = 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 == os_err);
        OSTaskNameSet(TASK1_PRIO, (INT8U *)"task1", &os_err);
        OSStart();             //开启ucosII
    
    	return 0;
    }
    
    //task1用来创建task2和task3，并闪烁led1
    void Start_task1(void)
    {
    	//创建TASK2任务
    	INT8U  os_err = 0;
    	INT8U  err = 0;
        bsp_init();   //时钟使能，必须要有，且这里不能放在main中
    
        OSStatInit();      //初始化空闲任务和统计任务
        
    	init_trace();
    
    	//OSSemCreate(INT16U cnt)    //创建信号量?
    	My_sem = OSSemCreate(1);     //参数表示计数值
        os_err = 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 == os_err);
        OSTaskNameSet(TASK2_PRIO, (INT8U *)"task2", &os_err);
    	
    	//创建TASK3任务
        err = OSTaskCreateExt((void (*)(void *)) Start_task3,
                                (void 		 * ) 0,
                                (OS_STK		 * )&TASK3[TASK3_STK_SIZE-1],
                                (INT8U		   ) TASK3_PRIO,
                                (INT16U		   ) TASK3_PRIO,
                                (OS_STK		 * )&TASK3[0],
                                (INT32U		   ) TASK3_STK_SIZE,
                                (void 		 * ) 0,
                                (INT16U		   )(OS_TASK_OPT_STK_CLR | OS_TASK_OPT_STK_CHK));
        assert_param(OS_ERR_NONE == err);
        OSTaskNameSet(TASK3_PRIO, (INT8U *)"task3", &err);
        //在任务1中实现led灯的闪烁
        while(1)
        {
        	led_trun_on(LED1);   //打开led灯1  右边灯
       		OSTimeDlyHMSM(0, 0, 0, 500);
       		led_trun_off(LED1);
        	OSTimeDlyHMSM(0, 0, 0, 500);
        }
       
    }
    
    //TASK2任务函数
    void Start_task2(void)
    {
    	INT8U  err;
    	while(1)
    	{
    		OSSemPend(My_sem, 0, &err);      //请求信号量
    		ch = USART_ReceiveData(USART3);
    		//OSTimeDlyHMSM(0, 0, 1, 0);  //若去掉，会影响任务3中灯
    		
    		if(ch == A)
    		{
    			APP_TRACE("recevied A success\r\n");
    		}
    		else if(ch == B)
    		{
    			APP_TRACE("recevied B success\r\n");
    		}
    		else if(ch == C)
    		{
    			APP_TRACE("recevied C success\r\n");
    		}
    		else
    		{
    			APP_TRACE("recevied error\r\n");
    		}
    		OSSemPost(My_sem);
    		OSTimeDlyHMSM(0, 0, 2, 0);
    	}
    
    }
    
    //TASK3任务函数
    void Start_task3(void)
    {
    	INT8U  err;
    	while(1)
    	{
    		OSSemPend(My_sem, 0, &err);      //请求信号量
    		if(ch == A)
    		{
    			TIM4_PWM_Init(500, 50);
    			APP_TRACE("pwm duty ratio is 10\r\n");
    		}
    		else if(ch == B)
    		{
    			TIM4_PWM_Init(500, 100);
    			APP_TRACE("pwm duty ratio is 20\r\n");
    		}
    		else if(ch == C)
    		{
    			TIM4_PWM_Init(500, 250);
    			APP_TRACE("pwm duty ratio is 50\r\n");
    		}
    		else
    		{
    			led_toggle(LED2);    //若接收指令有错，点亮led2，左边灯
    			APP_TRACE("pwm output error\r\n");
    			//OSTimeDlyHMSM(0, 0, 0, 500);
    		}
    		OSSemPost(My_sem);
    		OSTimeDlyHMSM(0, 0, 2, 0);
    	}
    }

2. 在207Base基础版本上编写一个shell命令，实现改变PWM占空比和频率，并练习207Base基础版本TRACE()、APP\_TRACE()、DUMP\_DATA(p\_data, len)三个函数的使用。

APP\_TRACE()：一般打印

DUMP\_DATA(p\_data, len)：数组打印

app\_shell.c

static CPU_INT16S ctrl_pwm_fre_duty( u32 argc,                          //pwm命令时执行
    										char**argv,
    										SHELL_OUT_FNCT pout_fnct,
    										SHELL_CMD_PARAM* pcmd_param)
    										
    {
    	
    	switch (argc)
    	{
    		case 1:
    			APP_TRACE("请输入pwm的频率及CCR值\r\n");                      
    			break;
    		case 2:
    			if((strcmp(argv[1], "0") == 0)||(strcmp(argv[1], "0") < 0))
    			//if((argv[1] < "0")|(&argv[1] == "0"))
    			{
    				APP_TRACE("请输入合适的频率值\r\n");
    			}
    			else if(strcmp(argv[1], "0") > 0)
    			{
    				APP_TRACE("频率为%s, 请输入pwm的CCR值\r\n", argv[1]);
    			}
    			else
    			{
    				return SHELL_EXEC_ERR;
    			}
    			break;
    		case 3:
    			if((strcmp(argv[2], "0") == 0)||(strcmp(argv[2], "0") < 0))
    			{
    				APP_TRACE("请输入合适的CCR值\r\n");
    			}
    			else if(strcmp(argv[2], "0") > 0)
    			{
    				APP_TRACE("频率为%s，CCR值为%s\r\n", argv[1], argv[2]);
    				TIM4_PWM_Init(atoi(argv[1]), atoi(argv[2]));           //是否正确?
    				APP_TRACE("占空比为%.2f%%\r\n", 100*(atof(argv[2]))/(atof(argv[1])));
    				
    				//APP_TRACE("1值为%d\r\n", atoi(argv[1]));     //对，字符串(int)强制转化失败，但是用stdlib.h中的atoi函数可以
    				//APP_TRACE("2值为%s\r\n", argv[2]);           //对，可以
    				//APP_TRACE("2值为%d\r\n", atof(argv[2]));     //不对
    				//APP_TRACE("除数%.2f\r\n", (atof(argv[2]))/(atof(argv[1])));    //对
    			}
    			else
    			{
    				return SHELL_EXEC_ERR;
    			}
    			break;
    		default:
    			return SHELL_EXEC_ERR;
    	}
    
    	return 0;
    }