有关单片机异口驱动LED数码管的求助

law3411209

数码管与单片机，由于布线原因，单片机驱动io比较乱，由于本人比较菜，程序太烂：

1. //=====================================================================
   
2. //=========================舵机测试仪==================================
   
3. //=================MCU: HC89S003F4  2020-2-26==========================
   
4. //========================编程：荆棘鸟=================================
   
5. //=====================================================================
   
6. 
   
7. #define ALLOCATE_EXTERN
   
8. #include "HC89S003F4.h"
   
9. #define Uint unsigned int
   
10. #define Uchar unsigned char
    
11.        
    
12. 
    
13. //======================LED数码管GPIO设置==============================
    
14. sbit SMG_COM1 = P1^0;               //       ==========
    
15. sbit SMG_COM2 = P2^1;               //     ||          ||
    
16. sbit SMG_COM3 = P0^6;               //     ||          ||
    
17. sbit SMG_COM4 = P0^4;               //     ||          ||
    
18. sbit SMG_A = P2^7;                  //     ||          ||
    
19. sbit SMG_B = P0^7;                  //       ==========        
    
20. sbit SMG_C = P0^2;                  //     ||          ||
    
21. sbit SMG_D = P0^0;                  //     ||          ||
    
22. sbit SMG_E = P1^1;                  //     ||          ||
    
23. sbit SMG_F = P2^2;                  //     ||          ||
    
24. sbit SMG_G = P0^3;                  //       ==========
    
25. sbit SMG_DP = P0^1;                 //       LED 数码管
    
26. 
    
27. /************************************系统初始化****************************************/
    
28. void SystemInit()
    
29. {
    
30.         WDTCCR = 0x00;                                                    //关闭看门狗
    
31.                                             //本例程为方便测试关闭看门狗，实际使用中，建议客户打开看门狗，详见WDT复位例程
    
32.         CLKSWR = 0x51;                                                    //选择内部高频RC为系统时钟，内部高频RC 2分频，Fosc=16MHz
    
33.         CLKDIV = 0x01;                                                    //Fosc 1分频得到Fcpu，Fcpu=16MHz
    
34. }
    
35. 
    
36. /*********************************设置IO口模式*****************************************/
    
37. void GpioInit()
    
38. {
    
39.         /***************************************************************************************
    
40.                        * @实现效果        设置各个IO口的工作状态
    
41.   ***************************************************************************************/       
    
42.   /***********************************设置IO口模式***************************************/
    
43.             //P0M1 = P0M1&0xF0|0x00;                                //P02设置为输入(非施密特)
    
44.             //P0M0 = P0M0&0x0F|0x10;                                //P01设置为带下拉输入(非施密特)
    
45.             //P0M0 = P0M0&0xF0|0x02;                                //P00设置为带上拉输入(非施密特)
    
46.             //P1M0 = P1M0&0x0F|0x30;                                //P11设置为带模拟输入
    
47.             //P2M0 = P2M0&0xF0|0x04;                                //P20设置为输入(施密特)
    
48.             //P0M2 = P0M2&0x0F|0x50;                                //P05设置为带下拉输入(施密特)
    
49.             //P0M2 = P0M2&0xF0|0x06;                                //P04设置为带上拉输入(施密特)
    
50.             //P0M3 = P0M3&0x0F|0x80;                                //P07设置为推挽输出
    
51.             //P0M3 = P0M3&0xF0|0x09;                                //P06设置为开漏输出
    
52.             //P2M1 = P2M1&0xF0|0x0A;                                //P22设置为带上拉开漏输出
    
53.            P2M3 = P2M3&0x0F|0x80;  //SMG_A P27 推挽输出  
    
54.            P0M3 = P0M3&0x0F|0x80;  //SMG_B P07 推挽输出
    
55.            P0M1 = P0M1&0xF0|0x08;  //SMG_C P02 推挽输出
    
56.            P0M0 = P0M0&0xF0|0x08;  //SMG_D P00 推挽输出
    
57.            P1M0 = P1M0&0x0F|0x80;  //SMG_E P11 推挽输出
    
58.            P2M1 = P2M1&0xF0|0x08;  //SMG_F P22 推挽输出
    
59.            P0M1 = P0M1&0X0F|0x80;  //SMG_G P03 推挽输出
    
60.            P0M0 = P0M0&0x0F|0x80;  //SMG_DP P01 推挽输出
    
61.            P1M0 = P1M0&0XF0|0x09;  //SMG_COM1 P10 推挽输出
    
62.            P2M0 = P2M0&0x0F|0x90;  //SMG_COM2 P21 推挽输出
    
63.            P0M3 = P0M3&0XF0|0x09;  //SMG_COM3 P06 推挽输出
    
64.            P0M2 = P0M2&0xF0|0x09;  //SMG_COM4 P04 推挽输出
    
65.                  //数码管COM端口初始化为高电平 不点亮
    
66.                  SMG_COM1 = 1;
    
67.                  SMG_COM2 = 1;
    
68.                  SMG_COM3 = 1;
    
69.                  SMG_COM4 = 1;
    
70. }
    
71. /*****************************************************************************************/
    
72. // * @说明          延时函数
    
73. // * [url=home.php?mod=space&uid=2842033]@参数[/url]          fui_i : 延时时间
    
74. // * @返回值 无
    
75. // * @注         Fcpu = 16MHz,fui_i = 1时,延时时间约为2us
    
76. /****************************************************************************************/
    
77. void Delay_2us(unsigned int fui_i)
    
78. {
    
79.         while(fui_i--);       
    
80. }
    
81. 
    
82. void Delay_ms(unsigned int i)
    
83. {
    
84.         unsigned int x,y;
    
85.         for(x=i;x>0;x--)
    
86.                 for(y=610;y>0;y--);
    
87. }
    
88. 
    
89. 
    
90. 
    
91. 
    
92. void SMG_Array(unsigned char i)
    
93. {
    
94.                 switch(i)
    
95.                 {
    
96.                         case 0:
    
97.                                   SMG_A = 1;
    
98.                             Delay_2us(100);
    
99.                             SMG_A = 0;
    
100.                                         Delay_2us(100);
     
101.                             SMG_B = 1;
     
102.                             Delay_2us(100);
     
103.                             SMG_B = 0;
     
104.                                         Delay_2us(100);
     
105.                             SMG_C = 1;
     
106.                             Delay_2us(100);
     
107.                             SMG_C = 0;
     
108.                                         Delay_2us(100);
     
109.                             SMG_D = 1;
     
110.                             Delay_2us(100);
     
111.                             SMG_D = 0;
     
112.                                         Delay_2us(100);
     
113.                             SMG_E = 1;
     
114.                             Delay_2us(100);
     
115.                             SMG_E = 0;
     
116.                                         Delay_2us(100);
     
117.                             SMG_F = 1;
     
118.                             Delay_2us(100);
     
119.                             SMG_F= 0;
     
120.                                         Delay_2us(100);
     
121.                             break;
     
122.                         case 1:
     
123.                                                  
     
124.                             SMG_B = 1;
     
125.                             Delay_2us(100);
     
126.                             SMG_B = 0;
     
127.                                         Delay_2us(100);
     
128.                             SMG_C = 1;
     
129.                             Delay_2us(100);
     
130.                             SMG_C = 0;
     
131.                                         Delay_2us(100);
     
132.                                         break;
     
133.                         case 2:
     
134.                                   SMG_A = 1;
     
135.                             Delay_2us(100);
     
136.                             SMG_A = 0;
     
137.                                         Delay_2us(100);
     
138.                             SMG_B = 1;
     
139.                             Delay_2us(100);
     
140.                             SMG_B = 0;
     
141.                                         Delay_2us(100);
     
142.                             SMG_D = 1;
     
143.                             Delay_2us(100);
     
144.                             SMG_D = 0;
     
145.                                         Delay_2us(100);
     
146.                             SMG_E = 1;
     
147.                             Delay_2us(100);
     
148.                             SMG_E = 0;
     
149.                                         Delay_2us(100);
     
150.                             SMG_G = 1;
     
151.                             Delay_2us(100);
     
152.                             SMG_G= 0;
     
153.                                         Delay_2us(100);
     
154.                                         break;
     
155.                         case 3:
     
156.                                   SMG_A = 1;
     
157.                             Delay_2us(100);
     
158.                             SMG_A = 0;
     
159.                                         Delay_2us(100);
     
160.                             SMG_B = 1;
     
161.                             Delay_2us(100);
     
162.                             SMG_B = 0;
     
163.                                         Delay_2us(100);
     
164.                             SMG_C = 1;
     
165.                             Delay_2us(100);
     
166.                             SMG_C = 0;
     
167.                                         Delay_2us(100);
     
168.                             SMG_D = 1;
     
169.                             Delay_2us(100);
     
170.                             SMG_D = 0;
     
171.                                         Delay_2us(100);
     
172.                             SMG_G = 1;
     
173.                             Delay_2us(100);
     
174.                             SMG_G= 0;
     
175.                                         Delay_2us(100);
     
176.                                         break;
     
177.                         case 4:
     
178.                                         Delay_2us(100);
     
179.                             SMG_B = 1;
     
180.                             Delay_2us(100);
     
181.                             SMG_B = 0;
     
182.                                         Delay_2us(100);
     
183.                             SMG_C = 1;
     
184.                             Delay_2us(100);
     
185.                             SMG_C = 0;
     
186.                                         Delay_2us(100);
     
187.                             SMG_G = 1;
     
188.                             Delay_2us(100);
     
189.                             SMG_G = 0;
     
190.                                         Delay_2us(100);
     
191.                             SMG_F = 1;
     
192.                             Delay_2us(100);
     
193.                             SMG_F= 0;
     
194.                                         Delay_2us(100);
     
195.                             break;
     
196.                         case 5:
     
197.                                   SMG_A = 1;
     
198.                             Delay_2us(100);
     
199.                             SMG_A = 0;
     
200.                                         Delay_2us(100);
     
201.                             SMG_C = 1;
     
202.                             Delay_2us(100);
     
203.                             SMG_C = 0;
     
204.                                         Delay_2us(100);
     
205.                             SMG_D = 1;
     
206.                             Delay_2us(100);
     
207.                             SMG_D = 0;
     
208.                                         Delay_2us(100);
     
209.                             SMG_G = 1;
     
210.                             Delay_2us(100);
     
211.                             SMG_G = 0;
     
212.                                         Delay_2us(100);
     
213.                             SMG_F = 1;
     
214.                             Delay_2us(100);
     
215.                             SMG_F= 0;
     
216.                                         Delay_2us(100);
     
217.                                         break;
     
218.                         case 6:
     
219.                                   SMG_A = 1;
     
220.                             Delay_2us(100);
     
221.                             SMG_A = 0;
     
222.                                         Delay_2us(100);
     
223.                             SMG_C = 1;
     
224.                             Delay_2us(100);
     
225.                             SMG_C = 0;
     
226.                                         Delay_2us(100);
     
227.                             SMG_D = 1;
     
228.                             Delay_2us(100);
     
229.                             SMG_D = 0;
     
230.                                         Delay_2us(100);
     
231.                             SMG_E = 1;
     
232.                             Delay_2us(100);
     
233.                             SMG_E = 0;
     
234.                                         Delay_2us(100);
     
235.                             SMG_F = 1;
     
236.                             Delay_2us(100);
     
237.                             SMG_F= 0;
     
238.                                         Delay_2us(100);
     
239.                             SMG_G = 1;
     
240.                             Delay_2us(100);
     
241.                             SMG_G= 0;
     
242.                                         Delay_2us(100);
     
243.                                         break;
     
244.                         case 7:
     
245.                                   SMG_A = 1;
     
246.                             Delay_2us(100);
     
247.                             SMG_A = 0;
     
248.                                         Delay_2us(100);
     
249.                             SMG_B = 1;
     
250.                             Delay_2us(100);
     
251.                             SMG_B = 0;
     
252.                                         Delay_2us(100);
     
253.                             SMG_C = 1;
     
254.                             Delay_2us(100);
     
255.                             SMG_C = 0;
     
256.                                         Delay_2us(100);
     
257.                                         break;
     
258.                         case 8:
     
259.                                   SMG_A = 1;
     
260.                             Delay_2us(100);
     
261.                             SMG_A = 0;
     
262.                                         Delay_2us(100);
     
263.                             SMG_B = 1;
     
264.                             Delay_2us(100);
     
265.                             SMG_B = 0;
     
266.                                         Delay_2us(100);
     
267.                             SMG_C = 1;
     
268.                             Delay_2us(100);
     
269.                             SMG_C = 0;
     
270.                                         Delay_2us(100);
     
271.                             SMG_D = 1;
     
272.                             Delay_2us(100);
     
273.                             SMG_D = 0;
     
274.                                         Delay_2us(100);
     
275.                             SMG_E = 1;
     
276.                             Delay_2us(100);
     
277.                             SMG_E = 0;
     
278.                                         Delay_2us(100);
     
279.                             SMG_F = 1;
     
280.                             Delay_2us(100);
     
281.                             SMG_F= 0;
     
282.                                         Delay_2us(100);
     
283.                                         SMG_G = 1;
     
284.                             Delay_2us(100);
     
285.                             SMG_G= 0;
     
286.                                         Delay_2us(100);
     
287.                             break;
     
288.                         case 9:
     
289.                                   SMG_A = 1;
     
290.                             Delay_2us(100);
     
291.                             SMG_A = 0;
     
292.                                         Delay_2us(100);
     
293.                             SMG_B = 1;
     
294.                             Delay_2us(100);
     
295.                             SMG_B = 0;
     
296.                                         Delay_2us(100);
     
297.                             SMG_C = 1;
     
298.                             Delay_2us(100);
     
299.                             SMG_C = 0;
     
300.                                         Delay_2us(100);
     
301.                             SMG_D = 1;
     
302.                             Delay_2us(100);
     
303.                             SMG_D = 0;
     
304.                                         Delay_2us(100);
     
305.                             SMG_G = 1;
     
306.                             Delay_2us(100);
     
307.                             SMG_G = 0;
     
308.                                         Delay_2us(100);
     
309.                             SMG_F = 1;
     
310.                             Delay_2us(100);
     
311.                             SMG_F= 0;
     
312.                                         Delay_2us(100);
     
313.                                         break;
     
314.                         case 10:
     
315.                                   SMG_A = 1;
     
316.                             Delay_2us(100);
     
317.                             SMG_A = 0;
     
318.                                         Delay_2us(100);
     
319.                             SMG_B = 1;
     
320.                             Delay_2us(100);
     
321.                             SMG_B = 0;
     
322.                                         Delay_2us(100);
     
323.                             SMG_C = 1;
     
324.                             Delay_2us(100);
     
325.                             SMG_C = 0;
     
326.                                         Delay_2us(100);
     
327.                             SMG_D = 1;
     
328.                             Delay_2us(100);
     
329.                             SMG_D = 0;
     
330.                                         Delay_2us(100);
     
331.                             SMG_E = 1;
     
332.                             Delay_2us(100);
     
333.                             SMG_E = 0;
     
334.                                         Delay_2us(100);
     
335.                             SMG_F = 1;
     
336.                             Delay_2us(100);
     
337.                             SMG_F= 0;
     
338.                                         Delay_2us(100);
     
339.                                         break;
     
340.                 }
     
341. }
     
342. 
     
343. void SMG_Display(unsigned int i)
     
344. {
     
345.                  unsigned char Qian, Bai, Shi, Ge;
     
346.                  Qian = i/1000;
     
347.            Bai = i%1000/100;
     
348.            Shi = i%100/10;
     
349.            Ge = i%10;
     
350.            SMG_COM1 = 0;
     
351.                  SMG_COM2 = 1;
     
352.            SMG_COM3 = 1;
     
353.            SMG_COM4 = 1;
     
354.                  switch(Qian)
     
355.                  {
     
356.                          case 0:
     
357.                                         SMG_Array(Qian);
     
358.                       break;
     
359.                          case 1:
     
360.                                         SMG_Array(Qian);
     
361.                       break;
     
362.                          case 2:
     
363.                                         SMG_Array(Qian);
     
364.                       break;
     
365.                          case 3:
     
366.                                         SMG_Array(Qian);
     
367.                       break;
     
368.                          case 4:
     
369.                                         SMG_Array(Qian);
     
370.                       break;
     
371.                          case 5:
     
372.                                         SMG_Array(Qian);
     
373.                       break;
     
374.                          case 6:
     
375.                                         SMG_Array(Qian);
     
376.                       break;
     
377.                          case 7:
     
378.                                         SMG_Array(Qian);
     
379.                       break;
     
380.                          case 8:
     
381.                                         SMG_Array(Qian);
     
382.                       break;
     
383.                          case 9:
     
384.                                         SMG_Array(Qian);
     
385.                       break;
     
386.                  }
     
387.                 SMG_COM1 = 1;
     
388.                 SMG_COM2 = 0;
     
389.                 SMG_COM3 = 1;
     
390.                 SMG_COM4 = 1;
     
391.                 switch(Bai)
     
392.                  {
     
393.                          case 0:
     
394.                                         SMG_Array(Bai);
     
395.                       break;
     
396.                          case 1:
     
397.                                         SMG_Array(Bai);
     
398.                       break;
     
399.                          case 2:
     
400.                                         SMG_Array(Bai);
     
401.                       break;
     
402.                          case 3:
     
403.                                         SMG_Array(Bai);
     
404.                       break;
     
405.                          case 4:
     
406.                                         SMG_Array(Bai);
     
407.                       break;
     
408.                          case 5:
     
409.                                         SMG_Array(Bai);
     
410.                       break;
     
411.                          case 6:
     
412.                                         SMG_Array(Bai);
     
413.                       break;
     
414.                          case 7:
     
415.                                         SMG_Array(Bai);
     
416.                       break;
     
417.                          case 8:
     
418.                                         SMG_Array(Bai);
     
419.                       break;
     
420.                          case 9:
     
421.                                         SMG_Array(Bai);
     
422.                       break;
     
423.                  }
     
424.                  SMG_COM1 = 1;
     
425.                  SMG_COM2 = 1;
     
426.                  SMG_COM3 = 0;
     
427.                  SMG_COM4 = 1;
     
428.                  switch(Shi)
     
429.                  {
     
430.                          case 0:
     
431.                                         SMG_Array(Shi);
     
432.                       break;
     
433.                          case 1:
     
434.                                         SMG_Array(Shi);
     
435.                       break;
     
436.                          case 2:
     
437.                                         SMG_Array(Shi);
     
438.                       break;
     
439.                          case 3:
     
440.                                         SMG_Array(Shi);
     
441.                       break;
     
442.                          case 4:
     
443.                                         SMG_Array(Shi);
     
444.                       break;
     
445.                          case 5:
     
446.                                         SMG_Array(Shi);
     
447.                       break;
     
448.                          case 6:
     
449.                                         SMG_Array(Shi);
     
450.                       break;
     
451.                          case 7:
     
452.                                         SMG_Array(Shi);
     
453.                       break;
     
454.                          case 8:
     
455.                                         SMG_Array(Shi);
     
456.                       break;
     
457.                          case 9:
     
458.                                         SMG_Array(Shi);
     
459.                       break;
     
460.                  }
     
461.                  SMG_COM1 = 1;
     
462.                  SMG_COM2 = 1;
     
463.                  SMG_COM3 = 1;
     
464.                  SMG_COM4 = 0;
     
465.                  switch(Ge)
     
466.                  {
     
467.                          case 0:
     
468.                                         SMG_Array(Ge);
     
469.                       break;
     
470.                          case 1:
     
471.                                         SMG_Array(Ge);
     
472.                       break;
     
473.                          case 2:
     
474.                                         SMG_Array(Ge);
     
475.                       break;
     
476.                          case 3:
     
477.                                         SMG_Array(Ge);
     
478.                       break;
     
479.                          case 4:
     
480.                                         SMG_Array(Ge);
     
481.                       break;
     
482.                          case 5:
     
483.                                         SMG_Array(Ge);
     
484.                       break;
     
485.                          case 6:
     
486.                                         SMG_Array(Ge);
     
487.                       break;
     
488.                          case 7:
     
489.                                         SMG_Array(Ge);
     
490.                       break;
     
491.                          case 8:
     
492.                                         SMG_Array(Ge);
     
493.                       break;
     
494.                          case 9:
     
495.                                         SMG_Array(Ge);
     
496.                       break;
     
497.                  }
     
498. }
     
499. 
     
500. /*********************************主程序*************************************************/
     
501. void main()
     
502. {
     
503.     SystemInit();       
     
504.           GpioInit();
     
505.           while(1)
     
506.           {
     
507.                  SMG_Display(1234);
     
508.           };
     
509. }
     

复制代码

代码500行，三分之二都是数码管显示代码，写的太过于繁琐，太狗屎，大佬们看看，有没有好的写法，有例程更好，谢谢大佬们

sz1988

switch处理改用函数指针，或者用数组来查表输出吧！另外要习惯写注释啊

温力口

把0～9数字分别做个字模表，然后直接调用。

hujj

建议段选控制集中用一个IO口，配合定义数组，可以简化许多代码。

wjxhone

在老论坛的我爱单片机分区，搜索“数码管”，可以找到不少例程。

触景情伤

老区论坛有，我也借用了一下效果比较好，数码管的驱动代码也没有那么多…

mckk520

哎，怎么能这样呢，一个char有八位，每个位&一个端口，就是数码管的八段啊，

la45088d1

1. sbit SMG_COM2 = P2^1;               //     ||          ||
   
2. sbit SMG_COM3 = P0^6;               //     ||          ||
   
3. sbit SMG_COM4 = P0^4;               //     ||          ||
   
4. sbit SMG_A = P2^7;                  //     ||          ||
   
5. sbit SMG_B = P0^7;                  //       ==========        
   
6. sbit SMG_C = P0^2;                  //     ||          ||
   
7. sbit SMG_D = P0^0;                  //     ||          ||
   
8. sbit SMG_E = P1^1;                  //     ||          ||
   
9. sbit SMG_F = P2^2;                  //     ||          ||
   
10. sbit SMG_G = P0^3;                  //       ==========
    
11. sbit SMG_DP = P0^1;                 //       LED ???
    
12. 
    
13. 
    
14. void Delay2us(unsigned int TimeSlotCtX2us)
    
15. {
    
16.         while(TimeSlotCtX2us--);        
    
17. }
    
18. 
    
19. void SegDataRemap(Uint8 DpValue)
    
20. {
    
21.         SMG_A = DpValue;
    
22.         SMG_B = DpValue >> 1;
    
23.         SMG_C = DpValue >> 2;
    
24.         SMG_D = DpValue >> 3;
    
25.         SMG_E = DpValue >> 4;
    
26.         SMG_F = DpValue >> 5;
    
27.         SMG_G = DpValue >> 6;
    
28.         SMG_DP = DpValue >> 7;
    
29. }
    
30. 
    
31. void ComSelect(Unit8 ComCount)
    
32. {
    
33.         switch(ComCount)
    
34.         {
    
35.                 case 1:
    
36.                 {
    
37.                         SMG_COM1 = 0;
    
38.                 }
    
39.                 case 2:
    
40.                 {
    
41.                         SMG_COM2 = 0;
    
42.                 }
    
43.                 case 2:
    
44.                 {
    
45.                         SMG_COM2 = 0;
    
46.                 }
    
47.                 case 3:
    
48.                 {
    
49.                         SMG_COM3 = 0;
    
50.                 }
    
51.                 case 4:
    
52.                 {
    
53.                         SMG_COM4 = 0;
    
54.                 }
    
55.                 default:
    
56.                 {
    
57.                         SMG_COM1 = 1;
    
58.                         SMG_COM2 = 1;
    
59.                         SMG_COM3 = 1;
    
60.                         SMG_COM4 = 1;
    
61.                 }
    
62.         }
    
63. }
    
64. 
    
65. void ShowVariableOnDigitalTube(Uint16 Input)
    
66. {
    
67.         Uint8 Digit;
    
68.         code Uint8 Front[10] = {};
    
69.        
    
70.         SegDataRemap(Front[Digit / 1000]);
    
71.         ComSelect(4);
    
72.         Delay2us(100);
    
73.        
    
74.         SegDataRemap(Front[(Digit % 1000) / 100]);
    
75.         ComSelect(3);
    
76.         Delay2us(100);
    
77.        
    
78.         SegDataRemap(Front[(Digit % 100) / 10]);
    
79.         ComSelect(2);
    
80.         Delay2us(100);
    
81.                
    
82.         SegDataRemap(Front[Digit % 10]);
    
83.         ComSelect(1);
    
84.         Delay2us(100);
    
85.        
    
86.         ComSelect(0);
    
87. }
    
88. 
    
89. void main()
    
90. {
    
91.   SystemInit();        
    
92.   GpioInit();
    
93.   while(1)
    
94.   {
    
95.     ShowVariableOnDigitalTube(1234);
    
96.   }
    
97. }
    

复制代码

la45088d1

哪有那么麻烦？
其中Font数组里面按照0-9的顺序填写字模，可以自己完成就不写了。

cbcb4cb

效率有点低，bdata了解下

cbcb4cb

好用的话不打赏也要点个赞

750123208

        D0=wc&0x01;
        D1=wc&0x02;
        D2=wc&0x04;
        D3=wc&0x08;
        D4=wc&0x10;                               
        D5=wc&0x20;
        D6=wc&0x40;
        D7=wc&0x80;

D1/D2，就是数据IO，wc就是整个传送的数据

zmc5354

unsigned char Wai;//放在顶部




void SMG_Array(unsigned char i)
{
                switch(i)
                {
                        case 0:{SMG_A=SMG_B=SMG_C=SMG_D=SMG_E=SMG_F=1;SMG_G=SMG_DP=0};  break;
                        case 1:{SMG_B=SMG_C=1;SMG_A=SMG_D=SMG_E=SMG_F=SMG_G=SMG_DP=0};  break;
                        case 2:{SMG_A=SMG_B=SMG_D=SMG_E=SMG_G=1;SMG_C=SMG_F=SMG_DP=0};  break;
                        case 3:{SMG_A=SMG_B=SMG_C=SMG_D=SMG_G=1;SMG_E=SMG_F=SMG_DP=0};  break;
                        case 4:{SMG_B=SMG_C=SMG_F=SMG_G=1;SMG_A=SMG_D=SMG_E=SMG_DP=0};  break;
                        case 5:{SMG_A=SMG_C=SMG_D=SMG_F=SMD_G=1;SMG_B=SMG_E=SMG_DP=0};  break;
                        case 6:{SMG_A=SMG_C=SMG_D=SMG_E=SMG_F=SMG_G=1;SMG_B=SMG_DP=0};  break;
                        case 7:{SMG_A=SMG_B=SMG_C=1;SMG_D=SMG_E=SMG_F=SMG_G=SMG_DP=0};  break;
                        case 8:{SMG_A=SMG_B=SMG_C=SMG_D=SMG_E=SMG_F=SMG_G=1;SMG_DP=0};  break;
                        case 9:{SMG_A=SMG_B=SMG_C=SMG_D=SMG_F=SMG_G=1;SMG_E=SMG_DP=0};  break;
                          }
              }

void SMG_Display(unsigned int i)
{
                 unsigned char Qian, Bai, Shi, Ge;

                 Wai++;
                 if(Wai>4)Wai=0;
                 Qian = i/1000;
                 Bai = i%1000/100;
                 Shi = i%100/10;
                 Ge = i%10;

                 switch(Wai)
                 {
                    case 0:{SMG_COM1=0;SMG_COM2=SMG_COM3=SMG_COM4=1;SMG_Array(Qian)};  break;
                    case 1:{SMG_COM2=0;SMG_COM1=SMG_COM3=SMG_COM4=1;SMG_Array(Bia)};  break;
                    case 2:{SMG_COM3=0;SMG_COM1=SMG_COM2=SMG_COM4=1;SMG_Array(Shi)};  break;
                    case 3:{SMG_COM4=0;SMG_COM1=SMG_COM2=SMG_COM3=1;SMG_Array(Ge)};  break;
                   }
                   Delay_ms(20);
                   SMG_COM1=SMG_COM2=SMG_COM3=SMG_COM4=1;


}

bg4uvr

1、字形数据做成表，显示某值直接查表。
2、更重要的，扫描程序放到定时器中断里。
如果第二点做不到，程序永远只能是实验性的，而没实用性。