基于51單片機的籃球計分計時板程序+電路設計

在主程序中，先使能全局中斷，然后使能74HC245來控制數碼管。配置定時器0工作在模式1并設置定時初值1ms，清零TF位，使能定時器0并啟動定時器0。按鍵動作函數keys進行按鍵消抖。進入中斷后，不斷掃描按鍵動作，并在中斷中完成隊伍比分、倒計時和蜂鳴器的顯示。最后while（1）循環中調用按鍵掃描掃描函數Keys、 600s和24s倒計時, 檢測一次按鍵狀態，如果在連續的8次移位檢測中按鍵狀態保持不變，則判定為按鍵已動作，顯示相應的數碼管動態。主程序流程圖如圖6所示：
                             
圖6 主程序流程圖

3.2蜂鳴器子程序設計
在中斷子程序中，對蜂鳴器函數進行調用，并判斷600s和24s函數中sec是否為0。當十分鐘倒計未結束的時候，蜂鳴器不工作，當十分鐘倒計時結束的時候，蜂鳴器發出響聲。蜂鳴器電路流程圖如圖6所示：

                                  圖7 蜂鳴器電路


3.3按鍵動作子程序設計
在中斷中完成按鍵掃描并消抖，主程序調用按鍵動作函數。如果檢測到按鍵1按下，給k賦值1；如果檢測到按鍵2按下，給k賦值2；如果檢測到按鍵3按下，給k賦值3；如果檢測到按鍵4按下，給k賦值4；如果檢測到按鍵5按下，給k賦值5；如果檢測到按鍵6按下，給k賦值6；如果檢測到按鍵7按下，給k賦值7；如果檢測到按鍵8按下，給k賦值8；如果檢測到按鍵9按下，給k賦值9；如果檢測到按鍵10按下，給k賦值10。按鍵動作函數流程圖如圖8所示：
   
圖8 按鍵動作函數流程圖
3.4中斷子程序設計
中斷子程序中，通過定時器T0調用數碼管動態刷新函數、矩陣按鍵掃描函數以及蜂鳴器函數。中斷1000次即一秒，當達到一秒時，清零計數值以重新開始下一個一秒計時，同時設置一秒定時器標志為1。定時器中斷流程圖如圖9所示：

單片機源程序如下:

1. #include<reg52.h>
   
2.   
   
3. sbit ADDR0 = P1^0;
   
4. sbit ADDR1 = P1^1;
   
5. sbit ADDR2 = P1^2;
   
6. sbit ADDR3 = P1^3;
   
7. 
   
8. 
   
9. 
   
10. sbit KEY_OUT_1 = P2^3;
    
11. sbit KEY_OUT_2 = P2^2;
    
12. sbit KEY_OUT_3 = P2^1;
    
13. sbit KEY_OUT_4 = P2^0;
    
14. 
    
15. sbit KEY_IN_1 = P2^4;
    
16. sbit KEY_IN_2 = P2^5;
    
17. sbit KEY_IN_3 = P2^6;
    
18. sbit KEY_IN_4 = P2^7;
    
19. 
    
20. sbit BUZZ = P1^6;
    
21. 
    
22. unsigned char code a[]={
    
23.         0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
    
24.         0x80, 0x90};
    
25. unsigned char  ledbuff[12] = {
    
26. 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
    
27. 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
    
28. };
    
29. unsigned char  KeySta[4][4] = {
    
30.         {1,1,1,1,},
    
31.         {1,1,1,1,},
    
32.         {1,1,1,1,},
    
33.         {1,1,1,1,}};
    
34. char x,z,k;
    
35. char add1,add2;
    
36. unsigned char flagls = 0;
    
37. unsigned char rst24 = 24;
    
38. int sec = 600;
    
39. char cnt1 = 0;
    
40. char cnt2 = 0;
    
41. unsigned char b[4][4]={
    
42.         {1,3,0,9,},
    
43.         {2,4,0,0,},
    
44.         {5,6,0,10,},
    
45.         {7,8,0,0,}};
    
46. 
    
47. 
    
48. //蜂鳴器部分
    
49. void buzz()
    
50. {
    
51.    if(sec == 0) BUZZ=0;
    
52. }
    
53. 
    
54. 
    
55. //矩陣按鍵消抖
    
56. void keyx()
    
57. {
    
58.     unsigned char i;
    
59.     static unsigned char keyout = 0;   //矩陣按鍵掃描輸出索引
    
60.     static unsigned char keybuf[4][4] = {  //矩陣按鍵掃描緩沖區
    
61.         {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF},
    
62.         {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF}
    
63.     };
    
64. 
    
65.     //將一行的4個按鍵值移入緩沖區
    
66.     keybuf[keyout][0] = (keybuf[keyout][0] << 1) | KEY_IN_1;
    
67.     keybuf[keyout][1] = (keybuf[keyout][1] << 1) | KEY_IN_2;
    
68.     keybuf[keyout][2] = (keybuf[keyout][2] << 1) | KEY_IN_3;
    
69.     keybuf[keyout][3] = (keybuf[keyout][3] << 1) | KEY_IN_4;
    
70.     //消抖后更新按鍵狀態
    
71.     for (i=0; i<4; i++)  //每行4個按鍵，所以循環4次
    
72.     {
    
73.         if ((keybuf[keyout][i] & 0x0F) == 0x00)
    
74.         {   //連續4次掃描值為0，即4*4ms內都是按下狀態時，可認為按鍵已穩定的按下
    
75.             KeySta[keyout][i] = 0;
    
76.         }
    
77.         else if ((keybuf[keyout][i] & 0x0F) == 0x0F)
    
78.         {   //連續4次掃描值為1，即4*4ms內都是彈起狀態時，可認為按鍵已穩定的彈起
    
79.             KeySta[keyout][i] = 1;
    
80.         }
    
81.     }
    
82.     //執行下一次的掃描輸出
    
83.     keyout++;                //輸出索引遞增
    
84.     keyout = keyout & 0x03;  //索引值加到4即歸零
    
85.     switch (keyout)          //根據索引，釋放當前輸出引腳，拉低下次的輸出引腳
    
86.     {
    
87.         case 0: KEY_OUT_4 = 1; KEY_OUT_1 = 0; break;
    
88.         case 1: KEY_OUT_1 = 1; KEY_OUT_2 = 0; break;
    
89.         case 2: KEY_OUT_2 = 1; KEY_OUT_3 = 0; break;
    
90.         case 3: KEY_OUT_3 = 1; KEY_OUT_4 = 0; break;
    
91.         default: break;
    
92.     }
    
93. }
    
94. 
    
95. 
    
96. 
    
97. //600s  and  24秒暫停
    
98. void s600and24()
    
99. {
    
100.         
     
101.         static char y;
     
102.         y = rst24;
     
103.         
     
104.         if(cnt2 != 0)
     
105.         {
     
106.                 if(flagls == 1)
     
107.                 {
     
108.                         sec--;
     
109.                         if(cnt1 % 2 == 1)
     
110.                         {
     
111.                                 flagls = 0;        
     
112.                         }
     
113.                         
     
114.                 }
     
115.         }
     
116.         if(cnt1%2 == 0)
     
117.         {
     
118.                 if(flagls == 1)
     
119.                 {
     
120.                         rst24--;
     
121.                         flagls = 0;
     
122.                 }
     
123.         }
     
124.         else
     
125.         {
     
126.                 rst24 = y;
     
127.         
     
128.         }
     
129. }
     
130. 
     
131. 
     
132. //數碼管掃描
     
133. void LED()
     
134. {        
     
135.         static char n = 0;
     
136. 
     
137.         P0 =0XFF;
     
138. 
     
139.         ledbuff[0] = a[(sec%60)%10];
     
140.         ledbuff[1] = a[(sec%60)/10];
     
141.         ledbuff[2] = a[(sec/60)%10] & 0x7F;
     
142.         ledbuff[3] = a[(sec/60)/10];
     
143. 
     
144.         ledbuff[4] = a[rst24%10];
     
145.         ledbuff[5] = a[rst24/10];
     
146. 
     
147.         ledbuff[6] = a[add1%10];
     
148.         ledbuff[7] = a[add1/10%10];
     
149.         ledbuff[8] = a[add1/100%10];
     
150. 
     
151.         ledbuff[9] = a[add2%10];
     
152.         ledbuff[10] = a[add2/10%10];
     
153.         ledbuff[11] = a[add2/100%10];
     
154. 
     
155.         switch(n)
     
156.         {
     
157.                 case 0:   P3 = 0XFF;ADDR0 = 0;ADDR1 = 1;ADDR2 = 1;ADDR3 = 1; n++;P0 = ledbuff[0];break;
     
158.                 case 1:   P3 = 0XFF;ADDR0 = 1;ADDR1 = 0;ADDR2 = 1;ADDR3 = 1; n++;P0 = ledbuff[1];break;
     
159.                 case 2:   P3 = 0XFF;ADDR0 = 1;ADDR1 = 1;ADDR2 = 0;ADDR3 = 1; n++;P0 = ledbuff[2];break;
     
160.                 case 3:   P3 = 0XFF;ADDR0 = 1;ADDR1 = 1;ADDR2 = 1;ADDR3 = 0; n++;P0 = ledbuff[3];break;
     
161.                 case 4:   P3 = 0XFE;ADDR0 = 1;ADDR1 = 1;ADDR2 = 1;ADDR3 = 1; n++;P0 = ledbuff[4];break;
     
162.                 case 5:   P3 = 0XFD;ADDR0 = 1;ADDR1 = 1;ADDR2 = 1;ADDR3 = 1; n++;P0 = ledbuff[5];break;
     
163.                 case 6:   P3 = 0XFB;ADDR0 = 1;ADDR1 = 1;ADDR2 = 1;ADDR3 = 1; n++;P0 = ledbuff[6];break;
     
164.                 case 7:   P3 = 0XF7;ADDR0 = 1;ADDR1 = 1;ADDR2 = 1;ADDR3 = 1; n++;P0 = ledbuff[7];break;
     
165.                 case 8:   P3 = 0XEF;ADDR0 = 1;ADDR1 = 1;ADDR2 = 1;ADDR3 = 1; n++;P0 = ledbuff[8];break;
     
166.                 case 9:   P3 = 0XDF;ADDR0 = 1;ADDR1 = 1;ADDR2 = 1;ADDR3 = 1; n++;P0 = ledbuff[9];break;
     
167.                 case 10:  P3 = 0XBF;ADDR0 = 1;ADDR1 = 1;ADDR2 = 1;ADDR3 = 1; n++;P0 = ledbuff[10];break;
     
168.                 case 11:  P3 = 0X7F;ADDR0 = 1;ADDR1 = 1;ADDR2 = 1;ADDR3 = 1; n=0;P0 = ledbuff[11];break;
     
169.                 default: break;
     
170.                
     
171.         
     
172. 
     
173.                                                                                                                   
     
174. 
     
175.         }
     
176. 
     
177. }
     
178. 
     
179. //矩陣按鍵動作函數，根據鍵碼進行相關操作
     
180. void  keys()
     
181. {
     
182.         unsigned char i, j;
     
183. 
     
184.         static        unsigned char backup [4][4] = {
     
185.         {1,1,1,1},{1,1,1,1},{1,1,1,1},{1,1,1,1}
     
186.         };
     
187. 
     
188.         for(i=0; i<4; i++)
     
189.                 {
     
190.                         for(j=0; j<4; j++)
     
191.                         {
     
192.                                 if(backup[i][j] != KeySta[i][j])
     
193.                                 {
     
194.                                         if(backup[i][j] == 0)
     
195.                                         {
     
196.                                                 k = b[i][j]        ;
     
197.                                                 
     
198.                                                 switch(k)
     
199.                                                 {
     
200.                                                          case 1: add1++;break;
     
201.                                                         case 2: add1--;break;
     
202.                                                         case 3: add2++;break;
     
203.                                                         case 4: add2--;break;
     
204.                                                         case 5: rst24=24;break;
     
205.                                                         case 6: cnt1++;break;
     
206.                                                         case 7: x = add1; add1 = add2; add2 =x;break;
     
207.                                                         case 8: cnt2++;break;
     
208.                                                         case 9: sec = sec+60; break;
     
209.                                                         case 10: sec = sec-60;break;
     
210.                                                         default: break;
     
211.                                                 }
     
212.                                                 
     
213. 
     
214.                                         }
     
215.                                         backup[i][j] = KeySta[i][j];
     
216.                                 }
     
217.                         }        
     
218.                 }                  
     
219.         
     
220.         
     
221. }
     
222. 
     
223. 
     
224. 
     
225. void main()
     
226. {
     
227.         EA = 1;
     
228.         TMOD = 0X01;
     
229.         TH0 = 0XFC;
     
230.         TL0 = 0X67;
     
231.         ET0 = 1;
     
232.         TR0 = 1;
     
233. 
     
234.         add1 = add2 = 0;
     
235.         while(1)
     
236.         {
     
237.                 keys();
     
238.                 s600and24();        
     
239.         }
     
240. 
     
241. }
     
242. 
     
243. //T0中斷服務函數
     
244. void InterruptTimer0()interrupt 1
     
245. {
     
246.         static int cnt = 0;
     
247. 
     
248.         TH0 = 0XFC;
     
249.         TL0 = 0X67;
     
250. 
     
251.         cnt ++ ;
     
252.         keyx();
     
253.         LED() ;
     
254.         if(cnt >= 1000)
     
255.         {
     
256.                 cnt = 0;
     
257.                 flagls = 1;
     
258.         }
     
259.         buzz();
     
260. 
     
261. }
     

復制代碼

所有資料51hei提供下載:
籃球計分計時.rar (2.34 MB, 下載次數: 35)

2019-12-14 19:57 上傳

點擊文件名下載附件
下載積分: 黑幣 -5