FreeRTOS实战（二）·按键实现任务的挂起和恢复（STM32移植模版）

最新推荐文章于 2025-05-19 14:03:35 发布
最新推荐文章于 2025-05-19 14:03:35 发布
阅读量1.6k 收藏 37
点赞数 42
分类专栏： FreeRTOS实时操作系统 # FreeRTOS实战系列 文章标签： 单片机 嵌入式硬件 stm32 物联网 c语言 FreeRTOS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MANONGDKY/article/details/147958312
版权

目录

1.  程序设计

2.  工程创建

3.  功能实现

        通过之前入门系列的学习，我们对FreeRTOS的移植已经有了一个大概的概念，那么我们下面就给其投入到实际的使用当中。

FreeRTOS菜鸟入门系列_时光の尘的博客-CSDN博客

1.  程序设计

        创建两个任务，一个LED任务实现电平的翻转，另一任务通过按键进行LED任务的挂起和恢复。

2.  工程创建

        这里不在一一介绍每个文件夹的作用，详细可以了解：

FreeRTOS菜鸟入门（六）·移植FreeRTOS到STM32（逐步超详细移植）-CSDN博客

        根据上面的移植好的模版，我们进行后续任务相关函数的移植，首先对于LED.c的函数，我们增加一个电平翻转的功能，方便后续调用：

//红灯电平翻转
void Toggle_LED_R(void)
{
	BitAction LED_R = (BitAction)(1 - GPIO_ReadOutputDataBit(LED1_GPIO_PORT, LED1_GPIO_PIN));
	GPIO_WriteBit(LED1_GPIO_PORT, LED1_GPIO_PIN, LED_R);
}

//绿灯电平翻转
void Toggle_LED_G(void)
{
	BitAction LED_G = (BitAction)(1 - GPIO_ReadOutputDataBit(LED2_GPIO_PORT, LED2_GPIO_PIN));
	GPIO_WriteBit(LED2_GPIO_PORT, LED2_GPIO_PIN, LED_G);
}

//蓝灯电平翻转
void Toggle_LED_B(void)
{
	BitAction LED_B = (BitAction)(1 - GPIO_ReadOutputDataBit(LED3_GPIO_PORT, LED3_GPIO_PIN));
	GPIO_WriteBit(LED3_GPIO_PORT, LED3_GPIO_PIN, LED_B);
}

        然后创建一个KEY.c函数，就是简单的按键触发函数，检测按键是否按下：

#include "Key.h"  

//初始化配置
void Key_GPIO_Config(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	
	/*开启按键端口的时钟*/
	RCC_APB2PeriphClockCmd(KEY1_GPIO_CLK|KEY2_GPIO_CLK,ENABLE);
	
	//选择按键的引脚
	GPIO_InitStructure.GPIO_Pin = KEY1_GPIO_PIN; 
	// 设置按键的引脚为浮空输入
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; 
	//使用结构体初始化按键
	GPIO_Init(KEY1_GPIO_PORT, &GPIO_InitStructure);
	
	//选择按键的引脚
	GPIO_InitStructure.GPIO_Pin = KEY2_GPIO_PIN; 
	//设置按键的引脚为浮空输入
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; 
	//使用结构体初始化按键
	GPIO_Init(KEY2_GPIO_PORT, &GPIO_InitStructure);	
}

//检测按键是否按下
uint8_t Key_Scan(GPIO_TypeDef* GPIOx,uint16_t GPIO_Pin)
{			
	/*检测是否有按键按下 */
	if(GPIO_ReadInputDataBit(GPIOx,GPIO_Pin) == KEY_ON )  
	{	 
		/*等待按键释放 */
		while(GPIO_ReadInputDataBit(GPIOx,GPIO_Pin) == KEY_ON);   
		return 	KEY_ON;	 
	}
	else
		return KEY_OFF;
}

        然后其中宏定义相关存放在 KEY.h 文件当中：

#ifndef __KEY_H
#define	__KEY_H

#include "stm32f10x.h"

//  引脚定义
#define    KEY1_GPIO_CLK     RCC_APB2Periph_GPIOA
#define    KEY1_GPIO_PORT    GPIOA			   
#define    KEY1_GPIO_PIN		 GPIO_Pin_0

#define    KEY2_GPIO_CLK     RCC_APB2Periph_GPIOC
#define    KEY2_GPIO_PORT    GPIOC		   
#define    KEY2_GPIO_PIN		  GPIO_Pin_13

 /** 按键按下标置宏
	*  按键按下为高电平，设置 KEY_ON=1， KEY_OFF=0
	*  若按键按下为低电平，把宏设置成KEY_ON=0 ，KEY_OFF=1 即可
	*/
#define KEY_ON	1
#define KEY_OFF	0

void Key_GPIO_Config(void);
uint8_t Key_Scan(GPIO_TypeDef* GPIOx,uint16_t GPIO_Pin);


#endif /* __KEY_H */

        两个外设的代码创建完了，我们回到main.c文件，先完善头文件：

#include "stm32f10x.h"                  // Device header
#include "Delay.h"

#include "LED.h"
#include "Usart.h"
#include "Key.h"  

/* FreeRTOS头文件 */
#include "FreeRTOS.h"
#include "task.h"

        然后为了方便管理初始化文件，我们创建一个函数，将初始化相关的函数都存放到这个函数中，这样主函数管理比较方便：

//初始化声明
static void All_Function_Init(void)
{
	/*
	 * STM32中断优先级分组为4，即4bit都用来表示抢占优先级，范围为：0~15
	 * 优先级分组只需要分组一次即可，以后如果有其他的任务需要用到中断，
	 * 都统一用这个优先级分组，千万不要再分组，切忌。
	 */
	NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
	
	/* LED 初始化 */
	LED_GPIO_Config();

	/* 串口初始化	*/
	USART_Config();

	//按键初始化
	Key_GPIO_Config();
  
}

        我们知道创建任务为了方便管理，我们需要创建一个任务句柄，我们这里先不考虑LED和KEY的任务创建，先创建一个用于创建任务的任务句柄：

static TaskHandle_t AppTaskCreate_Handle = NULL; /* 创建任务句柄 */

        我们创建一个用于创建别的任务的任务，这个任务的作用就是通过临界区访问将我们需要的如LED，KEY等任务能够完整的创建，不被中断或者在任务创建时被任务调度打扰，创建完成后就可以将创建任务的这个任务通过调用刚刚创建的句柄删除了，这个任务存在的意义就是保护我们所需要的任务在创建时不被打扰：

//任务创建函数
static void AppTaskCreate(void)
{
  BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
  
  taskENTER_CRITICAL();           //进入临界区

  /***这里是一些我们需要创建的任务***/
  
  vTaskDelete(AppTaskCreate_Handle); //删除AppTaskCreate任务
  
  taskEXIT_CRITICAL();            //退出临界区
}

对于临界区的概念，你可以把他理解为一个房子，保护内部正在做的事情，防止被外部打扰。

详细可以了解：

FreeRTOS菜鸟入门（四）·临界段的保护_freertos临界区保护-CSDN博客

        当然，虽然这个任务用一下就删除了，但是不妨碍他是一个任务，既然是任务，我们就需要给它分配，栈空间等参数，这里在主函数里进行分配：

int main(void)
{
  BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */

	All_Function_Init();//硬件初始化
	
	while (1)
	{
		 /* 创建AppTaskCreate任务 */
		xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate,  /* 任务入口函数 */
													(const char*    )"AppTaskCreate",/* 任务名字 */
													(uint16_t       )512,  /* 任务栈大小 */
													(void*          )NULL,/* 任务入口函数参数 */
													(UBaseType_t    )1, /* 任务的优先级 */
													(TaskHandle_t*  )&AppTaskCreate_Handle);/* 任务控制块指针 */ 
		/* 启动任务调度 */           
		if(pdPASS == xReturn)
			vTaskStartScheduler();   /* 启动任务，开启调度 */
		else
			return -1;  
	}
}

        完整的main函数：

#include "stm32f10x.h"                  // Device header
#include "Delay.h"

#include "LED.h"
#include "Usart.h"
#include "Key.h"  

/* FreeRTOS头文件 */
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"

/* 
 * 任务句柄是一个指针，用于指向一个任务，当任务创建好之后，它就具有了一个任务句柄
 * 以后我们要想操作这个任务都需要通过这个任务句柄，如果是自身的任务操作自己，那么
 * 这个句柄可以为NULL。
 */
static TaskHandle_t AppTaskCreate_Handle = NULL; /* 创建任务句柄 */

/********************************** 内核对象句柄 *********************************/
/*
 * 信号量，消息队列，事件标志组，软件定时器这些都属于内核的对象，要想使用这些内核
 * 对象，必须先创建，创建成功之后会返回一个相应的句柄。实际上就是一个指针，后续我
 * 们就可以通过这个句柄操作这些内核对象。
 *
 * 内核对象说白了就是一种全局的数据结构，通过这些数据结构我们可以实现任务间的通信，
 * 任务间的事件同步等各种功能。至于这些功能的实现我们是通过调用这些内核对象的函数
 * 来完成的
 * 
 */


/******************************* 宏定义 ************************************/
/*
 * 当我们在写应用程序的时候，可能需要用到一些宏定义。
 */


//一些函数声明
static void AppTaskCreate(void);/* 用于创建任务 */
static void All_Function_Init(void);/* 用于初始化板载相关资源 */

int main(void)
{
  BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */

	All_Function_Init();//硬件初始化
	
	while (1)
	{
		 /* 创建AppTaskCreate任务 */
		xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate,  /* 任务入口函数 */
													(const char*    )"AppTaskCreate",/* 任务名字 */
													(uint16_t       )512,  /* 任务栈大小 */
													(void*          )NULL,/* 任务入口函数参数 */
													(UBaseType_t    )1, /* 任务的优先级 */
													(TaskHandle_t*  )&AppTaskCreate_Handle);/* 任务控制块指针 */ 
		/* 启动任务调度 */           
		if(pdPASS == xReturn)
			vTaskStartScheduler();   /* 启动任务，开启调度 */
		else
			return -1;  
	}
}

//任务创建函数
static void AppTaskCreate(void)
{
  BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
  
  taskENTER_CRITICAL();           //进入临界区

  
  
  vTaskDelete(AppTaskCreate_Handle); //删除AppTaskCreate任务
  
  taskEXIT_CRITICAL();            //退出临界区
}


//初始化声明
static void All_Function_Init(void)
{
	/*
	 * STM32中断优先级分组为4，即4bit都用来表示抢占优先级，范围为：0~15
	 * 优先级分组只需要分组一次即可，以后如果有其他的任务需要用到中断，
	 * 都统一用这个优先级分组，千万不要再分组，切忌。
	 */
	NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
	
	/* LED 初始化 */
	LED_GPIO_Config();

	/* 串口初始化	*/
	USART_Config();

	//按键初始化
	Key_GPIO_Config();
  
}

        运行一下没有报错，不过由于我们没有给它其他任务，所以现在也没有实验详细，对于这个工程我们先保存一下，因为后续实验都直接在这个工程上进行操作，省的每次都要创建一遍。

基于STM32F1系列FreeRTOS移植模版资源-CSDN文库

3.  功能实现

        上面我们已经把工程的框架搭好了，下面开始对功能开始实现。

        首先，我们上面也提到了，需要创建两个任务，那么就需要两个任务句柄：

static TaskHandle_t Test_Task_Handle = NULL;/* LED任务句柄 */
static TaskHandle_t KEY_Task_Handle = NULL;/* KEY任务句柄 */

        既然句柄有了，就需要对任务主体进行设置，创建一个LED任务，每隔500ms亮灭一次：

static void Test_Task(void* parameter)
{	
  while (1)
  {
    LED1_ON;
    printf("Test_Task Running,LED1_ON!\r\n");
    vTaskDelay(500);   /* 延时500个tick */
    
    LED1_OFF;     
    printf("Test_Task Running,LED1_OFF!\r\n");
    vTaskDelay(500);   /* 延时500个tick */
  }
}

        然后是对按键任务的编写，我们设置两个按键一个调用vTaskSuspend()用来挂起任务，一个调用vTaskResume()用来恢复任务：

static void KEY_Task(void* parameter)
{	
  while (1)
  {
    if( Key_Scan(KEY1_GPIO_PORT,KEY1_GPIO_PIN) == KEY_ON )
    {/* K1 被按下 */
      printf("挂起Test任务!\r\n");
      vTaskSuspend(Test_Task_Handle);/* 挂起LED任务 */
      printf("挂起Test任务成功!\r\n");
    } 
    if( Key_Scan(KEY2_GPIO_PORT,KEY2_GPIO_PIN) == KEY_ON )
    {/* K2 被按下 */
      printf("恢复Test任务!\r\n");
      vTaskResume(Test_Task_Handle);/* 恢复LED任务！ */
      printf("恢复Test任务成功!\r\n");
    }
    vTaskDelay(20);/* 延时20个tick */
  }
}

对于挂起简单来说就是让任务调度器看不见他，这样被挂起的任务也就无法运行了，将其从挂起恢复，就是让调度器在次看见他，这样通过调度器还能继续运行。

详细的理解可以查看，任务管理的四种状态：

FreeRTOS菜鸟入门（九）·任务管理·超详细逐步解析_freertos菜鸟教程-CSDN博客

        完整main函数代码：

#include "stm32f10x.h"                  // Device header
#include "Delay.h"

#include "LED.h"
#include "Usart.h"
#include "Key.h"  

/* FreeRTOS头文件 */
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"

/* 
 * 任务句柄是一个指针，用于指向一个任务，当任务创建好之后，它就具有了一个任务句柄
 * 以后我们要想操作这个任务都需要通过这个任务句柄，如果是自身的任务操作自己，那么
 * 这个句柄可以为NULL。
 */
static TaskHandle_t AppTaskCreate_Handle = NULL; /* 创建任务句柄 */

static TaskHandle_t Test_Task_Handle = NULL;/* LED任务句柄 */
static TaskHandle_t KEY_Task_Handle = NULL;/* KEY任务句柄 */

/********************************** 内核对象句柄 *********************************/
/*
 * 信号量，消息队列，事件标志组，软件定时器这些都属于内核的对象，要想使用这些内核
 * 对象，必须先创建，创建成功之后会返回一个相应的句柄。实际上就是一个指针，后续我
 * 们就可以通过这个句柄操作这些内核对象。
 *
 * 内核对象说白了就是一种全局的数据结构，通过这些数据结构我们可以实现任务间的通信，
 * 任务间的事件同步等各种功能。至于这些功能的实现我们是通过调用这些内核对象的函数
 * 来完成的
 * 
 */


/******************************* 宏定义 ************************************/
/*
 * 当我们在写应用程序的时候，可能需要用到一些宏定义。
 */


//一些函数声明
static void AppTaskCreate(void);/* 用于创建任务 */

static void Test_Task(void* pvParameters);/* Test_Task任务实现 */
static void KEY_Task(void* pvParameters);/* KEY_Task任务实现 */

static void All_Function_Init(void);/* 用于初始化板载相关资源 */

int main(void)
{
  BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */

	All_Function_Init();//硬件初始化
	
	while (1)
	{
		 /* 创建AppTaskCreate任务 */
		xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate,  /* 任务入口函数 */
													(const char*    )"AppTaskCreate",/* 任务名字 */
													(uint16_t       )512,  /* 任务栈大小 */
													(void*          )NULL,/* 任务入口函数参数 */
													(UBaseType_t    )1, /* 任务的优先级 */
													(TaskHandle_t*  )&AppTaskCreate_Handle);/* 任务控制块指针 */ 
		/* 启动任务调度 */           
		if(pdPASS == xReturn)
			vTaskStartScheduler();   /* 启动任务，开启调度 */
		else
			return -1;  
	}
}

//任务创建函数
static void AppTaskCreate(void)
{
  BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
  
  taskENTER_CRITICAL();           //进入临界区

  /* 创建Test_Task任务 */
  xReturn = xTaskCreate((TaskFunction_t )Test_Task, /* 任务入口函数 */
                        (const char*    )"Test_Task",/* 任务名字 */
                        (uint16_t       )512,   /* 任务栈大小 */
                        (void*          )NULL,	/* 任务入口函数参数 */
                        (UBaseType_t    )2,	    /* 任务的优先级 */
                        (TaskHandle_t*  )&Test_Task_Handle);/* 任务控制块指针 */
  if(pdPASS == xReturn)
    printf("创建Test_Task任务成功!\r\n");
  /* 创建KEY_Task任务 */
  xReturn = xTaskCreate((TaskFunction_t )KEY_Task,  /* 任务入口函数 */
                        (const char*    )"KEY_Task",/* 任务名字 */
                        (uint16_t       )512,  /* 任务栈大小 */
                        (void*          )NULL,/* 任务入口函数参数 */
                        (UBaseType_t    )3, /* 任务的优先级 */
                        (TaskHandle_t*  )&KEY_Task_Handle);/* 任务控制块指针 */ 
  if(pdPASS == xReturn)
    printf("创建KEY_Task任务成功!\r\n");  
  
  vTaskDelete(AppTaskCreate_Handle); //删除AppTaskCreate任务
  
  taskEXIT_CRITICAL();            //退出临界区
}

//Test_Task任务主体
static void Test_Task(void* parameter)
{	
  while (1)
  {
    LED1_ON;
    printf("Test_Task Running,LED1_ON!\r\n");
    vTaskDelay(500);   /* 延时500个tick */
    
    LED1_OFF;     
    printf("Test_Task Running,LED1_OFF!\r\n");
    vTaskDelay(500);   /* 延时500个tick */
  }
}

//Test_Task任务主体
static void KEY_Task(void* parameter)
{	
  while (1)
  {
    if( Key_Scan(KEY1_GPIO_PORT,KEY1_GPIO_PIN) == KEY_ON )
    {/* K1 被按下 */
      printf("挂起Test任务!\r\n");
      vTaskSuspend(Test_Task_Handle);/* 挂起LED任务 */
      printf("挂起Test任务成功!\r\n");
    } 
    if( Key_Scan(KEY2_GPIO_PORT,KEY2_GPIO_PIN) == KEY_ON )
    {/* K2 被按下 */
      printf("恢复Test任务!\r\n");
      vTaskResume(Test_Task_Handle);/* 恢复LED任务！ */
      printf("恢复Test任务成功!\r\n");
    }
    vTaskDelay(20);/* 延时20个tick */
  }
}


//初始化声明
static void All_Function_Init(void)
{
	/*
	 * STM32中断优先级分组为4，即4bit都用来表示抢占优先级，范围为：0~15
	 * 优先级分组只需要分组一次即可，以后如果有其他的任务需要用到中断，
	 * 都统一用这个优先级分组，千万不要再分组，切忌。
	 */
	NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
	
	/* LED 初始化 */
	LED_GPIO_Config();

	/* 串口初始化	*/
	USART_Config();

	//按键初始化
	Key_GPIO_Config();
  
}

        运行结果：

        可以看到当我们将LED任务挂起后，其不在运行，只有当我们恢复后才会继续运行。

完整工程：

FreeRTOS-KEY调用挂起和恢复.zip资源-CSDN文库

FreeRTOS实战系列_时光の尘的博客-CSDN博客

FreeRTOS菜鸟入门系列_时光の尘的博客-CSDN博客

STM32（F103ZET6）第十九课：FreeRtos的移植和使用
2401_83971583的博客
08-28 2461
裸机执行流程：前后台系统操作系统执行流程：加入操作系统的作用：用户想要实现多个任务并行的效果，但是单片机只有一个核心，同时只能处理一件事，通过加入操作系统，可以实现任务快速的切换，给人一种多个任务同时在执行的错觉。
STM32F407移植FreeRTOS
m0_54259189的博客
02-14 1653
FreeRTOS是一个免费的实时操作系统内核。作为一个轻量级的操作系统，功能包括：任务管理、时间管理、信号量、消息队列、内存管理、记录功能、软件定时器、协程等，可基本满足较小系统的需要。由于RTOS需占用一定的系统资源(尤其是RAM资源)，只有μC/OS-II、embOS、salvo、FreeRTOS等少数实时操作系统能在小RAM单片机上运行。
FreeRTOS实战指南 — 2 移植 FreeRTOS 到 STM32F429
几度春风里的博客
09-16 1553
打开FreeRTOS源码，在“.\FreeRTOS\Demo”文件夹下面找到“CORTEX_M4F_STM32F407ZG-SK”这个文件夹（这里我们使用的是STM32F429，可以根据硬件平台选取相应的文件），双击打开，在其根目录下找到这个“FreeRTOSConfig.h”文件，然后拷贝到我们工程的user文件夹下即可。这里的值设置为1，空闲任务在执行完其必要的操作后，会调用taskYIELD()或taskYIELD_FROM_ISR()函数，从而让出CPU的控制权。(5) 重复定义中断服务函数错误。
FreeRTOS-基本介绍和移植STM32
m0_51319492的博客
09-08 2031
裸机：前后台系统，前台系统指的是中断服务函数，后台系统指的是大循环，即应用程序特点实时性差、delay(浪费资源)、结构臃肿(实现功能都放在无限循环)FreeRTOS开发：实时操作系统，强调的是实时性特点分而治之(实现功能划分为多个任务)、延时函数(不会空等待，会让出CPU的使用权给其他任务，即任务调度)、抢占式(高优先级任务抢占低优先级)、任务堆栈(每个任务都有自己的栈空间，用于保存局部变量以及任务的上下文信息)任务调度器就是决定在某一个时刻调用哪一个任务，切换速度很快，造成在。
STM32F1+HAL库+FreeTOTS学习2——STM32移植FreeRTOS
weixin_67907028的博客
06-27 2008
STM32CubeMX配置HAL库工程移植FreeRTOS步骤。
【FreeRTOS】FreeRTOS 任务挂起与恢复（包括在中断中恢复）
FuckerGod的博客
06-28 2458
动态创建任务需要使用到函数，我们可以在 FreeRTOS 官网中查看此函数详细的文档，点击此处跳转根据上方的描述我们可以得知，必须将定义为 1 才能使用此函数。暂停任意任务，无论任务优先级如何，任务被暂停后将无法获取任何微控制器处理时间。对的调用不会累积次数，例如：若在同一任务上调用两次，将仍然仅需调用一次，即可恢复暂停的任务。
STM32入门笔记(04)：STM32F103C8T6 移植 FreeRTOS 模板 (动态、静态创建任务模板及点灯操作，按键非阻塞，事件任务间通信，消息队列，信号量)
Naiva的博客
04-15 1083
fill:#333;color:#333;color:#333;fill:none;项目根目录UserSystemHardwareFreeRTOSmain.cDelay.cDelay.hLED.c/hKey.c/hOLED.c/h任务相关文件内核相关文件。
FreeRTOS移植到江科大stm32
qq_42794054的博客
10-04 790
记录一下移植过程，以江科大串口版为基础模板。
基于STM32CubeMX创建FreeRTOS—以STM32F429为例
qcmyqcmy的专栏
01-21 2611
基于STM32CubeMX创建FreeRTOS—以STM32F429为例。 创建了FreeRTOS双任务系统。
STM32F767 FreeRTOS实现二值信号量【支持STM32F7系列单片机-FreeRTOS实战】.zip
12-26
总之，STM32F767 FreeRTOS实现二值信号量的项目涵盖了嵌入式系统中的多任务调度、同步机制、硬件接口编程等多个重要知识点，对于提升STM32和FreeRTOS的实践技能非常有帮助。通过深入研究并实践该项目，开发者可以更...
stm32f103 FreeRTOS空闲任务钩子函数实验.zip
03-07
5. **工程模板程序**：这个实验提供的工程模板可以作为STM32F103 FreeRTOS开发的基础框架，包含了必要的初始化代码、任务创建示例以及空闲任务钩子的实现，对于初学者快速上手非常有帮助。 6. **信号量与互斥锁**：...
STM32H562实现FreeRTOS时间片调度【支持STM32H系列单片机】.zip
06-11
4. **中断服务例程**：FreeRTOS支持中断，中断发生时，RTOS会保存当前任务的状态并挂起，然后执行中断服务例程。中断完成后，通过`vTaskSwitchContext()`函数恢复任务调度。 5. **内存管理**：FreeRTOS提供了内置的...
YOLOv8 在单片机上部署的缺点和应对方案
m0_37302966的博客
05-19 389
YOLOv8 在单片机上部署的缺点和应对方案
支持python的单片机有哪些
yuanpan的专栏
05-19 440
本文介绍了支持Python编程的主流单片机方案，重点推荐了ESP32/ESP8266系列、Raspberry Pi Pico和STM32系列。ESP32/ESP8266因其内置WiFi和蓝牙功能、丰富的社区资源而成为最流行的MicroPython开发平台。Raspberry Pi Pico作为树莓派官方MCU，支持PIO和高级功能，适合复杂应用。STM32系列则通过OpenMV或刷入MicroPython固件实现高性能应用。此外，还提到了其他兼容开发板如PyBoard和K210开发板。文章还提供了新手选择建
STC-ISP烧录过程中一直显示“正在检测单片机”的解决办法
dhdhshshw2的博客
05-19 742
在嵌入式开发中，烧录程序时遇到“无法检测目标单片机”的问题十分常见。本文通过一个实际案例，分析了该问题的可能原因及解决方法。案例中，开发者通过拔掉VCC和GND后重新烧录成功，这通常与单片机的供电逻辑和CH340的时序匹配有关。文章从硬件原理和操作逻辑两方面进行了详细分析，包括单片机与CH340的供电冲突、复位时序异常、CH340模块的驱动兼容性问题等。此外，文章还提供了预防措施与优化建议，如避免多电源直接并联、添加复位控制电路、严格遵循供电顺序等。最后，文章总结了问题的本质，并建议在后续开发中优先通过CH
嵌套式向量中断控制器(NVIC)
最新发布
嵌入式老牛的博客
05-19 708
ARMv7-M架构中的嵌套向量中断控制器（NVIC）是异常模型的核心，支持最多496个中断。中断数量通过中断控制器类型寄存器（ICTR）确定，以32个中断为粒度。NVIC支持电平敏感和脉冲敏感两种中断行为，分别要求中断信号保持有效电平或至少一个处理器时钟周期的有效脉冲。中断管理包括启用/禁用、挂起状态控制、活动位状态查询和优先级配置。中断可通过硬件事件或软件操作触发，软件可通过挂起置位寄存器或软件触发寄存器（STIR）设置中断挂起状态。NVIC的设计确保了中断处理的灵活性和可靠性。
51 单片机头文件 reg51.h 和 reg52.h 详解
攻城狮鹏哥
05-12 751
51 单片机头文件 reg51.h 和 reg52.h 定义特殊功能寄存器（SFR）和位地址。reg51.h 针对标准 8051，reg52.h 针对增强型 8052，后者增加定时器 2 支持和额外 RAM。二者均含程序状态字、累加器、I/O 端口、定时器 / 计数器、中断、串口等相关寄存器定义。reg52.h 扩展定时器 2 相关寄存器。使用时依单片机型号选择头文件，可通过直接操作 SFR 及 sbit 定义的位名称开发程序。
基于单片机辣椒采摘小车系统设计与实现
Candy5204的博客
05-19 886
标题:基于单片机辣椒采摘小车系统设计与实现内容:1.摘要 随着农业现代化的发展，辣椒采摘的自动化需求日益增长。本研究的目的是设计并实现一种基于单片机的辣椒采摘小车系统，以提高辣椒采摘的效率和质量。采用单片机作为控制核心，结合传感器技术、机械结构设计和电机驱动等方法，构建了辣椒采摘小车系统。通过实际测试，该系统能够准确识别辣椒的位置，采摘成功率达到了85%以上，且对辣椒的损伤率低于5%。研究结果表明，基于单片机的辣椒采摘小车系统具有较高的可行性和实用性，能够有效降低人工劳动强度，提高辣椒采摘的效率。 关键词：
单片机Day11
WLYCTT的博客
05-14 247
u8 i=0;while(t--);P2=~0x01;while(1)i++;if(i>=8)i=0;if(i==0)i=7;elsei--;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

时光の尘

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值