代码:

1. /***************前言**************/
   
2. //设计名称：病房紧急呼叫系统的设计
   
3. //设计人：杨德富
   
4. //设计日期：2022年5月26日
   
5. /**************END****************/
   
6. #include "reg52.h"
   
7. 
   
8. sfr P4 = 0xC0;
   
9. 
   
10. //定义led端口
    
11. sbit L1 = P0^0;
    
12. sbit L2 = P0^1;
    
13. sbit L3 = P0^2;
    
14. 
    
15. //定义按键
    
16. sbit R1 = P3^0;
    
17. sbit R2 = P3^1;
    
18. sbit R3 = P3^2;
    
19. sbit R4 = P3^3;
    
20. 
    
21. sbit C1 = P4^4;
    
22. sbit C2 = P4^2;
    
23. sbit C3 = P3^5;
    
24. sbit C4 = P3^4;
    
25. 
    
26. //病房号
    
27. unsigned char num = 16;
    
28. //病房服务
    
29. unsigned char serve = 16;
    
30. 
    
31. ////定义LED灯的当前状态
    
32. //unsigned char stat_led = 0xff;
    
33. 
    
34. //LED标志
    
35. unsigned char led = 0;
    
36. //中断计数变量
    
37. unsigned char count=0;
    
38. 
    
39. //数码管段码0~f - 全灭
    
40. unsigned char code SMG_duanma[18]={
    
41. 0xc0,0xf9,0xa4,0xb0,0x99,0x92,
    
42. 0x82,0xf8,0x80,0x90,0x88,0x80,
    
43. 0xc6,0xc0,0x86,0x8e,0xbf,0x7f};
    
44. 
    
45. //数码管显示时长
    
46. #define TSMG 300
    
47. 
    
48. //按键延时
    
49. #define TAJ 50
    
50. 
    
51. //函数申明
    
52. void Display_Num();
    
53. 
    
54. //简单的延时函数
    
55. void Delay(unsigned int t)
    
56. {
    
57.         while(t--)
    
58.         {
    
59. //                Flag_Display();
    
60.         }
    
61. }
    
62. 
    
63. //573锁存器选中函数
    
64. void Init573(unsigned char n)
    
65. {
    
66.         switch(n)
    
67.         {
    
68.                 case 4:
    
69.                         P2 = (P2 & 0x1f) | 0x80;//Y4输出0，LED控制
    
70.                 break;
    
71.                 case 5:
    
72.                         P2 = (P2 & 0x1f) | 0xa0;//Y5输出0，蜂鸣器和继电器控制
    
73.                 break;
    
74.                 case 6:
    
75.                         P2 = (P2 & 0x1f) | 0xc0;//Y6输出0，数码管位选
    
76.                 break;
    
77.                 case 7:
    
78.                         P2 = (P2 & 0x1f) | 0xe0;//Y7输出0，数码管段码
    
79.                 break;
    
80.                 case 0:
    
81.                         P2 = (P2 & 0x1f) | 0x00;//所有锁存器不选择
    
82.                 break;       
    
83.                 }
    
84.         P2 = (P2 & 0x1f) | 0x00;    //所有锁存器都不选择
    
85. }
    
86. 
    
87. //数码管位选
    
88. void DisplaySMG_Bit(unsigned char pos,unsigned char value)
    
89. {
    
90.         P0 = 0x01 << pos;
    
91.         Init573(6);
    
92.         P0 = value;
    
93.         Init573(7);
    
94. }
    
95. 
    
96. //所有数码管全亮
    
97. void DisplaySMG_All(unsigned char value)
    
98. {
    
99.         P0 = 0xff;
    
100.         Init573(6);
     
101.         P0 = value;
     
102.         Init573(7);
     
103. }
     
104. 
     
105. //数码管延时函数
     
106. void DelaySMG(unsigned int t)
     
107. {
     
108.         while(t--);
     
109. }
     
110. 
     
111. //病房和服务显示
     
112. void Display_Num()
     
113. {
     
114.         //左边第一位显示病房号
     
115.         DisplaySMG_Bit(0,SMG_duanma[num]);
     
116.         DelaySMG(TSMG);
     
117.         DisplaySMG_Bit(0,0xff);
     
118.         //左边第二位"-"
     
119.         DisplaySMG_Bit(1,SMG_duanma[16]);
     
120.         DelaySMG(TSMG);
     
121.         DisplaySMG_Bit(1,0xff);
     
122.        
     
123.         //左边第三位"-"
     
124.         DisplaySMG_Bit(2,SMG_duanma[16]);
     
125.         DelaySMG(TSMG);
     
126.         DisplaySMG_Bit(2,0xff);
     
127.        
     
128.         //左边第四位显示服务serve
     
129.         DisplaySMG_Bit(3,SMG_duanma[serve]);
     
130.         DelaySMG(TSMG);
     
131.         DisplaySMG_Bit(3,0xff);
     
132.        
     
133.         DisplaySMG_All(0xff);
     
134. }
     
135. 
     
136. //初始化系统
     
137. void Init_sys()
     
138. {
     
139.         Init573(0);//关闭所有所有锁存器
     
140.         DisplaySMG_All(0xff);//关闭所有数码管
     
141.         P0 = 0x00;
     
142.         Init573(5);//关闭蜂鸣器和继电器
     
143.         P0 = 0xff;
     
144.         Init573(4);//关闭全部LED灯
     
145. }
     
146. 
     
147. //T0计数器初始化
     
148. void InitTimer0()
     
149. {
     
150.         TMOD=0x01;//选择模式
     
151.         TH0=(65535-50000)/256;
     
152.         TL0=(65535-50000)%256;
     
153.        
     
154.         ET0=1;
     
155.         EA=1;
     
156.         TR0=1;
     
157. }
     
158. //T0服务函数
     
159. void ServiceTimer0() interrupt 1
     
160. {
     
161.         TH0=(65535-50000)/256;
     
162.         TL0=(65535-50000)%256;
     
163.         count++;
     
164.         if(count==100)//5秒
     
165.         {
     
166.                 P0=0x00;
     
167.                 Init573(5);//关闭蜂鸣器
     
168.                 count=0;
     
169.         }
     
170. }
     
171. 
     
172. //按键扫描以及处理函数
     
173. void ScanKeys()
     
174. {
     
175.         //检测第一行按键
     
176.         R1=0;
     
177.         R2=R3=R4=1;
     
178.         C1=C2=C3=C4=1;
     
179.         if (C1==0)//S7按键:A1
     
180.         {
     
181.                 Delay(TAJ);
     
182.                 if(C1==0)
     
183.                 {       
     
184.                         P0=0x40;
     
185.                         Init573(5);
     
186.                         InitTimer0();
     
187.                         num=led=1;
     
188.                         serve=10;
     
189.                         while(C1==0);
     
190.                         {
     
191.                                 Display_Num();
     
192.                         }
     
193.                 }
     
194.         }
     
195.         else if(C2==0)//S11按键:B1
     
196.         {
     
197.                 Delay(TAJ);
     
198.                 if(C2==0)
     
199.                 {       
     
200.                         P0=0x40;
     
201.                         Init573(5);
     
202.                         InitTimer0();
     
203.                         num=led=1;
     
204.                         serve=11;
     
205.                         while(C2==0);
     
206.                         {
     
207.                                 Display_Num();
     
208.                         }
     
209.                 }
     
210.         }
     
211.         else if(C3==0)//S15按键:C1
     
212.         {
     
213.         Delay(TAJ);
     
214.                 if(C3==0)
     
215.                 {       
     
216.                         P0=0x40;
     
217.                         Init573(5);
     
218.                         InitTimer0();
     
219.                         num=led=1;
     
220.                         serve=12;
     
221.                         while(C3==0);
     
222.                         {
     
223.                                 Display_Num();
     
224.                         }
     
225.                 }
     
226.         }
     
227.         else if(C4==0)//S19按键:D1
     
228.         {
     
229.         Delay(TAJ);
     
230.                 if(C4==0)
     
231.                 {       
     
232.                         P0=0x40;
     
233.                         Init573(5);
     
234.                         InitTimer0();
     
235.                         num=led=1;
     
236.                         serve=13;
     
237.                         while(C4==0);
     
238.                         {
     
239.                                 Display_Num();
     
240.                         }
     
241.                 }
     
242.         }
     
243.         //检测第二行按键
     
244.         R2=0;
     
245.         R1=R3=R4=1;
     
246.         C1=C2=C3=C4=1;
     
247.         if (C1==0)//S6按键:A2
     
248.         {
     
249.                 Delay(TAJ);
     
250.                 if(C1==0)
     
251.                 {       
     
252.                         P0=0x40;
     
253.                         Init573(5);
     
254.                         InitTimer0();
     
255.                         num=led=2;
     
256.                         serve=10;
     
257.                         while(C1==0);
     
258.                         {
     
259.                                 Display_Num();
     
260.                         }
     
261.                 }
     
262.         }
     
263.         else if(C2==0)//S10按键:B2
     
264.         {
     
265.         Delay(TAJ);
     
266.                 if(C2==0)
     
267.                 {       
     
268.                         P0=0x40;
     
269.                         Init573(5);
     
270.                         InitTimer0();
     
271.                         num=led=2;
     
272.                         serve=11;
     
273.                         while(C2==0);
     
274.                         {
     
275.                                 Display_Num();
     
276.                         }
     
277.                 }
     
278.         }
     
279.         else if(C3==0)//S14按键:C2
     
280.         {
     
281.         Delay(TAJ);
     
282.                 if(C3==0)
     
283.                 {       
     
284.                         P0=0x40;
     
285.                         Init573(5);
     
286.                         InitTimer0();
     
287.                         num=led=2;
     
288.                         serve=12;
     
289.                         while(C3==0);
     
290.                         {
     
291.                                 Display_Num();
     
292.                         }
     
293.                 }
     
294.         }
     
295.         else if(C4==0)//S18按键:D2
     
296.         {
     
297.         Delay(TAJ);
     
298.                 if(C4==0)
     
299.                 {       
     
300.                         P0=0x40;
     
301.                         Init573(5);
     
302.                         InitTimer0();
     
303.                         num=led=2;
     
304.                         serve=13;
     
305.                         while(C4==0);
     
306.                         {
     
307.                                 Display_Num();
     
308.                         }
     
309.                 }
     
310.         }
     
311.         //检测第三行按键
     
312.         R3=0;
     
313.         R1=R2=R4=1;
     
314.         C1=C2=C3=C4=1;
     
315.         if (C1==0)//S5按键:A3
     
316.         {
     
317.                 Delay(TAJ);
     
318.                 if(C1==0)
     
319.                 {       
     
320.                         P0=0x40;
     
321.                         Init573(5);
     
322.                         InitTimer0();
     
323.                         num=led=3;
     
324.                         serve=10;
     
325.                         while(C1==0);
     
326.                         {
     
327.                                 Display_Num();
     
328.                         }
     
329.                 }
     
330.         }
     
331.         else if(C2==0)//S9按键:B3
     
332.         {
     
333.         Delay(TAJ);
     
334.                 if(C2==0)
     
335.                 {       
     
336.                         P0=0x40;
     
337.                         Init573(5);
     
338.                         InitTimer0();
     
339.                         num=led=3;
     
340.                         serve=11;
     
341.                         while(C2==0);
     
342.                         {
     
343.                                 Display_Num();
     
344.                         }
     
345.                 }
     
346.         }
     
347.         else if(C3==0)//S13按键:C3
     
348.         {
     
349.         Delay(TAJ);
     
350.                 if(C3==0)
     
351.                 {       
     
352.                         P0=0x40;
     
353.                         Init573(5);
     
354.                         InitTimer0();
     
355.                         num=led=3;
     
356.                         serve=12;
     
357.                         while(C3==0);
     
358.                         {
     
359.                                 Display_Num();
     
360.                         }
     
361.                 }
     
362.         }
     
363.         else if(C4==0)//S17按键:D3
     
364.         {
     
365.         Delay(TAJ);
     
366.                 if(C4==0)
     
367.                 {       
     
368.                         P0=0x40;
     
369.                         Init573(5);
     
370.                         InitTimer0();
     
371.                         num=led=3;
     
372.                         serve=13;
     
373.                         while(C4==0);
     
374.                         {
     
375.                                 Display_Num();
     
376.                         }
     
377.                 }
     
378.         }
     
379.         //检测第四行按键
     
380.         R4=0;
     
381.         R1=R2=R3=1;
     
382.         C1=C2=C3=C4=1;
     
383.         if (C1==0)//S4按键
     
384.         {
     
385.                 Delay(TAJ);
     
386.                 if(C1==0)
     
387.                 {       
     
388.                         num=16;
     
389.                         serve=16;
     
390.                         led=4;
     
391.                         P0=0x00;
     
392.                         Init573(5);
     
393.                         while(C1==0);
     
394.                         {
     
395.                                 Display_Num();
     
396.                         }
     
397.                 }
     
398.         }
     
399. //        else if(C2==0)//S8按键
     
400. //        {
     
401. //        Delay(TAJ);
     
402. //                if(C2==0)
     
403. //                {       
     
404. //                        while(C2==0);
     
405. //                        number=1;
     
406. //                        DisplayNumber(SMG_duanma[number]);
     
407. //                }
     
408. //        }
     
409. //        else if(C3==0)//S12按键
     
410. //        {
     
411. //        Delay(TAJ);
     
412. //                if(C3==0)
     
413. //                {       
     
414. //                        while(C3==0);
     
415. //                        number=2;
     
416. //                        DisplayNumber(SMG_duanma[number]);
     
417. //                }
     
418. //        }
     
419. //        else if(C4==0)//S16按键
     
420. //        {
     
421. //        Delay(TAJ);
     
422. //                if(C4==0)
     
423. //                {       
     
424. //                        while(C4==0);
     
425. //                        number=3;
     
426. //                        DisplayNumber(SMG_duanma[number]);
     
427. //                }
     
428. //        }
     
429. }
     
430. 
     
431. //LED控制函数
     
432. void LED_Control()
     
433. {
     
434.         if(led == 1)
     
435.                 {
     
436.                         //L1点亮
     
437. //                        P0 = 0xfe;
     
438.                         L1=0;
     
439.                         Init573(4);
     
440.                 }
     
441.                 else if(led == 2)
     
442.                 {
     
443.                         //L2点亮
     
444. //                        P0 = 0xfd;
     
445.                         L2=0;
     
446.                         Init573(4);
     
447.                 }
     
448.                 else if(led == 3)
     
449.                 {
     
450.                         //L3点亮
     
451. //                        P0 = 0xfb;
     
452.                         L3=0;
     
453.                         Init573(4);
     
454.                 }
     
455.                 else if(led == 4)
     
456.                 {
     
457.                         //全灭
     
458.                         P0 = 0xff;
     
459.                         Init573(4);
     
460.                 }
     
461.                 else
     
462.                 {
     
463.                         P0=0xff;
     
464.                         Init573(4);
     
465.                 }
     
466. }
     
467. //主函数
     
468. void main()
     
469. {
     
470.         Init_sys();
     
471.         while(1)
     
472.         {
     
473.                 Display_Num();
     
474.                 ScanKeys();
     
475.                 LED_Control();
     
476.         }
     
477. }