嵌入式RTOS编程

最新推荐文章于 2024-03-06 17:04:53 发布
最新推荐文章于 2024-03-06 17:04:53 发布
阅读量2.3k 收藏 11
点赞数 2
分类专栏： 嵌入式系统开发 文章标签： 单片机 stm32 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52791446/article/details/127638893
版权

目录

一、题目要求

二、关于嵌入式RTOS

1、什么是嵌入式RTOS

2、RTOS具体功能

3、常见的嵌入式操作系统（RTOS）

三、CubeMX配置STM32F103C8T6

四、获取uC/OS-III源码 

​编辑 五、移植uc/OS-III到工程文件

 1、复制uc/OS-III文件到工程文件夹

 2、添加工程文件和头文件路径

 3、修改文件内容

六、程序主要实现功能及实验效果

1、主要程序功能解析 

 2、IDE环境编译设置

 3、实验效果

七、总结

八、参考文献

一、题目要求

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

        记录详细的移植过程。

二、关于嵌入式RTOS

1、什么是嵌入式RTOS

        OS（操作系统，operating system），是嵌入式系统中的灵魂，是其软件系统中的重要组成部分，嵌入式系统的智能化程度与其密不可分。

        从嵌入式系统的应用领域来看，嵌入式操作系统可以分为实时操作系统（RTOS）和非实时操作系统（NRTOS）。但在嵌入式应用领域，很多场合对系统的实时性要求严格，因此操作系统的选择要基于实时系统。实时多任务操作系统(Real Time Operating System，简称RTOS)是根据操作系统的工作特性而言的，实时是指物理进程的真实时间。

2、RTOS具体功能

RTOS具有的功能描述
1) 任务管理包含多任务和基于优先级的任务调度
2) 任务间的同步和通信基于Semaphore  、MailBox等
3) 优化的内存管理单元 (MMU)负责处理中央处理器（CPU）的内存访问请求
4) 实时时钟服务用以设置相应的寄存器来控制实时时钟的状态
5) 中断管理服务处理器处理“急件”的服务

Semaphore：信号量 。又被称为信号灯，用信号量进行通信就像我们只拨通别人的手机而不与之通话。 

MailBox：邮箱。用邮箱进行通信则可达到既拨通别人的手机又与之通话的效果。换句话说，消息队列和邮箱可以及时传送事件的内容。

MMU：Memory Management Unit

RTC：Real Time Clock，可以。这些状态包括使实时时钟开始工作,也包括使实时时钟停止工作。

3、常见的嵌入式操作系统（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)。

三、CubeMX配置STM32F103C8T6

· 芯片选型（stm32f03c8t6）

· 系统时钟配置

首先选择高速外部时钟（HSE） 

配置系统时钟树如下

 

 · GPIO输出模式设置

 

 · USART1初始化

 

最终将配置完成的芯片工程文件导出即可，导出的时候记得选择对应的IDE（我这里选择的是MDK-ARM）

四、获取uC/OS-III源码 

进入官网下载：http://micrium.com/downloadcenter/

网盘链接：https://pan.baidu.com/s/10RqsDRecbmVteWmDv2oUNQ

提取码：1234

 网盘文件下载打开文件如下图（其中uC-BSP和uC-CONFIG是自己创建的两个文件夹，所以读者可以选择不用自己再重新新建两个等同的文件夹）

 五、移植uc/OS-III到工程文件

 1、复制uc/OS-III文件到工程文件夹

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

· 在文件夹uC-CONFIG添加以下文件（从以下路径复制过来）

 · 将uC/OSIII相关文件复制到HAL工程的MDK-ARM文件夹下

MDK-ARM文件夹如下

 2、添加工程文件和头文件路径

· 将uC/OSIII添加到项目

首先点击Manage Project Items（文件项目管理） 

工程项目新建文件夹如下

 分别给新增文件夹添加对应文件

点击以上创建的CPU–>Add Files…，选中以下文件，Add

 点击LIB–>Add Files…，选中以下文件，Add

 点击PORT–>Add Files…，选中以下文件，Add

 点击SOURCE–>Add Files…，选中以下文件，Add

 点击CONFIG–>Add Files…，选中以下文件，Add

 点击BSP–>Add Files…，选中以下文件，Add

 文件添加完成后点击OK保存

 添加头文件路径

 

至此文件路径完成添加

 3、修改文件内容

· 添加bsp.c和bsp.h源文件和头文件的代码如下：

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

// bsp.h
#ifndef  __BSP_H__
#define  __BSP_H__

#include "stm32f1xx_hal.h"

void BSP_Init(void);

#endif

· mian.c函数修改如下：

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usart.h"
#include "gpio.h"

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

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* 任务优先级 */
#define START_TASK_PRIO		3
#define LED0_TASK_PRIO		4
#define MSG_TASK_PRIO		5
#define LED1_TASK_PRIO		6

/* 任务堆栈大小	*/
#define START_STK_SIZE 		64
#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 PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* 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_pa1(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 */

/* USER CODE END 0 */

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

//  HAL_Init();
//  SystemClock_Config();
//  MX_GPIO_Init();
//  MX_USART1_UART_Init();
	
	
	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). */

				 
				 

  /* USER CODE BEGIN WHILE */
//  while (1)
//  {
//    /* USER CODE END WHILE */
//	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);		//设置PC为高电平
//	HAL_Delay(500);				//延时500ms
//	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);
//	HAL_Delay(500);
//    /* USER CODE BEGIN 3 */
//  }
  /* USER CODE END 3 */
}





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_pa1, 			
                 (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, 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  led_pa1 (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_1,GPIO_PIN_RESET);
		OSTimeDlyHMSM(0, 0, 3, 0,OS_OPT_TIME_HMSM_STRICT,&err);
		HAL_GPIO_WritePin(GPIOA,GPIO_PIN_1,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");
			printf("欢迎来到RTOS!  \r\n");
			//printf("多任务环境！\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)
{

}













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

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

 · 部分代码修改如下

找到startup_stm32f103xb.s,在以下位置处将PendSV_Handler修改为OS_CPU_PendSVHandler，且将SysTick_Handler修改为OS_CPU_SysTickHandler

记住下面有四个地方需要修改

 找到app_cfg.h进行如下修改 

 

 找到includes.h做如下添加处理

 在CONFIG工程文件夹下面找到lib_cfg.h做如下修改

 此处修改为5（该处宏定义设置堆空间的大小，STM32F103C8T6的RAM只有20K，所以要改小一点）

在Core工程文件夹里面找到usart.c文件做如下添加

因为我们通过使用printf函数将字符串通过串口发送，所以需要通过上述代码对printf进行重定向

注意！注意！注意！添加后可能FILE会报错，这时需要在文件头部添加头文件#include <stdio.h>就可以了

至此，部分代码也终于修改完毕了

六、程序主要实现功能及实验效果

1、主要程序功能解析 

PC13每隔2s变换一次电平

PA1每隔5s 变换一次电平

 USART1每隔2s发送一次字符串

程序工程代码传送门： 工程文件

 2、IDE环境编译设置

 3、实验效果

RTOS实时操作系统实验

七、总结

        在程序文件添加后路劲添加以及是后面代码修改的地方都要细心仔细，不然在某个地方出错了，后面代码编译就会出现一大堆问题报错，所以一定要按步骤一步一步来，相信你们一次就可以成功实现RTOS编程的应用。

八、参考文献

STM32F103C8T6移植uCOS基于HAL库

STM32F103C8T6移植uC/OS-III基于HAL库超完整详细过程

【嵌入式系统—实时操作系统】RTOS

Jay、cc
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
7天学会RTOS网络编程 课件资料
02-23
该资源是 7天学会RTOS网络编程的课件文档 对应的视频连接 请移步B站 链接： 也可以在摩尔吧观看 该教程基于RT-Thread操作系统 使用并且实例讲解了网络编程的相关内容
玩转C语言RTOS——从原理到应用
qq_61552113的博客
06-27 1068
RTOS是实时操作系统（Real-time Operating System）的英文缩写。C语言RTOS指的是使用C语言编写的嵌入式实时操作系统。1. 实时性：C语言RTOS通常采用抢占式调度算法来保证实时任务的及时响应，在复杂的实时环境下表现出良好的实时执行能力。2. 可靠性：C语言RTOS使用专业的调度算法来保证任务执行的可靠性，并采用任务保护机制（如互斥锁）避免多个任务同时访问共享资源导致的数据损坏和崩溃。3. 易于编写：C语言是一种广泛使用的编程语言，程序员通常可以轻松地编写C语言RTOS代码。
stm32 + freertos + c++混合编程方法
最新发布
yuhu0012的博客
03-06 592
其他一些资料上面，c++配置成--cpp11或者-cpp 都是把工程配置成c++。三、添加cpp文件，我们调用cpp文件里面的接口函数，不需要修改main.c后缀名。2、配置工程编译时候是--c99，是因为工程里面FreeRTOS是c语言，c++模式会报错。我们这里是默认c，编写的c++文件，单独选择--cpp编译，这在后面配置！c++是面向对象编程，对于一些项目来说，c++编程更加合适！stm32cubemax配置，这里就不写了，配置资料比较多。这里就是让cpp文件在c++下编译。最后，编程成功，点亮！
第9周-嵌入式RTOS编程
m0_65922780的博客
11-07 361
第9周-嵌入式RTOS编程
RTOS必备基础
qq_54806957的博客
03-28 3107
涉及： 1，基础ARM指令 2，ARM压栈过程 3，汇编详细分析
一个微型嵌入式RTOS，参考李述铜《从0到1自己动手写嵌入式操作系统》
06-21
C1.07 内核编程实践。CPU寄存器数据的保护（压栈）与恢复（出栈），调试技术的应用。简单汇编代码的编写 C2.01 简单的任务定义实现。包括任务函数、任务结构体、任务栈的定义 C2.02 双任务切换的具体实现。应对...
改进型时间触发嵌入式系统编程模式
01-19
　目前，RTOS特别是抢先式RTOS在嵌入式系统中的应用越来越广泛，但是还有很大一部分产品使用是小型单片机。这些系统由于成本的限制，通常资源非常有限，比如ROM往往小丁32 KB，RAM小于2 KB，由于RTOS对每个任务都要...
嵌入式系统高级编程语言技术分析
02-03
关键词：嵌入式系统高级语言基本性能编程特点一、嵌入式系统高级语言编程特点　随着嵌入式系统应用范围的不断扩大和嵌入式实时操作系统RTOS（RealTimeOperatingSystem）的广泛使用，高级语言编程已是嵌入式系统
07RTOS.zip_嵌入式/单片机/硬件编程_Windows_Unix_
08-12
嵌入式RTOS及其软件开发
嵌入式学习之RTOS编程
Serein1_的博客
11-07 1205
UCOS是Micrium公司出品的RTOS类实时操作系统，是一个可裁剪、可剥夺型的多任务内核，而且没有任务数限制，提供了实时操作系统所需的所有功能，包括资源管理、同步、任务通信等。在UCOSIII中任务就是程序实体，UCOSIII能够管理和调度这些小任务（程序）。UCOSIII中的任务由三部分组成：任务堆栈、任务控制块和任务函数。任务堆栈：上下文切换的时候用来保存任务的工作环境，就是STM32的内部寄存器值。任务控制块：任务控制块用来记录任务的各个属性。
【RTOS学习】精简RTOS源码 | 认识RTOS | 任务的创建和删除
weixin_63726869的博客
10-14 1147
介绍了如何精简从官方得到的FreeRTOS源码供我们使用，以及认识什么是RTOS，还有FreeRTOS的任务创建和删除等内容
嵌入式STM32深入之RTOS编程
huang_527的博客
11-06 3505
在之前的学习中，我们介绍了温度传感器的使用、OLED屏幕的显示，相当于学习了对于外设的基本使用，让我们学习不在仅仅限制于基本LED的使用，大家可以利用这种方式自己购买外设去实现一些功能，这种学习的方法才不会枯燥，就像我最开始购买了一块正点原子的STM32单片机mini的开发板自己学着实在是：因为最开始你学习的话没有系统的认知，只有先学习理论知识，但是对于芯片来说不是特别喜欢容易学崩，我当时就绷不住了。通过最小系统板学习，去开发你自己想做的事，你也不知道会出现什么有意思的事。
RTOS编程
m0_65923764的博客
11-12 396
RTOS编程
嵌入式RTOS多任务程序设计
qq_68130187的博客
11-27 28
（2）打开 CubeMX，从菜单栏 help 进入 Manage embedded software packages 界面，点击 From Url 按钮，进入 User Defined Packs Manager 界面，其次点击 new，填入上述网址，然后点击 check，（2）点击右侧的 Pack，展开 Generic，可以找到 RealThread::RT-Thread，点击 Action 栏对应的 Install ，就可以在线安装 Nano Pack 了。//初始化LED1线程。
嵌入式单片机编程框架
02-24
嵌入式单片机编程框架是用于开发嵌入式系统的软件框架，它提供了一系列的库函数、驱动程序和工具，帮助开发者更方便地进行单片机的编程和开发。 常见的嵌入式单片机编程框架有以下几种： 1. Arduino：Arduino是一个开源的电子原型平台，它提供了简单易用的编程接口和丰富的库函数，适合初学者和快速原型开发。 2. STM32Cube：STM32Cube是STMicroelectronics推出的一套全面的软件开发工具，包括了HAL（Hardware Abstraction Layer）库、LL（Low Layer）库、RTOS（Real-Time Operating System）等，支持多种STM32系列单片机。 3. mbed：mbed是ARM推出的一套开源的嵌入式开发平台，提供了易用的编程接口和丰富的库函数，支持多种不同厂商的单片机。 4. FreeRTOS：FreeRTOS是一个小型的实时操作系统内核，适用于资源有限的嵌入式系统，提供了任务调度、内存管理、通信等功能。 5. Contiki：Contiki是一个开源的操作系统，专门设计用于无线传感器网络和物联网设备，具有低功耗、小内存占用等特点。 以上是一些常见的嵌入式单片机编程框架，每个框架都有其特点和适用场景，开发者可以根据自己的需求选择合适的框架进行开发。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值