独立键盘

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

复制代码