【嵌入式知识15】嵌入式RTOS编程（uc/OS）

已于 2022-11-25 16:55:53 修改
阅读量487 收藏 2
点赞数
文章标签： 单片机 stm32 嵌入式硬件
于 2022-11-05 00:51:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52241626/article/details/127640444
版权

  本文以uc/OS为例，将其移植到stm32F103C8T6上，构建至少3个任务（task）:其中两个task分别以1s和3s周期对LED等进行点亮-熄灭的控制；另外一个task以2s周期通过串口发送“hello uc/OS! 欢迎来到RTOS多任务环境！”。

本文目录

一、获取uC/OS-III源码

1. 官网下载

进入 Micrium 公司官网下载中心：http://micrium.com/downloadcenter/
然后按照提示注册、登陆账号并下载
在这里插入图片描述

2. 网盘下载

链接：https://pan.baidu.com/s/10RqsDRecbmVteWmDv2oUNQ
提取码：1234
内容来源于博客：https://blog.csdn.net/qq_45659777/article/details/121570886
网盘下载完后，目录如下：
（文件夹uC-BSP和uC-CONFIG是自己新建的两个文件夹）
在这里插入图片描述

二、使用CubeMX创建工程

1. 选择芯片开始创建项目

选择STM32F103C8T6——>开始项目
在这里插入图片描述

2. 配置RCC

在这里插入图片描述

3. 配置SYS

在这里插入图片描述

4. 配置引脚

设置PC13为GPIO_Output，用该引脚点亮LED灯
在这里插入图片描述

5. 配置串口USART1

在这里插入图片描述

5. 配置时钟

选择外部时钟HSE
在这里插入图片描述
配置时钟树
在这里插入图片描述

6. 导出工程

在这里插入图片描述
最后点击GENERATE CODE导出文件。

三、将uC/OS-III文件复制到工程文件中

1. 在uC-BSP文件夹添加文件

在uC-BSP文件夹中新建bsp.c和bsp.h文件

2. 将以下文件添加到文件夹uC-CONFIG（文件路径如下）

在这里插入图片描述

3. 将uCOS相关文件复制到HAL工程的MDK-ARM文件夹下

uCOS相关文件：
在这里插入图片描述
HAL工程的MDK-ARM文件夹：
在这里插入图片描述

四、进行移植操作

1. 进入 Manage Project Items

打开Keil文件后，点击 Manage Project Items
在这里插入图片描述
项目新建的文件夹如下：
在这里插入图片描述

2. 添加相关文件到CPU文件夹

点击CPU–>Add Files–>uC-CPU，选中以下文件，点击Add添加
在这里插入图片描述
再添加如下路径中的文件：
在这里插入图片描述

3. 添加相关文件到LIB文件夹

点击LIB–>Add Files–>uC-LIB，选中以下文件，点击Add添加
在这里插入图片描述
再点击Ports–>ARM-Cortex-M3–>RealView，添加如下文件：
在这里插入图片描述

4. 添加相关文件到PORT文件夹

点击PORT–>Add Files–>uCOS-III…，选中以下文件，点击Add添加
在这里插入图片描述

5. 添加相关文件到SOURCE文件夹

点击SOURCE–>Add Files–>uCOS-III–>Source，选中以下文件，点击Add添加
在这里插入图片描述

6. 添加相关文件到CONFIG文件夹

点击CONFIG–>Add Files–>uc-CONFIG，选中以下文件，点击Add添加
在这里插入图片描述

7. 添加相关文件到BSP文件夹

点击BSP–>Add Files–>uc-BSP，选中以下文件，点击Add添加
在这里插入图片描述
文件添加完毕，点击OK完成移植操作。
在这里插入图片描述

五、导入文件路径及代码编写

1. 导入文件路径

点击魔法棒–>点击C/C++–>点击 Include Paths–>添加所有文件–>点击ok
在这里插入图片描述

2. 编写代码

bsp.c和bsp.h添加代码
bsp.h

// bsp.h
#ifndef  __BSP_H__
#define  __BSP_H__

#include "stm32f1xx_hal.h"

void BSP_Init(void);

#endif

bsp.c

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

main.c文件

/* 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 START_STK_SIZE 		64
#define LED0_STK_SIZE 		64
#define MSG_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];
/* 任务控制块 */
OS_TCB StartTaskTCB;
OS_TCB Led0TaskTCB;
OS_TCB MsgTaskTCB;
/* 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);
/* 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 	* )&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, 0, 500,OS_OPT_TIME_HMSM_STRICT,&err);
		HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_SET);
		OSTimeDlyHMSM(0, 0, 0, 500,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 world \r\n");
		OSTimeDlyHMSM(0, 0, 0, 500,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****/

3. 修改部分代码

找到文件startup_stm32f103xb.s
在这里插入图片描述
将PendSV_Handler和SysTick_Handler改为OS_CPU_PendSVHandler和OS_CPU_SysTickHandler
在这里插入图片描述
在这里插入图片描述
找到文件app_cfg.h
在这里插入图片描述
APP _CFG_SERIAL_EN DEF_ENABLED改为APP_CFG_SERIAL_EN DEF_DISABLED
在这里插入图片描述
找到文件includes.h
在这里插入图片描述
添加头文件
在这里插入图片描述
将#include <stm32f10x_lib.h>改为#include “stm32f1xx_hal.h”
在这里插入图片描述
找到lib_cfg.h
在这里插入图片描述
此处修改为5
在这里插入图片描述
由于我们使用了printf函数，需要在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 */

4.参数配置

具体操作步骤如下：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
将代码进行编译，编译没有错误后将代码烧录到开发板上。

六、测试

1. 开发板测试视频：

ucos简单测试-开发板视频

2. 串口助手测试视频：

ucos简单测试-串口助手视频

七、构建三个任务

1. 任务简述

  学习嵌入式实时操作系统（RTOS）,以uc/OS为例，将其移植到stm32F103上，构建至少3个任务（task）:其中两个task分别以1s和3s周期对LED灯进行点亮-熄灭的控制；另外一个task以2s周期通过串口发送“hello uc/OS! 欢迎来到RTOS多任务环境！”。记录详细的移植过程。

2. 代码编写

gpio.c中修改代码（添加初始化PA3）

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);

}

main.c代码编写

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

八、实验结果展示

1. 开发板实验结果

烧录代码，开发板实验结果展示：

ucos开发板视频

2. 串口助手实验结果

串口助手实现结果展示：

ucos串口助手视频

九、总结

  本次实验主要学习了嵌入式实时操作系统（RTOS）,以uc/OS为例，将其移植到stm32F103上，分别以1s和3s周期对LED灯进行点亮-熄灭的控制；再以2s周期通过串口发送“hello uc/OS! ”。
  进行实验时，文件添加过程比较繁琐，需要将所有文件添加到响应文件夹里，需要细心操作，不然就会失败。如果需要修改LED亮灭时间，可以修改对应函数中
OSTimeDlyHMSM(0, 0, x, 0,OS_OPT_TIME_HMSM_STRICT,&err函数，x即为对应的周期时间，修改x的值，再次编译，即可将LED亮灭时间进行修改。
  通过整个实验，我掌握了RTOS编程的应用，做实验的过程中也遇到和解决了很多问题，又是学习了新知识的一次实验。

十、参考资料

https://blog.csdn.net/qq_45659777/article/details/121570886

https://blog.csdn.net/weixin_43116606/article/details/105532222

https://blog.csdn.net/junseven164/article/details/121534916

小梅同学charles
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
嵌入式实时操作系统uC/OS-II 中文
09-08
μC OSII是著名的 源码公开的实时内核 是专为嵌入式应用设计的 可用于各类8位 16位和32位单片机或DSP 从μC OS算起 该内核已有10余年应用史 在诸多领域得到了广泛应用 如果您从未用过RTOS 那么这本书将让您掌握RTOS...
FreeRTOS与uCOS II的比较（嵌入式实时系统）
weixin_43684318的博客
09-25 2128
目前嵌入式主流实时系统（RTOS）有uCOS、FreeRTOS，之所以很多第三方库都有在FreeRTOS上的应用Demo，是因为FreeRTOS免费。不要钱是真的厉害呀！然而说实话，论源码规范，我还是喜欢uCOS。 一、FreeRTOS比uCOS II优胜的地方： 1。内核ROM和耗费RAM都比uCOS 小，特别是RAM。 这在单片机里面是稀缺资源，uCOS至少要5K以上， 而FreeRTOS用2~3K也可以跑的很好。 2。FreeRTOS 可以用协程（Co-routine），减少RAM消耗（共用S.
将uc/OS-III移植到stm32F103上的嵌入式实时操作系统（RTOS）-HAL库
最新发布
qq_65424589的博客
11-28 1300
uC/OS-III是一款高效、可移植、可裁剪的实时嵌入式操作系统，STM32F103C8T6是基于HAL库的微控制器。实操过程中，首先需要在STM32F103C8T6上移植uC/OS-III操作系统，然后使用逻辑分析仪抓取波形进行协议分析。通过这个过程，可以深入了解uC/OS-III的操作过程，以及如何在微控制器上实现基于操作系统的开发。同时，通过逻辑分析仪抓取的波形数据，可以进一步进行协议分析，对于研究嵌入式系统的通信协议具有重要意义。
[RTOS]uCOS、FreeRTOS、RTThread、RTX等RTOS的对比之特点
weixin_43684318的博客
09-25 1606
最近正好又重新回顾了一下这几款OS，心里一直有个疑问，明明这几款RTOS是这么像，为什么还要搞出这么多个来呢，最后的结论就是，管他呢，反正哪个用的顺手用哪个。 　　本篇博客就来细数这几个RTOS的特点。 　 以下内容均来自官方网站或者官方手册Feature的Google翻译的加了我的一些调整，没有任何主观成分。 未经同意禁止转载，尊重别人的劳动成果！！！https://blog.csdn.net/wangyijieonline/article/details/77584726 1. FreeRT..
STM32之移植uCOSIII（HAL库）
John_keen的博客
12-04 647
一.使用CubeMX建立STM32F103C8T6HAL库 创建新工程 配置RCC 配置SYS 设置PC13为GPIO_Output用于点亮LED灯 设置串口USART1 设置工程 二.准备uCOSIII源码 进入官网下载：http://micrium.com/downloadcenter/ 打开目录如下 三、准备移植 .将uCOS相关文件复制到HAL工程的MDK-ARM文件夹下 四.开始移植 Keil打开HAL工程 1.将uCOS文件添加到项目 点击Manage Project Item
[RTOS]rtthread,freeRTOS,uCOS等系统简单对比
m0_37370820的博客
10-12 1万+
[RTOS] rt-hread freeRTOS uCOS 简单对比
嵌入式实时操作系统μC／OS-III(英文版)
02-24
UCOS是Micrium公司出品的RTOS类实时操作系统，UCOS目前有两个版本：UCOSII和UCOSIII。 UCOSIII是一个可裁剪、可剥夺型的多任务内核，而且没有任务数限制。UCOSIII提供了实时操作系统所需的所有功能，包括资源管理、...
实时嵌入式系统uC/OS II教程（中文+英文）以及源代码
08-26
实时嵌入式系统uC/OS II教程，其中有中文、英文的word或者pdf版本的，以及源代码。 希望能够有用，对学习RTOS的各位。
嵌入式微系统的筋骨：精简uC/OS-II
08-30
uC/OS-II是最早进入国内的一款开源RTOS，因为代码开源，又有配套的书籍，加上不大的代码量，在嵌入式群体中最为流行。
嵌入式系统/ARM技术中的嵌入式实时操作系统uC/OS-II的应用与新发展
12-01
两年前的这个时候，笔者应《电子产品世界》之邀，在嵌入式 2000学术研讨会上提出，以免费的RTOS-uC/OS的学习与应用为突破口，提倡学习RTOS，使用RTOS，不久以后，《uC/0S-II the Real Time Kernel》一书的中译本出版...
基于ucos-ii的程序设计实例
11-19
基于ucos-ii的程序设计实例
uCOS-II多任务编程设计
02-14
uCOS-II 任务 编程 详细描述了在uCOS-II环境下，任务设计的步骤。全文分为任务函数和数据结构设计，并通过一个实例，说明了设计的具体过程
UCOS/RTOS 任务调度中的实时操作系统
m0_46171719的博客
08-05 807
RTOS
嵌入式RTOS编程
qq_52791446的博客
11-03 2370
OS（操作系统，operating system），是嵌入式系统中的灵魂，是其软件系统中的重要组成部分，嵌入式系统的智能化程度与其密不可分。从嵌入式系统的应用领域来看，嵌入式操作系统可以分为实时操作系统（RTOS）和非实时操作系统（NRTOS）。但在嵌入式应用领域，很多场合对系统的实时性要求严格，因此操作系统的选择要基于实时系统。实时多任务操作系统(Real Time Operating System，简称RTOS)是根据操作系统的工作特性而言的，实时是指物理进程的真实时间。2、RTOS具体功能。
STM32之RTOS：uCOS和FreeRTOS
qq_28576837的博客
08-22 7361
STM32之RTOS：uCOS和FreeRTOS
UCOS学习（一）——前后台系统、RTOS系统
qq_52608074的博客
01-07 2560
本文简单介绍了RTOS操作系统和UCOS操作系统基本知识和特性
嵌入式软件设计（ucos iii使用）
嵌入式-老费，一个分享专业嵌入式知识的blog
06-07 823
【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 很多人都知道ucos ii，因为邵贝贝翻译的那本书《嵌入式实时操作系统-ucos ii》影响还是很大的。只是很多人不知道的是，在ucos ii的基础上，后面micrium公司又开发了ucos iii。相比较ucos ii而言，ucos iii做了很多改进。比如说，之前ucos ii只能有64个任务，每个任务的优先级不能相同，ucos iii则没有这个限制。 目前，很多开发板厂商
STM32项目设计：基于STM32F4的mp3、wav音乐播放器 （UCOSIII操作系统、GUI控件）
热门推荐
mbs706的博客
12-17 2万+
文章目录基于STM32的音乐播放器一、项目要求：二、材料准备二、硬件连接三、下载调试四、相关知识点五、程序展示 基于STM32的音乐播放器 哔哩哔哩视频链接：https://www.bilibili.com/video/BV1cp4y1678G/ 资料链接：https://download.csdn.net/download/mbs520/13711787 百度网盘链接：https://pan.baidu.com/s/1G-Q1CA1Px8RSZJtTYjmELw 提取码：abcd 取走记得点赞 一、项
uCOS学习笔记以及编程接口
张鹏军的技术之旅
11-09 436
实时操作系统 uCOS是一个实时操作系统(RTOS)，在这里我对实时的理解是每个任务的有不同的优先级，当高优先级任务就绪时可以不用等待低优先级的任务执行完成，就可以立马调度执行，响应时间基本是固定的. 任务管理 主要包括任务的创建，删除，挂起和恢复 时间管理 主要是实现任务的延时，延时的单位可以节拍，毫秒，秒，分，小时。一般调用延时函数后，当前的任务会从运行状态变为睡眠状态.时间到后会把该任务变为就绪态. 任务间通讯及同步 uCOS使用信号量，邮箱，队列实现任务间的同步。邮箱相对于信号量，可以传递一个消息指
嵌入式软件基础知识的PPT
05-25
很抱歉，我没有访问PPT的权限。但是，我可以提供一些嵌入式软件基础知识的概述： 嵌入式软件是指运行在嵌入式系统上的软件，嵌入式系统包括电子设备、机器、汽车、航空航天设备等等。嵌入式系统通常需要满足实时性、可靠性、安全性、节能等要求。因此，嵌入式软件需要具备高效的处理能力、稳定的运行环境、精准的控制能力和良好的扩展性。 嵌入式软件开发一般包括以下几个方面： 1.硬件平台了解：熟悉使用的开发板或芯片的架构、特性和接口等。 2.编程语言：C、C++、汇编等是常用的编程语言，具体根据系统的需求来选择。 3.操作系统：嵌入式系统一般使用实时操作系统（RTOS），如FreeRTOS、uC/OS等。 4.驱动程序开发：驱动程序是嵌入式系统软件开发的重要组成部分，包括外设驱动程序、设备驱动程序等。 5.应用程序开发：根据系统需求，编写相应的应用程序。 6.调试和测试：嵌入式系统调试和测试是开发过程中必不可少的步骤，包括硬件和软件两个方面。 以上是嵌入式软件基础知识的简单介绍，如果您有具体的问题，欢迎继续提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小梅同学charles

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值