【STM32】µC/OS-III多任务程序

最新推荐文章于 2024-07-10 21:55:15 发布
最新推荐文章于 2024-07-10 21:55:15 发布
阅读量905 收藏 26
点赞数 17
分类专栏： STM32 嵌入式 文章标签： stm32 c语言 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_72935906/article/details/139396608
版权

【STM32】µC/OS-III多任务程序

一、探究目的

学习嵌入式实时操作系统（RTOS）,以uc/OS为例，将其移植到stm32F103上，构建至少3个任务（task）:

  • 其中两个task分别以1s和3s周期对LED等进行点亮-熄灭的控制；
  • 另外一个task以2s周期通过串口发送“hello uc/OS! 欢迎来到RTOS多任务环境！”。

二、探究原理

2.1 嵌入式操作系统

2.1.1 RTOS

实时操作系统(Real Time OS, RTOS)，是一款满足实时控制要求的嵌入式操作系统。

主流的RTOS，分别为μClinux、µC/OS-III、eCos、FreeRTOS、mbed OS、RTX、Vxworks、QNX、NuttX，而国产的嵌入式操作系统包括都江堰操作系统(djyos)、Alios Things、Huawei LiteOS、RT-Thread、SylixOS。

2.1.2 前后台系统

简单的小系统通常是前后台系统，这样的程序包括一个死循环和若干个中断服务程序。

其中那个死循环就叫做后台系统。
中断服务程序用于处理系统的异步事件，也就是前台系统。

前台是中断级，后台是任务级。

在这里插入图片描述

2.1.2 µC/OS-III

µC/OS-III是一款源代码开放的，抢占式多任务实时操作系统。

同样，µC/OS-III的任务和这个后台系统及其他的多任务系统一样，每个任务都是一个独立功能的无限循环。不同的是，µC/OS-III支持任务的参数输入。

µC/OS-III的任务有两种：系统任务和用户任务。
系统任务：由操作系统提供的任务，µC/OS-III有5个系统任务。
用户任务：由用户编写的实现应用程序功能的任务。

三、探究过程（实验一）

3.1 μC/OS-III环境配置

3.1.1 CubeMX配置

实现实验一的要求，我们只需要配置好时钟、两个GPIO输出端口就可。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.1.2 下载μC/OS-III源码

配置好的μC/OS-IIIF103环境源码（阿里云盘不限速）

下载之后，把文件放在CubeMX生成的文件uCOS_LED的MDK-ARM文件下。
在这里插入图片描述
点开我们下好的文件，它的精神状态是这样的：（几经疯癫后调出来的绝美环境）
在这里插入图片描述
确认无误后，开始新一轮的UCOS历险记（受难记）。

3.1.3 KEIL环境配置

打开我们的KEIL工程，点击在这里插入图片描述

  1. UC-CPU文件配置
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  2. UC-LIB文件配置
    在这里插入图片描述

  3. UC-SOURCE文件配置
    在这里插入图片描述

  4. UC-PORT文件配置
    在这里插入图片描述

  5. UC-CONFIG文件配置
    在这里插入图片描述

  6. BSP
    在这里插入图片描述
    到这基本配置好了，但你以为这就结束了吗？痛苦才刚刚开始！
    在这里插入图片描述
    在这里插入图片描述

3.1.4 KEIL代码更改

  1. startup_stm32f103xb.s
    在这里插入图片描述
    在这里插入图片描述

  2. app_cfg.h
    在这里插入图片描述
    在这里插入图片描述

  3. includes.h
    在这里插入图片描述

  4. lib_cfg.h在这里插入图片描述

3.1.5 bsp代码

#ifndef  __BSP_H__
#define  __BSP_H__
 
#include "stm32f1xx_hal.h"
 
void BSP_Init(void);
 
#endif

// 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

3.2 实现代码(main.c)

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2024 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <includes.h>
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* 任务优先级 */
#define APP_TASK_START_PRIO		2
#define MyTask_LED1_PRIO		3
#define MyTask_LED2_PRIO		3

/* 任务堆栈大小	*/
#define APP_TASK_START_STK_SIZE 128
#define MyTask_LED1_STK_SIZE 	512
#define MyTask_LED2_STK_SIZE	512

/* 任务控制块 */
static OS_TCB AppTaskStartTCB;
static OS_TCB MyTask_LED1TCB;
static OS_TCB MyTask_LED2TCB;
/* 任务栈 */	
static CPU_STK AppTaskStartStk[APP_TASK_START_STK_SIZE];
static CPU_STK TASK_LED1STK[MyTask_LED1_STK_SIZE];
static CPU_STK TASK_LED2STK[MyTask_LED2_STK_SIZE];

static void AppTaskStart  (void *p_arg);
static void MyTask_LED1  (void *p_arg);
static void MyTask_LED2  (void *p_arg);

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
/* 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 */
static void AppTaskStart (void *p_arg)
{
	CPU_INT32U cpu_clk_freq;
	CPU_INT32U cnts;
	OS_ERR  err;
	(void)p_arg;
	BSP_Init();
	CPU_Init();
	cpu_clk_freq=BSP_CPU_ClkFreq();
	cnts=cpu_clk_freq/(CPU_INT32U)OSCfg_TickRate_Hz;
	OS_CPU_SysTickInit(cnts);
	Mem_Init();
	
	#if OS_CFG_STAT_TASK_EN>0u
		OSStatTaskCPUUsageInit(&err);
	#endif
	CPU_IntDisMeasMaxCurReset();
	OSTaskCreate((OS_TCB *)&MyTask_LED1TCB,                /* Create the start task                                */
				 (CPU_CHAR   *)"LED1",
				 (OS_TASK_PTR ) MyTask_LED1,
				 (void       *) 0,
				 (OS_PRIO     ) MyTask_LED1_PRIO,
				 (CPU_STK    *)&TASK_LED1STK[0],
				 (CPU_STK_SIZE) MyTask_LED1_STK_SIZE/10,
				 (CPU_STK_SIZE) MyTask_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);
				 
	OSTaskCreate((OS_TCB *)&MyTask_LED2TCB,                /* Create the start task                                */
				 (CPU_CHAR   *)"LED2",
				 (OS_TASK_PTR ) MyTask_LED2,
				 (void       *) 0,
				 (OS_PRIO     ) MyTask_LED2_PRIO,
				 (CPU_STK    *)&TASK_LED2STK[0],
				 (CPU_STK_SIZE) MyTask_LED2_STK_SIZE/10,
				 (CPU_STK_SIZE) MyTask_LED2_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);
				 
}


static void MyTask_LED1(void *p_arg)
{
	OS_ERR err;
	(void)p_arg;
	
	while(1)
	{
		OSTimeDlyHMSM(0,0,0,500,OS_OPT_TIME_HMSM_STRICT,&err);
		HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_8);
	}
}

static void MyTask_LED2(void *p_arg)
{
	OS_ERR err;
	(void)p_arg;
	
	while(1)
	{
		OSTimeDlyHMSM(0,0,1,500,OS_OPT_TIME_HMSM_STRICT,&err);
		HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_9);
	}
}
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{

  /* USER CODE BEGIN 1 */
           
  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  /* USER CODE BEGIN 2 */
	OS_ERR  err;
	OSInit(&err);
	/* 创建任务 */
	OSTaskCreate((OS_TCB *)&AppTaskStartTCB,                /* Create the start task                                */
				 (CPU_CHAR   *)"App Task Start",
				 (OS_TASK_PTR ) AppTaskStart,
				 (void       *) 0,
				 (OS_PRIO     ) APP_TASK_START_PRIO,
				 (CPU_STK    *)&AppTaskStartStk[0],
				 (CPU_STK_SIZE) APP_TASK_START_STK_SIZE/10,
				 (CPU_STK_SIZE) APP_TASK_START_STK_SIZE,
				 (OS_MSG_QTY  ) 5u,
				 (OS_TICK     ) 0u,
				 (void       *) 0,
				 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
				 (OS_ERR     *)&err);
	/* 启动多任务系统，控制权交给uC/OS-III */
	OSStart(&err);
}



/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  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 buses 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 BEGIN 4 */
/* 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 */
  __disable_irq();
  while (1)
  {
  }
  /* 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,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

3.3 实现效果

在这里插入图片描述

3.4 代码分析

3.3.1 OS文件功能

在这里插入图片描述

3.3.2 多任务编程流程

1. 在生成任务之前，我们还要进行一些必要的声明，用来声明µC/OS-III的任务函数。
/* 任务优先级 */
#define APP_TASK_START_PRIO		2
#define MyTask_LED1_PRIO		3
#define MyTask_LED2_PRIO		3

/* 任务堆栈大小	*/
#define APP_TASK_START_STK_SIZE 128
#define MyTask_LED1_STK_SIZE 	512
#define MyTask_LED2_STK_SIZE	512

/* 任务控制块 */
static OS_TCB AppTaskStartTCB;
static OS_TCB MyTask_LED1TCB;
static OS_TCB MyTask_LED2TCB;

/* 任务栈 */	
static CPU_STK AppTaskStartStk[APP_TASK_START_STK_SIZE];
static CPU_STK TASK_LED1STK[MyTask_LED1_STK_SIZE];
static CPU_STK TASK_LED2STK[MyTask_LED2_STK_SIZE];

/* 声明用户任务 */	
static void AppTaskStart  (void *p_arg);
static void MyTask_LED1  (void *p_arg);
static void MyTask_LED2  (void *p_arg);

定义命名任务的优先级、堆栈大小、控制块、任务栈以及用户任务声明。

2. 多任务编程时，一般在main()函数中创建一个初始任务AppTaskStart。
//main()中部分代码
	OS_ERR  err;
	OSInit(&err);
	/* 创建任务 */
	OSTaskCreate((OS_TCB *)&AppTaskStartTCB,                /* Create the start task                                */
				 (CPU_CHAR   *)"App Task Start",
				 (OS_TASK_PTR ) AppTaskStart,
				 (void       *) 0,
				 (OS_PRIO     ) APP_TASK_START_PRIO,
				 (CPU_STK    *)&AppTaskStartStk[0],
				 (CPU_STK_SIZE) APP_TASK_START_STK_SIZE/10,
				 (CPU_STK_SIZE) APP_TASK_START_STK_SIZE,
				 (OS_MSG_QTY  ) 5u,
				 (OS_TICK     ) 0u,
				 (void       *) 0,
				 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
				 (OS_ERR     *)&err);
	/* 启动多任务系统，控制权交给uC/OS-III */
	OSStart(&err);

再通过AppTaskStart创建其它用户任务MyTask1、MyTask2等

static void AppTaskStart (void *p_arg)
{
	CPU_INT32U cpu_clk_freq;
	CPU_INT32U cnts;
	OS_ERR  err;
	(void)p_arg;
	BSP_Init();
	CPU_Init();
	cpu_clk_freq=BSP_CPU_ClkFreq();
	cnts=cpu_clk_freq/(CPU_INT32U)OSCfg_TickRate_Hz;
	OS_CPU_SysTickInit(cnts);
	Mem_Init();
	
	#if OS_CFG_STAT_TASK_EN>0u
		OSStatTaskCPUUsageInit(&err);
	#endif
	CPU_IntDisMeasMaxCurReset();
	OSTaskCreate((OS_TCB *)&MyTask_LED1TCB,                /* Create the start task                                */
				 (CPU_CHAR   *)"LED1",
				 (OS_TASK_PTR ) MyTask_LED1,
				 (void       *) 0,
				 (OS_PRIO     ) MyTask_LED1_PRIO,
				 (CPU_STK    *)&TASK_LED1STK[0],
				 (CPU_STK_SIZE) MyTask_LED1_STK_SIZE/10,
				 (CPU_STK_SIZE) MyTask_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);
				 
	OSTaskCreate((OS_TCB *)&MyTask_LED2TCB,                /* Create the start task                                */
				 (CPU_CHAR   *)"LED2",
				 (OS_TASK_PTR ) MyTask_LED2,
				 (void       *) 0,
				 (OS_PRIO     ) MyTask_LED2_PRIO,
				 (CPU_STK    *)&TASK_LED2STK[0],
				 (CPU_STK_SIZE) MyTask_LED2_STK_SIZE/10,
				 (CPU_STK_SIZE) MyTask_LED2_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);
				 
}
3. 任务函数编写

建立好后我们就可以在子任务中编写代码实现功能。
LED1的周期是1s，因此是每500ms翻转一次电平。

static void MyTask_LED1(void *p_arg)
{
	OS_ERR err;
	(void)p_arg;
	
	while(1)
	{
		OSTimeDlyHMSM(0,0,0,500,OS_OPT_TIME_HMSM_STRICT,&err);
		HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_8);
	}
}

LED1的周期是3s，因此是每1s500ms翻转一次电平。

static void MyTask_LED2(void *p_arg)
{
	OS_ERR err;
	(void)p_arg;
	
	while(1)
	{
		OSTimeDlyHMSM(0,0,1,500,OS_OPT_TIME_HMSM_STRICT,&err);
		HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_9);
	}
}

3.5 实验二

3.5.1 CubeMX配置

和3.1.1一样，区别是多了一个usart配置。

在这里插入图片描述

/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "gpio.h"
#include "usart.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <includes.h>
#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_pb8(void *p_arg);
static  void  send_msg(void *p_arg);
static  void  led_pb9(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_pb8", 		
                 (OS_TASK_PTR )led_pb8, 			
                 (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_pb9", 		
                 (OS_TASK_PTR )led_pb9, 			
                 (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_pb8 (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)
  {
  		OSTimeDlyHMSM(0, 0, 1, 0,OS_OPT_TIME_HMSM_STRICT,&err);
		HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_8,GPIO_PIN_RESET);
    /* USER CODE END WHILE */
 
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}
 
static  void  led_pb9 (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)
  {
  		OSTimeDlyHMSM(0, 0, 3, 0,OS_OPT_TIME_HMSM_STRICT,&err);
		HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_9,GPIO_PIN_RESET);
    /* 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 \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****/

四、探究总结

ucos操作系统的关键是环境的配置以及多任务的调配。只要熟悉多任务调配的流程与相关代码模板，想要实现功能就简单多了。

以上则是我本次的探究内容，如有错漏请在评论区指正，谢谢观看！

双料毒狼_s
关注
  • 17
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
µC-OS-III 3.06官方用户手册英文版
03-25
µC-OS-III 3.06官方用户手册英文版，详细介绍了µC-OS-III的系统架构、函数功能及使用，并对关键代码进行了详细说明。
实时多任务系统µC/OS-Ⅱ在DSP上的移植
07-22
本文将介绍实时多任务系统µC/OS-Ⅱ在DSP上的移植
关于µC/OS-III 多任务的基本理解
Yin_w的博客
09-10 442
任务和任务管理是 RTOS 的核心，且大多数项目使用 RTOS 的目的就是为了使用 RTOS 的多任务管理能力。 µC/OS-III作为经典的RTOS，了解并学习其任务管理机制，是非常有必要的。
STM32 uC/OS-III
lanzh_syf的博客
03-31 761
µC/OS-III 的发音为“Micro C O S Three”，这意味着 µC/OS-III 是基于 C 语言编写的第三代小型操作系统，当然这里所说的第三代是相对于 µC/OS 的前两个版本 µC/OS 和 µC/OS-II 而言的，后面也会介绍这三个版本的差别。µC/OS/III 是一个操作系统，准确地说应该是一个实时操作系统，也就是 RTOS（Real Time Operating System），与之类似的 RTOS 还有 FreeRTOS、RTX、RT-Thread 等.
stm32f103C8T6移植uc/OS-III实时操作系统
m0_70536801的博客
01-16 1377
3种物联网操作系统：Huawei LiteOS、Amazon FreeRTOS和RT-ThreadRTOS全称为：Real Time OS，就是实时操作系统，强调的是：实时性。实时操作系统又分为硬实时和软实时。硬实时要求在规定的时间内必须完成操作 ，硬实时系统不允许超时，在软实时里面处理过程超时的后果就没有那么严格。RTOS操作系统：UCOS，FreeRTOS，RTX，RT-Thread，DJYOS等。
µC/OS-III 消息队列
qq_51574957的博客
12-13 38
在上图中可以看到，在靠近接收任务的地方有一个代表超时“沙漏”，这表示任务从消息队列中接收消息是可以指定超时时间的，这个超时时间说明接收消息的任务愿意在消息队列中无消息的时候，等待一定的时间，如果超过了指定的这段时间，消息队列中还是没有消息，那么将接收任务将收到超时相应的错误代码，当然，也可以指定等待的时间为无限长，那么接收消息的任务将一直被挂起，直到消息队列中有消息。在这种情况下，发送消息的任务或中断，可以指定发送消息到挂起等待任务链表中任务优先级最高的任务或者是发送到挂起等待任务链表中的所有任务。
【单片机与嵌入式】uc/OS-III多任务程序
m0_74833863的博客
06-14 938
嵌入式实时操作系统（RTOS）是设计用于嵌入式系统的一种特殊操作系统。它们专注于处理实时任务，即需要在严格的时间限制内完成的任务。RTOS在嵌入式系统中扮演重要角色，通过提供高效的任务调度和实时响应能力，使得嵌入式设备可以在各种应用中可靠运行。选择适合的RTOS取决于具体的应用需求，包括实时性要求、系统资源限制以及开发团队的经验等因素。以下是关于RTOS的一些基本信息：特点和设计考虑因素：1.实时性：RTOS的核心特征是能够处理实时任务。
stm32F103移植uc/OS-III实现多任务
qq_59184121的博客
11-05 765
（英语：Operating System，缩写：OS）是一组主管并控制计算机操作、运用和运行硬件、软件资源和提供公共服务来组织用户交互的相互关联的系统软件程序。根据运行的环境，操作系统可以分为桌面操作系统，手机操作系统，服务器操作系统，嵌入式操作系统等嵌入式操作系统（Embedded Operating System，简称：EOS）是指用于嵌入式系统的操作系统。嵌入式操作系统是一种用途广泛的系统软件，通常包括与硬件相关的底层驱动软件、系统内核、设备驱动接口、通信协议、图形界面、标准化浏览器等。
µC/OS-III 信号量与互斥信号量
qq_51574957的博客
12-12 66
优先级翻转问题指的是，当一个高优先级任务因获取一个被低优先级任务获取而处于没有资源状态的二值信号量时，这个高优先级的任务将被阻塞，直到低优先级的任务释放这个二值信号量，而在这之前，如果有一个优先级介于高优先级任务和低优先级任务之间的任务就绪，那么这个中等优先级的任务就会抢占低优先级任务的运行，这么一来，这三个任务中优先级最高的任务反而要最后才能运行，这就是二值信号量带来的优先级翻转问题，用户在实际开发中要注意这个问题。任务的任务栈都是动态分配的，当然，也可以静态地定任务栈，就像定义一个数组一样。
基于stm32f103C8T6移植uc/OS-III实时操作系统
sjsnsnsnsi的博客
11-26 1588
uC/OS 是一个免费公开源代码、结构小巧、具有可剥夺实时内核的实时操作系统。它分为uC/OS-II 和uC/OS-III 两个版本。uC/OS-II 是一个实时操作系统内核，仅包含任务调度、任务管理、时间管理、内存管理和任务间的通信和同步等基本功能。uC/OS-III 是一个可升级的、可固化的、基于优先级的实时内核，它对任务的个数无限制，并且支持现代的实时内核所期待的大部分功能，例如资源管理、同步、任务间的通信等。
实时操作系统 µC/OS-III
qq_52227042的博客
03-09 792
STM32 系列的 F1、F4、F7 和 H7 等型号的 MCU 都受 µC/OS-III 的支持，只需要进行简单的移植操作，就能够在这些 MCU 上运行 µC/OS-III 操作系统，极大地方便了我们学习和使用µC/OS-III。
µC-OS-III 3.06 API Reference.pdf
03-25
µC-OS-III 3.06官方API参考手册英文版，详细介绍了µC-OS-III 3.06各个模块的API，对每个函数进行了详细的介绍，并举例说明的函数的使用方法。
µC/OS-II V2.86
06-12
3. **抢占式调度**：µC/OS-II支持抢占式调度，允许高优先级的任务中断低优先级任务的执行，以确保关键任务的优先处理。 4. **多任务管理**：系统允许同时执行多个任务，通过任务调度机制来实现并发执行，提高系统...
嵌入式设计：μC/OS-II实时任务模型设计
08-02
总的来说，μC/OS-II实时任务模型设计涉及任务分解、任务通信和任务创建等多个步骤，每个步骤都紧密关联并直接影响到实时系统的性能和可靠性。通过这种方式，开发者可以构建出高效、响应迅速的嵌入式应用，满足各种...
基于与STM32的加湿器之温湿度驱动
最新发布
weixin_44453694的博客
07-10 1210
DHT11 数字温湿度传感器是一款含有已校准数字信号输出的温湿度复合传感器。它应用专用的数字模块采集技术和温湿度传感技术，确保产品具有枀高的可靠性与卓越的长期稳定性。传感器包括一个电容式感湿元件和一个 NTC 测温元件，并与一个高性能 8 位单片机相连接。
STM32（三）：STM32指南者新建工程常用配置
weixin_44264994的博客
07-10 403
这一步的配置也不是配置一次之后完事，常常会因为各种原因需要重新选择，当你下载的时候，提示说找不到Device的时候， 请确保该配置是否正确。如图在F1标准库工程组织中的CMSIS部分的core_cm3.c实际是不需要的，是否留在工程里面没有任何影响，所有例程中都没有使用到它，此文件为官方库保留，已被其他代替。2、在Output选项卡中把输出文件夹定位到我们工程目录下的“output”文件夹， 如果想在编译的过程中生成hex文件，那么那Create HEX File选项勾上。路径没配全，见1、（3）、（4）
stm32实现软件spi
m0_46145044的博客
07-10 358
【代码】stm32实现软件spi。
STM32要学到什么程度才算合格？
linlaoshi2009的博客
06-28 1434
不过呢，我觉得要是能把外设原理搞懂，还会用，已经很不错。在开始前刚好我有一些资料，是我根据网友给的问题精心整理了一份「嵌入式的资料从专业入门到高级教程」，2. 学会用 STM32 来做一些小项目，比如说控制个小机器人啦，或者做个智能家居系统啥的。给个小建议，可以去参加一些 STM32 的比赛或者项目，这样可以更快地提高自己的水平。点个关注在评论区回复“888”之后私信回复“888”，全部无偿共享给大家！3. 掌握一些编程技巧，比如说优化代码啦，提高程序的运行效率啦。
µC/OS-II任务调度器实现调度的流程图。
06-02
下面是µC/OS-II任务调度器实现调度的流程图： ``` +---------------------------+ | | | 任务就绪列表 | | | +---------------------------+ | | V +---------------------------+ | | | 任务调度器 | | | +---------------------------+ | | V +---------------------------+ | | | 调度器任务 | | | +---------------------------+ | | V +---------------------------+ | | | 任务切换 | | | +---------------------------+ ``` 上面的流程图展示了µC/OS-II任务调度器的工作原理。当任务进入就绪状态时，它会被添加到任务就绪列表中，任务调度器会根据任务优先级和调度算法，从就绪列表中选择一个任务进行调度。调度器任务会在每个时钟节拍中运行一次，以检查是否需要进行任务调度。如果需要调度，则调用任务切换函数，将当前任务的上下文保存到其堆栈中，并加载下一个任务的上下文，使其开始运行。这样就实现了多任务的调度和切换。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值