标题: 51单片机8人抢答器仿真程序 易学简单 [打印本页]

---

作者: 2565971314    时间: 2020-10-8 10:03
标题: 51单片机8人抢答器仿真程序 易学简单

一、设计内容简介
8位抢答器由主体电路与扩展电路组成。通过8位按键产生相应电平变换通过单片机使得数码管及LED灯显示相应信息。经过布线、调试等工作后8位抢答器成形。单片机体积小价格低，应用方便，稳定可靠。单片机将很多任务交给了软件编程去实现，大大简化了外围硬件电路，使外围电路的实现简单方便。单片机系统的硬件结构给予了抢答系统“身躯”，而单片机的应用程序赋予了其新的“生命”，使其在传统的抢答器面前具有电路简单、成本低、运行可靠等特色。对于抢答器我们大家都知道那是用于选手做抢答题时用的，选手进行抢答，抢到题的选手来回答问题。抢答器不仅考验选手的反应速度同时也要求选手具备足够的知识面和一定的勇气。 选手们都站在同一个起跑线上，体现了公平公正的原则。一、设计内容简介
8位抢答器由主体电路与扩展电路组成。通过8位按键产生相应电平变换通过单片机使得数码管及LED灯显示相应信息。经过布线、调试等工作后8位抢答器成形。单片机体积小价格低，应用方便，稳定可靠。单片机将很多任务交给了软件编程去实现，大大简化了外围硬件电路，使外围电路的实现简单方便。单片机系统的硬件结构给予了抢答系统“身躯”，而单片机的应用程序赋予了其新的“生命”，使其在传统的抢答器面前具有电路简单、成本低、运行可靠等特色。对于抢答器我们大家都知道那是用于选手做抢答题时用的，选手进行抢答，抢到题的选手来回答问题。抢答器不仅考验选手的反应速度同时也要求选手具备足够的知识面和一定的勇气。 选手们都站在同一个起跑线上，体现了公平公正的原则。三、设计所涉及的原理
以AT89C51单片机为核心，起着控制作用。系统包括数码管显示电路、LED显示电路、按键输入电路。设计思路分为晶振电路模块、AT89C51、 数码管显示电路、LED显示电路、按键输入电路这五个模块。
1.单片机最小系统
1.1电源电路
　　电源电路就是单片机的供电电路，一般是3.3V或者5V，具体多少要参考各种型号的单片机的工作电压，通常情况下是5V，这里是指通常情况下。
　　1.2时钟电路
　　时钟电路就是晶振电路，一般选择12MHz的晶振，方便使用定时器、计数器的功能。AT89C51中有高增益的反相放大器，它是是构成内部振荡器的主要单元，XTAL2和引脚XTAL1分别是该放大器的输出端和输入端。
　　片外石英晶体或陶瓷谐振器和放大器共同构成自激振荡器，旁路电容Cl、C2与外接石英晶体（或陶瓷谐振器）接在具有反馈功能的放大器中，构成了并联反馈振荡电路。
对外接旁路电容Cl、C2即使没非常严厉的要求，但是电容容量的大小也会轻微影响振荡器频率的稳定性、振荡频率的幅值、起振的难易程序程度和温度稳定性等等。加入使用石英晶体，通常电容选，而如果使用陶瓷谐振器，通常选择电容
1.3复位电路
　　无论是在单片机刚开始接上电源时，还是运行过程中发生故障都需要复位。复位电路用于将单片机内部各电路的状态恢复到一个确定的初始值，并从这个状态开始工作。单片机的复位条件：必须使其RST引脚上持续出现两个（或以上）机器周期的高电平。单片机的复位形式：上电复位、按键复位。
　　上电复位电路中，利用电容充电来实现复位。在电源接通瞬间，RET引脚上的电位是高电平（Vcc），电源接通后对电容进行快速充电，随着充电的进行，RST引脚上的电位也会逐渐下降为低电平。只要保证RST引脚上高电平出现的时间大于两个机器周期，便可以实现正常复位。
按键复位电路中，当按键没有按下时，电路同上电复位电路。如在单片机运行过程中，按下RESET键，已经充好电的电容会快速通过200Ω电阻的回路放电，从而使得RST引脚上的电位快速变为高电平，此高电平会维持到按键释放，从而满足单片机复位的条件实现按键复位。
2.LED灯及数码管显示
2.1 LED灯显示
由于单片机额P0口作为一般的I/O口时用时，由于内部没有上拉电阻，故要接上上拉电阻。P0口接上拉电阻LED灯连接单片机P0口，通过单片机输出的数据来改变LED亮灯顺序。
2.2数码管显示
数码管的一种是半导体发光器件，数码管可分为七段数码管和八段数码管，区别在于八段数码管比七段数码管多一个用于显示小数点的发光二极管单元DP，其基本单元是发光二极管。本实验采用74LS245驱动7段数码管。
74LS245是我们常用的芯片，用来驱动led或者其他的设备,它是8路同相三态双向总线收发器，可双向传输数据。74LS245还具有双向三态功能，既可以输出，也可以输入数据

单片机源程序如下:

1. #include<reg51.h>
   
2. #define uchar unsigned char
   
3. #define uint unsigned int
   
4. uchar code1[9]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f};
   
5. sbit key1=P3^0;
   
6. sbit key2=P3^1;
   
7. sbit key3=P3^2;
   
8. sbit key4=P3^3;
   
9. sbit key5=P3^4;
   
10. sbit key6=P3^5;
    
11. sbit key7=P3^6;
    
12. sbit key8=P3^7;
    
13. sbit keep=P2^0;
    
14. sbit key9=P2^2;
    
15. void delay(uint t) //延时程序
    
16. {
    
17. uint j;
    
18. for(;t>0;t--)
    
19. for(j=121;j>0;j--);
    
20. }
    
21. void display(uchar i)//数码管显示
    
22. {
    
23. switch(i)
    
24. {
    
25.   case 0:P1=code1[0];break;
    
26.   case 1:P1=code1[1];break;
    
27.   case 2:P1=code1[2];break;
    
28.   case 3:P1=code1[3];break;
    
29.   case 4:P1=code1[4];break;
    
30.   case 5:P1=code1[5];break;
    
31.   case 6:P1=code1[6];break;
    
32.   case 7:P1=code1[7];break;
    
33.   case 8:P1=code1[8];break;
    
34.   default:break;
    
35. }
    
36. 
    
37. }
    
38. 
    
39. void key() //键盘扫描，判断哪个人抢答
    
40. {
    
41. uchar n;
    
42.   n=0;        
    
43.   display(n);
    
44.     keep=1;
    
45.          if(key1==0)
    
46.          {
    
47.           delay(5);
    
48.           if(key1==0)
    
49.                   {
    
50.                     n=1;
    
51.                     display(n);
    
52.                         P0=0xfe;
    
53.                         while(1)
    
54.                         {
    
55.                         keep=0;                         //开启蜂鸣器
    
56.                         delay(500);
    
57.                         keep=1;
    
58.                         delay(500);
    
59.                          if(key9==0)
    
60.                         {
    
61.                          delay(5);
    
62.                          if(key9==0)
    
63.                          {
    
64.                             keep=1;
    
65.                             n=0;        
    
66.                 display(n);
    
67.                                 P0=0xff;
    
68.                           while(1)return;
    
69.                          }
    
70.                          while(!key9);
    
71.                      delay(5);
    
72.                          while(1);   
    
73.                         }
    
74.                         }
    
75.                   }                  
    
76.                   while(!key1);
    
77.                   delay(5);
    
78.                  
    
79.          }
    
80.          if(key2==0)
    
81.          {
    
82.                   delay(5);
    
83.                   if(key2==0)
    
84.                   {
    
85.                            n=2;
    
86.                            display(n);
    
87.                                    P0=0xfd;
    
88.                            while(1)
    
89.                            {
    
90.                            keep=0;                         //开启蜂鸣器
    
91.                            delay(500);
    
92.                            keep=1;
    
93.                            delay(500);
    
94.                             if(key9==0)
    
95.                                 {
    
96.                                  delay(5);
    
97.                                  if(key9==0)
    
98.                                  {
    
99.                                     keep=1;
    
100.                                     n=0;        
     
101.                         display(n);
     
102.                                         P0=0xff;
     
103.                                    while(1)return;
     
104.                                  }
     
105.                                          while(!key9);
     
106.                                      delay(5);
     
107.                                          while(1);   
     
108.                                         }
     
109.                                 }
     
110.                           }         
     
111.                           while(!key2);
     
112.                           delay(5);
     
113.          }         
     
114.          if(key3==0)
     
115.          {
     
116.                   delay(5);
     
117.                   if(key3==0)
     
118.                   {
     
119.                            n=3;
     
120.                            display(n);
     
121.                                    P0=0xfb;
     
122.                             while(1)
     
123.                         {
     
124.                         keep=0;                         //开启蜂鸣器
     
125.                         delay(500);
     
126.                         keep=1;
     
127.                         delay(500);
     
128.                          if(key9==0)
     
129.                         {
     
130.                          delay(5);
     
131.                          if(key9==0)
     
132.                          {
     
133.                             keep=1;
     
134.                             n=0;        
     
135.                 display(n);
     
136.                                 P0=0xff;
     
137.                           while(1)return;
     
138.                          }
     
139.                          while(!key9);
     
140.                      delay(5);
     
141.                          while(1);   
     
142.                         }
     
143.                         }
     
144.                   }                                       
     
145.                   while(!key3);
     
146.                   delay(5);         
     
147.          }
     
148.          if(key4==0)
     
149.          {
     
150.                   delay(5);
     
151.                   if(key4==0)
     
152.                   {
     
153.                            n=4;
     
154.                            display(n);
     
155.                                    P0=0xf7;
     
156.                            while(1)
     
157.                         {
     
158.                         keep=0;                         //开启蜂鸣器
     
159.                         delay(500);
     
160.                         keep=1;
     
161.                         delay(500);
     
162.                          if(key9==0)
     
163.                         {
     
164.                          delay(5);
     
165.                          if(key9==0)
     
166.                          {
     
167.                             keep=1;
     
168.                             n=0;        
     
169.                 display(n);
     
170.                                 P0=0xff;
     
171.                           while(1)return;
     
172.                          }
     
173.                          while(!key9);
     
174.                      delay(5);
     
175.                          while(1);   
     
176.                         }
     
177.                         }
     
178.                   }                                       
     
179.                   while(!key4);
     
180.                   delay(5);         
     
181.          }               
     
182.          if(key5==0)
     
183.          {
     
184.                   delay(5);
     
185.                   if(key5==0)
     
186.                   {
     
187.                            n=5;
     
188.                            display(n);
     
189.                                    P0=0xef;
     
190.                            while(1)
     
191.                         {
     
192.                         keep=0;                         //开启蜂鸣器
     
193.                         delay(500);
     
194.                         keep=1;
     
195.                         delay(500);
     
196.                          if(key9==0)
     
197.                         {
     
198.                          delay(5);
     
199.                          if(key9==0)
     
200.                          {
     
201.                             keep=1;
     
202.                             n=0;        
     
203.                 display(n);
     
204.                                 P0=0xff;
     
205.                           while(1)return;
     
206.                          }
     
207.                          while(!key9);
     
208.                      delay(5);
     
209.                          while(1);   
     
210.                         }
     
211.                         }
     
212.                   }                                       
     
213.                   while(!key5);
     
214.                   delay(5);         
     
215.          }
     
216.          if(key6==0)
     
217.          {
     
218.                   delay(5);
     
219.                   if(key6==0)
     
220.                   {
     
221.                            n=6;
     
222.                            display(n);
     
223.                            P0=0xdf;
     
224.                            while(1)
     
225.                         {
     
226.                         keep=0;                         //开启蜂鸣器
     
227.                         delay(500);
     
228.                         keep=1;
     
229.                         delay(500);
     
230.                          if(key9==0)
     
231.                         {
     
232.                          delay(5);
     
233.                          if(key9==0)
     
234.                          {
     
235.                             keep=1;
     
236.                             n=0;        
     
237.                 display(n);
     
238.                                 P0=0xff;
     
239.                           while(1)return;
     
240.                          }
     
241.                          while(!key9);
     
242.                      delay(5);
     
243.                          while(1);   
     
244.                         }
     
245.                         }
     
246.                   }                                       
     
247.                   while(!key6);
     
248.                   delay(5);
     
249.          }        
     
250.           if(key7==0)
     
251.          {
     
252.                   delay(5);
     
253.                   if(key7==0)
     
254.                   {
     
255.                            n=7;
     
256.                            display(n);
     
257.                            P0=0xbf;
     
258.                            while(1)
     
259.                         {
     
260.                         keep=0;                         //开启蜂鸣器
     
261.                         delay(500);
     
262.                         keep=1;
     
263.                         delay(500);
     
264.                          if(key9==0)
     
265.                         {
     
266.                          delay(5);
     
267.                          if(key9==0)
     
268.                          {
     
269.                             keep=1;
     
270.                             n=0;        
     
271.                 display(n);
     
272.                                 P0=0xff;
     
273.                           while(1)return;
     
274.                          }
     
275.                          while(!key9);
     
276.                      delay(5);
     
277.                          while(1);   
     
278.                         }
     
279.                         }
     
280.                   }                                       
     
281.                   while(!key7);
     
282.                   delay(5);         
     
283.          }        
     
284.          if(key8==0)
     
285.          {
     
286.                   delay(5);
     
287.                   if(key8==0)
     
288.                   {
     
289.                            n=8;
     
290.                            display(n);
     
291.                            P0=0x7f;
     
292.                            while(1)
     
293.                         {
     
294.                         keep=0;                         //开启蜂鸣器
     
295.                         delay(500);
     
296.                         keep=1;
     
297.                         delay(500);
     
298.                          if(key9==0)
     
299.                         {
     
300.                          delay(5);
     
301.                          if(key9==0)
     
302.                          {
     
303.                             keep=1;
     
304.                             n=0;        
     
305.                 display(n);
     
306.                                 P0=0xff;
     
307.                           while(1)return;
     
308.                          }
     
309.                          while(!key9);
     
310.                      delay(5);
     
311.                          while(1);   
     
312.                         }
     
313.                         }
     
314.                   }                                       
     
315.                   while(!key8);
     
316.                   delay(5);         
     
317.          }        
     
318. }
     
319. void main()
     
320. {
     
321.    while(1)
     
322.    {
     
323.            key();
     
324.    }
     
325. }  
     

复制代码

所有资料51hei提供下载:
抢答器.rar (38.13 KB, 下载次数: 49)

2020-10-7 19:52 上传

点击文件名下载附件
下载积分: 黑币 -5

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1