设为首页收藏本站
开启辅助访问

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机24小时倒计时源程序+仿真

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

查看数: 20717 | 评论数: 22 | 收藏 11
关灯 | 提示：支持键盘翻页<-左 右->
帖子模式
    组图打开中，请稍候......
lids
发布时间: 2018-5-16 11:07

正文摘要:

功能 ：倒计时八数码管显示，最小1秒，最大24小时；计时结束蜂鸣器报警响10次；如果做实物，可以用继电器作开关控制强电。 设置方法： 1.按K1键第一次，秒位闪烁，短按加减键加减1，长按连加连减； 2.按K1键第二 ...

回复

ID:1140794 发表于 2025-1-4 18:09
lids 发表于 2018-5-22 12:33
按键扫描部分重新写一下，加减键的短按更稳定，长按短按分的更清

按键消抖、确认按键确实被按下后，加一行代码：        while(key==0);，意思是确认按键松开才执行功能，可以使按键更稳定。
ID:1140794 发表于 2025-1-4 17:15
请问这个源程序要怎么样才能改成At89c51的程序呢？有什么要特别注意的地方吗？
ID:887667 发表于 2021-4-2 11:22
请问为什么是255
ID:826214 发表于 2021-3-30 23:00
你好，又可以借鉴的原理图吗
ID:140489 发表于 2020-10-19 14:22
ajian-1023 发表于 2020-10-19 13:20
感谢楼主分享。好东西，有电路图吗，这个图看不太清

你下载压缩包里有仿真文件的，源程序也有的，都很清晰的
ID:243874 发表于 2020-10-19 13:20
感谢楼主分享。好东西，有电路图吗，这个图看不太清
ID:202586 发表于 2019-10-10 20:54
谢谢分享，
ID:473698 发表于 2019-10-10 14:33
感谢楼主分享...
ID:504013 发表于 2019-4-3 20:09
为啥我试验后不报警发出声音呢
ID:439289 发表于 2018-12-12 10:29
感谢分享 学习一下
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:140489 发表于 2018-11-22 09:04
天籁游子 发表于 2018-11-21 06:24
楼主，我想增加一个功能，比如现在正在倒计时开的功能，我按一个按钮后，变成倒计时关，但是这间期倒计时一 ...

你可以设置一个标志位，如果标志位为1，就倒计时，为0就正计时
ID:228888 发表于 2018-11-21 06:24
楼主，我想增加一个功能，比如现在正在倒计时开的功能，我按一个按钮后，变成倒计时关，但是这间期倒计时一直在进行，其实就是想随时切换倒计时开或关，但不影响计时器的工作，只是改变了结果，请问这个功能怎么实现？
ID:140489 发表于 2018-11-7 07:55
可以的，你自己改改输出的状态就可以
ID:228888 发表于 2018-11-7 01:34
楼主，我想做一个预约开关，就是定时关，也能定时开的功能，你这个程序应该可以吧
ID:320226 发表于 2018-9-8 21:41
楼主  你好，可以将程序的共阴极改为共阳极吗？反相器改为三极管程序怎样改吖？
ID:376438 发表于 2018-8-14 09:43
谢谢楼主，学习一下
ID:140489 发表于 2018-6-6 10:37
当然可以改为共阳的，仿真用反相器方便些，与三极管是一样的效果，做实物就用三极管；蜂鸣器报警的不用改，要接继电器就接p2.2口LED那里
ID:320226 发表于 2018-6-4 09:26
改回共阳极行吗反相器改为三极管蜂鸣器改为继电器吗
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;                //蜂鸣器

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

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


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


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

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

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


  112.         if(key2==0)                //加
  113.         {
  114.                 j++;
  115.                 if(j >= 3000)           //长按，数码管扫描放中断里面，这里的值就要取得大才行
  116.                 {                                        //因为没用delay延时，CPU跑的很快
  117.                         if(knum==1)
  118.                         {
  119.                                 miao++;
  120.                                 if(miao==60)
  121.                                         miao = 0;
  122.                         }

  124.                         if(knum==2)
  125.                         {
  126.                                 fen++;
  127.                                 if(fen==60)
  128.                                         fen=0;
  129.                         }

  131.                         if(knum==3)
  132.                         {
  133.                                 shi++;
  134.                                 if(shi==24)
  135.                                         shi=0;
  136.                         }

  138.                         j=1000;           //这里j的值可以设置连加的快慢，j的值越大就越快
  139.                 }                           //因为初值越大，加到3000的时间就越短
  140.         }       

  142.         else
  143.         {
  144.                         if(j>500 && j<3000) //短按
  145.                         {
  146.                                
  147.                         if(knum==1)
  148.                         {
  149.                                 miao++;
  150.                                 if(miao==60)
  151.                                         miao = 0;
  152.                         }

  154.                         if(knum==2)
  155.                         {
  156.                                 fen++;
  157.                                 if(fen==60)
  158.                                         fen=0;
  159.                         }

  161.                         if(knum==3)
  162.                         {
  163.                                 shi++;
  164.                                 if(shi==24)
  165.                                         shi=0;
  166.                         }
  167.                         j=0;
  168.                 }

  170.         }       
  171.        
  172.         if(key3==0)                //减
  173.         {
  174.                 k++;
  175.                 if(k >= 3000)           //长按
  176.                 {
  177.                         if(knum==1)
  178.                         {
  179.                                 miao--;
  180.                                 if(miao==255)
  181.                                         miao = 59;
  182.                         }

  184.                         if(knum==2)
  185.                         {
  186.                                 fen--;
  187.                                 if(fen==255)
  188.                                         fen=59;
  189.                         }

  191.                         if(knum==3)
  192.                         {
  193.                                 shi--;
  194.                                 if(shi==255)
  195.                                         shi=23;
  196.                         }

  198.                         k=1000;
  199.                 }
  200.         }       

  202.         else
  203.         {
  204.                 if(k>500 && k<3000) //短按
  205.                 {
  206.                                
  207.                         if(knum==1)
  208.                         {
  209.                                 miao--;
  210.                                 if(miao==255)
  211.                                         miao = 59;
  212.                         }

  214.                         if(knum==2)
  215.                         {
  216.                                 fen--;
  217.                                 if(fen==255)
  218.                                         fen=59;
  219.                         }

  221.                         if(knum==3)
  222.                         {
  223.                                 shi--;
  224.                                 if(shi==255)
  225.                                         shi=23;
  226.                         }
  227.                 }
  228.                 k=0;        //消抖变量清零，为下次按键做准备       
  229.         }         
  230. }


  233. void main()
  234. {
  235.         init();
  236.         out = 1;
  237.         while(1)
  238.         {
  239.                 keysan();
  240.                 dis();
  241.                 if(shi==0 && fen==0 && miao==0 && flag == 1 )  //倒计时时间到
  242.                 {
  243.                          flag=0;          //停止计时
  244.                         flag1=1;  //启动蜂鸣器标志置1
  245.                         out=1;          //关闭输出
  246.                 }
  247.         }       
  248. }

  250. void timer() interrupt 1
  251. {
  252.         TH0 = (65536-1000)/256;          //50毫秒初值
  253.         TL0 = (65536-1000)%256;
  254.        
  255.         if(flag)
  256.         {
  257.                 cont++;
  258.                 if(cont == 1000)          
  259.                 {
  260.                         cont = 0;
  261.                         miao--;
  262.                         if(miao==255)
  263.                         {
  264.                                 miao=59;
  265.                                 fen--;
  266.                                 if(fen==255)
  267.                                 {
  268.                                         fen=59;
  269.                                         shi--;
  270.                                         if(shi==255)
  271.                                         {
  272.                                                 shi=0;
  273.                                         }
  274.                                         if(shi==0)
  275.                                                 fen=59;
  276.                                         if(fen==0 && shi==0)
  277.                                                 fen=0;
  278.                                 }
  279.                         }
  280.                 }
  281.         }

  283.         if(flag1)                 //倒计时时间到，启动蜂鸣器
  284.         {
  285.                 cont1++;
  286.                 if(cont1==500) //500ms蜂鸣器响一次
  287.                 {
  288.                         cont1=0;
  289.                         di=!di;
  290.                         cont2++;
  291.                         if(cont2==20)//500*20=10000ms=10s，蜂鸣器响10s后停止
  292.                         {
  293.                                 cont2=0;
  294.                                 flag1=0;
  295.                         }
  296.                 }
  297.         }

  299.         if(knum != 0)
  300.         {
  301.                 shan_cont++;
  302.                 if(shan_cont==100)  //设置时，100ms闪烁时间        可根据实际效果调整
  303.                 {
  304.                         shan_cont=0;
  305.                         shan = !shan;
  306.                 }
  307.         }
  308. /**********数码管扫描函数************/
  309.         i++;
  310.         if(i>=8)
  311.         {
  312.                 i=0;
  313.         }
  314.         duan = 0x00;
  315.         switch(i)
  316.         {
  317.                 case 0:
  318.                                 if(knum==1)                                                                          //如果设置键第一次按下
  319.                                 {if(shan==1){wei = 0x00; duan = LedBuff[0];}  //设置秒位闪烁
  320.                                         else{wei = weima[0]; duan = LedBuff[0];}
  321.                                 }
  322.                                 else{wei = weima[0]; duan = LedBuff[0];}        break;        //否则正常显示
  323.                
  324.                 case 1:       
  325.                                
  326.                                 if(knum==1)
  327.                                 {if(shan==1){wei = 0x00; duan = LedBuff[1];}
  328.                                         else{wei = weima[1]; duan = LedBuff[1];}
  329.                                 }
  330.                                 else{wei = weima[1]; duan = LedBuff[1];}  break;
  331.        
  332.                 case 2:        wei = weima[2]; duan = LedBuff[2];        break;
  333.                
  334.                 case 3:       
  335.                                 if(knum==2)
  336.                                 {if(shan==1){wei = 0x00; duan = LedBuff[3];}
  337.                                         else{wei = weima[3]; duan = LedBuff[3];}
  338.                                 }
  339.                                 else{wei = weima[3]; duan = LedBuff[3];}        break;
  340.                
  341.                 case 4:       
  342.                                 if(knum==2)
  343.                                 {if(shan==1){wei = 0x00; duan = LedBuff[4];}
  344.                                         else{wei = weima[4]; duan = LedBuff[4];}
  345.                                 }
  346.                                 else{wei = weima[4]; duan = LedBuff[4];}        break;
  347.                
  348.                 case 5:        wei = weima[5]; duan = LedBuff[5];        break;
  349.                
  350.                 case 6:       
  351.                                 if(knum==3)
  352.                                 {if(shan==1){wei = 0x00; duan = LedBuff[6];}
  353.                                         else{wei = weima[6]; duan = LedBuff[6];}
  354.                                 }
  355.                                 else{wei = weima[6]; duan = LedBuff[6];}        break;       

  357.                 case 7:       
  358.                                 if(knum==3)
  359.                                 {if(shan==1){wei = 0x00; duan = LedBuff[7];}
  360.                                         else{wei = weima[7]; duan = LedBuff[7];}
  361.                                 }
  362.                                 else{wei = weima[7]; duan = LedBuff[7];}        break;
  363.                
  364.                 default: break;       

  366.         }

  368. }
复制代码
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;        //消抖延时变量

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

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

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



  66.         if(key2==0)                //加
  67.         {
  68.                 j++;
  69.                 if(j >= 120)           //长按
  70.                 {
  71.                         if(knum==1)
  72.                         {
  73.                                 miao++;
  74.                                 if(miao==60)
  75.                                         miao = 0;
  76.                         }

  78.                         if(knum==2)
  79.                         {
  80.                                 fen++;
  81.                                 if(fen==60)
  82.                                         fen=0;
  83.                         }

  85.                         if(knum==3)
  86.                         {
  87.                                 shi++;
  88.                                 if(shi==24)
  89.                                         shi=0;
  90.                         }

  92.                         j=90;           //这里j的值可以设置连加的快慢，j的值越大就越快
  93.                 }                           //因为初值越大，加到120的时间就越短
  94.         }       

  96.         else
  97.         {
  98.                         if(j>15 && j<120) //短按
  99.                         {
  100.                                
  101.                         if(knum==1)
  102.                         {
  103.                                 miao++;
  104.                                 if(miao==60)
  105.                                         miao = 0;
  106.                         }

  108.                         if(knum==2)
  109.                         {
  110.                                 fen++;
  111.                                 if(fen==60)
  112.                                         fen=0;
  113.                         }

  115.                         if(knum==3)
  116.                         {
  117.                                 shi++;
  118.                                 if(shi==24)
  119.                                         shi=0;
  120.                         }
  121.                         j=0;
  122.                 }

  124.         }       
  125.        
  126.         if(key3==0)                //减
  127.         {
  128.                 k++;
  129.                 if(k >= 120)           //长按
  130.                 {
  131.                         if(knum==1)
  132.                         {
  133.                                 miao--;
  134.                                 if(miao==255)
  135.                                         miao = 59;
  136.                         }

  138.                         if(knum==2)
  139.                         {
  140.                                 fen--;
  141.                                 if(fen==255)
  142.                                         fen=59;
  143.                         }

  145.                         if(knum==3)
  146.                         {
  147.                                 shi--;
  148.                                 if(shi==255)
  149.                                         shi=23;
  150.                         }

  152.                         k=90;
  153.                 }
  154.         }       

  156.         else
  157.         {
  158.                 if(k>15 && k<120) //短按
  159.                 {
  160.                                
  161.                         if(knum==1)
  162.                         {
  163.                                 miao--;
  164.                                 if(miao==255)
  165.                                         miao = 59;
  166.                         }

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

  175.                         if(knum==3)
  176.                         {
  177.                                 shi--;
  178.                                 if(shi==255)
  179.                                         shi=23;
  180.                         }
  181.                 }
  182.                 k=0;       
  183.         }         
  184. }
复制代码
ID:46999 发表于 2018-5-16 21:04
很好的例程

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

Powered by 单片机教程网

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