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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机按键数码管的组合使用 附源程序
返回列表 发新帖
查看: 3913|回复: 7
打印 上一主题 下一主题
收起左侧

单片机按键数码管的组合使用 附源程序

[复制链接]
跳转到指定楼层
楼主
ID:673128 发表于 2020-2-11 13:27 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
        这次我们用4个独立按键和8位数码管来做一个正计数器和倒计时器，到时间后（正计时最大值，倒计时最小值）LED灯闪烁10秒熄灭（大家可以先自己想好步骤，再看一下我下面的思路步骤）我用的单片机是STC89C52

主要的步骤：1、先思考正计数，倒计数需要定时器中断。还需要按键处理函数。另外需要一个数码管显示函数。


        2、如何将这三个程序有序的排列组合起来形成一个完整的程序，这时我们可以从正计时器入手（也可以从倒计时入手）（由简入深，抓住主干）先规定K1代表正计数器的开和关，K2代表秒分时的移位，K3代表自加，K4代表自减。还有就是正计数到达最大值的时候LED灯进行闪烁。


        3、这时就要用标志位来分清关系。
        第一部分按键程序，具体操作就是用flag0代表正计数器的开关，knum代表K2按下的时候到底是秒分时哪个 ，K3代表按一下加，K4代表按一下减，这时我们的按键程序基本完成；
        第二部分就是我们的定时器中断函数，因为定时器我选的时16位非自动重装10ms，所以要累计100次到一秒，大家要注意如果你选的是1ms定时，就需要累计1000次，记着你的数据类型要选int或者unsigned int,这部分容易忽略。还有当K2按下,标志位knum进行改变也就代表着秒分时要开始闪烁。这时要进行计数操作也就是当计数时间到时，flag1进行改变，控制秒分时的闪烁时间间隔。当计数时间到的时候还需要flag2的改变这样控制LED灯的闪烁频率以及时间。
        第三部分就是我们的数码管显示程序，这个程序要根据knum的值进行改变，当knum=0时它直接进行显示，当knum!=0也就是K2按下的时候，根据flag1的值来闪烁。
        第四部分就是我们要看到效果，当正计数器到达最大值的时候LED灯开始闪烁。只需在正计数结束的时候控制flag2。
        第五部分当你把前四部分都解决了之后，那么你就可以着手做互锁关系了，当我们正计数的时候我们不能进行移位操作，也就是说正计数器的开启与移位操作形成互锁（我们可以加if语句这样就实现了）。
        接下来就是K3,4长按和短按操作，短按加减一次，长按连加减。
        我们想要实现的还有倒计时器的设定这时我们可以将K1也设定为长按和短按，长按倒计时器，短按正计数器。同时此时也会出现两者的相互干扰情况，于是再设定一个互锁，这样就就避免了（用if语句来解决，就用我们现成的标志位）。因为我们将K1，K3，K4都用了长按短按，所以就让K2的长按也有功能，就是全体清零，LED灯闪烁。
        第六部分就是大家发现了吗？就是在进行长按的时候，由于我们这时候还想要数码管继续显示，所以我在长按的while循环里做了显示，但这个显示函数单次显示只用了1ms，这样我们显示了八次，再加上一次延时1ms，我近似认为一次长按循环所需时间为10ms，这一点大家做长按，短按的时候会遇到的，还有就是数码管显示函数的延时时间长短，会改变数码管亮度。大家可以自己写一下这个程序，写完就理解我为什么要这样写了。
        有错误请指出，谢谢。

单片机源程序如下:
  1. #include"digdisplay.h"
  2. sbit k1=P3^1;                        //短按进行计数操作，长按进行倒计时操作
  3. sbit k2=P3^0;                        //短按进行秒分时的移位闪烁，长按进行秒分时归零，没有移位闪烁，LED灯闪烁开始
  4. sbit k3=P3^2;                        //短按进行秒分时（看K2让谁闪烁）的加一操作 ，长按进行连加操作（K2让谁闪烁）
  5. sbit k4=P3^3;                        //短按进行秒分时（看K2让谁闪烁）的减一操作 ，长按进行连减操作（K2让谁闪烁）
  6. sbit led=P2^0;                        //当计数到最大值时LED灯开始闪烁，当倒计时到零时开始闪烁
  7. u8 datenume[6]={0,0,0,0,0,0};         //当做存储秒分时的值，通过运算转换为数码管显示的值
  8. u8 miao=0,fen=0,shi=0,count,knum=0,flag0=0,time=0,flag1=0,flag2=0,flag3=0,time_count=0;                  //flag0是否进行计数操作，falg1秒分时的闪烁标志位，falg2是定时或计数到时LED灯进行闪烁，flag3是否进行倒计时操作，knum进行移位操作的标志性
  9. u8 a,b,c,d,e;                          //这几个都代表数值，计算时间用的，你可以在程序中发现它们

  11. void Delay5ms()                //@12.000MHz
  12. {
  13.         unsigned char i, j;

  15.         i = 10;
  16.         j = 183;
  17.         do
  18.         {
  19.                 while (--j);
  20.         } while (--i);
  21. }


  24. void keyprogress()                        //对四个固定按键进行操作，具体操作如下
  25. {
  26.            if(!k1)
  27.         {
  28.            Delay5ms();
  29.            if(!k1)
  30.            {
  31.              while(!k1)
  32.                  {
  33.                      digdisplay(0,datenume[0]);
  34.                  digdisplay(1,datenume[1]);
  35.                  digdisplay(2,16);
  36.                  digdisplay(3,datenume[2]);
  37.                  digdisplay(4,datenume[3]);
  38.                  digdisplay(5,16);
  39.                  digdisplay(6,datenume[4]);
  40.                  digdisplay(7,datenume[5]);
  41.                     d++;
  42.                         Delay1ms();
  43.                         if(d==100)
  44.                         {
  45.                           if(knum==0&&flag0==0&&(miao!=0||fen!=0||shi!=0))          //计数器和倒计时形成互锁当秒分时都为零时不能进行倒计时
  46.                           {
  47.                            flag3=!flag3;  //开启倒计时和关闭倒计时
  48.                       }
  49.                         }
  50.                  }
  51.                  if(d<100)
  52.                  {
  53.               if(knum==0&&flag3==0)           //当没进行移位操作时才可以启动计数器，解决了移位时计数器开启问题，互锁
  54.                   {                                                   //计数器和倒计时形成互锁
  55.                 flag0=!flag0;                   //开启计数器和关闭计数器
  56.                   }
  57.                  }
  58.                  d=0;
  59.            }
  60.         }
  61.         if(!k2)
  62.         {
  63.            Delay5ms();
  64.            if(!k2)
  65.            {
  66.              while(!k2)
  67.                  {
  68.                      digdisplay(0,datenume[0]);
  69.                  digdisplay(1,datenume[1]);
  70.                  digdisplay(2,16);
  71.                  digdisplay(3,datenume[2]);
  72.                  digdisplay(4,datenume[3]);
  73.                  digdisplay(5,16);
  74.                  digdisplay(6,datenume[4]);
  75.                  digdisplay(7,datenume[5]);
  76.                             e++;
  77.                          Delay1ms();
  78.                          if(e==100)                 //全体归零LED灯闪烁
  79.                          {
  80.                                    flag0=0;
  81.                                 flag1=0;
  82.                                 flag2=1;
  83.                                 flag3=0;
  84.                                 knum=0;
  85.                                 shi=0;
  86.                                 fen=0;
  87.                                 miao=0;
  88.                          }
  89.                  }
  90.              if(flag0==0&&e<100)                //解决了当移位操作时计数器开启问题，形成必须要计数器关闭才能开始移位，形成互锁
  91.                 {
  92.               knum++;
  93.                   if(knum==4)
  94.                   {
  95.                     knum=0;
  96.                   }
  97.                 }
  98.                 e=0;
  99.            }
  100.         }
  101.         if(!k3)                                                        //必须在有移位操作的时候才能加，也算一个锁定
  102.         {
  103.          Delay5ms();
  104.           if(!k3)
  105.          {
  106.           while(!k3)
  107.           {
  108.           digdisplay(0,datenume[0]);
  109.           digdisplay(1,datenume[1]);
  110.           digdisplay(2,16);
  111.           digdisplay(3,datenume[2]);
  112.           digdisplay(4,datenume[3]);
  113.           digdisplay(5,16);
  114.           digdisplay(6,datenume[4]);
  115.           digdisplay(7,datenume[5]);
  116.             Delay1ms();
  117.                 a++;
  118.                 if(a==100)
  119.                 {
  120.                   a=50;
  121.                    if(knum==1)
  122.                    {
  123.                       miao++;
  124.                           if(miao==60)
  125.                           {
  126.                              miao=0;
  127.                           }
  128.                    }
  129.                    else if(knum==2)
  130.                    {
  131.                       fen++;
  132.                           if(fen==60)
  133.                           {
  134.                               fen=0;
  135.                           }
  136.                    }
  137.                    else if(knum==3)
  138.                    {
  139.                       shi++;
  140.                           if(shi==24)
  141.                           {
  142.                               shi=0;
  143.                           }
  144.                    }
  145.                 }
  146.           }
  147.                 if(knum!=0)
  148.            {
  149.                 if(a<50)
  150.                 {
  151.                    if(knum==1)
  152.                   {
  153.                    miao++;
  154.                    if(miao==60)
  155.                    {
  156.                      miao=0;
  157.                    }
  158.                   }
  159.                   else if(knum==2)
  160.                   {
  161.                     fen++;
  162.                         if(fen==60)
  163.                         {
  164.                           fen=0;
  165.                         }
  166.                   }
  167.                   else if(knum==3)
  168.                   {
  169.                      shi++;
  170.                          if(shi==24)
  171.                          {
  172.                            shi=0;
  173.                          }
  174.                   }
  175.                 }
  176.            }
  177.        a=0;
  178.          }
  179.         }
  180.         if(!k4)                                                          //必须在有移位操作时才可以自减
  181.         {
  182.           Delay5ms();
  183.            if(!k4)
  184.            {
  185.              while(!k4)
  186.                  {
  187.            digdisplay(0,datenume[0]);
  188.                digdisplay(1,datenume[1]);
  189.                digdisplay(2,16);
  190.                digdisplay(3,datenume[2]);
  191.                digdisplay(4,datenume[3]);
  192.                digdisplay(5,16);
  193.                digdisplay(6,datenume[4]);
  194.                digdisplay(7,datenume[5]);
  195.                Delay1ms();
  196.                    a++;
  197.                    if(a==100)
  198.                    {
  199.                      a=50;
  200.                          if(knum==1)
  201.                          {
  202.                            miao--;
  203.                            if(miao==255)
  204.                            {
  205.                              miao=59;
  206.                            }
  207.                          }
  208.                          if(knum==2)
  209.                          {
  210.                             fen--;
  211.                                 if(fen==255)
  212.                                 {
  213.                                    fen=59;
  214.                                 }
  215.                          }
  216.                          if(knum==3)
  217.                          {
  218.                             shi--;
  219.                                 if(shi==255)
  220.                                 {
  221.                                    shi=23;
  222.                                 }
  223.                          }
  224.                    }
  225.                  }
  226.                  if(a<50)
  227.                  {
  228.               if(knum==1)
  229.                   {
  230.                     miao--;
  231.                         if(miao==255)
  232.                         {
  233.                           miao=59;
  234.                         }
  235.                   }
  236.                   else if(knum==2)
  237.                   {
  238.                      fen--;
  239.                          if(fen==255)
  240.                          {
  241.                            fen=59;
  242.                          }
  243.                   }
  244.                  else if(knum==3)
  245.                   {
  246.                      shi--;
  247.                          if(shi==255)
  248.                          {
  249.                                    shi=23;
  250.                          }
  251.                   }
  252.                  }
  253.                  a=0;
  254.            }
  255.         }
  256. }
  257. void shuma()                                //做数码管显示函数，当knum=0时普通显示，当knum!=0时靠标志位flag1决定闪烁
  258. {
  259.     if(knum==0)
  260.         {
  261.           digdisplay(0,datenume[0]);
  262.           digdisplay(1,datenume[1]);
  263.           digdisplay(2,16);
  264.           digdisplay(3,datenume[2]);
  265.           digdisplay(4,datenume[3]);
  266.           digdisplay(5,16);
  267.           digdisplay(6,datenume[4]);
  268.           digdisplay(7,datenume[5]);
  269.         }
  270.   else if(knum==1)
  271.    {
  272.      if(flag1)
  273.          {                                                                                                                                                                                                                                                                                          
  274.       digdisplay(0,datenume[0]);
  275.           digdisplay(1,datenume[1]);
  276.           digdisplay(2,16);
  277.           digdisplay(3,datenume[2]);
  278.           digdisplay(4,datenume[3]);
  279.           digdisplay(5,16);
  280.           digdisplay(6,datenume[4]);
  281.           digdisplay(7,datenume[5]);
  282.          }
  283.          else
  284.          {
  285.           digdisplay(0,17);
  286.           digdisplay(1,17);
  287.           digdisplay(2,16);
  288.           digdisplay(3,datenume[2]);
  289.           digdisplay(4,datenume[3]);
  290.           digdisplay(5,16);
  291.           digdisplay(6,datenume[4]);
  292.           digdisplay(7,datenume[5]);
  293.          }
  294.    }
  295.   else if(knum==2)
  296.    {
  297.      if(flag1)
  298.          {
  299.       digdisplay(0,datenume[0]);
  300.           digdisplay(1,datenume[1]);
  301.           digdisplay(2,16);
  302.           digdisplay(3,datenume[2]);
  303.           digdisplay(4,datenume[3]);
  304.           digdisplay(5,16);
  305.           digdisplay(6,datenume[4]);
  306.           digdisplay(7,datenume[5]);
  307.          }
  308.          else
  309.          {
  310.           digdisplay(0,datenume[0]);
  311.           digdisplay(1,datenume[1]);
  312.           digdisplay(2,16);
  313.           digdisplay(3,17);
  314.           digdisplay(4,17);
  315.           digdisplay(5,16);
  316.           digdisplay(6,datenume[4]);
  317.           digdisplay(7,datenume[5]);
  318.          }
  319.    }
  320.   else  if(knum==3)
  321.    {
  322.      if(flag1)
  323.          {
  324.       digdisplay(0,datenume[0]);
  325.           digdisplay(1,datenume[1]);
  326.           digdisplay(2,16);
  327.           digdisplay(3,datenume[2]);
  328.           digdisplay(4,datenume[3]);
  329.           digdisplay(5,16);
  330.           digdisplay(6,datenume[4]);
  331.           digdisplay(7,datenume[5]);
  332.          }
  333.          else
  334.          {
  335.           digdisplay(0,datenume[0]);
  336.           digdisplay(1,datenume[1]);
  337.           digdisplay(2,16);
  338.           digdisplay(3,datenume[2]);
  339.           digdisplay(4,datenume[3]);
  340.           digdisplay(5,16);
  341.           digdisplay(6,17);
  342.           digdisplay(7,17);
  343.          }
  344.    }
  345. }
  346. void main()
  347. {
  348.    TMOD &= 0xF0;    //设置定时器模式
  349.    TMOD |= 0x01;    //设置定时器模式
  350.    TL0 = 0xF0;                //设置定时初值                10毫秒定时器
  351.    TH0 = 0xD8;                //设置定时初值
  352.    TF0 = 0;                     //清除TF0标志
  353.    TR0=1;                //定时器开启           定时器在程序运行过程中将一直启动     
  354.    ET0=1;
  355.    EA=1;
  356.    while(1)
  357.    {
  358.       keyprogress();           //按键处理函数分别处理K1，K2，K3，K4的长按和短按程序
  359.           shuma();                           //数码管管显示程序，处理K2按键按下
  360.    }
  361. }
  362. void int0() interrupt 1                                
  363. {
  364.    TL0 = 0xF0;                //设置定时初值
  365.    TH0 = 0xD8;                //设置定时初值
  366.    datenume[0]=miao%10;                        //对秒分时进行数据处理，用数码管显示做铺垫
  367.    datenume[1]=miao/10;
  368.    datenume[2]=fen%10;
  369.    datenume[3]=fen/10;
  370.    datenume[4]=shi%10;
  371.    datenume[5]=shi/10;
  372.    if(flag0&&knum==0)                //进行正向计数,knum判断是否进行了移位操作，flag0判断是否进行了开始操作
  373.   {
  374.    count++;
  375.    if(count==100)
  376.    {
  377.      count=0;
  378.          miao++;
  379.          if(miao==60)
  380.          {
  381.            miao=0;
  382.            fen++;
  383.            if(fen==60)
  384.            {
  385.               fen=0;
  386.                   shi++;
  387.                   if(shi==24)
  388.                   {
  389.                     shi=0;
  390.                         flag2=!flag2;                //开启LED灯的闪烁
  391.                         flag0=!flag0;                //关闭计数器
  392.                   }
  393.            }
  394.          }
  395.    }
  396.   }

  398.   if(flag3&&knum==0)                  //进行倒计时操作
  399.   {
  400.      time_count++;
  401.          if(time_count==100)
  402.          {
  403. ……………………

  405. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
数码管与按键的组合使用.rar (39.3 KB, 下载次数: 26)

评分

参与人数 1黑币 +80 收起 理由
admin + 80 共享资料的黑币奖励！

查看全部评分

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

使用道具 举报

沙发
ID:673128 发表于 2020-2-12 11:23 | 只看该作者
gpdt3209 发表于 2020-2-11 19:52
压缩包损坏

大哥没有坏啊
回复

使用道具 举报

板凳
ID:135835 发表于 2020-2-12 17:02 | 只看该作者
下了，压缩包没坏，正常解压。
回复

使用道具 举报

地板
ID:328014 发表于 2020-2-15 14:15 | 只看该作者
好东东 很详细啊,,楼主能附个原理图吗?
回复

使用道具 举报

5#
ID:691807 发表于 2020-2-15 14:42 | 只看该作者
谢谢楼主分享
回复

使用道具 举报

6#
ID:24810 发表于 2020-2-15 17:23 | 只看该作者
下来学习下。
回复

使用道具 举报

7#
ID:673128 发表于 2020-2-17 08:47 | 只看该作者
51hei团团 发表于 2020-2-15 14:15
好东东 很详细啊,,楼主能附个原理图吗?

那个我这是用单片机一步步实验出来的，我没有学用仿真软件，思路就是开头的思路。你按照它走一定能做出来的。
回复

使用道具 举报

8#
ID:684248 发表于 2020-2-24 17:22 | 只看该作者
楼主，digdisplay.c的函数能分享下吗
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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