从零开始 开关计数器（4位数码管的控制）

hxf

       楼主有一个朋友最近购置了一批游乐设施，想知道这些设施每天的工作情况，于是拜托楼主做一个计数器，记录下开机次数和开机时间。

初步方案（方案一）：3641共阳极四位数码管+arduino+开关   实现简单的计数功能并显示
先查阅了一些关于数码管的资料，推荐一个讲的比较详细的   http://bbs.elecfans.com/jishu_455250_1_1.html
接下来是接线，只需要在原图上稍作改动即可：

程序同样是在原作者程序上稍作了些改动，感谢开源的arduino：

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

复制代码

eysajan

程序写得很详细，但是这样写太麻烦了吧？

hxf

eysajan 发表于 2015-7-7 17:05
程序写得很详细，但是这样写太麻烦了吧？

恩，也可以自己尝试建立库文件

eysajan

hxf 发表于 2015-7-7 17:09
恩，也可以自己尝试建立库文件

也没必要库文件，没必要每一个数字设计几行代码，用for循环可以简化接口定义和输出状态。用字符串可以设定每一个数字的高低电平，那样可以把这个程序简化好多。这是我做的温度控制器方案，参考一下。

1. #include <Arduino.h>
   
2. #define termo A0   
   
3. #define Reli  0      
   
4. #define Reli1 1   
   
5. 
   
6. #define Put_A 2
   
7. #define Put_B 3
   
8. #define Put_C 4
   
9. #define Put_D 5
   
10. #define Put_E 6
    
11. #define Put_F 7
    
12. #define Put_G 8
    
13. #define Put_H 9
    
14. 
    
15. #define Hane1 10
    
16. #define Hane2 11
    
17. #define Hane3 12
    
18. #define Hane4 13
    
19. 
    
20. int tengshek=0;
    
21. int asti=0;
    
22. int usti=0;
    
23. 
    
24. int chong=40;  
    
25. int kichik=20;
    
26. int halet=0;  
    
27. int ter = 0;         
    
28. int temp = 0;               
    
29. unsigned char jedwel[14][7] =
    
30. {/*   
    
31.                aaaaaaa     
    
32.             ff              bb   
    
33.             ff              bb   
    
34.             ff              bb  
    
35.              ggggggg
    
36.             ee            cc
    
37.             ee            cc
    
38.             ee            cc
    
39.              ddddddd    hh*/
    
40. /*{a  ,   b  ,   c  ,   d  ,   e  ,   f  ,   g },   */
    
41.   {1  ,   1  ,   1  ,   1  ,   1  ,   1  ,   0 },   //0     0
    
42.   {0  ,   1  ,   1  ,   0  ,   0  ,   0  ,   0 },   //1     1
    
43.   {1  ,   1  ,   0  ,   1  ,   1  ,   0  ,   1 },   //2     2
    
44.   {1  ,   1  ,   1  ,   1  ,   0  ,   0  ,   1 },   //3     3
    
45.   {0  ,   1  ,   1  ,   0  ,   0  ,   1  ,   1 },   //4     4
    
46.   {1  ,   0  ,   1  ,   1  ,   0  ,   1  ,   1 },   //5     5
    
47.   {1  ,   0  ,   1  ,   1  ,   1  ,   1  ,   1 },   //6     6
    
48.   {1  ,   1  ,   1  ,   0  ,   0  ,   0  ,   0 },   //7     7
    
49.   {1  ,   1  ,   1  ,   1  ,   1  ,   1  ,   1 },   //8     8
    
50.   {1  ,   1  ,   1  ,   1  ,   0  ,   1  ,   1 },   //9     9
    
51.   {1  ,   1  ,   1  ,   0  ,   1  ,   1  ,   1 },   //A   10
    
52.   {0  ,   1  ,   1  ,   1  ,   1  ,   1  ,   0 },   //U   11
    
53.   {0  ,   1  ,   1  ,   0  ,   1  ,   1  ,   1 },   //H   12
    
54.   {0  ,   0  ,   0  ,   0  ,   0  ,   0  ,   1 }    //-   13
    
55. };
    
56. 
    
57. unsigned char hane_jedwel[4][4] ={{0,1,1,1},{1,0,1,1},{1,1,0,1},{1,1,1,0}};
    
58. void setup()
    
59.   {         pinMode(Put_A  ,   OUTPUT);               
    
60.         pinMode(Put_B  ,   OUTPUT);
    
61.         pinMode(Put_C  ,   OUTPUT);
    
62.         pinMode(Put_D  ,   OUTPUT);
    
63.         pinMode(Put_E  ,   OUTPUT);
    
64.         pinMode(Put_F  ,   OUTPUT);
    
65.         pinMode(Put_G  ,   OUTPUT);
    
66.         pinMode(Put_H  ,   OUTPUT);
    
67.         pinMode(Reli   ,      OUTPUT);
    
68.         pinMode(Reli1  ,     OUTPUT);
    
69.         pinMode(Hane1  ,   OUTPUT);
    
70.         pinMode(Hane2  ,   OUTPUT);
    
71.         pinMode(Hane3  ,   OUTPUT);
    
72.         pinMode(Hane4  ,   OUTPUT);}
    
73. void loop()
    
74.   {    tengshek=analogRead(1);  
    
75.    asti=analogRead(2);  
    
76.    usti=analogRead(3);   
    
77.    ter = analogRead(termo);            
    
78.    temp = ter * 4.8876;               
    
79.   if(temp/10>chong)
    
80.   digitalWrite(Reli  ,  LOW);  
    
81.   else digitalWrite(Reli  ,  HIGH);
    
82.    if(temp/10<kichik)
    
83.   digitalWrite(Reli1  ,  LOW);
    
84.   else digitalWrite(Reli1  ,  HIGH);  
    
85. if (tengshek>900)
    
86.          {delay(20);
    
87.           halet++;  
    
88. if (halet==3)
    
89.           halet=0;};
    
90. if (usti>900)
    
91.    {delay(100);
    
92.      if(halet==1)
    
93.           chong++;
    
94.           else if(halet==2)
    
95.           kichik++;    };  
    
96. if (asti>900)
    
97.    {delay(100);
    
98.      if(halet==1)
    
99.           chong--;
    
100. else if(halet==2)
     
101.           kichik--;    };
     
102. switch(halet)
     
103. {case 0:  
     
104.         Korsitish(0  ,   12);                        //H
     
105.         delay(3);
     
106.         Korsitish(1  ,   temp/100%10);                 
     
107.         delay(3);
     
108.         Korsitish(2  ,   temp/10%10);                     
     
109.         delay(3);
     
110.         Korsitish(3  ,   temp%10);                     
     
111.         delay(3);
     
112.         break;
     
113. case 1:
     
114.         Korsitish(0  ,   11);                        //U
     
115.         delay(3);
     
116.         Korsitish(1  ,   13);                        //-
     
117.         delay(3);
     
118.         Korsitish(2  ,   chong/10%10);                     
     
119.         delay(3);
     
120.         Korsitish(3  ,   chong%10);                       
     
121.         delay(3);
     
122.         break;
     
123. case 2:
     
124.         Korsitish(0  ,   10);                        //A
     
125.         delay(3);
     
126.         Korsitish(1  ,   13);                        //-
     
127.         delay(3);
     
128.         Korsitish(2  ,  kichik/10%10);               
     
129.         delay(3);
     
130.         Korsitish(3  ,  kichik%10);                  
     
131.         delay(3);
     
132.         break;}}
     
133. 
     
134. void Korsitish(int Hane  ,   int reqem)                 
     
135.   {        digitalWrite(Put_A  ,   LOW);                  
     
136.         digitalWrite(Put_B  ,   LOW);
     
137.         digitalWrite(Put_C  ,   LOW);
     
138.         digitalWrite(Put_D  ,   LOW);
     
139.         digitalWrite(Put_E  ,   LOW);
     
140.         digitalWrite(Put_F  ,   LOW);
     
141.         digitalWrite(Put_G  ,   LOW);
     
142.         digitalWrite(Put_H  ,   LOW);
     
143.    
     
144.         digitalWrite(Hane1  ,   hane_jedwel[Hane][0]);
     
145.         digitalWrite(Hane2  ,   hane_jedwel[Hane][1]);
     
146.         digitalWrite(Hane3  ,   hane_jedwel[Hane][2]);
     
147.         digitalWrite(Hane4  ,   hane_jedwel[Hane][3]);
     
148.      
     
149.         digitalWrite(Put_A  ,   jedwel[reqem][0]);        
     
150.         digitalWrite(Put_B  ,   jedwel[reqem][1]);
     
151.         digitalWrite(Put_C  ,   jedwel[reqem][2]);
     
152.         digitalWrite(Put_D  ,   jedwel[reqem][3]);
     
153.         digitalWrite(Put_E  ,   jedwel[reqem][4]);
     
154.         digitalWrite(Put_F  ,   jedwel[reqem][5]);
     
155.         digitalWrite(Put_G  ,   jedwel[reqem][6]);
     
156.         if(halet==0&&Hane==2)         
     
157.         digitalWrite(Put_H  ,   HIGH);
     
158.         else digitalWrite(Put_H  ,   LOW);}

复制代码

来源 http://alip.biz/forum.php?mod=vi ... page%3D2&page=1

hxf

eysajan 发表于 2015-7-7 17:18
也没必要库文件，没必要每一个数字设计几行代码，用for循环可以简化接口定义和输出状态。用字符串可以设 ...

牛，很不错的思路啊

hxf

eysajan 发表于 2015-7-7 17:18
也没必要库文件，没必要每一个数字设计几行代码，用for循环可以简化接口定义和输出状态。用字符串可以设 ...

不过我那样做是因为后期想通过74hc595进行一下IO口扩展

eysajan

hxf 发表于 2015-7-7 17:40
不过我那样做是因为后期想通过74hc595进行一下IO口扩展

用74HC595的话更简单了，代码更短

1. #include <Arduino.h>
   
2. #define tengshex 2
   
3. #define asti         3
   
4. #define usti         4
   
5. #define clockPin  5
   
6. #define latchPin  6
   
7. #define reqem    7
   
8. #define hane      8
   
9. int chong=40;
   
10. int kichik=20;
    
11. int halet=0;
    
12. int ad = 0;        
    
13. int temp = 0;        
    
14.                                   //0,1 ,2 , 3 , 4 , 5 , 6 , 7 , 8 ,  9
    
15. unsigned char reqem_jedwel[10] ={252,96,218,242,102,182,190,224,254,246};
    
16. void setup()
    
17.   {         pinMode(clockPin ,      OUTPUT);               
    
18.         pinMode(latchPin ,              OUTPUT);
    
19.         pinMode(reqem  ,            OUTPUT);
    
20.         pinMode(hane ,               OUTPUT);
    
21.         pinMode(tengshex,INPUT_PULLUP);
    
22.         pinMode(asti  ,       INPUT_PULLUP);
    
23.         pinMode(usti  ,       INPUT_PULLUP);}
    
24. void loop()
    
25.   { if(digitalRead(tengshex) == LOW)
    
26.          {delay(20);
    
27.           halet++;
    
28. if (halet==3)
    
29.           halet=0; };
    
30. if(digitalRead(asti) == LOW)
    
31. {delay(20);
    
32.      if(halet==1)
    
33.           chong--;
    
34.           else if(halet==2)
    
35.           kichik--;    };
    
36. if(digitalRead(usti) == LOW)
    
37.    {delay(100);
    
38.      if(halet==1)
    
39.           chong++;
    
40. else if(halet==2)
    
41.           kichik++;    };
    
42.    ad= analogRead(A0);                        
    
43.    temp = ad* 4.8876;                        
    
44. switch(halet)
    
45. {case 0:
    
46.         Korsitish(7  ,   110);               
    
47.         delay(3);
    
48.         Korsitish(11 ,   reqem_jedwel[temp/100%10]);        
    
49.         delay(3);
    
50.         Korsitish(13 ,   reqem_jedwel[temp/10%10]+128);        
    
51.         delay(3);
    
52.         Korsitish(14  ,   reqem_jedwel[temp%10]);               
    
53.         delay(3);
    
54.         break;
    
55. case 1:
    
56.         Korsitish(7  ,   124);               
    
57.         delay(3);
    
58.         Korsitish(11  ,   2);               
    
59.         delay(3);
    
60.         Korsitish(13,   reqem_jedwel[chong/10%10]);        
    
61.         delay(3);
    
62.         Korsitish(14 ,   reqem_jedwel[chong%10]);        
    
63.         delay(3);
    
64.         break;
    
65. case 2:
    
66.         Korsitish(7  ,   238);               
    
67.         delay(3);
    
68.         Korsitish(11  ,   2);               
    
69.         delay(3);
    
70.         Korsitish(13 ,  reqem_jedwel[kichik/10%10]);        
    
71.         delay(3);
    
72.         Korsitish(14 ,  reqem_jedwel[kichik%10]);               
    
73.         delay(3);
    
74.         break;}    }
    
75. void Korsitish(unsigned char _Hane  ,   unsigned char _reqem)        
    
76.   {          /*  if(temp/10<kichik)  _Hane&=16;
    
77.             if(temp/10<chong&&temp/10>kichik) _Hane&=32;
    
78.             if(temp/10>chong) _Hane&=64;*/
    
79.     digitalWrite(latchPin,LOW);
    
80.     shiftOut(hane ,clockPin,MSBFIRST,_Hane);
    
81.     shiftOut(reqem ,clockPin,MSBFIRST,_reqem);
    
82.     digitalWrite(latchPin,HIGH); }

复制代码

lm4766

占用IO口多，程序又太罗嗦