找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 17035|回复: 20
收起左侧

单片机24小时倒计时源程序+仿真

  [复制链接]
ID:140489 发表于 2018-5-16 11:07 | 显示全部楼层 |阅读模式
功能 :倒计时八数码管显示,最小1秒,最大24小时;计时结束蜂鸣器报警响10次;如果做实物,可以用继电器作开关控制强电。
设置方法:
1.按K1键第一次,秒位闪烁,短按加减键加减1,长按连加连减;
2.按K1键第二次,分位闪烁,短按加减键加减1,长按连加连减;
3.按K1键第三次,时位闪烁,短按加减键加减1,长按连加连减;
4.按K1键第四次,退出设置;
5.按K4键启动倒计时(非设置状态下时分秒其中之一不为0才能启动计时);
6.计时的时候,按K4键1次可以暂停计时并关闭输出,再按一次恢复计时并启动输出,按K6键停止计时并清零,关闭输出;
7.非计时状态下,K5手动开关控制输出。
完整工程文件见附件

仿真原理图如下(proteus仿真工程文件可到本帖附件中下载)
QQ截图20180516104608.jpg

单片机源程序:
  1. #include<reg52.h>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4. #define duan P1
  5. #define wei P3
  6. sbit key1 = P2^3;  //设置
  7. sbit key2 = P2^4;  //加
  8. sbit key3 = P2^5;        //减
  9. sbit key4 = P2^6;        //启动
  10. sbit key5 = P2^7;        //手动
  11. sbit out = P2^2;        //输出控制 ,低电平有效
  12. sbit di = P2^0;                //蜂鸣器

  13. bit flag=0,flag1=0,shan=0;
  14. uchar knum,shan_cont;
  15. uchar shi=0,fen=0,miao=0,cont,cont1,cont2;
  16. uchar code duanma[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};//共阴段码表
  17. //uchar code weima[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};//位码
  18. uchar code weima[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};//位码        加反相器用

  19. void delay(uint z)
  20. {
  21.         uint x,y;
  22.         for(x=z; x>0; x--)
  23.                 for(y=114; y>0; y--);        
  24. }

  25. void init()
  26. {
  27.         TMOD |= 0x01;                           //定时器0 工作方式1
  28.         TH0 = (65536-50000)/256;   //50ms初值 @12MHz
  29.         TL0 = (65536-50000)%256;
  30.         EA = 1;
  31.         ET0 = 1;
  32.         TR0 = 1;        
  33. }


  34. void dispaly(uchar shi,uchar fen,uchar miao)
  35. {
  36.                
  37.                 duan = 0;
  38.                 wei = weima[5];
  39.                 duan = 0x40;
  40.                 delay(1);


  41.                 duan = 0;
  42.                 wei = weima[2];
  43.                 duan = 0x40;
  44.                 delay(1);


  45.         if(knum==0)
  46.         {
  47.                 duan = 0;
  48.                 wei = weima[7];
  49.                 duan = duanma[shi/10];
  50.                 delay(1);
  51.                
  52.                 duan = 0;
  53.                 wei = weima[6];
  54.                 duan = duanma[shi%10];
  55.                 delay(1);
  56.                         
  57.                         
  58.                 duan = 0;
  59.                 wei = weima[4];
  60.                 duan = duanma[fen/10];
  61.                 delay(1);
  62.                
  63.                 duan = 0;
  64.                 wei = weima[3];
  65.                 duan = duanma[fen%10];
  66.                 delay(1);
  67.                
  68.                
  69.                 duan = 0;
  70.                 wei = weima[1];
  71.                 duan = duanma[miao/10];
  72.                 delay(1);
  73.                
  74.                 duan = 0;
  75.                 wei = weima[0];
  76.                 duan = duanma[miao%10];
  77.                 delay(1);
  78.         }
  79.         else
  80.         {
  81.                 if(knum==1)
  82.                 {
  83.                         if(shan==1)
  84.                         {
  85.                                 duan = 0;
  86.                                 wei = weima[7];
  87.                                 duan = duanma[shi/10];
  88.                                 delay(1);
  89.                         
  90.                                 duan = 0;
  91.                                 wei = weima[6];
  92.                                 duan = duanma[shi%10];
  93.                                 delay(1);
  94.                                        
  95.                                        
  96.                                 duan = 0;
  97.                                 wei = weima[4];
  98.                                 duan = duanma[fen/10];
  99.                                 delay(1);
  100.                                 
  101.                                 duan = 0;
  102.                                 wei = weima[3];
  103.                                 duan = duanma[fen%10];
  104.                                 delay(1);
  105.                                 
  106.                                 
  107.                                 duan = 0;
  108.                                 wei = weima[1];
  109.                                 duan = duanma[miao/10];
  110.                                 delay(1);
  111.                         
  112.                                 duan = 0;
  113.                                 wei = weima[0];
  114.                                 duan = duanma[miao%10];
  115.                                 delay(1);
  116.                         }
  117.                         else
  118.                         {
  119.                                 duan = 0;
  120.                                 wei = weima[7];
  121.                                 duan = duanma[shi/10];
  122.                                 delay(1);
  123.                         
  124.                                 duan = 0;
  125.                                 wei = weima[6];
  126.                                 duan = duanma[shi%10];
  127.                                 delay(1);
  128.                                        
  129.                                        
  130.                                 duan = 0;
  131.                                 wei = weima[4];
  132.                                 duan = duanma[fen/10];
  133.                                 delay(1);
  134.                                 
  135.                                 duan = 0;
  136.                                 wei = weima[3];
  137.                                 duan = duanma[fen%10];
  138.                                 delay(1);
  139.                                 
  140.                                 
  141.                                 duan = 0;
  142.                                 wei = weima[1];
  143.                                 duan = 0;
  144.                                 delay(1);
  145.                         
  146.                                 duan = 0;
  147.                                 wei = weima[0];
  148.                                 duan = 0;
  149.                                 delay(1);
  150.                         
  151.                         }
  152.                 }
  153.         
  154.                 if(knum==2)
  155.                 {
  156.                         if(shan==1)
  157.                         {
  158.                                 duan = 0;
  159.                                 wei = weima[7];
  160.                                 duan = duanma[shi/10];
  161.                                 delay(1);
  162.                         
  163.                                 duan = 0;
  164.                                 wei = weima[6];
  165.                                 duan = duanma[shi%10];
  166.                                 delay(1);
  167.                                        
  168.                                        
  169.                                 duan = 0;
  170.                                 wei = weima[4];
  171.                                 duan = duanma[fen/10];
  172.                                 delay(1);
  173.                                 
  174.                                 duan = 0;
  175.                                 wei = weima[3];
  176.                                 duan = duanma[fen%10];
  177.                                 delay(1);
  178.                                 
  179.                                 
  180.                                 duan = 0;
  181.                                 wei = weima[1];
  182.                                 duan = duanma[miao/10];
  183.                                 delay(1);
  184.                         
  185.                                 duan = 0;
  186.                                 wei = weima[0];
  187.                                 duan = duanma[miao%10];
  188.                                 delay(1);
  189.                         }
  190.                         else
  191.                         {
  192.                                 duan = 0;
  193.                                 wei = weima[7];
  194.                                 duan = duanma[shi/10];
  195.                                 delay(1);
  196.                         
  197.                                 duan = 0;
  198.                                 wei = weima[6];
  199.                                 duan = duanma[shi%10];
  200.                                 delay(1);
  201.                                        
  202.                                        
  203.                                 duan = 0;
  204.                                 wei = weima[4];
  205.                                 duan = 0;
  206.                                 delay(1);
  207.                                 
  208.                                 duan = 0;
  209.                                 wei = weima[3];
  210.                                 duan = 0;
  211.                                 delay(1);
  212.                                 
  213.                                 
  214.                                 duan = 0;
  215.                                 wei = weima[1];
  216.                                 duan = duanma[miao/10];
  217.                                 delay(1);
  218.                         
  219.                                 duan = 0;
  220.                                 wei = weima[0];
  221.                                 duan = duanma[miao%10];
  222.                                 delay(1);
  223.                         
  224.                         }
  225.                 }
  226.         
  227.                 if(knum==3)
  228.                 {
  229.                         if(shan==1)
  230.                         {
  231.                                 duan = 0;
  232.                                 wei = weima[7];
  233.                                 duan = duanma[shi/10];
  234.                                 delay(1);
  235.                         
  236.                                 duan = 0;
  237.                                 wei = weima[6];
  238.                                 duan = duanma[shi%10];
  239.                                 delay(1);
  240.                                        
  241.                                        
  242.                                 duan = 0;
  243.                                 wei = weima[4];
  244.                                 duan = duanma[fen/10];
  245.                                 delay(1);
  246.                                 
  247.                                 duan = 0;
  248.                                 wei = weima[3];
  249.                                 duan = duanma[fen%10];
  250.                                 delay(1);
  251.                                 
  252.                                 
  253.                                 duan = 0;
  254.                                 wei = weima[1];
  255.                                 duan = duanma[miao/10];
  256.                                 delay(1);
  257.                         
  258.                                 duan = 0;
  259.                                 wei = weima[0];
  260.                                 duan = duanma[miao%10];
  261.                                 delay(1);
  262.                         }
  263.                         else
  264.                         {
  265.                                 duan = 0;
  266.                                 wei = weima[7];
  267.                                 duan = 0;
  268.                                 delay(1);
  269.                         
  270.                                 duan = 0;
  271.                                 wei = weima[6];
  272.                                 duan = 0;
  273.                                 delay(1);
  274.                                        
  275.                                        
  276.                                 duan = 0;
  277.                                 wei = weima[4];
  278.                                 duan = duanma[fen/10];
  279.                                 delay(1);
  280.                                 
  281.                                 duan = 0;
  282.                                 wei = weima[3];
  283.                                 duan = duanma[fen%10];
  284.                                 delay(1);
  285.                                 
  286.                                 
  287.                                 duan = 0;
  288.                                 wei = weima[1];
  289.                                 duan = duanma[miao/10];
  290.                                 delay(1);
  291.                         
  292.                                 duan = 0;
  293.                                 wei = weima[0];
  294.                                 duan = duanma[miao%10];
  295.                                 delay(1);
  296.                         
  297.                         }
  298.                 }
  299.         }
  300. }



  301. void keysan()
  302. {
  303.         uchar i;
  304.         if(knum==0)
  305.         {
  306.                 if(key4 == 0 )                  //启动 暂停
  307.                 {
  308.                         
  309.                         i++;  //消抖
  310.                         if( (key4 == 0 && i>12 )|| (miao != 0) || (fen != 0) || (shi != 0) )
  311.                         {        //时分秒都为0时,不能启动输出,只要其中之一不为0,就能启动输出
  312.                                 i=0;
  313.                                 while(!key4)
  314.                                 dispaly(shi,fen,miao);
  315.                                 flag = !flag;
  316.                                 out = !out;
  317.                         }
  318.                 }
  319.         }
  320.         
  321.         if(key5 == 0 )          //手动开关,在没有倒计时的状态下才有用
  322.         {
  323.                 delay(5);
  324.         //        i++;
  325.                 if( key5 == 0  )
  326.                 {
  327.         //                i=0;
  328.                         while(!key5)
  329.                         dispaly(shi,fen,miao);
  330.                         if(shi==0 && fen==0 && miao==0)
  331.                         out = !out;
  332.                 }
  333.         }

  334.         
  335.         if(key1==0)                //设置
  336.         {
  337.                 i++;
  338.                 if(key1 ==0 && i>12)
  339.                 {
  340.                         i=0;
  341.                         while(!key1)
  342.                         dispaly(shi,fen,miao);
  343.                         knum++;
  344.                         if(knum==4)
  345.                                 knum = 0;
  346.                 }        
  347.         }

  348.         if(knum==1)
  349.         {        
  350.                 if(key2==0)
  351.                 {
  352.                         i++;
  353.                         if(key2 ==0 && i>20)
  354.                         {
  355.                                 i=0;
  356.                                 miao++;
  357.                                 if(miao==60)
  358.                                         miao = 0;
  359.                         }        
  360.                 }
  361.         
  362.                 if(key3==0)
  363.                 {
  364.                         i++;
  365.                         if(key3 ==0 && i>20)
  366.                         {
  367.                                 i=0;
  368.                                 miao--;
  369.                                 if(miao==255)
  370.                                         miao = 59;
  371.                         }        
  372.                 }
  373.     }

  374.         if(knum==2)
  375.         {        
  376.                 if(key2==0)
  377.                 {
  378.                         i++;
  379.                         if(key2 ==0 && i>20)
  380.                         {
  381.                                 i=0;
  382.                                 fen++;
  383.                                 if(fen==60)
  384.                                         fen = 0;
  385.                         }        
  386.                 }
  387.         
  388.                 if(key3==0)
  389.                 {
  390.                         i++;
  391.                         if(key3 ==0 && i>20)
  392.                         {
  393.                                 i=0;
  394.                                 fen--;
  395.                                 if(fen==255)
  396.                                         fen = 59;
  397.                         }        
  398.                 }
  399.     }

  400.         if(knum==3)
  401.         {        
  402.                 if(key2==0)
  403.                 {
  404.                         i++;
  405.                         if(key2 ==0 && i>20)
  406.                         {
  407.                                 i=0;
  408.                                 shi++;
  409.                                 if(shi==24)
  410.                                         shi = 0;
  411.                         }        
  412.                 }
  413.         
  414.                 if(key3==0)
  415.                 {
  416.                         i++;
  417.                         if(key3 ==0 && i>20)
  418.                         {
  419.                                 i=0;
  420.                                 shi--;
  421.                                 if(shi==255)
  422.                                         shi = 23;
  423.                         }        
  424.                 }
  425.     }
  426. }


  427. void main()
  428. {
  429.         init();
  430.         wei = 0x00;
  431.         while(1)
  432.         {
  433.                 keysan();
  434.                 dispaly(shi,fen,miao);
  435.                 if(shi==0 && fen==0 && miao==0 && flag == 1)  //倒计时时间到
  436.                 {
  437.                          flag=0;          //停止计时
  438.                         flag1=1;  //启动蜂鸣器标志置1
  439.                         out=1;          //关闭输出
  440.                 }
  441.         }        
  442. }

  443. void timer() interrupt 1
  444. {
  445.         TH0 = (65536-50000)/256;          //50毫秒初值
  446.         TL0 = (65536-50000)%256;
  447.         
  448.         if(flag)
  449.         {
  450.                 cont++;
  451.                 if(cont == 20)         
  452.                 {
  453.                         cont = 0;
  454.                         miao--;
  455.                         if(miao==255)
  456.                         {
  457.                                 miao=59;
  458.                                 fen--;
  459.                                 if(fen==255)
  460.                                 {
  461.                                         fen=59;
  462.                                         shi--;
  463.                                         if(shi==255)
  464.                                         {
  465.                                                 shi=0;
  466.                                         }
  467.                                         if(shi==0)
  468.                                                 fen=59;
  469.                                         if(fen==0 && shi==0)
  470.                                                 fen=0;
  471.                                 }
  472.                         }
  473.                 }
  474.         }

  475.         if(flag1)                 //倒计时时间到,启动蜂鸣器
  476.         {
  477.                 cont1++;
  478.                 if(cont1==10) //500ms蜂鸣器响一次
  479.                 {
  480.                         cont1=0;
  481.                         di=!di;
  482.                         cont2++;
  483.                         if(cont2==20)//500*20=10000ms=10s,蜂鸣器响10s后停止
  484.                         {
  485.                                 cont2=0;
  486.                                 flag1=0;
  487.                         }
  488.                 }
  489.         }

  490.         if(knum != 0)
  491.         {
  492.                 shan_cont++;
  493.                 if(shan_cont==5)  //250ms闪烁时间
  494.                 {
  495.                         shan_cont=0;
  496.                         shan = !shan;
  497.                 }
  498.         }
  499. }
复制代码

全部资料51hei下载地址:
24小时倒计时仿真文件.rar (180.63 KB, 下载次数: 321)

评分

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

查看全部评分

回复

使用道具 举报

ID:46999 发表于 2018-5-16 21:04 | 显示全部楼层
很好的例程
回复

使用道具 举报

ID:140489 发表于 2018-5-22 12:33 | 显示全部楼层
按键扫描部分重新写一下,加减键的短按更稳定,长按短按分的更清
  1. void keysan()
  2. {
  3.         static bit kf1=0, kf2=0,kf3=0;  //自锁标志,这里一定要加static(或者用全局变量),否则按键不灵
  4.         static uint i,j,k,l,m;        //消抖延时变量

  5. //        if(knum==0)
  6. //        {
  7.                 if(key4 == 1)
  8.                 {
  9.                         m=0;
  10.                         kf2=0;
  11.                
  12.                 }
  13.                 else if(kf2 == 0 )                  //启动 暂停键
  14.                 {
  15.                         ++m;  //消抖
  16.                         if( (m>20) || (miao != 0) || (fen != 0) || (shi != 0) )
  17.                         {        //时分秒都为0时,不能启动输出,只要其中之一不为0,就能启动输出
  18.                                 m=0;
  19.                                 kf2=1;
  20.                                 flag = !flag;  //启动、暂停计时标志
  21.                                 out = !out;
  22.                         }
  23.                 }       
  24. //        }          
  25.        

  26.         if(key5==1)
  27.         {
  28.                 l=0;
  29.                 kf3=0;
  30.         }
  31.         else if(kf3==0 )          //手动开关,在没有倒计时的状态下才有用
  32.         {
  33.                 ++l;
  34.                 if(l > 20)
  35.                 {
  36.                         l=0;
  37.                         kf3=1;
  38.                         if(shi==0 && fen==0 && miao==0)
  39.                         out = !out;
  40.                 }
  41.         }
  42.                

  43.         if(key1==1)                //设置         //IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  44.         {
  45.                 i=0;           //按键消抖计时变量清零
  46.                 kf1=0;           //按键自锁标志清零
  47.         }
  48.         else if(kf1 == 0)        //有按键按下,且是第一次被按下
  49.         {
  50.                 ++i;
  51.                 if(i>12)
  52.                 {
  53.                         i=0;
  54.                         kf1=1;         //自锁按键置位,避免一直触发
  55.                         knum++;
  56.                         if(knum==4)
  57.                                 knum = 0;
  58.                 }       
  59.         }



  60.         if(key2==0)                //加
  61.         {
  62.                 j++;
  63.                 if(j >= 120)           //长按
  64.                 {
  65.                         if(knum==1)
  66.                         {
  67.                                 miao++;
  68.                                 if(miao==60)
  69.                                         miao = 0;
  70.                         }

  71.                         if(knum==2)
  72.                         {
  73.                                 fen++;
  74.                                 if(fen==60)
  75.                                         fen=0;
  76.                         }

  77.                         if(knum==3)
  78.                         {
  79.                                 shi++;
  80.                                 if(shi==24)
  81.                                         shi=0;
  82.                         }

  83.                         j=90;           //这里j的值可以设置连加的快慢,j的值越大就越快
  84.                 }                           //因为初值越大,加到120的时间就越短
  85.         }       

  86.         else
  87.         {
  88.                         if(j>15 && j<120) //短按
  89.                         {
  90.                                
  91.                         if(knum==1)
  92.                         {
  93.                                 miao++;
  94.                                 if(miao==60)
  95.                                         miao = 0;
  96.                         }

  97.                         if(knum==2)
  98.                         {
  99.                                 fen++;
  100.                                 if(fen==60)
  101.                                         fen=0;
  102.                         }

  103.                         if(knum==3)
  104.                         {
  105.                                 shi++;
  106.                                 if(shi==24)
  107.                                         shi=0;
  108.                         }
  109.                         j=0;
  110.                 }

  111.         }       
  112.        
  113.         if(key3==0)                //减
  114.         {
  115.                 k++;
  116.                 if(k >= 120)           //长按
  117.                 {
  118.                         if(knum==1)
  119.                         {
  120.                                 miao--;
  121.                                 if(miao==255)
  122.                                         miao = 59;
  123.                         }

  124.                         if(knum==2)
  125.                         {
  126.                                 fen--;
  127.                                 if(fen==255)
  128.                                         fen=59;
  129.                         }

  130.                         if(knum==3)
  131.                         {
  132.                                 shi--;
  133.                                 if(shi==255)
  134.                                         shi=23;
  135.                         }

  136.                         k=90;
  137.                 }
  138.         }       

  139.         else
  140.         {
  141.                 if(k>15 && k<120) //短按
  142.                 {
  143.                                
  144.                         if(knum==1)
  145.                         {
  146.                                 miao--;
  147.                                 if(miao==255)
  148.                                         miao = 59;
  149.                         }

  150.                         if(knum==2)
  151.                         {
  152.                                 fen--;
  153.                                 if(fen==255)
  154.                                         fen=59;
  155.                         }

  156.                         if(knum==3)
  157.                         {
  158.                                 shi--;
  159.                                 if(shi==255)
  160.                                         shi=23;
  161.                         }
  162.                 }
  163.                 k=0;       
  164.         }         
  165. }
复制代码
回复

使用道具 举报

ID:140489 发表于 2018-5-30 17:37 | 显示全部楼层
程序重写了一遍,数码管扫描也放到定时器里面,程序不用delay软件延时
  1. #include<reg52.h>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4. #define duan P1
  5. #define wei P3
  6. sbit key1 = P2^3;   //设置
  7. sbit key2 = P2^4;   //加
  8. sbit key3 = P2^5;        //减
  9. sbit key4 = P2^6;        //启动
  10. sbit key5 = P2^7;        //手动
  11. sbit out = P2^2;        //输出控制 ,低电平有效
  12. sbit di = P2^0;                //蜂鸣器

  13. bit flag=0,flag1=0,shan=0;
  14. uchar knum,shan_cont,i;
  15. uchar shi=0,fen=0,miao=0;
  16. uint cont,cont1,cont2;
  17. uchar code duanma[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};//共阴段码表
  18. uchar code weima[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};                        //位码        加反相器用
  19. uchar LedBuff[]={0,0,0,0,0,0,0,0};                                                                                //数码管显示缓冲区

  20. void init()
  21. {
  22.         TMOD |= 0x01;                           //定时器0 工作方式1
  23.         TH0 = (65536-1000)/256;   //1ms初值 @12MHz
  24.         TL0 = (65536-1000)%256;
  25.         EA = 1;
  26.         ET0 = 1;
  27.         TR0 = 1;       
  28. }


  29. void dis()           //显示函数
  30. {
  31.         LedBuff[0] = duanma[miao%10];
  32.         LedBuff[1] = duanma[miao/10];
  33.         LedBuff[2] = 0x40;
  34.         LedBuff[3] = duanma[fen%10];
  35.         LedBuff[4] = duanma[fen/10];
  36.         LedBuff[5] = 0x40;
  37.         LedBuff[6] = duanma[shi%10];
  38.         LedBuff[7] = duanma[shi/10];
  39. }


  40. void keysan()
  41. {
  42.         static bit kf1=0, kf2=0,kf3=0;  //自锁标志,这里一定要加static(或者用全局变量),否则按键不灵
  43.         static uint i=0,j=0,k=0,l=0,m=0;        //消抖延时变量

  44.         if(knum==0)
  45.         {
  46.                 if(key4 == 1)
  47.                 {
  48.                         m=0;
  49.                         kf2=0;
  50.                
  51.                 }
  52.                 else if(kf2 == 0 )                  //启动 暂停键
  53.                 {
  54.                         ++m;  //消抖
  55.                         if( (m>20) && ((miao != 0) || (fen != 0) || (shi != 0)) )
  56.                         {        //时分秒都为0时,不能启动输出,只要其中之一不为0,就能启动输出
  57.                                 m=0;
  58.                                 kf2=1;
  59.                                 flag = !flag;  //启动、暂停计时标志
  60.                                 out = !out;
  61.                         }
  62.                 }       
  63.         }          
  64.        

  65.         if(key5==1)
  66.         {
  67.                 l=0;
  68.                 kf3=0;
  69.         }
  70.         else if(kf3==0 )          //手动开关,在没有倒计时的状态下才有用
  71.         {
  72.                 ++l;
  73.                 if(l > 20)
  74.                 {
  75.                         l=0;
  76.                         kf3=1;
  77.                         if(shi==0 && fen==0 && miao==0)
  78.                         out = !out;
  79.                 }
  80.         }
  81.                
  82.         if(out==1)        //加这句,只有在输出关闭的时候,才能设置计时时间,在倒计时的过程中是不能设置的
  83.         {
  84.                 if(key1==1)                //设置         //IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  85.                 {
  86.                         i=0;           //按键消抖计时变量清零
  87.                         kf1=0;           //按键自锁标志清零
  88.                 }
  89.                 else if(kf1 == 0)        //有按键按下,且是第一次被按下
  90.                 {
  91.                         ++i;
  92.                         if(i>12)
  93.                         {
  94.                                 i=0;
  95.                                 kf1=1;         //自锁按键置位,避免一直触发
  96.                                 knum++;
  97.                                 if(knum==4)
  98.                                         knum = 0;
  99.                         }       
  100.                 }
  101.         }


  102.         if(key2==0)                //加
  103.         {
  104.                 j++;
  105.                 if(j >= 3000)           //长按,数码管扫描放中断里面,这里的值就要取得大才行
  106.                 {                                        //因为没用delay延时,CPU跑的很快
  107.                         if(knum==1)
  108.                         {
  109.                                 miao++;
  110.                                 if(miao==60)
  111.                                         miao = 0;
  112.                         }

  113.                         if(knum==2)
  114.                         {
  115.                                 fen++;
  116.                                 if(fen==60)
  117.                                         fen=0;
  118.                         }

  119.                         if(knum==3)
  120.                         {
  121.                                 shi++;
  122.                                 if(shi==24)
  123.                                         shi=0;
  124.                         }

  125.                         j=1000;           //这里j的值可以设置连加的快慢,j的值越大就越快
  126.                 }                           //因为初值越大,加到3000的时间就越短
  127.         }       

  128.         else
  129.         {
  130.                         if(j>500 && j<3000) //短按
  131.                         {
  132.                                
  133.                         if(knum==1)
  134.                         {
  135.                                 miao++;
  136.                                 if(miao==60)
  137.                                         miao = 0;
  138.                         }

  139.                         if(knum==2)
  140.                         {
  141.                                 fen++;
  142.                                 if(fen==60)
  143.                                         fen=0;
  144.                         }

  145.                         if(knum==3)
  146.                         {
  147.                                 shi++;
  148.                                 if(shi==24)
  149.                                         shi=0;
  150.                         }
  151.                         j=0;
  152.                 }

  153.         }       
  154.        
  155.         if(key3==0)                //减
  156.         {
  157.                 k++;
  158.                 if(k >= 3000)           //长按
  159.                 {
  160.                         if(knum==1)
  161.                         {
  162.                                 miao--;
  163.                                 if(miao==255)
  164.                                         miao = 59;
  165.                         }

  166.                         if(knum==2)
  167.                         {
  168.                                 fen--;
  169.                                 if(fen==255)
  170.                                         fen=59;
  171.                         }

  172.                         if(knum==3)
  173.                         {
  174.                                 shi--;
  175.                                 if(shi==255)
  176.                                         shi=23;
  177.                         }

  178.                         k=1000;
  179.                 }
  180.         }       

  181.         else
  182.         {
  183.                 if(k>500 && k<3000) //短按
  184.                 {
  185.                                
  186.                         if(knum==1)
  187.                         {
  188.                                 miao--;
  189.                                 if(miao==255)
  190.                                         miao = 59;
  191.                         }

  192.                         if(knum==2)
  193.                         {
  194.                                 fen--;
  195.                                 if(fen==255)
  196.                                         fen=59;
  197.                         }

  198.                         if(knum==3)
  199.                         {
  200.                                 shi--;
  201.                                 if(shi==255)
  202.                                         shi=23;
  203.                         }
  204.                 }
  205.                 k=0;        //消抖变量清零,为下次按键做准备       
  206.         }         
  207. }


  208. void main()
  209. {
  210.         init();
  211.         out = 1;
  212.         while(1)
  213.         {
  214.                 keysan();
  215.                 dis();
  216.                 if(shi==0 && fen==0 && miao==0 && flag == 1 )  //倒计时时间到
  217.                 {
  218.                          flag=0;          //停止计时
  219.                         flag1=1;  //启动蜂鸣器标志置1
  220.                         out=1;          //关闭输出
  221.                 }
  222.         }       
  223. }

  224. void timer() interrupt 1
  225. {
  226.         TH0 = (65536-1000)/256;          //50毫秒初值
  227.         TL0 = (65536-1000)%256;
  228.        
  229.         if(flag)
  230.         {
  231.                 cont++;
  232.                 if(cont == 1000)          
  233.                 {
  234.                         cont = 0;
  235.                         miao--;
  236.                         if(miao==255)
  237.                         {
  238.                                 miao=59;
  239.                                 fen--;
  240.                                 if(fen==255)
  241.                                 {
  242.                                         fen=59;
  243.                                         shi--;
  244.                                         if(shi==255)
  245.                                         {
  246.                                                 shi=0;
  247.                                         }
  248.                                         if(shi==0)
  249.                                                 fen=59;
  250.                                         if(fen==0 && shi==0)
  251.                                                 fen=0;
  252.                                 }
  253.                         }
  254.                 }
  255.         }

  256.         if(flag1)                 //倒计时时间到,启动蜂鸣器
  257.         {
  258.                 cont1++;
  259.                 if(cont1==500) //500ms蜂鸣器响一次
  260.                 {
  261.                         cont1=0;
  262.                         di=!di;
  263.                         cont2++;
  264.                         if(cont2==20)//500*20=10000ms=10s,蜂鸣器响10s后停止
  265.                         {
  266.                                 cont2=0;
  267.                                 flag1=0;
  268.                         }
  269.                 }
  270.         }

  271.         if(knum != 0)
  272.         {
  273.                 shan_cont++;
  274.                 if(shan_cont==100)  //设置时,100ms闪烁时间        可根据实际效果调整
  275.                 {
  276.                         shan_cont=0;
  277.                         shan = !shan;
  278.                 }
  279.         }
  280. /**********数码管扫描函数************/
  281.         i++;
  282.         if(i>=8)
  283.         {
  284.                 i=0;
  285.         }
  286.         duan = 0x00;
  287.         switch(i)
  288.         {
  289.                 case 0:
  290.                                 if(knum==1)                                                                          //如果设置键第一次按下
  291.                                 {if(shan==1){wei = 0x00; duan = LedBuff[0];}  //设置秒位闪烁
  292.                                         else{wei = weima[0]; duan = LedBuff[0];}
  293.                                 }
  294.                                 else{wei = weima[0]; duan = LedBuff[0];}        break;        //否则正常显示
  295.                
  296.                 case 1:       
  297.                                
  298.                                 if(knum==1)
  299.                                 {if(shan==1){wei = 0x00; duan = LedBuff[1];}
  300.                                         else{wei = weima[1]; duan = LedBuff[1];}
  301.                                 }
  302.                                 else{wei = weima[1]; duan = LedBuff[1];}  break;
  303.        
  304.                 case 2:        wei = weima[2]; duan = LedBuff[2];        break;
  305.                
  306.                 case 3:       
  307.                                 if(knum==2)
  308.                                 {if(shan==1){wei = 0x00; duan = LedBuff[3];}
  309.                                         else{wei = weima[3]; duan = LedBuff[3];}
  310.                                 }
  311.                                 else{wei = weima[3]; duan = LedBuff[3];}        break;
  312.                
  313.                 case 4:       
  314.                                 if(knum==2)
  315.                                 {if(shan==1){wei = 0x00; duan = LedBuff[4];}
  316.                                         else{wei = weima[4]; duan = LedBuff[4];}
  317.                                 }
  318.                                 else{wei = weima[4]; duan = LedBuff[4];}        break;
  319.                
  320.                 case 5:        wei = weima[5]; duan = LedBuff[5];        break;
  321.                
  322.                 case 6:       
  323.                                 if(knum==3)
  324.                                 {if(shan==1){wei = 0x00; duan = LedBuff[6];}
  325.                                         else{wei = weima[6]; duan = LedBuff[6];}
  326.                                 }
  327.                                 else{wei = weima[6]; duan = LedBuff[6];}        break;       

  328.                 case 7:       
  329.                                 if(knum==3)
  330.                                 {if(shan==1){wei = 0x00; duan = LedBuff[7];}
  331.                                         else{wei = weima[7]; duan = LedBuff[7];}
  332.                                 }
  333.                                 else{wei = weima[7]; duan = LedBuff[7];}        break;
  334.                
  335.                 default: break;       

  336.         }

  337. }
复制代码
回复

使用道具 举报

ID:320226 发表于 2018-6-4 09:26 | 显示全部楼层
改回共阳极行吗反相器改为三极管蜂鸣器改为继电器吗
回复

使用道具 举报

ID:140489 发表于 2018-6-6 10:37 | 显示全部楼层
当然可以改为共阳的,仿真用反相器方便些,与三极管是一样的效果,做实物就用三极管;蜂鸣器报警的不用改,要接继电器就接p2.2口LED那里
回复

使用道具 举报

ID:376438 发表于 2018-8-14 09:43 | 显示全部楼层
谢谢楼主,学习一下
回复

使用道具 举报

ID:320226 发表于 2018-9-8 21:41 | 显示全部楼层
楼主  你好,可以将程序的共阴极改为共阳极吗?反相器改为三极管程序怎样改吖?
回复

使用道具 举报

ID:228888 发表于 2018-11-7 01:34 | 显示全部楼层
楼主,我想做一个预约开关,就是定时关,也能定时开的功能,你这个程序应该可以吧
回复

使用道具 举报

ID:140489 发表于 2018-11-7 07:55 | 显示全部楼层
可以的,你自己改改输出的状态就可以
回复

使用道具 举报

ID:228888 发表于 2018-11-21 06:24 | 显示全部楼层
楼主,我想增加一个功能,比如现在正在倒计时开的功能,我按一个按钮后,变成倒计时关,但是这间期倒计时一直在进行,其实就是想随时切换倒计时开或关,但不影响计时器的工作,只是改变了结果,请问这个功能怎么实现?
回复

使用道具 举报

ID:140489 发表于 2018-11-22 09:04 | 显示全部楼层
天籁游子 发表于 2018-11-21 06:24
楼主,我想增加一个功能,比如现在正在倒计时开的功能,我按一个按钮后,变成倒计时关,但是这间期倒计时一 ...

你可以设置一个标志位,如果标志位为1,就倒计时,为0就正计时
回复

使用道具 举报

ID:140489 发表于 2018-11-22 09:11 | 显示全部楼层
天籁游子 发表于 2018-11-21 06:24
楼主,我想增加一个功能,比如现在正在倒计时开的功能,我按一个按钮后,变成倒计时关,但是这间期倒计时一 ...

功能 :倒计时八数码管显示,最小1秒,最大24小时;计时结束蜂鸣器报警响10次;如果做实物,可以用继电器作开关控制强电。
设置方法:
1.按K1键第一次,秒位闪烁,短按加减键加减1,长按连加连减;
2.按K1键第二次,分位闪烁,短按加减键加减1,长按连加连减;
3.按K1键第三次,时位闪烁,短按加减键加减1,长按连加连减;
4.按K1键第四次,退出设置;
5.按K4键启动倒计时(非设置状态下时分秒其中之一不为0才能启动计时);
6.计时的时候,按K4键1次可以暂停计时并关闭输出,再按一次恢复计时并启动输出,按K6键停止计时并清零,关闭输出;
7.非计时状态下,K5手动开关控制输出。
回复

使用道具 举报

ID:439289 发表于 2018-12-12 10:29 来自手机 | 显示全部楼层
感谢分享 学习一下
回复

使用道具 举报

ID:504013 发表于 2019-4-3 20:09 | 显示全部楼层
为啥我试验后不报警发出声音呢
回复

使用道具 举报

ID:473698 发表于 2019-10-10 14:33 | 显示全部楼层
感谢楼主分享...
回复

使用道具 举报

ID:202586 发表于 2019-10-10 20:54 来自手机 | 显示全部楼层
谢谢分享,
回复

使用道具 举报

ID:243874 发表于 2020-10-19 13:20 | 显示全部楼层
感谢楼主分享。好东西,有电路图吗,这个图看不太清
回复

使用道具 举报

ID:140489 发表于 2020-10-19 14:22 | 显示全部楼层
ajian-1023 发表于 2020-10-19 13:20
感谢楼主分享。好东西,有电路图吗,这个图看不太清

你下载压缩包里有仿真文件的,源程序也有的,都很清晰的
回复

使用道具 举报

ID:826214 发表于 2021-3-30 23:00 | 显示全部楼层
你好,又可以借鉴的原理图吗
回复

使用道具 举报

ID:887667 发表于 2021-4-2 11:22 | 显示全部楼层
请问为什么是255
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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