publish libraries to avoid users to have to download them one by one
This commit is contained in:
1technophile committed
1 parent
93c075e880
commit
f0546fab8c
396 files changed
+536928
No files matched your search
@@ -0,0 +1,387 @@
|
||||
/*
|
||||
SFE_BMP180.cpp
|
||||
Bosch BMP180 pressure sensor library for the Arduino microcontroller
|
||||
Mike Grusin, SparkFun Electronics
|
||||
|
||||
Uses floating-point equations from the Weather Station Data Logger project
|
||||
http://wmrx00.sourceforge.net/
|
||||
http://wmrx00.sourceforge.net/Arduino/BMP085-Calcs.pdf
|
||||
|
||||
Forked from BMP085 library by M.Grusin
|
||||
|
||||
version 1.0 2013/09/20 initial version
|
||||
|
||||
Our example code uses the "beerware" license. You can do anything
|
||||
you like with this code. No really, anything. If you find it useful,
|
||||
buy me a (root) beer someday.
|
||||
*/
|
||||
|
||||
#include <SFE_BMP180.h>
|
||||
#include <Wire.h>
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
|
||||
|
||||
SFE_BMP180::SFE_BMP180()
|
||||
// Base library type
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
char SFE_BMP180::begin()
|
||||
// Initialize library for subsequent pressure measurements
|
||||
{
|
||||
double c3,c4,b1;
|
||||
|
||||
// Start up the Arduino's "wire" (I2C) library:
|
||||
|
||||
Wire.begin();
|
||||
|
||||
// The BMP180 includes factory calibration data stored on the device.
|
||||
// Each device has different numbers, these must be retrieved and
|
||||
// used in the calculations when taking pressure measurements.
|
||||
|
||||
// Retrieve calibration data from device:
|
||||
|
||||
if (readInt(0xAA,AC1) &&
|
||||
readInt(0xAC,AC2) &&
|
||||
readInt(0xAE,AC3) &&
|
||||
readUInt(0xB0,AC4) &&
|
||||
readUInt(0xB2,AC5) &&
|
||||
readUInt(0xB4,AC6) &&
|
||||
readInt(0xB6,VB1) &&
|
||||
readInt(0xB8,VB2) &&
|
||||
readInt(0xBA,MB) &&
|
||||
readInt(0xBC,MC) &&
|
||||
readInt(0xBE,MD))
|
||||
{
|
||||
|
||||
// All reads completed successfully!
|
||||
|
||||
// If you need to check your math using known numbers,
|
||||
// you can uncomment one of these examples.
|
||||
// (The correct results are commented in the below functions.)
|
||||
|
||||
// Example from Bosch datasheet
|
||||
// AC1 = 408; AC2 = -72; AC3 = -14383; AC4 = 32741; AC5 = 32757; AC6 = 23153;
|
||||
// B1 = 6190; B2 = 4; MB = -32768; MC = -8711; MD = 2868;
|
||||
|
||||
// Example from http://wmrx00.sourceforge.net/Arduino/BMP180-Calcs.pdf
|
||||
// AC1 = 7911; AC2 = -934; AC3 = -14306; AC4 = 31567; AC5 = 25671; AC6 = 18974;
|
||||
// VB1 = 5498; VB2 = 46; MB = -32768; MC = -11075; MD = 2432;
|
||||
|
||||
/*
|
||||
Serial.print("AC1: "); Serial.println(AC1);
|
||||
Serial.print("AC2: "); Serial.println(AC2);
|
||||
Serial.print("AC3: "); Serial.println(AC3);
|
||||
Serial.print("AC4: "); Serial.println(AC4);
|
||||
Serial.print("AC5: "); Serial.println(AC5);
|
||||
Serial.print("AC6: "); Serial.println(AC6);
|
||||
Serial.print("VB1: "); Serial.println(VB1);
|
||||
Serial.print("VB2: "); Serial.println(VB2);
|
||||
Serial.print("MB: "); Serial.println(MB);
|
||||
Serial.print("MC: "); Serial.println(MC);
|
||||
Serial.print("MD: "); Serial.println(MD);
|
||||
*/
|
||||
|
||||
// Compute floating-point polynominals:
|
||||
|
||||
c3 = 160.0 * pow(2,-15) * AC3;
|
||||
c4 = pow(10,-3) * pow(2,-15) * AC4;
|
||||
b1 = pow(160,2) * pow(2,-30) * VB1;
|
||||
c5 = (pow(2,-15) / 160) * AC5;
|
||||
c6 = AC6;
|
||||
mc = (pow(2,11) / pow(160,2)) * MC;
|
||||
md = MD / 160.0;
|
||||
x0 = AC1;
|
||||
x1 = 160.0 * pow(2,-13) * AC2;
|
||||
x2 = pow(160,2) * pow(2,-25) * VB2;
|
||||
y0 = c4 * pow(2,15);
|
||||
y1 = c4 * c3;
|
||||
y2 = c4 * b1;
|
||||
p0 = (3791.0 - 8.0) / 1600.0;
|
||||
p1 = 1.0 - 7357.0 * pow(2,-20);
|
||||
p2 = 3038.0 * 100.0 * pow(2,-36);
|
||||
|
||||
/*
|
||||
Serial.println();
|
||||
Serial.print("c3: "); Serial.println(c3);
|
||||
Serial.print("c4: "); Serial.println(c4);
|
||||
Serial.print("c5: "); Serial.println(c5);
|
||||
Serial.print("c6: "); Serial.println(c6);
|
||||
Serial.print("b1: "); Serial.println(b1);
|
||||
Serial.print("mc: "); Serial.println(mc);
|
||||
Serial.print("md: "); Serial.println(md);
|
||||
Serial.print("x0: "); Serial.println(x0);
|
||||
Serial.print("x1: "); Serial.println(x1);
|
||||
Serial.print("x2: "); Serial.println(x2);
|
||||
Serial.print("y0: "); Serial.println(y0);
|
||||
Serial.print("y1: "); Serial.println(y1);
|
||||
Serial.print("y2: "); Serial.println(y2);
|
||||
Serial.print("p0: "); Serial.println(p0);
|
||||
Serial.print("p1: "); Serial.println(p1);
|
||||
Serial.print("p2: "); Serial.println(p2);
|
||||
*/
|
||||
|
||||
// Success!
|
||||
return(1);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Error reading calibration data; bad component or connection?
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
char SFE_BMP180::readInt(char address, int &value)
|
||||
// Read a signed integer (two bytes) from device
|
||||
// address: register to start reading (plus subsequent register)
|
||||
// value: external variable to store data (function modifies value)
|
||||
{
|
||||
unsigned char data[2];
|
||||
|
||||
data[0] = address;
|
||||
if (readBytes(data,2))
|
||||
{
|
||||
value = (((int)data[0]<<8)|(int)data[1]);
|
||||
//if (*value & 0x8000) *value |= 0xFFFF0000; // sign extend if negative
|
||||
return(1);
|
||||
}
|
||||
value = 0;
|
||||
return(0);
|
||||
}
|
||||
|
||||
|
||||
char SFE_BMP180::readUInt(char address, unsigned int &value)
|
||||
// Read an unsigned integer (two bytes) from device
|
||||
// address: register to start reading (plus subsequent register)
|
||||
// value: external variable to store data (function modifies value)
|
||||
{
|
||||
unsigned char data[2];
|
||||
|
||||
data[0] = address;
|
||||
if (readBytes(data,2))
|
||||
{
|
||||
value = (((unsigned int)data[0]<<8)|(unsigned int)data[1]);
|
||||
return(1);
|
||||
}
|
||||
value = 0;
|
||||
return(0);
|
||||
}
|
||||
|
||||
|
||||
char SFE_BMP180::readBytes(unsigned char *values, char length)
|
||||
// Read an array of bytes from device
|
||||
// values: external array to hold data. Put starting register in values[0].
|
||||
// length: number of bytes to read
|
||||
{
|
||||
char x;
|
||||
|
||||
Wire.beginTransmission(BMP180_ADDR);
|
||||
Wire.write(values[0]);
|
||||
_error = Wire.endTransmission();
|
||||
if (_error == 0)
|
||||
{
|
||||
Wire.requestFrom(BMP180_ADDR,length);
|
||||
while(Wire.available() != length) ; // wait until bytes are ready
|
||||
for(x=0;x<length;x++)
|
||||
{
|
||||
values[x] = Wire.read();
|
||||
}
|
||||
return(1);
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
|
||||
|
||||
char SFE_BMP180::writeBytes(unsigned char *values, char length)
|
||||
// Write an array of bytes to device
|
||||
// values: external array of data to write. Put starting register in values[0].
|
||||
// length: number of bytes to write
|
||||
{
|
||||
char x;
|
||||
|
||||
Wire.beginTransmission(BMP180_ADDR);
|
||||
Wire.write(values,length);
|
||||
_error = Wire.endTransmission();
|
||||
if (_error == 0)
|
||||
return(1);
|
||||
else
|
||||
return(0);
|
||||
}
|
||||
|
||||
|
||||
char SFE_BMP180::startTemperature(void)
|
||||
// Begin a temperature reading.
|
||||
// Will return delay in ms to wait, or 0 if I2C error
|
||||
{
|
||||
unsigned char data[2], result;
|
||||
|
||||
data[0] = BMP180_REG_CONTROL;
|
||||
data[1] = BMP180_COMMAND_TEMPERATURE;
|
||||
result = writeBytes(data, 2);
|
||||
if (result) // good write?
|
||||
return(5); // return the delay in ms (rounded up) to wait before retrieving data
|
||||
else
|
||||
return(0); // or return 0 if there was a problem communicating with the BMP
|
||||
}
|
||||
|
||||
|
||||
char SFE_BMP180::getTemperature(double &T)
|
||||
// Retrieve a previously-started temperature reading.
|
||||
// Requires begin() to be called once prior to retrieve calibration parameters.
|
||||
// Requires startTemperature() to have been called prior and sufficient time elapsed.
|
||||
// T: external variable to hold result.
|
||||
// Returns 1 if successful, 0 if I2C error.
|
||||
{
|
||||
unsigned char data[2];
|
||||
char result;
|
||||
double tu, a;
|
||||
|
||||
data[0] = BMP180_REG_RESULT;
|
||||
|
||||
result = readBytes(data, 2);
|
||||
if (result) // good read, calculate temperature
|
||||
{
|
||||
tu = (data[0] * 256.0) + data[1];
|
||||
|
||||
//example from Bosch datasheet
|
||||
//tu = 27898;
|
||||
|
||||
//example from http://wmrx00.sourceforge.net/Arduino/BMP085-Calcs.pdf
|
||||
//tu = 0x69EC;
|
||||
|
||||
a = c5 * (tu - c6);
|
||||
T = a + (mc / (a + md));
|
||||
|
||||
/*
|
||||
Serial.println();
|
||||
Serial.print("tu: "); Serial.println(tu);
|
||||
Serial.print("a: "); Serial.println(a);
|
||||
Serial.print("T: "); Serial.println(*T);
|
||||
*/
|
||||
}
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
char SFE_BMP180::startPressure(char oversampling)
|
||||
// Begin a pressure reading.
|
||||
// Oversampling: 0 to 3, higher numbers are slower, higher-res outputs.
|
||||
// Will return delay in ms to wait, or 0 if I2C error.
|
||||
{
|
||||
unsigned char data[2], result, delay;
|
||||
|
||||
data[0] = BMP180_REG_CONTROL;
|
||||
|
||||
switch (oversampling)
|
||||
{
|
||||
case 0:
|
||||
data[1] = BMP180_COMMAND_PRESSURE0;
|
||||
delay = 5;
|
||||
break;
|
||||
case 1:
|
||||
data[1] = BMP180_COMMAND_PRESSURE1;
|
||||
delay = 8;
|
||||
break;
|
||||
case 2:
|
||||
data[1] = BMP180_COMMAND_PRESSURE2;
|
||||
delay = 14;
|
||||
break;
|
||||
case 3:
|
||||
data[1] = BMP180_COMMAND_PRESSURE3;
|
||||
delay = 26;
|
||||
break;
|
||||
default:
|
||||
data[1] = BMP180_COMMAND_PRESSURE0;
|
||||
delay = 5;
|
||||
break;
|
||||
}
|
||||
result = writeBytes(data, 2);
|
||||
if (result) // good write?
|
||||
return(delay); // return the delay in ms (rounded up) to wait before retrieving data
|
||||
else
|
||||
return(0); // or return 0 if there was a problem communicating with the BMP
|
||||
}
|
||||
|
||||
|
||||
char SFE_BMP180::getPressure(double &P, double &T)
|
||||
// Retrieve a previously started pressure reading, calculate abolute pressure in mbars.
|
||||
// Requires begin() to be called once prior to retrieve calibration parameters.
|
||||
// Requires startPressure() to have been called prior and sufficient time elapsed.
|
||||
// Requires recent temperature reading to accurately calculate pressure.
|
||||
|
||||
// P: external variable to hold pressure.
|
||||
// T: previously-calculated temperature.
|
||||
// Returns 1 for success, 0 for I2C error.
|
||||
|
||||
// Note that calculated pressure value is absolute mbars, to compensate for altitude call sealevel().
|
||||
{
|
||||
unsigned char data[3];
|
||||
char result;
|
||||
double pu,s,x,y,z;
|
||||
|
||||
data[0] = BMP180_REG_RESULT;
|
||||
|
||||
result = readBytes(data, 3);
|
||||
if (result) // good read, calculate pressure
|
||||
{
|
||||
pu = (data[0] * 256.0) + data[1] + (data[2]/256.0);
|
||||
|
||||
//example from Bosch datasheet
|
||||
//pu = 23843;
|
||||
|
||||
//example from http://wmrx00.sourceforge.net/Arduino/BMP085-Calcs.pdf, pu = 0x982FC0;
|
||||
//pu = (0x98 * 256.0) + 0x2F + (0xC0/256.0);
|
||||
|
||||
s = T - 25.0;
|
||||
x = (x2 * pow(s,2)) + (x1 * s) + x0;
|
||||
y = (y2 * pow(s,2)) + (y1 * s) + y0;
|
||||
z = (pu - x) / y;
|
||||
P = (p2 * pow(z,2)) + (p1 * z) + p0;
|
||||
|
||||
/*
|
||||
Serial.println();
|
||||
Serial.print("pu: "); Serial.println(pu);
|
||||
Serial.print("T: "); Serial.println(*T);
|
||||
Serial.print("s: "); Serial.println(s);
|
||||
Serial.print("x: "); Serial.println(x);
|
||||
Serial.print("y: "); Serial.println(y);
|
||||
Serial.print("z: "); Serial.println(z);
|
||||
Serial.print("P: "); Serial.println(*P);
|
||||
*/
|
||||
}
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
double SFE_BMP180::sealevel(double P, double A)
|
||||
// Given a pressure P (mb) taken at a specific altitude (meters),
|
||||
// return the equivalent pressure (mb) at sea level.
|
||||
// This produces pressure readings that can be used for weather measurements.
|
||||
{
|
||||
return(P/pow(1-(A/44330.0),5.255));
|
||||
}
|
||||
|
||||
|
||||
double SFE_BMP180::altitude(double P, double P0)
|
||||
// Given a pressure measurement P (mb) and the pressure at a baseline P0 (mb),
|
||||
// return altitude (meters) above baseline.
|
||||
{
|
||||
return(44330.0*(1-pow(P/P0,1/5.255)));
|
||||
}
|
||||
|
||||
|
||||
char SFE_BMP180::getError(void)
|
||||
// If any library command fails, you can retrieve an extended
|
||||
// error code using this command. Errors are from the wire library:
|
||||
// 0 = Success
|
||||
// 1 = Data too long to fit in transmit buffer
|
||||
// 2 = Received NACK on transmit of address
|
||||
// 3 = Received NACK on transmit of data
|
||||
// 4 = Other error
|
||||
{
|
||||
return(_error);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,121 @@
|
||||
/*
|
||||
SFE_BMP180.h
|
||||
Bosch BMP180 pressure sensor library for the Arduino microcontroller
|
||||
Mike Grusin, SparkFun Electronics
|
||||
|
||||
Uses floating-point equations from the Weather Station Data Logger project
|
||||
http://wmrx00.sourceforge.net/
|
||||
http://wmrx00.sourceforge.net/Arduino/BMP085-Calcs.pdf
|
||||
|
||||
Forked from BMP085 library by M.Grusin
|
||||
|
||||
version 1.0 2013/09/20 initial version
|
||||
|
||||
Our example code uses the "beerware" license. You can do anything
|
||||
you like with this code. No really, anything. If you find it useful,
|
||||
buy me a (root) beer someday.
|
||||
*/
|
||||
|
||||
#ifndef SFE_BMP180_h
|
||||
#define SFE_BMP180_h
|
||||
|
||||
#if defined(ARDUINO) && ARDUINO >= 100
|
||||
#include "Arduino.h"
|
||||
#else
|
||||
#include "WProgram.h"
|
||||
#endif
|
||||
|
||||
class SFE_BMP180
|
||||
{
|
||||
public:
|
||||
SFE_BMP180(); // base type
|
||||
|
||||
char begin();
|
||||
// call pressure.begin() to initialize BMP180 before use
|
||||
// returns 1 if success, 0 if failure (bad component or I2C bus shorted?)
|
||||
|
||||
char startTemperature(void);
|
||||
// command BMP180 to start a temperature measurement
|
||||
// returns (number of ms to wait) for success, 0 for fail
|
||||
|
||||
char getTemperature(double &T);
|
||||
// return temperature measurement from previous startTemperature command
|
||||
// places returned value in T variable (deg C)
|
||||
// returns 1 for success, 0 for fail
|
||||
|
||||
char startPressure(char oversampling);
|
||||
// command BMP180 to start a pressure measurement
|
||||
// oversampling: 0 - 3 for oversampling value
|
||||
// returns (number of ms to wait) for success, 0 for fail
|
||||
|
||||
char getPressure(double &P, double &T);
|
||||
// return absolute pressure measurement from previous startPressure command
|
||||
// note: requires previous temperature measurement in variable T
|
||||
// places returned value in P variable (mbar)
|
||||
// returns 1 for success, 0 for fail
|
||||
|
||||
double sealevel(double P, double A);
|
||||
// convert absolute pressure to sea-level pressure (as used in weather data)
|
||||
// P: absolute pressure (mbar)
|
||||
// A: current altitude (meters)
|
||||
// returns sealevel pressure in mbar
|
||||
|
||||
double altitude(double P, double P0);
|
||||
// convert absolute pressure to altitude (given baseline pressure; sea-level, runway, etc.)
|
||||
// P: absolute pressure (mbar)
|
||||
// P0: fixed baseline pressure (mbar)
|
||||
// returns signed altitude in meters
|
||||
|
||||
char getError(void);
|
||||
// If any library command fails, you can retrieve an extended
|
||||
// error code using this command. Errors are from the wire library:
|
||||
// 0 = Success
|
||||
// 1 = Data too long to fit in transmit buffer
|
||||
// 2 = Received NACK on transmit of address
|
||||
// 3 = Received NACK on transmit of data
|
||||
// 4 = Other error
|
||||
|
||||
private:
|
||||
|
||||
char readInt(char address, int &value);
|
||||
// read an signed int (16 bits) from a BMP180 register
|
||||
// address: BMP180 register address
|
||||
// value: external signed int for returned value (16 bits)
|
||||
// returns 1 for success, 0 for fail, with result in value
|
||||
|
||||
char readUInt(char address, unsigned int &value);
|
||||
// read an unsigned int (16 bits) from a BMP180 register
|
||||
// address: BMP180 register address
|
||||
// value: external unsigned int for returned value (16 bits)
|
||||
// returns 1 for success, 0 for fail, with result in value
|
||||
|
||||
char readBytes(unsigned char *values, char length);
|
||||
// read a number of bytes from a BMP180 register
|
||||
// values: array of char with register address in first location [0]
|
||||
// length: number of bytes to read back
|
||||
// returns 1 for success, 0 for fail, with read bytes in values[] array
|
||||
|
||||
char writeBytes(unsigned char *values, char length);
|
||||
// write a number of bytes to a BMP180 register (and consecutive subsequent registers)
|
||||
// values: array of char with register address in first location [0]
|
||||
// length: number of bytes to write
|
||||
// returns 1 for success, 0 for fail
|
||||
|
||||
int AC1,AC2,AC3,VB1,VB2,MB,MC,MD;
|
||||
unsigned int AC4,AC5,AC6;
|
||||
double c5,c6,mc,md,x0,x1,x2,y0,y1,y2,p0,p1,p2;
|
||||
char _error;
|
||||
};
|
||||
|
||||
#define BMP180_ADDR 0x77 // 7-bit address
|
||||
|
||||
#define BMP180_REG_CONTROL 0xF4
|
||||
#define BMP180_REG_RESULT 0xF6
|
||||
|
||||
#define BMP180_COMMAND_TEMPERATURE 0x2E
|
||||
#define BMP180_COMMAND_PRESSURE0 0x34
|
||||
#define BMP180_COMMAND_PRESSURE1 0x74
|
||||
#define BMP180_COMMAND_PRESSURE2 0xB4
|
||||
#define BMP180_COMMAND_PRESSURE3 0xF4
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,168 @@
|
||||
/* SFE_BMP180 altitude example sketch
|
||||
|
||||
This sketch shows how to use the Bosch BMP180 pressure sensor
|
||||
as an altimiter.
|
||||
https://www.sparkfun.com/products/11824
|
||||
|
||||
Like most pressure sensors, the BMP180 measures absolute pressure.
|
||||
Since absolute pressure varies with altitude, you can use the pressure
|
||||
to determine your altitude.
|
||||
|
||||
Because pressure also varies with weather, you must first take a pressure
|
||||
reading at a known baseline altitude. Then you can measure variations
|
||||
from that pressure
|
||||
|
||||
Hardware connections:
|
||||
|
||||
- (GND) to GND
|
||||
+ (VDD) to 3.3V
|
||||
|
||||
(WARNING: do not connect + to 5V or the sensor will be damaged!)
|
||||
|
||||
You will also need to connect the I2C pins (SCL and SDA) to your
|
||||
Arduino. The pins are different on different Arduinos:
|
||||
|
||||
Any Arduino pins labeled: SDA SCL
|
||||
Uno, Redboard, Pro: A4 A5
|
||||
Mega2560, Due: 20 21
|
||||
Leonardo: 2 3
|
||||
|
||||
Leave the IO (VDDIO) pin unconnected. This pin is for connecting
|
||||
the BMP180 to systems with lower logic levels such as 1.8V
|
||||
|
||||
Have fun! -Your friends at SparkFun.
|
||||
|
||||
The SFE_BMP180 library uses floating-point equations developed by the
|
||||
Weather Station Data Logger project: http://wmrx00.sourceforge.net/
|
||||
|
||||
Our example code uses the "beerware" license. You can do anything
|
||||
you like with this code. No really, anything. If you find it useful,
|
||||
buy me a beer someday.
|
||||
|
||||
V10 Mike Grusin, SparkFun Electronics 10/24/2013
|
||||
*/
|
||||
|
||||
// Your sketch must #include this library, and the Wire library.
|
||||
// (Wire is a standard library included with Arduino.):
|
||||
|
||||
#include <SFE_BMP180.h>
|
||||
#include <Wire.h>
|
||||
|
||||
// You will need to create an SFE_BMP180 object, here called "pressure":
|
||||
|
||||
SFE_BMP180 pressure;
|
||||
|
||||
double baseline; // baseline pressure
|
||||
|
||||
void setup()
|
||||
{
|
||||
Serial.begin(9600);
|
||||
Serial.println("REBOOT");
|
||||
|
||||
// Initialize the sensor (it is important to get calibration values stored on the device).
|
||||
|
||||
if (pressure.begin())
|
||||
Serial.println("BMP180 init success");
|
||||
else
|
||||
{
|
||||
// Oops, something went wrong, this is usually a connection problem,
|
||||
// see the comments at the top of this sketch for the proper connections.
|
||||
|
||||
Serial.println("BMP180 init fail (disconnected?)\n\n");
|
||||
while(1); // Pause forever.
|
||||
}
|
||||
|
||||
// Get the baseline pressure:
|
||||
|
||||
baseline = getPressure();
|
||||
|
||||
Serial.print("baseline pressure: ");
|
||||
Serial.print(baseline);
|
||||
Serial.println(" mb");
|
||||
}
|
||||
|
||||
void loop()
|
||||
{
|
||||
double a,P;
|
||||
|
||||
// Get a new pressure reading:
|
||||
|
||||
P = getPressure();
|
||||
|
||||
// Show the relative altitude difference between
|
||||
// the new reading and the baseline reading:
|
||||
|
||||
a = pressure.altitude(P,baseline);
|
||||
|
||||
Serial.print("relative altitude: ");
|
||||
if (a >= 0.0) Serial.print(" "); // add a space for positive numbers
|
||||
Serial.print(a,1);
|
||||
Serial.print(" meters, ");
|
||||
if (a >= 0.0) Serial.print(" "); // add a space for positive numbers
|
||||
Serial.print(a*3.28084,0);
|
||||
Serial.println(" feet");
|
||||
|
||||
delay(500);
|
||||
}
|
||||
|
||||
|
||||
double getPressure()
|
||||
{
|
||||
char status;
|
||||
double T,P,p0,a;
|
||||
|
||||
// You must first get a temperature measurement to perform a pressure reading.
|
||||
|
||||
// Start a temperature measurement:
|
||||
// If request is successful, the number of ms to wait is returned.
|
||||
// If request is unsuccessful, 0 is returned.
|
||||
|
||||
status = pressure.startTemperature();
|
||||
if (status != 0)
|
||||
{
|
||||
// Wait for the measurement to complete:
|
||||
|
||||
delay(status);
|
||||
|
||||
// Retrieve the completed temperature measurement:
|
||||
// Note that the measurement is stored in the variable T.
|
||||
// Use '&T' to provide the address of T to the function.
|
||||
// Function returns 1 if successful, 0 if failure.
|
||||
|
||||
status = pressure.getTemperature(T);
|
||||
if (status != 0)
|
||||
{
|
||||
// Start a pressure measurement:
|
||||
// The parameter is the oversampling setting, from 0 to 3 (highest res, longest wait).
|
||||
// If request is successful, the number of ms to wait is returned.
|
||||
// If request is unsuccessful, 0 is returned.
|
||||
|
||||
status = pressure.startPressure(3);
|
||||
if (status != 0)
|
||||
{
|
||||
// Wait for the measurement to complete:
|
||||
delay(status);
|
||||
|
||||
// Retrieve the completed pressure measurement:
|
||||
// Note that the measurement is stored in the variable P.
|
||||
// Use '&P' to provide the address of P.
|
||||
// Note also that the function requires the previous temperature measurement (T).
|
||||
// (If temperature is stable, you can do one temperature measurement for a number of pressure measurements.)
|
||||
// Function returns 1 if successful, 0 if failure.
|
||||
|
||||
status = pressure.getPressure(P,T);
|
||||
if (status != 0)
|
||||
{
|
||||
return(P);
|
||||
}
|
||||
else Serial.println("error retrieving pressure measurement\n");
|
||||
}
|
||||
else Serial.println("error starting pressure measurement\n");
|
||||
}
|
||||
else Serial.println("error retrieving temperature measurement\n");
|
||||
}
|
||||
else Serial.println("error starting temperature measurement\n");
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,200 @@
|
||||
/* SFE_BMP180 library example sketch
|
||||
|
||||
This sketch shows how to use the SFE_BMP180 library to read the
|
||||
Bosch BMP180 barometric pressure sensor.
|
||||
https://www.sparkfun.com/products/11824
|
||||
|
||||
Like most pressure sensors, the BMP180 measures absolute pressure.
|
||||
This is the actual ambient pressure seen by the device, which will
|
||||
vary with both altitude and weather.
|
||||
|
||||
Before taking a pressure reading you must take a temparture reading.
|
||||
This is done with startTemperature() and getTemperature().
|
||||
The result is in degrees C.
|
||||
|
||||
Once you have a temperature reading, you can take a pressure reading.
|
||||
This is done with startPressure() and getPressure().
|
||||
The result is in millibar (mb) aka hectopascals (hPa).
|
||||
|
||||
If you'll be monitoring weather patterns, you will probably want to
|
||||
remove the effects of altitude. This will produce readings that can
|
||||
be compared to the published pressure readings from other locations.
|
||||
To do this, use the sealevel() function. You will need to provide
|
||||
the known altitude at which the pressure was measured.
|
||||
|
||||
If you want to measure altitude, you will need to know the pressure
|
||||
at a baseline altitude. This can be average sealevel pressure, or
|
||||
a previous pressure reading at your altitude, in which case
|
||||
subsequent altitude readings will be + or - the initial baseline.
|
||||
This is done with the altitude() function.
|
||||
|
||||
Hardware connections:
|
||||
|
||||
- (GND) to GND
|
||||
+ (VDD) to 3.3V
|
||||
|
||||
(WARNING: do not connect + to 5V or the sensor will be damaged!)
|
||||
|
||||
You will also need to connect the I2C pins (SCL and SDA) to your
|
||||
Arduino. The pins are different on different Arduinos:
|
||||
|
||||
Any Arduino pins labeled: SDA SCL
|
||||
Uno, Redboard, Pro: A4 A5
|
||||
Mega2560, Due: 20 21
|
||||
Leonardo: 2 3
|
||||
|
||||
Leave the IO (VDDIO) pin unconnected. This pin is for connecting
|
||||
the BMP180 to systems with lower logic levels such as 1.8V
|
||||
|
||||
Have fun! -Your friends at SparkFun.
|
||||
|
||||
The SFE_BMP180 library uses floating-point equations developed by the
|
||||
Weather Station Data Logger project: http://wmrx00.sourceforge.net/
|
||||
|
||||
Our example code uses the "beerware" license. You can do anything
|
||||
you like with this code. No really, anything. If you find it useful,
|
||||
buy me a beer someday.
|
||||
|
||||
V10 Mike Grusin, SparkFun Electronics 10/24/2013
|
||||
*/
|
||||
|
||||
// Your sketch must #include this library, and the Wire library.
|
||||
// (Wire is a standard library included with Arduino.):
|
||||
|
||||
#include <SFE_BMP180.h>
|
||||
#include <Wire.h>
|
||||
|
||||
// You will need to create an SFE_BMP180 object, here called "pressure":
|
||||
|
||||
SFE_BMP180 pressure;
|
||||
|
||||
#define ALTITUDE 1655.0 // Altitude of SparkFun's HQ in Boulder, CO. in meters
|
||||
|
||||
void setup()
|
||||
{
|
||||
Serial.begin(9600);
|
||||
Serial.println("REBOOT");
|
||||
|
||||
// Initialize the sensor (it is important to get calibration values stored on the device).
|
||||
|
||||
if (pressure.begin())
|
||||
Serial.println("BMP180 init success");
|
||||
else
|
||||
{
|
||||
// Oops, something went wrong, this is usually a connection problem,
|
||||
// see the comments at the top of this sketch for the proper connections.
|
||||
|
||||
Serial.println("BMP180 init fail\n\n");
|
||||
while(1); // Pause forever.
|
||||
}
|
||||
}
|
||||
|
||||
void loop()
|
||||
{
|
||||
char status;
|
||||
double T,P,p0,a;
|
||||
|
||||
// Loop here getting pressure readings every 10 seconds.
|
||||
|
||||
// If you want sea-level-compensated pressure, as used in weather reports,
|
||||
// you will need to know the altitude at which your measurements are taken.
|
||||
// We're using a constant called ALTITUDE in this sketch:
|
||||
|
||||
Serial.println();
|
||||
Serial.print("provided altitude: ");
|
||||
Serial.print(ALTITUDE,0);
|
||||
Serial.print(" meters, ");
|
||||
Serial.print(ALTITUDE*3.28084,0);
|
||||
Serial.println(" feet");
|
||||
|
||||
// If you want to measure altitude, and not pressure, you will instead need
|
||||
// to provide a known baseline pressure. This is shown at the end of the sketch.
|
||||
|
||||
// You must first get a temperature measurement to perform a pressure reading.
|
||||
|
||||
// Start a temperature measurement:
|
||||
// If request is successful, the number of ms to wait is returned.
|
||||
// If request is unsuccessful, 0 is returned.
|
||||
|
||||
status = pressure.startTemperature();
|
||||
if (status != 0)
|
||||
{
|
||||
// Wait for the measurement to complete:
|
||||
delay(status);
|
||||
|
||||
// Retrieve the completed temperature measurement:
|
||||
// Note that the measurement is stored in the variable T.
|
||||
// Function returns 1 if successful, 0 if failure.
|
||||
|
||||
status = pressure.getTemperature(T);
|
||||
if (status != 0)
|
||||
{
|
||||
// Print out the measurement:
|
||||
Serial.print("temperature: ");
|
||||
Serial.print(T,2);
|
||||
Serial.print(" deg C, ");
|
||||
Serial.print((9.0/5.0)*T+32.0,2);
|
||||
Serial.println(" deg F");
|
||||
|
||||
// Start a pressure measurement:
|
||||
// The parameter is the oversampling setting, from 0 to 3 (highest res, longest wait).
|
||||
// If request is successful, the number of ms to wait is returned.
|
||||
// If request is unsuccessful, 0 is returned.
|
||||
|
||||
status = pressure.startPressure(3);
|
||||
if (status != 0)
|
||||
{
|
||||
// Wait for the measurement to complete:
|
||||
delay(status);
|
||||
|
||||
// Retrieve the completed pressure measurement:
|
||||
// Note that the measurement is stored in the variable P.
|
||||
// Note also that the function requires the previous temperature measurement (T).
|
||||
// (If temperature is stable, you can do one temperature measurement for a number of pressure measurements.)
|
||||
// Function returns 1 if successful, 0 if failure.
|
||||
|
||||
status = pressure.getPressure(P,T);
|
||||
if (status != 0)
|
||||
{
|
||||
// Print out the measurement:
|
||||
Serial.print("absolute pressure: ");
|
||||
Serial.print(P,2);
|
||||
Serial.print(" mb, ");
|
||||
Serial.print(P*0.0295333727,2);
|
||||
Serial.println(" inHg");
|
||||
|
||||
// The pressure sensor returns abolute pressure, which varies with altitude.
|
||||
// To remove the effects of altitude, use the sealevel function and your current altitude.
|
||||
// This number is commonly used in weather reports.
|
||||
// Parameters: P = absolute pressure in mb, ALTITUDE = current altitude in m.
|
||||
// Result: p0 = sea-level compensated pressure in mb
|
||||
|
||||
p0 = pressure.sealevel(P,ALTITUDE); // we're at 1655 meters (Boulder, CO)
|
||||
Serial.print("relative (sea-level) pressure: ");
|
||||
Serial.print(p0,2);
|
||||
Serial.print(" mb, ");
|
||||
Serial.print(p0*0.0295333727,2);
|
||||
Serial.println(" inHg");
|
||||
|
||||
// On the other hand, if you want to determine your altitude from the pressure reading,
|
||||
// use the altitude function along with a baseline pressure (sea-level or other).
|
||||
// Parameters: P = absolute pressure in mb, p0 = baseline pressure in mb.
|
||||
// Result: a = altitude in m.
|
||||
|
||||
a = pressure.altitude(P,p0);
|
||||
Serial.print("computed altitude: ");
|
||||
Serial.print(a,0);
|
||||
Serial.print(" meters, ");
|
||||
Serial.print(a*3.28084,0);
|
||||
Serial.println(" feet");
|
||||
}
|
||||
else Serial.println("error retrieving pressure measurement\n");
|
||||
}
|
||||
else Serial.println("error starting pressure measurement\n");
|
||||
}
|
||||
else Serial.println("error retrieving temperature measurement\n");
|
||||
}
|
||||
else Serial.println("error starting temperature measurement\n");
|
||||
|
||||
delay(5000); // Pause for 5 seconds.
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
#######################################
|
||||
# Syntax Coloring Map for SFE_BMP180
|
||||
#######################################
|
||||
|
||||
#######################################
|
||||
# Datatypes (KEYWORD1)
|
||||
#######################################
|
||||
|
||||
SFE_BMP180 KEYWORD1
|
||||
|
||||
#######################################
|
||||
# Methods and Functions (KEYWORD2)
|
||||
#######################################
|
||||
|
||||
begin KEYWORD2
|
||||
startTemperature KEYWORD2
|
||||
getTemperature KEYWORD2
|
||||
startPressure KEYWORD2
|
||||
getPressure KEYWORD2
|
||||
sealevel KEYWORD2
|
||||
altitude KEYWORD2
|
||||
|
||||
#######################################
|
||||
# Constants (LITERAL1)
|
||||
#######################################
|
||||
|
||||
BMP180_ADDR LITERAL1
|
||||
Reference in new issue
Block a user