arduino学习笔记13 - 4位数码管实验

弘毅

这次我们进行的实验是使用arduino驱动一块共阳四位数码管。驱动数码管限流电阻肯定是必不可少的，限流电阻有两种接法，一种是在d1-d4阳极接，总共接4颗。这种接法好处是需求电阻比较少，但是会产生每一位上显示不同数字亮度会不一样，1最亮，8最暗。另外一种接法就是在其他8个引脚上接，这种接法亮度显示均匀，但是用电阻较多。本次实验使用8颗220Ω电阻（因为没有100Ω电阻，所以使用220Ω的代替，100欧姆亮度会比较高）。

下图为4位数码管



4位数码管总共有12个引脚，小数点朝下正放在面前时，左下角为1,其他管脚顺序为逆时针旋转。左上角为最大的12号管脚。



下图为数码管的说明手册



下面是硬件连接图





把下面的代码复制下载到控制板中，看看效果。

1. //设置阴极接口
   
2. int a = 1;
   
3. int b = 2;
   
4. int c = 3;
   
5. int d = 4;
   
6. int e = 5;
   
7. int f = 6;
   
8. int g = 7;
   
9. int p = 8;
   
10. //设置阳极接口
    
11. int d4 = 9;
    
12. int d3 = 10;
    
13. int d2 = 11;
    
14. int d1 = 12;
    
15. //设置变量
    
16. int del = 100;
    
17. int buttoncount = 0;
    
18. int loopcount = 0;
    
19. 
    
20. void setup()
    
21. {
    
22.   pinMode(d1, OUTPUT);
    
23.   pinMode(d2, OUTPUT);
    
24.   pinMode(d3, OUTPUT);
    
25.   pinMode(d4, OUTPUT);
    
26.   pinMode(a, OUTPUT);
    
27.   pinMode(b, OUTPUT);
    
28.   pinMode(c, OUTPUT);
    
29.   pinMode(d, OUTPUT);
    
30.   pinMode(e, OUTPUT);
    
31.   pinMode(f, OUTPUT);
    
32.   pinMode(g, OUTPUT);
    
33.   pinMode(p, OUTPUT);
    
34.   digitalWrite(a, HIGH);
    
35.   digitalWrite(b, HIGH);
    
36.   digitalWrite(c, HIGH);
    
37.   digitalWrite(d, HIGH);
    
38.   digitalWrite(e, HIGH);
    
39.   digitalWrite(f, HIGH);
    
40.   digitalWrite(g, HIGH);
    
41.   digitalWrite(p, HIGH);
    
42. }
    
43. 
    
44. void loop()
    
45. {
    
46.   roulette(4);  //轮转效果
    
47.   delay(100);
    
48.   zigzag(2);    //Z字型效果
    
49.   delay(100);
    
50.   circles(4);   //圈状效果
    
51.   delay(100);
    
52. }
    
53. 
    
54. void pickDigit(int x)  //定义pickDigit(x),其作用是开启dx端口
    
55. {
    
56.   digitalWrite(d1, LOW);
    
57.   digitalWrite(d2, LOW);
    
58.   digitalWrite(d3, LOW);
    
59.   digitalWrite(d4, LOW);
    
60. 
    
61.   switch(x)
    
62.   {
    
63.   case 1:
    
64.     digitalWrite(d1, HIGH);
    
65.     break;
    
66.   case 2:
    
67.     digitalWrite(d2, HIGH);
    
68.     break;
    
69.   case 3:
    
70.     digitalWrite(d3, HIGH);
    
71.     break;
    
72.   default:
    
73.     digitalWrite(d4, HIGH);
    
74.     break;
    
75.   }
    
76. }
    
77. 
    
78. void clearLEDs()  //清屏
    
79. {
    
80.   digitalWrite(a, HIGH);
    
81.   digitalWrite(b, HIGH);
    
82.   digitalWrite(c, HIGH);
    
83.   digitalWrite(d, HIGH);
    
84.   digitalWrite(e, HIGH);
    
85.   digitalWrite(f, HIGH);
    
86.   digitalWrite(g, HIGH);
    
87.   digitalWrite(p, HIGH);
    
88. }
    
89. 
    
90. void roulette(int x)  //设置轮转效果
    
91. {
    
92.   loopcount = 0;
    
93.   while (loopcount < x)
    
94.   {
    
95.     digitalWrite(a, LOW);
    
96.     pickDigit(1);
    
97.     delay(del);
    
98.     pickDigit(2);
    
99.     delay(del);
    
100.     pickDigit(3);
     
101.     delay(del);
     
102.     pickDigit(4);
     
103.     delay(del);
     
104.     digitalWrite(a, HIGH);
     
105.     digitalWrite(b, LOW);
     
106.     delay(del);
     
107.     digitalWrite(b, HIGH);
     
108.     digitalWrite(c, LOW);
     
109.     delay(del);
     
110.     digitalWrite(c, HIGH);
     
111.     digitalWrite(d, LOW);
     
112.     delay(del);
     
113.     pickDigit(3);
     
114.     delay(del);
     
115.     pickDigit(2);
     
116.     delay(del);
     
117.     pickDigit(1);
     
118.     delay(del);
     
119.     digitalWrite(d, HIGH);
     
120.     digitalWrite(e, LOW);
     
121.     delay(del);
     
122.     digitalWrite(e, HIGH);
     
123.     digitalWrite(f, LOW);
     
124.     delay(del);
     
125.     clearLEDs();
     
126.     loopcount++;
     
127.   }
     
128. }
     
129. 
     
130. void zigzag(int x)  //设置Z字形效果
     
131. {
     
132.   loopcount = 0;
     
133.   while(loopcount < x)
     
134.   {
     
135.     digitalWrite(a, LOW);
     
136.     pickDigit(1);
     
137.     delay(del);
     
138.     pickDigit(2);
     
139.     delay(del);
     
140.     pickDigit(3);
     
141.     delay(del);
     
142.     pickDigit(4);
     
143.     delay(del);
     
144.     digitalWrite(a, HIGH);
     
145.     digitalWrite(b, LOW);
     
146.     delay(del);
     
147.     digitalWrite(b, HIGH);
     
148.     digitalWrite(g, LOW);
     
149.     delay(del);
     
150.     pickDigit(3);
     
151.     delay(del);
     
152.     pickDigit(2);
     
153.     delay(del);
     
154.     pickDigit(1);
     
155.     delay(del);
     
156.     digitalWrite(g, HIGH);
     
157.     digitalWrite(e, LOW);
     
158.     delay(del);
     
159.     digitalWrite(e, HIGH);
     
160.     digitalWrite(d, LOW);
     
161.     delay(del);
     
162.     pickDigit(2);
     
163.     delay(del);
     
164.     pickDigit(3);
     
165.     delay(del);
     
166.     pickDigit(4);
     
167.     delay(del);
     
168.     digitalWrite(d, HIGH);
     
169.     digitalWrite(c, LOW);
     
170.     delay(del);
     
171.     digitalWrite(c, HIGH);
     
172.     digitalWrite(g, LOW);
     
173.     delay(del);
     
174.     pickDigit(3);
     
175.     delay(del);
     
176.     pickDigit(2);
     
177.     delay(del);
     
178.     pickDigit(1);
     
179.     delay(del);
     
180.     digitalWrite(g, HIGH);
     
181.     digitalWrite(f, LOW);
     
182.     delay(del);
     
183.     clearLEDs();
     
184.     loopcount++;
     
185.   }
     
186. }
     
187. 
     
188. void circles(int x)  //设置圈状效果
     
189. {
     
190.   loopcount = 0;
     
191.   while (loopcount < x)
     
192.   {
     
193.     digitalWrite(a, LOW);
     
194.     digitalWrite(b, LOW);
     
195.     digitalWrite(f, LOW);
     
196.     digitalWrite(g, LOW);
     
197.     pickDigit(1);
     
198.     delay(250);
     
199.     digitalWrite(a, HIGH);
     
200.     digitalWrite(b, HIGH);
     
201.     digitalWrite(f, HIGH);
     
202.     digitalWrite(c, LOW);
     
203.     digitalWrite(d, LOW);
     
204.     digitalWrite(e, LOW);
     
205.     pickDigit(2);
     
206.     delay(250);
     
207.     digitalWrite(a, LOW);
     
208.     digitalWrite(b, LOW);
     
209.     digitalWrite(f, LOW);
     
210.     digitalWrite(c, HIGH);
     
211.     digitalWrite(d, HIGH);
     
212.     digitalWrite(e, HIGH);
     
213.     pickDigit(3);
     
214.     delay(250);
     
215.     digitalWrite(a, HIGH);
     
216.     digitalWrite(b, HIGH);
     
217.     digitalWrite(f, HIGH);
     
218.     digitalWrite(c, LOW);
     
219.     digitalWrite(d, LOW);
     
220.     digitalWrite(e, LOW);
     
221.     pickDigit(4);
     
222.     delay(250);
     
223.     clearLEDs();
     
224.     loopcount++;
     
225.   }
     
226. }
     

复制代码

上面代码效果如下，为3种花样组成。

如果无法播放，请点击此处在新窗口打开

再把下面代码复制下载到控制板中，看看效果。

1. //设置阴极接口
   
2. int a = 1;
   
3. int b = 2;
   
4. int c = 3;
   
5. int d = 4;
   
6. int e = 5;
   
7. int f = 6;
   
8. int g = 7;
   
9. int p = 8;
   
10. //设置阳极接口
    
11. int d4 = 9;
    
12. int d3 = 10;
    
13. int d2 = 11;
    
14. int d1 = 12;
    
15. //设置变量
    
16. long n = 0;
    
17. int x = 100;
    
18. int del = 55;  //此处数值对时钟进行微调
    
19. 
    
20. void setup()
    
21. {
    
22.   pinMode(d1, OUTPUT);
    
23.   pinMode(d2, OUTPUT);
    
24.   pinMode(d3, OUTPUT);
    
25.   pinMode(d4, OUTPUT);
    
26.   pinMode(a, OUTPUT);
    
27.   pinMode(b, OUTPUT);
    
28.   pinMode(c, OUTPUT);
    
29.   pinMode(d, OUTPUT);
    
30.   pinMode(e, OUTPUT);
    
31.   pinMode(f, OUTPUT);
    
32.   pinMode(g, OUTPUT);
    
33.   pinMode(p, OUTPUT);
    
34. }
    
35. 
    
36. void loop()
    
37. {
    
38.   clearLEDs();
    
39.   pickDigit(1);
    
40.   pickNumber((n/x/1000)%10);
    
41.   delayMicroseconds(del);
    
42.   
    
43.   clearLEDs();
    
44.   pickDigit(2);
    
45.   pickNumber((n/x/100)%10);
    
46.   delayMicroseconds(del);
    
47.   
    
48.   clearLEDs();
    
49.   pickDigit(3);
    
50.   dispDec(3);
    
51.   pickNumber((n/x/10)%10);
    
52.   delayMicroseconds(del);
    
53.   
    
54.   clearLEDs();
    
55.   pickDigit(4);
    
56.   pickNumber(n/x%10);
    
57.   delayMicroseconds(del);
    
58.   
    
59.   n++;
    
60.   
    
61.   if (digitalRead(13) == HIGH)
    
62.   {
    
63.     n = 0;
    
64.   }
    
65. }
    
66. 
    
67. void pickDigit(int x)  //定义pickDigit(x),其作用是开启dx端口
    
68. {
    
69.   digitalWrite(d1, LOW);
    
70.   digitalWrite(d2, LOW);
    
71.   digitalWrite(d3, LOW);
    
72.   digitalWrite(d4, LOW);
    
73.   
    
74.   switch(x)
    
75.   {
    
76.   case 1:
    
77.     digitalWrite(d1, HIGH);
    
78.     break;
    
79.   case 2:
    
80.     digitalWrite(d2, HIGH);
    
81.     break;
    
82.   case 3:
    
83.     digitalWrite(d3, HIGH);
    
84.     break;
    
85.   default:
    
86.     digitalWrite(d4, HIGH);
    
87.     break;
    
88.   }
    
89. }
    
90. 
    
91. void pickNumber(int x)   //定义pickNumber(x),其作用是显示数字x
    
92. {
    
93.   switch(x)
    
94.   {
    
95.   default:
    
96.     zero();
    
97.     break;
    
98.   case 1:
    
99.     one();
    
100.     break;
     
101.   case 2:
     
102.     two();
     
103.     break;
     
104.   case 3:
     
105.     three();
     
106.     break;
     
107.   case 4:
     
108.     four();
     
109.     break;
     
110.   case 5:
     
111.     five();
     
112.     break;
     
113.   case 6:
     
114.     six();
     
115.     break;
     
116.   case 7:
     
117.     seven();
     
118.     break;
     
119.   case 8:
     
120.     eight();
     
121.     break;
     
122.   case 9:
     
123.     nine();
     
124.     break;
     
125.   }
     
126. }
     
127. 
     
128. void dispDec(int x)  //设定开启小数点
     
129. {
     
130.   digitalWrite(p, LOW);
     
131. }
     
132. 
     
133. void clearLEDs()  //清屏
     
134. {
     
135.   digitalWrite(a, HIGH);
     
136.   digitalWrite(b, HIGH);
     
137.   digitalWrite(c, HIGH);
     
138.   digitalWrite(d, HIGH);
     
139.   digitalWrite(e, HIGH);
     
140.   digitalWrite(f, HIGH);
     
141.   digitalWrite(g, HIGH);
     
142.   digitalWrite(p, HIGH);
     
143. }
     
144. 
     
145. void zero()  //定义数字0时阴极那些管脚开关
     
146. {
     
147.   digitalWrite(a, LOW);
     
148.   digitalWrite(b, LOW);
     
149.   digitalWrite(c, LOW);
     
150.   digitalWrite(d, LOW);
     
151.   digitalWrite(e, LOW);
     
152.   digitalWrite(f, LOW);
     
153.   digitalWrite(g, HIGH);
     
154. }
     
155. 
     
156. void one()  //定义数字1时阴极那些管脚开关
     
157. {
     
158.   digitalWrite(a, HIGH);
     
159.   digitalWrite(b, LOW);
     
160.   digitalWrite(c, LOW);
     
161.   digitalWrite(d, HIGH);
     
162.   digitalWrite(e, HIGH);
     
163.   digitalWrite(f, HIGH);
     
164.   digitalWrite(g, HIGH);
     
165. }
     
166. 
     
167. void two()  //定义数字2时阴极那些管脚开关
     
168. {
     
169.   digitalWrite(a, LOW);
     
170.   digitalWrite(b, LOW);
     
171.   digitalWrite(c, HIGH);
     
172.   digitalWrite(d, LOW);
     
173.   digitalWrite(e, LOW);
     
174.   digitalWrite(f, HIGH);
     
175.   digitalWrite(g, LOW);
     
176. }
     
177. 
     
178. void three()  //定义数字3时阴极那些管脚开关
     
179. {
     
180.   digitalWrite(a, LOW);
     
181.   digitalWrite(b, LOW);
     
182.   digitalWrite(c, LOW);
     
183.   digitalWrite(d, LOW);
     
184.   digitalWrite(e, HIGH);
     
185.   digitalWrite(f, HIGH);
     
186.   digitalWrite(g, LOW);
     
187. }
     
188. 
     
189. void four()  //定义数字4时阴极那些管脚开关
     
190. {
     
191.   digitalWrite(a, HIGH);
     
192.   digitalWrite(b, LOW);
     
193.   digitalWrite(c, LOW);
     
194.   digitalWrite(d, HIGH);
     
195.   digitalWrite(e, HIGH);
     
196.   digitalWrite(f, LOW);
     
197.   digitalWrite(g, LOW);
     
198. }
     
199. 
     
200. void five()  //定义数字5时阴极那些管脚开关
     
201. {
     
202.   digitalWrite(a, LOW);
     
203.   digitalWrite(b, HIGH);
     
204.   digitalWrite(c, LOW);
     
205.   digitalWrite(d, LOW);
     
206.   digitalWrite(e, HIGH);
     
207.   digitalWrite(f, LOW);
     
208.   digitalWrite(g, LOW);
     
209. }
     
210. 
     
211. void six()  //定义数字6时阴极那些管脚开关
     
212. {
     
213.   digitalWrite(a, LOW);
     
214.   digitalWrite(b, HIGH);
     
215.   digitalWrite(c, LOW);
     
216.   digitalWrite(d, LOW);
     
217.   digitalWrite(e, LOW);
     
218.   digitalWrite(f, LOW);
     
219.   digitalWrite(g, LOW);
     
220. }
     
221. 
     
222. void seven()  //定义数字7时阴极那些管脚开关
     
223. {
     
224.   digitalWrite(a, LOW);
     
225.   digitalWrite(b, LOW);
     
226.   digitalWrite(c, LOW);
     
227.   digitalWrite(d, HIGH);
     
228.   digitalWrite(e, HIGH);
     
229.   digitalWrite(f, HIGH);
     
230.   digitalWrite(g, HIGH);
     
231. }
     
232. 
     
233. void eight()  //定义数字8时阴极那些管脚开关
     
234. {
     
235.   digitalWrite(a, LOW);
     
236.   digitalWrite(b, LOW);
     
237.   digitalWrite(c, LOW);
     
238.   digitalWrite(d, LOW);
     
239.   digitalWrite(e, LOW);
     
240.   digitalWrite(f, LOW);
     
241.   digitalWrite(g, LOW);
     
242. }
     
243. 
     
244. void nine()  //定义数字9时阴极那些管脚开关
     
245. {
     
246.   digitalWrite(a, LOW);
     
247.   digitalWrite(b, LOW);
     
248.   digitalWrite(c, LOW);
     
249.   digitalWrite(d, LOW);
     
250.   digitalWrite(e, HIGH);
     
251.   digitalWrite(f, LOW);
     
252.   digitalWrite(g, LOW);
     
253. }
     

复制代码

下面的代码与上面的效果一样，但是使用了数组方法进行简写，大家对比一下看看哪里不易一样。

1. //设置阴极接口
   
2. int a = 1;
   
3. int b = 2;
   
4. int c = 3;
   
5. int d = 4;
   
6. int e = 5;
   
7. int f = 6;
   
8. int g = 7;
   
9. int p = 8;
   
10. //设置阳极接口
    
11. int d4 = 9;
    
12. int d3 = 10;
    
13. int d2 = 11;
    
14. int d1 = 12;
    
15. //设置变量
    
16. long n = 0;
    
17. int x = 100;
    
18. int del = 55;  //此处数值对时钟进行微调
    
19. 
    
20. byte segs[7] = { a, b, c, d, e, f, g };
    
21. 
    
22. byte seven_seg_digits[10][7] = { { 0,0,0,0,0,0,1 },  // = 0
    
23.                                  { 1,0,0,1,1,1,1 },  // = 1
    
24.                                  { 0,0,1,0,0,1,0 },  // = 2
    
25.                                  { 0,0,0,0,1,1,0 },  // = 3
    
26.                                  { 1,0,0,1,1,0,0 },  // = 4
    
27.                                  { 0,1,0,0,1,0,0 },  // = 5
    
28.                                  { 0,1,0,0,0,0,0 },  // = 6
    
29.                                  { 0,0,0,1,1,1,1 },  // = 7
    
30.                                  { 0,0,0,0,0,0,0 },  // = 8
    
31.                                  { 0,0,0,0,1,0,0 }   // = 9
    
32.                              };
    
33. 
    
34. void setup()
    
35. {
    
36.   pinMode(d1, OUTPUT);
    
37.   pinMode(d2, OUTPUT);
    
38.   pinMode(d3, OUTPUT);
    
39.   pinMode(d4, OUTPUT);
    
40.   pinMode(a, OUTPUT);
    
41.   pinMode(b, OUTPUT);
    
42.   pinMode(c, OUTPUT);
    
43.   pinMode(d, OUTPUT);
    
44.   pinMode(e, OUTPUT);
    
45.   pinMode(f, OUTPUT);
    
46.   pinMode(g, OUTPUT);
    
47.   pinMode(p, OUTPUT);
    
48. }
    
49. 
    
50. void loop()
    
51. {
    
52.   clearLEDs();
    
53.   pickDigit(1);
    
54.   lightSegments((n/x/1000)%10);
    
55.   delayMicroseconds(del);
    
56.   
    
57.   clearLEDs();
    
58.   pickDigit(2);
    
59.   lightSegments((n/x/100)%10);
    
60.   delayMicroseconds(del);
    
61.   
    
62.   clearLEDs();
    
63.   pickDigit(3);
    
64.   dispDec(3);
    
65.   lightSegments((n/x/10)%10);
    
66.   delayMicroseconds(del);
    
67.   
    
68.   clearLEDs();
    
69.   pickDigit(4);
    
70.   lightSegments(n/x%10);
    
71.   delayMicroseconds(del);
    
72.   
    
73.   n++;
    
74.   
    
75.   if (digitalRead(13) == HIGH)
    
76.   {
    
77.     n = 0;
    
78.   }
    
79. }
    
80. 
    
81. void pickDigit(int x)  //定义pickDigit(x),其作用是开启dx端口
    
82. {
    
83.   digitalWrite(d1, LOW);
    
84.   digitalWrite(d2, LOW);
    
85.   digitalWrite(d3, LOW);
    
86.   digitalWrite(d4, LOW);
    
87.   
    
88.   switch(x)
    
89.   {
    
90.   case 1:
    
91.     digitalWrite(d1, HIGH);
    
92.     break;
    
93.   case 2:
    
94.     digitalWrite(d2, HIGH);
    
95.     break;
    
96.   case 3:
    
97.     digitalWrite(d3, HIGH);
    
98.     break;
    
99.   default:
    
100.     digitalWrite(d4, HIGH);
     
101.     break;
     
102.   }
     
103. }
     
104. 
     
105. void dispDec(int x)  //设定开启小数点
     
106. {
     
107.   digitalWrite(p, LOW);
     
108. }
     
109. 
     
110. void clearLEDs()  //清屏
     
111. {
     
112.   digitalWrite(a, HIGH);
     
113.   digitalWrite(b, HIGH);
     
114.   digitalWrite(c, HIGH);
     
115.   digitalWrite(d, HIGH);
     
116.   digitalWrite(e, HIGH);
     
117.   digitalWrite(f, HIGH);
     
118.   digitalWrite(g, HIGH);
     
119.   digitalWrite(p, HIGH);
     
120. }
     
121. 
     
122. 
     
123. // 点亮对应数字的数码管
     
124. void lightSegments(int x) {
     
125.   for (int i = 0; i < 7; i++) {
     
126.     digitalWrite(segs[i], seven_seg_digits[x][i]);
     
127.   }
     
128. }
     

复制代码

此代码为简易的秒表，效果如下，精准度不是很高，需要大家微调参数。

如果无法播放，请点击此处在新窗口打开

悠然小调

关注中

悠然小调

n/x/1000)%10这没看懂，开始时n=0

悠然小调

把最后一个程序缩一下，不知道是否正确。

1. //设置变量
   
2. long n = 0;
   
3. int x = 100;
   
4. int del = 55;  //此处数值对时钟进行微调
   
5. Byte pin[4]={12,11,10,9}                     //设置阳极接口:d1接12; d2接11; d3接10; d4接9
   
6. byte segs[7] = { 1, 2, 3, 4, 5 ,6, 7 };    //设置阴极接口:a接 1; b接 2; c 接 3; d 接 4; e接 5; f接 6; g接 7; p 接 8;
   
7. 
   
8. byte seven_seg_digits[10][7] = {   { 0,0,0,0,0,0,1 },  // = 0
   
9.                              { 1,0,0,1,1,1,1 },  // = 1
   
10.                              { 0,0,1,0,0,1,0 },  // = 2
    
11.                              { 0,0,0,0,1,1,0 },  // = 3
    
12.                              { 1,0,0,1,1,0,0 },  // = 4
    
13.                              { 0,1,0,0,1,0,0 },  // = 5
    
14.                              { 0,1,0,0,0,0,0 },  // = 6
    
15.                              { 0,0,0,1,1,1,1 },  // = 7
    
16.                              { 0,0,0,0,0,0,0 },  // = 8
    
17.                              { 0,0,0,0,1,0,0 }   // = 9
    
18.                            };
    
19. 
    
20. void setup()
    
21. {  for(int i=1,i<12,i++)
    
22.   {  pinMode(i, OUTPUT); }
    
23. }
    
24. 
    
25. void loop()
    
26. {
    
27.    int shu;
    
28.    for (int k=0,k<3,k++)
    
29.     {
    
30.       clearLEDs();
    
31.       digitalWrite(pin[k],HIGH);
    
32.       shu=n/k%10;
    
33.       for (int i = 0; i < 7; i++)
    
34.      {  
    
35.        digitalWrite(segs[i], seven_seg_digits[shu][i] );
    
36.             if (k==2)
    
37.          { digitalWrite(p, LOW); }
    
38.        }
    
39.    delayMicroseconds(del);
    
40.   }
    
41.          n++;
    
42.     if (digitalRead(13) == HIGH)
    
43.   {  n = 0;  }
    
44. }
    
45. 
    
46. void clearLEDs()  //清屏
    
47. {
    
48.    for (int j=1,j<12,j++)
    
49.     {
    
50.       digitalWrite( j, HIGH);
    
51.      }  
    
52. }

复制代码

━__Neo_ˇ

嘿嘿嘿嘿

渤海渔翁

我的数码管没有说明书，几个脚还没分清

悠然小调

用万用表量量

プ汏坏疍

呵呵，用arduino这样玩数码管，真的很神！赞一下！

幻生幻灭

弘毅,你太耐亲了！你都可以出书了！

xzmoji

跟2楼一样，我也没看懂(n/x/1000)%10

xzmoji

我终于知道了，数码管在同一时刻4位只能显示同一数字，即1111、2222……，如果要显示1324，就要
①先关第2~4位，第1位显示“1”，延时。
①先关第1、3、4位，第2位显示“3”，延时。
①先关第1、2、4位，第3位显示“2”，延时。
①先关第1~3位，第4位显示“4”，延时。
调节延时的时间，让人眼分辨不出它在闪烁。
我的理解对吗？斑竹

bigtreelbq

用analogwrite不就可以去掉电阻吗

骷髅

悠然小调 发表于 2011-8-8 16:45
n/x/1000)%10这没看懂，开始时n=0

求解，这句的意思看懂没有呢

hk386

斑竹啊，数字脚一般的0 1不是不用做输出的吗，这次怎么用了

弘毅

hk386 发表于 2012-10-8 17:40
斑竹啊，数字脚一般的0 1不是不用做输出的吗，这次怎么用了

额。。。当年不知道模拟口可以当数字口用。。。端口不够用，所以就都用了。其实。。可以用A0,A1等。。。