如何添加两个按键，一个控制启停，一个清零？

zmllzw

1. #ifndef __SEG_H
   
2. 
   
3. #define __SEG_H
   
4. 
   
5. void Seg_Tran(unsigned char *pucSeg_Buf,
   
6.         unsigned char *pucSeg_Code) ;
   
7. 
   
8. void Seg_Disp(unsigned char *pucSeg_Code,
   
9.         unsigned char ucSeg_Pos) ;
   
10. 
    
11. #endif

复制代码

1. sfr P4= 0xC0;
   
2. sbit DAT = P4^0;
   
3. sbit OE = P4^1;
   
4. sbit LCK = P4^2;
   
5. sbit SCK = P4^3;
   
6. //代码转换: pucSeg_Buf- 显示字符串，pucSeg_ Code-显示字形码
   
7. void Seg_Tran(unsigned char *pucSeg_Buf,
   
8.         unsigned char *pucSeg_Code)
   
9. {
   
10.         unsigned char i, j=0, ucSeg_Code;
    
11.         for(i=0; i<4; i++, j++)
    
12.         {
    
13.                 switch(pucSeg_Buf[j])
    
14. 
    
15.                 {//低电平点亮段，段码[MS8...LSB]对应码顺序为[dp g f e d c b a]
    
16.                         case '0': ucSeg_Code =0xc0; break;                //11000000
    
17.                
    
18.                         case '1': ucSeg_Code =0xf9; break;     //11111001
    
19.                        
    
20.                         case '2': ucSeg_Code =0xa4; break;                //10100100
    
21.                        
    
22.                         case '3': ucSeg_Code = 0xb0; break;        //10110000
    
23.                        
    
24.                         case '4': ucSeg_Code = 0x99; break;                //10011001
    
25.                        
    
26.                         case '5': ucSeg_Code = 0x92; break;                //10010010
    
27. 
    
28.                         case '6': ucSeg_Code = 0x82; break;        //10000010
    
29.                        
    
30.                         case '7': ucSeg_Code = 0xf8; break;        //11111000
    
31.                        
    
32.                         case '8': ucSeg_Code = 0x80; break;                //10000000
    
33.                        
    
34.                         case '9': ucSeg_Code = 0x90; break;        //10010000
    
35.                        
    
36.                         case 'A': ucSeg_Code = 0x88; break;        //10001000
    
37.                        
    
38.                         case 'B': ucSeg_Code = 0x83; break;                //10000011
    
39.                        
    
40.                         case 'C': ucSeg_Code = 0xc6; break;                //11000110
    
41.                        
    
42.                         case 'D': ucSeg_Code = 0xA1; break;        //10100001
    
43.                        
    
44.                         case 'E': ucSeg_Code = 0x86; break;                //10000110
    
45.                        
    
46.                         case 'F': ucSeg_Code = 0x8E; break;        //10001110
    
47.                        
    
48.                         case 'H': ucSeg_Code = 0x89; break;        //10001001
    
49.                        
    
50.                         case 'I': ucSeg_Code =0xC7; break;                //11000111
    
51.                        
    
52.                         case '-': ucSeg_Code = 0xbf; break;                //10111111
    
53.                        
    
54.                         default: ucSeg_Code = 0xff;                                //11111111
    
55.                 }
    
56.                 if(pucSeg_Buf[j+i] == '.')
    
57.                 {
    
58.                         ucSeg_Code &= 0x7f;
    
59.                         j++;
    
60.                 }
    
61.                 pucSeg_Code[i] = ucSeg_Code;
    
62.           }
    
63.         }
    
64.         //数码管显示：pucSeg_Code-显示字形码，ucSeg_Pos-显示位置
    
65. void Seg_Disp(unsigned char *pucSeg_Code,
    
66.         unsigned char ucSeg_Pos)
    
67. {
    
68.         unsigned char i;
    
69.         unsigned int temp;
    
70. 
    
71. 
    
72.         temp = (1<<(8+ucSeg_Pos)) + pucSeg_Code[ucSeg_Pos];
    
73.         LCK = 0;
    
74.         for(i=0;i<12;i++)
    
75.         {
    
76.                 SCK = 0;
    
77.                 if(temp & 0x800)
    
78.                         DAT = 1;
    
79.                 else
    
80.                         DAT = 0;
    
81.                 temp  <<= 1;
    
82.                 SCK = 1;                                                                        //移位
    
83.         }
    
84.         LCK = 1;                                                                                //锁存
    
85.         OE = 0;
    
86. }                                                       

复制代码

1. #include <reg51.h>
   
2. #include <STDIO.H>
   
3. #include "seg.h"
   
4. //sbit P04=P0^4;
   
5. //sbit P05=P0^5;
   
6. 
   
7. unsigned char ucSec = 0,ucMin =0;
   
8. unsigned char pucSeg_Buf[6], pucSeg_Code[4], ucSeg_Pos = 0;
   
9. unsigned int uims = 0, uiSeg_Dly = 0;
   
10. 
    
11. // T1初始化
    
12. void T1_Init (void)                                // 1毫秒@12.000MHz
    
13. {
    
14. 
    
15.         TL1=0x18;
    
16.         TH1=0xFC;                                        //设置定时初值高8位
    
17.         TR1=1;                                        // T1开始计时
    
18.        
    
19. }
    
20. // T1 处理
    
21. 
    
22. void T1_Proc(void)
    
23. {
    
24. 
    
25.         if(!TF1)                                        //定时时间未到
    
26.           return;
    
27.         TF1 = 0;                                        //清除时间到标志
    
28.         if(++uims == 1000)                        // 1s到
    
29.         {
    
30.                 uims = 0;
    
31.                 if(++ucSec == 60)                // 1min到
    
32.                         ucSec =0;
    
33.         }
    
34.         if((uims&3) == 0)                        //4ma显示1位
    
35.         {
    
36.                 Seg_Disp(pucSeg_Code, ucSeg_Pos);
    
37.                 if (++ucSeg_Pos == 4)        //循环显示
    
38.                         ucSeg_Pos = 0;
    
39.         }
    
40.         if(++uiSeg_Dly == 500)                //500ms 到
    
41.                 uiSeg_Dly = 0;
    
42.         }
    
43.         //数码管处理(500ms刷新-次)
    
44.         void Seg_Proc (void)
    
45.         {
    
46.                 if(uiSeg_Dly != 0)
    
47.                         return;
    
48.                 uiSeg_Dly = 1;                        //500ms 到
    
49.                 sprintf(pucSeg_Buf,"%02u%02u",\
    
50.                 (unsigned int)ucMin,(unsigned int)ucSec);
    
51.                 Seg_Tran (pucSeg_Buf, pucSeg_Code);
    
52. }
    
53. //主函数
    
54. void main (void)
    
55. {
    
56.         T1_Init();
    
57. 
    
58.         while(1)
    
59.         {                                                                                  
    
60.                 T1_Proc();
    
61.                 Seg_Proc();
    
62.   }
    
63. }

复制代码

村里小黑

两个不同的脚连接按键，分别进行判断按键连接的引脚电平是否有变化（低至高或高至低，看硬件连接），检测到变化后一般加15ms的防抖，然后再判断是否确实变化，确实变化后再分别对应相应的启停或清零功能

番杰

直接用两个外部中断，用分别由两个按钮触发，
按钮1负责“启停”，按钮“2”负责清零。
定义2个标志位：

1. int start_flag; //0：停止   1：开始
   
2. int zreo_flag; //0：无效   1：清零

复制代码

（1）主函数首先进行初始化部分，然后while循环，
判断start_flag和zreo_flag的状态，
根据不同状态进行不同动作。
例如：

1. void main(void)
   
2. {
   
3.         BSP_Init();//硬件初始化
   
4.         Interrupt_Init(); //中断初始化
   
5.         //其他的什么初始化
   
6.        
   
7.         while(1)
   
8.         {
   
9.                 if(start_flag == 1)
   
10.                 {
    
11.                         Start(); //启动
    
12.                         if(zreo_flag == 1)
    
13.                         {
    
14.                                 Zero(); // 清零
    
15.                         }
    
16.                 }
    
17.                 else
    
18.                 {
    
19.                         Close(); // 关闭
    
20.                 }
    
21.         }
    
22. 
    
23. }

复制代码

（2）按下按钮1，触发外部中断0：程序进入中断，判断start_flag的状态，为0则置1，为1则清零。
例如：

1. void EXTI0(void)
   
2. {
   
3.         if(start_flag == 1)
   
4.                 start_flag = 0;
   
5.         else
   
6.                 start_flag = 1;
   
7. 
   
8.         // 清除中断状态标志位 ！！！！
   
9. }

复制代码

（3）按下按钮2，触发外部中断1：程序进入中断，判断zreo_flag的状态，为0则置1，为1则清零。写法同（2）。

另外，注意控制启停的按钮的中断优先级应该高于清零的