矩阵键盘

admin

1. /*
   
2. 
   
3. 矩阵键盘
   
4. 
   
5. 数码管字符串,双精度,长整型显示
   
6. 利用共用体指针解决方案
   
7. 
   
8. 
   
9. */
   
10. #include <REG52.H>
    
11. #include <stdio.h>
    
12. #include <string.h>
    
13. 
    
14. #define Uchar unsigned char
    
15. #define Uint  unsigned int
    
16. #define Ulong unsigned long
    
17. 
    
18. // 引脚定义区域
    
19. sbit DU = P2 ^ 6; // 数码管段选
    
20. sbit WE = P2 ^ 7; // 数码管位选
    
21. Uchar y = 999;    // 行 初始化
    
22. Uchar x = 999;    // 列初始化
    
23. 
    
24. int IS_double = 999;
    
25. 
    
26. int Get_val(union DIS_VAL *val, int type);
    
27. void Dis_scan();
    
28. void DIS_play(int result, int type);
    
29. void delay(Uchar z, int mod);
    
30. void Chars_convert(union DIS_VAL *chars_ptr);
    
31. void Ulong_convert(Ulong Z);
    
32. int Double_convert(double Z);
    
33. 
    
34. int val_arr[] = {24, 24, 24, 24, 24, 24, 24, 24}; // 24 在表码表中定义熄灭
    
35. 
    
36. // 用共用体作为万能数据类型,兼容多种场景
    
37. union DIS_VAL {
    
38.     /*无符号长整型*/
    
39.     unsigned long ULONG_data;
    
40.     /*浮点型*/
    
41.     float Float_data;
    
42.     /*双精度*/
    
43.     double Double_data;
    
44.     /*字符串*/
    
45.     char *Chars_data;
    
46. };
    
47. // 定义4*4 矩阵键盘
    
48. int code KEY_TABLE[4][4] = {
    
49.     {0, 1, 2, 3},
    
50.     {4, 5, 6, 7},
    
51.     {8, 9, 10, 11},
    
52.     {12, 13, 14, 15}
    
53. 
    
54. };
    
55. // 段码表
    
56. Uchar code DUtabel[] = {
    
57.     0x3F, //"0"
    
58.     0x06, //"1"
    
59.     0x5B, //"2"
    
60.     0x4F, //"3"
    
61.     0x66, //"4"
    
62.     0x6D, //"5"
    
63.     0x7D, //"6"
    
64.     0x07, //"7"
    
65.     0x7F, //"8"
    
66.     0x6F, //"9"
    
67.     0x77, //"A"
    
68.     0x7C, //"B"
    
69.     0x39, //"C"
    
70.     0x5E, //"D"
    
71.     0x79, //"E"
    
72.     0x71, //"F"
    
73.     0x76, //"H"
    
74.     0x38, //"L"
    
75.     0x6d, // S
    
76.     0x6d, // S
    
77.     0x37, //"n"
    
78.     0x3E, //"u"
    
79.     0x73, //"P"
    
80.     0x63, //"o"
    
81.     0x00, // 熄灭
    
82.     0x01, // 上 -
    
83.     0x40, // 中 -
    
84.     0x08, // 下 -
    
85. 
    
86. };
    
87. 
    
88. // 位码表
    
89. Uchar code WEtabel[] = {
    
90.     0xFE, // 1
    
91.     0xFD, // 2
    
92.     0xfb, // 3
    
93.     0xf7, // 4
    
94.     0xef, // 5
    
95.     0xdf, // 6
    
96.     0xbf, // 7
    
97.     0x7f, // 8
    
98. };
    
99. 
    
100. // 合法字符表
     
101. Uchar code Enable_tabel[] = {
     
102.     '0',
     
103.     '1',
     
104.     '2',
     
105.     '3',
     
106.     '4',
     
107.     '5',
     
108.     '6',
     
109.     '7',
     
110.     '8',
     
111.     '9',
     
112.     'a',
     
113.     'b',
     
114.     'c',
     
115.     'd',
     
116.     'e',
     
117.     'f',
     
118.     'h',
     
119.     'l',
     
120.     'A',
     
121.     'B',
     
122.     'C',
     
123.     'D',
     
124.     'E',
     
125.     'F',
     
126.     'H',
     
127.     'L',
     
128.     'S',
     
129.     's',
     
130.     'n',
     
131.     'N',
     
132.     'u',
     
133.     'U',
     
134.     'P',
     
135.     'p',
     
136.     'O',
     
137.     'o',
     
138.     '-',
     
139.     '_',
     
140. 
     
141. };
     
142. 
     
143. int main()
     
144. {
     
145.     union DIS_VAL val;
     
146. 
     
147.     // //字符串显示处理方案
     
148.     // val.Chars_data = "05-09";
     
149.     // if(Get_val(&val, 4)==1){//如果传入的数据合法
     
150. 
     
151.     // //长整形处理方案
     
152.     // val.ULONG_data = 23311;
     
153. 
     
154.     // if(Get_val(&val, 1)==1){//如果传入的数据合法
     
155. 
     
156.     //     // 双精度处理方案
     
157.     // val.Double_data = 88888888.55;
     
158. 
     
159.     // if (Get_val(&val, 3) == 1) { // 如果传入的数据合法
     
160. 
     
161.     // // 双精度处理方案
     
162.     // val.Double_data = 88888888.55;
     
163. 
     
164.     // if (Get_val(&val, 3) == 1) { // 如果传入的数据合法
     
165. 
     
166.     //     while (1)
     
167. 
     
168.     //     {
     
169.     //         Dis_scan();
     
170.     //     }
     
171.     // } else {
     
172.     //     // 显示错误代码 001 传入字符串有误
     
173.     //     val.Chars_data = "no000001";
     
174.     //     Chars_convert(&val);
     
175.     //     while (1) {
     
176.     //         Dis_scan();
     
177.     //     }
     
178.     // }
     
179. 
     
180.     while (1) {
     
181. 
     
182.         val.ULONG_data = Matrix_scan();
     
183.         Get_val(&val, 1);
     
184.         Dis_scan();
     
185.     }
     
186. }
     
187. 
     
188. /*
     
189. 
     
190. 这个一个万能变量的处理函数
     
191. /////////////////////////////////////////
     
192. 参数1:union 指针
     
193. 参数2:tpye  处理类型
     
194. 返回值说明:0 传入数据有误,进程终止 1:处理成功
     
195. /////////////////////////////////////////
     
196. 1:无符号长整型
     
197. 2:浮点型
     
198. 3:双精度
     
199. 4.字符串
     
200. */
     
201. int Get_val(union DIS_VAL *val, int type)
     
202. {
     
203. 
     
204.     char *charP       = val->Chars_data;
     
205.     Ulong *ulongP     = val->ULONG_data;
     
206.     double Double_val = val->Double_data;
     
207.     int count;
     
208.     int find_char;
     
209.     int i = 0;
     
210. 
     
211.     switch (type) {
     
212.         case 1: // 无符号长整型
     
213.             if (val->ULONG_data < 0 || val->ULONG_data > 99999999) {
     
214.                 return 0;
     
215.             }
     
216. 
     
217.             Ulong_convert(ulongP);
     
218.             break;
     
219. 
     
220.         case 2: // 浮点型
     
221.             // printf("%f", val->Float_data);
     
222.             if (val->Float_data < 0 || val->Float_data > 99999999) {
     
223.                 return 0;
     
224.             }
     
225. 
     
226.             break;
     
227.         case 3: // 双精度
     
228. 
     
229.             if (val->Double_data < 0 || val->Double_data > 99999999) {
     
230.                 return 0;
     
231.             }
     
232.             IS_double = Double_convert(Double_val);
     
233. 
     
234.             break;
     
235.         case 4: // 字符串
     
236.             // printf("%s", val->Chars_data);
     
237. 
     
238.             count     = 0;
     
239.             find_char = 1; // 和编码表比对字符串 1表示找到了  0代表找不到
     
240.             Chars_convert(val);
     
241.             // 传入的字符串合法性检测 如果中途返回0 则表示 传入的数据有误
     
242.             while (charP[count] != '\0') {
     
243.                 int count_char = count;
     
244.                 count++;
     
245.                 for (i = 0; i < sizeof(Enable_tabel) / sizeof(Uchar); i++) {
     
246.                     if (Enable_tabel[i] == charP[count_char]) {
     
247. 
     
248.                         find_char = 1;
     
249.                         // continue;
     
250.                         break;
     
251.                     } else {
     
252. 
     
253.                         find_char = 0;
     
254.                     }
     
255.                 }
     
256. 
     
257.                 if (find_char == 0 || count >= 9) {
     
258.                     return 0;
     
259.                 } else {
     
260.                     continue;
     
261.                 }
     
262.             }
     
263. 
     
264.             break;
     
265. 
     
266.         default:
     
267.             break;
     
268.     }
     
269. 
     
270.     return 1;
     
271. }
     
272. 
     
273. /*数码管扫描显示
     
274. 参数1:传入显示数据的指针首地址;
     
275. */
     
276. void Dis_scan()
     
277. {
     
278.     int i;
     
279. 
     
280.     for (i = 0; i < 8; i++) {
     
281. 
     
282.         DIS_play(val_arr[i], i);
     
283.     }
     
284. }
     
285. /*单位数码管显示
     
286. 参数1:显示的结果     详情查询段位表DUtabel[]
     
287. 参数2:显示在哪一位上 0-7
     
288. */
     
289. void DIS_play(int result, int WE_int)
     
290. {
     
291.     P0 = 0XFF;            // 清除断码
     
292.     WE = 1;               // 打开位选锁存器
     
293.     P0 = WEtabel[WE_int]; // 1111 1110 选通第WE_int位数码管
     
294.     WE = 0;               // 锁存位选数据
     
295. 
     
296.     DU = 1;               // 打开段选锁存器
     
297.     P0 = DUtabel[result]; // 推送数据
     
298. 
     
299.     /*判断小数点,加小数点*/
     
300.     if (IS_double != 999 && IS_double == WE_int) {
     
301.         P0 = DUtabel[result];
     
302.         P0 |= 0x80;
     
303. 
     
304.     } else {
     
305.         P0 = DUtabel[result];
     
306.     }
     
307.     DU = 0; // 锁存段选数据
     
308.     delay(2, 1);
     
309. }
     
310. /*
     
311. 延迟函数.晶振:11.0592
     
312. 参数1:z为数量
     
313. 参数2:mod为模式
     
314. 1:毫秒
     
315. 2:秒
     
316. */
     
317. void delay(Uchar z, int mod)
     
318. {
     
319.     Uint i;
     
320. 
     
321.     if (mod == 1) {
     
322.         for (i = 0; i < z; i++) {
     
323. 
     
324.             unsigned char a, b;
     
325.             for (b = 102; b > 0; b--)
     
326.                 for (a = 3; a > 0; a--)
     
327.                     ;
     
328.         }
     
329.     }
     
330. 
     
331.     else if (mod == 2) {
     
332.         for (i = 0; i < z * 1000; i++) {
     
333.             // 10000us //误差 -0.000000000002us
     
334.             unsigned char a, b;
     
335.             for (b = 102; b > 0; b--)
     
336.                 for (a = 3; a > 0; a--)
     
337.                     ;
     
338.         }
     
339.     }
     
340. }
     
341. /*转换到段表*/
     
342. void Chars_convert(union DIS_VAL *chars_ptr)
     
343. {
     
344.     int i;
     
345.     int char_i = 0;
     
346.     while (chars_ptr->Chars_data[char_i] != '\0') {
     
347.         char_i++;
     
348.     }
     
349. 
     
350.     for (i = 0; i < char_i; i++) {
     
351. 
     
352.         switch ((chars_ptr->Chars_data)[i]) {
     
353.             case '0':
     
354.                 val_arr[i] = 0;
     
355.                 break;
     
356.             case '1':
     
357.                 val_arr[i] = 1;
     
358.                 break;
     
359.             case '2':
     
360.                 val_arr[i] = 2;
     
361.                 break;
     
362.             case '3':
     
363.                 val_arr[i] = 3;
     
364.                 break;
     
365.             case '4':
     
366.                 val_arr[i] = 4;
     
367.                 break;
     
368.             case '5':
     
369.                 val_arr[i] = 5;
     
370.                 break;
     
371.             case '6':
     
372.                 val_arr[i] = 6;
     
373.                 break;
     
374.             case '7':
     
375.                 val_arr[i] = 7;
     
376.                 break;
     
377.             case '8':
     
378.                 val_arr[i] = 8;
     
379.                 break;
     
380. 
     
381.             case '9':
     
382.                 val_arr[i] = 9;
     
383.                 break;
     
384.             case 'a':
     
385.                 val_arr[i] = 10;
     
386.                 break;
     
387.             case 'A':
     
388.                 val_arr[i] = 10;
     
389.                 break;
     
390.             case 'b':
     
391.                 val_arr[i] = 11;
     
392.                 break;
     
393.             case 'B':
     
394.                 val_arr[i] = 11;
     
395.                 break;
     
396.             case 'c':
     
397.                 val_arr[i] = 12;
     
398.                 break;
     
399.             case 'C':
     
400.                 val_arr[i] = 12;
     
401.                 break;
     
402.             case 'D':
     
403.                 val_arr[i] = 13;
     
404.                 break;
     
405.             case 'd':
     
406.                 val_arr[i] = 13;
     
407.                 break;
     
408.             case 'E':
     
409.                 val_arr[i] = 14;
     
410.                 break;
     
411.             case 'e':
     
412.                 val_arr[i] = 14;
     
413.                 break;
     
414. 
     
415.             case 'F':
     
416.                 val_arr[i] = 15;
     
417.                 break;
     
418.             case 'f':
     
419.                 val_arr[i] = 15;
     
420.                 break;
     
421.             case 'H':
     
422.                 val_arr[i] = 16;
     
423.                 break;
     
424.             case 'h':
     
425.                 val_arr[i] = 16;
     
426.                 break;
     
427.             case 'L':
     
428.                 val_arr[i] = 17;
     
429.                 break;
     
430.             case 'l':
     
431.                 val_arr[i] = 17;
     
432.                 break;
     
433.             case 's':
     
434.                 val_arr[i] = 18;
     
435.                 break;
     
436.             case 'S':
     
437.                 val_arr[i] = 18;
     
438.                 break;
     
439. 
     
440.             case 'n':
     
441.                 val_arr[i] = 20;
     
442.                 break;
     
443.             case 'N':
     
444.                 val_arr[i] = 20;
     
445.                 break;
     
446.             case 'u':
     
447.                 val_arr[i] = 21;
     
448.                 break;
     
449.             case 'U':
     
450.                 val_arr[i] = 21;
     
451.                 break;
     
452.             case 'P':
     
453.                 val_arr[i] = 22;
     
454.                 break;
     
455.             case 'p':
     
456.                 val_arr[i] = 22;
     
457.                 break;
     
458.             case 'o':
     
459.                 val_arr[i] = 23;
     
460.                 break;
     
461.             case 'O':
     
462.                 val_arr[i] = 23;
     
463.                 break;
     
464.             case 0x00:
     
465.                 val_arr[i] = 24;
     
466.                 break;
     
467.             case '`':
     
468.                 val_arr[i] = 25;
     
469.                 break;
     
470.             case '-':
     
471.                 val_arr[i] = 26;
     
472.                 break;
     
473.             case '_':
     
474.                 val_arr[i] = 27;
     
475.                 break;
     
476. 
     
477.             default:
     
478.                 break;
     
479.         }
     
480.     }
     
481. }
     
482. 
     
483. // 长整型处理方案
     
484. void Ulong_convert(Ulong Z)
     
485. {
     
486.     // Z长度
     
487.     int Zlen = 0;
     
488.     int Ulongi;
     
489.     int temp[8] = {24};
     
490.     int ii;
     
491.     for (ii = 0; ii < 8; ii++) {
     
492.         val_arr[ii] = 24;
     
493.     }
     
494. 
     
495.     /*存储Z每个位的数字数组变量*/
     
496.     if (Z == 0) {
     
497.         val_arr[0] = 0;
     
498.     }
     
499.     while (Z != 0) {
     
500.         // 提取n的各个数位上的数
     
501.         val_arr[Zlen] = Z % 10;
     
502.         Z /= 10;
     
503.         Zlen++;
     
504.     }
     
505. 
     
506.     for (Ulongi = 0; Ulongi < 8; Ulongi++) {
     
507.         temp[Ulongi] = val_arr[7 - Ulongi];
     
508.     }
     
509. 
     
510.     for (Ulongi = 0; Ulongi < 8; Ulongi++) {
     
511.         val_arr[Ulongi] = temp[Ulongi];
     
512.     }
     
513. }
     
514. int Double_convert(double Z)
     
515. {
     
516.     int Zlen       = 0;
     
517.     Ulong zhengshu = Z / 1; // 整数部分
     
518.     int ge;                 // 个位数
     
519.     int zhengshu_count = 0; // 整数位数
     
520.     double xiaoshu     = Z - (double)zhengshu;
     
521.     int i              = 0;
     
522.     Ulong tempge;
     
523.     Uint ii = 0;
     
524.     Ulong temp_zhengshu;
     
525.     Ulong z = Z / 1;
     
526.     if (z == 0) {
     
527.         val_arr[0] = 0;
     
528.         i          = 1;
     
529.         IS_double  = 0;
     
530.         ge         = 0;
     
531.     } else {
     
532.         temp_zhengshu = zhengshu;
     
533.         while (temp_zhengshu > 0) {
     
534.             // 提取n的各个数位上的数
     
535.             temp_zhengshu /= 10;
     
536.             ii++;
     
537.         }
     
538.     }
     
539. 
     
540.     while (zhengshu > 0) {
     
541.         // 提取n的各个数位上的数
     
542. 
     
543.         val_arr[ii - Zlen - 1] = zhengshu % 10;
     
544.         zhengshu /= 10;
     
545.         Zlen++;
     
546.     }
     
547.     ge = Zlen;
     
548. 
     
549.     if (z == 0) {
     
550. 
     
551.         if (8 - Zlen > 0 || 8 - i > 0) {
     
552. 
     
553.             for (i = ge + 1; i < 8; i++) {
     
554.                 val_arr[i] = (xiaoshu * 10) / 1;
     
555.                 tempge     = xiaoshu * 10;
     
556.                 xiaoshu    = xiaoshu * 10 - tempge;
     
557.             }
     
558.         }
     
559. 
     
560.     } else {
     
561.         if (8 - Zlen > 0 || 8 - i > 0) {
     
562. 
     
563.             for (i = ge; i < 8; i++) {
     
564.                 val_arr[i] = (xiaoshu * 10) / 1;
     
565.                 tempge     = xiaoshu * 10;
     
566.                 xiaoshu    = xiaoshu * 10 - tempge;
     
567.             }
     
568.         }
     
569. 
     
570.         return ge - 1;
     
571.     }
     
572. 
     
573.     return ge;
     
574. }
     
575. 
     
576. int Matrix_scan()
     
577. {
     
578. 
     
579.     P3 = 0XF0;
     
580.     if (P3 != 0XF0) {
     
581. 
     
582.         x = P3;
     
583.         delay(10, 1);
     
584.         P3 = 0X0F;
     
585.     }
     
586.     P3 = 0X0F;
     
587.     if (P3 != 0X0F) {
     
588. 
     
589.         y = P3;
     
590.         delay(10, 1);
     
591.     }
     
592. 
     
593.     switch (x) {
     
594.         case 0x70:
     
595.             x = 3;
     
596.             break;
     
597.         case 0xb0:
     
598.             x = 2;
     
599.             break;
     
600.         case 0xd0:
     
601.             x = 1;
     
602.             break;
     
603.         case 0xe0:
     
604.             x = 0;
     
605.             break;
     
606. 
     
607.         default:
     
608.             break;
     
609.     }
     
610. 
     
611.     switch (y) {
     
612.         case 0x0e:
     
613.             y = 0;
     
614.             break;
     
615.         case 0x0d:
     
616.             y = 1;
     
617.             break;
     
618.         case 0x0b:
     
619.             y = 2;
     
620.             break;
     
621.         case 0x07:
     
622.             y = 3;
     
623.             break;
     
624. 
     
625.         default:
     
626.             break;
     
627.     }
     
628. 
     
629.     return KEY_TABLE[y][x];
     
630. }

复制代码