嵌入式STM32深入之RTOS编程
RTOS编程
- 一、前言
- 二、 RTOS的概念
-
- （一）用人来类比单片机程序和RTOS
-
- 1.1 我无法一心多用
- 1.2 我可以一心多用
- （二）架构的概念
- （三）常见的嵌入式操作系统（RTOS）
- （四）uc/OS系统介绍
- （五）软实时 和 硬实时
-
- 1. 软实时
- 2. 硬实时
- （六）RTOS 的特征
- 三、RTOS具体实验
-
- 1.新建工程
- 2.选择对应的芯片
- 3.配置RCC
- 4.配置SYS
- 5.配置USART1
- 6.设置LED端口
- 7.生成对应工程
- 四、准备uCOSIII源码
- 五、移植前的准备
-
- （1）文件内部移植
- （2）将uCOS相关文件复制到HAL工程的MDK-ARM文件夹下
- （3）开始移植
- （4）导入文件路径
- （5）为bsp.c和bsp.h添加代码
-
- 1.bsp.c代码
- 2. bsp.h代码
- （6）修改startup_stm32f103xb.s文件代码
- （7）修改app_cfg.h文件代码
- （8）修改includes.h文件代码
- （9）修改lib_cfg.h文件代码
- （10）修改usart.c文件代码
- （11）修改usart.h文件代码
- （12）初始化管脚
- 六、撰写代码与效果实现
-
- 1.撰写主函数
- 2.环境配置
- 3.整体运行
- 七、具体实现
-
- （1）实现了两个task分别以1s和3s周期对LED灯进行点亮-熄灭的控制。
- （2）UC/OS实现串口数据周期发送：
- 八、总结
- 九、参考
一、前言
在之前的学习中，我们介绍了温度传感器的使用、OLED屏幕的显示，相当于学习了对于外设的基本使用，让我们学习不在仅仅限制于基本LED的使用，大家可以利用这种方式自己购买外设去实现一些功能，这种学习的方法才不会枯燥，就像我最开始购买了一块正点原子的STM32单片机mini的开发板自己学着实在是：
因为最开始你学习的话没有系统的认知，只有先学习理论知识，但是对于芯片来说不是特别喜欢容易学崩，我当时就绷不住了。通过最小系统板学习，去开发你自己想做的事，你也不知道会出现什么有意思的事。
本次是学习嵌入式实时操作系统（RTOS）,以uc/OS为例，将其移植到stm32F103上，构建至少3个任务（task）:
- 两个task分别以1s和3s周期对LED灯进行点亮-熄灭的控制；
- 另外一个task以2s周期通过串口发送“hello uc/OS! 欢迎来到RTOS多任务环境！”。
整体实现：
二、 RTOS的概念
（一）用人来类比单片机程序和RTOS
妈妈要一边给小孩喂饭，一边加班跟同事微信交流，怎么办？
1.1 我无法一心多用
对于单线条的人，不能分心、不能同时做事，她只能这样做：
- 给小孩喂一口饭
- 瞄一眼电脑，有信息就去回复
- 再回来给小孩喂一口饭
- 如果小孩吃这口饭太慢，她回复同事的信息也就慢了，被同事催：你半天都不回我？
- 如果回复同事的信息要写一大堆，小孩就着急得大哭起来。
- 这种做法，在软件开发上就是一般的单片机开发，没有用操作系统。
1.2 我可以一心多用
对于眼明手快的人，她可以一心多用，她这样做：
- 左手拿勺子，给小孩喂饭
- 右手敲键盘，回复同事
- 两不耽误，小孩“以为”妈妈在专心喂饭，同事“以为”她在专心聊天
- 但是脑子只有一个啊，虽然说“一心多用”，但是谁能同时思考两件事？
- 只是她反应快，上一秒钟在考虑夹哪个菜给小孩，下一秒钟考虑给同事回复什么信息
- 这种做法，在软件开发上就是使用操作系统，在单片机里叫做使用RTOS。
RTOS的意思是：Real-time operating system，实时操作系统。
我们使用的Windows也是操作系统，被称为通用操作系统。使用Windows时，我们经常碰到程序卡死、停顿的现象，日常生活中这可以忍受。
但是在电梯系统中，你按住开门键时如果没有即刻反应，即使只是慢个1秒，也会夹住人。
在专用的电子设备中，“实时性”很重要。
（二）架构的概念
在电子系统中，CPU就是大脑，CPU有很多种类别，被称为架构。
常见的有：
== ARM：==
目前主流的架构，用得最广，芯片公司需要付费购买，再搭配各种模块才能设计出芯片。
目前华为被美国制裁，无法获得最新的ARM架构；
对于其他公司，购买ARM新架构的价格也不低。
== RISC-V：==
后起之秀，开源、免费。
目前华为海思的HI3861、乐鑫的ESP32-C3等芯片，都是使用RISC-V的单片机芯片；
平头哥和全志的D1芯片，是使用RISC-V的、能运行Linux的芯片；
RISC-V作为全新的架构，没有历史包袱，设计优美，在技术上大有可为，另外它开源无需授权，能摆脱技术的卡脖子问题。
（三）常见的嵌入式操作系统（RTOS）
目前市场上的嵌入式操作系统有几十种，中国近年出现了不少国产嵌入式操作系统，如 HopenOs、DeltaOs 等。国际上嵌入式操作系统种类更多，除了最常用的 uC/OS-II、嵌入式 Linux、 Vxworks 和 WinCE 外，还包括 QNX、PSOS 等。
1、uC/OS-II
uC/OS-II ，一个实时多任务的微内核，为 Jean J. Labrosse 在 1992 年编写的一个开源代码。由于内核小(仅由十几个 C 语言和汇编文件构成)，应用范围宽，目前可应用在许多工业控制器、通信设备和交换机中。它既是实时多任务的微内核，又是开源的代码。
2、Linux 操作系统
Linux 操作系统，有强大的网络功能及其代码的开源性， 但其内核具有不可剥夺特点，其实时性受到一定的限制。因此，为改善其实时性，人们提出了各种嵌入式 Linux 操作系统，如：RT-Linux、Kurt-Linux 和 Red-Linux。
3、Vxworks
Vxworks，作为一种商用的嵌入式操作系统，具有优秀的实时性和稳定性，其代码是不公开的， 而且价格昂贵。Vxworks 主要用于对实时性和稳定性有严格要求的航空航天项目中。
4、 WinCE
WinCE（Window Compact Edition），由美国微软公司设计的，也可用于手持设备的操作系统中， 其主要特点是用户界面非常漂亮，但由于其针对不同种类的手持设备，导致生成的目标代码“超长”(redundant codes)。
（四）uc/OS系统介绍
- uC/OS是一个可以基于ROM运行的、可裁减的、抢占式、实时多任务内核，具有高度可移植性，特别适合于微处理器和控制器，适合很多商业操作系统的实时操作系统(RTOS)。
- uC/OS可简单的视为一个多任务调度器，在这个任务调度器之上完善并添加了和多任务操作系统相关的系统服务，如信号量、邮箱等；其主要特点有公开源代码，代码结构清晰、明了，注释详尽，组织有条理，可移植性好，可裁剪，可固化。 内核属于抢占式，最多可以管理60个任务；从1992年开始，由于高度可靠性、鲁棒性和安全性，uC/OS已经广泛使用在从照相机到航空电子产品的各种应用中。
- μC/OS实时多任务操作系统被广泛应用于微处理器、微控制器和数字信号处理器；μC/OS最早出自于1992 年美国嵌入式系统专家Jean J.Labrosse 在《嵌入式系统编程》杂志的5 月和6 月刊上刊登的文章连载，并把μC/OS的源码发布在该杂志的BBS 上。
（五）软实时 和 硬实时
实时操作系统又可以分为软实时和硬实时。
1. 软实时
软实时只要按照任务的优先级，尽可能快地完成操作即可。
举个例子，电脑的输入处理可以算作是一种“软实时”。为了保证用户的最佳体验，计算机对每个输入的响应应当在一个恰当的时间范围；但如果响应超出了这个时间范围，可能只是稍有卡顿，并不会让人觉得这台电脑无法使用。
比如，最近我的 Windows11的输入法经常性卡顿，偶尔敲字时会突然卡在那里，但最终还是会将我输入的内容显示在响应的地方。把输入法调到实时便可解决问题。
2. 硬实时
硬实时要求在规定的时间内必须完成操作，这是在操作系统设计时保证的，如果无法做到则意味着整个系统的失败。
硬实时操作系统一般都是在对某些对时间把控非常严格的领域使用，例如如说火箭发射，火箭发射的时间都是要精挑细选的。比如小学课本上 1967年8月23日，苏联的“联盟一号”宇宙飞船在返回大气层时，由于忽略了一个小数点，突然发生了恶性循环事故，导致了减速降落伞无法打开；最终导致宇宙飞船在两小时后坠毁，宇航员弗拉迪米·科马洛夫殉难。
像火箭发射这种精密度极高的工作，稍有不慎，算错了时间点，就会“箭毁人亡”，非常需要实时操作系统。
还比如生活中常见的安全气囊，也是硬实时操作系统应用的一个场景。如果汽车发生意外后，安全气囊没有在极短的时间内弹出来并充满氮气，就会给前排驾驶人员带来极大的生命威胁。
（六）RTOS 的特征
① 高精度计时
系统计时精度是影响实时性的一个重要因素。在实时应用系统中，经常需要精确确定实时地操作某个设备或执行某个任务，或精确的计算一个时间函数。这些不仅依赖于一些硬件提供的时钟精度，也依赖于实时操作系统实现的高精度计时功能。
② 多级中断机制
一个实时应用系统通常需要处理多种外部信息或事件，但处理的紧迫程度有轻重缓急之分。有的必须立即作出反应，有的则可以延后处理。因此，需要建立多级中断嵌套处理机制，以确保对紧迫程度较高的实时事件进行及时响应和处理。
③ 实时调度机制
实时操作系统不仅要及时响应实时事件中断，同时也要及时调度运行实时任务。但是，处理机调度并不能随心所欲的进行，因为涉及到两个进程之间的切换，只能在确保“安全切换”的时间点上进行，实时调度机制包括两个方面，一是在调度策略和算法上保证优先调度实时任务；二是建立更多“安全切换”时间点，保证及时调度实时任务。
简单来说，实时性操作系统的特点如下：
①异步的事件响应；
②切换时间和中断延迟时间确定；
③优先级中断和调度；
④抢占式调度。
三、RTOS具体实验
1.新建工程
2.选择对应的芯片
3.配置RCC
点System Cor，选择RCC，在右侧弹出的菜单栏中选Crystal/Ceramic Resonator：
4.配置SYS
选择调试接口，点System Cor，选择SYS。在右侧弹出的菜单栏中选Serial Wire：
5.配置USART1
配置串口USART1：
6.设置LED端口
设置PA3、PC13作为两个LED灯的端口：
7.生成对应工程
之后生成工程导出就可以了，基本命名等等
四、准备uCOSIII源码
进入官网下载：官网
或链接：百度网盘提取码：1234
网盘下载，打开目录如下：
五、移植前的准备
（1）文件内部移植
为uC-BSP文件夹新建bsp.c和bsp.h文件。
给文件夹uC-CONFIG添加以下文件（从以下路径复制过来）
（2）将uCOS相关文件复制到HAL工程的MDK-ARM文件夹下
（3）开始移植
回到Keil打开的HAL工程
1.将uCOS文件添加到项目
若没有图示中的图标，点击1步，添加文件
点击CPU–>Add Files…，选中以下文件，Add
再打开MDK-ARM\uC-CPU\ARM-Cortex-M3\RealView路径，选中以下文件，Add添加：
点击LIB–>Add Files…，在MDK-ARM\uC-LIB路径下选中下图文件，Add添加：
再打开MDK-ARM\uC-LIB\Ports\ARM-Cortex-M3\RealView路径，选中下图框文件，Add添加：
点击SOURCE–>Add Files…，MDK-ARM\uCOS-III\Source路径下选中以下全部.c .h文件，Add添加：
点击CONFIG–>Add Files…，MDK-ARM\uC-CONFIG路径下选中以下全部文件，Add添加：
点击BSP–>Add Files…，LMDK-ARM\uC-BSP路径下选中以下全部文件，Add添加：
！！！一定记得点击OK，不然就白干了
此时项目结构会发生变化：
（4）导入文件路径
导入文件路径：
项目路径下寻找：
（5）为bsp.c和bsp.h添加代码
为bsp.c和bsp.h添加代码
1.bsp.c代码
#include "includes.h"
#define DWT_CR *(CPU_REG32 *)0xE0001000
#define DWT_CYCCNT *(CPU_REG32 *)0xE0001004
#define DEM_CR *(CPU_REG32 *)0xE000EDFC
#define DBGMCU_CR *(CPU_REG32 *)0xE0042004
#define DEM_CR_TRCENA (1 << 24)
#define DWT_CR_CYCCNTENA (1 << 0)
CPU_INT32U BSP_CPU_ClkFreq (void)
{
return HAL_RCC_GetHCLKFreq();
}
void BSP_Tick_Init(void)
{
CPU_INT32U cpu_clk_freq;
CPU_INT32U cnts;
cpu_clk_freq = BSP_CPU_ClkFreq();
#if(OS_VERSION>=3000u)
cnts = cpu_clk_freq/(CPU_INT32U)OSCfg_TickRate_Hz;
#else
cnts = cpu_clk_freq/(CPU_INT32U)OS_TICKS_PER_SEC;
#endif
OS_CPU_SysTickInit(cnts);
}
void BSP_Init(void)
{
BSP_Tick_Init();
MX_GPIO_Init();
}
#if (CPU_CFG_TS_TMR_EN == DEF_ENABLED)
void CPU_TS_TmrInit (void)
{
CPU_INT32U cpu_clk_freq_hz;
DEM_CR |= (CPU_INT32U)DEM_CR_TRCENA; /* Enable Cortex-M3's DWT CYCCNT reg. */
DWT_CYCCNT = (CPU_INT32U)0u;
DWT_CR |= (CPU_INT32U)DWT_CR_CYCCNTENA;
cpu_clk_freq_hz = BSP_CPU_ClkFreq();
CPU_TS_TmrFreqSet(cpu_clk_freq_hz);
}
#endif
#if (CPU_CFG_TS_TMR_EN == DEF_ENABLED)
CPU_TS_TMR CPU_TS_TmrRd (void)
{
return ((CPU_TS_TMR)DWT_CYCCNT);
}
#endif
#if (CPU_CFG_TS_32_EN == DEF_ENABLED)
CPU_INT64U CPU_TS32_to_uSec (CPU_TS32 ts_cnts)
{
CPU_INT64U ts_us;
CPU_INT64U fclk_freq;
fclk_freq = BSP_CPU_ClkFreq();
ts_us = ts_cnts / (fclk_freq / DEF_TIME_NBR_uS_PER_SEC);
return (ts_us);
}
#endif
#if (CPU_CFG_TS_64_EN == DEF_ENABLED)
CPU_INT64U CPU_TS64_to_uSec (CPU_TS64 ts_cnts)
{
CPU_INT64U ts_us;
CPU_INT64U fclk_freq;
fclk_freq = BSP_CPU_ClkFreq();
ts_us = ts_cnts / (fclk_freq / DEF_TIME_NBR_uS_PER_SEC);
return (ts_us);
}
#endif
2. bsp.h代码
#ifndef __BSP_H__
#define __BSP_H__
#include "stm32f1xx_hal.h"
void BSP_Init(void);
#endif
（6）修改startup_stm32f103xb.s文件代码
== PendSV_Handler改为OS_CPU_PendSVHandler，==
== SysTick_Handler改为OS_CPU_SysTickHandler ==
（7）修改app_cfg.h文件代码
DEF_ENABLED 改为 DEF_DISABLED
#define APP_TRACE BSP_Ser_Printf 改为 #define APP_TRACE(void)
（8）修改includes.h文件代码
在#include
将#include
（9）修改lib_cfg.h文件代码
修改为5u
（10）修改usart.c文件代码
添加代码完成printf重定向
/* USER CODE BEGIN 1 */
int fputc(int ch,FILE *f){
HAL_UART_Transmit(&huart1,(uint8_t *)&ch,1,0xffff);
return ch;
}
/* USER CODE END 1 */
（11）修改usart.h文件代码
添加定义代码：
typedef struct __FILE FILE;
（12）初始化管脚
在gpio.c文件中修改代码：
void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_3, GPIO_PIN_RESET);
/*Configure GPIO pin : PC13|PA3 */
GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_3;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}
六、撰写代码与效果实现
1.撰写主函数
修改main.c文件代码：
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "gpio.h"
#include "usart.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include
#include "stm32f1xx_hal.h"
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* 任务优先级 */
#define START_TASK_PRIO 3
#define LED0_TASK_PRIO 4
#define MSG_TASK_PRIO 5
#define LED1_TASK_PRIO 6
/* 任务堆栈大小 */
#define START_STK_SIZE 96
#define LED0_STK_SIZE 64
#define MSG_STK_SIZE 64
#define LED1_STK_SIZE 64
/* 任务栈 */
CPU_STK START_TASK_STK[START_STK_SIZE];
CPU_STK LED0_TASK_STK[LED0_STK_SIZE];
CPU_STK MSG_TASK_STK[MSG_STK_SIZE];
CPU_STK LED1_TASK_STK[LED1_STK_SIZE];
/* 任务控制块 */
OS_TCB StartTaskTCB;
OS_TCB Led0TaskTCB;
OS_TCB MsgTaskTCB;
OS_TCB Led1TaskTCB;
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */
/* 任务函数定义 */
void start_task(void *p_arg);
static void AppTaskCreate(void);
static void AppObjCreate(void);
static void led_pc13(void *p_arg);
static void send_msg(void *p_arg);
static void led_pa3(void *p_arg);
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
/**Initializes the CPU, AHB and APB busses clocks
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/**Initializes the CPU, AHB and APB busses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
{
Error_Handler();
}
}
/* USER CODE END 0 */
/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
OS_ERR err;
OSInit(&err);
HAL_Init();
SystemClock_Config();
//MX_GPIO_Init(); 这个在BSP的初始化里也会初始化
MX_USART1_UART_Init();
/* 创建任务 */
OSTaskCreate((OS_TCB *)&StartTaskTCB, /* Create the start task */
(CPU_CHAR *)"start task",
(OS_TASK_PTR ) start_task,
(void *) 0,
(OS_PRIO ) START_TASK_PRIO,
(CPU_STK *)&START_TASK_STK[0],
(CPU_STK_SIZE) START_STK_SIZE/10,
(CPU_STK_SIZE) START_STK_SIZE,
(OS_MSG_QTY ) 0,
(OS_TICK ) 0,
(void *) 0,
(OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
(OS_ERR *)&err);
/* 启动多任务系统，控制权交给uC/OS-III */
OSStart(&err); /* Start multitasking (i.e. give control to uC/OS-III). */
}
void start_task(void *p_arg)
{
OS_ERR err;
CPU_SR_ALLOC();
p_arg = p_arg;
/* YangJie add 2021.05.20*/
BSP_Init(); /* Initialize BSP functions */
//CPU_Init();
//Mem_Init(); /* Initialize Memory Management Module */
#if OS_CFG_STAT_TASK_EN > 0u
OSStatTaskCPUUsageInit(&err); //统计任务
#endif
#ifdef CPU_CFG_INT_DIS_MEAS_EN //如果使能了测量中断关闭时间
CPU_IntDisMeasMaxCurReset();
#endif
#if OS_CFG_SCHED_ROUND_ROBIN_EN //当使用时间片轮转的时候
//使能时间片轮转调度功能,时间片长度为1个系统时钟节拍，既1*5=5ms
OSSchedRoundRobinCfg(DEF_ENABLED,1,&err);
#endif
OS_CRITICAL_ENTER(); //进入临界区
/* 创建LED0任务 */
OSTaskCreate((OS_TCB * )&Led0TaskTCB,
(CPU_CHAR * )"led_pc13",
(OS_TASK_PTR )led_pc13,
(void * )0,
(OS_PRIO )LED0_TASK_PRIO,
(CPU_STK * )&LED0_TASK_STK[0],
(CPU_STK_SIZE)LED0_STK_SIZE/10,
(CPU_STK_SIZE)LED0_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建LED1任务 */
OSTaskCreate((OS_TCB * )&Led1TaskTCB,
(CPU_CHAR * )"led_pa3",
(OS_TASK_PTR )led_pa3,
(void * )0,
(OS_PRIO )LED1_TASK_PRIO,
(CPU_STK * )&LED1_TASK_STK[0],
(CPU_STK_SIZE)LED1_STK_SIZE/10,
(CPU_STK_SIZE)LED1_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
/* 创建MSG任务 */
OSTaskCreate((OS_TCB * )&MsgTaskTCB,
(CPU_CHAR * )"send_msg",
(OS_TASK_PTR )send_msg,
(void * )0,
(OS_PRIO )MSG_TASK_PRIO,
(CPU_STK * )&MSG_TASK_STK[0],
(CPU_STK_SIZE)MSG_STK_SIZE/10,
(CPU_STK_SIZE)MSG_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
OS_TaskSuspend((OS_TCB*)&StartTaskTCB,&err); //挂起开始任务
OS_CRITICAL_EXIT(); //进入临界区
}
/**
* 函数功能: 启动任务函数体。
* 输入参数: p_arg 是在创建该任务时传递的形参
* 返 回 值: 无
* 说 明：无
*/
static void led_pc13 (void *p_arg)
{
OS_ERR err;
(void)p_arg;
BSP_Init(); /* Initialize BSP functions */
CPU_Init();
Mem_Init(); /* Initialize Memory Management Module */
#if OS_CFG_STAT_TASK_EN > 0u
OSStatTaskCPUUsageInit(&err); /* Compute CPU capacity with no task running */
#endif
CPU_IntDisMeasMaxCurReset();
AppTaskCreate(); /* Create Application Tasks */
AppObjCreate(); /* Create Application Objects */
while (DEF_TRUE)
{
HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_RESET);
OSTimeDlyHMSM(0, 0, 1, 0,OS_OPT_TIME_HMSM_STRICT,&err);
HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_SET);
OSTimeDlyHMSM(0, 0, 1, 0,OS_OPT_TIME_HMSM_STRICT,&err);
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
static void led_pa3 (void *p_arg)
{
OS_ERR err;
(void)p_arg;
BSP_Init(); /* Initialize BSP functions */
CPU_Init();
Mem_Init(); /* Initialize Memory Management Module */
#if OS_CFG_STAT_TASK_EN > 0u
OSStatTaskCPUUsageInit(&err); /* Compute CPU capacity with no task running */
#endif
CPU_IntDisMeasMaxCurReset();
AppTaskCreate(); /* Create Application Tasks */
AppObjCreate(); /* Create Application Objects */
while (DEF_TRUE)
{
HAL_GPIO_WritePin(GPIOA,GPIO_PIN_3,GPIO_PIN_RESET);
OSTimeDlyHMSM(0, 0, 3, 0,OS_OPT_TIME_HMSM_STRICT,&err);
HAL_GPIO_WritePin(GPIOA,GPIO_PIN_3,GPIO_PIN_SET);
OSTimeDlyHMSM(0, 0, 3, 0,OS_OPT_TIME_HMSM_STRICT,&err);
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
static void send_msg (void *p_arg)
{
OS_ERR err;
(void)p_arg;
BSP_Init(); /* Initialize BSP functions */
CPU_Init();
Mem_Init(); /* Initialize Memory Management Module */
#if OS_CFG_STAT_TASK_EN > 0u
OSStatTaskCPUUsageInit(&err); /* Compute CPU capacity with no task running */
#endif
CPU_IntDisMeasMaxCurReset();
AppTaskCreate(); /* Create Application Tasks */
AppObjCreate(); /* Create Application Objects */
while (DEF_TRUE)
{
printf("hello uc/OS！欢迎来到RTOS多任务环境！ \r\n");
OSTimeDlyHMSM(0, 0, 2, 0,OS_OPT_TIME_HMSM_STRICT,&err);
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
/* USER CODE BEGIN 4 */
/**
* 函数功能: 创建应用任务
* 输入参数: p_arg 是在创建该任务时传递的形参
* 返 回 值: 无
* 说 明：无
*/
static void AppTaskCreate (void)
{
}
/**
* 函数功能: uCOSIII内核对象创建
* 输入参数: 无
* 返 回 值: 无
* 说 明：无
*/
static void AppObjCreate (void)
{
}
/* USER CODE END 4 */
/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
/* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t *file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
2.环境配置
如图所示：
3.整体运行
此时
最后烧录进入最小系统板即可，连接方式与之前相同，不懂得可以看我之前的博客：
https://blog.csdn.net/huang_527/article/details/127244937
七、具体实现
（1）实现了两个task分别以1s和3s周期对LED灯进行点亮-熄灭的控制。
（2）UC/OS实现串口数据周期发送：
八、总结
本次实操不难，主要是难在去理解uc/OS实时操作系统，移植uc/OS文件这一点操作需要非常仔细，出错一点，就牵一发动全身，需要修改的文件代码非常多，需要一步一步的去完成，最后编写成功的时候，还是特别有成就感，实验效果是一遍就出来，但过程却比较艰难，需要细心仔细。一不小心就加错了，加重复了，代码编译不报错，但不能运行，很大可能是参数配置的问题。
那就到此为止吧，再说就不礼貌了。
今天的学习到这里就结束了，整体上我们学习了嵌入式实时操作系统（RTOS）,以uc/OS为例，将其移植到stm32F103上，构建至少3个任务（task）:其中两个task分别以1s和3s周期对LED灯进行点亮-熄灭的控制；另外一个task以2s周期通过串口发送“hello uc/OS! 欢迎来到RTOS多任务环境！”。
下班！！