嵌入式RTOS多任务程序设计

最新推荐文章于 2024-05-30 15:50:43 发布
最新推荐文章于 2024-05-30 15:50:43 发布
阅读量896 收藏 29
点赞数 26
文章标签： 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79695596/article/details/134652406
版权

1、什么是嵌入式实时操作系统（RTOS）

嵌入式实时操作系统（RTOS）是一种专门设计用于嵌入式系统的操作系统。它的特点是具有实时性、可预测性和高效性，能够满足嵌入式系统对于实时性和稳定性的要求。RTOS通常运行在资源受限的嵌入式设备上，例如传感器、控制器、嵌入式系统等，并能够管理硬件资源、处理任务调度、提供通信接口等功能。常见的RTOS包括FreeRTOS、VxWorks、uC/OS等。

2、UCOSIII简单介绍

UCOSIII是一款由国内著名嵌入式操作系统厂商Real-Thread推出的一款嵌入式实时操作系统。它具有高效、稳定、可靠的特点，适用于各种嵌入式系统的开发。UCOSIII采用了多任务、抢占式的实时操作系统内核，支持多种处理器架构，并提供了丰富的中间件和驱动程序支持。它在工业控制、通信设备、汽车电子等领域有着广泛的应用。

3、实验过程

1、使用cubemx创建工程

（1）选择自己使用的芯片类型，这里选择STM32F103C8T6
（2）配置RCC
在这里插入图片描述

(2)配置SYS
在这里插入图片描述
(3)串口设置 USART1
在这里插入图片描述
(4)设置输出端口，这里选择PA3、PC13配置为GPIO_Output
在这里插入图片描述
创建工程并打开。

2、获取uCOS-III源码

进入 Micrium 公司官网下载中心：[http://micrium.com/downloadcenter/]
选择ST系列，点击 View all STMicroelectronics，点击 STMicroelectronics STM32F107
之后按照提示注册下载即可。

3、移植前的文件准备

这里需要把下载下来的和uCOS有关的五个文件夹移到创建的工程的MDK-ARM文件夹下。
在这里插入图片描述

4、移植文件

（1）在工程中打开Manage Project Items，并添加如下六个文件夹：
在这里插入图片描述

（2）点击CPU并添加如下文件，文件路径为：MDK-ARM\uC-CPU以及MDK-ARM\uC-CPU\ARM-Cortex-M3\RealView
在这里插入图片描述
（3）点击LIB并添加如下文件，文件路径为：MDK-ARM\uC-LIB以及MDK-ARM\uC-LIB\Ports\ARM-Cortex-M3\RealView
在这里插入图片描述
（4）点击PORT并添加如下文件，文件路径为：MDK-ARM\uCOS-III\Ports\ARM-Cortex-M3\Generic\RealView
在这里插入图片描述
（5）点击SOURCE并添加如下文件，文件路径为：MDK-ARM\uCOS-III\Source
在这里插入图片描述
（6）点击CONFIG并添加如下文件，文件路径为：MDK-ARM\uC-CONFIG
在这里插入图片描述
（7）点击BSP并添加如下文件，文件路径为：MDK-ARM\uC-BSP
在这里插入图片描述
（8）导入所有的文件路径，如图：
在这里插入图片描述

5、构建三个任务

（1）在bsp.h中添加如下代码：

#ifndef  __BSP_H__
#define  __BSP_H__

#include "stm32f1xx_hal.h"

void BSP_Init(void);

#endif

（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中的部分代码，把如下位置下的PendSV_Handler改为OS_CPU_PendSVHandler，
SysTick_Handler改为OS_CPU_SysTickHandler
在这里插入图片描述

在这里插入图片描述
（4）把app_cfg.h文件中的DEF_ENABLED 改为 DEF_DISABLED
在这里插入图片描述
（5）打开includes.h文件
在#include <bsp.h>下面添加 #include “gpio.h” #include “app_cfg.h”
将#include <stm32f10x_lib.h> 改为 #include “stm32f1xx_hal.h”
在这里插入图片描述

（6）打开lib_cfg.h文件，把如下位置的数字改为5
在这里插入图片描述
（7）在usart.c文件中添加如下代码：

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

（8）在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);

}

（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();	//进入临界区
}
/**
  * 函数功能: 启动任务函数体。
  * 输入参数: 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****/

（9）修改魔术棒设置
在这里插入图片描述

6、编译并烧录运行

得到如下结果：

fireTools 2023-11-27 19-06-56


video_20231127_190632

2301_79695596
关注
  • 26
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
嵌入式RTOS多任务程序设计.
ozp666666的博客
11-30 416
在每个任务中实现相应的功能：例如在任务A中控制GPIO口控制LED灯的亮灭，在任务B中同样控制GPIO口但是LED的频率和任务A不同，串口发送任务C在周期性发送“hello uc/OS!这是一项相对复杂的任务，需要逐步了解嵌入式RTOS及其API、STM32F103 MCU的使用方法，以及如何使用串口和IO口进行控制。构建任务：按照要求构建至少3个任务，并分配相应的优先级，例如亮灯任务A的周期是1s，亮灯任务B的周期是3s，串口发送任务C的周期是2s。准备好STM32F103开发板，并配置开发环境。
12周嵌入式RTOS多任务程序设计
m0_63306098的博客
01-16 752
在这个项目中，我们系统地学习了嵌入式实时操作系统（RTOS），并以uc/OS-III为例进行了移植到STM32F103上的实际操作。移植过程让我们更深入地了解了RTOS的内部机制和与特定硬件平台的适配。我们成功地构建了至少3个任务（task），其中两个任务分别以1秒和3秒周期对LED进行控制，另一个任务以2秒周期通过串口发送特定的消息。这一步让我们深入了解了任务调度、任务优先级和任务间通信等概念。
第12周实验---嵌入式RTOS多任务程序设计
m0_70598552的博客
11-27 70
PC13以1s的周期亮绿灯；PA3以3s周期亮红灯。下载源码添加到工程文件夹。
STM32基于HAL库的嵌入式RTOS多任务程序设计
qq_65299693的博客
12-18 1041
学习嵌入式实时操作系统（RTOS）,以uc/OS-III为例，将其移植到stm32F103上，构建至少3个任务（task）:其中两个task分别以1s和3s周期对LED等进行点亮-熄灭的控制；另外一个task以2s周期通过串口发送“hello uc/OS!欢迎来到RTOS多任务环境！
嵌入式5个RTOS程序设计建议
qq_41854911的博客
11-07 340
一旦创建了数据流图，就很容易开始对应用程序进行编码。这无疑会在一段时间内顺利进行，但我发现如果开发人员不花时间预先仔细定义任务和消息接口，它可能会导致返工。虽然数据流图通常显示数据如何通过应用程序传播，但它并不一定要求定义数据结构。目标是预先检查每个消息队列，然后为这些消息构建结构。这很重要，因为它将定义消息的外观，而且还将有助于任何底层模块的接口的外观。阀门 ID阀门状态阀门所需的时间再说一次，它可能会期待：归根结底，做事的方式总是不止一种，一种不一定比另一种更好。
嵌入式RTOS编程
weixin_45203491的博客
11-04 1336
本次实验中，在一个工程文件里同时设置了三个任务。这次的实验相比较于我们我们之前的实验来说是有一点复杂的，但通过对网上的资料查阅以及与同学之间的讨论交流，最近成功完成了本次实验，学习了uc/os移植。
增强RTOS集成的系统级设计流程
05-15
嵌入式系统软件通常由实时操作系统（RTOS）和在异构多处理器系统上执行的多线程应用程序组成。在设计空间探索过程中，RTOS上运行的应用程序的动态调度行为、任务分配、优先级分配和延迟等重要的非功能考虑因素。ESL...
基于RTOS的太阳能热水控制系统设计
12-13
摘要：介绍通过在单片机内嵌入实时多任务操作系统RTOS来实现太阳能热水控制系统的设计。文中包含主控制端（主端）与数据采集端（从端）的功能模块图及说明，对存在的多个任务进行解释分析，并给出实现主从通信所定义...
嵌入式系统/ARM技术中的基于Small RTOS51的数据采集器设计
12-10
关键词：Small RTOS51 多任务操作系统 数据采集器引 言　随着嵌入式系统的发展，嵌入式软件设计向软件平台靠近，单片机软件设计不再是单一线程结构方式，而是逐步采用多任务的设计思想。实时内核也称为实时操作系统...
基于Small RTOS51的PS/2键盘驱动程序开发
12-13
　随着嵌入式系统的发展，嵌入式软件设计向软件平台靠近，单片机软件设计不再是单一线程结构方式，而是逐步采用多任务的设计思想。实时操作系统使得实时应用程序的设计、扩展和维护变得更容易，无需大的改动就可以...
基于实时操作系统的单片机多任务应用程序设计
06-26
基于实时操作系统的单片机多任务应用程序设计。通过深入剖析μC/OS-Ⅱ内核架构，之后理解和读懂small RTOS微型嵌入式操作系统的内核。实现多任务的驱动程序，实现LED驱动、串口驱动和键盘驱动。
【嵌入式硬件】DRV8874电机驱动
qq_39200110的博客
05-30 423
1）N沟道H桥电机驱动；2）驱动1个双向有刷直流电机；3）2个单向有刷直流电机；4）4.5V-37V工作电压范围；5）集成电流感测和调节；6）成比例电流输出（IPROPI）；7）可选电流调节（IMODE）:逐周期或固定关断时间；8）支持1.8、3V、5V逻辑输入；9）集成保护：欠压、电荷泵欠压、过流保护、输出关闭、热关断、自动故障恢复。
STM32H562实现FreeRTOS内存管理【支持STM32H系列单片机】.zip
最新发布
06-03
STM32H562 FreeRTOS驱动程序，支持STM32H系列单片机。 项目代码可直接运行~
恶魔轮盘.cpp
06-03
恶魔轮盘
基于C++&OPENCV 的全景图像拼接.zip
06-03
基于C++&OPENCV 的全景图像拼接 C++是一种广泛使用的编程语言，它是由Bjarne Stroustrup于1979年在新泽西州美利山贝尔实验室开始设计开发的。C++是C语言的扩展，旨在提供更强大的编程能力，包括面向对象编程和泛型编程的支持。C++支持数据封装、继承和多态等面向对象编程的特性和泛型编程的模板，以及丰富的标准库，提供了大量的数据结构和算法，极大地提高了开发效率。12 C++是一种静态类型的、编译式的、通用的、大小写敏感的编程语言，它综合了高级语言和低级语言的特点。C++的语法与C语言非常相似，但增加了许多面向对象编程的特性，如类、对象、封装、继承和多态等。这使得C++既保持了C语言的低级特性，如直接访问硬件的能力，又提供了高级语言的特性，如数据封装和代码重用。13 C++的应用领域非常广泛，包括但不限于教育、系统开发、游戏开发、嵌入式系统、工业和商业应用、科研和高性能计算等领域。在教育领域，C++因其结构化和面向对象的特性，常被选为计算机科学和工程专业的入门编程语言。在系统开发领域，C++因其高效性和灵活性，经常被作为开发语言。游戏开发领域中，C++由于其高效性和广泛应用，在开发高性能游戏和游戏引擎中扮演着重要角色。在嵌入式系统领域，C++的高效和灵活性使其成为理想选择。此外，C++还广泛应用于桌面应用、Web浏览器、操作系统、编译器、媒体应用程序、数据库引擎、医疗工程和机器人等领域。16 学习C++的关键是理解其核心概念和编程风格，而不是过于深入技术细节。C++支持多种编程风格，每种风格都能有效地保证运行时间效率和空间效率。因此，无论是初学者还是经验丰富的程序员，都可以通过C++来设计和实现新系统或维护旧系统。3
SDIO接口远距离无线图传WIFI6模块TT-S6D2TR-105HP
06-03
SDIO接口HI1105远距离无线图传WIFI6模块TT-S6D2TR-105HP
windows微信双开t脚本文件
06-03
bat文件，用于微信双开，如果微信是按照默认地址安装的话，即安装路径为 C:\Program Files (x86)\Tencent\WeChat\WeChat.exe 无需修改，直接放到桌面右键点击以管理员身份运行即可。 如微信非默认安装路径，先右键，点击编辑，然后将其中的 C:\Program Files (x86)\Tencent\WeChat\WeChat.exe 替换为电脑中微信安装路径，再右键点击以管理员身份运行即可。
转子发动机 转子发动机 转子发动机
06-03
转子发动机
嵌入式软件编程c设计经验
09-19
另外，对于实时性要求较高的嵌入式系统，需要熟悉实时操作系统（RTOS）和多任务处理技术。了解任务调度、同步和通信机制，能够设计和实现具有良好实时性能的嵌入式软件。 最后，良好的调试和测试能力是嵌入式软件...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值