嵌入式RTOS多任务程序设计

于 2023-11-26 20:00:48 发布
阅读量264 收藏 1
点赞数 1
文章标签： stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yokuershi/article/details/134631731
版权

一、嵌入式实时操作系统（RTOS）

嵌入式实时操作系统（RTOS）是专为嵌入式系统设计的操作系统，它能够满足实时性和可预测性的要求。uc/OS-III（MicroC/OS-III）是一种广泛使用的开源嵌入式实时操作系统之一。

1. uc/OS-III 简介：

1.1 特点：
实时性：uc/OS-III设计用于支持实时系统应用。
多任务支持：支持多任务处理，可以同时执行多个任务。
内核对象：提供了诸如任务、信号量、消息队列等内核对象。
可裁剪性：可以根据应用需求选择性地裁剪功能，以减小内存占用。
1.2 内核对象：
任务（Task）：用于执行实际的工作。
信号量（Semaphore）：用于任务间的同步和互斥。
消息队列（Message Queue）：任务之间通过消息进行通信。
事件标志组（Event Flag Group）：用于任务同步。
互斥量（Mutex）：提供互斥访问共享资源的机制。
1.3 任务调度：
uc/OS-III使用抢占式优先级调度算法，高优先级任务可以抢占低优先级任务的执行。
2. 使用 uc/OS-III 的基本步骤：
2.1 创建任务：
使用uc/OS-III API创建需要执行的任务。
2.2 初始化内核对象：
初始化信号量、消息队列等内核对象。
2.3 启动 uc/OS-III 内核：
启动uc/OS-III内核后，它将开始执行预定义的任务。
2.4 任务编写：
在任务中编写具体的应用逻辑。
2.5 任务同步和通信：
使用信号量、消息队列等机制进行任务之间的同步和通信。

二、使用STM32CubeMX配置项目

1.在STM32CubeMX中选择相应芯片

这里使用STM32F103C8芯片进行实现
在这里插入图片描述

2.配置RCC

在这里插入图片描述

3.配置SYS

在这里插入图片描述

4.配置USART1

在这里插入图片描述

5.配置引脚

在这里插入图片描述

6.在项目设置中进行如下设置

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

设置完成后，点击右上角GENERATE CODE 进行输出。

三、在keil中进行编程

1.添加文件

1.在文件夹中粘贴文件

在这里插入图片描述

2.在项目中创建文件夹
在这里插入图片描述

3.在CPU中导入以下文件
在这里插入图片描述

在这里插入图片描述
4.在LIB中导入以下文件
在这里插入图片描述
在这里插入图片描述
5.在PORT中导入以下文件
在这里插入图片描述
6.在SOURCE中导入以下文件
在这里插入图片描述
7.在CONFIG中导入以下文件
在这里插入图片描述
8.在BSP中导入以下文件
在这里插入图片描述
9.在BSP中导入以下文件
在这里插入图片描述

10.添加路径
在这里插入图片描述

2.修改代码

1.编写bsp.h
在这里插入图片描述
2.编写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

3.在startup_stm32f103xb.s文件中修改
在这里插入图片描述
在这里插入图片描述
4.在app_cfg.h中修改
在这里插入图片描述
在这里插入图片描述
5.修改includes.h文件
在这里插入图片描述
在这里插入图片描述
6.修改lib_cfg.h文件
在这里插入图片描述
7.修改usart.c文件
在这里插入图片描述
8.修改gpio.c文件
在这里插入图片描述
9.编写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();	//进入临界区
}

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

static  void  AppTaskCreate (void)
{
  
}



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

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

10.修改设置
在这里插入图片描述
11.编译
在这里插入图片描述
12.烧录
在这里插入图片描述
13.实物展示

L

串口输出

四、总结

在嵌入式系统的开发中，多任务程序设计是一个至关重要的方面。在进行实验中学习了嵌入式实时操作系统（RTOS）的多任务编程后，体会到了它在提高系统效率、响应性和可维护性方面的巨大潜力。
首先，嵌入式RTOS提供了一种有效的方式来组织和管理系统中的任务。通过RTOS，可以将系统划分为多个独立的任务，每个任务负责执行特定的功能。这种任务的划分使得系统结构更加清晰，便于理解和维护。实时性是嵌入式系统中不可忽视的因素。在RTOS的支持下，可以更好地处理实时任务和事件。通过使用RTOS提供的任务调度器，学到了如何合理分配任务的优先级，确保高优先级任务在需要时能够迅速响应，从而满足系统对于实时性的要求。嵌入式系统常常需要对外部事件进行快速响应，而中断是实现这一目标的关键。通过学习RTOS对中断的支持，掌握了如何编写中断服务程序，以及如何在任务和中断之间实现有效的通信和同步。
嵌入式RTOS的强大之处不仅仅在于它提供了一套丰富的API和任务管理工具，更在于它为嵌入式系统开发提供了一种规范和可重用的方法。合理利用RTOS的功能，可以加速嵌入式系统的开发过程，提高代码的可维护性，降低系统的复杂性。

五、参考

【嵌入式17】STM32F103C8T6基于HAL库移植uC/OS-III及逻辑分析仪波形观测

Yokuershi
关注
详解FreeRTOS：FreeRTOS任务管理程序设计思路（基础篇—9）
不脱发的程序猿
08-09 3805
作为一位RTOS程序开发者，要对自己设计的嵌入式系统要了如指掌，任务的优先级信息，任务与中断的处理，任务的运行时间、逻辑、状态等都要知道，才能设计出好的系统，所以，在设计的时候需要根据需求制定框架。
嵌入式RTOS编程
m0_54226157的博客
11-12 210
2. 学习嵌入式实时操作系统（RTOS）,以uc/OS为例，将其移植到stm32F103上，构建至少3个任务（task）:其中两个task分别以1s和3s周期对LED等进行点亮-熄灭的控制；记录详细的移植过程。1. 使用TIM3和TIM4，分别输出一个PWM波形，PWM的占空比随时间变化，去驱动你外接的一个LED以及最小开发板上已焊接的LED（固定接在 PC13 GPIO端口），实现2个 LED呼吸灯的效果。#if OS_CFG_SCHED_ROUND_ROBIN_EN //当使用时间片轮转的时候。
嵌入式系统/ARM技术中的可DIY的嵌入式RTOS
12-09
二十年来，为了维持对软件编码的控制并减少商业操作系统的成本，“自制式”嵌入式系统的设计者们一直努力在他们在产品中减少RTOS的份额。　　 现在，有了一种更好的方法。　　 以SynthOS为代表的软件产品能够为设计者提供一种RTOS，它采用了一种自动控制技术，减少了软件开发过程中沉闷繁琐的工作。而且以这种方法编写的软件产品的代码也是完全可见的。　　 使用这种系统时，开发者可先用C代码写下软件任务（就是那些用商业RTOS也能完成的基本任务），然后在其中添加简单的SynthOS陈述，即“原语”。这种规定任务间通讯和操作系统参数的“原语”，以及简单的配置文件，就是产
STM32F103C8T6移植uCOS基于HAL库
weixin_46075497的博客
12-04 278
一、使用CubeMX建立STM32F103C8T6HAL库 1.配置RCC 2.配置SYS 设置PC13为GPIO_Output用于点亮LED灯 设置串口USART1 设置工程 点击生成代码，并在Keil中打开该工程。 在main函数中的while循环里添加语句 while (1) { /* USER CODE END WHILE */ /* USER CODE BEGIN 3 */ HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_
STM32F103C8T6移植uCOS
qq1742517469的博客
12-07 514
一、基于CubeMX建立（STM32F103C8T6）HAL库 1.配置RCC 2.配置SYS 3.设置PC13为GPIO_Output（用于点亮LED灯） 4.设置串口USART1 5.生成工程 6.验证 在Keil中打开该工程，然后在main函数中的while循环里添加语句 while (1) { /* USER CODE END WHILE */ /* USER CODE BEGIN 3 */ HAL_GPIO_WritePin(GPIOC, GPIO_PIN_1
RTOS编程
m0_65923764的博客
11-12 434
RTOS编程
stm32 嵌入式RTOS
最新发布
05-08
嵌入式实时操作系统（RTOS）为微控制器提供了一个多任务环境，使开发者能够高效地管理硬件资源，确保系统在严格的时间约束下运行。本文将深入探讨e-kernel在STM32H7xx上的应用及其关键特性。 首先，STM32H7xx系列是...
嵌入式开发：5个RTOS设计最佳实践
yueqian_edu的博客
04-15 590
RTOS 设计已成为许多嵌入式应用的关键，RTOS 用于超过 50% 的嵌入式应用程序，并且随着如此多的设备开始连接并开始使用机器学习，这些数字只会增加。嵌入式开发人员在设计基于 RTOS 的应用程序时，有许多注意事项，在今天的文章中，我们探讨5个RTOS 设计最佳实践。
蓝桥杯嵌入式模拟题3程序设计
03-13
总之，【蓝桥杯嵌入式模拟题3程序设计】将全面测试参赛者的嵌入式系统理论知识和实践能力，包括硬件、软件、编程和系统层面的多个方面。通过这样的竞赛，参与者不仅能提升自身的技术水平，还能积累宝贵的项目经验。
嵌入式实时多任务操作系统
08-20
RTOS是针对不同处理器优化设计的高效率实时多任务内核，优秀商品化的RTOS可以面对几十个系列的嵌入式处理器MPU、MCU、DSP、SOC等提供类同的API接口，这是RTOS基于设备独立的应用程序开发基础。 因此基于RTOS上的...
【嵌入式09】RTOS编程
weixin_52588847的博客
11-03 499
【嵌入式09】RTOS编程
张勇深入讲解嵌入式系统与任务程序设计
资源摘要信息:"嵌入式操作系统原理与面向任务程序设计" 知识点一：嵌入式操作系统的基本概念 嵌入式操作系统是一种专用的操作系统，它被设计用来管理特定硬件设备上的资源。与通用操作系统相比，嵌入式操作系统通常...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值