关于延时机制的状态机讨论

ID:326261 · 发表于 2023-5-22 09:24

这个帖子对于我这个刚入门的软件开发遇到的瓶颈，希望各位大牛帮忙，谢谢！！
也望此贴下大家踊跃讨论，给出不同意见，为各位新人解答疑惑。

--------------------------------------分割线---------------------------------------------------------------------------------
目前遇到的问题：
-1、在做LCD1602显示的时候，因为LCD1602需要做忙检测延时，硬件又没有预留读IO的口，导致需要做延时才能应付LCD1602忙检测，延时1ms。

-2、系统时间要求较高，不能用原地延时，则需要做状态机。

-3、但是这个延时的状态机需要怎么做才能每次按键进来，显示字符，发送一个数据/指令，下次还能再进来，重新回到同一个地方？

我假认的处理方式（未编程确认）是：
①、每次进来发送一次数据/指令设置为一个状态，这样下次进这个状态检测既可，但是这样的状态数太多了，几乎重新写了整个程序。

②、字符都放置到数组里面，每次进来读取数组，每次发送一组指令/数据进入下一个状态，结构体附带数据个数，相比①，这样就缩小了每次发一组显示数据的状态数，这样写要考虑数据放的顺序，和状态数也是不少的。

③、我假想，设置一个临时状态，进来后将当前状态给到临时状态，当前状态+1，判断是否相等，状态机到了之后，将当前状态给到临时状态，这样，相等就运行，不相等就进入延时，好像几乎第①相等，具体思路还没捋顺

......
4、而且我这个是多级菜单的显示，每个显示都要做状态机也太多了

----------------到此，希望各位给点思路，延时状态机该如何写，代码重构要怎么去实施，在此先谢谢大家-------------------------------------

ID:94031 · 发表于 2023-5-22 11:18

延时用中断，要延时时打开延时中断并设标志，继续干别的事，延时到改延时标记，这样延时不影响干别的事。

ID:1065084 · 发表于 2023-5-22 11:29

状态机嘛，就是状态嘛，为什么不能有子状态呢？
你这个提问的最大问题是没有写清楚系统功能和需求，根据系统功能和需求来切分状态。
我假设你是 1602显示，按键控制，18B20测温，外部通信这几个功能。

显示改变的触发条件是温度变化，按键动作，通信动作

18b20的触发条件就是比如定时器1s测温一次，测温后读出数据

按键的触发条件就是 20ms读一次按键状态

外部通信就是比如串口接受数据，接受一定量数据触发数据处理

上面这些就是状态机中的状态，所谓的状态就是一个用于判断的数字，譬如按键就是为不同按键状态设置不同键值，然后根据键值和当前菜单状态判断下一步操作。
所以状态机不是一个变量用起来没完，而是多个变量代表不同意义，比如键值为0说明按键未动，那显示函数中根据键值判断当前菜单不操作。比如18b20温度测量后比较上一次值确定“温度变化”状态是否刷新，刷新后显示函数中的温度才会变化。
如果系统对低功耗没有要求，那系统大部分时间都是在判断这个状态进不去，那个状态也进不去的“空转”，大体分开来讲状态机的变化条件就是 “时间”和“事件”两种，你所谓的“延时”代码在系统内可以分为两种：
1.不精确的延时，采用“时间片”的方法，譬如你最小延时为1ms，可以定时器1ms触发一次，比如按键就20次触发一次按键扫描。譬如你显示函数中写完数据要等待1ms反应，因为你长于1ms也无所谓，所以你直接将写完数据设置为一个状态1，下一次可以写数据设置为一个状态2，状态1的触发条件是写数据动作，状态2的触发条件是状态1下定时器触发了一次。
2.精确的延时，一般是先处理完等待的任务后，关闭中断，使用cpu精确延时，注意这时要考虑阻塞情况，会比较麻烦。

状态机编程是将你所有的程序打乱根据时间和事件进行重排。系统内正常就没有延时函数了，所有需要延时的地方都要重新判断和排列，当然你也可以编写一个“假延时”函数用于暂时释放系统资源，但是这个有软件重入的问题存在，这时上操作系统相对会更好一些。当然对于你这特别简单的项目，状态机还是明显优于操作系统的，操作系统有cpu 内存和固件开销，绝大部分项目不需要的。

ID:161164 · 发表于 2023-5-22 11:50

1. 除了清屏，其它写命令/数据延时只需40us
2. 建立一个显存数组(或两个，一行一个), 有数据更新，只更新显存，然后更新标志位置位(Flag_
3. 在主循环中根据更新标志位把显存数组写进LCD，每次循环只写一个字

u8 DispBuff[32];
bit Flag_Row1_Update = 0;
bit Flag_Row2_Update = 0;
void LCD_Update()
{
static u8 i = 0;
if(Flag_Row1_Update)
{
if(i==0)LCD_WriteCMD(0x80);
LCD_WriteData(DispBuff[i]);
if(++i>=16)
{
i=0;
Flag_Row1_Update = 0;
}
}else if(Flag_Row2_Update)
{
if(i==0)LCD_WriteCMD(0xC0);
LCD_WriteData(DispBuff[i+16]);
if(++i>=16)
{
i=0;
Flag_Row2_Update = 0;
}
}
}

复制代码

ID:326261 · 发表于 2023-5-22 13:19

xuyaqi 发表于 2023-5-22 11:18
延时用中断，要延时时打开延时中断并设标志，继续干别的事，延时到改延时标记，这样延时不影响干别的事。

是的，分出一个定时器来作延时中断，一般延时使用，用一个计数寄存器器来判断延时时间。

ID:526543 · 发表于 2023-5-22 13:21

针对你提到的问题，我可以给你一些建议和思路来处理延时状态机的编写和代码重构。首先，关于问题1中LCD1602的忙检测延时，如果你的硬件没有预留读取IO的口，可以考虑使用软件延时。你可以通过循环执行一段时间来模拟延时，例如使用一个延时函数，该函数通过循环指定次数来达到延时的效果。你可以根据你的具体需求来调整循环的次数，以达到所需的延时时间。关于问题2中系统时间要求较高的情况，可以考虑使用状态机来处理。状态机是一种用于管理系统状态的方法，它可以帮助你在不使用原地延时的情况下实现所需的功能。你可以定义不同的状态，并在每个状态中执行相应的操作。在状态机中，你可以使用条件语句（如switch-case语句）来根据当前状态执行相应的操作或者切换到下一个状态。对于问题3，你可以考虑使用一个临时状态来帮助处理延时状态机。当进入一个状态时，将当前状态保存到临时状态中，并将当前状态递增。然后，判断当前状态是否等于临时状态，如果相等，则执行相应的操作，否则进行延时。这样可以确保每次进入状态机时都会检测到是否需要延时。对于多级菜单的显示，可以考虑使用层级结构来管理状态机。你可以定义不同的状态和菜单层级，并在每个状态中执行相应的操作或者切换到下一个状态。这样可以避免在每个显示中都编写独立的状态机，而是通过管理菜单层级来实现整体的状态控制。在进行代码重构时，你可以考虑将字符放置到数组中，使用循环来处理数组中的数据。这样可以简化代码，并减少状态的数量。你可以定义一个索引变量来追踪当前处理的数组元素，每次处理完一个元素后，递增索引，然后根据索引获取下一个要处理的元素。最后，为了更好地进行代码重构，建议使用函数和模块化编程的方式。将不同的功能模块分解成独立的函数，并通过函数的调用来实现状态的切换和处理。这样可以提高代码的可读性和可维护性，同时也便于进行功能扩展和修改。希望以上的建议对你有所帮助，

ID:326261 · 发表于 2023-5-22 13:24

yuxuesuixing 发表于 2023-5-22 11:29
状态机嘛，就是状态嘛，为什么不能有子状态呢？
你这个提问的最大问题是没有写清楚系统功能和需求，根据系 ...

嗯对，状态机即为判断当前状态来进入对应功能，代码需要重构的。
现在有疑问的地方就是，每发一个字节就需要延时，LCD显示一次需要连续发34个字节，所以状态数比较多。
并且此程序是作多级菜单的，就是发不同显示，那状态机的状态数更多了，状态机的代码都要超过源程序代码量了，感觉有点矛盾。

ID:326261 · 发表于 2023-5-22 14:05

lkc8210 发表于 2023-5-22 11:50
1. 除了清屏，其它写命令/数据延时只需40us
2. 建立一个显存数组(或两个，一行一个), 有数据更新，只更新 ...

请问指令和数据一个字节所需要的时间是怎么得到40us的吗？是否有文档确认？
图中是时序图，你是从时序图推出指令/数据时间的吗？

你的方案是比较接近实际的，加上延时判断最好了。
我目前做的也是和你这个方式类似，所有数据放进一个数据包里，每次更新数据，则更新数据包状态机，如：LCD1602两行数据，加指令，需要38个状态机状态，每次更新数据，就写一遍状态机数据。

这个应该是比较好的一个方法了

ID:161164 · 发表于 2023-5-22 14:12

工学院陈伟霆发表于 2023-5-22 14:05
请问指令和数据一个字节所需要的时间是怎么得到40us的吗？是否有文档确认？
图中是时序图，你是从时序图 ...

ID:326261 · 发表于 2023-5-22 14:32

lkc8210 发表于 2023-5-22 14:12

对的，感谢，是我看漏了，抱歉

ID:326261 · 发表于 2023-5-22 14:34

123456ZXC1 发表于 2023-5-22 13:21
针对你提到的问题，我可以给你一些建议和思路来处理延时状态机的编写和代码重构。首先，关于问题1中LCD16 ...

受益匪浅，感谢！

ID:94031 · 发表于 2023-5-22 14:41

按你的描述，就是想解决LCD1602显示与及时响应按键的冲突，不需要搞得那么复杂，处理LCD1602显示时间很短，完全可以处理完LCD1602显示后判断按键处理按键，这有什么问题吗？

ID:326261 · 发表于 2023-5-22 14:51

xuyaqi 发表于 2023-5-22 14:41
按你的描述，就是想解决LCD1602显示与及时响应按键的冲突，不需要搞得那么复杂，处理LCD1602显示时间很短， ...

我的问题是
因为LCD忙检测需要延时，但不能影响程序响应，即不能原地延时。

程序中遇到的问题是代码重构，上面的解决方法应该是需要状态机了，状态机的编写遇到了困惑，我的显示太多了，每发一个字节进入一次状态机状态，那么一路下来状态机太庞大了。

ID:94031 · 发表于 2023-5-22 15:05

原地延时影响什么功能了。

ID:326261 · 发表于 2023-5-22 15:10

xuyaqi 发表于 2023-5-22 15:05
原地延时影响什么功能了。

影响了另一部分程序的数据收发和IO判断响应，总的说，ms级的原地延时还是尽量避免，并且LCD1602，一次发16个字节，就有16ms以上的固定时间了。

ID:94031 · 发表于 2023-5-22 15:31

工学院陈伟霆发表于 2023-5-22 15:10
影响了另一部分程序的数据收发和IO判断响应，总的说，ms级的原地延时还是尽量避免，并且LCD1602，一次发1 ...

那你数据收发和IO判断期间不刷新LCD1602可以吗？

ID:326261 · 发表于 2023-5-22 15:39

xuyaqi 发表于 2023-5-22 15:31
那你数据收发和IO判断期间不刷新LCD1602可以吗？

我的按键控制LCD1602刷新，在LCD刷新时不能影响IO口的接收判断。

按照您的说法，设两个状态位，那么代码需要考虑的地方应该会很多。

关于延时机制，我还是不建议经常使用原地循环做延时，除非时间非常短。

ID:384109 · 发表于 2023-5-22 15:48

感觉还是你的整体结构和构思的问题，虽然一直在强度LCD写数据延时等待不好，而硬件电路又没有设计查忙功能，那么即使硬件电路设计了查忙功能，那么查忙的最大延时一样还是1.6毫秒，那这种情况你又如何处理，又如何设置所谓的状态机

ID:94031 · 发表于 2023-5-22 16:02

工学院陈伟霆发表于 2023-5-22 15:39
我的按键控制LCD1602刷新，在LCD刷新时不能影响IO口的接收判断。

按照您的说法，设两个状态位，那么代 ...

16ms间隔不会影响IO口的接收判断，完全可以刷新完LCD再判断IO口,当然实时性要求高的系统要用状态机，但我觉得你这个应用不需要。你也可以每20ms来个定时中断，判断一下有无IO变化，有，处理IO，没有，刷新LCD。

ID:353115 · 发表于 2023-5-22 16:14

按键要改变当前页面，只需要提交数据到数组，页面的刷新定时执行即可，这样不会造成按键快速按下导致页面刷新堵塞。

ID:996773 · 发表于 2023-5-22 16:18

楼主的编程思路可能有问题，状态机我也不懂，我也写过类似的程序，我的思路是这样，1602不要查忙，

不要查忙，不要查忙，重点说三遍。一开机1602初始化，把固定不变的显示字符都显示，然后就是主程

序不停的查按键，一旦按键触发，再去执行模数转换和处理，在去把1602变化的显示单元显示，这种程

序够简单，定时器和中断都不需要够运行了，不要以为用了定时器和中断就是高手，真正高手是用更少的资

源干定时器中断同样能做到的事

ID:326261 · 发表于 2023-5-22 16:52

hi等你发表于 2023-5-22 16:18
楼主的编程思路可能有问题，状态机我也不懂，我也写过类似的程序，我的思路是这样，1602不要查忙，

...

可能主MCU不同，你的程序不需要查忙，具体不细究

我的主MCU是stm32f4，主频180M，IO时钟45M/90M，外加spi控制595转并驱动DB0-DB7去显示。

出现的问题是，SPI发送速度足够快，第一个字节发送完，显示缓存还没稳定，已经开始发第二个字节了，导致显示出现乱码。

为什么查忙？LCD数据手册你是否看过？时序逻辑图、指令时间，你是否掌握？
作为一个开发者，不仅仅是开发，还要保障系统的极限和稳定，不浪费资源的同时，达到手册的最佳要求，且不会受干扰影响程序运行。

不是你说的用了定时器和中断就是高手，我也在找解决办法，是程序实时性比较高，不能兼容原地等待，如果你有更好的方法，能够保证不用原地等待，也能保证LCD显示正确，我洗耳恭听

ID:326261 · 发表于 2023-5-22 16:57

qsssuv 发表于 2023-5-22 16:14
按键要改变当前页面，只需要提交数据到数组，页面的刷新定时执行即可，这样不会造成按键快速按下导致页面刷 ...

方法是可行的，定时刷新我觉得没有必要，既然LCD有显存，发送一次即可，多次发送会占用系统资源。
现在的问题不是按键按的快，是显示的数据发送太快，需要在每个发送字节加上一个延时，来替代忙检测。

可以在按键按下的时候刷新数据，但是发送数据延时也要加上的，所以状态机也是要的。

ID:275826 · 发表于 2023-5-22 18:05

学习了一下，编程最简单能实现楼主要求的方法就是用非阻塞延时函数，也就是通过循环执行一段时间来模拟延时，该函数通过循环指定次数来达到延时的效果。你可以根据你的具体需求来调整循环的次数，以达到所需的延时时间。

ID:213173 · 发表于 2023-5-23 10:20

LCD1602、DS18B20、按键消抖、长短按识别等都是对时序有一定要求的外部硬件。用常见的阻滞型延时函数写代码，单独使用一般都没有什么问题，多个外部硬件组合在一起就会起冲突。楼主这个困局其实不难处理，也不一定非得用状态机、时间片。就用一个定时器，主函数按合适的最小周期轮询所有子函数模块，反正单片机也累不死。以下示例改编于一款温度上下限报警程序+仿真，其中的数码管是为了代替可能增加其它硬件刻意塞进去搅局、P0分时复用增加难度的。此代码有可能对楼主有所帮助。其中变量、注释未必恰当，亦或错漏，仅供参考，请高手绕道勿喷。

#include <AT89X52.h>
#define uint unsigned int
#define uchar unsigned char //宏定义
#define key_S 10 //定义短按(约20ms)
#define key_L key_S*50 //定义长按(约500ms)
#define key_I key_S*38 //定义长按连+/-间隔(约120ms)
sbit LCD_RS =P2^4; //液晶屏RS口写指令低，写数据高
sbit LCD_EN =P2^5; //液晶屏EN口高脉冲使能写指令/数据，低跳变执行
sbit limit_H=P2^6; //定义上限灯光报警
sbit limit_L=P2^7; //定义下限灯光报警
sbit SET = P3^3; //定义调整键
sbit DEC = P3^4; //定义减少键
sbit ADD = P3^5; //定义增加键
sbit BEEP = P3^6; //定义蜂鸣器
sbit DQ = P3^7; //定义DS18B20总线I/O
uchar code LEDData[]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0x89,0x83,0x86,0xA1,0x86,0x8E};
uchar data dis_buf[4];//数码管显示缓存
uchar data dis_buf1[]={'T','e','m','p',':','0','0','0','.','0',0xdf,'C'};
int Ceiling=38; //上限报警温度，默认值为38
int Bottom=5; //下限报警温度，默认值为5
int temp,tempM; //温度变量
uchar tempH,tempL; //高4位以上整数，低4位小数
bit negative; //负号标志
uchar KeySec=0; //键值
/*****延时子程序*****/
void Delay(uint num)//T=num*8+6us
{
while(--num);
}
/*******液晶写指令程序********/
void write_com(uchar com)
{
LCD_RS=0; //允许写指令
P0=com; //传递指令
Delay(120); //延时966us
LCD_EN=1; //使能写入
Delay(120); //延时966us
LCD_EN=0; //低跳变执行
}
/*******液晶写数据程序********/
void write_date(uchar date)
{
LCD_RS=1; //允许写数据
P0 =date; //传递数据
Delay(120); //延时966us
LCD_EN=1; //使能写入
Delay(120); //延时966us
LCD_EN=0; //低跳变执行
}
/*******液晶初始化程序********/
void LCDinit() //设置显示模式、
{
LCD_EN=0; //初始设置LCD_EN低电平
write_com(0x38);//设置16*2显示，5*7点阵，8位数据接口
write_com(0x01);//显示清零，数据指针清零
write_com(0x0c);//设置开显示，不显光标
write_com(0x06);//设置写一个字符后地址指针加1
}
/*****初始化DS18B20*****/
void Init_DS18B20(void)
{
uchar x=0;
DQ = 1; //DQ复位
Delay(2); //稍做延时22us
DQ = 0; //单片机将DQ拉低
Delay(60); //精确延时大于480us//486us
DQ = 1; //拉高总线
Delay(12); //102us
x = DQ; //稍做延时后，如果x=0则初始化成功，x=1则初始化失败
Delay(6); //54us
}
/*****读一个字节*****/
uchar ReadOneChar(void)
{
uchar i=0;
uchar dat = 0;
for(i=8;i>0;i--)
{
DQ = 0; // 给脉冲信号
dat>>=1;
DQ = 1; // 给脉冲信号
if(DQ)
dat|=0x80;
Delay(6); //54us
}
return(dat);
}
/*****写一个字节*****/
void WriteOneChar(uchar dat)
{
uchar i=0;
for (i=8; i>0; i--)
{
DQ = 0;
DQ = dat&0x01;
Delay(6); //54us
DQ = 1;
dat>>=1;
}
Delay(6); //54us
}
/*****温度值转换*****/
void ReadTemperature()
{
static uchar i=0;
uchar a=0,b=0;
switch(i)
{
case 0:
Init_DS18B20();
WriteOneChar(0xCC);//跳过读序号列号的操作
WriteOneChar(0x44);//启动温度转换
break;
case 3:
Init_DS18B20();
WriteOneChar(0xCC);//跳过读序号列号的操作
WriteOneChar(0xBE);//读取温度寄存器
break;
case 5:
a=ReadOneChar(); //读低8位
b=ReadOneChar(); //读高8位
temp=b<<8|a; //高8位+低8位转移到t
break;
case 6:
tempM=temp;
if(temp&0x8000)
{
negative=1; //负号标志
temp=~temp+1; //取反加1
}
else negative=0; //正数
tempH=temp>>4; //分解出整数
tempL=temp&0x0F; //分解出小数
tempL=tempL*0.625; //保留1位小数
}
i=++i%7;
}
void disassemble()
{
if(KeySec==0)//显示初始状态'----'
{
dis_buf[0]=0xbf;
dis_buf[1]=0xbf;
dis_buf[2]=0xbf;
dis_buf[3]=0xbf;
dis_buf1[5]='-';
dis_buf1[6]='-';
dis_buf1[7]='-';
dis_buf1[9]='-';
}
else if(KeySec==1)//显示温度
{
if(negative==1)
{
if(tempH>=10)
{
dis_buf[0]=0xbf;//显示负号
dis_buf[1]=LEDData[tempH/10%10];
dis_buf1[5]='-';
dis_buf1[6]=tempH/10%10+'0';
}
else if(tempH<10)//小于100
{
dis_buf[0]=0xff;//不显示
dis_buf[1]=0xbf;//显示负号
dis_buf1[5]=' ';
dis_buf1[6]='-';
}
}
else
{
if(tempH>=100)
{
dis_buf[0]=LEDData[tempH/100];
dis_buf1[5]=tempH/100+'0';
}
else
{
dis_buf[0]=0xff;//不显示
dis_buf1[5]=' ';
}
if(tempH>=10)
{
dis_buf[1]=LEDData[tempH/10%10];
dis_buf1[6]=tempH/10%10+'0';
}
else
{
dis_buf[1]=0xff;//不显示
dis_buf1[6]=' ';
}
}
dis_buf[2]=LEDData[tempH%10]&0x7f;
dis_buf[3]=LEDData[tempL];
dis_buf1[7]=tempH%10+'0';
dis_buf1[9]=tempL+'0';
}
else if(KeySec==2)//显示调整上限
{
dis_buf[0]=0x89;//显示'H'
dis_buf[1]=LEDData[Ceiling/10%10];
dis_buf[2]=LEDData[Ceiling%10]&0x7f;
dis_buf[3]=LEDData[0];
dis_buf1[5]='H';//显示'H'
dis_buf1[6]=Ceiling/10%10+'0';
dis_buf1[7]=Ceiling%10+'0';
dis_buf1[9]='0';
}
else if(KeySec==3)//显示调整下限
{
dis_buf[0]=0xc7;//显示'L'
dis_buf[1]=LEDData[Bottom/10%10];
dis_buf[2]=LEDData[Bottom%10]&0x7f;
dis_buf[3]=LEDData[0];
dis_buf1[5]='L';//显示'L'
dis_buf1[6]=Bottom/10%10+'0';
dis_buf1[7]=Bottom%10+'0';
dis_buf1[9]='0';
}
}
/*****显示子程序*****/
void display()
{
static uchar i,j;
static bit flag=0;
//数码管与LCD1602交替刷新
if(!flag)
{
P2&=0xf0;//清P2低4位数码管消隐
switch(j)
{
case 0:LCD_RS=0;P0=0x85; break;//坐标指令
case 1:LCD_RS=1;P0=dis_buf1[5]; break;//更新字符
case 2:P0=dis_buf1[6]; break;
case 3:P0=dis_buf1[7]; break;
case 4:P0=dis_buf1[8]; break;
case 5:P0=dis_buf1[9]; break;
}
LCD_EN=1;
j=++j%6;
}
else
{
LCD_EN=0;
P0=dis_buf[i];//送段码
P2|=0x01<<i; //送位码
i=++i%4; //位扫描计数
}
flag=~flag;
}
//按键扫描
void keyscan()
{
static uint time=0;
if(!SET||!DEC||!ADD)
{
time++;
if(time>key_L)//长按计数
time=key_I;//连+/-间隔
if(time==key_S)//短按消抖
{
if(!SET)
{
KeySec++;
if(KeySec>3)
{
KeySec=1;
}
}
}
if(time==key_S||time==key_L)//短按消抖或长按连+/-
{//设置范围0~99℃，上限不小于下限+1℃ 下限不大于上限-1℃，
if(!DEC && KeySec>1)
{
switch(KeySec)
{
case 2: if(Ceiling>1&&Ceiling>(Bottom+1))Ceiling--; break;
case 3: if(Bottom>0)Bottom--; break;
}
}
if(!ADD && KeySec>1)
{
switch(KeySec)
{
case 2: if(Ceiling<99)Ceiling++; break;
case 3: if(Bottom<(Ceiling-1))Bottom++; break;
}
}
}
}
else time=0;
}
/*****报警子程序*****/
void Alarm()
{
static unsigned int count=0;
if(tempM>(Ceiling<<4))//超上限
limit_H=0; //LED亮
else limit_H=1; //LED灭
if(tempM<(Bottom<<4)) //超下限
limit_L=0; //LED亮
else limit_L=1; //LED灭
if(limit_H==0||limit_L==0)
{
count++;
if(count>50)
BEEP=1;
if(count>=100)
{
count=0;
BEEP=0;
}
}
else
{
count=0;
BEEP=0;
}
}
void Timer0Init() //2毫秒@12.000MHz
{
TMOD |= 0x01; //设置定时器模式
TL0 = 0x30; //设置定时初始值
TH0 = 0xF8; //设置定时初始值
TF0 = 0; //清除TF0标志
TR0 = 1; //定时器0开始计时
}
/*****主函数*****/
void main(void)
{
uint z;
BEEP=0;//蜂鸣器初始化
P2&=0xf0;//清P2低4位数码管消隐
LCDinit();//初始化LCD
write_com(0x80);//固定字符
for(z=0;z<12;z++)
write_date(dis_buf1[z]);
for(z=0;z<7;z++)
ReadTemperature();//初始读DS18B20
disassemble();//
for(z=380;z>0;z--)//不显示DS18B20初始85℃
{
display(); //显示'----'
Delay(250); //2ms
}
KeySec=1;//键值初始化
Timer0Init();//定时器初始化
while(1)
{
if(TF0)
{
TF0 = 0;
TL0 = 0x18; //设置定时初始值
TH0 = 0xFC; //设置定时初始值
display();//显示扫描
ReadTemperature();//温度检测
keyscan();//按键扫描
disassemble();//数据分解
Alarm();//报警检测
}
}
}

复制代码

ID:326261 · 发表于 2023-5-24 10:37

tyrl800 发表于 2023-5-22 18:05
学习了一下，编程最简单能实现楼主要求的方法就是用非阻塞延时函数，也就是通过循环执行一段时间来模拟延 ...

非阻塞式延时不是循环执行，是以状态机来判断延时。你的理解反了

把当前状态列入保护现场，开启延时，程序继续运行，不影响整个程序，下次进来时，还要回到计时的节点来判断是否定时到达，定时未到达，则继续，定时到达则进入下一个状态或者释放状态机。

ID:326261 · 发表于 2023-5-24 10:39

wulin 发表于 2023-5-23 10:20
LCD1602、DS18B20、按键消抖、长短按识别等都是对时序有一定要求的外部硬件。用常见的阻滞型延时函数写代码 ...

你的程序我看了，如果你认真审题，当你delay开始while--的时候就已经对不上我的问题了

我的初衷就是程序中不能出现while等待，程序实时性很高的，会影响其他资源运行。

ID:644357 · 发表于 2023-5-24 10:46

使用操作系统，把LCD任务设置高优先级，遇到忙延时就挂起或者阻塞，不影响其他线程，理查德、

ID:644357 · 发表于 2023-5-24 10:48

使用操作系统，LCD设置高优先级，忙延时进入阻塞，显示任务完成后挂起等待标志位恢复线程，这样能把每一个忙延时榨干净，还能不影响其他线程运行，也不影响中断触发

ID:213173 · 发表于 2023-5-24 15:59

本帖最后由 wulin 于 2023-5-24 16:10 编辑

工学院陈伟霆发表于 2023-5-24 10:39
你的程序我看了，如果你认真审题，当你delay开始while--的时候就已经对不上我的问题了

我的初衷就是程 ...

...........

ID:384109 · 发表于 2023-5-24 16:27

按楼主的需求，的确如29楼说的用操作系统最好，而且楼主的还是32的F4芯片，跑操作系统就更方便了

ID:744809 · 发表于 2023-5-24 22:55

/* main.c */
#include <REGX52.H>
#include <stdio.h>
#include "lcd1602.h"
#define MAIN_FOSC_DELAY 12000000UL
#define T1MS_0 (65536-MAIN_FOSC_DELAY/12/1000) //1ms timer calculation method in 12T mode
#define T1MS_1 (65536-MAIN_FOSC_DELAY/12/1000) //1ms timer calculation method in 12T mode
#define TIMER_MODE0 0x00
#define TIMER_MODE1 0x01
#define TIMER_MODE2 0x02
#define TIMER_MODE3 0x03
static bit _1_ms_flag = 0; //1ms标志位
static bit _100ms_flag = 0; //100ms标志位
static bit _500ms_flag = 0; //500ms标志位
static void Timer0Init( void );
//主函数
int main( void )
{
idata float disTemp[4] = {0};
idata unsigned char display_buf[16];//显示数组
idata unsigned int display_len;//显示数据长度
Timer0Init();
MngLCD1602_Init();//LCD1602初始化
EA = 1;
while( 1 )
{
if(1 == _100ms_flag)
{
_100ms_flag = 0;
disTemp[0] += 0.1f;
disTemp[1] += 0.2f;
disTemp[2] += 0.3f;
disTemp[3] += 0.4f;
display_len = sprintf( display_buf, "%.2f ", disTemp[0] );
displayString( 0, 0, display_buf, display_len );
display_len = sprintf( display_buf, "%.2f ", disTemp[1] );
displayString( 10, 0, display_buf, display_len );
display_len = sprintf( display_buf, "%.2f ", disTemp[2] );
displayString( 0, 1, display_buf, display_len );
display_len = sprintf( display_buf, "%.2f ", disTemp[3] );
displayString( 10, 1, display_buf, display_len );
}
else
{
/* empty */
}
if(1 == _1_ms_flag)
{
_1_ms_flag = 0u;
MngLCD1602_Handle();
}
else
{
/* empty */
}
}
}
//定时器0中断
static void Timer0Init( void ) //定时器初始化为1ms一次
{
TMOD |= 0X01; //选择为定时器0模式，工作方式1，仅用TR0打开启动。
TL0 = T1MS_0;//给定时器赋初值，定时1ms ,计算方式(65536 -(12/12*1000))%256
TH0 = T1MS_0 >> 8;//给定时器赋初值，定时1ms ,计算方式(65536 -(12/12*1000))/256
ET0 = 1; //打开定时器0中断允许
TR0 = 1; //打开定时器
}
void time0_isr() interrupt 1 using 0
{
static unsigned int count = 0;
static unsigned int count2 = 0;
TL0 = T1MS_0;//手动重装载
TH0 = T1MS_0 >> 8;//手动重装载
_1_ms_flag = 1;//1ms标志位置1
if( ++count >= 100 ) //0.1秒到了
{
count = 0;
_100ms_flag = 1;//1秒标志位置1
}
if( ++count2 >= 500 )
{
count2 = 0;
_500ms_flag = 1;
}
}
/* LCD1602.h */
#ifndef __LCD1602_H_
#define __LCD1602_H_
/**********************************
包含头文件
**********************************/
#include <REGX52.H>
typedef unsigned long uint32_t;
typedef unsigned int uint16_t;
typedef unsigned char uint8_t;
/**********************************
PIN口定义
**********************************/
#define LCD1602_DATAPINS P0
sbit LCD1602_RS = P2 ^ 6;
sbit LCD1602_RW = P2 ^ 5;
sbit LCD1602_E = P2 ^ 7;
/**********************************
函数声明
**********************************/
extern void MngLCD1602_Init( void );
extern void MngLCD1602_Handle( void );
extern void displayString( uint8_t x, uint8_t y, uint8_t* dat, uint8_t len);
#endif
/* LCD1602.c */
#include "lcd1602.h"
#include <string.h>
#define LCD1602_ROW_NUM 2u
#define LCD1602_COLUMN_NUM 16u
#define LCD1602_READ_DATA() (LCD1602_DATAPINS)
#define LCD1602_WRITE_DATA(dat) (LCD1602_DATAPINS = (uint8_t)dat)
#define LCD1602_SET_RS_H() (LCD1602_RS = 1)
#define LCD1602_SET_RS_L() (LCD1602_RS = 0)
#define LCD1602_SET_RW_H() (LCD1602_RW = 1)
#define LCD1602_SET_RW_L() (LCD1602_RW = 0)
#define LCD1602_SET_E_H() (LCD1602_E = 1)
#define LCD1602_SET_E_L() (LCD1602_E = 0)
typedef enum
{
false = 0u,
true,
}Bool;
typedef enum
{
Ce_Sending = 0u,
Ce_SendOK,
}TeLCD1602_SendState;
typedef enum
{
Ce_SendAddr_00 = 0u,
Ce_SendData_00,
Ce_SendAddr_10,
Ce_SendData_10,
}TeLCD1602_SendStep;
typedef enum TeLCD1602_e_writeStateTypeTag
{
Ce_Stay_0 = 0u,
Ce_Stay_1 = 1u,
Ce_Stay_2 = 2u,
} TeLCD1602_e_writeStateType;
typedef struct TsLCD1602_h_RowParaTypeTag
{
const uint8_t* e_p_DisplayStartAddr;
const uint8_t* e_p_DisplayEndAddr;
} TsLCD1602_h_RowParaType;
typedef struct TsLCD1602_h_displayParaTypeTag
{
TeLCD1602_SendStep e_e_SendStep;
TeLCD1602_e_writeStateType e_e_WriteState;
TsLCD1602_h_RowParaType e_h_RowPara[LCD1602_ROW_NUM];
uint8_t* e_p_DisplayNextAddr;
} TsLCD1602_h_displayParaType;
static volatile uint8_t SeLCD1602_u_displayBuffer[LCD1602_ROW_NUM][LCD1602_COLUMN_NUM];
static volatile TsLCD1602_h_displayParaType SsLCD1602_h_displayPara;
static Bool MngLCD1602_IsBusy( void );
static void MngLCD1602_Display();
static TeLCD1602_SendState LcdWriteData( const uint8_t dat );
static TeLCD1602_SendState LcdWriteCom( const uint8_t com ) ;
static Bool MngLCD1602_IsBusy( void )
{
LCD1602_WRITE_DATA(0xff);
LCD1602_SET_RS_L();
LCD1602_SET_RW_H();
if( 0 != (LCD1602_READ_DATA() & 0x80) )
{
LCD1602_SET_E_L();
LCD1602_SET_E_H();
return true;
}
else
{
LCD1602_SET_E_L();
return false;
}
}
static TeLCD1602_SendState LcdWriteCom( const uint8_t com )
{
switch( SsLCD1602_h_displayPara.e_e_WriteState )
{
case Ce_Stay_0:
LCD1602_SET_RS_L();
LCD1602_SET_RW_L();
LCD1602_WRITE_DATA( com );
SsLCD1602_h_displayPara.e_e_WriteState = Ce_Stay_1;
return Ce_Sending;
break;
case Ce_Stay_1:
LCD1602_SET_E_H();
SsLCD1602_h_displayPara.e_e_WriteState = Ce_Stay_2;
return Ce_Sending;
break;
case Ce_Stay_2:
LCD1602_SET_E_L();
SsLCD1602_h_displayPara.e_e_WriteState = Ce_Stay_0;
return Ce_SendOK;
break;
default:
SsLCD1602_h_displayPara.e_e_WriteState = Ce_Stay_0;
return Ce_SendOK;
break;
}
}
static TeLCD1602_SendState LcdWriteData( const uint8_t dat )
{
switch( SsLCD1602_h_displayPara.e_e_WriteState )
{
case Ce_Stay_0:
LCD1602_SET_RS_H();
LCD1602_SET_RW_L();
LCD1602_WRITE_DATA( dat );
SsLCD1602_h_displayPara.e_e_WriteState = Ce_Stay_1;
return Ce_Sending;
break;
case Ce_Stay_1:
LCD1602_SET_E_H();
SsLCD1602_h_displayPara.e_e_WriteState = Ce_Stay_2;
return Ce_Sending;
break;
case Ce_Stay_2:
LCD1602_SET_E_L();
SsLCD1602_h_displayPara.e_e_WriteState = Ce_Stay_0;
return Ce_SendOK;
break;
default:
SsLCD1602_h_displayPara.e_e_WriteState = Ce_Stay_0;
return Ce_SendOK;
break;
}
}
static void MngLCD1602_Display( void )
{
switch(SsLCD1602_h_displayPara.e_e_SendStep)
{
case Ce_SendAddr_00:
if(Ce_Stay_0 == SsLCD1602_h_displayPara.e_e_WriteState)
{
if(false == MngLCD1602_IsBusy())
{
LcdWriteCom(0x80);
}
else
{
/* empty */
}
}
else if(Ce_SendOK == LcdWriteCom(0x80)) /* 第0,0位置开始显示 */
{
SsLCD1602_h_displayPara.e_e_SendStep = Ce_SendData_00;
SsLCD1602_h_displayPara.e_e_WriteState = Ce_Stay_0;
SsLCD1602_h_displayPara.e_p_DisplayNextAddr = SsLCD1602_h_displayPara.e_h_RowPara[0].e_p_DisplayStartAddr;
}
else
{
/* empty */
}
break;
case Ce_SendData_00:
if(Ce_Stay_0 == SsLCD1602_h_displayPara.e_e_WriteState)
{
if(false == MngLCD1602_IsBusy())
{
LcdWriteData(*SsLCD1602_h_displayPara.e_p_DisplayNextAddr);
}
else
{
/* empty */
}
}
else if(Ce_SendOK == LcdWriteData(*SsLCD1602_h_displayPara.e_p_DisplayNextAddr))
{
SsLCD1602_h_displayPara.e_p_DisplayNextAddr++;
if(SsLCD1602_h_displayPara.e_p_DisplayNextAddr > SsLCD1602_h_displayPara.e_h_RowPara[0].e_p_DisplayEndAddr)
{
SsLCD1602_h_displayPara.e_e_SendStep = Ce_SendAddr_10;
SsLCD1602_h_displayPara.e_e_WriteState = Ce_Stay_0;
SsLCD1602_h_displayPara.e_p_DisplayNextAddr = SsLCD1602_h_displayPara.e_h_RowPara[1].e_p_DisplayStartAddr;
}
else
{
/* empty */
}
}
else
{
/* empty */
}
break;
case Ce_SendAddr_10:
if(Ce_Stay_0 == SsLCD1602_h_displayPara.e_e_WriteState)
{
if(false == MngLCD1602_IsBusy())
{
LcdWriteCom(0x80 + 0x40);
}
else
{
/* empty */
}
}
else if(Ce_SendOK == LcdWriteCom(0x80 + 0x40)) /* 第0,1位置开始显示 */
{
SsLCD1602_h_displayPara.e_e_SendStep = Ce_SendData_10;
SsLCD1602_h_displayPara.e_e_WriteState = Ce_Stay_0;
SsLCD1602_h_displayPara.e_p_DisplayNextAddr = SsLCD1602_h_displayPara.e_h_RowPara[1].e_p_DisplayStartAddr;
}
else
{
/* empty */
}
break;
case Ce_SendData_10:
if(Ce_Stay_0 == SsLCD1602_h_displayPara.e_e_WriteState)
{
if(false == MngLCD1602_IsBusy())
{
LcdWriteData(*SsLCD1602_h_displayPara.e_p_DisplayNextAddr);
}
else
{
/* empty */
}
}
else if(Ce_SendOK == LcdWriteData(*SsLCD1602_h_displayPara.e_p_DisplayNextAddr))
{
SsLCD1602_h_displayPara.e_p_DisplayNextAddr++;
if(SsLCD1602_h_displayPara.e_p_DisplayNextAddr > SsLCD1602_h_displayPara.e_h_RowPara[1].e_p_DisplayEndAddr)
{
SsLCD1602_h_displayPara.e_e_SendStep = Ce_SendAddr_00;
SsLCD1602_h_displayPara.e_e_WriteState = Ce_Stay_0;
SsLCD1602_h_displayPara.e_p_DisplayNextAddr = SsLCD1602_h_displayPara.e_h_RowPara[0].e_p_DisplayStartAddr;
}
else
{
/* empty */
}
}
else
{
/* empty */
}
break;
default :
SsLCD1602_h_displayPara.e_e_SendStep = Ce_SendAddr_00;
SsLCD1602_h_displayPara.e_p_DisplayNextAddr = SsLCD1602_h_displayPara.e_h_RowPara[0].e_p_DisplayStartAddr;
break;
}
}
void MngLCD1602_Init( void )
{
uint8_t index = 0u;
uint8_t LeLCD1602InitCfg[4] = {0x38, 0x0c, 0x06, 0x01};
SsLCD1602_h_displayPara.e_e_SendStep = Ce_SendAddr_00;
SsLCD1602_h_displayPara.e_e_WriteState = Ce_Stay_0;
SsLCD1602_h_displayPara.e_p_DisplayNextAddr = &SeLCD1602_u_displayBuffer[0][0];
SsLCD1602_h_displayPara.e_h_RowPara[0].e_p_DisplayStartAddr = &SeLCD1602_u_displayBuffer[0][0];
SsLCD1602_h_displayPara.e_h_RowPara[0].e_p_DisplayEndAddr = &SeLCD1602_u_displayBuffer[0][LCD1602_COLUMN_NUM-1];
SsLCD1602_h_displayPara.e_h_RowPara[1].e_p_DisplayStartAddr = &SeLCD1602_u_displayBuffer[1][0];
SsLCD1602_h_displayPara.e_h_RowPara[1].e_p_DisplayEndAddr = &SeLCD1602_u_displayBuffer[1][LCD1602_COLUMN_NUM-1];
memset(SeLCD1602_u_displayBuffer, 0x20, sizeof(SeLCD1602_u_displayBuffer));
while(index < (sizeof(LeLCD1602InitCfg)/sizeof(uint8_t)))
{
if(Ce_Stay_0 == SsLCD1602_h_displayPara.e_e_WriteState)
{
if(false == MngLCD1602_IsBusy())
{
LcdWriteCom(LeLCD1602InitCfg[index]);
}
else
{
/* empty */
}
}
else if(Ce_SendOK == LcdWriteCom(LeLCD1602InitCfg[index]))
{
index++;
}
else
{
/* empty */
}
}
}
void MngLCD1602_Handle( void )
{
MngLCD1602_Display();
}
void displayString( uint8_t x, uint8_t y, uint8_t* dat, uint8_t len)
{
if(y >= 2)
{
return;
}
else
{
/* empty */
}
if(16 > (x + len))
{
memcpy(&SeLCD1602_u_displayBuffer[y][x], dat, len);
}
else
{
memcpy(&SeLCD1602_u_displayBuffer[y][x], dat, 15-x);
}
}

复制代码

你可以参考下我的，写了一个小时才调好。51还是有点费劲，没法直接仿真，而且对指针、宏定义的处理也有些问题。你移植到stm32的话就很简单了。周期调用MngLCD1602_Handle();接口就ok了，1ms、5ms、10ms一次都可以，时间越长刷新的越慢。

ID:744809 · 发表于 2023-5-25 09:06

1、业务代码和驱动代码要分层，不论什么优化，都不要把业务代码和驱动代码放到一起去写，改起来会要命的。
2、我上面那个代码是一直循环发送，其实也可以改一改，每次重新设置了显示数组，就让驱动去循环显示一下32个字节的数组就好了，这样没有新显示内容的时候，就不会一直刷新。

ID:41043 · 发表于 2023-5-25 09:20

yuxuesuixing 发表于 2023-5-22 11:29
状态机嘛，就是状态嘛，为什么不能有子状态呢？
你这个提问的最大问题是没有写清楚系统功能和需求，根据系 ...

这个解释的很好，很清楚。

ID:326261 · 发表于 2023-5-30 09:49

123156fsadf 发表于 2023-5-24 22:55
你可以参考下我的，写了一个小时才调好。51还是有点费劲，没法直接仿真，而且对指针、宏定义的处理也有些 ...

写的很好，程序我已经看了，使用轮询模式，全局指针来写数据，根据状态位写指令。如果直接把全部数据放入一个地方，直接使用写全局指针的方式这样就不需要区分了。和状态机类似，用全局指针代替状态位。感谢同仁支持！

ID:326261 · 发表于 2023-5-30 09:52

123156fsadf 发表于 2023-5-25 09:06
1、业务代码和驱动代码要分层，不论什么优化，都不要把业务代码和驱动代码放到一起去写，改起来会要命的。
...

对的！是这样的，我目前的操作也是这么做，驱动和业务代码还是需要区分，后来人希望能够看到和代码规范化，也感谢大家的支持。
无论是写状态机，还是写操作系统，还是要把驱动层程序和应用层分开，这样对驱动的校验很好，也提高代码阅读性，可修改性。

ID:326261 · 发表于 2023-5-30 09:55

mcu_xing 发表于 2023-5-25 09:20
这个解释的很好，很清楚。

是的，层主解释的很好，状态机的学习可以参考一下，具体的解决方法层主也没有说清楚，还是笼统了一点，看的懂就好，向各位学习。

ID:404263 · 发表于 2023-5-31 15:29

工学院陈伟霆发表于 2023-5-22 15:39
我的按键控制LCD1602刷新，在LCD刷新时不能影响IO口的接收判断。

按照您的说法，设两个状态位，那么代 ...

这个我也有点没理解，你这个屏幕刷新能占用的时间大概是多少，如果只是50ms内的话我感觉没必要考虑你那种做法，毕竟不用延时的你很难做到说这1ms不动作然后1ms后我要马上跳回发送这样，按键和数据接收这些可以考虑放定时中断里面

ID:744809 · 发表于 2023-6-1 17:22

cokesu 发表于 2023-5-31 15:29
这个我也有点没理解，你这个屏幕刷新能占用的时间大概是多少，如果只是50ms内的话我感觉没必要考虑你那种 ...

有些系统是周期性的，比如所有函数都要求在5ms内完成，即5ms作为一个周期，那么ms级的延时就是致命的，在实时性要求高的系统中，不能够有这种延时存在

ID:514317 · 发表于 2023-8-1 21:32

都用F4了还用什么延时？？？？直接上系统就行了上个最简单的时间片轮询系统也能满足要求
你说的还有个主要问题是LCD1602匹配的问题这个确实是太慢可以用固定每次发送一个字节解决不然是很占用时间最好换成oled12864

帐号		自动登录	找回密码
密码			立即注册