基于HAL库的STM32F103移植RTOS多任务程序设计

已于 2023-11-26 15:20:26 修改
阅读量987 收藏 27
点赞数 19
文章标签： stm32 嵌入式硬件 单片机
于 2023-11-26 15:18:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73993338/article/details/134624542
版权

一、实验任务

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

二、实时操作系统RTOS

us/OS-III介绍

uC/OS-III(Micro C OS Three 微型的C 语言编写的操作系统第3版)是一个可升级的，可固化的，基于优先级的实时内核。它对任务的个数无限制。uC/OS-III 是一个第3 代的系统内核，支持现代的实时内核所期待的大部分功能。例如资源管理，同步，任务间的通信等等。然而，uC/OS-III 提供的特色功能在其它的实时内核中是找不到的，比如说完备的运行时间测量性能，直接地发送信号或者消息到任务，任务可以同时等待多个内核对象等。

相比于uC/OS-II，删除和更新一些少用的功能，添加更加高效的功能和服务。其中最有用的功能就是时间片轮转法(round robin)，该功能是uC/OS-III特有的。uC/OS-III可同时用于32位处理器、16位处理器、8位处理器，软实时和硬实时。

uC/OS-III的应用范围很广，包括前后台系统、ISR中断服务例程等。实时内核是用于管理微处理器、微控制器或者数字信号处理器的时间及硬件资源的软件代码，负责管理这些任务，决定运行哪个任务，何时停止运行当前任务并切换到其他任务，这称为多任务管理。在多个顺序执行的任务代码切换时，CPU会根据uC/OS-III的管理而进行高效使用。

总之，uC/OS-III是一个功能强大且高效的实时操作系统，适用于各种需要高效率、实时响应和稳定性的应用场景。

us/OS-III移植到STM32F103上

uC/OS-III是一个可移植的实时操作系统，可以将其移植到不同的微处理器或微控制器上。

  • 硬件配置 ：首先，需要配置STM32F103的硬件，包括时钟、内存和其他硬件资源。这涉及到设置芯片的特定寄存器以及为操作系统提供必要的硬件接口。
  • 编译器和链接器：uC/OS-III需要使用特定的编译器和链接器来编译和链接操作系统的代码。在移植过程中，需要配置适当的编译器和链接器选项，以确保操作系统代码能够正确编译并在STM32F103上运行。
  • 中断处理：uC/OS-III需要处理STM32F103的中断。这包括配置中断控制器、注册中断服务程序（ISR）以及在操作系统中实现中断处理机制。
  • 任务调度：uC/OS-III需要实现任务调度功能，以便在STM32F103上管理和切换任务。这涉及到定义任务结构、任务堆栈和任务切换函数等。
  • 系统初始化：在移植过程中，需要对uC/OS-III进行初始化，包括设置系统时钟、内存管理等。此外，还需要配置操作系统的各种数据结构和变量，以便在STM32F103上正确运行。
  • 测试和调试：完成移植后，需要进行测试和调试，以确保uC/OS-III在STM32F103上正常运行并实现预期的功能。

三、工程创建

新建工程
在这里插入图片描述
选择芯片STM32F103C8T6
在这里插入图片描述
配置RCC
在这里插入图片描述
配置SYS
在这里插入图片描述
配置USART1
在这里插入图片描述
设置PA3，PC13作为两个LED灯的端口，将这两个端口配置为GPIO_OUTPUT
在这里插入图片描述
工程创建
在这里插入图片描述
在这里插入图片描述

四、移植

1.移植前准备

（1）可以进入 官网下载：https://www.silabs.com/developers/micrium

（2）也可以直接在下列网盘下载：
链接：https://pan.baidu.com/s/10RqsDRecbmVteWmDv2oUNQ
提取码：1234

打开下载好的文件，把下列文件复制到CubeMX工程中的MDK-ARM文件中去
在这里插入图片描述
在这里插入图片描述

2.移植过程

打开生成的keil文件，点击箱子，建立文件夹，将刚刚复制的文件添加到对应的文件夹里去。

在这里插入图片描述
（1）cU-BSP文件下添加下列文件

在这里插入图片描述
（2）cU-CONFIG文件下添加下列文件

在这里插入图片描述
（3）cU-CPU文件下添加下列文件

在这里插入图片描述
再选择cU-CPU\ARM-Cortex-M3\RealView路径下的这些文件

在这里插入图片描述
（4）cU-LIB文件下添加下列文件
在这里插入图片描述
再选择cU-LIB\Ports\ARM-Cortex-M3\RealView路径下的这些文件

在这里插入图片描述
(5)SOURCE文件下添加下列文件

在这里插入图片描述
（6）选择cCOS-III\Ports\ARM-Cortex-M3\GenericRealView路径下的这些文件

在这里插入图片描述
全部添加完毕后点击OK

在这里插入图片描述
（7）点击魔术棒，添加文件路径

在这里插入图片描述
在这里插入图片描述

五、代码编写

1.代码添加

在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

在bsp.c中添加下列代码

#ifndef  __BSP_H__
#define  __BSP_H__

#include "stm32f1xx_hal.h"

void BSP_Init(void);

#endif

2.代码修改

打开startup_stm32f103xb.s文件，在下列位置处进行修改：PendSV_Handler改为OS_CPU_PendSVHandler，
SysTick_Handler改为OS_CPU_SysTickHandler

在这里插入图片描述
在这里插入图片描述
打开app_cfg.h文件，在下列位置处进行修改：DEF_ENABLED 改为 DEF_DISABLED，#define APP_TRACE BSP_Ser_Printf 改为 #define APP_TRACE(void)

在这里插入图片描述
在这里插入图片描述
打开includes.h文件在下列位置处进行添加和修改：

在这里插入图片描述
将#include <stm32f10x_lib.h> 改为 #include “stm32f1xx_hal.h”
在这里插入图片描述
打开lib_cfg.h文件，将27改为5（该处宏定义设置堆空间的大小，STM32F103C8T6的RAM只有20K，所以要改小一点）

在这里插入图片描述
打开usart.c文件，添加代码完成printf重定向

/* USER CODE BEGIN 1 */

typedef struct __FILE FILE;
int fputc(int ch,FILE *f){
	HAL_UART_Transmit(&huart1,(uint8_t *)&ch,1,0xffff);
	return ch;
}

/* USER CODE END 1 */

在这里插入图片描述
在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);

}

在这里插入图片描述

修改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 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****/

点击魔法棒，勾选Use MicroLIB

在这里插入图片描述
编译成功

在这里插入图片描述

六、烧录运行

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

七、波形观察

在工程下新建一个debug.ini文件，在文件中写入下列内容

map 0x40000000, 0x40007FFF read write // APB1
map 0x40010000, 0x400157FF read write // APB2
map 0x40020000, 0x4007FFFF read write // AHB1
map 0x50000000, 0x50060BFF read write // AHB2
map 0x60000000, 0x60000FFF read write // AHB3
map 0xE0000000, 0xE00FFFFF read write // CORTEX-M4 internal peripherals

点击魔法棒进行设置

在这里插入图片描述
选择要观察的端口

在这里插入图片描述
设置完成后，点击运行等待运行一段时间后可观察到下列波形

在这里插入图片描述

八、总结

在本次实验中，我学习了有关嵌入式实时操作系统（RTOS）的知识：RTOS是一种实时性操作系统，能够在特定的硬件资源限制内执行多个任务，并对这些任务进行调度和管理。它能够实现多任务的并行执行、优先级管理、资源分配等功能，从而提高系统的整体性能和效率。
将uc/OS-III移植到stm32F103上，构建3个任务：其中两个task分别以1s和3s周期对LED等进行点亮-熄灭的控制；另外一个task以2s周期通过串口发送文字。通过上述任务，我练习了uc/OS-III的移植过程，移植过程不难，但注意一定要仔细，这次实验让我收获颇深！

参考

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

touyaaa
关注
  • 19
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
STM32F103CAT6的RTOS使用
weixin_54435584的博客
11-07 460
使用RTOS，制作一个同时闪烁LED与串口发送数据的程序
利用FreeRTOS在STM32中进行多线程操作（HAL库）
m0_70942404的博客
09-16 1293
如何创建多线程操作
基于stm32f103ze的freertos学习——cubemx配置与测试(1)
最新发布
xingmujia的博客
05-13 204
注意：这里的延时函数我用的是它给的，当然可以用vTaskDelay这个函数，记得用pdMS_TO_TICKS函数将时间转换为毫秒(使用其他延时函数可能导致阻塞)由上往下依次为：1.调用的函数 2.指定的命名 3.该任务调用的栈的深度 4.参数 5.任务优先级 6..句柄。然后用xTasCreat函数建立新的任务(箭头上面那行的是cubemx生成的自带进程)要先配置一下基本时钟源，这里原本默认的是滴答定时器，给它修改成定时器。在灯光闪亮的同时lcd中的数字进行叠加。我的测试程序是这样的。
基于FreeRTOS的stm32程序初始化底层搭建（hal库）
qq_45512097的博客
03-04 2492
采用嵌入式实时操作系统(RTOS)可以更合理、更有效地利用CPU的资源，简化应用软件的设计，缩短系统开发时间，更好地保证系统的实时性和可靠性。 **FreeRTOS是一个迷你的实时操作系统内核。作为一个轻量级的操作系统，功能包括：任务管理、时间管理、信号量、消息队列、内存管理、记录功能、软件定时器、协程等，可基本满足较小系统的需要。**而且最重要的一点，freertos完全免费，而且非常方便移植，...
STM32基于HAL库和STM32CubeMX的实时操作系统FreeRtOS开发
weixin_48503637的博客
01-31 1402
在 FreeRTOS 中， 使用的数据类型虽然都是标准 C 里面的数据类型，但是针对不同的处理器，对标准 C 的数据类型又进行了重定义，给它们取了一个新的名字， 比如 char 重新定义了一个名字 portCHAR， 这里面的 port 表示接口的意思，就是 FreeRTOS 要移植到这些处理器上需要这些接口文件来把它们连接在一起。相比前后台系统，多任务系统的事件响应也是在中断中完成的，但是事件的处理是在任务中完成的。当一个紧急的事件在中断被标记之后，如果事件对应的任务的优先级足够高，就会立马得到响应。
HAL库 FreeRTOS学习笔记
Deheng_Kong的博客
07-30 393
1、前言 我学习FreeRTOS已经有一段时间了，学习周期也比较长，在这里讲一讲我的理解和学习方法。 环境配置 STM32CubeMX 5.6.0 Keil MDK 5.33 NUCLEO STM32F411RETx 2、FreeRTOS简介 在学习一个新东西前一定要把最基础的原理搞懂，然后在去学着如何取运用，所以首先让我们了解什么是FreeRTOS，以及FreeRTOS的框架和运用。 FreeRTOS是一种实时操作系统，实时就是展现了此系统处理具有及时性，这一点在学习FreeRTOS是也是展现的淋漓尽致，
HAL库STM32F103C8T6 IAP升级实验程序
10-15
HAL库STM32F103C8T6 IAP升级实验程序 HAL库STM32F103C8T6 IAP升级实验程序 HAL库STM32F103C8T6 IAP升级实验程序 HAL库STM32F103C8T6 IAP升级实验程序 HAL库STM32F103C8T6 IAP升级实验程序 HAL库STM32F103C8T6 IAP...
STM32F103RCT6程序移植至GD32F103RCT6（HAL+RTOS）
04-18
关于STMF32103RCT6程序移植至GD32F103RCT6，并且使用了HAL+RTOS资源。大概需要修改四处地方，如频率、CAN通讯、内存地址、FLASH。其余像UART、IIC、SPI是不需要修改的。具体可以看看问题。测试完全可用。
基于HAL库STM32F103创建工程例程.rar
06-14
基于HAL库STM32F103创建工程例程
U盘读卡器-基于HAL库STM32F103C8
12-08
本例程基于STM32F103C8，使用PA4 5 6 7 SPI对接外部FLASH，实现读卡器功能。FLASH为fm25w1283,可运行。注意，使用该例程前，需要确保SPI和FLASH可通信，且接线正确。
基于HAL库STM32F103创建工程例程.zip
06-27
基于HAL库STM32F103创建工程例程BSP中放CubeMX生成的外设配置文件 System中放通用的驱动程序 User中放用户自己编写的应用程序
STM32F103 HAL库版FreeRTOS
qq_66258329的博客
06-11 1009
STM32CubeMX生成FreeRTOS
嵌入式实时操作系统（RTOS）,以uc/OS-III为例，将其移植到stm32F103上
liuwei1015的博客
11-29 2275
RT-thread Nano或FreeRTOS的移植相比自己手动移植简单，大大提高了效率，但手动移植锻炼自己的细心。
将uc/OS-III移植到stm32F103上的嵌入式实时操作系统（RTOS）-HAL库
qq_65424589的博客
11-28 1534
uC/OS-III是一款高效、可移植、可裁剪的实时嵌入式操作系统，STM32F103C8T6是基于HAL库的微控制器。实操过程中，首先需要在STM32F103C8T6上移植uC/OS-III操作系统，然后使用逻辑分析仪抓取波形进行协议分析。通过这个过程，可以深入了解uC/OS-III的操作过程，以及如何在微控制器上实现基于操作系统的开发。同时，通过逻辑分析仪抓取的波形数据，可以进一步进行协议分析，对于研究嵌入式系统的通信协议具有重要意义。
嵌入式实时操作系统,将uc/OS-III移植到stm32F103上，构建3个任务。并使用Keil虚拟仿真逻辑仪抓取LED输出电平和串口通信的波形
SS_SS_SSS_SSS的博客
12-02 1017
一.准备uC/OS-III源码 链接：百度网盘 请输入提取码 提取码：qwer 下载后打开目录如下，然后新创建文件夹uC-BSP和uC-CONFIG 二.建立STM32F103C8T6HAL库 1.点击System Core，双击SYS，在Debug里选Serial Wire 2.点击System Core，双击RCC，在High Speed Clock（HSE）里选Crystal/Ceramic Resonator 3.将Clock Configuration从HSI设为PLLO.
STM32F103C8T6移植ucOS并构建三个任务
风起鹤归
11-08 630
本篇博客主要是学习嵌入式实时操作系统（RTOS）,以uc/OS为例，将其移植到stm32F103上，构建至少3个任务（task）:其中两个task分别以1s和3s周期对LED等进行点亮-熄灭的控制；另外一个task以2s周期通过串口发送“hello uc/OS!欢迎来到RTOS多任务环境！”。记录详细的移植过程。本次实验步骤较多，较为繁琐，跟着步骤一步一步来，不能急躁，一定要细心，特别是移植的时候添加文件一定要仔细。
STM32F103C8T6移植uCOS基于HAL库
weixin_59156930的博客
11-07 169
在经过查阅资料和请教同学的情况下，动手做出了实验，受益匪浅！
嵌入式系统基础A就9周作业
qq_52001155的博客
11-07 147
嵌入式系统基础第9周作业
基于stm32F103（keil5）移植FreeRTOS(202112.00版本)
m0_57575318的博客
06-07 2021
基于STM32F103系列（keil5）的最新FreeRTOS移植（202112.00版本）
基于hal库 用stm32f103 实现电压采集程序
05-18
下面是一个基于HAL库的STM32F103电压采集程序示例： ```c #include "stm32f1xx_hal.h" ADC_HandleTypeDef hadc1; void SystemClock_Config(void); static void MX_GPIO_Init(void); static void MX_ADC1_Init...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值