延时算法进阶

最新推荐文章于 2024-06-12 10:17:10 发布
最新推荐文章于 2024-06-12 10:17:10 发布
阅读量445 收藏 5
点赞数 3
文章标签： c++ 51单片机 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LevolutionL/article/details/129720975
版权

  1. 简介

  2. 阻塞延时

  3. 非阻塞延迟

  4. 非阻塞延迟拓展

  5. 心得体会

  • 1、简介

今天利用上课的摸鱼时间，学习了一下延时发现其中有挺多学问，同样也有些规律，以此记录下自己的心得。

  • 2、阻塞延时

void DelayXms(unsigned int xms)	
{
	unsigned char i, j;
	
	while (xms--)
	{
		i = 2;
		j = 239;
		do
		{
			while (--j);
		} while (--i);
	}
}

上面是我们一般用到的阻塞延迟，它是很简单，很方便甚至在stc-isp可以直接生成（我绝对不会告诉你这个就是在stc-isp上生成的），但是它也有缺点，就是它需要等待for循环的完成，这样就很不优雅，作为时间管理大师的我肯定是无法忍受的，那么怎么才能够一“芯”多用，让多个任务“同时”运行呢？那就要使用接下来说的非阻塞延迟。

  • 3、非阻塞延迟

#include "reg52.h"

#define _DELAY_TIME 1000        //宏定义延迟时间
unsigned int u16_cnt;           //时间积累变量
unsigned char u8_delay_flag;    //延迟标志

/*延迟函数*/
void _DELAY()
{
	u16_cnt = _DELAY_TIME;
	if(u16_cnt)
	{
		u16_cnt--;
		if(!u16_cnt)
		{
			u8_delay_flag = 1;
		}
	}
	if(u8_delay_flag == 1)
	{
		u8_delay_flag = 0;
		u16_cnt = _DELAY_TIME;
		//执行语句
	}
}

以上就是最简单的非阻塞函数，其实并不难理解。

首先要判断什么时候所需时间到了，先定义一个变量，赋给它我们要延迟的时间，进入if判断语句，当时间积累变量不为0时，让它减少，当它为0时，将标志位置1。

那么要如何实现我们所需的功能？这就需要另一个if判断语句，当标志位为1时，将标志位置0，防止多次触发，将时间积累变量重置，然后实现我们所需的功能。

那它又是如何实现非阻塞的呢？我们将这个函数放入while循环里，每次循环都会对时间积累变量进行一次判断，如果成立往下走程序，如果不成立，跳出if判断，回到while循环，我们将之前for循环需要一次执行完的程序，分解为多个判断语句，使得我们不需要去等待，以实现非阻塞。

但这不是完美的，当我们的任务变多，if判断语句就会增加，我们需要在DELAY函数里花费的时间就会变多，导致我们的延时变得不精准，那有没有什么办法既能实现非阻塞延迟又能获得一个相对精准的时间呢？这时大家一定想到了定时器，没错！当我们加上定时器，就能解决以上问题。

  • 4、非阻塞延迟扩展

  • 定时器

#include "reg52.h"

/*外部变量声明*/
extern unsigned int g_u16_time_cnt;      //时间计数值
extern unsigned char g_u8_time_flag;	 //时间标志位

unsigned int g_u16_time_cnt;             //时间计数值
unsigned char g_u8_time_flag;	         //时间标志位

#define  time_delay 1000

void Timer0_Init(void)		             //1毫秒@12.000MHz
{
	TMOD &= 0xF0;			            //设置定时器模式
	TMOD |= 0x01;			            //设置定时器模式
	TL0 = 0x18;				            //设置定时初始值 （65536 - 1000）%256 1000 = 延迟时间/机械周期 机械周期 = 12*（1/晶振频率）
	TH0 = 0xFC;				            //设置定时初始值	（65536 - 1000）/256
	TF0 = 0;				            //清除TF0标志
	ET0 = 1;				            //使能定时器0中断
	EA = 1;					            //使能中断总开关
	TR0 = 1;				            //定时器0开始计时

}

void Timer0_Isr(void) interrupt 1
{
	TR0 = 0;					        //关闭定时计数器
	if(g_u16_time_cnt)
	{
		g_u16_time_cnt--;
		if(!g_u16_time_cnt)
		{
			g_u8_time_flag = 1;
			TL0 = 0x18;				    //设置定时初始值
			TH0 = 0xFC;				    //设置定时初始值
		}
	}
	TL0 = 0x18;				            //设置定时初始值
	TH0 = 0xFC;				            //设置定时初始值
	TR0 = 1;					        //打开定时计数器
}

void main()
{
	g_u16_time_cnt = time_delay;
	g_u8_time_flag = 0;
	Timer0_Init();
	while(1)
	{
		if(1 == g_u8_time_flag)
		{
			g_u8_time_flag = 0;
			//执行程序
			g_u16_time_cnt = time_delay;
		}
	}
}

这段代码其实和上面那部分代码并没有什么区别，只是加入了定时器，这里就不过多赘述，不过这里需要注意，中断的时机不能过短，否则会频繁进入中断影响主程序。

  • 多任务并行

当然我们实现功能时，肯定不可能只有一个点灯（或者点亮一颗CPU），以51单片机为例，它只内带了两个定时器，那我们需要多个定时器时，两个肯定是不够用的，那么我们就可以多写几个软件定时器，以满足我们的需求。

/*外部变量声明*/
extern unsigned int g_u16_time1_cnt;  //时间计数值
extern bit g_u8_time1_flag;	//时间标志位
extern unsigned int g_u16_time2_cnt;  //时间计数值
extern bit g_u8_time2_flag;	//时间标志位

void Timer0_Init(void)		//1毫秒@12.000MHz
{
	TMOD &= 0xF0;			//设置定时器模式
	TMOD |= 0x01;			//设置定时器模式
	TL0 = 0x18;				//设置定时初始值 （65536 - 1000）%256 1000 = 延迟时间/机械周期 机械周期 = 12*（1/晶振频率）
	TH0 = 0xFC;				//设置定时初始值	（65536 - 1000）/256
	TF0 = 0;				//清除TF0标志
	ET0 = 1;				//使能定时器0中断
	EA = 1;					//使能中断总开关
	TR0 = 1;				//定时器0开始计时

}

void Timer0_Isr(void) interrupt 1
{
	TR0 = 0;					//关闭定时计数器
	if(g_u16_time1_cnt)
	{
		g_u16_time1_cnt--;
		if(!g_u16_time1_cnt)
		{
			g_u8_time1_flag = 1;
			TL0 = 0x18;				//设置定时初始值
			TH0 = 0xFC;				//设置定时初始值
		}
	}
		if(g_u16_time2_cnt)
	{
		g_u16_time2_cnt--;
		if(!g_u16_time2_cnt)
		{
			g_u8_time2_flag = 1;
			TL0 = 0x18;				//设置定时初始值
			TH0 = 0xFC;				//设置定时初始值
		}
	}
	TL0 = 0x18;				//设置定时初始值
	TH0 = 0xFC;				//设置定时初始值
	TR0 = 1;					//打开定时计数器
}

接下来是任务的实现

#include "reg52.h"
#include "intrins.h"

/*管脚定义*/
sbit P10 = P1^0;
sbit P11 = P1^1;
sbit P12 = P1^2;
sbit P13 = P1^3;
sbit P14 = P1^4;
sbit P15 = P1^5;
sbit P16 = P1^6;
sbit P17 = P1^7;

sbit P20 = P2^0;
sbit P21 = P2^1;
sbit P22 = P2^2;
sbit P23 = P2^3;
sbit P24 = P2^4;
sbit P25 = P2^5;
sbit P26 = P2^6;
sbit P27 = P2^7;

/*延迟时间定义*/
#define _TIME1 1000
#define _TIME2 1000

void _init(void)
{
	g_u16_time1_cnt = _TIME1;//设置时间积累量
	g_u8_time1_flag = 0;//初始化时间标志位
	
	g_u16_time2_cnt = _TIME2;
	g_u8_time2_flag = 0;
}

void _task1(void)
{
	static unsigned char u8_step = 0;
	switch(u8_step)
	{
		case 0:
			if(_testbit_(g_u8_time1_flag))
			{
				g_u16_time1_cnt = _TIME1;
				P10 = 1;
				P11 = 1;
				P12 = 1;
				P13 = 1;
				P14 = 1;
				P15 = 1;
				P16 = 1;
				P17 = 1;
				u8_step = 1;
			}
			break;
		case 1:
			if(_testbit_(g_u8_time1_flag))
			{
				g_u16_time1_cnt = _TIME1;
				P10 = 1;
				P11 = 1;
				P12 = 1;
				P13 = 1;
				P14 = 1;
				P15 = 1;
				P16 = 1;
				P17 = 1;
				u8_step = 0;
			}
			break;
		default:
			break;
	}
}

void _task2(void)
{
	static unsigned char u8_step = 0;
	switch(u8_step)
	{
		case 0:
			if(_testbit_(g_u8_time2_flag))
			{
				g_u16_time2_cnt = _TIME2;
				P20 = 1;
				P21 = 1;
				P22 = 1;
				P23 = 1;
				P24 = 1;
				P25 = 1;
				P26 = 1;
				P27 = 1;
				u8_step = 1;
			}
			break;
		case 1:
			if(_testbit_(g_u8_time2_flag))
			{
				g_u16_time2_cnt = _TIME2;
				P20 = 1;
				P21 = 1;
				P22 = 1;
				P23 = 1;
				P24 = 1;
				P25 = 1;
				P26 = 1;
				P27 = 1;
				u8_step = 0;
			}
			break;
		default:
			break;
	}
}

这个可以当成一个模板，当需要多任务并行时，可以使用，同样与定时器那部分的代码差别不大，但是有一点不同，就是它没有使用传统的

if(1 == g_u8_time_flag){   
            g_u8_time_flag = 0;}

而是使用了库函数_testbit_()，这个函数可以检测数据是否为1，同时将数据清零，这样我们定义标志位时就可以用 bit 这个数据类型，既可以节省存储空间，又可以优化代码，一举两得，不过要注意，这个库函数需要包含#include "intrins.h"这个头文件。

当我们需要多个软件定时器时，可以在定时器初始化时进行补偿，使得定时器更加精确。当我们加任务的时候要注意，一个任务不能把CPU的所有时间占满，要雨露均沾。

  • 心得体会

这些需要延迟的函数我觉得都是一个套路，设定一个积累变量，一个标志位，当积累变量到达规定值，将标志位反转，然后执行程序，初始化积累变量，标志位，。

非阻塞延迟其实就是将一个循环，分成多个步骤，每次只运行一个，因为我们与机器所在的时间维度不同，所以我们会感觉任务是同时实现的，我觉得这种思想可以学习，就是无法执行多个任务是，将任务拆分为多个部分，然后运行，以达到同时执行的效果。

本文参考B站UP金善愚的视频

阻塞延时与非阻塞延时之非阻塞延时实现LED闪烁（累计主循环次数）

非阻塞延时实现LED闪烁功能（ 累计定时中断次数）——多路软件定时器的实现

软件定时器非阻塞延时并行处理实现两路跑马灯——基于状态切换

三无凡人
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
项目 2-2 独立按键进阶——非阻塞延时实现独立按键的识别与数码管动态刷新的常用程序框架——基于定时器
weixin_43251807的博客
10-01 284
非阻塞延时实现独立按键的识别与数码管动态刷新的常用程序框架——基于定时器 参考金善禹
单片机阻塞延时与非阻塞延时（1）
fuyuyf的博客
02-05 2942
阻塞延时函数与非阻塞延时函数
单片机实现非阻塞延时
h17878761977的博客
04-10 717
单片机实现非阻塞延时。
延时函数（阻塞式，非阻塞式）
Luojw_98的博客
06-14 4254
非阻塞式延时思路
Qtime非阻塞延时和Sleep阻塞延时
康闯
03-17 1600
最简单的延时方法就是使用QThread类的sleep(n)、msleep(n)、usleep(n)，这几个函数的不良后果就是，GUI会在延时的时间段内失去响应，界面卡死，所以，这三个函数一般用在非GUI线程中。等到 QTimer启动指定毫秒后就会触发 timeout 信号, 接着就会调用上面 connect 的槽函数。（3）然后再.cpp文件中的构造器里面初始化 QTimer 和 连接 槽函数。阻塞的原理就是：在延时期间，本线程的事件循环得不到执行。（1）在头文件（.h文件）声明 QTimer。
基于CC算法的信号延迟时间和嵌入维数计算
FPGA/MATLAB学习教程/源码/项目合作开发
11-25 550
信号延迟时间和嵌入维数是信号处理领域中的两个重要参数。信号延迟时间是指信号从发送端到接收端的传播时间，对于控制系统和网络传输等领域具有重要意义。嵌入维数则是描述信号复杂性的一个重要特征，对于信号的分类和识别具有重要作用。因此，准确计算信号延迟时间和嵌入维数是信号处理领域的一个重要问题。
延迟限流算法
yinhaoh的博客
08-13 307
限流算法+延迟限流，实现求和更新的限流计算
51单片机延时算法
10-10
主要是一些51常用的延时，以及延时所需时间的算法，即如何计算延时的时间长度
汇编延时程序算法详解
08-04
本文旨在对汇编程序的延时算法进行详细的讲解，以帮助初学者更好地理解和掌握相关知识。延时程序是指计算机反复执行一段程序以达到延时的目的，在单片机应用程序中经常需要短时间延时。 首先，需要了解指令周期、...
51单片机延时程序算法详解.doc
05-08
"51单片机延时程序算法详解" 本文详细解释了51单片机延时程序算法的实现原理和计算方法。首先，文章介绍了指令周期、机器周期与时钟周期的概念，并解释了MCS-51单片机的机器周期和时钟周期的关系。 然后，文章通过...
Keil51中几种精确延时算法
05-26
提供几种51的精确延时算法，各位童鞋，大家互相学习学习，有好的想法，在评论中交流哈！
单片机延时算法工具软件
05-05
一个轻松帮你计算单片机延时的软件，能做到精确延时，让你不用再为计算延时的复杂而烦恼，此软件轻松帮你搞定，只需你输入要延时的时间。
【Cortex-M架构】SysTick系统定时器阻塞和非阻塞延时
网易独家音乐人Mike Zhou的博客
12-01 1473
Cortex-M架构系统定时器阻塞和非阻塞延时
精妙的单片机非阻塞延时程序设计
qq_33712422的博客
10-15 1401
文章出处：http://blog.chinaunix.net/uid-29673749-id-4425603.html 精妙的单片机非阻塞延时程序设计  对于每个单片机爱好者及工程开发设计人员，在刚接触单片机的那最初的青葱岁月里，都有过点亮跑马灯的经历。从看到那一排排小灯按着我们的想法在跳动时激动心情。到随着经验越多，越来又会感觉到这个小灯是个好东西，尤其是在调试资源有限的环境中，有时会帮上大...
基于STM32标准库函数的LED流水灯实验
Constellation_zZ的博客
10-11 2152
我们首先打开keil MDK，点击“NEW PROJECT"命名好工程名字，文件路径。（建议工程名字使用英语）。完成后，选择STM32F103C8T6。随后弹出来的这个界面不用管，直接取消掉。这个是用它自带的library添加所需库函数。但是我试了很多次发现文件总是缺少一些，所以就自己手动添加了。与寄存器编程方式相比， 库函数更加具有逻辑性与模块性。
QT 不阻塞线程，达到延时的作用
在水一方
06-09 2199
这里穿插一个概念，所谓线程，不是new了一个线程对象就是线程，这个线程对象其实是在父线程中，跟其它对象一样，new了一个实例而已。所以使用继承QThread并重写run函数的方式实现线程时，一定切记，不是所有函数就一定会在线程中执行，除非它被run函数调用，或者在run当中使用rambda写匿名槽函数。而写匿名槽函数的时候，接收者千万别写this，this指针是指向父线程的线程对象，能作为句柄控制线程，但this隶属于父线程。上面说过线程的实现，离不开父线程的线程对象，它仅仅是子线程的操作句柄。
QT:非阻塞延迟
AI.PLAY
06-04 577
QT:非阻塞延迟
TCP之延时Nagle算法实验详解
qq_37247026的博客
07-04 846
Nagle 算法是应用在发送端的，简而言之就是，对发送端而言：• 当第一次发送数据时不用等待，就算是 1byte 的小包也立即发送• 后面发送数据时需要累积数据包直到满足下面的条件之一才会继续发送数数据包达到最大段大小MSS接收端收到之前数据包的确认 ACK。
C++ Primer Chapter 10 Generic Algorithms
最新发布
qq_22609521的博客
06-12 217
其中，capture list（捕获列表）是一个lambda所在函数中定义的局部变量的列表（通常为空）；单数，与普通函数不同，lambda必须使用尾置返回来指定返回类型。一个lambda表达式表示一个可调用的代码单元。与任何函数类似，一个lambda具有一个返回类型、一个参数列表和一个函数体。即，如果e是一个可调用的表达式，则我们可以编写代码e(args)，其中args是一个逗号分隔的一个或多个参数的列表。对于一个对象或一个表达式，如果对其使用调用运算符，则称它为可调用的。
FPGA相控延时算法
09-30
相控延时算法是一种通过调整信号的相位以实现延时的算法。在FPGA设计中，相控延时算法可以用于时钟信号的延时控制，以满足不同模块之间的时序要求。常见的相控延时算法包括锁相环（PLL）和延时锁定环（DLL）。 锁相环是一种常用的相控延时算法，它通过比较输入信号和反馈信号的相位差，并根据相位差的大小控制输出信号的延时。锁相环主要由相频比较器、环形计数器和数字控制电压控制振荡器（DCO）等组成。 延时锁定环也是一种常见的相控延时算法，它使用延时线和比较器来产生相位差，并通过调整延时线的长度来控制输出信号的延时。 以上是两种常见的相控延时算法，它们在FPGA设计中都起到了重要的作用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值