【stm32】STM32F103C8T6移植uCOS基于HAL库

最新推荐文章于 2024-06-19 12:24:12 发布
最新推荐文章于 2024-06-19 12:24:12 发布
阅读量286 收藏
点赞数
文章标签： stm32 嵌入式硬件 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29536813/article/details/134556041
版权

文章目录

一、UCOSIII简单介绍

UCOS是Micrium公司出品的RTOS类实时操作系统， UCOS目前有两个版本：UCOSII和UCOSIII。

UCOSIII是一个可裁剪、可剥夺型的多任务内核，而且没有任务数限制，提供了实时操作系统所需的所有功能，包括资源管理、同步、任务通信等。

UCOSIII是用C和汇编来写的，其中绝大部分都是用C语言编写的，只有极少数的与处理器密切相关的部分代码才是用汇编写的， UCOSIII结构简洁，可读性很强！非常适合初次接触嵌入式实时操作系统学生、嵌入式系统开发人员和爱好者学习。

什么是任务？

任务（线程）是简单的程序。单CPU 中，在任何时刻只能是一个任务被执行。
任务看起来像C 函数。在大多数嵌入式系统中，任务通常是无限循环的。任务不能像C 函数那样，它是不能return 的。

在UCOSIII中任务是以何种面貌存在的呢？

在UCOSIII中任务就是程序实体，UCOSIII能够管理和调度这些小任务（程序）。UCOSIII中的任务由三部分组成：任务堆栈、任务控制块和任务函数。

任务堆栈上下文切换的时候用来保存任务的工作环境，就是STM32的内部寄存器值。
上下文切换的时候用来保存任务的工作环境，就是STM32的内部寄存器值。
任务堆栈是任务的重要部分，堆栈是在RAM中按照“先进先出（FIFO）”的原则组织的一块连续的存储空间。为了满足任务切换和响应中断时保存CPU寄存器中的内容及任务调用其它函数时的需要，每个任务都应该有自己的堆栈。
任务如何才能切换回上一个任务并且还能接着从上次被中断的地方开始运行？

恢复现场即可，现场就是CPU的内部各个寄存器。因此在创建一个新任务时，必须把系统启动这个任务时所需的CPU各个寄存器初始值事先存放在任务堆栈中。这样当任务获得CPU使用权时，就把任务堆栈的内容复制到CPU的各个寄存器，从而可以任务顺利地启动并运行。

把任务初始数据存放到任务堆栈的工作就叫做任务堆栈的初始化，UCOSIII提供了完成堆栈初始化的函数：OSTaskStkInit()。

当然，用户一般不会直接操作堆栈初始化函数，任务堆栈初始化函数由任务创建函数OSTaskCreate()调用。不同的CPU对于的寄存器和对堆栈的操作方式不同，因此在移植UCOSIII的时候需要用户根据各自所选的CPU来编写任务堆栈初始化函数。
任务控制块：任务控制块用来记录任务的各个属性。
任务控制块是用来记录与任务相关的信息的数据结构，每个任务都要有自己的任务控制块。我们使用OSTaskCreate()函数来创建任务的时候就会给任务分配一个任务控制块。任务控制块由用户自行创建。
*USOCIII提供了用于任务控制块初始化的函数：OS_TaskInitTCB()。**但是，用户不需要自行初始化任务控制块。因为和任务堆栈初始化函数一样，函数OSTaskCreate()在创建任务的时候会对任务的任务控制块进行初始化

任务函数由用户编写的任务处理代码，是实实在在干活的，任务函数通常是一个无限循环，也可以是一个只执行一次的任务。任务的参数是一个void类型的，可以可以传递不同类型的数据甚至是函数。
任务函数其实就是一个C语言的函数，但是在使用UCOIII的情况下这个函数不能有用户自行调用，任务函数何时执行执行，何时停止完全有操作系统来控制。

UCOSIII支持时间片轮转调度，因此在一个优先级下会有多个任务，那么我们就要对这些任务做一个管理，这里使用OSRdyList[]数组管理这些任务。

OSRdyList[]数组中的每个元素对应一个优先级，比如OSRdyList[0]就用来管理优先级0下的所有任务。OSRdyList[0]为OS_RDY_LIST类型，从上面OS_RDY_LIST结构体可以看到成员变量：HeadPtr和TailPtr分别指向OS_TCB，我们知道OS_TCB是可以用来构造链表的，因此同一个优先级下的所有任务是通过链表来管理的，HeadPtr和TailPtr分别指向这个链表的头和尾，NbrEntries用来记录此优先级下的任务数量，图5.5.2表示了优先级4现在有3个任务时候的就绪任务列表。

同一优先级下如果有多个任务的话最先运行的永远是HeadPtr所指向的任务
在这里插入图片描述

二、实验过程

1.创建CubxMX工程

打开CubeMX软件选择STM32F103C8T6芯片
在这里插入图片描述
配置RCC
在这里插入图片描述
配置SYS
在这里插入图片描述
配置串口
在这里插入图片描述
将PC13和PA3配置输出
在这里插入图片描述
配置晶振72
在这里插入图片描述
配置工程
在这里插入图片描述
在这里插入图片描述

2.下载UCOSIII文件

链接：https://pan.baidu.com/s/11xTQoNY9vLX6IXjDigvYyA?pwd=1234
提取码：1234

将下面6个文件解压
在这里插入图片描述
创建
BSP ，CONFIG， CPU ，LIB，PORT，SOURCE文件夹
在这里插入图片描述
打开uC-CPU文件夹将下面的3个.c.h文件复制到刚刚新建的CPU文件中
在这里插入图片描述

点击第一个文件夹可以看到RealView点击进去
在这里插入图片描述
将这3个文件也复制到自己新建的CPU文件夹中
在这里插入图片描述
此时打开CPU文件夹可以看到
在这里插入图片描述
打开uC-CONFIG文件夹
将下面这些文件复制到自己建立的CONFIG文件夹
在这里插入图片描述
可以看到CONFIG文件夹里有
在这里插入图片描述
打开uC-BSP文件夹将下列俩个文件复制到自己建立的BSP文件夹中
在这里插入图片描述
自己建立的文件夹中有
在这里插入图片描述
打开uC-LIB文件夹复制全部.c.h文件

在这里插入图片描述
点击Ports文件夹里面有点击RealView，复制下列文件
在这里插入图片描述
将这些全部复制到自己建立的LIB文件
LIB文件里有
在这里插入图片描述

打开uC-COSIII文件中的PORT中RealView
复制下列文件到自己建立的PORT文件夹
在这里插入图片描述

自己PORT的文件夹
在这里插入图片描述

打开uC-COSIII中的SOURCE
在这里插入图片描述
复制全部文件到自己的SOURCE文件夹中

到这里需要的文件已经配置完成。

三、kiel配置

方法一：打开工程文件
点击
在这里插入图片描述

创建下列文件夹
在这里插入图片描述
然后添加刚刚复制的文件夹（这种方法容易死机就不演示了）

因为上面那种方法容易死机
则利用上面那种方法建立文件夹
文件夹建立完成后可以看到下面6个文件夹
在这里插入图片描述
点击CPU文件夹右击添加已存在的文件

在这里插入图片描述
点击CPU(需要找到目前工程文件目录下，就是刚刚建立6个文件夹的目录)
在这里插入图片描述
点击全部文件然后全选，添加
在这里插入图片描述
下列也是同理添加文件
在这里插入图片描述
添加LIB文件
在这里插入图片描述
添加CONFIG文件
在这里插入图片描述
添加BSP文件
在这里插入图片描述
添加PORT文件
在这里插入图片描述
添加SOURCE文件
在这里插入图片描述

这里全部文件添加成功

点击魔术棒
在这里插入图片描述

点击添加文件路径
在这里插入图片描述
找到刚刚建立的文件夹添加下面六个文件路径
在这里插入图片描述

添加完成后编译此时会有俩个错误

四、添加代码

1.为bsp.c和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

2.修改部分文件相关代码

打开startup_stm32f103xb.s文件
在以下位置处将PendSV_Handler改为OS_CPU_PendSVHandler，
SysTick_Handler改为OS_CPU_SysTickHandler
在这里插入图片描述
在这里插入图片描述

3.打开app_cfg.h文件

DEF_ENABLED 改为 DEF_DISABLED

在这里插入图片描述
#define APP_TRACE BSP_Ser_Printf 改为 #define APP_TRACE(void)
在这里插入图片描述

4.打开includes.h文件

在#include <bsp.h>下面添加 #include “gpio.h” #include “app_cfg.h”
将#include <stm32f10x_lib.h> 改为 #include “stm32f1xx_hal.h”

在这里插入图片描述

5.打开lib_cfg.h文件

修改为5（该处宏定义设置堆空间的大小，STM32F103C8T6的RAM只有20K，所以要改小一点）
在这里插入图片描述

6.打开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 */

7.初始化引脚

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

}

8.撰写主函数

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

在这里插入图片描述

五、实验结果

PTOS

六、总结

如果我们需要处理器完成的任务比较单一，可以不使用操作系统；
如果需要处理器完成的任务比较多，为了便于管理可以引入轻巧的实时操作系统。
在进行uCOS移植时，务必要仔细，否则在编译时很容易报一大堆错误，究其原因只是因为在移植过程中某一个步骤忘记了，参数、文件路径的设置等问题，务必谨慎！
逻辑分析仪是一个较好的波形分析设备，操作并不困难。
整个实验过程并不复杂，只需要按部就班的进行即可完成移植和任务执行。

在文件添加过程中一定要仔细，一不小心就加错了，加重复了，代码编译不报错，但不能运行，很大可能是参数配置的问题。

要成为大佬^
关注
stm32f103c8t6基于hal库的uCOSIII-版本
02-01
在"stm32f103c8t6基于hal库的uCOSIII_版本"中，开发者可能已经预先配置好了HAL库与uC/OS-III的集成，包括任务的创建、中断处理、硬件初始化等功能。这个版本应该是为了方便初学者或者项目快速开发而准备的，因为它被...
STM32基于HAL库移植UCOS-III教程
weixin_57356056的博客
06-08 1242
STM32基于HAL库移植uCOS-III教程
STM32 + UCOSII 操作系统（简单讲解）
weixin_50641310的博客
11-04 9891
前言 这是我将UCOSII操作系统移植在STM32单片机上后进行UCOSII操作系统学习的一些笔记与理解，此文最后会附上我自己在UCOSII操作系统下使用STM32写的ESP8266+onenet+http协议的程序链接，可以作为参考，如果文中有不当的地方，还请各位大佬加以中指正，我一定会虚心求教。参考资料：正点原子RTOS操作系统讲解，参考的文章：(53条消息) STM32学习笔记一一UCOSII（1）_霁风AI-CSDN博客_ucosii 1.UCOSII操作系统的简介 前台后台系统 相信大家都
HAL库配置DMA ADC 基于 STM32F103C8
最新发布
ly_link的博客
06-19 580
首先要把Number Of Conversion更改为2，因为我们只启用了两个通道。选择开发单片机的型号，我们用的型号是STM32F103C8T6。配置ADC引脚，我们这里选择的是ADC1，IN4，IN5。注意：这里是一个坑见下图红色圈起来部分，非常容易踩到。开始运行，查看watch1中已有adc的两路数据了。再次编译代码，启动调试。设置工程名称、工程导出路径和IDE工具。时钟配置，我们只需配置为外部高速时钟。图 10Watch1中监视的ADC数据。等几秒中后，弹出工程配置界面。打开工程后先编译一下。
全网最简单的stm32f103c8t6移植ucosiii教程（附移植好的工程）
qq_45290757的博客
04-16 5587
最近在做一个机器人项目，需要使用到stm32f103c8t6核心板。考虑程序中的多任务特性，因此决定使用ucosiii用于多任务管理。ucosiii移植可能对于一些嵌入式老鸟来说，可能是信手拈来，但是对于很多新手特别是刚入门的小白来说还是有一定的难度的。尤其是全网的移植教程过于杂乱良莠不齐，甚至有些博主将移植好的工程设置为付费下载。这里决定分享下我的移植过程，并在最后附上工程模板以供学习和参考。
基于STM32F103C8T6--通过HAL库实现STM32的ADC+DMA
热门推荐
zxs865的博客
03-10 1万+
一、ADC简介 12位ADC是一种逐次逼近型模拟数字转换器。它有多达18个通道，可测量16个外部和2个内部信号源。各通道的A/D转换可以单次、连续、扫描或间断模式执行。 ADC的结果可以左对齐或右对齐方式存储在16位数据寄存器中。 ADC的输入时钟不得超过14MHz，它是由PCLK2经分频产生。 二、ADC通道选择 STM32 的 ADC 多达 18 个通道，其中外部的 16 个通道就是框图中的 ADCx_IN0、ADCx_IN1…ADCx_IN5。这 16 个通道对应着不同的 IO 口，具体是哪一个 IO
STM32F103C8T6+UCOSII+LED闪烁
06-11
"STM32F103C8T6+UCOSII+LED闪烁"这个项目是基于STM32F103C8T6芯片，采用UCOSII实时操作系统进行的简单LED灯闪烁示例。 UCOSII，全称为uC/OS-II，是由Micrium公司开发的一款开源、可移植的嵌入式实时操作系统。它...
stm32f103c8移植UCOSIII单任务演示
02-23
2. **初始化设置**：在工程中，需要包含STM32F103C8的启动文件（startup_stm32f10x_md.s）和HAL库（如果使用），以便进行中断向量表设置、时钟配置以及内存映射等基本操作。 3. **UCOSIII内核代码**：下载UCOSIII的...
基于stm32f103c8t6固件库ucosiii操作系统的移植模板
02-08
将UCOSIII移植到STM32F103C8T6上，可以显著提升系统的复杂性和效率，使其能够执行更复杂的任务。 在移植过程中，我们首先需要准备STM32的固件库。固件库是ST提供的软件框架，包含了针对STM32系列微控制器的HAL...
stm32f103c8t6移植uC/OS-III基于HAL库的工程下载
04-15
总之，STM32F103C8T6移植uC/OS-III基于HAL库的工程是一个综合了嵌入式系统、RTOS和特定芯片驱动程序开发的过程。通过这样的实践，开发者可以深入理解RTOS的运行机制以及如何有效地利用HAL库简化开发工作。
stm32入门学习（基于STM32F103C8T6）
V85042的博客
03-24 6100
じゃ、始めましょう。--最近在学外语，对于IT从业者来说，会是一项优势。
STM32F103C8T6移植uCOS基于HAL库
jynyyhd的博客
11-05 314
通过本次学习，掌握了嵌入式实时操作系统UC/OS的基本原理，以及通过STM32F103C8T6移植UC/OS来实现LED周期点亮及串口数据周期发送的实验过程；本次实验总体不太困难，但是非常繁琐，一不小心就会出现错误。同时能感觉到文件容量变大了，这一变化在代码烧录时，就可以明显的观察到！
stm32f103C8T6移植uc/OS-III实时操作系统
m0_70536801的博客
01-16 1516
3种物联网操作系统：Huawei LiteOS、Amazon FreeRTOS和RT-ThreadRTOS全称为：Real Time OS，就是实时操作系统，强调的是：实时性。实时操作系统又分为硬实时和软实时。硬实时要求在规定的时间内必须完成操作 ，硬实时系统不允许超时，在软实时里面处理过程超时的后果就没有那么严格。RTOS操作系统：UCOS，FreeRTOS，RTX，RT-Thread，DJYOS等。
STM32F103c8t6_hal库建工程
m0_62181798的博客
02-25 1715
STM32F1_HAL库建工程，内容很详细，隔壁村的糟老头子都会
HAL库新建工程（STM32F103C8T6）
qq_53338155的博客
12-28 894
5.找到内核文件，复制以下文件夹中的内容到工程文件夹startup下。6找到system相关文件，复制到工程文件夹startup下。4.Library下保存HAL库中 .c 和 .h文件。需要修改conf文件，去掉后面的template。至此startup文件内容添加完成。10.添加工程文件和必要的路径。
STM32F103C8T6 GY30光强传感器模块 IIC通讯 HAL库（学习记录）
weixin_53925604的博客
01-27 1986
三年以来一直想写博客记录一下自己的成长，但是其实本人真的对于写文章没有一丝好感，但是学习过程中发现，不做记录的话，确实是学点忘点，自己做过的项目也不能一下子就想起来，很多东西也是一概而论的学，学的不精细，因此有了开始写博客的想法。对于IIC的学习，本次采用的是较为简单的模块，之前对于IIC，只是停留在了会用的层面，从来没有想过去理解一下IIC具体是怎么工作的，但是由于毕设需要用到IIC通讯的传感器，因此决定洗心革面，仔细学习一下IIC。因此在初始化时，需要对GY30写入数据0x01和0x10。
ucOS-II在STM32F1移植
weixin_48120109的博客
09-16 2108
ucOS-II移植
基于hal库实现stm32f103c8t6裸机项目的“软件定时器”
yrx020307的博客
01-31 1048
一，项目背景：优化裸机项目，考虑到硬件资源有限，所以不移植rtos,采用的方案是“软件定时器+状态机”注意点：软件定时器的任务要求短小精悍，要在定时时间到达前运行完毕。原因：未做保存现场和恢复现场。二，下面是cubemx的配置：我还做了其他功能，但是这里仅描述“时钟配置”，“定时器配置”（1）时钟72MHZ（2）定时器2通道1设计要求：主频72MHZ，软件定时器的时基为1ms;定时器参数解读：(2)per:9。
STM32F103C8T6基于HAL库移植uC/OS-III
qq_63793647的博客
11-29 1994
uC/OS是一个可以 基于ROM运行的、可裁减的、抢占式、实时多任务内核，具有高度可移植性，特别适合于微处理器和控制器，适合很多商业操作系统的实时操作系统(RTOS)uC/OS可简单的视为一个多任务调度器，在这个任务调度器之上完善并添加了和多任务操作系统相关的系统服务，如信号量、邮箱等；其主要特点有公开源代码，代码结构清晰、明了，注释详尽，组织有条理，可移植性好，可裁剪，可固化。内核属于抢占式，最多可以管理60个任务；
stm32f103c8t6移植ucosii
08-29
要在STM32F103C8T6上移植uC/OS-II操作系统，您可以按照以下步骤进行操作： 1. 准备工作： - 下载uC/OS-II源代码，并将其加入您的工程中。您可以从Micrium官方网站获取源代码。 - 确保您已经熟悉STM32F103C8T6的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值