单片机程序怎么修改设置好对应时间,等待10s左右自动倒计时,不用按键触发倒计时

1. #include<reg51.h>
   
2. #define uchar unsigned char
   
3. #define uint unsigned int
   
4. uchar min,sec,count,sec1,sec2,min0,min1,min2,keystopc,temp;
   
5. sbit keystop=P3^0;
   
6. sbit keyh=P3^1;
   
7. sbit keym=P3^2;
   
8. sbit keys=P3^3;
   
9. sbit lcden=P3^4;
   
10. sbit lcdrw=P3^6;
    
11. sbit lcdrs=P3^5;
    
12. uchar code table[]={'0','1','2','3','4','5','6','7','8','9',':'};
    
13. void init()                                                //定时器初始化
    
14. {
    
15.         count=0;
    
16.         min=0;
    
17.         sec=59;
    
18.         TMOD=0x01;
    
19.         TH0=(65536-50000)/256;
    
20.         TL0=(65536-50000)%256;
    
21.         TR0=0;
    
22.         ET0=1;
    
23.         EA=1;
    
24. }
    
25. void delay(uint z)                //延时程序
    
26. {
    
27.         uint x,y;
    
28.         for(x=z;x>0;x--)
    
29.          for(y=110;y>0;y--);
    
30. }
    
31. /**************************************************************
    
32. ------LCD1602显示函数------
    
33. *************************************************************/
    
34. void write_com(uchar com)
    
35. {
    
36.         lcdrs=0;
    
37.         P0=com;
    
38.         delay(5);
    
39.         lcden=1;
    
40.         delay(5);
    
41.         lcden=0;
    
42. }
    
43. void write_data(uchar date)
    
44. {
    
45.         lcdrs=1;
    
46.         P0=date;
    
47.         delay(5);
    
48.         lcden=1;
    
49.         delay(5);
    
50.         lcden=0;
    
51. }
    
52. void init_1602()                                //初始化1602
    
53. {
    
54.         lcden=0;
    
55.         lcdrw=0;
    
56.         write_com(0x38);
    
57.         write_com(0x0c);
    
58.         write_com(0x06);
    
59.         write_com(0x01);
    
60.         write_com(0x80);
    
61. }
    
62. void write_Char(unsigned char x,unsigned char y,unsigned char date)
    
63. {
    
64.          if (y == 0)
    
65.          {
    
66.                 write_com(0x80 + x);     
    
67.          }
    
68.         else
    
69.          {
    
70.                 write_com(0xC0 + x);     
    
71.          }
    
72.         write_data(date);  
    
73. }
    
74. void display(uchar min0,uchar min1,uchar min2,uchar sec1,uchar sec2)         //显示程序
    
75. {        
    
76.         write_Char(3,0,table[min0]);
    
77.         write_Char(4,0,table[min1]);
    
78.         write_Char(5,0,table[min2]);
    
79.         write_Char(6,0,table[0x0a]);
    
80.         write_Char(7,0,table[sec1]);
    
81.         write_Char(8,0,table[sec2]);
    
82. }
    
83. /************************************************************
    
84. ------计时器/定时器0-----
    
85. *************************************************************/
    
86. void count0() interrupt 1
    
87. {
    
88.         TH0=(65536-50000)/256;
    
89.         TL0=(65536-50000)%256;
    
90.         count++;
    
91.         if(count==20)
    
92.                 {
    
93.                         count=0;
    
94.                         if(sec==0)
    
95.                         {
    
96.                                 if (min!=0)
    
97.                                 {
    
98.                                         sec=59;
    
99.                                         min--;
    
100.                                 }                                
     
101.                         }
     
102.                         else sec--;
     
103.                 }
     
104. }
     
105. /************************************************************
     
106. ------主函数------
     
107. *************************************************************/
     
108. void main()
     
109. {
     
110.         init();
     
111.         init_1602();
     
112.         while(1)
     
113.         {               
     
114.                 if(keystop==0)                             //检测是否停止键按下
     
115.                 {
     
116.                         delay(10);
     
117.                         if(keystop==0)
     
118.                         {
     
119.                                 if(keystopc!=1)   keystopc++;      //按停止键的次数        
     
120.                                 else              keystopc=0;
     
121.                                 while(keystop==0);                 //松手检测
     
122.                                 delay(5);
     
123.                                 while(keystop==0);
     
124.                         }
     
125.                         switch(keystopc)
     
126.                         {
     
127.                                 case 1:TR0=0;break;                // 按键一次就停止计数
     
128.                                 case 0:TR0=1;break;
     
129.                                 default:break;
     
130.                         }
     
131.                 }
     
132.                 if(keyh==0)                 //实现小时加一
     
133.                 {
     
134.                         delay(50);
     
135.                         if(keyh==0)
     
136.                         {        
     
137.                                 if(min!=110)
     
138.                                 {
     
139.                                         min++;
     
140.                                 }
     
141.                         }
     
142.                         while(!keym);                  //松手检测
     
143.                         delay(5);
     
144.                         while(!keym);
     
145.                 }
     
146.                 if(keym==0)              //实现分钟加一
     
147.                 {
     
148.                         delay(100);
     
149.                         if(keym==0)
     
150.                         {        
     
151.                                 if(min!=0)
     
152.                                 {
     
153.                                         min--;
     
154.                                 }
     
155.                         }
     
156.                         while(!keyh);                //松手检测
     
157.                         delay(5);
     
158.                         while(!keyh);
     
159.                 }
     
160.                 min0=min/100;
     
161.                 min1=min%100/10;
     
162.                 min2=min%10;
     
163.                 sec1=sec/10;
     
164.                 sec2=sec%10;
     
165.                display(min0,min1,min2,sec1,sec2);  //一直显示时钟               
     
166.         }
     
167. }
     
168. 
     

复制代码

再用一个定时器来控制10秒

bit  T_run;             <==== 增加全局变量

/************************************************************
------计时器/定时器0-----
*************************************************************/
void count0() interrupt 1
{
        TH0=(65536-50000)/256;
        TL0=(65536-50000)%256;
        count++;
        if(T_run)               <==== 增加
        {
        if(count>=20)
                {
                        count=0;
                        if(sec==0)
                        {
                                if (min!=0)
                                {
                                        sec=59;
                                        min--;
                                }                                
                        }
                        else sec--;
                }
          }
          else                      <==== 增加
          {
                 if（count >= 200）           <==== 增加
                 {
                           T_run = 1;                  <==== 增加
                           count = 0;                 <==== 增加
                  }
          }
}
/************************************************************
------主函数------
*************************************************************/
void main()
{
        init();
        init_1602();
        TR0 = 1         <==== 增加
        while(1)
        {               
                if(keystop==0)                             //检测是否停止键按下
                {
                        delay(10);
                        if(keystop==0)
                        {
                                if(keystopc!=1)   keystopc++;      //按停止键的次数        
                                else              keystopc=0;
                                while(keystop==0);                 //松手检测
                                delay(5);
                                while(keystop==0);
                        }
                        switch(keystopc)
                        {
//                                case 1:TR0=0;break;                // 按键一次就停止计数
//                                case 0:TR0=1;break;
                                case 1:T_run=0;break;           <==== 修改
                                case 0:T_run=1;break;           <==== 修改
                               default:break;
                        }
                }
                if(keyh==0)                 //实现小时加一
                {
                        delay(50);
                        if(keyh==0)
                        {        
                                if(min!=110)
                                {
                                        min++;
                                }
                                count = 0;             <==== 增加
                        }
                        while(!keym);                  //松手检测
                        delay(5);
                        while(!keym);
                }
                if(keym==0)              //实现分钟加一
                {
                        delay(100);
                        if(keym==0)
                        {        
                                if(min!=0)
                                {
                                        min--;
                                }
                                count = 0;                  <==== 增加
                        }
                        while(!keyh);                //松手检测
                        delay(5);
                        while(!keyh);
                }
                min0=min/100;
                min1=min%100/10;
                min2=min%10;
                sec1=sec/10;
                sec2=sec%10;
               display(min0,min1,min2,sec1,sec2);  //一直显示时钟               
        }
}


惨不忍睹，只能改成这样了

既然是计时就一定有开始和结束。
结束：可以由计时器计时10s后触发。
开始：谁触发呢？不用按键触发，也需要你设置一个触发的方式呀。哪怕你决定打个喷嚏也行啊。

yzwzfyz 发表于 2021-10-28 14:33
既然是计时就一定有开始和结束。
结束：可以由计时器计时10s后触发。
开始：谁触发呢？不用按键触发，也 ...

这个是做一个倒计时的，只有两个按键，一个控制分钟加，一个控制分钟减
看能不能自动触发开始倒计时，设置倒计的时间后等待十秒，按键加和按键减没有被按下，测开始倒计时，启动定时器1

qwettyuio 发表于 2021-10-28 14:41
这个是做一个倒计时的，只有两个按键，一个控制分钟加，一个控制分钟减
看能不能自动触发开始倒计时，设 ...

那你再定时10秒啊！

很简单的事！抓住要点：如何起，如何停。再想想，不要想程序如何写，想想逻辑上是否说得通。

188610329 发表于 2021-10-28 14:25
bit  T_run;

我想把那个暂停/启动按键去掉，例如设置10分钟倒计时，设置结束后等待10s启动倒计时

yzwzfyz 发表于 2021-10-29 09:46
很简单的事！抓住要点：如何起，如何停。再想想，不要想程序如何写，想想逻辑上是否说得通。

原本使用一个按键控制启动和暂停
现在想使用设置好对应时间，等待10s左右，开启定时器进入倒计时，倒计时结束后定时器停止，蜂鸣器响3s停3s循环

qwettyuio 发表于 2021-11-10 14:53
我想把那个暂停/启动按键去掉，例如设置10分钟倒计时，设置结束后等待10s启动倒计时

不是帮你改好了么？

你不要那个暂停/启动 直接删掉不就行了？ 你程序试过没有？ 是不是那个键按不按都没所谓？是的话，直接删了不就没有了？

188610329 发表于 2021-11-10 15:15
不是帮你改好了么？

你不要那个暂停/启动 直接删掉不就行了？ 你程序试过没有？ 是不是那个键按不按都 ...

这个不能等待按键设置对应时间后等待10s再启动定时器进入倒计时，倒计时结束后，定时器一直在启动，没有中断停止

188610329 发表于 2021-11-10 15:15
不是帮你改好了么？

你不要那个暂停/启动 直接删掉不就行了？ 你程序试过没有？ 是不是那个键按不按都 ...

有两个加减按键设置时间的，倒计时结束后有蜂鸣器提示的，既要启动，也要停止

qwettyuio 发表于 2021-11-10 15:58
这个不能等待按键设置对应时间后等待10s再启动定时器进入倒计时，倒计时结束后，定时器一直在启动，没有 ...

这么改就是设好时间后，等10秒启动啊，你不是要等10秒启动么？ 定时器关了，怎么判断10秒？

至于停止，你原来怎么停的？你原来停的地方， 只要T_run = 0, 就停了啊，我只看到你按键的地方，所以那里我帮你写了 T_run = 0;
但是，其他地方，我没看到，你有其他停的地方，你手动把 T_run = 0, 反正， TR0 是不能 =0 的 不然，没办法10秒自己启动。

qwettyuio 发表于 2021-11-10 16:00
有两个加减按键设置时间的，倒计时结束后有蜂鸣器提示的，既要启动，也要停止

你原程序里哪里有到时间蜂鸣器响的判断？ 你原程序里没有，我帮你凭空加出来？