手把手教你STM32F103C8移植uCOSIII（HAL库/CubeMX）

原创 于 2025-11-13 00:33:05 发布 · 980 阅读 · 26 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#stm32 #嵌入式硬件 #单片机

一、获取uC/OS-III源码

1.官方下载（不推荐）

进入 Micrium 公司官网下载中心：Micrium Examples - Weston Embedded Solutions

但官网下载需要注册账号，且一般的邮箱不可以使用，这里推荐使用野火的模板例程Embedfire-ucos/ebf_ucos_tutorial_code_2_stm32f103_zhinanzhe: 野火开源图书/[野火]《uCOS-III 内核实现与应用开发实战》/配套代码/第二部分/F103_指南者

这三个文件夹就是我们需要的文件夹

二、建立stm32 hal库工程

打开stm32 cubeMX，选择芯片stm32f103c8，配置系统时钟为72M，作为移植测试，将与LED相连的两个端口PC13，PA2配置为GPIO_Output，用于两个LEDtask，配置PB9,PB10为串口，用于串口task。

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

在生成的keil工程文件夹中新建一个 UCOSIII 的文件夹，将我们下载的源代码中三个文件夹： Uc-CPU、 uC-LIB、 Ucos-III 复制到我们新建的文件夹中：

在Core/Src文件夹下新建一个OS文件夹

将刚才下载源码打开，将路径：\ebf_ucos_tutorial_code_2_stm32f103_zhinanzhe-master\16- 移植 uCOS-III 到 STM32\uCOS III 工程模板\User\APP 下的文件：
app.c 、 app_cfg.h 、 cpu_cfg.h 、 includes.h 、 lib_cfg.h 、 os_app_hooks.c 、os_app_hook.h、os_cfg.h、os_cfg_app.h复制到上一步建立的OS文件夹中，同时新建三个空白文件： bsp.c、bsp.h、app.h

四、添加工程组件和头文件路径

1. 添加工程分组

打开工程， 按照如图所示添加六个新的组： bsp、uCOSIII_CPU、 uCOSIII_LIB、 uCOSIII_Ports、 uCOSIII_Source、 OS_cfg

2. 添加文件到分组

文件目录是： Src/OS，将其中 bsp.c 和 bsp.h文件添加至 bsp 组中，将 app.c 添加进 Application/User 组中

uCOSIII_CPU 组件， 点击 Add Files…按钮，将文件目录跳转至： UCOSIII/uC-CPU， 选择 ALL files 文件类型，将其中的三个文件点击 Add 添加， 然后再打开： ARM-Cortex-M3\RealView， 同样选择 ALL files 文件类型，将三个文件添加进 uCOSIII_CPU 组

添加 uCOSIII_LIB 组件文件：选择 uCOSIII_LIB 组，点击 Add Files…按钮， 将文件目录跳转至： UCOSIII/uCLIB，选择 ALL files 文件类型，将其中的九个文件添加进 uCOSIII_LIB 组；然后继续打开： Ports/ARM-Cortex-M3/Realview， 添加 lib_mem_a.asm 文件选择 uCOSIII_Ports 组，点击 Add Files…按钮， 将文件目录调整至： UCOSIII/UcosIII/Ports/RAM-Cortex-M3/Generic/RealView。选择 ALL files 文件类型， 将其中三个文件添加进 uCOSIII_Ports 组选择uCOSIII_Sourc组，点击Add Files…按钮， 将文件目录调整至： UCOSIII/UcosIII/Source。选择 ALL files 文件类型， 将其中二十个文件添加进 uCOSIII_Sourc 组

选择 OS_cfg 组，点击 Add Files…按钮， 将文件目录调整至： Src/OS。选择 ALLfiles 文件类型， 将图中的八个文件添加进 uCOSIII_Sourc 组

3. 添加头文件路径

五、修改文件内容

1. 启动文件 startup_stm32f103xb.s

2. app_cfg.h

3. includes.h

4. 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
5. app.c和app.h
// app.c
#include <includes.h>

// app.h
#ifndef  __APP_H__
#define  __APP_H__

#include <includes.h>

#endif /* __APP_H__ */
6. main.c

在main.c中编写任务实现PC13为板载LED灯以1s为周期闪烁，串口以2s为周期发送，PA2为第二个LED灯以3S为周期发送。

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "gpio.h"
#include "usart.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 START_TASK_PRIO		3
#define LED0_TASK_PRIO		4
#define LED2_TASK_PRIO		5       // PA2 LED（3s周期）
#define LED1_TASK_PRIO		6
#define FLOAT_TASK_PRIO		7

/* 任务堆栈大小	*/
#define START_STK_SIZE 		256
#define LED0_STK_SIZE 		128
#define LED1_STK_SIZE 		128
#define LED2_STK_SIZE 		128
#define FLOAT_STK_SIZE		128

/* 任务栈 */	
CPU_STK START_TASK_STK[START_STK_SIZE];
CPU_STK LED0_TASK_STK[LED0_STK_SIZE];
CPU_STK LED1_TASK_STK[LED1_STK_SIZE];
CPU_STK LED2_TASK_STK[LED2_STK_SIZE];  // PA2 LED任务栈
/* 任务控制块 */
OS_TCB StartTaskTCB;
OS_TCB Led0TaskTCB;
OS_TCB Led1TaskTCB;
OS_TCB Led2TaskTCB;  // PA2 LED任务
OS_TCB FloatTaskTCB;
/* 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 led_pa2(void *p_arg);     // PA2 LED（3s周期）
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;
	
  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	* )"led1 task", 		
                 (OS_TASK_PTR )send_msg, 			
                 (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);
				 
    	/* 创建PA2 LED任务（3s周期） */
	OSTaskCreate((OS_TCB 	* )&Led2TaskTCB,		
				 (CPU_CHAR	* )"led_pa2", 		
                 (OS_TASK_PTR )led_pa2, 			
                 (void		* )0,					
                 (OS_PRIO	  )LED2_TASK_PRIO,     	
                 (CPU_STK   * )&LED2_TASK_STK[0],	
                 (CPU_STK_SIZE)LED2_STK_SIZE/10,	
                 (CPU_STK_SIZE)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);
	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 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 */
}
/**
  * @brief PA2 LED任务：3s周期闪烁（亮1.5s+灭1.5s）
  * @param p_arg: 任务参数（未使用）
  */
static void led_pa2 (void *p_arg)
{
  OS_ERR      err;
  (void)p_arg;

  while (DEF_TRUE)  // 任务主循环（永不退出）
  {
		HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, GPIO_PIN_RESET);  // 点亮PA2 LED（低电平）
		OSTimeDlyHMSM(0, 0, 1, 500, OS_OPT_TIME_HMSM_STRICT, &err);  // 延时1.5s
		HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, GPIO_PIN_SET);    // 熄灭PA2 LED（高电平）
		OSTimeDlyHMSM(0, 0, 1, 500, OS_OPT_TIME_HMSM_STRICT, &err);  // 再延时1.5s（总周期3s）
  }
}

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

实验结果：

APPLE_PIE07
关注
基于STM32F103的HAL库手动配置FreeRTOS
weixin_44098974的博客
05-28 1516
基于STM32F103的HAL库手动配置FreeRTOS
基于STM32F103HAL库移植FreeRTOS移植实操 （一）
cairongshou的博客
06-11 5205
二、FreeRTOS手把手移植 1.生成HAL库工程 2.添加FreeRTOS源码文件到工程目录下 3.添加FreeRTOS源码到工程中 4.添加FreeRTOSConfig.h 5.修改Systick中断、SVC中断、PendSV中断 6.添加应用程序：验证移植是否成功。
uC/OS-III 内核实现与应用开发实战学习（一）
Eterlove的博客
01-10 1790
我们所说的堆栈其实是两个东西，分别是堆和栈，当然如果有人给你说起堆栈这个名词，那他想要表达的一定是栈这个概念。除了放置全局变量是在堆区，其他像局部变量全部分配在栈区，栈是由高地址向低地址生长的。这一点与堆不一样，堆由低地址向高地址生长。 全局变量由编译器分配堆空间，除了堆和栈来分配内存空间的方式，还有一种动态内存的方式，就是用malloc函数动态分配内存和free释放内存做到。 在单片机中，有内存的地方就是RAM和Flash
STM32初识HAL库
Caramel_biscuit的博客
05-25 889
Cube固件包Drivers驱动源码文件夹下Device和Include文件夹的关键文件介绍stm32f1xx.h：是所有F1系列的顶层头文件，通过条件编译来包含某个芯片的头文件，定义通用的枚举类型，定义通用的宏定义。stm32f103ex.h：大容量的stm32f103头文件，包含：中断编号定义、外设寄存器结构体定义、寄存器映射、寄存器位定义、外设判定。
带你快速上手STM32F103的HAL库开发--keil版
weixin_51134453的博客
06-11 4671
HAL库的好处：初级开发者不需要太仔细阅读芯片手册；封闭性较好；开发速度较快坏处：你需要去阅读HAL库文件的函数，英文备注很烧脑，甚至你会觉得他的算法比较抽象；代码量太大，占内存，优化不是很好。推荐还是需要仔细去看stm32f1xx.h 了解其中结构体数据类型有哪些 然后从寄存器的角度去看待HAL库函数做了些什么。
手把手教你STM32F103C8移植uCOSII（HAL库）并实现多任务（完美避坑版）
YouthBlood9的博客
12-03 3101
录一、CubeMX构建项目二、准备uCOSII2.1 下载uCOSII源码2.2 文件准备2.2.1 源码中文件改动三、移植uCOSII四、修改代码五、实现三个任务小小的总结参考文献 一、CubeMX构建项目 新建项目 配置RCC 配置SYS 设置串口USART1 时钟 配置工程 在Keil中打开该工程，在main函数中的while循环里添加语句： while (1) { /* USER CODE END WHILE */ /* USER CO
STM32F103C8T6使用HAL库驱动DHT11温湿度传感器
06-05
DHT11温湿度传感器使用说明： https://blog.youkuaiyun.com/mcu_fang/article/details/124686729 IO口操作为HAL库生成，读IO口时未使用while死等，DHT11温湿度传感器未连接时也不会造成程序死机，本驱动可移值至其它单片机
STM32手把手教你移植UCOSII系统
08-31
《STM32手把手教你移植UCOSII系统》是一篇深度教程，主要针对嵌入式开发者，特别是那些希望在STM32微控制器上部署实时操作系统（RTOS）UCOSII的初学者。STM32是意法半导体（STMicroelectronics）推出的一系列基于ARM...
STM32f103C8T6移植正点原子工程
w_150831的博客
06-16 852
STM32f103C8T6移植正点原子工程
Stm32f103c8t6驱动JX90614红外测温传感器
最新发布
qq_44465154的博客
04-07 1208
基于Stm32f103c8t6使用IIC驱动JX90614红外测温传感器
ucosiii和emXGUI移植到野火RT1052开发板
01-30
ucosiii和emXGUI移植到野火RT1052开发板,例程是用野火例子改的，测试OK
【STM32】STM32F103ZET6 创建工程模版详解(HAL库)
C/C++软件工程师、嵌入式软件工程师、物联网研发工程师、C/C++讲师、物联网讲师、嵌入式讲师、鸿蒙讲师---欢迎大家一起交流(私信添加博主微信)
07-10 3586
HAL库，全称为Hardware Abstraction Layer（硬件抽象层）库，是STMicroelectronics（ST）为STM32微控制器提供的较新的固件库。HAL库的定义与特点定义：HAL库是一个中间件，为应用程序和硬件之间提供了一个接口，允许开发者在不知道底层硬件细节的情况下编写控制硬件的代码。特点跨平台支持：HAL库支持STM32全系列微控制器，使得开发者编写的代码可以在不同的STM32产品之间移植。结构统一：为所有外设提供统一的API和驱动结构，简化了开发过程。易于使用。
STM32F103 HAL库基本使用（一）
青烨慕容
08-02 4832
STM32F103 HAL库基本使用系列的 全部博客是我重新学习HAL库的学习记录，仅作为学习记录。其中使用了正点原子Mini开发板和正点原子HAL库Demo，详细的资料请观看正点原子官网。
STM32F103_HAL库CubeMX工程配置
qq_51688022的博客
10-29 380
本文详细讲述了如果进行STM32F103芯片的工程配置
【STM32+CubeMX+HAL库教程】 新建一个工程(STM32F103)
qq_49053936的博客
12-28 4061
注意：目前F103系列，常用8MHz晶振，也有用25MHz晶振的板子，要注意查看。其下，有常用的main.c、it.c等文件，双击其中文件，即可在代码编辑区中打开进行编辑。如果，在CubeMX配置时，使用了中文路径、名称，就会出再各种错误，如缺少启动文件等。注意：1、3两项，要填写实物晶振值，可以查看晶振上丝印， 也可以查看原理图。注意：如果设置的工程存放目录有中文，弹出的窗体就有点区别了，建议修改配置。必须养成习惯，新建工程，进入配置后，先配置Debgu, 即调试模式。
【正点原子STM32连载】 第七章 认识HAL库 摘自【正点原子】STM32F103 战舰开发指南V1.2
weixin_55796564的博客
05-09 1470
1）实验平台：正点原子stm32f103战舰开发板V4 2）平台购买地址：https://detail.tmall.com/item.htm?id=609294757420 3）全套实验源码+手册+视频下载地址： http://www.openedv.com/thread-340252-1-1.htmlHAL，英文全称Hardware Abstraction Layer，即硬件抽象层。HAL库是ST公司提供的外设驱动代码的驱动库，用户只需要调用库的API函数，便可间接配置寄存器。我们要写程序控制STM32芯
STM32——STM32F103时钟解析（正点原子资料+HAL库代码分析）
老王的博客
11-16 4433
上次写系统时钟解析的时候说出一篇103的时钟解析，我就整理HAL库开发的正点的资料，给小白梳理，我也是小白，不做权威使用。
uCOS-III内核与应用开发实战详解
weixin_42181686的博客
03-19 913
uCOS-III内核是高度模块化的实时操作系统内核，它被设计为支持对实时性要求极高的嵌入式系统应用。该内核能为任务分配不同的优先级，并在这些任务之间进行有效的调度，以保证高优先级任务能及时获得处理时间。在uCOS-III中，任务间同步可以通过以下几种机制实现：信号量（Semaphores）：用于同步和互斥访问共享资源。互斥锁（Mutexes）：专门用于保护共享资源的同步机制。消息邮箱（Mailboxes）：用于任务之间的信息传递。
STM32F103C8移植FreeRTOS与HAL库实践指南
本压缩包“FreeRTOS-STM32F103C8-HAL.zip”包含了将FreeRTOS操作系统移植到使用STM32 HAL库的STM32F103C8微控制器上的相关文件。具体操作通常包括以下几个步骤： 1. **环境准备**：首先需要安装Keil uVision、STM32...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值