单片机程序 16个按键＋1个数码管＋Uart通信

1. /*此函数为按键发送 ,同时在数码管上显示
   
2. /*功能：单片机向PC发送按键字符，0-9　英文
   
3. //                上下左右对错,U,D,L,R,Y,N
   
4. //                 按一下，发送一个，不按不发送，
   
5. //                长按一直发送
   
6. //                 数码管上显示0－9　ABCDEF
   
7. //日期：2022-4-14AM　
   
8. ***********************************************/
   
9. #include <reg52.h>
   
10. #include "key16-2.h"
    
11. typedef   unsigned int   u16;
    
12. sbit led=P2^2;
    
13. u8 temp,n;
    
14. void delay(u16 n)
    
15. {
    
16.         while(n--);
    
17. }
    
18. void UART_init(void)
    
19. {
    
20.         SCON = 0x50;
    
21.         TMOD = 0x20;
    
22.         TH1  = 0xFD;
    
23.         TL1  = 0xFD;
    
24.         TR1  = 1;
    
25.         //ES   = 1;
    
26.         //EA   = 1;
    
27. }
    
28. void Uart_send(u8 dat)
    
29. {
    
30.         SBUF = dat;
    
31.         while(!TI);
    
32. }
    
33. 
    
34. main()
    
35. {
    
36.         UART_init();
    
37.         led=0;
    
38.         while(1)
    
39.         {
    
40.                 temp=key_scan();
    
41.                 if(temp!=0xff)
    
42.                 {
    
43.                          Uart_send(temp);
    
44.                         switch (temp)
    
45.                         {
    
46.                                  case 'Y': temp=11;break;
    
47.                                 case 'N': temp=10;break;
    
48.                                 case 'L': temp=12;break;
    
49.                                 case 'D': temp=13;break;
    
50.                                 case 'U': temp=14;break;
    
51.                                 case 'R': temp=15;break;
    
52.                                
    
53.                         }
    
54.                         P0=~num[temp];                //加“~”是因为我的代码表是共阴数码的，而板
    
55.                         delay(30000);                        //子上是共阳的
    
56.                 }
    
57.         }
    
58. }
    
59. 
    

复制代码

1. #ifndef _KEY16_H_
   
2. #define _KEY16_H_
   
3. 
   
4. typedef unsigned char u8;
   
5. 
   
6. sbit hang1=P1^7;
   
7. sbit hang2=P1^6;
   
8. sbit hang3=P1^5;
   
9. sbit hang4=P1^4;
   
10. 
    
11. sbit lie1=P1^3;
    
12. sbit lie2=P1^2;
    
13. sbit lie3=P1^1;
    
14. sbit lie4=P1^0;
    
15. 
    
16. u8 code num[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,
    
17.                            0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71
    
18. };
    
19. u8 key_val=0xff;
    
20. void key_delay()
    
21. {
    
22.         u8 x,y;
    
23.         for(x=200;x>0;x--)
    
24.                 for(y=220;y>0;y--);
    
25. }
    
26. u8 key_scan()
    
27. {
    
28.         hang1=0;
    
29.         hang2=1;
    
30.         hang3=1;
    
31.         hang4=1;
    
32.         if(lie1==0)                                //right         15
    
33.         {
    
34.                  key_delay();
    
35.                 if(lie1==0)
    
36.                 {
    
37.                    return 'R'+'\0';
    
38.                 }
    
39.                 while(lie1==0);
    
40.         }
    
41.         if(lie2==0)                                   //up                14
    
42.         {
    
43.                  key_delay();
    
44.                 if(lie2==0)
    
45.                 {
    
46.                    return 'U'+'\0';
    
47.                 }
    
48.                 while(lie2==0);
    
49.         }
    
50.         if(lie3==0)                                //down           13
    
51.         {
    
52.                  key_delay();
    
53.                 if(lie3==0)
    
54.                 {
    
55.                    return 'D'+'\0';
    
56.                 }
    
57.                 while(lie3==0);
    
58.         }
    
59.         if(lie4==0)                                        //left           12
    
60.         {
    
61.                  key_delay();
    
62.                 if(lie4==0)
    
63.                 {
    
64.                    return 'L'+'\0';
    
65.                 }
    
66.                 while(lie4==0);
    
67.         }
    
68.         hang1=1;
    
69.         hang2=0;
    
70.         hang3=1;
    
71.         hang4=1;
    
72.         if(lie1==0)                                //ok
    
73.         {
    
74.                  key_delay();
    
75.                 if(lie1==0)
    
76.                 {
    
77.                    return 'Y'+'\0';
    
78.                 }
    
79.                 while(lie1==0);
    
80.         }
    
81.         if(lie2==0)                                   //9
    
82.         {
    
83.                  key_delay();
    
84.                 if(lie2==0)
    
85.                 {
    
86.                    return 9;
    
87.                 }
    
88.                 while(lie2==0);
    
89.         }
    
90.         if(lie3==0)                                //3
    
91.         {
    
92.                  key_delay();
    
93.                 if(lie3==0)
    
94.                 {
    
95.                    return 3;
    
96.                 }
    
97.                 while(lie3==0);
    
98.         }
    
99.         if(lie4==0)                                        //6
    
100.         {
     
101.                  key_delay();
     
102.                 if(lie4==0)
     
103.                 {
     
104.                    return 6;
     
105.                 }
     
106.                 while(lie4==0);
     
107.         }
     
108.         hang1=1;
     
109.         hang2=1;
     
110.         hang3=0;
     
111.         hang4=1;
     
112.         if(lie1==0)                                //0
     
113.         {
     
114.                  key_delay();
     
115.                 if(lie1==0)
     
116.                 {
     
117.                    return 0;
     
118.                 }
     
119.                 while(lie1==0);
     
120.         }
     
121.         if(lie2==0)                                   //8
     
122.         {
     
123.                  key_delay();
     
124.                 if(lie2==0)
     
125.                 {
     
126.                    return 8;
     
127.                 }
     
128.                 while(lie2==0);
     
129.         }
     
130.         if(lie3==0)                                //2
     
131.         {
     
132.                  key_delay();
     
133.                 if(lie3==0)
     
134.                 {
     
135.                    return 2;
     
136.                 }
     
137.                 while(lie3==0);
     
138.         }
     
139.         if(lie4==0)                                        //5
     
140.         {
     
141.                  key_delay();
     
142.                 if(lie4==0)
     
143.                 {
     
144.                    return 5;
     
145.                 }
     
146.                 while(lie4==0);
     
147.         }
     
148.         hang1=1;
     
149.         hang2=1;
     
150.         hang3=1;
     
151.         hang4=0;
     
152.         if(lie1==0)                                //ESC
     
153.         {
     
154.                  key_delay();
     
155.                 if(lie1==0)
     
156.                 {
     
157.                    return 'N'+'\0';
     
158.                 }
     
159.                 while(lie1==0);
     
160.         }
     
161.         if(lie2==0)                                   //7
     
162.         {
     
163.                  key_delay();
     
164.                 if(lie2==0)
     
165.                 {
     
166.                    return 7;
     
167.                 }
     
168.                 while(lie2==0);
     
169.         }
     
170.         if(lie3==0)                                //1
     
171.         {
     
172.                  key_delay();
     
173.                 if(lie3==0)
     
174.                 {
     
175.                    return 1;
     
176.                 }
     
177.                 while(lie3==0);
     
178.         }
     
179.         if(lie4==0)                                        //4
     
180.         {
     
181.                  key_delay();
     
182.                 if(lie4==0)
     
183.                 {
     
184.                    return 4;
     
185.                 }
     
186.                 while(lie4==0);
     
187.         }
     
188.         return 0xff;                   
     
189. }
     
190. #endif

复制代码

定义按键和按键扫描函数在include文件里