基于51单片机的六路抢答器Protues仿真筹划

目次
一、筹划配景
二、实现功能
三、仿真演示
四、源步伐（部门）

---

一、筹划配景

        比年来随着科技的飞速发展，单片机的应用正在不停的走向深入。本文论述了基于51单片机的六路抢答器筹划。本筹划中，51单片机充当了焦点控制器的脚色，通过IO口与各个功能模块相毗连。按键模块负责检测到场者的抢答动作，当有人按下抢答按钮时，会通过IO口电平的变革关照单片机，单片机遇记载按键的序次，并通过数码管表现当前的抢答效果。
        为了包管抢答过程的正确性和公平性，筹划中还须要思量到以下因素。起首，按键模块须要具备快速相应和高可靠性，以确保抢答者的动作可以或许被正确地捕获到。其次，表现屏模块须要可以或许及时更新抢答效果，并表现相应的信息，比如到场者的编号和抢答时间。末了，在电路毗连方面，须要注意各个模块之间的线路结构，以克制信号干扰和电气标题。
       软件体系采取C语言编写步伐，包罗表现步伐，定时制止服务，延时步伐等，并在KEIL5中调试运行，硬件体系利用PROTEUS8.13强盛的功能来实现，简朴切易于观察，在仿真中就可以观察到实际的工作状态。
二、实现功能

        以51单片机为控制焦点，筹划一种六路抢答器。整个体系包罗MCU、晶振电路、时钟电路、蜂鸣器控制电路、指示灯控制电路、译码电路、独立按键电路、矩阵键盘以及数码管表现电路等。可具体实现以下功能：
     （1）设定矩阵键盘的6个键作为6位选手的抢答按键,键的编号即选手编号，为1~6号;设定1个独立按键作为抢答开始键;选择四位数码管作为倒计时、选手编号表现;选择蜂鸣器作为正常抢答和犯规抢答的提示。
     （2）只有当裁判按下开始键时才可以进入正常抢答，否则属于犯规抢答。抢答完毕，或计时时间到，制止抢答。当裁判按下抢答开始键时，开始抢答，计时器开始倒计时，10秒倒计期间，如有抢答，则制止计时，数码管表现选手号;若倒计时竣事时无人抢答，则制止抢答。
     （3）正常抢答时，有效抢答指示灯亮起，蜂鸣器播放音乐1，低位数码管数码管表现抢答选手的编号，高位数码管开始60s倒计时，60s时间到，数码管表现0-00。违规抢答时，无效抢答指示灯亮起，蜂鸣器播放音乐2，低位数码管表现违规抢答选手编号，高位数码管表现抢答倒计时时间10s。
三、仿真演示

未运行仿真时，数码管不表现。

运行仿真后，进入预备界面，数码管表现0-10。

按下启动按键，进入抢答界面，开始10秒抢答倒计时。

在抢答倒计时范围内，按下序号为1~6的选手抢答按键，抢答有效指示灯亮起，蜂鸣器播放《两只老虎》的旋律，低位数码管上表现抢答选手序号，高位数码管开始60s倒计时。

当裁判未按下开始键时，如有选手抢答视为犯规抢答，抢答无效指示灯亮起，蜂鸣器播放《粉刷匠》的旋律，低位数码管表现犯规选手的编号,高位数码管表现10。

正常抢答还是犯规抢答竣事后，按下复位按钮规复到预备界面，以便举行下一次抢答。

四、源步伐（部门）

1. #include "reg52.h"
2. #include "delay.h"
3. #include "smg.h"
4. #include "timer.h"
6. sbit Beep = P1^5;        //六位选手
7. sbit key1 = P1^1;       
8. sbit key2 = P1^2;
9. sbit key3 = P1^3;
10. sbit key4 = P1^4;
11. sbit key5 = P1^5;       
12. sbit key6 = P1^6;
13. sbit EffectLED = P2^6;  //抢答有效指示灯
14. sbit UeffectLED = P2^7; //抢答无效指示灯
15. sbit start_stop = P3^1;        //抢答按钮
17. sbit L1 = P1^7;
18. sbit L2 = P1^6;
20. sbit R1 = P1^3;
21. sbit R2 = P1^2;
22. sbit R3 = P1^1;
23. sbit R4 = P1^0;
25. //**《两只老虎》
26. uint8 code  x0[]={1+7,2+7,3+7,1+7,1+7,2+7,3+7,1+7,3+7,4+7,5+7,3+7,4+7,5+7,5+7,6+7,5+7,4+7,3+7,1+7,5+7,6+7,5+7,4+7,3+7,1+7,1+7,5,1+7,1+7,5,1+7};
27. uint8 code  y0[]={4,4,4,4,4,4,4,4,4,4,8,4,4,8,3,1,3,1,4,4,3,1,3,1,4,4,4,4,8,4,4,8};
28. //**《粉刷匠》
29. uint8 code  x1[]={5+7,3+7,5+7,3+7,5+7,3+7,1+7,2+7,4+7,3+7,2+7,5+7,5+7,3+7,5+7,3+7,5+7,3+7,1+7,2+7,4+7,3+7,2+7,1+7,2+7,
30.                                         2+7,4+7,4+7,3+7,1+7,5+7,2+7,4+7,3+7,2+7,5+7,5+7,3+7,5+7,3+7,5+7,3+7,1+7,2+7,4+7,3+7,2+7,1+7};
31. uint8 code  y1[]={4,4,4,4,4,4,8,4,4,4,4,16,4,4,4,4,4,4,8,4,4,4,4,16,4,4,4,4,4,4,8,4,4,4,4,16,4,4,4,4,4,4,8,4,4,4,4,16};
33.         //以下定义低中高共21个音阶的定时参数,通过定时器来实现不同音频的输出
34. uint8 code ti[21][2]={
35.         {0xf8,0x8c},{0xf9,0x5c},{0xfa,0x14},{0xfa,0x67},{0xfb,0x04},{0xfb,0x90},{0xfc,0x0c},  //低音
36.         {0xfc,0x44},{0xfc,0xb6},{0xfd,0x09},{0xfd,0x34},{0xfd,0x82},{0xfd,0xc8},{0xfe,0x06},  //中音
37.         {0xfe,0x22},{0xfe,0x56},{0xfe,0x8c},{0xfe,0x9a},{0xfe,0xc1},{0xfe,0xe4},{0xff,0x03}}; //高音
39. uint8 th,tl,i;
40. _bool action = 0;
41. _bool key1_flag = 0;
42. _bool key2_flag = 0;
43. _bool key3_flag = 0;
44. _bool key4_flag = 0;
45. _bool key5_flag = 0;
46. _bool key6_flag = 0;
47. _bool start_stop_flag = 0; //抢答标志位
48. _bool cntflag=0;
49. uint8 second = 10;        //时间
50. uint8 timer0_count = 0;        //定时器1计数值
51. uint8 number = 0; //队号
52. uint8 number_display = 0;        //队号显示
53. uint8 a = 0xff;        //按键值
54.        
55. uint8 key_scan8(void);
56. void start_stop_keyscan(void);
57. void music1(void);//演奏《两只老虎》
58. void music2(void);//演奏《粉刷匠》
59. void keycheckdown(void);                                /* 反转法键盘扫描 */
60. /*-----------------------------------------------------------
61. 主函数
62. ------------------------------------------------------------*/
63. void SMG_delay(uint8 t)
64. {
65.         while(t--)
66.         {
67.            display(number_display,second);       
68.         }
69. }
71. void main()
72. {
73.         ConfigTimer();//定时器初始化
74.         while(1)
75.         {
76.                 start_stop_keyscan();//开始按键
77.                 keycheckdown();
78.     if(key_scan8()&&action==0&&cntflag==0)
79.                 {      
80.                         UeffectLED=0;       
81.                         EffectLED=1;
82.                         music2();
83.                         cntflag=1;
84.                 }
85.                 while(action)//按下开始键为1，抢答结束为0
86.                 {
87.                         keycheckdown();
88.                         if(cntflag==1)
89.                         {
90.                           number_display=0;
91.                                 cntflag=0;
92.                         }
93.                         while(!key_scan8())        //无队抢答
94.                         {
95.                                 keycheckdown();
96.                                 display(number_display,second);
97.                                 if(second == 0)
98.                                 {
99.                                         break;
100.                                 }
101.                         }
102.                         if(number_display)//有队抢答
103.                         {
104.                                 EffectLED=0;
105.         UeffectLED=1;       
106.                                 second=60;
107.         music1();
108.                         }
109.                         while(number_display)
110.                         {
111.                                 display(number_display,second);
112.                                 TR0 = 1;
113.                                 if(second == 0)
114.                                 {
115.                                         break;
116.                                 }
117.                         }
118.                         TR0 = 0;//时间到
119.                         display(number_display,second);
120.                         action = 0;//抢答结束
121.                         break;
122.                 }
123.                 display(number_display,second);       
124.         }
125. }
127. void music1(void)//演奏《两只老虎》
128. {
129.         for(i=0;i<14;i++)
130.         {
131.                 th=ti[x0[i]-1][0];
132.                 tl=ti[x0[i]-1][1];
133.                 TH1=th;
134.                 TL1=tl;
135.                 TR1=1;
136.     SMG_delay(y0[i]*10);
137.                 TR1=0;
138.         }
139. }
141. void music2(void)//演奏《粉刷匠》
142. {
143.         for(i=0;i<12;i++)
144.         {
145.                 th=ti[x1[i]-1][0];
146.                 tl=ti[x1[i]-1][1];
147.                 TH1=th;
148.                 TL1=tl;
149.                 TR1=1;
150.                 SMG_delay(y1[i]*9);
151.                 TR1=0;
152.         }
153. }
154. /*-----------------------------------------------------------
155. 中断服务函数
156. ------------------------------------------------------------*/
157. void timer0() interrupt 1
158. {
159.         TH0 = (65536-50000)/256; //50ms
160.         TL0 = (65536-50000)%256;       
161.         timer0_count ++;
162.         if(timer0_count == 20)//1s
163.         {
164.                 timer0_count = 0;
165.                 second--;        //10s倒计时
166.                 if(second == 0)//计时结束
167.                 {
168.                         TR0 = 0;
169.                         number_display = 0;
170.                         action = 0;
171.                 }
172.         }       
173. }
175. /*-----------------------------------------------------------
176. 开始键扫描函数
177. ------------------------------------------------------------*/
178. void start_stop_keyscan(void)
179. {
180.         if(start_stop == 0)
181.         {
182.                 SMG_delay(8);
183.                 if((start_stop == 0)&&(!start_stop_flag))
184.                 {
185.                         start_stop_flag = 1;
186.                         action = 1;
187.                         TR0 = 1;
188.                 }
189.                 while(start_stop == 0){display(number_display,second);}               
190.                
191.         }
192.         else
193.         {
194.                 start_stop_flag = 0;       
195.         }
196. }
198. void keycheckdown()               
199. {
200.         L1=0;L2=1;
201.         R1=R2=R3=R4=1;
202.         if(R1==0)
203.         {
204.                 while(R1==0)
205.                 {
206.       display(number_display,second);               
207.                 }
208.     a=1;
209.         }
210.         else if(R2==0)
211.         {
212.                 while(R2==0)
213.                 {
214.                    display(number_display,second);               
215.                 }
216.     a=2;
217.         }       
218.         else if(R3==0)
219.         {
220.                 while(R3==0)
221.                 {
222.        display(number_display,second);               
223.                 }
224.                 a=3;
225.         }
226.         else if(R4==0)
227.         {
228.                 while(R4==0)
229.                 {
230.        display(number_display,second);               
231.                 }
232.     a=0x4;
233.         }
234.        
235.         L2=0;L1=1;
236.         R1=R2=R3=R4=1;
237.         if(R1==0)
238.         {
239.                 while(R1==0)
240.                 {
241.        display(number_display,second);               
242.                 }
243.     a=0x5;
244.         }
245.         else if(R2==0)
246.         {
247.                 while(R2==0)
248.                 {
249.        display(number_display,second);                       
250.                 }
251.     a=0x6;
252.         }       
253.         else if(R3==0)
254.         {
255.                 while(R3==0)
256.                 {
257.        display(number_display,second);                       
258.                 }
259.                 a=0x7;
260.         }
261.         else if(R4==0)
262.         {
263.                 while(R4==0)
264.                 {
265.        display(number_display,second);               
266.                 }
267.     a=0x8;
268.         }
269. }
271. /*-----------------------------------------------------------
272. 六位抢答键扫描函数
273. ------------------------------------------------------------*/
274. uint8 key_scan8(void)
275. {
276.         if((a == 1)&&(!key1_flag))
277.         {
278.                 key1_flag = 1;
279.                 number  = 1;
280.                 number_display = number;
281.         }
282.         else
283.         {
284.                 key1_flag = 0;
285.                 number  = 0;       
286.         }
287.         if((a == 2)&&(!key2_flag))
288.         {
289.                 key2_flag = 1;
290.                 number  = 2;
291.                 number_display = number;
292.         }
293.         else
294.         {
295.                 key2_flag = 0;
296.                 number  = 0;       
297.         }
298.         if((a == 3)&&(!key3_flag))
299.         {
300.                 key3_flag = 1;
301.                 number  = 3;
302.                 number_display = number;
303.         }
304.         else
305.         {
306.                 key3_flag = 0;
307.                 number  = 0;       
308.         }
309.        
310.         if((a == 0x4)&&(!key4_flag))
311.         {
312.                 key4_flag = 1;
313.                 number  = 4;
314.                 number_display = number;
315.         }
316.         else
317.         {
318.                 key4_flag = 0;
319.                 number  = 0;       
320.         }
321.        
322.         if((a == 0x5)&&(!key5_flag))
323.         {
324.                 key5_flag = 1;
325.                 number  = 5;
326.                 number_display = number;
327.         }
328.         else
329.         {
330.                 key5_flag = 0;
331.                 number  = 0;       
332.         }               
333.         if((a == 0x6)&&(!key6_flag))
334.         {
335.                 key6_flag = 1;
336.                 number  = 6;
337.                 number_display = number;
338.         }
339.         else
340.         {
341.                 key6_flag = 0;
342.                 number  = 0;       
343.         }       
344.        
345.         if(number_display != 0)       
346.         {
347.                 return 1;
348.         }
349.         else
350.         {
351.                 return 0;
352.         }       
353. }
355. void Timer1Service() interrupt 3 /* T0中断服务程序 */
356. {
357.          Beep=~Beep;
358.          TH1=th;
359.          TL1=tl;
360. }

复制代码

仿真源文件及源步伐百度网盘链接：https://pan.baidu.com/s/1baNdNosxDLxHD96VyCc8uw 
提取码：it38