【Arduino】108种传感器模块系列实验（资料+代码+图形+仿真）

eagler8

eagler8

主要特点
压力范围：300~1100hPa（海拔9000米~-500米）
电源电压：1.8V~3.6V（VDDA），1.62V~3.6V（VDDD） VIN需要5V
LCC8封装：无铅陶瓷载体封装（LCC）
低功耗：5μA，在标准模式
高精度：低功耗模式下，分辨率为0.06hPa（0.5米）
高线性模式下，分辨率为0.03hPa（0.25米）
含温度输出
I2C接口
温度补偿
无铅，符合RoHS规范
MSL 1反应时间：7.5ms
待机电流：0.1μA
无需外部时钟电路

eagler8

技术数据
压力范围300……1100 hPa
均方根噪声中表达压力0.06 hPa typ。(超低功耗模式)
0.02 hPa typ。(超高分辨率模式)
均方根噪声中表达高度0.5 m,typ。(超低功耗模式)
0.17米,typ。(超高分辨率模式)
相对精度的压力
VDD = 3.3 v 950……1050 hPa / hPa±0.12
@ 25°C / m±1.0
700年……900 hPa / hPa±0.12
25…40°C / m±1.0
绝对精度
p = 300…1100 hpa
(温度= 0…+ 65°C,VDD = 3.3。-4.0 V)压力:……+ 2.0 hPa
温度:±1°C,typ。
平均电流消耗(1 Hz刷新率数据)
峰值电流3μA典型(超低功耗模式)
32μA,典型的(高级模式)
650μA,典型的
待机电流1.62……3.6 V
电源电压vddio 1.62……3.6 V
电源电压vdd 1.8……3.6 V
操作温度。
范围全面准确”40…+ 85°C
0…+ 65°C
conv压力。5毫秒,典型的(标准模式)
I2C传输速率3.4 MHz,马克斯。

eagler8

典型应用
GPS精准导航（航位推算，上下桥检测等）
室内室外导航
休闲、体育和医疗健康等监测
天气预报
垂直速度指示（上升/下沉速度）
风扇功率控制
体育设备，如高度剖面

eagler8

BMP180 新款 BOSCH温度模块气压传感器

eagler8

BMP180气压模块是一款高精度、小体积、低能耗的压力传感器，可以应用在移动设备中，它的性能卓越，绝对精度最低可以达到0.03hPa，并且耗电极低，只有3μA。BMP180采用强大的8-pin陶瓷无引线芯片承载（LCC）超薄封装，可以通过I2C总线直接与各种微处理器相连。

eagler8

特性曲线

eagler8

模块电原理图

eagler8

eagler8

eagler8

需要用的 “SFE_BMP180” 库文件如下
SFE_BMP180.h

1. /*
   
2. 【Arduino】66种传感器模块系列实验（68）
   
3. 实验六十八：BMP180 新款 BOSCH温度模块气压传感器（代替BMP085）
   
4. SFE_BMP180.h
   
5. */
   
6. 
   
7. #ifndef SFE_BMP180_h
   
8. #define SFE_BMP180_h
   
9. 
   
10. #if defined(ARDUINO) && ARDUINO >= 100
    
11. #include "Arduino.h"
    
12. #else
    
13. #include "WProgram.h"
    
14. #endif
    
15. 
    
16. class SFE_BMP180
    
17. {
    
18.     public:
    
19.         SFE_BMP180();
    
20. 
    
21.         char begin();
    
22.             shorted?)
    
23.         
    
24.         char startTemperature(void);
    
25.            
    
26.         char getTemperature(double &T);
    
27.             startTemperature command
    
28.             
    
29.         char startPressure(char oversampling);
    
30.             
    
31.         char getPressure(double &P, double &T);
    
32.             startPressure command           
    
33. 
    
34.         double sealevel(double P, double A);
    
35.            weather data)
    
36.            
    
37.         double altitude(double P, double P0);
    
38.            sea-level, runway, etc.)
    
39.             
    
40.         char getError(void);
    
41.             
    
42.     private:
    
43.    
    
44.         char readInt(char address, int16_t &value);
    
45.            
    
46.         char readUInt(char address, uint16_t &value);
    
47.          
    
48.         char readBytes(unsigned char *values, char length);
    
49.             
    
50.             
    
51.         char writeBytes(unsigned char *values, char length);
    
52.             subsequent registers)
    
53.             
    
54.         int16_t AC1,AC2,AC3,VB1,VB2,MB,MC,MD;
    
55.         uint16_t AC4,AC5,AC6;
    
56.         double c5,c6,mc,md,x0,x1,x2,y0,y1,y2,p0,p1,p2;
    
57.         char _error;
    
58. };
    
59. 
    
60. #define BMP180_ADDR 0x77
    
61. 
    
62. #define BMP180_REG_CONTROL 0xF4
    
63. #define BMP180_REG_RESULT 0xF6
    
64. 
    
65. #define BMP180_COMMAND_TEMPERATURE 0x2E
    
66. #define BMP180_COMMAND_PRESSURE0 0x34
    
67. #define BMP180_COMMAND_PRESSURE1 0x74
    
68. #define BMP180_COMMAND_PRESSURE2 0xB4
    
69. #define BMP180_COMMAND_PRESSURE3 0xF4
    

复制代码

eagler8

SFE_BMP180.cp

1. /*
   
2. 【Arduino】66种传感器模块系列实验（68）
   
3. 实验六十八：BMP180 新款 BOSCH温度模块气压传感器（代替BMP085）
   
4. SFE_BMP180.cp
   
5. */
   
6. 
   
7. #include <SFE_BMP180.h>
   
8. #include <Wire.h>
   
9. #include <stdio.h>
   
10. #include <math.h>
    
11. 
    
12. SFE_BMP180::SFE_BMP180()
    
13. {
    
14. }
    
15. 
    
16. char SFE_BMP180::begin()
    
17. 
    
18. {
    
19.     double c3,c4,b1;
    
20.    
    
21.     Wire.begin();
    
22. 
    
23.     if (readInt(0xAA,AC1) &&
    
24.         readInt(0xAC,AC2) &&
    
25.         readInt(0xAE,AC3) &&
    
26.         readUInt(0xB0,AC4) &&
    
27.         readUInt(0xB2,AC5) &&
    
28.         readUInt(0xB4,AC6) &&
    
29.         readInt(0xB6,VB1) &&
    
30.         readInt(0xB8,VB2) &&
    
31.         readInt(0xBA,MB) &&
    
32.         readInt(0xBC,MC) &&
    
33.         readInt(0xBE,MD))
    
34.     {
    
35. 
    
36. AC6 = 23153;
    
37.         
    
38. Calcs.pdf
    
39.         
    
40. 25671; AC6 = 18974;
    
41. 
    
42.         c3 = 160.0 * pow(2,-15) * AC3;
    
43.         c4 = pow(10,-3) * pow(2,-15) * AC4;
    
44.         b1 = pow(160,2) * pow(2,-30) * VB1;
    
45.         c5 = (pow(2,-15) / 160) * AC5;
    
46.         c6 = AC6;
    
47.         mc = (pow(2,11) / pow(160,2)) * MC;
    
48.         md = MD / 160.0;
    
49.         x0 = AC1;
    
50.         x1 = 160.0 * pow(2,-13) * AC2;
    
51.         x2 = pow(160,2) * pow(2,-25) * VB2;
    
52.         y0 = c4 * pow(2,15);
    
53.         y1 = c4 * c3;
    
54.         y2 = c4 * b1;
    
55.         p0 = (3791.0 - 8.0) / 1600.0;
    
56.         p1 = 1.0 - 7357.0 * pow(2,-20);
    
57.         p2 = 3038.0 * 100.0 * pow(2,-36);
    
58. 
    
59.         return(1);
    
60.     }
    
61.     else
    
62.     {
    
63.       
    
64.         return(0);
    
65.     }
    
66. }
    
67. 
    
68. char SFE_BMP180::readInt(char address, int16_t &value)
    
69. 
    
70. {
    
71.     unsigned char data[2];
    
72. 
    
73.     data[0] = address;
    
74.     if (readBytes(data,2))
    
75.     {
    
76.         value = (int16_t)((data[0]<<8)|data[1]);
    
77.         
    
78. negative
    
79.         return(1);
    
80.     }
    
81.     value = 0;
    
82.     return(0);
    
83. }
    
84. 
    
85. char SFE_BMP180::readUInt(char address, uint16_t &value)
    
86. 
    
87. {
    
88.     unsigned char data[2];
    
89. 
    
90.     data[0] = address;
    
91.     if (readBytes(data,2))
    
92.     {
    
93.         value = (((uint16_t)data[0]<<8)|(uint16_t)data[1]);
    
94.         return(1);
    
95.     }
    
96.     value = 0;
    
97.     return(0);
    
98. }
    
99. 
    
100. char SFE_BMP180::readBytes(unsigned char *values, char length)
     
101. 
     
102. {
     
103.     char x;
     
104. 
     
105.     Wire.beginTransmission(BMP180_ADDR);
     
106.     Wire.write(values[0]);
     
107.     _error = Wire.endTransmission();
     
108.     if (_error == 0)
     
109.     {
     
110.         Wire.requestFrom(BMP180_ADDR,length);
     
111.         while(Wire.available() != length) ;
     
112.         for(x=0;x<length;x++)
     
113.         {
     
114.             values[x] = Wire.read();
     
115.         }
     
116.         return(1);
     
117.     }
     
118.     return(0);
     
119. }
     
120. 
     
121. char SFE_BMP180::writeBytes(unsigned char *values, char length)
     
122. 
     
123. {
     
124.     char x;
     
125.    
     
126.     Wire.beginTransmission(BMP180_ADDR);
     
127.     Wire.write(values,length);
     
128.     _error = Wire.endTransmission();
     
129.     if (_error == 0)
     
130.         return(1);
     
131.     else
     
132.         return(0);
     
133. }
     
134. 
     
135. char SFE_BMP180::startTemperature(void)
     
136. 
     
137. {
     
138.     unsigned char data[2], result;
     
139.    
     
140.     data[0] = BMP180_REG_CONTROL;
     
141.     data[1] = BMP180_COMMAND_TEMPERATURE;
     
142.     result = writeBytes(data, 2);
     
143.     if (result)
     
144.         return(5);
     
145.     else
     
146.         return(0);
     
147. }
     
148. 
     
149. char SFE_BMP180::getTemperature(double &T)
     
150. 
     
151. {
     
152.     unsigned char data[2];
     
153.     char result;
     
154.     double tu, a;
     
155.    
     
156.     data[0] = BMP180_REG_RESULT;
     
157. 
     
158.     result = readBytes(data, 2);
     
159.     if (result)
     
160.     {
     
161.         tu = (data[0] * 256.0) + data[1];
     
162.         
     
163.         a = c5 * (tu - c6);
     
164.         T = a + (mc / (a + md));
     
165. 
     
166.     }
     
167.     return(result);
     
168. }
     
169. 
     
170. 
     
171. char SFE_BMP180::startPressure(char oversampling)
     
172. 
     
173. {
     
174.     unsigned char data[2], result, delay;
     
175.    
     
176.     data[0] = BMP180_REG_CONTROL;
     
177. 
     
178.     switch (oversampling)
     
179.     {
     
180.         case 0:
     
181.             data[1] = BMP180_COMMAND_PRESSURE0;
     
182.             delay = 5;
     
183.         break;
     
184.         case 1:
     
185.             data[1] = BMP180_COMMAND_PRESSURE1;
     
186.             delay = 8;
     
187.         break;
     
188.         case 2:
     
189.             data[1] = BMP180_COMMAND_PRESSURE2;
     
190.             delay = 14;
     
191.         break;
     
192.         case 3:
     
193.             data[1] = BMP180_COMMAND_PRESSURE3;
     
194.             delay = 26;
     
195.         break;
     
196.         default:
     
197.             data[1] = BMP180_COMMAND_PRESSURE0;
     
198.             delay = 5;
     
199.         break;
     
200.     }
     
201.     result = writeBytes(data, 2);
     
202.     if (result)
     
203.         return(delay);
     
204.     else
     
205.         return(0);
     
206. }
     
207. 
     
208. 
     
209. char SFE_BMP180::getPressure(double &P, double &T)
     
210. 
     
211. sealevel().
     
212. {
     
213.     unsigned char data[3];
     
214.     char result;
     
215.     double pu,s,x,y,z;
     
216.    
     
217.     data[0] = BMP180_REG_RESULT;
     
218. 
     
219.     result = readBytes(data, 3);
     
220.     if (result)
     
221.     {
     
222.         pu = (data[0] * 256.0) + data[1] + (data[2]/256.0);
     
223.         
     
224.         s = T - 25.0;
     
225.         x = (x2 * pow(s,2)) + (x1 * s) + x0;
     
226.         y = (y2 * pow(s,2)) + (y1 * s) + y0;
     
227.         z = (pu - x) / y;
     
228.         P = (p2 * pow(z,2)) + (p1 * z) + p0;
     
229. 
     
230.     }
     
231.     return(result);
     
232. }
     
233. 
     
234. 
     
235. double SFE_BMP180::sealevel(double P, double A)
     
236. 
     
237. {
     
238.     return(P/pow(1-(A/44330.0),5.255));
     
239. }
     
240. 
     
241. double SFE_BMP180::altitude(double P, double P0)
     
242. 
     
243. {
     
244.     return(44330.0*(1-pow(P/P0,1/5.255)));
     
245. }
     
246. 
     
247. 
     
248. char SFE_BMP180::getError(void)
     
249.    
     
250. {
     
251.     return(_error);
     
252. }
     
253. 
     

复制代码

eagler8

接线方式
1.先连接芯片与单片机（通过I2C接口），按照如下方式连接
5V—VIN
GND–GND
A5—SCL
A4—SDA
2.然后UNO通过usb与PC电脑连接
3.拷贝后面的代码烧录进Arduino

eagler8

1. /*
   
2. 【Arduino】66种传感器模块系列实验（68）
   
3. 实验六十八：BMP180 新款 BOSCH温度模块气压传感器（代替BMP085）
   
4. 程序之一
   
5. */
   
6. 
   
7. #include <SFE_BMP180.h>
   
8. 
   
9. SFE_BMP180 AirPresure;
   
10. char presureDelayTime;
    
11. double presureP, presureT;
    
12. 
    
13. void setup() {
    
14.   Serial.begin(9600);
    
15.   AirPresure.begin();
    
16. }
    
17. 
    
18. void loop()
    
19. {
    
20.   presureDelayTime = AirPresure.startPressure(3);
    
21.   if (presureDelayTime != 0)
    
22.   {
    
23.     delay(presureDelayTime);
    
24.     presureDelayTime = AirPresure.getPressure(presureP, presureT);
    
25.     if (presureDelayTime != 0)
    
26.     {
    
27.       
    
28.       Serial.print("Current Preasure: ");
    
29.       Serial.print(presureP);
    
30.       Serial.println(" bar");
    
31. 
    
32.       Serial.print(presureP);
    
33.       Serial.print(" bar is");
    
34.       Serial.print(presureP / 1000.0);
    
35.       Serial.println(" atm");
    
36.     }
    
37.     else
    
38.     {
    
39.       Serial.println("ERROR");
    
40.     }
    
41.   }
    
42.   else
    
43.   {
    
44.     Serial.println("ERROR");
    
45.   }
    
46.   delay(1000);
    
47. }

复制代码

eagler8