菜鸟求助，GP2Y1010AU0F与Arduino怎么连接？

hi55234

1、GP2Y1010AU0F的针脚是怎么定义的？
看数据手册（https://www.sparkfun.com/datasheets/Sensors/gp2y1010au_e.pdf），内部示意图这样的：

按照本菜鸟的理解，对应的针脚就是1、3、2、6、5、4


按照外形尺寸的图：

按照本菜鸟的理解，对应的针脚就变成了是1、2、3、4、5、6

2、这个针脚是怎么和Arduino连接的？

按照本菜鸟的理解，这个是PNP三极管，目测V1(E极)>V3(B极)>V2(C极),同时V3决定了LED是否发光（是控制端）

网上关于各个针脚的连接方法是这么说的（http://www.guokr.com/article/434130/）：
Sharp pin 1 (V-LED) => 5V (通过一个150欧的电阻连接)
Sharp pin 2 (LED-GND) => Arduino GND pin
Sharp pin 3 (LED) => Arduino pin 2
Sharp pin 4 (S-GND) => Arduino GND pin
Sharp pin 5 (Vo) => Arduino A0 pin
Sharp pin 6 (Vcc) => 5V

但看到大神的连接图时（http://www.geek-workshop.com/for ... thread&tid=4848），顿时凌乱了：


即：
1——V-LED——5V (通过一个150欧的电阻连接)
2——LED-GND——Arduino A0 pin
3——LED——Arduino GND pin
4——S-GND——Arduino pin 2
5——VO——Arduino GND pin
6——VCC——5V

怎么感觉和文字说明对不上号呢？请各位坛友不吝赐教

____________分割线_____20131214________________________
用GP2Y1010AU0F+Arduino pro min+ CP2102+74hc595 两片+四位时钟数码管+面包板(成本75元一个的样子) 做了2个pm2.5检测
目测稳定性还是有那么一点的(东西直接插面包板上,电容两端电压4.48v的4.75v,坑爹啊,统一电脑的相邻usb口取的电,只能说线没接好,面包板内阻也有差异,不过只要粉尘头上了电容滤波,实际看数据,模拟口处的电压的差异也就4个单位的样子,小于0.015V)
端口读取的图:


实际连接的样子:


----------------------分割线_____20131218--------------------------------
用SprintLayout画了个pcb

i7456

（1）        夏普GP2Y1010AU0F_粉尘传感器（按图示方式放置，从左到右分别为1~6脚）
Sharp pin 1 (V-LED) => 5V (串联150Ω电阻，pin 1和电阻之间连220μF电容接地);
Sharp pin 2 (LED-GND) => Arduino GND脚;
Sharp pin 3 (LED) => Arduino 数字口pin 2 ;
Sharp pin 4 (S-GND) => Arduino GND 脚;
Sharp pin 5 (Vo) => Arduino 模拟口A0pin;
Sharp pin 6 (Vcc) => 5V;

人家有说明的，接线的说明和数据手册是对应得起来的。

lariver

楼主，可以看这一篇非常详细的设置教程，Arduino+GP2Y1010空气质量监测方案，http://tuding.iego.cn:8001/archives/98

hi55234

昨天淘宝买的，CP2102和pro mini到了，手工极差，却很有毅力的菜鸟开始干活

前前后后的差不多用了6小时，就成了这副模样：





除开焊点与排针外，感觉工艺还可以~~~

短接RXD与TXD，运行USB-TTL测试工具，蒙苍天垂怜，一切正常

hi55234

焊完了CP2102模块 开始焊pro mini，确实很小，对于俺这种苦手来说，真心伤不起····


背面一览


其实这货长这样子：


PS：为啥有的针没有焊好呢？因为焊好了，经过多次插拔与摔打，就成了这样子，好在不影响啥~~~
PS2：就是这个不影响，让俺从昨晚10点一直折腾到今天18:00······

hi55234

然后，既然都焊接好了，就该上机连接了吧~~

装好java JDK，下个绿色版的1.0.4，然后下程序，我下，我下，死活下不了，经典的avrdude: stk500_getsync(): not in sync: resp=0x00错误~~~

按道理来讲，俺是照着大神的教程来的，CTS接RST这种事还是知道的，可是，可是，还是下载不进去····一上午就这么纠结过去了

俺就是参照这个链接的（CP2102啥的，需要CTS接口啥的，都是拜这位大神指点）：

原帖：http://www.geekfans.com/thread-63037-1-1.html


到了下午，淘宝上买的万用表到了，好了，看看是啥问题吧，

1、曾经一度怀疑CP2102被俺焊残废了，原因在于TX0-TXD这个在下载程序的时候没有电压变化~~~~不过USB-TTL测试工具运行的时候用电压表测试发现电压是会跳动的~~~所以CP2102是好的，可是，没道理啊，同样的解法，为啥俺就下载不了。

2、难道是pro mini被俺焊残废了？好在俺pro mini一次买了2片（当时是为了防止bootloader被俺搞残废了，网上大神说arduino是可以为arduino刷bootloader的），另外一片测试，依旧写不上去~~~

3、开始怀疑是arduino IDE的问题，1.0.5、1.0.4、1.0.1轮番试过，依旧无解

百般无奈之下考试测各个接口的电压，发现2个TX0的电压竟然不一致，一个2.5V、一个0.13V，怎么可能呢？一条导线联通的2点，竟然电压会不一致！！！拆开来看看，尼玛，TX0已经送了，当然，TX0只是众多松了的接口之一。速度飞线修正，烙铁也在今日早些时候归西，万幸人每受伤（平安是福啊）~~~

修正之后再次下载程序，是不是就OK了呢？果断不是啊，依旧是 resp=0x00错误~~~~

万般无奈之下，再次求助googol
发现一篇文章：

单片机串口通讯RXD与TXD如何对接详解（独家！）
http://blog.csdn.net/sdwuyulunbi/article/details/6632382

说的就是有时候是TX0接TXD，有时候是TX0接RXD，怎么接，本菜鸟傻傻分不清楚，得，倒过来试试，再次下载：


泪奔啊，终于下载成功~~~

hi55234

附上链接图一张：


至于手动按REST：通过万用表的电压变化，个人的理解是，按下rest，pro mini的rest电压发生变化，以此通知cp2102已经做好准备，可以传输数据了，按得时机那网友的话来说就是出现：使用xx字节，xx字节可用的提示的时候········

hi55234

hi55234

下面是关于自定义变量的问题：

int dustPin=1;//A0没焊好，就用了A1接口
int dustVal=0;

int ledPower=2;
int delayTime=280;
int delayTime2=40;
float offTime=9680;
void setup(){
Serial.begin(9600);
pinMode(ledPower,OUTPUT);
pinMode(4, OUTPUT);//这一行就本阶段来说目测是废的，因为数字口4，根本没接任何东西，即便注释掉也没问题
}

void loop(){
// l接下来6行，就是粉尘探测的程序
digitalWrite(ledPower,LOW); // power on the LED
delayMicroseconds(delayTime);
dustVal=analogRead(dustPin); // read the dust value via pin 5 on the sensor
delayMicroseconds(delayTime2);
digitalWrite(ledPower,HIGH); // turn the LED off
delayMicroseconds(offTime);

delay(3000);
Serial.println(dustVal);//所得到的dustVal是1024中德一个数字，一个单位代表5/1024伏特

float dustVal3=dustVal;
dustVal3=dustVal*5/1024;
Serial.println(dustVal3);//这个的结果就是0.00，自定义变量能定义却不能与其他自定义变量进行运算

float dustVal4=dustVal;
dustVal4=dustVal4*5/1024;
Serial.println(dustVal4);//这个却能得出正确的结果（作为人类的智商优越感瞬间爆棚，有木有！！）


float dustVal5=dustVal;
dustVal5=dustVal5*5/1024;
Serial.println(dustVal5);//这个的结果就是0，电压不足1V，取整导致为0


float dustVal6=dustVal3;
dustVal6=dustVal6*5/1024;
Serial.println(dustVal6);//自变量的传递，结果0.00，可见自变量不能传递，dustVal6=dustVal3无效，准备的说是dustVal3的值无效

float dustVal7=dustVal;
dustVal7=dustVal7*5/1024;
Serial.println(dustVal7);//第二次引用，得出正确的结果（dustVal7=dustVal有效），个人觉得更准确的说法是，如果自变量的值没有外部数据作为支撑，那么这个值只能本次自己用，且不能被传递
delay(3000);

}

hi55234

目前程序的样子：

int dustPin=1;
int dustVal=0;

int ledPower=2;
int delayTime=280;
int delayTime2=40;
float offTime=9680;
void setup(){
Serial.begin(9600);
pinMode(ledPower,OUTPUT);
//pinMode(4, OUTPUT);
}

void loop(){
// ledPower is any digital pin on the arduino connected to Pin 3 on the sensor
digitalWrite(ledPower,LOW); // power on the LED
delayMicroseconds(delayTime);
dustVal=analogRead(dustPin); // read the dust value via pin 5 on the sensor
delayMicroseconds(delayTime2);
digitalWrite(ledPower,HIGH); // turn the LED off
delayMicroseconds(offTime);

delay(3000);
Serial.println(dustVal);


float dustVal2=dustVal;
dustVal2=(dustVal2*5/1024-0.0356)*120000;
Serial.println(dustVal2);//实际的颗粒数

if(dustVal2<76)
{
Serial.println("EXCELLENT");
}
else if(dustVal2<151)
{
Serial.println("VERY GOOD");
}
else if(dustVal2<301)
{
Serial.println("GOOD");
}
else if(dustVal2<1051)
{
Serial.println("FAIR");
}
else if(dustVal2<3001)
{
Serial.println("POOR");
}
else
{
Serial.println("VERY POOR");
}


if(dustVal>118)
//此拟合公式有效y=0.172*x-0.0999
{
float dustVal3=dustVal;
dustVal3=((dustVal3*5/1024)*0.172-0.0999)*1000;
Serial.println("PM2.5:");
Serial.println(dustVal3);//实际的颗粒数
}
else
{
Serial.println("PM2.5:");
Serial.println("----");
}



}

hi55234

公司悲催的空气质量
~~~~~~~~~~~~~~~~~~
传说中的指针

1. 
   
2. void setup() {               
   
3. Serial.begin (9600);
   
4. }
   
5. 
   
6. // the loop routine runs over and over again forever:
   
7. void loop() {
   
8. int a,b;
   
9.   int *pointer_1, *pointer_2;
   
10.   a=100;b=10;
    
11.   pointer_1=&a;
    
12. pointer_2=&b;
    
13. 
    
14.   delay (1000);
    
15.    Serial.print ("a=");
    
16.    Serial.println (a);
    
17.     Serial.print ("b=");
    
18.    Serial.println (b);
    
19.       Serial.print ("*pointer_1=");
    
20.    Serial.println (*pointer_1);
    
21.     Serial.print ("*pointer_2=");
    
22.    Serial.println (*pointer_2);
    
23. }

复制代码

---------------------------------------------
C语言的printf目测在arduino中不能打印
---------------------------------------------
指针与数组

1. int xx[5] = {1,2,3,4,5};
   
2. int *pa;
   
3. int *pa2;
   
4. 
   
5. void setup() {               
   
6. Serial.begin (9600);
   
7. }
   
8. 
   
9. // the loop routine runs over and over again forever:
   
10. void loop() {
    
11. pa=xx;
    
12. pa2=&xx[0];
    
13. 
    
14.   delay (1000);
    
15. 
    
16. Serial.println (*pa);
    
17.    Serial.println (*(pa+1));
    
18.    Serial.println (*(pa+2));
    
19.     Serial.println (*(pa+3));
    
20.     Serial.println (*(pa+4));
    
21.   
    
22.   
    
23.   Serial.println (*pa2);
    
24.    Serial.println (*(pa2+1));
    
25.    Serial.println (*(pa2+2));
    
26.     Serial.println (*(pa2+3));
    
27.     Serial.println (*(pa2+4));
    
28.    
    
29.        Serial.println ("-----------------");
    
30. }

复制代码

-------------
char 与指针

1. 
   
2. const char *pa = "arduino";
   
3. 
   
4. void setup() {               
   
5. Serial.begin (9600);
   
6. }
   
7. 
   
8. 
   
9. void loop() {
   
10. 
    
11.   delay (1000);
    
12. 
    
13. Serial.println (*pa);
    
14.    Serial.println (*(pa+1));
    
15.    Serial.println (*(pa+2));
    
16.     Serial.println (*(pa+3));
    
17.     Serial.println (*(pa+4));
    
18.    Serial.println (*(pa+5));
    
19.    Serial.println (*(pa+6));
    
20. 
    
21.            Serial.println ("-----------------");
    
22. 
    
23.        Serial.print (*pa);
    
24.    Serial.print (*(pa+1));
    
25.    Serial.print (*(pa+2));
    
26.     Serial.print (*(pa+3));
    
27.     Serial.print (*(pa+4));
    
28.    Serial.print (*(pa+5));
    
29.    Serial.println (*(pa+6));
    
30.         Serial.println ("-----------------");
    
31. }

复制代码

char *pc;
pc = "C Language"; 貌似arduino编译不过

char *pc="C Language";就没有问题

--------------------
指针变量的减法，（数组）元素个数差，仅有指定个数且填满了的数组才有意义

1. int xx[5] = {1,2,3,4,5};
   
2. int yy[10] = {1,2,3,4,5,6,7,8,9,0};
   
3. int zz[] = {1,2,3,4,5,6,7,8,9};
   
4. int nn[10] = {1,2,3,4,5};
   
5. 
   
6. 
   
7. int *pa,*pa2,*pa3,*pa4;
   
8. 
   
9. void setup() {               
   
10. Serial.begin (9600);
    
11. }
    
12. 
    
13. // the loop routine runs over and over again forever:
    
14. void loop() {
    
15. pa=xx;
    
16. pa2=yy;
    
17. pa3=zz;
    
18. pa4=nn;
    
19. int x=pa2-pa;
    
20. int y=pa3-pa;
    
21. int z=pa4-pa;
    
22.   delay (1000);
    
23. Serial.println (x);
    
24.   Serial.println (y);
    
25.   Serial.println (z);
    
26.        Serial.println ("-----------------");
    
27. }

复制代码

-----------------------------------------------
  int a=10,b=20,s,t,*pa,*pb; /*说明pa,pb为整型指针变量*/
  pa=&a;                     /*给指针变量pa赋值，pa指向变量a*/
  pb=&b;                     /*给指针变量pb赋值，pb指向变量b*/
  s=*pa+*pb;                 /*求a+b之和,(*pa就是a,*pb就是b)*/
  t=*pa**pb;                 /*本行是求a*b之积*/

p的初值为&a[0],*(p+i)与*(a+i)等价

1. int xx[5] = {1,2,3,4,5};
   
2. 
   
3. 
   
4. 
   
5. int *pa,*pa2,*pa3,*pa4;
   
6. 
   
7. void setup() {               
   
8. Serial.begin (9600);
   
9. }
   
10. 
    
11. // the loop routine runs over and over again forever:
    
12. void loop() {
    
13. pa=xx;
    
14. 
    
15. 
    
16. Serial.println (*xx);
    
17.   Serial.println (*pa);
    
18. Serial.println (*(xx+1));
    
19.   Serial.println (*(pa+1));
    
20.        Serial.println ("-----------------");
    
21.        delay (1000);
    
22. }

复制代码

------------------------------------------------
三种方式定义数组，另外不打括号的for循环就只管下面一排

1. 
   
2. void setup() {               
   
3. Serial.begin (9600);
   
4. }
   
5. 
   
6. 
   
7. void loop() {
   
8.   int a[10],i;
   
9.   for(i=0;i<10;i++)
   
10.     a[i]=i;
    
11.   for(i=0;i<10;i++)
    
12.   Serial.print (a[i]);
    
13.   Serial.print (",");
    
14. 
    
15. Serial.println ();
    
16. delay (1000);
    
17. Serial.println ("-----------------1");
    
18. 
    
19.   int aa[10];
    
20.   for(i=0;i<10;i++)
    
21.     *(aa+i)=i;
    
22.   for(i=0;i<10;i++)
    
23. Serial.print (*(aa+i));
    
24. Serial.print (",");
    
25. 
    
26. Serial.println ();
    
27. delay (1000);
    
28. Serial.println ("-----------------2");
    
29. 
    
30.   int aaa[10],*p;
    
31.   p=aaa;
    
32.   for(i=0;i<10;i++)
    
33.     *(p+i)=i;
    
34.   for(i=0;i<10;i++)
    
35. Serial.print (*(p+i));
    
36. Serial.print (",");
    
37. 
    
38. Serial.println ();
    
39. delay (1000);
    
40. Serial.println ("-----------------3");
    
41. 
    
42. }

复制代码

hi55234

1. /*粉尘头的代码*/
   
2. int dustPin=0;//数字口p2控制模拟口A0读取粉尘电压
   
3. int dustVal=0;
   
4. int ledPower=2;
   
5. int delayTime=280;
   
6. int delayTime2=40;
   
7. float offTime=9680;
   
8. 
   
9. //定义一个只有2个元素的数组
   
10. int mySensVals [2];
    
11. //定义2个布尔变量，通过i的变化让粉尘电压值先进先出循环填入上数组，实现相邻采样平均
    
12. boolean i=0,j=0;
    
13. 
    
14. 
    
15. /*数码管与74hc595的代码*/
    
16. //数码管显示为0-9共10个数字，以便四位数码管显示调用
    
17. const byte DIGX_COUNT = 10;
    
18. unsigned int sequence[DIGX_COUNT] = {0x77,0x14,0x5B,0x5E,0x3C,0x6E,0x6F,0x54,0x7F,0x7E};
    
19. 
    
20. //接法：P5、P7、P9接第一片595（Q0-Q7对应数码管逆时针1、2、4、5、7、10、11、3（这个是点），第二片控制数码管共阴脚Q0-Q3接6、8、9、12）,
    
21. int latchPin = 8;  //Pin connected to ST_CP(pin 12) of 74HC595
    
22. int clockPin = 7; //Pin connected to SH_CP(pin 11) of 74HC595
    
23. int dataPin = 9;  //Pin connected to DS(pin 14) of 74HC595
    
24. 
    
25. //引入millis()来控制循环
    
26. unsigned long time1=millis();
    
27. 
    
28. 
    
29. //pm2.5的数值、AQI指数、灰尘数，相邻采样平均电压
    
30. float dustValPM25,AQI,dustnumber,averagedustVal;
    
31. 
    
32. 
    
33. 
    
34. 
    
35. void setup(){
    
36. Serial.begin(9600);
    
37. 
    
38. 
    
39. pinMode(ledPower,OUTPUT);//开启粉尘的控制端口
    
40. 
    
41. /*74HC595所涉及的3个端口*/
    
42. pinMode(latchPin, OUTPUT);
    
43. pinMode(clockPin, OUTPUT);
    
44. pinMode(dataPin, OUTPUT);
    
45.   
    
46. }
    
47. 
    
48. void loop(){
    
49. 
    
50. //最初的3秒内获得mySensVals [0]，第3秒的时候就可以计算averagedustVal
    
51. if(!j){
    
52.    /*粉尘头控制代码*/
    
53. digitalWrite(ledPower,LOW); //开灯
    
54. delayMicroseconds(delayTime);
    
55. dustVal=analogRead(dustPin); //读电压
    
56. delayMicroseconds(delayTime2);
    
57. digitalWrite(ledPower,HIGH); //关灯
    
58. delayMicroseconds(offTime);
    
59. 
    
60. mySensVals [i]=dustVal;//把检测到的第一次电压塞给mySensVals [0]
    
61. i=!i;//i值反转
    
62. j=1;//不再执行这个程序
    
63. 
    
64.   }
    
65.   
    
66.   
    
67. /*粉尘头取得的粉尘对应电压dustVal,每3秒循环一次*/
    
68. 
    
69. if (millis() - time1 > 3000){
    
70. time1=millis();
    
71. 
    
72. /*粉尘头控制代码*/
    
73. digitalWrite(ledPower,LOW); //开灯
    
74. delayMicroseconds(delayTime);
    
75. dustVal=analogRead(dustPin); //读电压
    
76. delayMicroseconds(delayTime2);
    
77. digitalWrite(ledPower,HIGH); //关灯
    
78. 
    
79. /*邻采样平均averagedustVal的计算*/
    
80. mySensVals [i]=dustVal;//把检测到的第一次电压塞给mySensVals [1]
    
81. i=!i;//i值反转
    
82. averagedustVal=(mySensVals [0]+mySensVals [1])*0.5;//计算平均电压
    
83. 
    
84. 
    
85. 
    
86. /*计算0.01 cubic feet的颗粒数：（v-0.0356）X120000
    
87. 对于电压低于8个单位的用线性，搞定值以下颗粒数为负数的情况*/
    
88. 
    
89. if(averagedustVal>8)dustnumber=(averagedustVal*5/1024-0.0356)*120000;
    
90. else dustnumber=averagedustVal*52;
    
91. 
    
92. 
    
93. /*计算pm2.5的数值 电压阀值以上用：(v*0.172-0.0999)*1000，阀值以下用线性，参考国外帖子，认为输出最低17，对应粉尘5000*/
    
94. 
    
95. //0.9V【184.5】线性pm：电压单位*0.298373984进行计算，依据为手册上无灰尘也有0.9V的电压
    
96. //0.78V【161】线性pm：电压单位*0.21931677行计算，颗粒数降低数/粉尘降低数值最大值
    
97. //0.69V【142】线性pm：电压单位*0.136338028行计算，颗粒数/粉尘值增速加快速上升
    
98. //((averagedustVal*5/1024)*0.172-0.0999)*1000公式实质是0.83984375*averagedustVal-99.9
    
99. 
    
100. if(averagedustVal>184.5)dustValPM25=0.83984375*averagedustVal-99.9;
     
101. else dustValPM25=averagedustVal*0.298373984;
     
102. 
     
103. 
     
104. /*AQI的计算，美国标准*/
     
105. 
     
106. if(dustValPM25<15.4) AQI=(50-0)/(15.4-0)*(dustValPM25-0)+0;
     
107. else if(dustValPM25<40.4) AQI=(100-51)/(40.4-15.5)*(dustValPM25-15.5)+51;
     
108. else if(dustValPM25<65.4) AQI=(150-101)/(65.4-40.5)*(dustValPM25-40.5)+101;
     
109. else if(dustValPM25<150.4) AQI=(200-151)/(150.4-65.5)*(dustValPM25-65.5)+151;
     
110. else if(dustValPM25<250.4) AQI=(300-201)/(250.4-150.5)*(dustValPM25-150.5)+201;
     
111. else if(dustValPM25<350.4) AQI=(400-301)/(350.4-250.5)*(dustValPM25-250.5)+301;
     
112. else AQI=(500-401)/(500.4-350.5)*(dustValPM25-350.5)+401;
     
113. 
     
114. 
     
115. 
     
116. 
     
117. }
     
118. 
     
119. 
     
120. 
     
121. //做一个保险,对应millis()溢出归零后,millis()<time1,则3秒检测一次循环终止的情况
     
122. if (millis() < time1){
     
123. time1=millis();
     
124. i=0;//重置i的值
     
125. j=0;//重置j的值
     
126. }
     
127. 
     
128. 
     
129. 
     
130.     /*计算任意数字（小于999）各上是什么数字*/
     
131.   
     
132.   float test=dustValPM25;
     
133.     int test1=test*0.01;
     
134.     int test2=test*0.1;
     
135.     int test3=test;
     
136.        
     
137.    
     
138. 
     
139.    
     
140.    //test小数点左边有0位，4位数码管最高2位第一位不显，第二位为0
     
141.   //（0.xx的情况）数字口控制两片74HC595进而控制4位时钟数码管
     
142.    if(test3==0){  
     
143.    int test4=test*10;//十分位上的数字，如0.12的1
     
144.    int test5=test*100-test4*10;//百分位上的数字，如0.12的2
     
145. 
     
146.     digitalWrite(latchPin, LOW);
     
147.     shiftOut(dataPin, clockPin, MSBFIRST, 0xFE); //shift out highbyte
     
148.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
149.     digitalWrite(latchPin, HIGH);
     
150. 
     
151.     digitalWrite(latchPin, LOW);
     
152.     shiftOut(dataPin, clockPin, MSBFIRST, 0xFD); //shift out highbyte
     
153.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
154.     digitalWrite(latchPin, HIGH);
     
155.    
     
156.     digitalWrite(latchPin, LOW);
     
157.     shiftOut(dataPin, clockPin, MSBFIRST, 0xFB); //shift out highbyte
     
158.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test3]); //shift out lowbyte
     
159.     digitalWrite(latchPin, HIGH);
     
160. 
     
161.     digitalWrite(latchPin, LOW);//加入小数点
     
162.     shiftOut(dataPin, clockPin, MSBFIRST, 0xF7); //shift out highbyte
     
163.     shiftOut(dataPin, clockPin, MSBFIRST,0x80); //shift out lowbyte
     
164.     digitalWrite(latchPin, HIGH);
     
165. 
     
166.    }
     
167.    //test小数点左边有1位,4位数码管最高1位第一位不显，第二位为test3
     
168.    //（x.xx的情况）数字口控制两片74HC595进而控制4位时钟数码管
     
169.    else if(test2==0){  
     
170. 
     
171.    int test4=test*10-test3*10;//十分位上的数字，如1.23的2
     
172.    int test5=test*100-test3*100-test4*10;//百分位上的数字，如1.23的3
     
173.    
     
174.     digitalWrite(latchPin, LOW);
     
175.     shiftOut(dataPin, clockPin, MSBFIRST, 0xFE); //shift out highbyte
     
176.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
177.     digitalWrite(latchPin, HIGH);
     
178. 
     
179.     digitalWrite(latchPin, LOW);
     
180.     shiftOut(dataPin, clockPin, MSBFIRST, 0xFD); //shift out highbyte
     
181.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
182.     digitalWrite(latchPin, HIGH);
     
183.    
     
184.     digitalWrite(latchPin, LOW);
     
185.     shiftOut(dataPin, clockPin, MSBFIRST, 0xFB); //shift out highbyte
     
186.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test3]); //shift out lowbyte
     
187.     digitalWrite(latchPin, HIGH);
     
188. 
     
189. 
     
190.     digitalWrite(latchPin, LOW);//加入小数点
     
191.     shiftOut(dataPin, clockPin, MSBFIRST, 0xF7); //shift out highbyte
     
192.     shiftOut(dataPin, clockPin, MSBFIRST,0x80); //shift out lowbyte     
     
193.     digitalWrite(latchPin, HIGH);
     
194.    
     
195.    }
     
196.     //test小数点左边有2位,4位数码管最高1位第一位test2
     
197.     //（xx.xx的情况）数字口控制两片74HC595进而控制4位时钟数码管
     
198.    else if(test1==0){
     
199.    
     
200.    int test4=test-test2*10;//个位上的数字，如12.34的2
     
201.    int test5=test*10-test2*100-test4*10;//十分位上的数字，如12.34的3
     
202.    int test6=test*100-test2*1000-test4*100-test5*10;//百分位上的数字  
     
203.        
     
204.     digitalWrite(latchPin, LOW);
     
205.     shiftOut(dataPin, clockPin, MSBFIRST, 0xFE); //shift out highbyte
     
206.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test6]); //shift out lowbyte
     
207.     digitalWrite(latchPin, HIGH);
     
208. 
     
209.     digitalWrite(latchPin, LOW);
     
210.     shiftOut(dataPin, clockPin, MSBFIRST, 0xFD); //shift out highbyte
     
211.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
212.     digitalWrite(latchPin, HIGH);
     
213.    
     
214.     digitalWrite(latchPin, LOW);
     
215.     shiftOut(dataPin, clockPin, MSBFIRST, 0xFB); //shift out highbyte
     
216.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
217.     digitalWrite(latchPin, HIGH);
     
218. 
     
219. 
     
220.     digitalWrite(latchPin, LOW);
     
221.     shiftOut(dataPin, clockPin, MSBFIRST, 0xF7); //shift out highbyte
     
222.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test2]); //shift out lowbyte
     
223.     digitalWrite(latchPin, HIGH);
     
224. 
     
225.     digitalWrite(latchPin, LOW);//加入小数点
     
226.     shiftOut(dataPin, clockPin, MSBFIRST, 0xF7); //shift out highbyte
     
227.     shiftOut(dataPin, clockPin, MSBFIRST,0x80); //shift out lowbyte
     
228.     digitalWrite(latchPin, HIGH);
     
229. 
     
230.    
     
231.    }
     
232. 
     
233. //test小数点左边有3位，如123.45，因为只有4位时钟数码管，所以只显示前3位，最高1位第一位不显，第二位为test1
     
234. //（xxx.x的情况，时钟数码管只有中间有小数点，所以变成了xxx）数字口控制两片74HC595进而控制4位时钟数码管
     
235.    else {
     
236.    int test4=test2-test1*10;//十位上的数字，如123.45的2
     
237.    int test5=test-test1*100-test4*10;//个分位上的数字，如123.45的3
     
238. 
     
239.     digitalWrite(latchPin, LOW);
     
240.     shiftOut(dataPin, clockPin, MSBFIRST, 0xFE); //shift out highbyte
     
241.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
242.     digitalWrite(latchPin, HIGH);
     
243. 
     
244.     digitalWrite(latchPin, LOW);
     
245.     shiftOut(dataPin, clockPin, MSBFIRST, 0xFD); //shift out highbyte
     
246.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
247.     digitalWrite(latchPin, HIGH);
     
248.    
     
249.     digitalWrite(latchPin, LOW);
     
250.     shiftOut(dataPin, clockPin, MSBFIRST, 0xFB); //shift out highbyte
     
251.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test1]); //shift out lowbyte
     
252.     digitalWrite(latchPin, HIGH);
     
253. 
     
254.    }
     
255.    
     
256.    
     
257.    
     
258.   
     
259. 
     
260.    
     
261.   
     
262.   
     
263.    /*计算任意数字（小于999）各上是什么数字--------------------end*/
     
264. 
     
265. 
     
266. 
     
267. }

复制代码

hi55234

注意：因为我做了2个pm2.5的·检测，2个接74HC595的数字口有差异，所以接法与注释有差异，不过也就是595的差异，实际接法以程序为准

1. 
   
2. /*
   
3. 功能：四位12脚共阴数码管，实时循环显示所测定的PM2.5值\AQI\颗粒数\温度四个值,并驱动LED等在显示不同的值的时候显示不同的颜色
   
4. 
   
5. 链接方式：
   
6. CP2102~~~~Pro mini：
   
7. GND-GND、5V-Vcc、TXD-RX1、RXD-TX0、CTS-GRN（rest）
   
8. 
   
9. Pro mini~~~GP2Y1010AU0F：
   
10. 5V-150欧-（V-LED）
    
11. 5V-150欧—Vcc
    
12. 5V-150欧-220uF-GND
    
13. GND-（LED-GND）
    
14. GND-（S-GND）
    
15. Pin2-LED
    
16. A0-Vo
    
17. 
    
18. Pro mini~~~74HC595（片1）：
    
19. Pin8-ST_CP(pin 12)
    
20. Pin7-SH_CP(pin 11)
    
21. Pin9-DS(pin 14)
    
22. GND-pin13【EN允许输出】
    
23. GND-pin8【GND】
    
24. Vcc-pin10【CR不清除】
    
25. Vcc-pin16【Vcc】
    
26. 
    
27. Pro mini~~~74HC595（片2）：
    
28. Pin8-ST_CP(pin 12)
    
29. Pin7-SH_CP(pin 11)
    
30. GND-pin13【EN允许输出】
    
31. GND-pin8【GND】
    
32. Vcc-pin10【CR不清除】
    
33. Vcc-pin16【Vcc】
    
34. 
    
35. 
    
36. 74HC595（片1）~~~74HC595（片2）：
    
37. Pin9【Q7s】-DS(pin 14)
    
38. 
    
39. 74HC595（片1）~~~四位12脚共阴数码管
    
40. Q0-Pin1（逆时针）
    
41. Q1-Pin2（逆时针）
    
42. Q2-Pin4（逆时针）
    
43. Q3-Pin5（逆时针）
    
44. Q4-Pin7（逆时针）
    
45. Q5-Pin10（逆时针）
    
46. Q6-Pin11（逆时针）
    
47. Q7-Pin3（逆时针，这个控制小点）
    
48. 
    
49. 74HC595（片2）~~~四位12脚共阴数码管
    
50. Q0-Pin6（逆时针DIG4）
    
51. Q1-Pin8（逆时针DIG3）
    
52. Q2-Pin9（逆时针DIG2）
    
53. Q3-Pin12（逆时针DIG1）
    
54. Q4-LED蓝
    
55. Q5-LED绿
    
56. Q6-LED红
    
57. 
    
58. */
    
59. 
    
60. 
    
61. 
    
62. /*DS18B20的代码*/
    
63. //调用外部的2个库文件
    
64. #include <OneWire.h>
    
65. #include <DallasTemperature.h>
    
66. // DS18B20的数据接口pin3
    
67. #define ONE_WIRE_BUS 3
    
68. // Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
    
69. OneWire oneWire(ONE_WIRE_BUS);
    
70. // Pass our oneWire reference to Dallas Temperature.
    
71. DallasTemperature sensors(&oneWire);
    
72. 
    
73. /*粉尘头的代码*/
    
74. int dustPin=0;//数字口p2控制模拟口A0读取粉尘电压
    
75. int dustVal=0;
    
76. int ledPower=2;
    
77. int delayTime=280;
    
78. int delayTime2=40;
    
79. float offTime=9680;
    
80. 
    
81. //定义一个只有2个元素的数组
    
82. int mySensVals [2];
    
83. //定义2个布尔变量，通过i的变化让粉尘电压值先进先出循环填入上数组，实现相邻采样平均
    
84. boolean i=0,j=0;
    
85. 
    
86. 
    
87. /*数码管与74hc595的代码*/
    
88. //数码管显示为0-9共10个数字，以便四位数码管显示调用
    
89. const byte DIGX_COUNT = 10;
    
90. unsigned int sequence[DIGX_COUNT] = {0x77,0x14,0x5B,0x5E,0x3C,0x6E,0x6F,0x54,0x7F,0x7E};
    
91. 
    
92. //接法：P5、P7、P9接第一片595（Q0-Q7对应数码管逆时针1、2、4、5、7、10、11、3（这个是点），第二片控制数码管共阴脚Q0-Q3接6、8、9、12）,
    
93. int latchPin = 8;  //Pin connected to ST_CP(pin 12) of 74HC595
    
94. int clockPin = 7; //Pin connected to SH_CP(pin 11) of 74HC595
    
95. int dataPin = 9;  //Pin connected to DS(pin 14) of 74HC595
    
96. 
    
97. //引入4个数组来控制第二片74hc595（即高位部分）
    
98. //rgb led接第二片的Q4-Q6脚（对应蓝、绿、红）,9蓝、A绿、B青、C红、D紫、E黄、F白
    
99. unsigned int DIG4[6] = {0x9E,0xAE,0xBE,0xCE,0xCE,0xFE};//控制四位数码管的DIG4位
    
100. unsigned int DIG3[6] = {0x9D,0xAD,0xBD,0xCD,0xCD,0xFD};
     
101. unsigned int DIG2[6] = {0x9B,0xAB,0xBB,0xCB,0xCB,0xFB};
     
102. unsigned int DIG1[6] = {0x97,0xA7,0xB7,0xC7,0xC7,0xF7};//控制四位数码管的DIG1位
     
103. 
     
104. 
     
105. //引入millis()来控制循环
     
106. unsigned long time1=millis();
     
107. unsigned long time2=millis();
     
108. 
     
109. //pm2.5的数值、AQI指数、灰尘数，相邻采样平均电压
     
110. float dustValPM25,AQI,dustnumber,averagedustVal;
     
111. 
     
112. //对显示的值究竟是PM2.5，AQI，粉尘颗粒数，温度进行切换
     
113. int xianshi=0;
     
114. 
     
115. 
     
116. 
     
117. void setup(){
     
118. Serial.begin(9600);
     
119. 
     
120. sensors.begin(); //DS18B20所涉及的代码,开始检测?
     
121. 
     
122. pinMode(ledPower,OUTPUT);//开启粉尘的控制端口
     
123. 
     
124. /*74HC595所涉及的3个端口*/
     
125. pinMode(latchPin, OUTPUT);
     
126. pinMode(clockPin, OUTPUT);
     
127. pinMode(dataPin, OUTPUT);
     
128.   
     
129.   
     
130. }
     
131. 
     
132. void loop(){
     
133. 
     
134. //最初的3秒内获得mySensVals [0]，第3秒的时候就可以计算averagedustVal
     
135. if(!j){
     
136.    /*粉尘头控制代码*/
     
137. digitalWrite(ledPower,LOW); //开灯
     
138. delayMicroseconds(delayTime);
     
139. dustVal=analogRead(dustPin); //读电压
     
140. delayMicroseconds(delayTime2);
     
141. digitalWrite(ledPower,HIGH); //关灯
     
142. delayMicroseconds(offTime);
     
143. 
     
144. mySensVals [i]=dustVal;//把检测到的第一次电压塞给mySensVals [1]
     
145. i=!i;//i值反转
     
146. j=1;//不再执行这个程序
     
147. 
     
148.   }
     
149.   
     
150.   
     
151. /*粉尘头取得的粉尘对应电压dustVal,每3秒循环一次*/
     
152. 
     
153. if (millis() - time1 > 3000){
     
154. time1=millis();
     
155. 
     
156. /*粉尘头控制代码*/
     
157. digitalWrite(ledPower,LOW); //开灯
     
158. delayMicroseconds(delayTime);
     
159. dustVal=analogRead(dustPin); //读电压
     
160. delayMicroseconds(delayTime2);
     
161. digitalWrite(ledPower,HIGH); //关灯
     
162. 
     
163. /*邻采样平均averagedustVal的计算*/
     
164. mySensVals [i]=dustVal;//把检测到的第一次电压塞给mySensVals [1]
     
165. i=!i;//i值反转
     
166. averagedustVal=(mySensVals [0]+mySensVals [1])*0.5;//计算平均电压
     
167. 
     
168. 
     
169. /*计算0.01 cubic feet的颗粒数：（v-0.0356）X120000
     
170. 对于电压低于8个单位的用线性，搞定值以下颗粒数为负数的情况*/
     
171. 
     
172. if(averagedustVal>8)dustnumber=(averagedustVal*5/1024-0.0356)*120000;
     
173. else dustnumber=averagedustVal*52;
     
174. 
     
175. 
     
176. /*计算pm2.5的数值 电压阀值以上用：(v*0.172-0.0999)*1000，阀值以下用线性，参考国外帖子，认为输出最低17，对应粉尘5000*/
     
177. 
     
178. //0.9V【184.5】线性pm：电压单位*0.298373984进行计算，依据为手册上无灰尘也有0.9V的电压
     
179. //0.78V【161】线性pm：电压单位*0.21931677行计算，颗粒数降低数/粉尘降低数值最大值
     
180. //0.69V【142】线性pm：电压单位*0.136338028行计算，颗粒数/粉尘值增速加快速上升
     
181. //((averagedustVal*5/1024)*0.172-0.0999)*1000公式实质是0.83984375*averagedustVal-99.9
     
182. 
     
183. if(averagedustVal>184.5)dustValPM25=0.83984375*averagedustVal-99.9;
     
184. else dustValPM25=averagedustVal*0.298373984;
     
185. 
     
186. 
     
187. /*AQI的计算，美国标准*/
     
188. 
     
189. if(dustValPM25<15.4) AQI=(50-0)/(15.4-0)*(dustValPM25-0)+0;
     
190. else if(dustValPM25<40.4) AQI=(100-51)/(40.4-15.5)*(dustValPM25-15.5)+51;
     
191. else if(dustValPM25<65.4) AQI=(150-101)/(65.4-40.5)*(dustValPM25-40.5)+101;
     
192. else if(dustValPM25<150.4) AQI=(200-151)/(150.4-65.5)*(dustValPM25-65.5)+151;
     
193. else if(dustValPM25<250.4) AQI=(300-201)/(250.4-150.5)*(dustValPM25-150.5)+201;
     
194. else if(dustValPM25<350.4) AQI=(400-301)/(350.4-250.5)*(dustValPM25-250.5)+301;
     
195. else AQI=(500-401)/(500.4-350.5)*(dustValPM25-350.5)+401;
     
196. 
     
197. 
     
198. 
     
199. //sensors.requestTemperatures();
     
200. 
     
201. Serial.print("dust number=");
     
202. Serial.print(dustnumber);//粉尘颗粒数
     
203. Serial.print("= averagedustVal=");
     
204. Serial.print(averagedustVal);//平均电压
     
205. Serial.print("= dustValPM25=");
     
206. Serial.print(dustValPM25);//PM2.5
     
207. Serial.print("=AQI=");
     
208. Serial.print(AQI);//AQI数
     
209. //Serial.print("=sensors.getTempCByIndex(0)=");
     
210. //Serial.print(sensors.getTempCByIndex(0));//温度
     
211. Serial.print("____________________=millis(0)=");
     
212. Serial.println(millis());//
     
213. 
     
214. xianshi=(xianshi+1)%4;
     
215. 
     
216. /*打印这些造成的时间开销会导致LED数码管的闪烁（单线程，打印的时候LED的输出就终止了），所以如非迫不得已，最好不打印
     
217. Serial.print("dust number=");
     
218. Serial.print(dustnumber);//粉尘颗粒数
     
219. Serial.print("= averagedustVal=");
     
220. Serial.print(averagedustVal);//平均电压
     
221. Serial.print("= dustValPM25=");
     
222. Serial.print(dustValPM25);//PM2.5
     
223. Serial.print("=AQI=");
     
224. Serial.print(AQI);//AQI数
     
225. Serial.print("=sensors.getTempCByIndex(0)=");
     
226. Serial.print(sensors.getTempCByIndex(0));//温度
     
227. Serial.print("=");
     
228. 
     
229. if(AQI<50)  Serial.println("1-VERY GOOD");//优
     
230. else if(AQI<100) Serial.println("2-good");//良
     
231. else if(AQI<150) Serial.println("3-mild concentration");//轻度污染
     
232. else if(AQI<200) Serial.println("4-mesosaprobic");//中度污染
     
233. else if(AQI<300) Serial.println("5-serious pollution");//重度污染
     
234. else Serial.println("6-severe contamination");//严重污染
     
235. 
     
236. // 这个是DS18B20读取温度的指令(750ms的时间开销，坑爹不解释，LED抖动的罪魁祸首)
     
237. sensors.requestTemperatures();
     
238. 
     
239. Serial.print("____________________=millis(0)=");
     
240. Serial.println(millis());//
     
241. */
     
242. 
     
243. }
     
244. 
     
245. 
     
246. 
     
247. //做一个保险,对应millis()溢出归零后,millis()<time1,则3秒检测一次循环终止的情况
     
248. if (millis() < time1){
     
249. time1=millis();
     
250. i=0;//重置i的值
     
251. j=0;//重置j的值
     
252. }
     
253. 
     
254. 
     
255. 
     
256. 
     
257. 
     
258.     /*计算任意数字（小于999）各上是什么数字*/
     
259.   
     
260.   float test;
     
261.   
     
262.   //对显示的值究竟是PM2.5，AQI，粉尘颗粒数，温度进行切换
     
263.   if(xianshi==0) test=dustValPM25;
     
264.   else if(xianshi==1) test=AQI;
     
265.   else if(xianshi==2) test=dustnumber*0.001;
     
266. 
     
267.   
     
268.     int test1=test*0.01;
     
269.     int test2=test*0.1;
     
270.     int test3=test;
     
271.        
     
272.    
     
273. 
     
274.    
     
275.    //test小数点左边有0位，4位数码管最高2位第一位不显，第二位为0
     
276.   //（0.xx的情况）数字口控制两片74HC595进而控制4位时钟数码管
     
277.    if(test3==0){  
     
278.    int test4=test*10;//十分位上的数字，如0.12的1
     
279.    int test5=test*100-test4*10;//百分位上的数字，如0.12的2
     
280. 
     
281.     digitalWrite(latchPin, LOW);
     
282.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
283.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
284.     digitalWrite(latchPin, HIGH);
     
285. 
     
286.     digitalWrite(latchPin, LOW);
     
287.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
288.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
289.     digitalWrite(latchPin, HIGH);
     
290.    
     
291.     digitalWrite(latchPin, LOW);
     
292.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
293.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test3]); //shift out lowbyte
     
294.     digitalWrite(latchPin, HIGH);
     
295. 
     
296.     digitalWrite(latchPin, LOW);//加入小数点
     
297.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
298.     shiftOut(dataPin, clockPin, MSBFIRST,0x80); //shift out lowbyte
     
299.     digitalWrite(latchPin, HIGH);
     
300. 
     
301.    }
     
302.    //test小数点左边有1位,4位数码管最高1位第一位不显，第二位为test3
     
303.    //（x.xx的情况）数字口控制两片74HC595进而控制4位时钟数码管
     
304.    else if(test2==0){  
     
305. 
     
306.    int test4=test*10-test3*10;//十分位上的数字，如1.23的2
     
307.    int test5=test*100-test3*100-test4*10;//百分位上的数字，如1.23的3
     
308.    
     
309.     digitalWrite(latchPin, LOW);
     
310.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
311.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
312.     digitalWrite(latchPin, HIGH);
     
313. 
     
314.     digitalWrite(latchPin, LOW);
     
315.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
316.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
317.     digitalWrite(latchPin, HIGH);
     
318.    
     
319.     digitalWrite(latchPin, LOW);
     
320.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
321.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test3]); //shift out lowbyte
     
322.     digitalWrite(latchPin, HIGH);
     
323. 
     
324. 
     
325.     digitalWrite(latchPin, LOW);//加入小数点
     
326.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
327.     shiftOut(dataPin, clockPin, MSBFIRST,0x80); //shift out lowbyte     
     
328.     digitalWrite(latchPin, HIGH);
     
329.    
     
330.    }
     
331.     //test小数点左边有2位,4位数码管最高1位第一位test2
     
332.     //（xx.xx的情况）数字口控制两片74HC595进而控制4位时钟数码管
     
333.    else if(test1==0){
     
334.    
     
335.    int test4=test-test2*10;//个位上的数字，如12.34的2
     
336.    int test5=test*10-test2*100-test4*10;//十分位上的数字，如12.34的3
     
337.    int test6=test*100-test2*1000-test4*100-test5*10;//百分位上的数字  
     
338.        
     
339.     digitalWrite(latchPin, LOW);
     
340.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
341.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test6]); //shift out lowbyte
     
342.     digitalWrite(latchPin, HIGH);
     
343. 
     
344.     digitalWrite(latchPin, LOW);
     
345.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
346.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
347.     digitalWrite(latchPin, HIGH);
     
348.    
     
349.     digitalWrite(latchPin, LOW);
     
350.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
351.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
352.     digitalWrite(latchPin, HIGH);
     
353. 
     
354. 
     
355.     digitalWrite(latchPin, LOW);
     
356.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
357.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test2]); //shift out lowbyte
     
358.     digitalWrite(latchPin, HIGH);
     
359. 
     
360.     digitalWrite(latchPin, LOW);//加入小数点
     
361.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
362.     shiftOut(dataPin, clockPin, MSBFIRST,0x80); //shift out lowbyte
     
363.     digitalWrite(latchPin, HIGH);
     
364. 
     
365.    
     
366.    }
     
367. 
     
368. //test小数点左边有3位，如123.45，因为只有4位时钟数码管，所以只显示前3位，最高1位第一位不显，第二位为test1
     
369. //（xxx.x的情况，时钟数码管只有中间有小数点，所以变成了xxx）数字口控制两片74HC595进而控制4位时钟数码管
     
370.    else {
     
371.    int test4=test2-test1*10;//十位上的数字，如123.45的2
     
372.    int test5=test-test1*100-test4*10;//个分位上的数字，如123.45的3
     
373. 
     
374.     digitalWrite(latchPin, LOW);
     
375.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
376.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
377.     digitalWrite(latchPin, HIGH);
     
378. 
     
379.     digitalWrite(latchPin, LOW);
     
380.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
381.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
382.     digitalWrite(latchPin, HIGH);
     
383.    
     
384.     digitalWrite(latchPin, LOW);
     
385.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
386.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test1]); //shift out lowbyte
     
387.     digitalWrite(latchPin, HIGH);
     
388. 
     
389.    }
     
390.    
     
391.    
     
392.    
     
393.   
     
394. 
     
395.    
     
396.   
     
397.   
     
398.    /*计算任意数字（小于999）各上是什么数字--------------------end*/
     
399. 
     
400. 
     
401.   if(xianshi==3) {
     
402.       sensors.requestTemperatures();
     
403.     test=sensors.getTempCByIndex(0);
     
404. Serial.print("=sensors.getTempCByIndex(0)=");
     
405. Serial.println(sensors.getTempCByIndex(0));//温度
     
406.     for(int col=0;col<2499;col++){
     
407.      
     
408. 
     
409.   
     
410.     int test1=test*0.01;
     
411.     int test2=test*0.1;
     
412.     int test3=test;
     
413.        
     
414.    
     
415. 
     
416.    
     
417.    //test小数点左边有0位，4位数码管最高2位第一位不显，第二位为0
     
418.   //（0.xx的情况）数字口控制两片74HC595进而控制4位时钟数码管
     
419.    if(test3==0){  
     
420.    int test4=test*10;//十分位上的数字，如0.12的1
     
421.    int test5=test*100-test4*10;//百分位上的数字，如0.12的2
     
422. 
     
423.     digitalWrite(latchPin, LOW);
     
424.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
425.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
426.     digitalWrite(latchPin, HIGH);
     
427. 
     
428.     digitalWrite(latchPin, LOW);
     
429.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
430.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
431.     digitalWrite(latchPin, HIGH);
     
432.    
     
433.     digitalWrite(latchPin, LOW);
     
434.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
435.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test3]); //shift out lowbyte
     
436.     digitalWrite(latchPin, HIGH);
     
437. 
     
438.     digitalWrite(latchPin, LOW);//加入小数点
     
439.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
440.     shiftOut(dataPin, clockPin, MSBFIRST,0x80); //shift out lowbyte
     
441.     digitalWrite(latchPin, HIGH);
     
442. 
     
443.    }
     
444.    //test小数点左边有1位,4位数码管最高1位第一位不显，第二位为test3
     
445.    //（x.xx的情况）数字口控制两片74HC595进而控制4位时钟数码管
     
446.    else if(test2==0){  
     
447. 
     
448.    int test4=test*10-test3*10;//十分位上的数字，如1.23的2
     
449.    int test5=test*100-test3*100-test4*10;//百分位上的数字，如1.23的3
     
450.    
     
451.     digitalWrite(latchPin, LOW);
     
452.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
453.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
454.     digitalWrite(latchPin, HIGH);
     
455. 
     
456.     digitalWrite(latchPin, LOW);
     
457.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
458.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
459.     digitalWrite(latchPin, HIGH);
     
460.    
     
461.     digitalWrite(latchPin, LOW);
     
462.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
463.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test3]); //shift out lowbyte
     
464.     digitalWrite(latchPin, HIGH);
     
465. 
     
466. 
     
467.     digitalWrite(latchPin, LOW);//加入小数点
     
468.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
469.     shiftOut(dataPin, clockPin, MSBFIRST,0x80); //shift out lowbyte     
     
470.     digitalWrite(latchPin, HIGH);
     
471.    
     
472.    }
     
473.     //test小数点左边有2位,4位数码管最高1位第一位test2
     
474.     //（xx.xx的情况）数字口控制两片74HC595进而控制4位时钟数码管
     
475.    else if(test1==0){
     
476.    
     
477.    int test4=test-test2*10;//个位上的数字，如12.34的2
     
478.    int test5=test*10-test2*100-test4*10;//十分位上的数字，如12.34的3
     
479.    int test6=test*100-test2*1000-test4*100-test5*10;//百分位上的数字  
     
480.        
     
481.     digitalWrite(latchPin, LOW);
     
482.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
483.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test6]); //shift out lowbyte
     
484.     digitalWrite(latchPin, HIGH);
     
485. 
     
486.     digitalWrite(latchPin, LOW);
     
487.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
488.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
489.     digitalWrite(latchPin, HIGH);
     
490.    
     
491.     digitalWrite(latchPin, LOW);
     
492.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
493.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
494.     digitalWrite(latchPin, HIGH);
     
495. 
     
496. 
     
497.     digitalWrite(latchPin, LOW);
     
498.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
499.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test2]); //shift out lowbyte
     
500.     digitalWrite(latchPin, HIGH);
     
501. 
     
502.     digitalWrite(latchPin, LOW);//加入小数点
     
503.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
504.     shiftOut(dataPin, clockPin, MSBFIRST,0x80); //shift out lowbyte
     
505.     digitalWrite(latchPin, HIGH);
     
506. 
     
507.    
     
508.    }
     
509. 
     
510. //test小数点左边有3位，如123.45，因为只有4位时钟数码管，所以只显示前3位，最高1位第一位不显，第二位为test1
     
511. //（xxx.x的情况，时钟数码管只有中间有小数点，所以变成了xxx）数字口控制两片74HC595进而控制4位时钟数码管
     
512.    else {
     
513.    int test4=test2-test1*10;//十位上的数字，如123.45的2
     
514.    int test5=test-test1*100-test4*10;//个分位上的数字，如123.45的3
     
515. 
     
516.     digitalWrite(latchPin, LOW);
     
517.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
518.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
519.     digitalWrite(latchPin, HIGH);
     
520. 
     
521.     digitalWrite(latchPin, LOW);
     
522.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
523.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
524.     digitalWrite(latchPin, HIGH);
     
525.    
     
526.     digitalWrite(latchPin, LOW);
     
527.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
528.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test1]); //shift out lowbyte
     
529.     digitalWrite(latchPin, HIGH);
     
530. 
     
531.    }
     
532.       
     
533.     }
     
534.   
     
535. 
     
536. }
     
537. 
     
538. }

复制代码

hi55234

相当另类的按键切换功能，用模拟口A1来读电压实现，针对的是抖动问题（面包板模拟口插根铜丝，随意动一下，每循环99次中电压高于1000个单位的可以有60-70次，数字口因为抖动厉害，无法实现按键切换的问题，原型就是http://www.geek-workshop.com/for ... thread&tid=1092帖子，不过我没有实现，就是因为抖动太厉害了，我要切换的RGB LED是接在第二片74hc595上面的）

1. /*数码管与74hc595的代码*/
   
2. //数码管显示为0-9共10个数字，以便四位数码管显示调用
   
3. const byte DIGX_COUNT = 10;
   
4. unsigned int sequence[DIGX_COUNT] = {0x77,0x14,0x5B,0x5E,0x3C,0x6E,0x6F,0x54,0x7F,0x7E};
   
5. 
   
6. //接法：P8、P7、P9接第一片595（Q0-Q7对应数码管逆时针1、2、4、5、7、10、11、3（这个是点），第二片控制数码管共阴脚Q0-Q3接6、8、9、12）,
   
7. int latchPin = 8;  //Pin connected to ST_CP(pin 12) of 74HC595
   
8. int clockPin = 7; //Pin connected to SH_CP(pin 11) of 74HC595
   
9. int dataPin = 9;  //Pin connected to DS(pin 14) of 74HC595
   
10. 
    
11. //引入4个数组来控制第二片74hc595（即高位部分）
    
12. //rgb led接第二片的Q4-Q6脚（对应蓝、绿、红）,9蓝、A绿、B青、C红、D紫、E黄、F白
    
13. //啰嗦一句，如果rgb led只在共脚上接一个电阻的话，7种颜色并不能全部实现，因为3种灯的电压要求不一样
    
14. unsigned int DIG4[6] = {0x9E,0xAE,0xCE,0xBE,0xEE,0xFE};//控制四位数码管的DIG4位
    
15. unsigned int DIG3[6] = {0x9D,0xAD,0xCD,0xBD,0xED,0xFD};
    
16. unsigned int DIG2[6] = {0x9B,0xAB,0xCB,0xBB,0xEB,0xFB};
    
17. unsigned int DIG1[6] = {0x97,0xA7,0xC7,0xB7,0xE7,0xF7};//控制四位数码管的DIG1位
    
18. 
    
19. 
    
20. //对显示的值究竟是PM2.5，AQI，粉尘颗粒数，温度进行切换
    
21. int xianshi=0;
    
22. int xianshi2=0;
    
23. 
    
24. boolean isPressed = 0;  //针对按起不放开的情况
    
25. 
    
26. 
    
27. unsigned long time1=millis();
    
28. unsigned long time2=millis();
    
29. unsigned long time3=millis();
    
30. 
    
31. void setup(){
    
32. Serial.begin(9600);
    
33. 
    
34. 
    
35. 
    
36. /*74HC595所涉及的3个端口*/
    
37. pinMode(latchPin, OUTPUT);
    
38. pinMode(clockPin, OUTPUT);
    
39. pinMode(dataPin, OUTPUT);
    
40.   
    
41.   
    
42. }
    
43. 
    
44. 
    
45. void loop(){
    
46. 
    
47. 
    
48. 
    
49. 
    
50. if(millis()-time2>500){ //每500ms扫描一次
    
51. time2=millis();
    
52. int xianshi3=analogRead(1);
    
53. int col2=0;
    
54. if(xianshi3>1000&&!isPressed){  //高电压+不是按着不放的情况
    
55. for(int col=0;col<99;col++){
    
56.   xianshi3=analogRead(1);
    
57. if(xianshi3>1000)col2++; //防抖动的关键，实际测试，接vcc是100%都是大于1000的
    
58. }
    
59. }
    
60. 
    
61. if(col2>95){  //99次有95次都高，就算是按下了切换
    
62. xianshi2++;
    
63.   isPressed=1; //转换为按着不放的状态
    
64. }
    
65.   
    
66.   //打印是调试用的，实际程序不需要
    
67. Serial.print("xianshi2 = ");
    
68. Serial.println(xianshi2);
    
69. 
    
70. 
    
71. 
    
72. }
    
73. 
    
74. 
    
75. if(millis()-time3>500){
    
76. time3=millis();
    
77. int xianshi3=analogRead(1);
    
78. int col2=0;
    
79. if(isPressed){
    
80. for(int col=0;col<99;col++){
    
81.   xianshi3=analogRead(1);
    
82. if(xianshi3<1000)col2++;
    
83. }
    
84. }
    
85. 
    
86. if(col2>40){  //与上同理，鉴于插铜线抖动严重，认为99次内小于1000个单位的有40次以上就算放开了
    
87.   isPressed=0;
    
88. }
    
89. 
    
90. 
    
91. }
    
92.        
    
93. //pm2.5、aqi、颗粒数、温度一共四态，所以用4取模
    
94. xianshi=xianshi2%4;
    
95. 
    
96. 
    
97. 
    
98. 
    
99. 
    
100. 
     
101.     /*计算任意数字（小于9999）各上是什么数字*/
     
102.   
     
103.   float test=xianshi;
     
104.   
     
105. 
     
106. 
     
107.     int test0=test*0.001;
     
108.     int test1=test*0.01;
     
109.     int test2=test*0.1;
     
110.     int test3=test;
     
111.        
     
112.    
     
113. 
     
114.    
     
115.    //test小数点左边有0位，4位数码管最高2位第一位不显，第二位为0
     
116.   //（0.xx的情况）数字口控制两片74HC595进而控制4位时钟数码管
     
117.    if(test3==0){  
     
118.    int test4=test*10;//十分位上的数字，如0.12的1
     
119.    int test5=test*100-test4*10;//百分位上的数字，如0.12的2
     
120. 
     
121.     digitalWrite(latchPin, LOW);
     
122.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
123.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
124.     digitalWrite(latchPin, HIGH);
     
125. 
     
126.     digitalWrite(latchPin, LOW);
     
127.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
128.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
129.     digitalWrite(latchPin, HIGH);
     
130.    
     
131.     digitalWrite(latchPin, LOW);
     
132.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
133.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test3]); //shift out lowbyte
     
134.     digitalWrite(latchPin, HIGH);
     
135. 
     
136.     digitalWrite(latchPin, LOW);//加入小数点
     
137.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
138.     shiftOut(dataPin, clockPin, MSBFIRST,0x80); //shift out lowbyte
     
139.     digitalWrite(latchPin, HIGH);
     
140. 
     
141.    }
     
142.    //test小数点左边有1位,4位数码管最高1位第一位不显，第二位为test3
     
143.    //（x.xx的情况）数字口控制两片74HC595进而控制4位时钟数码管
     
144.    else if(test2==0){  
     
145. 
     
146.    int test4=test*10-test3*10;//十分位上的数字，如1.23的2
     
147.    int test5=test*100-test3*100-test4*10;//百分位上的数字，如1.23的3
     
148.    
     
149.     digitalWrite(latchPin, LOW);
     
150.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
151.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
152.     digitalWrite(latchPin, HIGH);
     
153. 
     
154.     digitalWrite(latchPin, LOW);
     
155.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
156.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
157.     digitalWrite(latchPin, HIGH);
     
158.    
     
159.     digitalWrite(latchPin, LOW);
     
160.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
161.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test3]); //shift out lowbyte
     
162.     digitalWrite(latchPin, HIGH);
     
163. 
     
164. 
     
165.     digitalWrite(latchPin, LOW);//加入小数点
     
166.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
167.     shiftOut(dataPin, clockPin, MSBFIRST,0x80); //shift out lowbyte     
     
168.     digitalWrite(latchPin, HIGH);
     
169.    
     
170.    }
     
171.     //test小数点左边有2位,4位数码管最高1位第一位test2
     
172.     //（xx.xx的情况）数字口控制两片74HC595进而控制4位时钟数码管
     
173.    else if(test1==0){
     
174.    
     
175.    int test4=test-test2*10;//个位上的数字，如12.34的2
     
176.    int test5=test*10-test2*100-test4*10;//十分位上的数字，如12.34的3
     
177.    int test6=test*100-test2*1000-test4*100-test5*10;//百分位上的数字  
     
178.        
     
179.     digitalWrite(latchPin, LOW);
     
180.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
181.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test6]); //shift out lowbyte
     
182.     digitalWrite(latchPin, HIGH);
     
183. 
     
184.     digitalWrite(latchPin, LOW);
     
185.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
186.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
187.     digitalWrite(latchPin, HIGH);
     
188.    
     
189.     digitalWrite(latchPin, LOW);
     
190.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
191.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
192.     digitalWrite(latchPin, HIGH);
     
193. 
     
194. 
     
195.     digitalWrite(latchPin, LOW);
     
196.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
197.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test2]); //shift out lowbyte
     
198.     digitalWrite(latchPin, HIGH);
     
199. 
     
200.     digitalWrite(latchPin, LOW);//加入小数点
     
201.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
202.     shiftOut(dataPin, clockPin, MSBFIRST,0x80); //shift out lowbyte
     
203.     digitalWrite(latchPin, HIGH);
     
204. 
     
205.    
     
206.    }
     
207. 
     
208. //test小数点左边有3位，如123.45，因为只有4位时钟数码管，所以只显示前3位，最高1位第一位不显，第二位为test1
     
209. //（xxx.x的情况，时钟数码管只有中间有小数点，所以变成了xxx）数字口控制两片74HC595进而控制4位时钟数码管
     
210. else if(test0==0){
     
211.    int test4=test2-test1*10;//十位上的数字，如123.45的2
     
212.    int test5=test3-test2*10;//个位上的数字，如123.45的3
     
213. 
     
214.     digitalWrite(latchPin, LOW);
     
215.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
216.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
217.     digitalWrite(latchPin, HIGH);
     
218. 
     
219.     digitalWrite(latchPin, LOW);
     
220.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
221.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
222.     digitalWrite(latchPin, HIGH);
     
223.    
     
224.     digitalWrite(latchPin, LOW);
     
225.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
226.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test1]); //shift out lowbyte
     
227.     digitalWrite(latchPin, HIGH);
     
228. 
     
229.    }
     
230.    
     
231.    //test小数点左边有3位，如1234，因为只有4位时钟数码管，所以只显示前3位，最高1位第一位test0
     
232. //（xxxx.x的情况，时钟数码管只有中间有小数点，所以变成了xxxx）数字口控制两片74HC595进而控制4位时钟数码管
     
233. else {
     
234.    int test4=test2-test1*10;//十位上的数字，如1234的3
     
235.    int test5=test-test2*10;//个位上的数字，如1234的4
     
236.    int test6=test1-test0*10;//百位上的数字，如1234的2
     
237. 
     
238.     digitalWrite(latchPin, LOW);
     
239.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
240.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
241.     digitalWrite(latchPin, HIGH);
     
242. 
     
243.     digitalWrite(latchPin, LOW);
     
244.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
245.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
246.     digitalWrite(latchPin, HIGH);
     
247.    
     
248.     digitalWrite(latchPin, LOW);
     
249.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
250.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test6]); //shift out lowbyte
     
251.     digitalWrite(latchPin, HIGH);
     
252.        
     
253.         digitalWrite(latchPin, LOW);
     
254.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
255.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test0]); //shift out lowbyte
     
256.     digitalWrite(latchPin, HIGH);
     
257. 
     
258.    }
     
259.    
     
260.   
     
261. 
     
262.    
     
263.   
     
264.   
     
265.    /*计算任意数字（小于9999）各上是什么数字--------------------end*/
     
266. 
     
267. 
     
268. 
     
269.   
     
270. 
     
271.   
     
272.   
     
273. }

复制代码

hi55234

综合一下，代码如下，但还是有2个小问题
1、温度取得是12位分辨率，耗时750ms，导致采集温度时LED数码管必然有闪烁
2、对于没有后台记录习惯的用户，在显示温度时粉尘头依然在采集数据，这个是没啥意义的

打算的解决方法：
1、降低采集精度，如果用9位，据称50ms就能完成采集
2、在采集前先行判断是否有必要采集

1. /*
   
2. 功能：四位12脚共阴数码管，实时循环显示所测定的PM2.5值\AQI\颗粒数\温度四个值,并驱动LED等在显示不同的值的时候显示不同的颜色
   
3. 
   
4. 链接方式：
   
5. CP2102~~~~Pro mini：
   
6. GND-GND、5V-Vcc、TXD-RX1、RXD-TX0、CTS-GRN（rest）
   
7. 
   
8. Pro mini~~~GP2Y1010AU0F：
   
9. 5V-150欧-（V-LED）
   
10. 5V-150欧—Vcc
    
11. 5V-150欧-220uF-GND
    
12. GND-（LED-GND）
    
13. GND-（S-GND）
    
14. Pin2-LED
    
15. A0-Vo
    
16. 
    
17. Pro mini~~~74HC595（片1）：
    
18. Pin8-ST_CP(pin 12)
    
19. Pin7-SH_CP(pin 11)
    
20. Pin9-DS(pin 14)
    
21. GND-pin13【EN允许输出】
    
22. GND-pin8【GND】
    
23. Vcc-pin10【CR不清除】
    
24. Vcc-pin16【Vcc】
    
25. 
    
26. Pro mini~~~74HC595（片2）：
    
27. Pin8-ST_CP(pin 12)
    
28. Pin7-SH_CP(pin 11)
    
29. GND-pin13【EN允许输出】
    
30. GND-pin8【GND】
    
31. Vcc-pin10【CR不清除】
    
32. Vcc-pin16【Vcc】
    
33. 
    
34. 
    
35. 74HC595（片1）~~~74HC595（片2）：
    
36. Pin9【Q7s】-DS(pin 14)
    
37. 
    
38. 74HC595（片1）~~~四位12脚共阴数码管
    
39. Q0-Pin1（逆时针）
    
40. Q1-Pin2（逆时针）
    
41. Q2-Pin4（逆时针）
    
42. Q3-Pin5（逆时针）
    
43. Q4-Pin7（逆时针）
    
44. Q5-Pin10（逆时针）
    
45. Q6-Pin11（逆时针）
    
46. Q7-Pin3（逆时针，这个控制小点）
    
47. 
    
48. 74HC595（片2）~~~四位12脚共阴数码管
    
49. Q0-Pin6（逆时针DIG4）
    
50. Q1-Pin8（逆时针DIG3）
    
51. Q2-Pin9（逆时针DIG2）
    
52. Q3-Pin12（逆时针DIG1）
    
53. Q4-LED蓝
    
54. Q5-LED绿
    
55. Q6-LED红
    
56. 
    
57. */
    
58. 
    
59. 
    
60. 
    
61. /*DS18B20的代码*/
    
62. //调用外部的2个库文件
    
63. #include <OneWire.h>
    
64. #include <DallasTemperature.h>
    
65. // DS18B20的数据接口pin3
    
66. #define ONE_WIRE_BUS 3
    
67. // Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
    
68. OneWire oneWire(ONE_WIRE_BUS);
    
69. // Pass our oneWire reference to Dallas Temperature.
    
70. DallasTemperature sensors(&oneWire);
    
71. 
    
72. /*粉尘头的代码*/
    
73. int dustPin=0;//数字口p2控制模拟口A0读取粉尘电压
    
74. int dustVal=0;
    
75. int ledPower=2;
    
76. int delayTime=280;
    
77. int delayTime2=40;
    
78. float offTime=9680;
    
79. 
    
80. //定义一个只有2个元素的数组
    
81. int mySensVals [2];
    
82. //定义2个布尔变量，通过i的变化让粉尘电压值先进先出循环填入上数组，实现相邻采样平均
    
83. boolean i=0,j=0;
    
84. 
    
85. 
    
86. /*数码管与74hc595的代码*/
    
87. //数码管显示为0-9共10个数字，以便四位数码管显示调用
    
88. const byte DIGX_COUNT = 10;
    
89. unsigned int sequence[DIGX_COUNT] = {0x77,0x14,0x5B,0x5E,0x3C,0x6E,0x6F,0x54,0x7F,0x7E};
    
90. 
    
91. //接法：P5、P7、P9接第一片595（Q0-Q7对应数码管逆时针1、2、4、5、7、10、11、3（这个是点），第二片控制数码管共阴脚Q0-Q3接6、8、9、12）,
    
92. int latchPin = 8;  //Pin connected to ST_CP(pin 12) of 74HC595
    
93. int clockPin = 7; //Pin connected to SH_CP(pin 11) of 74HC595
    
94. int dataPin = 9;  //Pin connected to DS(pin 14) of 74HC595
    
95. 
    
96. float test;//四位数码管拆分时用到的变量
    
97. 
    
98. //引入4个数组来控制第二片74hc595（即高位部分）
    
99. //rgb led接第二片的Q4-Q6脚（对应蓝、绿、红）,9蓝、A绿、B青、C红、D紫、E黄、F白
    
100. unsigned int DIG4[6] = {0x9E,0xAE,0xBE,0xCE,0xCE,0xFE};//控制四位数码管的DIG4位
     
101. unsigned int DIG3[6] = {0x9D,0xAD,0xBD,0xCD,0xCD,0xFD};
     
102. unsigned int DIG2[6] = {0x9B,0xAB,0xBB,0xCB,0xCB,0xFB};
     
103. unsigned int DIG1[6] = {0x97,0xA7,0xB7,0xC7,0xC7,0xF7};//控制四位数码管的DIG1位
     
104. 
     
105. 
     
106. //引入millis()来控制循环
     
107. unsigned long time1=millis();
     
108. unsigned long time2=millis();
     
109. unsigned long time3=millis();
     
110. unsigned long time4=millis();
     
111. 
     
112. //pm2.5的数值、AQI指数、灰尘数，相邻采样平均电压
     
113. float dustValPM25,AQI,dustnumber,averagedustVal;
     
114. 
     
115. //对显示的值究竟是PM2.5，AQI，粉尘颗粒数，温度进行切换
     
116. int xianshi=0;
     
117. 
     
118. boolean isPressed = 0;  //针对按起不放开的情况
     
119. 
     
120. 
     
121. 
     
122. void setup(){
     
123. Serial.begin(9600);
     
124. 
     
125. sensors.begin(); //DS18B20所涉及的代码,开始检测?
     
126. 
     
127. pinMode(ledPower,OUTPUT);//开启粉尘的控制端口
     
128. 
     
129. /*74HC595所涉及的3个端口*/
     
130. pinMode(latchPin, OUTPUT);
     
131. pinMode(clockPin, OUTPUT);
     
132. pinMode(dataPin, OUTPUT);
     
133. 
     
134. 
     
135. }
     
136. 
     
137. void loop(){
     
138. 
     
139. //最初的3秒内获得mySensVals [0]，第3秒的时候就可以计算averagedustVal
     
140. if(!j){
     
141.    /*粉尘头控制代码*/
     
142. digitalWrite(ledPower,LOW); //开灯
     
143. delayMicroseconds(delayTime);
     
144. dustVal=analogRead(dustPin); //读电压
     
145. delayMicroseconds(delayTime2);
     
146. digitalWrite(ledPower,HIGH); //关灯
     
147. delayMicroseconds(offTime);
     
148. 
     
149. mySensVals [i]=dustVal;//把检测到的第一次电压塞给mySensVals [1]
     
150. i=!i;//i值反转
     
151. j=1;//不再执行这个程序
     
152. 
     
153.   }
     
154. 
     
155. 
     
156. /*粉尘头取得的粉尘对应电压dustVal,每3秒循环一次*/
     
157. 
     
158. if (millis() - time1 > 3000){
     
159. time1=millis();
     
160. 
     
161. /*粉尘头控制代码*/
     
162. digitalWrite(ledPower,LOW); //开灯
     
163. delayMicroseconds(delayTime);
     
164. dustVal=analogRead(dustPin); //读电压
     
165. delayMicroseconds(delayTime2);
     
166. digitalWrite(ledPower,HIGH); //关灯
     
167. 
     
168. /*邻采样平均averagedustVal的计算*/
     
169. mySensVals [i]=dustVal;//把检测到的第一次电压塞给mySensVals [1]
     
170. i=!i;//i值反转
     
171. averagedustVal=(mySensVals [0]+mySensVals [1])*0.5;//计算平均电压
     
172. 
     
173. 
     
174. /*计算0.01 cubic feet的颗粒数：（v-0.0356）X120000
     
175. 对于电压低于8个单位的用线性，搞定值以下颗粒数为负数的情况*/
     
176. 
     
177. if(averagedustVal>8)dustnumber=(averagedustVal*5/1024-0.0356)*120000;
     
178. else dustnumber=averagedustVal*52;
     
179. 
     
180. 
     
181. /*计算pm2.5的数值 电压阀值以上用：(v*0.172-0.0999)*1000，阀值以下用线性，参考国外帖子，认为输出最低17，对应粉尘5000*/
     
182. 
     
183. //0.9V【184.5】线性pm：电压单位*0.298373984进行计算，依据为手册上无灰尘也有0.9V的电压
     
184. //0.78V【161】线性pm：电压单位*0.21931677行计算，颗粒数降低数/粉尘降低数值最大值
     
185. //0.69V【142】线性pm：电压单位*0.136338028行计算，颗粒数/粉尘值增速加快速上升
     
186. //((averagedustVal*5/1024)*0.172-0.0999)*1000公式实质是0.83984375*averagedustVal-99.9
     
187. 
     
188. if(averagedustVal>184.5)dustValPM25=0.83984375*averagedustVal-99.9;
     
189. else dustValPM25=averagedustVal*0.298373984;
     
190. 
     
191. 
     
192. /*AQI的计算，美国标准*/
     
193. 
     
194. if(dustValPM25<15.4) AQI=(50-0)/(15.4-0)*(dustValPM25-0)+0;
     
195. else if(dustValPM25<40.4) AQI=(100-51)/(40.4-15.5)*(dustValPM25-15.5)+51;
     
196. else if(dustValPM25<65.4) AQI=(150-101)/(65.4-40.5)*(dustValPM25-40.5)+101;
     
197. else if(dustValPM25<150.4) AQI=(200-151)/(150.4-65.5)*(dustValPM25-65.5)+151;
     
198. else if(dustValPM25<250.4) AQI=(300-201)/(250.4-150.5)*(dustValPM25-150.5)+201;
     
199. else if(dustValPM25<350.4) AQI=(400-301)/(350.4-250.5)*(dustValPM25-250.5)+301;
     
200. else AQI=(500-401)/(500.4-350.5)*(dustValPM25-350.5)+401;
     
201. 
     
202. 
     
203. 
     
204. //sensors.requestTemperatures();
     
205. 
     
206. Serial.print("dust number=");
     
207. Serial.print(dustnumber);//粉尘颗粒数
     
208. Serial.print("= averagedustVal=");
     
209. Serial.print(averagedustVal);//平均电压
     
210. Serial.print("= dustValPM25=");
     
211. Serial.print(dustValPM25);//PM2.5
     
212. Serial.print("=AQI=");
     
213. Serial.print(AQI);//AQI数
     
214. //Serial.print("=sensors.getTempCByIndex(0)=");
     
215. //Serial.print(sensors.getTempCByIndex(0));//温度
     
216. Serial.print("____________________=millis(0)=");
     
217. Serial.print(millis());//
     
218. Serial.print("=xianshi = ");
     
219. Serial.println(xianshi);
     
220. 
     
221. 
     
222. 
     
223. }
     
224. 
     
225. 
     
226. 
     
227. //做一个保险,对应millis()溢出归零后,millis()<time1,则3秒检测一次循环终止的情况
     
228. if (millis() < time1){
     
229. time1=millis();
     
230. i=0;//重置i的值
     
231. j=0;//重置j的值
     
232. }
     
233. 
     
234. 
     
235. 
     
236. 
     
237. 
     
238. if(millis()-time2>500){ //每500ms扫描一次
     
239. time2=millis();
     
240. int xianshi2=analogRead(1);
     
241. int col2=0;
     
242. if(xianshi2>1000&&!isPressed){  //高电压+不是按着不放的情况
     
243. for(int col=0;col<99;col++){
     
244.   xianshi2=analogRead(1);
     
245. if(xianshi2>1000)col2++; //防抖动的关键，实际测试，接vcc是100%都是大于1000的
     
246. }
     
247. }
     
248. 
     
249. if(col2>95){  //99次有95次都高，就算是按下了切换
     
250. xianshi++;
     
251.   isPressed=1; //转换为按着不放的状态
     
252. }
     
253. 
     
254. 
     
255. 
     
256. }
     
257. 
     
258. 
     
259. if(millis()-time3>500){
     
260. time3=millis();
     
261. int xianshi2=analogRead(1);
     
262. int col2=0;
     
263. if(isPressed){
     
264. for(int col=0;col<99;col++){
     
265.   xianshi2=analogRead(1);
     
266. if(xianshi2<1000)col2++;
     
267. }
     
268. }
     
269. 
     
270. if(col2>40){  //与上同理，鉴于插铜线抖动严重，认为99次内小于1000个单位的有40次以上就算放开了
     
271.   isPressed=0;
     
272. }
     
273. 
     
274. 
     
275. }
     
276. 
     
277. 
     
278.   //pm2.5、aqi、颗粒数、温度一共四态，所以用4取模
     
279. xianshi=xianshi%4;
     
280. 
     
281. 
     
282.   
     
283. 
     
284.   //对显示的值究竟是PM2.5，AQI，粉尘颗粒数，温度进行切换
     
285.   if(xianshi==0) test=dustValPM25;
     
286.   else if(xianshi==1) test=AQI;
     
287.   else if(xianshi==2) test=dustnumber*0.001;
     
288.   else  if(xianshi==3) {
     
289.   
     
290.   if(millis()-time4>3000){
     
291. time4=millis();
     
292.       sensors.requestTemperatures();
     
293.           Serial.print("=sensors.getTempCByIndex(0)=");
     
294. Serial.println(sensors.getTempCByIndex(0));//温度
     
295. test=sensors.getTempCByIndex(0);
     
296.           }
     
297. 
     
298. }
     
299. 
     
300. 
     
301. 
     
302.     /*计算任意数字（小于9999）各上是什么数字*/
     
303. 
     
304.   
     
305.     int test0=test*0.001;
     
306.     int test1=test*0.01;
     
307.     int test2=test*0.1;
     
308.     int test3=test;
     
309. 
     
310. 
     
311. 
     
312. 
     
313.    //test小数点左边有0位，4位数码管最高2位第一位不显，第二位为0
     
314.   //（0.xx的情况）数字口控制两片74HC595进而控制4位时钟数码管
     
315.    if(test3==0){  
     
316.    int test4=test*10;//十分位上的数字，如0.12的1
     
317.    int test5=test*100-test4*10;//百分位上的数字，如0.12的2
     
318. 
     
319.     digitalWrite(latchPin, LOW);
     
320.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
321.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
322.     digitalWrite(latchPin, HIGH);
     
323. 
     
324.     digitalWrite(latchPin, LOW);
     
325.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
326.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
327.     digitalWrite(latchPin, HIGH);
     
328. 
     
329.     digitalWrite(latchPin, LOW);
     
330.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
331.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test3]); //shift out lowbyte
     
332.     digitalWrite(latchPin, HIGH);
     
333. 
     
334.     digitalWrite(latchPin, LOW);//加入小数点
     
335.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
336.     shiftOut(dataPin, clockPin, MSBFIRST,0x80); //shift out lowbyte
     
337.     digitalWrite(latchPin, HIGH);
     
338. 
     
339.    }
     
340.    //test小数点左边有1位,4位数码管最高1位第一位不显，第二位为test3
     
341.    //（x.xx的情况）数字口控制两片74HC595进而控制4位时钟数码管
     
342.    else if(test2==0){  
     
343. 
     
344.    int test4=test*10-test3*10;//十分位上的数字，如1.23的2
     
345.    int test5=test*100-test3*100-test4*10;//百分位上的数字，如1.23的3
     
346. 
     
347.     digitalWrite(latchPin, LOW);
     
348.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
349.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
350.     digitalWrite(latchPin, HIGH);
     
351. 
     
352.     digitalWrite(latchPin, LOW);
     
353.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
354.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
355.     digitalWrite(latchPin, HIGH);
     
356. 
     
357.     digitalWrite(latchPin, LOW);
     
358.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
359.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test3]); //shift out lowbyte
     
360.     digitalWrite(latchPin, HIGH);
     
361. 
     
362. 
     
363.     digitalWrite(latchPin, LOW);//加入小数点
     
364.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
365.     shiftOut(dataPin, clockPin, MSBFIRST,0x80); //shift out lowbyte     
     
366.     digitalWrite(latchPin, HIGH);
     
367. 
     
368.    }
     
369.     //test小数点左边有2位,4位数码管最高1位第一位test2
     
370.     //（xx.xx的情况）数字口控制两片74HC595进而控制4位时钟数码管
     
371.    else if(test1==0){
     
372. 
     
373.    int test4=test-test2*10;//个位上的数字，如12.34的2
     
374.    int test5=test*10-test2*100-test4*10;//十分位上的数字，如12.34的3
     
375.    int test6=test*100-test2*1000-test4*100-test5*10;//百分位上的数字  
     
376. 
     
377.     digitalWrite(latchPin, LOW);
     
378.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
379.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test6]); //shift out lowbyte
     
380.     digitalWrite(latchPin, HIGH);
     
381. 
     
382.     digitalWrite(latchPin, LOW);
     
383.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
384.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
385.     digitalWrite(latchPin, HIGH);
     
386. 
     
387.     digitalWrite(latchPin, LOW);
     
388.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
389.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
390.     digitalWrite(latchPin, HIGH);
     
391. 
     
392. 
     
393.     digitalWrite(latchPin, LOW);
     
394.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
395.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test2]); //shift out lowbyte
     
396.     digitalWrite(latchPin, HIGH);
     
397. 
     
398.     digitalWrite(latchPin, LOW);//加入小数点
     
399.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
400.     shiftOut(dataPin, clockPin, MSBFIRST,0x80); //shift out lowbyte
     
401.     digitalWrite(latchPin, HIGH);
     
402. 
     
403. 
     
404.    }
     
405. 
     
406. //test小数点左边有3位，如123.45，因为只有4位时钟数码管，所以只显示前3位，最高1位第一位不显，第二位为test1
     
407. //（xxx.x的情况，时钟数码管只有中间有小数点，所以变成了xxx）数字口控制两片74HC595进而控制4位时钟数码管
     
408. else if(test0==0){
     
409.    int test4=test2-test1*10;//十位上的数字，如123.45的2
     
410.    int test5=test3-test2*10;//个位上的数字，如123.45的3
     
411. 
     
412.     digitalWrite(latchPin, LOW);
     
413.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
414.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
415.     digitalWrite(latchPin, HIGH);
     
416. 
     
417.     digitalWrite(latchPin, LOW);
     
418.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
419.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
420.     digitalWrite(latchPin, HIGH);
     
421. 
     
422.     digitalWrite(latchPin, LOW);
     
423.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
424.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test1]); //shift out lowbyte
     
425.     digitalWrite(latchPin, HIGH);
     
426. 
     
427.    }
     
428. 
     
429.    //test小数点左边有3位，如1234，因为只有4位时钟数码管，所以只显示前3位，最高1位第一位test0
     
430. //（xxxx.x的情况，时钟数码管只有中间有小数点，所以变成了xxxx）数字口控制两片74HC595进而控制4位时钟数码管
     
431. else {
     
432.    int test4=test2-test1*10;//十位上的数字，如1234的3
     
433.    int test5=test-test2*10;//个位上的数字，如1234的4
     
434.    int test6=test1-test0*10;//百位上的数字，如1234的2
     
435. 
     
436.     digitalWrite(latchPin, LOW);
     
437.     shiftOut(dataPin, clockPin, MSBFIRST, DIG4[xianshi]); //shift out highbyte
     
438.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test5]); //shift out lowbyte
     
439.     digitalWrite(latchPin, HIGH);
     
440. 
     
441.     digitalWrite(latchPin, LOW);
     
442.     shiftOut(dataPin, clockPin, MSBFIRST, DIG3[xianshi]); //shift out highbyte
     
443.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test4]); //shift out lowbyte
     
444.     digitalWrite(latchPin, HIGH);
     
445. 
     
446.     digitalWrite(latchPin, LOW);
     
447.     shiftOut(dataPin, clockPin, MSBFIRST, DIG2[xianshi]); //shift out highbyte
     
448.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test6]); //shift out lowbyte
     
449.     digitalWrite(latchPin, HIGH);
     
450. 
     
451.         digitalWrite(latchPin, LOW);
     
452.     shiftOut(dataPin, clockPin, MSBFIRST, DIG1[xianshi]); //shift out highbyte
     
453.     shiftOut(dataPin, clockPin, MSBFIRST,sequence[test0]); //shift out lowbyte
     
454.     digitalWrite(latchPin, HIGH);
     
455. 
     
456.    }
     
457. 
     
458. 
     
459. 
     
460. 
     
461. 
     
462. 
     
463.    /*计算任意数字（小于9999）各上是什么数字--------------------end*/
     
464. 
     
465. 
     
466. 
     
467. 
     
468. 
     
469. 
     
470. 
     
471. 
     
472. 
     
473. 
     
474. }
     

复制代码