设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 单片机状态机来扫描键盘程序 调时状态加减会出问题
返回列表 发新帖
查看: 805|回复: 3
打印 上一主题 下一主题
收起左侧

单片机状态机来扫描键盘程序 调时状态加减会出问题

[复制链接]
跳转到指定楼层
楼主
ID:1095802 发表于 2023-10-25 17:42 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
用状态机来扫描键盘，有时按了会出现错乱，不知道哪里出问题了
单片机源程序如下:
  1. #include <reg52.h>
  2. #include <intrins.h>
  3. #define SXLed_P P0
  4. #define K5 0x07
  5. #define K4 0x0b
  6. #define K3 0x0d
  7. #define K2 0x0e
  8. unsigned int i;
  9. unsigned char KeyValue,KeyValueTemp,StateNo,Flag_Time;
  10. bit Flag_05s,Flag_1s,Flag_Change,Flag_Hide;                                                        //位标志
  11. unsigned char SX[8];                        //数码管数据缓存,位标志
  12. unsigned char Hour,Minute,Second;        //时分秒
  13. sbit SXLed_W=P2^7;                                //数码管位选
  14. sbit SXLed_D=P2^6;                                //数码管段选
  15. sbit bp=P2^3;
  16. unsigned  char code Number[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7F,
  17. 0x6F,0x40,0x80,0x00};                                //共阴极数码管0-9-.灭
  18. void Delay(unsigned char ); //毫秒延时函数
  19. void Init(void);                                                //数据初始化函数
  20. void T0_Init(void);                                        //T0中断初始化函数
  21. void SXLed (unsigned char location,unsigned char Num);//数码管显示函数
  22. void Start_Screen(void);                //开机显示画面函数
  23. void Time(void);                                                //时分秒进位函数
  24. void Hex_BCD(void);                                        //数据转换并送到数码管数缓存函数
  25. void KeyScan(void);                                        //按键扫描函数（状态机法）
  26. void KeyProcess(void);                        //按键处理函数
  27. void main(void)
  28. {
  29.         Delay(100);                                                                //开机延时
  30.         Init();                                                                                //变量初始化                                
  31.         T0_Init();                                                                //定时器T0初始化
  32.   Start_Screen();                                                //开机画面
  33. //        P1=0x00;
  34.         while(1)
  35.         {        
  36.                 if(Flag_05s==1)        //0.5秒到了
  37.                 {        
  38.                         Flag_05s=0;//0.5秒到状态清0
  39.                         Hex_BCD();//数据转换并送到数码管数缓存
  40.                         if(Flag_Change!=0)//调时状态
  41.                         {
  42.                                 Flag_Hide=!Flag_Hide;//隐藏标志
  43.                                 if ((Flag_Hide==1)&&(Flag_Time==0))//调时状态时闪烁
  44.                                 {
  45.                                         SX[7]=12;
  46.                                         SX[6]=12;
  47.                                 }
  48.                                 if ((Flag_Hide==1)&&(Flag_Time==1))//调时状态分闪烁
  49.                                 {
  50.                                         SX[4]=12;
  51.                                         SX[3]=12;
  52.                                 }
  53.                                 if ((Flag_Hide==1)&&(Flag_Time==2))//调时状态秒闪烁
  54.                                 {
  55.                                         SX[1]=12;
  56.                                         SX[0]=12;
  57.                                 }
  58.                         }
  59.                 }        
  60.         }                        
  61. }
  62. void Init(void)
  63. {
  64.         i=0;
  65.         Hour=23;
  66.         Minute=59;
  67.         Second=50;
  68.         Flag_05s=0;
  69.         Flag_1s=0;
  70.         Flag_Change=0;
  71.         Flag_Hide=0;
  72.         StateNo=1;
  73.         KeyValue=0;
  74.         KeyValueTemp=0;
  75.         Flag_Time=0;
  76. }
  77. void T0_Timer(void) interrupt 1
  78. {
  79.         TH0=0xf8;                                                                        //定时2毫秒高四位初值重装
  80.         TL0=0xcd;                                                                        //定时2毫秒高四位初值重装
  81.         SXLed(i%8,SX[i%8]);                                //数码管扫描显示
  82.         i++;
  83.         if(!(i%5))        KeyScan();                //按键扫描
  84.         if(!(i%250))                                                        //0.5秒到了
  85.         {        
  86. //                P1=~P1;                                                                //指示灯0.5秒交替闪烁
  87.                 Flag_05s=1;                                                        //0.5秒标志置1
  88.                 Flag_1s=!Flag_1s;                                //1秒标志置取反
  89.                 if(Flag_1s==0)                                        //1秒到了
  90.                         if(Flag_Change==1)                //是否调时状态
  91.                                 _nop_();                                                //是，啥也不干
  92.                         else
  93.                         Time();                                                                //否，时间变动
  94.         }
  95. }

  97. void         KeyProcess(void)
  98. {
  99.         switch (KeyValue)
  100.         {
  101.                 case K2:
  102.                                                 if(Flag_Change==1)
  103.                                                 {
  104.                                                         Flag_Time++;
  105.                                                         if(Flag_Time==3)Flag_Time=0;
  106.                                                 }
  107.                                                 break;
  108.                 case K3:
  109.                                                 if(Flag_Change==1)
  110.                                                 {
  111.                                                         if(Flag_Time==0)        
  112.                                                         {
  113.                                                                 Hour++;
  114.                                                                 if(Hour==23)Hour=0;
  115.                                                         }
  116.                                                         if(Flag_Time==1)        
  117.                                                         {
  118.                                                                 Minute++;
  119.                                                                 if(Minute==59)Minute=0;
  120.                                                         }
  121.                                                         if(Flag_Time==2)        
  122.                                                         {
  123.                                                                 Second++;
  124.                                                                 if(Second==59)Second=0;
  125.                                                         }
  126.                                                 }        
  127.                                                 break;                                       
  128.                 case K4:
  129.                                                 if(Flag_Change==1)
  130.                                                 {
  131.                                                         if(Flag_Time==0)        
  132.                                                         {
  133.                                                                 Hour--;
  134.                                                                 if(Hour==0)Hour=23;
  135.                                                         }
  136.                                                         if(Flag_Time==1)        
  137.                                                         {
  138.                                                                 Minute--;
  139.                                                                 if(Minute==0)Minute=59;
  140.                                                         }
  141.                                                         if(Flag_Time==2)        
  142.                                                         {
  143.                                                                 Second--;
  144.                                                                 if(Second==0)Second=59;
  145.                                                         }
  146.                                                 }
  147.                                                 break;
  148.                 case K5:        
  149.                                                 if(Flag_Change==0)
  150.                                                         Flag_Change=1;
  151.                                                 else
  152.                                                         Flag_Change=0;
  153.                                                 break;
  154.                 default:
  155.                                                 Flag_Change=0;        
  156.                                                 break;        
  157.         }
  158. }
  159. void KeyScan(void)
  160. {
  161.         P3=P3|0x0f;
  162.         if (StateNo==1)
  163.         {
  164.                 if ((P3&0x0f)!=0x0f)
  165.                         StateNo=2;
  166.                 else
  167.                         StateNo=1;
  168.         }
  169.         else if (StateNo==2)
  170.         {
  171.                 if ((P3&0x0f)!=0x0f)
  172.                 {
  173.                         KeyValueTemp=P3&0x0f;
  174.                         StateNo=3;
  175.                 }
  176.                 else
  177.                         StateNo=1;               
  178.         }        
  179.         else if (StateNo==3)
  180.         {
  181.                 if ((P3&0x0f)==0x0f)
  182.                 {
  183.                         KeyValue=KeyValueTemp;
  184.                         StateNo=4;
  185.                 }
  186.                 else
  187.                 {
  188.                         ;
  189.                 }        
  190.         }
  191.         else if (StateNo==4)
  192.         {
  193.                 KeyProcess();
  194.                 StateNo=1;
  195.         }
  196.         else
  197.                 StateNo=1;               
  198. }
  199. void Hex_BCD(void)
  200. {
  201.         SX[0]=Second%10;
  202.         SX[1]=Second/10;
  203.         SX[2]=10;
  204.         SX[3]=Minute%10;
  205.         SX[4]=Minute/10;
  206.         SX[5]=10;
  207.         SX[6]=Hour%10;
  208.         SX[7]=Hour/10;
  209. }
  210. void Time(void)
  211. {
  212.         Second++;
  213.         if (Second==60)
  214.         {
  215.                 Second=0;
  216.                 Minute++;
  217.                 if(Minute==60)
  218.                 {
  219.                         Minute=0;
  220.                         Hour++;
  221.                         if(Hour==24)Hour=0;
  222.                 }
  223.         }
  224. }
  225. void T0_Init(void)
  226. {
  227.         TMOD|=0x01;                                                                //定时器T0工作在16位定时模式
  228.         EA=1;                                                                                        //开总中断
  229.         ET0=1;                                                                                //开定时器中断
  230.         TR0=1;                                                                                //启动定时器
  231.         TH0=0xf8;                                                                        //定时2毫秒高四位初值重装
  232.         TL0=0xcd;                                                                        //定时2毫秒高四位初值重装
  233. }
  234. void SXLed (unsigned char location,unsigned char Num)//location显示位置，num显示数字
  235. {
  236.         SXLed_P=0xff;                                                                        //消影
  237.         SXLed_W=1;                                                                                //打开位选锁存器
  238.         SXLed_P=~(0x80>>location);                //送位码
  239.         SXLed_W=0;                                                                                //锁存位选数据
  240.         SXLed_D=1;                                                                                //打开段选锁存器
  241.         SXLed_P=Number[Num];                                        //送段码
  242.         SXLed_D=0;                                                                                //锁存段选数据
  243. }
  244. void Start_Screen(void)                                        //开机显示画面
  245. {
  246.         unsigned char k,j;
  247.         for (k=0;k<11;k++)
  248.         {
  249.                 for (j=0;j<8;j++)
  250.                         if(k==0)
  251.                                 SX[j]=10;
  252.                         else
  253.                                 SX[j]=k-1;
  254.                 Delay(1000);
  255.         }
  256. }
  257. void Delay(unsigned char ms)                        //@11.0592MHz延时
  258. {
  259.         unsigned char data i, j;
  260.         while(ms--)
  261.         {
  262.                 _nop_();
  263.                 i = 2;
  264.                 j = 198;
  265.                 do
  266.                 {
  267.                         while (--j);
  268.                 } while (--i);
  269.         }
  270. }
复制代码

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:213173 发表于 2023-10-25 21:01 | 只看该作者
void KeyProcess(void)
{
        switch(KeyValue)
        {
                case K2:/* */break;
                case K3:/* */break;
                case K4:/* */break;
                case K5:/* */break;
        }
        KeyValue=0x00;//键值用后要清0
}

void KeyScan(void)
{
        P3=0x0f;
        if(P3!=0x0f)
                KeyValue=P3;
        KeyProcess();
}
回复

使用道具 举报

板凳
ID:1095802 发表于 2023-10-26 15:31 | 只看该作者
wulin 发表于 2023-10-25 21:01
void KeyProcess(void)
{
        switch(KeyValue)

你这样就不是用状态机的方式了，我找到原因了，是值设置的不对，还有调时进去时默认改时。
                case K3:
                                                if(Flag_Change==1)
                                                {
                                                        if(Flag_Time==0)       
                                                        {
                                                                Hour++;
                                                                if(Hour==24)Hour=0;
                                                        }
                                                        if(Flag_Time==1)       
                                                        {
                                                                Minute++;
                                                                if(Minute==60)Minute=0;
                                                        }
                                                        if(Flag_Time==2)       
                                                        {
                                                                Second++;
                                                                if(Second==60)Second=0;
                                                        }
                                                }       
                                                break;                       
case K4:
                                                if(Flag_Change==1)
                                                {
                                                        if(Flag_Time==0)       
                                                        {
                                                                Hour--;
                                                                if(Hour==255)Hour=23;
                                                        }
                                                        if(Flag_Time==1)       
                                                        {
                                                                Minute--;
                                                                if(Minute==255)Minute=59;
                                                        }
                                                        if(Flag_Time==2)       
                                                        {
                                                                Second--;
                                                                if(Second==255)Second=59;
                                                        }
                                                }
                                                break;
                case K5:       
                                                if(Flag_Change==0)
                                                {
                                                        Flag_Change=1;
                                                        Flag_Time=0;
                                                }
                                                else
                                                        Flag_Change=0;
                                                break;
、、、、、、、、、、、、、、、、、、、、、、、、、、、

回复

使用道具 举报

地板
ID:1097455 发表于 2023-10-27 09:27 | 只看该作者
大体看了一下你的代码框架，写8位机思路是对的，但是按键的处理是不建议放中段处理的，你中断定时到了后，在While大循环里去刷新按键进行消抖        
keytemp=0;
  if(pin_adkey==0)     //               adckeyvolt<=20      
        {
                  keytemp=1;
        }

直接向上面给出键值而后对键值进行定时刷新
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表