这个单片机程序怎么实现长按加1?

1. #include<reg51.h>
   
2. sbit LED=P3^1;
   
3. sbit BEEP=P3^2;
   
4. sbit PWM=P3^0;
   
5. sbit INA=P2^4;
   
6. sbit INB=P2^5;
   
7. sbit INC=P2^6;
   
8. sbit IND=P2^7;  
   
9. unsigned char code led_mod[10]={0x3f,0x06,0x5b,0x4f,
   
10.           0x66,0x6d,0x7d,0x07,0x7f,0x6f};
    
11. unsigned char code led_sel[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
    
12. unsigned char DisplayCode[8]={0x00,0x00,0x00,0x3f,0x3f,0x40,0x3f,0x3f};
    
13. unsigned char code f_rotation[8]={0xfe,0xfd,0xfb,0xf7,0x7f,0xbf,0xdf,0xef};
    
14. unsigned char code b_rotation[4]={0X6F,0x3F,0x9F,0xCF }; typedef unsigned int u16; typedef unsigned char u8;
    
15.   bit king_flag=0 ;
    
16. bit Time_adjust=0;////????????????????????????     
    
17. bit timer_1sec_flag=0;//???????????1???????????
    
18. bit alarm_flag=0;//?????????????????????????????
    
19. bit alarm_fen_flag=0;
    
20. bit alarm_h_flag=0;  
    
21. bit led_flag=0;//????????????LED??10????
    
22. unsigned int motor=32;//?????????????????
    
23. bit dir=1;//???岽????????????????????????
    
24. bit r_run=0;    bit timer_1min_flag=0;     bit flag=0;      
    
25. unsigned char min=0;
    
26. unsigned char h=0;               u8 Motor_Step=0;
    
27. unsigned char alarm_min=10;//????????
    
28. unsigned char alarm_h=0;//?????С?
    
29. unsigned char key_value;
    
30. unsigned char led_timer_counter;        double count=2;unsigned char ID;unsigned char kind;  
    
31. sbit K1=P1^0;//????1
    
32. sbit K2=P1^1;
    
33. sbit K3=P1^2;
    
34. sbit K4=P1^3;
    
35. sbit K5=P1^4;
    
36. unsigned char  pre_sta[5]={1,1,1,1,1};//??????????????I/O????λ
    
37. unsigned char cur_sta[5]={1,1,1,1,1};//??????????????I/O????λ
    
38. unsigned char key_buff[5]={0xff,0xff,0xff,0xff,0xff};
    
39. void delay(unsigned int z)//??????
    
40. {
    
41.   unsigned int i,j;
    
42. for(i=0;i<z;i++)
    
43.   for(j=0;j<125;j++);
    
44. }
    
45. void led7seg_scan()//??????????
    
46. {
    
47. unsigned char i;
    
48.     for(i=0;i<4;i++)
    
49.    {
    
50.    P2=led_sel[i];//λ????????????λ????????
    
51.    P0=DisplayCode[i];//????????????????????
    
52.    delay(1);//delay 1ms
    
53.    P0=0x00;//?????????
    
54.    }
    
55. }
    
56. void Motor_Delay1ms(u16 c)   //??? 0us
    
57. {
    
58. for (; c>0; c--)
    
59. {
    
60. //   for (b=199;b>0;b--)
    
61. //   {
    
62. //     
    
63. //   }      
    
64. }
    
65.      
    
66. }
    
67.      void Motor_Run(bit dir)
    
68. {      
    
69.          
    
70.       if(r_run){
    
71.     switch(Motor_Step)
    
72.      {
    
73.       case 0: INA=1;INB=0;INC=0;IND=0;Motor_Step++;delay(12);break;
    
74.          
    
75.       case 1: INA=1;INB=0;INC=1;IND=0;Motor_Step++;delay(12);break;
    
76.         
    
77.       case 2: INA=0;INB=0;INC=1;IND=0;Motor_Step++;delay(12);break;
    
78.         
    
79.       case 3: INA=0;INB=1;INC=1;IND=0;Motor_Step++;delay(12);break;
    
80.         
    
81.       case 4: INA=0;INB=1;INC=0;IND=0;Motor_Step++;delay(12);break;
    
82.         
    
83.       case 5: INA=0;INB=1;INC=0;IND=0;Motor_Step++;delay(12);break;
    
84.         
    
85.       case 6: INA=0;INB=1;INC=1;IND=0;Motor_Step++;delay(12);break;
    
86.          
    
87.       case 7: INA=0;INB=0;INC=1;IND=0;Motor_Step++;delay(12);break;
    
88.       case 8: INA=1;INB=0;INC=0;IND=0;Motor_Step=0;delay(12);break;
    
89.          
    
90.      /* case 9: INA=0;INB=1;INC=1;IND=0;if(dir)Motor_Step++;else Motor_Step--;Motor_Delay1ms(20);break;
    
91.         
    
92.       case 10: INA=0;INB=0;INC=1;IND=0;if(dir)Motor_Step++;else Motor_Step--;Motor_Delay1ms(20);break;
    
93.         
    
94.       case 11: INA=0;INB=1;INC=1;IND=0;if(dir)Motor_Step++;else Motor_Step--;Motor_Delay1ms(20);break;
    
95.         
    
96.       case 12: INA=0;INB=1;INC=0;IND=0;if(dir)Motor_Step++;else Motor_Step--;Motor_Delay1ms(20);break;
    
97.         
    
98.       case 13: INA=0;INB=1;INC=0;IND=1;if(dir)Motor_Step++;else Motor_Step--;Motor_Delay1ms(20);break;
    
99.         
    
100.       case 14: INA=0;INB=0;INC=0;IND=1;if(dir)Motor_Step=0;else Motor_Step--;Motor_Delay1ms(20);break;   */
     
101.          
     
102.         
     
103.       
     
104.      }
     
105.   } else INA=0;INB=0;INC=0;IND=0;  
     
106.      delay(2);
     
107. }  
     
108. void   timer0_init()
     
109. {                                             
     
110.   TR0=1;//???????0
     
111. TMOD=0x11;//????????0??1????????????????????????1
     
112. EA=1;//???ж????ж?
     
113. ET0=1;//???????0???ж?
     
114. ET1=1;//???????1???ж?
     
115. TR1=0;//???????1
     
116.     TH0=(65536-4000)/256;//?????0????????   
     
117. TL0=(65536-4000)%256;
     
118.   TH1=(65536-4000)/256; //?????1????????  
     
119. TL1=(65536-4000)%256;
     
120. }           
     
121. void key_action(unsigned char key_value)//???????????
     
122. {        
     
123. if(key_value==1)
     
124. delay(100);//?????????????
     
125. {      
     
126. if(key_value==1) {
     
127.   LED=~LED;  king_flag=~king_flag;
     
128.   TR1=~TR1; delay(100);
     
129.   }
     
130.             else if(key_value==2)//?????????????
     
131. {        if(king_flag)
     
132.     {  if(K2==0)  {   delay(2); //????????????????????ж???????
     
133.   if(K2==0)  {   count+=1; //?????μ???????????0.5
     
134.      if(count>=8)     //???????????
     
135.    {  count=2; }  } while(!K1);  }  } }
     
136.   
     
137. else if(key_value==3 )//??3??????
     
138. {    if(king_flag) ID++;if(ID==3){
     
139. ID=0;
     
140.   }  }
     
141. //Motor_Run(dir);               }   
     
142.      
     
143.    
     
144.   
     
145.   else if(key_value==4)//????4????
     
146. { if(king_flag){   kind++;if(kind==4){
     
147. kind=0; }    }
     
148.   
     
149. /* else if(key_value==5)
     
150.       delay(100);  
     
151.   { if(key_value==5)if(king_flag) {
     
152. 
     
153.     if(alarm_fen_flag)//???????????????￡??????????????
     
154.   {  
     
155.    alarm_min++;
     
156.     if(alarm_min==60) alarm_min=0;
     
157.    DisplayCode[3]=led_mod[alarm_min%10];
     
158.    DisplayCode[2]=led_mod[alarm_min/10];
     
159.     }
     
160.   
     
161.   }      
     
162. 
     
163.   else  if(alarm_h_flag)//???????????????￡??????????????
     
164.   {
     
165.    alarm_h++;
     
166.     if(alarm_h==24) alarm_h=0;
     
167.    DisplayCode[1]=led_mod[alarm_h%10];
     
168.    DisplayCode[0]=led_mod[alarm_h/10];
     
169.     }
     
170.   
     
171.   }      }   */
     
172.    
     
173.    
     
174.      
     
175.   }  }
     
176. } unsigned char key_scan(void)//???????
     
177. {
     
178. unsigned char i;
     
179. unsigned char key_value=0;
     
180. for(i=0;i<5;i++)
     
181. {
     
182. if(cur_sta[i]!=pre_sta[i])//??????????????????
     
183.   {
     
184.    if(pre_sta[i]==1)//???????????,????????
     
185.    {
     
186.      key_value=i+1;
     
187.        }
     
188.     pre_sta[i]=cur_sta[i];//??????????????
     
189.     }
     
190. }
     
191.   return (key_value);//?????????????????????????????????
     
192. }
     
193. void cur_sta_update()//???????????
     
194. {
     
195. unsigned char i;
     
196.   key_buff[0]=(key_buff[0]<<1)|K1;//??????????K1?????key_buff[0]?е?????λ
     
197. key_buff[1]=(key_buff[1]<<1)|K2;//??????????K2?????key_buff[1]?е?????λ
     
198. key_buff[2]=(key_buff[2]<<1)|K3;//??????????K3?????key_buff[2]?е?????λ
     
199. key_buff[3]=(key_buff[3]<<1)|K4;//??????????K4?????key_buff[3]?е?????λ
     
200. key_buff[4]=(key_buff[4]<<1)|K5;//??????????K4?????key_buff[3]?е?????λ
     
201. for(i=0;i<5;i++)
     
202. {
     
203.   if((key_buff[i]&0x0f)==0x00)//???????4?γ???????
     
204.   {
     
205.    cur_sta[i]=0;//????μ????0
     
206.   }
     
207.   else if((key_buff[i]&0x0f)==0x0f)//???????4?γ???????
     
208.   {
     
209.   cur_sta[i]=1;//????μ????1
     
210.   }
     
211. }
     
212. }
     
213. void DisplayCode_update_time()//??????????????
     
214. {
     
215. if(Time_adjust==0)//?????δ???????????￡??????1????У????????????С?????
     
216. {
     
217.    if(timer_1sec_flag)//1 sec ?????
     
218.   {
     
219.    timer_1sec_flag=0;
     
220.      
     
221.    
     
222.     min++;
     
223.       if(min==60)
     
224.      {
     
225.       min=0;
     
226.       h++;
     
227.         if(h==24)
     
228.         h=0;
     
229.           }
     
230.       }   
     
231.    
     
232.    if(alarm_flag==0)//????δ???????????????????????????
     
233.    {DisplayCode[3]=led_mod[min%10];
     
234.    DisplayCode[2]=led_mod[min/10];         
     
235.    DisplayCode[1]=led_mod[h%10];
     
236.    DisplayCode[0]=led_mod[h/10];
     
237.    } delay(1);
     
238. }  
     
239. } void DisplayCode_update_time25()//??????????????
     
240. {
     
241. if(flag)//?????δ???????????￡??????1????У????????????С?????
     
242. {
     
243.    if(timer_1min_flag)//1 sec ?????
     
244.   {
     
245.    timer_1min_flag=0;
     
246.    
     
247.    
     
248.     alarm_min--;
     
249.       if(alarm_min==0)
     
250.      {    alarm_min=10;
     
251.     kind=0;  ID=0;LED=~LED;PWM=0;TR1=~TR1;
     
252.           }
     
253.       }   
     
254.     }}
     
255. void main()
     
256. {     unsigned char i,j;
     
257.     unsigned char k=0;
     
258. unsigned char key_value;LED=0;r_run=0;dir=0;
     
259. timer0_init(); IT0=1;
     
260.   while(1)
     
261. {      
     
262.   led7seg_scan();
     
263.   key_value=key_scan();
     
264.   key_action(key_value);
     
265.   DisplayCode_update_time();
     
266.   DisplayCode_update_time25();
     
267.       if(key_value!=0)  
     
268.   {    delay(2);
     
269.   while(key_value==0);
     
270.   if(key_value!=0)
     
271.   {
     
272.   for(i=10;i>0;i--){
     
273.   for(j=5;j>0;j--){
     
274.   BEEP=0;
     
275.   delay(1);
     
276.   BEEP=1;
     
277.   delay(1);
     
278.   }
     
279.   }
     
280.   BEEP=1;
     
281.   }
     
282.   }      
     
283.       
     
284.       
     
285.    
     
286.   
     
287.    switch(ID)
     
288.         {
     
289.          case 0: r_run=0; break;    //??/??
     
290.          case 1: r_run=1; break;    //???
     
291.         
     
292.         }
     
293.         if(r_run) Motor_Run(dir);
     
294.    switch(kind)
     
295.         {
     
296.          case 0: alarm_flag=0; break;    //??/??
     
297.          case 1: alarm_flag=1;alarm_fen_flag=1; break;    //???
     
298.          case 2:  alarm_flag=1;alarm_h_flag=1;alarm_fen_flag=0;DisplayCode[3]=led_mod[alarm_min%10];
     
299.     DisplayCode[2]=led_mod[alarm_min/10];      break;  //???
     
300.          case 3: alarm_flag=1;alarm_h_flag=0;alarm_fen_flag=0;flag=1;DisplayCode[1]=led_mod[alarm_h%10];
     
301.     DisplayCode[0]=led_mod[alarm_h/10];  DisplayCode[3]=led_mod[alarm_min%10];
     
302.     DisplayCode[2]=led_mod[alarm_min/10];     break;
     
303.         }  
     
304.       
     
305.       
     
306.       
     
307.   if(key_value==5)
     
308.       delay(100);if(key_value==5){if(king_flag) {
     
309.       
     
310.     if(alarm_fen_flag)//???????????????￡??????????????
     
311.   {  
     
312.    alarm_min++;
     
313.     if(alarm_min==60) alarm_min=0;
     
314.    DisplayCode[3]=led_mod[alarm_min%10];
     
315.    DisplayCode[2]=led_mod[alarm_min/10];while(key_value!=5);}
     
316.    else  if(alarm_h_flag)//???????????????￡??????????????
     
317.   {
     
318.    alarm_h++;
     
319.     if(alarm_h==24) alarm_h=0;
     
320.    DisplayCode[1]=led_mod[alarm_h%10];
     
321.    DisplayCode[0]=led_mod[alarm_h/10];}}delay(100); while(key_value!=5);} }
     
322. }                                       
     
323. void timer0_4ms() interrupt 1
     
324. {   
     
325. static unsigned char timer_count=0; static unsigned char count=0;static unsigned char count_timer=0;static unsigned char timer_count12=0;
     
326.          key_value=key_scan();
     
327.       
     
328.   TH0=(65536-4000)/256;
     
329. TL0=(65536-4000)%256;
     
330.                                  
     
331.     timer_count++;
     
332. if(timer_count==250)//1 sec
     
333. {
     
334.       
     
335.     timer_count=0;   
     
336.   timer_1sec_flag=1;
     
337.   }  
     
338.     if(alarm_flag)
     
339. {        
     
340. if(alarm_fen_flag){if(count_timer==100)  DisplayCode[3]=led_mod[alarm_min%10];  
     
341.   if(count_timer==100)  DisplayCode[2]=led_mod[alarm_min/10];  
     
342.     count_timer++;
     
343.     if(count_timer==170){  count_timer=0;
     
344.    DisplayCode[3]=0x00;  
     
345.     DisplayCode[2]=0x00;   
     
346.    
     
347.     }         
     
348. 
     
349.   }}if(alarm_h_flag)//???????????????￡??????????????
     
350.    
     
351.   {if(count==100)  DisplayCode[1]=led_mod[alarm_h%10];  
     
352.   if(count==100)  DisplayCode[0]=led_mod[alarm_h/10];  
     
353.     count++;
     
354.     if(count==170){  count=0;
     
355.    DisplayCode[1]=0x00;  
     
356.     DisplayCode[0]=0x00;   
     
357.     }         
     
358. 
     
359.   }  if(flag)
     
360.   {
     
361.   timer_count12++;
     
362.   if(timer_count12==250)
     
363.   {
     
364.   timer_count=0;
     
365.   timer_1min_flag=1;
     
366.   }
     
367. }   
     
368.   cur_sta_update();  {
     
369. }   
     
370. }void timer1_1ms() interrupt 3
     
371. {     
     
372.   static unsigned char led_timer_counter=0;   
     
373.      TR1=0;
     
374.      TH1=(65536-4000)/256;
     
375. TL1=(65536-4000)%256;
     
376.           TR1=1;
     
377.       led_timer_counter++;
     
378.      //????
     
379.       
     
380. {      
     
381.   if(led_timer_counter<count)   //count?????
     
382.   {
     
383. PWM=1;    //???????
     
384.    
     
385.   }
     
386.   else
     
387. PWM=0;
     
388.    
     
389.   if(led_timer_counter>8)
     
390.   {
     
391. led_timer_counter=0;
     
392.       
     
393.   }
     
394.    
     
395. }      
     
396.            }

复制代码