精妙的单片机非阻塞延时程序设计

最新推荐文章于 2025-10-16 18:15:30 发布
转载 最新推荐文章于 2025-10-16 18:15:30 发布 · 1k 阅读 · 2

本文介绍了在单片机项目中实现非阻塞定时延时的方法，通过使用systick定时中断和自定义数据结构，提高了程序效率并简化了任务定时逻辑。展示了如何在主轮询中调用定时处理函数，实现多个不同时间间隔的任务处理，同时保持代码清晰易读。

http://blog.chinaunix.net/uid-29673749-id-4425603.html

  对于每个单片机爱好者及工程开发设计人员，在刚接触单片机的那最初的青葱岁月里，都有过点亮跑马灯的经历。从看到那一排排小灯按着我们的想法在跳动时激动心情。到随着经验越多，越来又会感觉到这个小灯是个好东西，尤其是在调试资源有限的环境中，有时会帮上大忙。


但对于绝大多数人，我们在最最初让灯闪烁起来时大约都会用到阻塞延时实现，会像如下代码的样子：
  1. while(1)
  2. {
  3.     LED =OFF;
  4.     Delay_ms(500);
  5.     LED = ON;
  6.     Delay_ms(500);
  7. }
然后，在我们接触到定时器，我们会发现，原来用定时中断来处理会更好。比如我们可以500ms中断一次，让灯亮或灭，其余的时间系统还可以做非常之多的事情，效率一下提升了很多。

这时我们就会慢慢意识到，第一种（阻塞延时）方法效率很低，让芯片在那儿空运行几百毫米，什么也不做，真是莫大的浪费，尤其在芯片频率较高，任务又很多时，这样做就像在平坦宽阔的高速公路上挖了一大坑，出现事故可想而知。

但一个单片机中的定时器毕竟有限，如果我需要几十个或者更多不同时间的定时中断，每一个时间到都完成不同的处理动作，如何去做呢。一般我们会想到在一个定时中断函数中再定义static 变量继续定时，到了所需时间，做不同的动作。而这样又会导致在一个中断里做了很多不同的事情，会抢占主轮询更多时间，有时甚至喧宾夺主，并也不是很如的思维逻辑。

那么有没有更好的方法来实现呢，答案是肯定的。下面介绍我在一个项目中偶遇，一个精妙设计的非阻塞定时延时软件的设计（此设计主要针对于无操作系统的裸机程序）。

在上篇文章中有对systick的介绍，比如我要设置其10ms中断一次，如何实现呢？
也很简单，只需调用 core_cm3.h文件中 SysTick_Config 函数 ，当系统时钟为72MHZ，则设置成如下即可 SysTick_Config（720000 ）; (递减计数720000次后中断一次) 。此时SysTick_Handler中断函数就会10ms进入一次；

任务定时用软件是如何设计的呢 ？ 
且先看其数据结构，这也是精妙所在之处，在此作自顶向下的介绍：

其定义结构体类型如：
  1. typedef struct
  2. {
  3.     uint8_t Tick10Msec;
  4.     Char_Field Status;
  5. } Timer_Struct;
其中Char_Field 为一联合体，设计如下：
  1. typedef union
  2. {
  3.     unsigned char byte;
  4.     Timer_Bit field;
  5. } Char_Field
而它内部的Timer_Bit是一个可按位访问的结构体：
  1. typedef struct
  2. {
  3.     unsigned char bit0: 1;
  4.     unsigned char bit1: 1;
  5.     unsigned char bit2: 1;
  6.     unsigned char bit3: 1;
  7.     unsigned char bit4: 1;
  8.     unsigned char bit5: 1;
  9.     unsigned char bit6: 1;
  10.     unsigned char bit7: 1;
  11. } Timer_Bit
此联合体的这样设计的目的将在后面的代码中体现出来。
如此结构体的设计就完成了。

然后我们定义的一全局变量，Timer_Struct  gTimer;

并在头文件中宏定义如下：
  1. #define bSystem10Msec        gTimer.Status.field.bit0
  2. #define bSystem50Msec        gTimer.Status.field.bit1
  3. #define bSystem100Msec       gTimer.Status.field.bit2
  4. #define bSystem1Sec          gTimer.Status.field.bit3
  5. #define bTemp10Msec          gTimer.Status.field.bit4
  6. #define bTemp50Msec          gTimer.Status.field.bit5
  7. #define bTemp100Msec         gTimer.Status.field.bit6
  8. #define bTemp1Sec            gTimer.Status.field.bit
另外为了后面程序清晰，再定义一状态指示：
  1. typedef enum
  2. {
  3.     TIMER_RESET = 0,
  4.     TIMER_SET = 1,
  5. } TimerStatus;
至此，准备工作就完成了。下面我们就开始大显神通了！

首先，10ms定时中断处理函数如，可以看出，每到达10ms 将把bTemp10Msec置1，每50ms 将把bTemp50Msec 置1，每100ms 将把bTemp100Msec 置1，每1s 将把bTemp1Sec 置1，
  1. void SysTick_Handler(void)
  2. {
  3.          
  4.         bTemp10Msec = TIMER_SET;
  5.         
  6.         ++gTimer.Tick10Msec;
  7.         if (0 == (gTimer.Tick10Msec % 5))
  8.         {
  9.             bTemp50Msec = TIMER_SET;
  10.         }
  11.         
  12.         if (0 == (gTimer.Tick10Msec % 10))
  13.         {
  14.             bTemp100Msec = TIMER_SET;
  15.         }
  16.         
  17.         if (100 == gTimer.Tick10Msec)
  18.         {
  19.             gTimer.Tick10Msec = 0;
  20.             bTemp1Sec = TIMER_SET;
  21.         }
  22. }
而这又有什么用呢 ？

这时，我们需在主轮询while(1)内最开始调用一个定时处理函数如下：
  1. void SysTimer _Process(void)
  2. {
  3.     gTimer.Status.byte &= 0xF0;
  4.     
  5.     if (bTemp10Msec)
  6.     {
  7.         bSystem10Msec = TIMER_SET;
  8.     }
  9.     
  10.     if (bTemp50Msec)
  11.     {
  12.         bSystem50Msec = TIMER_SET;
  13.     }
  14.     
  15.     if (bTemp100Msec)
  16.     {
  17.         bSystem100Msec = TIMER_SET;
  18.     }
  19.     
  20.     if (bTemp1Sec)
  21.     {
  22.         bSystem1Sec = TIMER_SET;
  23.     }
  24.     
  25.     gTimer.Status.byte &= 0x0F;
  26. }
此函数开头与结尾两句
  1. gTimer.Status.byte &= 0xF0;
  2. gTimer.Status.byte &= 0x0F
就分别巧妙的实现了bSystemXXX （低4位） 和 bTempXXX（高4位）的清零工作，不用再等定时到达后还需手动把计数值清零。此处清零工作用到了联合体中的变量共用一个起始存储空间的特性。

但要保证while(1)轮询时间要远小于10ms，否则将导致定时延时不准确。这样，在每轮询一次，就先把bSystemXXX ，再根据bTempXXX判断是否时间到达，并把对应的bSystemXXX 置1，而后面所有的任务就都可以通过bSystemXXX 来进行定时延时，在最后函数退出时，又会把bTempXXX清零，为下一次时间到达后查询判断作好了准备。

说了这么多，举例说明一下如何应用：
  1. void Task_A_Processing(void)
  2. {
  3.     if(TIMER_SET == bSystem50Msec){
  4.         //do something
  5.     }
  6. }

  8. void Task_B_Processing(void)
  9. {
  10.     if(TIMER_SET == bSystem100Msec){
  11.         //do something
  12.     }
  13. }

  15. void Task_C_Processing(void)
  16. {
  17.     static uint8_t ticks = 0;
  18.     if(TIMER_SET == bSystem100Msec){
  19.        ticks ++ ;
  20.     }

  22.     if(5 == ticks){
  23.         ticks = 0;
  24.          //do something
  25.     }

  27. }

  29. void Task_D_Processing(void)
  30. {
  31.     if(TIMER_SET == bSystem1Sec){
  32.         //do something
  33.     }
  34. }
以上示例四个任务进程，

在主轮询里可进行如下处理：
  1. int main(void)
  2. {
  3.     while(1)
  4.     {
  5.         SysTimer _Process();

  7.         Task_A_Processing();
  8.         Task_B_Processing();
  9.         Task_C_Processing();
  10.         Task_D_Processing();

  12.     }
  13. }
这样，就可以轻松且清晰实现了多个任务，不同时间内处理不同事件。（但注意，每个任务处理中不要有阻塞延时，也不要处理过多的事情，以致处理时间较长。可设计成状态机来处理不同任务。）
51单片机 利用定时中断做“非阻塞式”点灯
lj2407727730的博客
04-15 1452
前言 很多程序员的第一句代码，估计都是“hello world”。 在电子行业里，软件工程师的第一个成（入）功（坑）代码，估计都是从点亮第一颗LED灯讲起。 今天的自学笔记记录的例程是如何利用定时中断，来做一个“非阻塞式”的闪灯程序。 这节内容，看似简单，实际项目中却有很多地方可以应用，比如模拟PWM波形，还有接下来要写的 按键消抖清零 应用 一、 “阻塞”和“非阻塞”是什么？ 首先名词解释一下： [ “阻塞”
单片机裸机中的非阻塞延时：任务分离计数器法实战
2502_92275547的博客
06-21 1018
本文介绍了裸机编程中推荐的非阻塞延时方法——任务分离计数器法。通过为每个任务分配独立计数器和周期变量，在定时器中断中统一更新计数，在主循环中轮询判断执行，实现了多任务并行处理。相比阻塞延时，该方法避免了CPU空转，提升了系统响应性和扩展性。文中以LED闪烁和按键扫描为例展示了具体实现，并指出该方法具有结构清晰、易于扩展、高效灵活等优势，适合构建裸机系统中的轻量级任务调度框架。
单片机中的非阻塞延时程序设计
最新发布
用学习探索人生的更多可能
10-16 507
摘要：非阻塞延时程序通过替代传统delay()函数，实现单片机高效多任务处理。其核心是使用millis()记录时间差，结合定时中断和状态标志，允许多个任务在不同时间间隔下并行执行。相比阻塞延时会占用CPU空转，非阻塞方案显著提升系统响应效率。关键设计包括：1）利用SysTick定时器产生10ms基准；2）通过位域结构体管理多个定时标志；3）主循环轮询处理各任务状态。要注意轮询周期应短于最小定时单位，且避免任务处理耗时过长。该技术是嵌入式系统实现实时多任务的基础方案。
单片机与DSP中的精妙的单片机非阻塞延时程序设计
10-15
总之，非阻塞延时程序设计是单片机与DSP开发中的一个重要技巧，通过合理利用定时中断和精心设计的数据结构，可以实现高效的任务调度和管理，优化系统的整体性能。这对于资源有限的嵌入式系统来说至关重要，能够最大...
单片机非阻塞延时程序设计
07-14
对于每个单片机爱好者及工程开发设计人员，在刚接触单片机的那最初的青葱岁月里，都有过点亮跑马灯的经历。从看到那一排排小灯按着我们的想法在跳动时激动心情。到随着经验越多，越来又会感觉到这个小灯是个好东西，...
单片机非阻塞延时实现
weixin_45660027的博客
02-15 789
基于定时器的单片机非阻塞延时函数实现
嵌入式（单片机）裸机 C 语言开发 + 按键扫描（模块分层/非阻塞式）
大橙子的博客
08-31 2814
本文目的是讲述一个按键扫描处理的面向对象开发的设计思想，适用于裸机开发，通过按键扫描，检测到按键是否按下，松开等状态，并将该状态通过其他形式反馈给其他模块进行处理。初次使用按键时，最常用的办法就是如以下代码一样，硬延时抖动滤波，等待确认后做相应的处理。
STM32CubeMX系列教程7：裸机编程的非阻塞式简易多任务程序设计方法
小白的学习笔记
11-13 2400
文章目录摘要应用举例 摘要   单片机的裸机编程中，如果有多个执行频率不同或需要有一定间隔时间执行的任务，一般使用中断或延时的方式安排任务的执行顺序。但中断函数中不能放置执行时间比较长的任务，会影响其他中断的响应，而在大循环中以软件延时的方式，是一种阻塞式程序，对其他功能的影响非常大，很不推荐。这里我推荐一种多任务的执行方式。   这种方式是使用定时器产生一个1ms的时基，为每一个任务创建一个任务时间戳，在定时器中断中，对每一个任务时间戳进行累加。在主循环中，对每一个任务的任务时间戳进行判断是否大于等于任务
通过单片机理解来理解异步非阻塞
凉
12-08 723
通过单片机理解来理解异步非阻塞 并发在BS架构中非常重要，是web服务器的典型应用场景。 传统后台高级语言java、php虽然能实现高并发，但是却有缺点，最好解决并发的方案是异步非阻塞。下文以单片机多任务来讲解异步非阻塞的优点。 两个基本概念 并发 并发指的时服务器同时应对多个客户端请求，这里的同时是宏观的，从微观来讲cpu只在某一小段时间处理其中一个请求并且在不同的处理线程上进行切换，因为切换的...
单片机实现非阻塞延时
h17878761977的博客
04-10 1135
单片机实现非阻塞延时。
关于单片机实现非阻塞式程序的思路（不使用rtos）
m0_73279193的博客
11-22 1849
主要是介绍一下非阻塞式的设计思想
实用的MCU非阻塞式框架---外设部分
weixin_50197990的博客
12-03 2061
2.单片机资源紧张，串口发送时无需判断是否发送成功，1ms或者2ms发送一字节数据即可。1.机械按键按下会产生抖动，通过非阻塞式的延时消抖，轻触按键也可以通过计数消抖。为避免全局变量满天飞，用结构体管理全局变量，若MCU内存不够，最后可解耦；2.一阶滤波、限幅滤波、温差比较 ---- 冒泡排序后取平均值。1.设置1ms定时器中断，设置变量在定时器中断函数中++/–1.分层扫描，高低都延时，随意更改开关个数。2.跑裸机都可参考此框架的非阻塞式延时。2.假设用按键设置时，数码管闪烁显示。##IO口模拟PWM。
按键阻塞与非阻塞
菜菜的博客
12-26 1618
按键消抖之 同步 异步 阻塞 非阻塞(基于STM32) 同步、异步：通讯方式 阻塞、非阻塞：等待状态 老张爱喝茶，废话不说/煮开水。 出场人物：老张，水壶两把（普通氷壶，简称水壶,•会响M水壶，简称响氷壶） 1、老张把水壶放到火上，立等水开，（同步阻塞 ） 老张觉得自己有点傻 2、老张把水誠到火上，去客厅看电视，时不时去厨房看看水开没有。（同步非阻塞） 老张还是觉得自己有点傻，于是变高端了，买了把...
STM32 时延函数之阻塞和非阻塞的实现讨论
热门推荐
戈扬的博客
08-11 1万+
一 、常使用的几种延时方式 1 自带的hal_delay 函数 毫秒级延迟 void HAL_Delay(__IO uint32_t Delay) { uint32_t tickstart = HAL_GetTick(); //获取tick值（毫秒） uint32_t wait = Delay; /* Add a period to guarantee minimum wait */ if (wait < HAL_MAX_DELAY) { wait++;//
【HAL库】STM32CubeMX开发----非阻塞延时实验----SysTick(滴答定时器)中断
MQ0522的博客
05-11 4549
【HAL库】STM32CubeMX开发----非阻塞延时实验----SysTick(滴答定时器)中断
stm32非阻塞延时函数
04-22
<think>好的，我现在需要帮助用户找到关于STM32实现非阻塞延时函数的方法和代码示例。用户之前提供的引用资料主要涉及阻塞式延时函数，比如使用循环或SysTick定时器。但用户现在明确要求非阻塞的方法，所以我得回忆一下相关知识，并结合引用内容思考如何整合信息。 首先，非阻塞延时的核心是不占用CPU资源，允许程序在等待期间执行其他任务。通常，这可以通过状态机、定时器中断或系统滴答定时器（SysTick）来实现。在用户提供的引用中，引用[1]提到了SysTick的初始化和中断，这可能与非阻塞延时有关。引用[3]和[4]中的代码都是阻塞式的，比如循环延时，所以需要排除这些方法。 接下来，我需要考虑如何利用SysTick或硬件定时器来记录时间流逝，从而判断延时是否完成。例如，使用全局变量来存储时间戳，然后在主循环中检查当前时间是否超过预设的延时时间。这种方法需要定时器提供精确的时间基准，比如每毫秒递增一个计数器。 用户提供的引用[1]中的Delay_Init函数初始化了SysTick，可能用于产生定时中断。这里可以设想，在中断服务例程中更新一个全局时间变量，比如uwTick，类似于HAL库中的做法。然后，非阻塞延时函数可以通过比较当前uwTick和开始时间来判断是否完成延时。 另外，引用[3]和[4]中提到了循环延时，但这些都是阻塞的，不适合非阻塞需求。所以，正确的方向应该是基于定时器中断的方法。需要确保代码示例中使用的是状态检查而非等待循环。 可能还需要考虑多任务情况下的时间管理，例如多个延时任务同时进行。因此，每个延时实例需要独立的开始时间和延时长度，可能通过结构体或数组来管理。 最后，我需要确保代码示例正确使用了SysTick，并且有初始化和更新时间戳的部分。同时，需要说明如何调用这些函数，比如在main循环中检查时间是否到达，从而执行相应的操作而不阻塞其他代码。</think>### STM32非阻塞延时函数实现方法 非阻塞延时的核心思想是通过**时间戳比对**实现延时判断，无需占用CPU资源。以下是三种常用实现方式及代码示例： --- ### 方法一：SysTick滴答定时器方案 #### 实现原理 利用SysTick定时器每1ms产生中断更新全局时间戳，通过比对时间差实现非阻塞判断[^1][^3] ```c // delay.h volatile uint32_t uwTick = 0; // 全局时间戳 void Delay_Init(void) { SysTick_Config(SystemCoreClock / 1000); // 1ms中断 } uint32_t HAL_GetTick(void) { return uwTick; } // SysTick中断服务函数 void SysTick_Handler(void) { uwTick++; } // 非阻塞延时判断函数 uint8_t Delay_Elapsed(uint32_t *prev_tick, uint32_t delay) { if(HAL_GetTick() - *prev_tick >= delay) { *prev_tick = HAL_GetTick(); return 1; } return 0; } ``` #### 使用示例 ```c uint32_t led_timestamp = 0; while(1) { if(Delay_Elapsed(&led_timestamp, 500)) { // 500ms间隔 LED_Toggle(); // 非阻塞执行LED翻转 } // 此处可执行其他任务 } ``` --- ### 方法二：硬件定时器方案 #### 实现原理 使用通用定时器（如TIM2）实现高精度计时，通过捕获比较寄存器自动更新时间戳[^1] ```c // 启用TIM2定时器（1MHz时钟） void TIM2_Init(void) { RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); TIM_TimeBaseInitTypeDef timer; timer.TIM_Prescaler = 72-1; // 72MHz/72=1MHz timer.TIM_CounterMode = TIM_CounterMode_Up; timer.TIM_Period = 0xFFFFFFFF; TIM_TimeBaseInit(TIM2, &timer); TIM_Cmd(TIM2, ENABLE); } // 获取当前计时值 uint32_t Get_Micros(void) { return TIM2->CNT; } // 微秒级非阻塞判断 uint8_t Delay_NonBlocking(uint32_t *prev_time, uint32_t us) { if(Get_Micros() - *prev_time >= us) { *prev_time = Get_Micros(); return 1; } return 0; } ``` --- ### 方法三：状态机方案 #### 实现原理 通过结构体封装延时状态，支持多任务并行处理[^2] ```c typedef struct { uint32_t start_time; uint32_t duration; uint8_t is_running; } NonBlockDelay_t; void Delay_Start(NonBlockDelay_t *delay, uint32_t ms) { delay->start_time = HAL_GetTick(); delay->duration = ms; delay->is_running = 1; } uint8_t Delay_Check(NonBlockDelay_t *delay) { if(delay->is_running && (HAL_GetTick() - delay->start_time >= delay->duration)) { delay->is_running = 0; return 1; } return 0; } ``` #### 使用示例 ```c NonBlockDelay_t led_delay, sensor_delay; Delay_Start(&led_delay, 500); // LED延时500ms Delay_Start(&sensor_delay, 2000); // 传感器延时2s while(1) { if(Delay_Check(&led_delay)) { LED_Toggle(); Delay_Start(&led_delay, 500); // 重启延时 } if(Delay_Check(&sensor_delay)) { Read_Sensor(); Delay_Start(&sensor_delay, 2000); } } ``` --- ### 关键点对比 | 方法 | 精度 | 资源占用 | 适用场景 | |-------------|-------|----------|------------------------| | SysTick | 1ms | 低 | 常规任务调度 | | 硬件定时器 | 1μs | 中 | 高精度控制 | | 状态机 | 1ms | 低 | 多任务并行管理 | ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值