欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標題: 單片機24小時倒計時源程序+仿真 [打印本頁]
作者: lids    時間: 2018-5-16 11:07
標題: 單片機24小時倒計時源程序+仿真
功能 ：倒計時八數碼管顯示，最小1秒，最大24小時；計時結束蜂鳴器報警響10次；如果做實物，可以用繼電器作開關控制強電。
設置方法：
1.按K1鍵第一次，秒位閃爍，短按加減鍵加減1，長按連加連減；
2.按K1鍵第二次，分位閃爍，短按加減鍵加減1，長按連加連減；
3.按K1鍵第三次，時位閃爍，短按加減鍵加減1，長按連加連減；
4.按K1鍵第四次，退出設置；
5.按K4鍵啟動倒計時（非設置狀態下時分秒其中之一不為0才能啟動計時）；
6.計時的時候，按K4鍵1次可以暫停計時并關閉輸出，再按一次恢復計時并啟動輸出，按K6鍵停止計時并清零，關閉輸出；
7.非計時狀態下，K5手動開關控制輸出。
完整工程文件見附件

仿真原理圖如下（proteus仿真工程文件可到本帖附件中下載）


單片機源程序：
  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;
  16. uchar shi=0,fen=0,miao=0,cont,cont1,cont2;
  17. uchar code duanma[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};//共陰段碼表
  18. //uchar code weima[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};//位碼
  19. uchar code weima[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};//位碼        加反相器用

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

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


  39. void dispaly(uchar shi,uchar fen,uchar miao)
  40. {
  41.                
  42.                 duan = 0;
  43.                 wei = weima[5];
  44.                 duan = 0x40;
  45.                 delay(1);


  48.                 duan = 0;
  49.                 wei = weima[2];
  50.                 duan = 0x40;
  51.                 delay(1);


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



  313. void keysan()
  314. {
  315.         uchar i;
  316.         if(knum==0)
  317.         {
  318.                 if(key4 == 0 )                  //啟動 暫停
  319.                 {
  320.                         
  321.                         i++;  //消抖
  322.                         if( (key4 == 0 && i>12 )|| (miao != 0) || (fen != 0) || (shi != 0) )
  323.                         {        //時分秒都為0時，不能啟動輸出，只要其中之一不為0，就能啟動輸出
  324.                                 i=0;
  325.                                 while(!key4)
  326.                                 dispaly(shi,fen,miao);
  327.                                 flag = !flag;
  328.                                 out = !out;
  329.                         }
  330.                 }
  331.         }
  332.         
  333.         if(key5 == 0 )          //手動開關，在沒有倒計時的狀態下才有用
  334.         {
  335.                 delay(5);
  336.         //        i++;
  337.                 if( key5 == 0  )
  338.                 {
  339.         //                i=0;
  340.                         while(!key5)
  341.                         dispaly(shi,fen,miao);
  342.                         if(shi==0 && fen==0 && miao==0)
  343.                         out = !out;
  344.                 }
  345.         }

  347.         
  348.         if(key1==0)                //設置
  349.         {
  350.                 i++;
  351.                 if(key1 ==0 && i>12)
  352.                 {
  353.                         i=0;
  354.                         while(!key1)
  355.                         dispaly(shi,fen,miao);
  356.                         knum++;
  357.                         if(knum==4)
  358.                                 knum = 0;
  359.                 }        
  360.         }

  362.         if(knum==1)
  363.         {        
  364.                 if(key2==0)
  365.                 {
  366.                         i++;
  367.                         if(key2 ==0 && i>20)
  368.                         {
  369.                                 i=0;
  370.                                 miao++;
  371.                                 if(miao==60)
  372.                                         miao = 0;
  373.                         }        
  374.                 }
  375.         
  376.                 if(key3==0)
  377.                 {
  378.                         i++;
  379.                         if(key3 ==0 && i>20)
  380.                         {
  381.                                 i=0;
  382.                                 miao--;
  383.                                 if(miao==255)
  384.                                         miao = 59;
  385.                         }        
  386.                 }
  387.     }

  389.         if(knum==2)
  390.         {        
  391.                 if(key2==0)
  392.                 {
  393.                         i++;
  394.                         if(key2 ==0 && i>20)
  395.                         {
  396.                                 i=0;
  397.                                 fen++;
  398.                                 if(fen==60)
  399.                                         fen = 0;
  400.                         }        
  401.                 }
  402.         
  403.                 if(key3==0)
  404.                 {
  405.                         i++;
  406.                         if(key3 ==0 && i>20)
  407.                         {
  408.                                 i=0;
  409.                                 fen--;
  410.                                 if(fen==255)
  411.                                         fen = 59;
  412.                         }        
  413.                 }
  414.     }

  416.         if(knum==3)
  417.         {        
  418.                 if(key2==0)
  419.                 {
  420.                         i++;
  421.                         if(key2 ==0 && i>20)
  422.                         {
  423.                                 i=0;
  424.                                 shi++;
  425.                                 if(shi==24)
  426.                                         shi = 0;
  427.                         }        
  428.                 }
  429.         
  430.                 if(key3==0)
  431.                 {
  432.                         i++;
  433.                         if(key3 ==0 && i>20)
  434.                         {
  435.                                 i=0;
  436.                                 shi--;
  437.                                 if(shi==255)
  438.                                         shi = 23;
  439.                         }        
  440.                 }
  441.     }
  442. }


  445. void main()
  446. {
  447.         init();
  448.         wei = 0x00;
  449.         while(1)
  450.         {
  451.                 keysan();
  452.                 dispaly(shi,fen,miao);
  453.                 if(shi==0 && fen==0 && miao==0 && flag == 1)  //倒計時時間到
  454.                 {
  455.                          flag=0;          //停止計時
  456.                         flag1=1;  //啟動蜂鳴器標志置1
  457.                         out=1;          //關閉輸出
  458.                 }
  459.         }        
  460. }

  462. void timer() interrupt 1
  463. {
  464.         TH0 = (65536-50000)/256;          //50毫秒初值
  465.         TL0 = (65536-50000)%256;
  466.         
  467.         if(flag)
  468.         {
  469.                 cont++;
  470.                 if(cont == 20)         
  471.                 {
  472.                         cont = 0;
  473.                         miao--;
  474.                         if(miao==255)
  475.                         {
  476.                                 miao=59;
  477.                                 fen--;
  478.                                 if(fen==255)
  479.                                 {
  480.                                         fen=59;
  481.                                         shi--;
  482.                                         if(shi==255)
  483.                                         {
  484.                                                 shi=0;
  485.                                         }
  486.                                         if(shi==0)
  487.                                                 fen=59;
  488.                                         if(fen==0 && shi==0)
  489.                                                 fen=0;
  490.                                 }
  491.                         }
  492.                 }
  493.         }

  495.         if(flag1)                 //倒計時時間到，啟動蜂鳴器
  496.         {
  497.                 cont1++;
  498.                 if(cont1==10) //500ms蜂鳴器響一次
  499.                 {
  500.                         cont1=0;
  501.                         di=!di;
  502.                         cont2++;
  503.                         if(cont2==20)//500*20=10000ms=10s，蜂鳴器響10s后停止
  504.                         {
  505.                                 cont2=0;
  506.                                 flag1=0;
  507.                         }
  508.                 }
  509.         }

  511.         if(knum != 0)
  512.         {
  513.                 shan_cont++;
  514.                 if(shan_cont==5)  //250ms閃爍時間
  515.                 {
  516.                         shan_cont=0;
  517.                         shan = !shan;
  518.                 }
  519.         }
  520. }
復制代碼

全部資料51hei下載地址：
24小時倒計時仿真文件.rar (180.63 KB, 下載次數: 324)



作者: 維超    時間: 2018-5-16 21:04
很好的例程
作者: lids    時間: 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. }
復制代碼
作者: lids    時間: 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. }
復制代碼
作者: vbnm    時間: 2018-6-4 09:26
改回共陽極行嗎反相器改為三極管蜂鳴器改為繼電器嗎
作者: lids    時間: 2018-6-6 10:37
當然可以改為共陽的，仿真用反相器方便些，與三極管是一樣的效果，做實物就用三極管；蜂鳴器報警的不用改，要接繼電器就接p2.2口LED那里
作者: eeadad    時間: 2018-8-14 09:43
謝謝樓主，學習一下
作者: vbnm    時間: 2018-9-8 21:41
樓主  你好，可以將程序的共陰極改為共陽極嗎？反相器改為三極管程序怎樣改吖？
作者: 天籟游子    時間: 2018-11-7 01:34
樓主，我想做一個預約開關，就是定時關，也能定時開的功能，你這個程序應該可以吧
作者: lids    時間: 2018-11-7 07:55
可以的，你自己改改輸出的狀態就可以
作者: 天籟游子    時間: 2018-11-21 06:24
樓主，我想增加一個功能，比如現在正在倒計時開的功能，我按一個按鈕后，變成倒計時關，但是這間期倒計時一直在進行，其實就是想隨時切換倒計時開或關，但不影響計時器的工作，只是改變了結果，請問這個功能怎么實現？
作者: lids    時間: 2018-11-22 09:04
天籟游子 發表于 2018-11-21 06:24
樓主，我想增加一個功能，比如現在正在倒計時開的功能，我按一個按鈕后，變成倒計時關，但是這間期倒計時一 ...

你可以設置一個標志位，如果標志位為1，就倒計時，為0就正計時
作者: lids    時間: 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手動開關控制輸出。
作者: a250720    時間: 2018-12-12 10:29
感謝分享 學習一下
作者: 且戰且走    時間: 2019-4-3 20:09
為啥我試驗后不報警發出聲音呢
作者: yejianxin1990    時間: 2019-10-10 14:33
感謝樓主分享...
作者: 學徒工--靜    時間: 2019-10-10 20:54
謝謝分享，
作者: ajian-1023    時間: 2020-10-19 13:20
感謝樓主分享。好東西，有電路圖嗎，這個圖看不太清
作者: lids    時間: 2020-10-19 14:22
ajian-1023 發表于 2020-10-19 13:20
感謝樓主分享。好東西，有電路圖嗎，這個圖看不太清

你下載壓縮包里有仿真文件的，源程序也有的，都很清晰的
作者: 提咯紅敏敏    時間: 2021-3-30 23:00
你好，又可以借鑒的原理圖嗎
作者: Danielw3    時間: 2021-4-2 11:22
請問為什么是255
作者: huhuli    時間: 2025-1-4 17:15
請問這個源程序要怎么樣才能改成At89c51的程序呢？有什么要特別注意的地方嗎？
作者: huhuli    時間: 2025-1-4 18:09
lids 發表于 2018-5-22 12:33
按鍵掃描部分重新寫一下，加減鍵的短按更穩定，長按短按分的更清

按鍵消抖、確認按鍵確實被按下后，加一行代碼：        while(key==0);，意思是確認按鍵松開才執行功能，可以使按鍵更穩定。



歡迎光臨 (http://www.raoushi.com/bbs/) Powered by Discuz! X3.1