基于51单片机的五路抢答器Protues仿真设计

目次
一、设计背景
二、实现功能
三、仿真演示
四、源步调（部分）

---

一、设计背景

        近年来随着科技的飞速发展，单片机的应用正在不停的走向深入。本文阐述了基于51单片机的五路抢答器设计。本设计中，51单片机充当了焦点控制器的角色，通过IO口与各个功能模块相连接。按键模块负责检测参与者的抢答动作，当有人按下抢答按钮时，会通过IO口电平的变化关照单片机，单片时机记载按键的序次，并通过数码管显示当前的抢答结果。
        为了包管抢答过程的准确性和公平性，设计中还必要思量到以下因素。首先，按键模块必要具备快速相应和高可靠性，以确保抢答者的动作能够被准确地捕捉到。其次，显示屏模块必要能够及时更新抢答结果，并显示相应的信息，比如参与者的编号和抢答时间。末了，在电路连接方面，必要注意各个模块之间的线路布局，以避免信号干扰和电气题目。
       软件系统采用C语言编写步调，包括显示步调，定时中断服务，延时步调等，并在KEIL5中调试运行，硬件系统利用PROTEUS8.11强大的功能来实现，简单切易于观察，在仿真中就可以观察到实际的工作状态。
二、实现功能

        以51单片机为控制焦点，设计一种五路抢答器。整个系统包括MCU、晶振电路、时钟电路、蜂鸣器控制电路、指示灯控制电路、独立按键电路、矩阵键盘以及数码管显示电路等。可具体实现以下功能：
     （1）设定矩阵键盘的5个键作为5位选手的抢答按键,键的编号即选手编号，为1~5号，同时设定5个LED灯作为5位选手抢答状态指示;设定1个独立按键作为抢答开始键;选择两位数码管作为倒计时、选手编号及犯规显示;选择蜂鸣器作为开始、抢答、犯规和计时结束的提示。
     （2）只有当裁判按下开始键时才可以进入正常抢答，否则属于犯规抢答。抢答完毕，或计时时间到，停止抢答，数码管显示0。当裁判按下抢答开始键时，开始抢答，计时器开始倒计时，10秒倒计期间，若有抢答，则停止计时，相应选手的LED灯亮，数码管显示选手号;若倒计时结束时无人抢答，则停止抢答。
     （3）正确抢答时，抢答选手的LED灯迟钝闪烁，数码管显示抢答选手的编号;犯规抢答时，犯规选手的LED灯快速闪烁，低位数码管显示犯规选手的编号,高位数码管显示F（foul，犯规）。
       (4）开始抢答按键按下时、倒计时结束时和抢答键按下时蜂鸣器响1声,犯规时响2声。
三、仿真演示

未运行仿真时，数码管不显示。

运行仿真后，进入准备界面，数码管显示00。

按下启动按键，蜂鸣器响一声，进入抢答界面，开始10秒抢答倒计时。

在抢答倒计时范围内，按下序号为1~5的选手抢答按键，蜂鸣器响1声，数码管上显示抢答选手序号，而且相应序号的指示灯迟钝闪烁4次。

当裁判未按下开始键时，若有选手抢答视为犯规抢答，蜂鸣器响2声指示犯规抢答犯规选手的LED灯快速闪烁20次，低位数码管显示犯规选手的编号,高位数码管显示F。

无论是正常抢答还是犯规抢答，指示灯停止闪烁后，数码管显示00，表示一次抢答结束。

按下复位按钮规复到准备界面，以便进行下一次抢答。

四、源步调（部分）

1. #include "reg52.h"
2. #include "delay.h"
3. #include "smg.h"
4. #include "timer.h"
6. sbit key1Led = P3^1;        //四位选手
7. sbit key2Led = P3^2;
8. sbit key3Led = P3^3;
9. sbit key4Led = P3^4;
10. sbit key5Led = P3^5;
11. sbit start_stop = P3^6;        //抢答按钮
12. sbit Beep = P3^7;        //抢答按钮
13. _bool action = 0;
14. _bool key1_flag = 0;
15. _bool key2_flag = 0;
16. _bool key3_flag = 0;
17. _bool key4_flag = 0;
18. _bool key5_flag = 0;
20. _bool Rush_flag = 0;
22. _bool reset_flag = 0; //复位标志位
23. _bool start_stop_flag = 0; //抢答标志位
24. _bool BeepF=0;       
26. uint8 second = 0;        //时间
27. uint8 timer0_count = 0;        //定时器1计数值
28. uint8 LedFre0Count = 0;
29. uint8 LedFre1Count = 0;
30. uint8 number = 0; //队号
31. uint8 number_display = 0;        //队号显示
32. uint8 a = 0xff;        //按键值
33. uint8 key_scan8(void);
34. uint8 Fval = 0;
35. void start_stop_keyscan(void);
36. void keycheckdown(void);                                /* 反转法键盘扫描 */
37. /*-----------------------------------------------------------
38. 主函数
39. ------------------------------------------------------------*/
40. void LedDisplay(uint8 _number)
41. {
42.         switch(_number)
43.         {
44.                 case 1:
45.                         key1Led=~key1Led;
46.                 break;
47.                 case 2:
48.                         key2Led=~key2Led;
49.                 break;
50.                 case 3:
51.                         key3Led=~key3Led;
52.                 break;
53.                 case 4:
54.                         key4Led=~key4Led;
55.                 break;
56.                 case 5:
57.                         key5Led=~key5Led;
58.                 break;
59.         }
60. }
61. void SMG_delay(uint8 t)
62. {
63.         while(t--)
64.         {
65.           display(second);
66.         }
67. }
69. void SMG_Bdelay(uint8 t)
70. {
71.         while(t--)
72.         {
73.       P2 = 0xfe;
74.                         P0 = table[number_display];
75.                         Delay_ms(2);
76.                        
77.                         P2 = 0xfd;
78.                         P0 = table[15];
79.                         Delay_ms(2);               
80.         }
81. }
83. void keycheckdown()                                /* 反转法键盘扫描 */
84. {
85.         short temp1,temp2,temp;
86.         P1=0xf0;                                                /* 输入行值（或列值） */
87.   SMG_delay(20);
88.         temp1=P1;                                                /* 读列值（或行值） */
89.         P1=0xff;
90.   SMG_delay(20);
91.         P1=0x0f;                                                /* 输入列值（或行值） */
92.   SMG_delay(20);
93.         temp2=P1;                                                /* 读行值（或列值） */
94.         P1=0xff;
95.         temp=(temp1&0xf0)|(temp2&0xf);        /* 将两次读入数据组合 */
96.         switch(temp)                                        /* 通过读入数据组合判断按键位置 */
97.         {
98.                 case 0x77 :a=0x0a;break;//  按键+   
99.                 case 0x7b :a=0x0e; break;// 按键=       
100.                 case 0x7d :a=0;           break;// 按键0
101.                 case 0x7e :a=0x0f; break;// 按键CE
103.                 case 0xe7 :a=0x0d;break;//         按键/
104.                 case 0xeb :a=0x9;break; //  按键9
105.                 case 0xed :a=0x8;break; //  按键8
106.                 case 0xee :a=0x7;break; //         按键7
108.                 case 0xd7 :a=0x0c;break;//  按键*
109.                 case 0xdb :a=0x6;break; //         按键6
110.                 case 0xdd :a=0x5;Beep=0;SMG_delay(500);Beep=1;break; //         按键5
111.                 case 0xde :a=0x4;Beep=0;SMG_delay(500);Beep=1;break; //         按键4
113.                 case 0xb7 :a=0x0b; break;// 按键-
114.                 case 0xbb :a=3;Beep=0;SMG_delay(500);Beep=1;break;        //  按键3
115.                 case 0xbd :a=2;Beep=0;SMG_delay(500);Beep=1;break;        //  按键2
116.                 case 0xbe :a=1;Beep=0;SMG_delay(500);Beep=1;break;        //  按键1
118.                 default :a=0xff;
119.         }
120. }
122. void main()
123. {
124.         ConfigTimer0();//定时器初始化
125.         while(1)
126.         {
127.                 start_stop_keyscan();//开始按键
128.                 keycheckdown();//键盘扫描       
129.                 Fval=key_scan8();
130.                 if(action)//有队抢答
131.                 {
132.                    second=10;
133.                 }
134.                 else
135.                 {
136.                         if(a!=0xff)
137.                         {
138.                            Rush_flag=1;//违规抢答
139.                                  second=8;
140.                                  TR0=1;
141.                         }               
142.                 }
143.     while(Rush_flag==1)
144.                 {
145.                         if(BeepF==0)
146.                         {
147.                                 Beep=0;
148.                                 SMG_Bdelay(200);
149.                                 Beep=1;       
150.                                 SMG_Bdelay(200);
151.                                 Beep=0;
152.                                 SMG_Bdelay(200);
153.                                 Beep=1;       
154.         BeepF=1;                               
155.                         }
156.                         P2 = 0xfe;
157.                         P0 = table[number_display];
158.                         Delay_ms(2);
159.                        
160.                         P2 = 0xfd;
161.                         P0 = table[15];
162.                         Delay_ms(2);               
163.                         if(second==0)
164.                         {
165.                                 Rush_flag=0;
166.                                 TR0=0;
167.                                 key1Led = 1;       
168.                                 key2Led = 1;
169.                                 key3Led = 1;
170.                                 key4Led = 1;
171.                                 key5Led = 1;       
172.         BeepF=0;                                       
173.                                 break;
174.                         }
175.                 }
176.                 while(action==1)//按下开始键为1，抢答结束为0
177.                 {
178.                         while(!key_scan8())        //无队抢答
179.                         {
180.                                 display(second);
181.                                 TR0 = 1;
182.                                 if(second == 0)
183.                                 {
184.                                         Beep=0;
185.                             SMG_delay(200);
186.                             Beep=1;
187.                                         break;
188.                                 }
189.                                 keycheckdown();//键盘扫描       
190.                         }
191.                         if(number_display)//有队抢答
192.                         {
193.                                 second=8;
194.                         }
195.                         while(number_display)
196.                         {
197.                                 display(number_display);
198.                                 if(second == 0)
199.                                 {
200.                                         key1Led = 1;       
201.                                         key2Led = 1;
202.                                         key3Led = 1;
203.                                         key4Led = 1;
204.                                         key5Led = 1;                                       
205.                                         break;                       
206.                                 }
207.                         }
208.                         TR0 = 0;//时间到
209.                         second=0;
210.                         display(second);
211.                         action = 0;//抢答结束
212.                         break;
213.                 }
214.                 display(second);       
215.         }
216. }
218. /*-----------------------------------------------------------
219. 中断服务函数
220. ------------------------------------------------------------*/
221. void timer0() interrupt 1
222. {
223.         TH0 = (65536-50000)/256; //50ms
224.         TL0 = (65536-50000)%256;       
225.         timer0_count ++;
226.         if(timer0_count == 20)//1s
227.         {
228.                 timer0_count = 0;
229.                 second--;        //10s倒计时
230.                 if(second == 0)//计时结束
231.                 {
232.                         TR0 = 0;
233.                         number_display = 0;
234.                         action = 0;
235.                         second = 0;
236.                 }
237.         }       
238.         if(number_display!=0)
239.         {
240.                 if(Rush_flag==0)
241.                 {  
242.                          LedFre0Count++;
243.                          if(LedFre0Count==20)
244.                          {
245.                                  LedFre0Count=0;
246.                            LedDisplay(number_display);
247.                          }
248.                 }
249.                 else
250.                 {
251.                          LedFre1Count++;
252.                          if(LedFre1Count==5)
253.                          {
254.                                  LedFre1Count=0;
255.                            LedDisplay(number_display);
256.                          }       
257.                 }
258.         }
259. }
261. /*-----------------------------------------------------------
262. 开始键扫描函数
263. ------------------------------------------------------------*/
264. void start_stop_keyscan(void)
265. {
266.         if(start_stop == 0)
267.         {
268.                 SMG_delay(800);
269.                 if((start_stop == 0)&&(!start_stop_flag))
270.                 {
271.                         start_stop_flag = 1;
272.                         action = 1;
273.                         TR0 = 1;
274.                         Beep=0;
275.                         SMG_delay(200);
276.                         Beep=1;
277.                         reset_flag = 0;
278.                 }
279.         }
280.         else
281.         {
282.                 start_stop_flag = 0;       
283.         }
284. }
286. /*-----------------------------------------------------------
287. 四位抢答键扫描函数
288. ------------------------------------------------------------*/
289. uint8 key_scan8(void)
290. {
291.         if((a == 1)&&(!key1_flag))
292.         {
293.                 key1_flag = 1;
294.                 number  = 1;
295.                 number_display = number;
296.         }
297.         else
298.         {
299.                 key1_flag = 0;
300.                 number  = 0;       
301.         }
302.        
303.         if((a == 2)&&(!key2_flag))
304.         {
305.                 key2_flag = 1;
306.                 number  = 2;
307.                 number_display = number;
308.         }
309.         else
310.         {
311.                 key2_flag = 0;
312.                 number  = 0;       
313.         }
314.        
315.         if((a == 3)&&(!key3_flag))
316.         {
317.                 key3_flag = 1;
318.                 number  = 3;
319.                 number_display = number;
320.         }
321.         else
322.         {
323.                 key3_flag = 0;
324.                 number  = 0;       
325.         }
326.        
327.         if((a == 4)&&(!key4_flag))
328.         {
329.                 key4_flag = 1;
330.                 number  = 4;
331.                 number_display = number;
332.         }
333.         else
334.         {
335.                 key4_flag = 0;
336.                 number  = 0;       
337.         }
338.         if((a == 5)&&(!key5_flag))
339.         {
340.                 key5_flag = 1;
341.                 number  = 5;
342.                 number_display = number;
343.         }
344.         else
345.         {
346.                 key5_flag = 0;
347.                 number  = 0;       
348.         }                       
349.        
350.         if(number_display != 0)       
351.         {
352.                 return 1;
353.         }
354.         else
355.         {
356.                 return 0;
357.         }       
358. }

复制代码

仿真源文件及源步调百度网盘链接：https://pan.baidu.com/s/12J02HAeeTJgKW468viFx1g 
提取码：kc9n 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。