├── .categories ├── Arduino └── BMP280.ino ├── BMP280_I2CS.png ├── C └── BMP280.c ├── Java └── BMP280.java ├── Onion Omega Python └── BMP280.py ├── Particle └── BMP280.ino ├── Python └── BMP280.py └── README.md /.categories: -------------------------------------------------------------------------------- 1 | lang:java 2 | lang:python 3 | lang:arduino 4 | lang:particle 5 | sku:BMP280_I2CS 6 | -------------------------------------------------------------------------------- /Arduino/BMP280.ino: -------------------------------------------------------------------------------- 1 | // Distributed with a free-will license. 2 | // Use it any way you want, profit or free, provided it fits in the licenses of its associated works. 3 | // BMP280 4 | // This code is designed to work with the BMP280_I2CS I2C Mini Module available from ControlEverything.com. 5 | // https://www.controleverything.com/content/Barometer?sku=BMP280_I2CSs#tabs-0-product_tabset-2 6 | 7 | #include 8 | 9 | // BMP280 I2C address is 0x76(108) 10 | #define Addr 0x76 11 | 12 | void setup() 13 | { 14 | // Initialise I2C communication as MASTER 15 | Wire.begin(); 16 | // Initialise Serial communication, set baud rate = 9600 17 | Serial.begin(9600); 18 | } 19 | 20 | void loop() 21 | { 22 | unsigned int b1[24]; 23 | unsigned int data[8]; 24 | for (int i = 0; i < 24; i++) 25 | { 26 | // Start I2C Transmission 27 | Wire.beginTransmission(Addr); 28 | // Select data register 29 | Wire.write((136 + i)); 30 | // Stop I2C Transmission 31 | Wire.endTransmission(); 32 | 33 | // Request 1 byte of data 34 | Wire.requestFrom(Addr, 1); 35 | 36 | // Read 1 byte of data 37 | if (Wire.available() == 1) 38 | { 39 | b1[i] = Wire.read(); 40 | } 41 | } 42 | // Convert the data 43 | // temp coefficients 44 | unsigned int dig_T1 = (b1[0] & 0xFF) + ((b1[1] & 0xFF) * 256); 45 | int dig_T2 = b1[2] + (b1[3] * 256); 46 | int dig_T3 = b1[4] + (b1[5] * 256); 47 | 48 | // pressure coefficients 49 | unsigned int dig_P1 = (b1[6] & 0xFF) + ((b1[7] & 0xFF) * 256); 50 | int dig_P2 = b1[8] + (b1[9] * 256); 51 | int dig_P3 = b1[10] + (b1[11] * 256); 52 | int dig_P4 = b1[12] + (b1[13] * 256); 53 | int dig_P5 = b1[14] + (b1[15] * 256); 54 | int dig_P6 = b1[16] + (b1[17] * 256); 55 | int dig_P7 = b1[18] + (b1[19] * 256); 56 | int dig_P8 = b1[20] + (b1[21] * 256); 57 | int dig_P9 = b1[22] + (b1[23] * 256); 58 | 59 | // Start I2C Transmission 60 | Wire.beginTransmission(Addr); 61 | // Select control measurement register 62 | Wire.write(0xF4); 63 | // Normal mode, temp and pressure over sampling rate = 1 64 | Wire.write(0x27); 65 | // Stop I2C Transmission 66 | Wire.endTransmission(); 67 | 68 | // Start I2C Transmission 69 | Wire.beginTransmission(Addr); 70 | // Select config register 71 | Wire.write(0xF5); 72 | // Stand_by time = 1000ms 73 | Wire.write(0xA0); 74 | // Stop I2C Transmission 75 | Wire.endTransmission(); 76 | 77 | for (int i = 0; i < 8; i++) 78 | { 79 | // Start I2C Transmission 80 | Wire.beginTransmission(Addr); 81 | // Select data register 82 | Wire.write((247 + i)); 83 | // Stop I2C Transmission 84 | Wire.endTransmission(); 85 | 86 | // Request 1 byte of data 87 | Wire.requestFrom(Addr, 1); 88 | 89 | // Read 1 byte of data 90 | if (Wire.available() == 1) 91 | { 92 | data[i] = Wire.read(); 93 | } 94 | } 95 | 96 | // Convert pressure and temperature data to 19-bits 97 | long adc_p = (((long)(data[0] & 0xFF) * 65536) + ((long)(data[1] & 0xFF) * 256) + (long)(data[2] & 0xF0)) / 16; 98 | long adc_t = (((long)(data[3] & 0xFF) * 65536) + ((long)(data[4] & 0xFF) * 256) + (long)(data[5] & 0xF0)) / 16; 99 | 100 | // Temperature offset calculations 101 | double var1 = (((double)adc_t) / 16384.0 - ((double)dig_T1) / 1024.0) * ((double)dig_T2); 102 | double var2 = ((((double)adc_t) / 131072.0 - ((double)dig_T1) / 8192.0) * 103 | (((double)adc_t) / 131072.0 - ((double)dig_T1) / 8192.0)) * ((double)dig_T3); 104 | double t_fine = (long)(var1 + var2); 105 | double cTemp = (var1 + var2) / 5120.0; 106 | double fTemp = cTemp * 1.8 + 32; 107 | 108 | // Pressure offset calculations 109 | var1 = ((double)t_fine / 2.0) - 64000.0; 110 | var2 = var1 * var1 * ((double)dig_P6) / 32768.0; 111 | var2 = var2 + var1 * ((double)dig_P5) * 2.0; 112 | var2 = (var2 / 4.0) + (((double)dig_P4) * 65536.0); 113 | var1 = (((double) dig_P3) * var1 * var1 / 524288.0 + ((double) dig_P2) * var1) / 524288.0; 114 | var1 = (1.0 + var1 / 32768.0) * ((double)dig_P1); 115 | double p = 1048576.0 - (double)adc_p; 116 | p = (p - (var2 / 4096.0)) * 6250.0 / var1; 117 | var1 = ((double) dig_P9) * p * p / 2147483648.0; 118 | var2 = p * ((double) dig_P8) / 32768.0; 119 | double pressure = (p + (var1 + var2 + ((double)dig_P7)) / 16.0) / 100; 120 | 121 | // Output data to serial monitor 122 | Serial.print("Pressure : "); 123 | Serial.print(pressure); 124 | Serial.println(" hPa"); 125 | Serial.print("Temperature in Celsius : "); 126 | Serial.print(cTemp); 127 | Serial.println(" C"); 128 | Serial.print("Temperature in Fahrenheit : "); 129 | Serial.print(fTemp); 130 | Serial.println(" F"); 131 | delay(1000); 132 | } 133 | -------------------------------------------------------------------------------- /BMP280_I2CS.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ControlEverythingCommunity/BMP280/bad088173f0df6f41085a3fdbd6c3d6d901595d0/BMP280_I2CS.png -------------------------------------------------------------------------------- /C/BMP280.c: -------------------------------------------------------------------------------- 1 | // Distributed with a free-will license. 2 | // Use it any way you want, profit or free, provided it fits in the licenses of its associated works. 3 | // BMP280 4 | // This code is designed to work with the BMP280_I2CS I2C Mini Module available from ControlEverything.com. 5 | // https://www.controleverything.com/content/Barometer?sku=BMP280_I2CSs#tabs-0-product_tabset-2 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | void main() 15 | { 16 | // Create I2C bus 17 | int file; 18 | char *bus = "/dev/i2c-1"; 19 | if((file = open(bus, O_RDWR)) < 0) 20 | { 21 | printf("Failed to open the bus. \n"); 22 | exit(1); 23 | } 24 | // Get I2C device, BMP280 I2C address is 0x76(108) 25 | ioctl(file, I2C_SLAVE, 0x76); 26 | 27 | // Read 24 bytes of data from address(0x88) 28 | char reg[1] = {0x88}; 29 | write(file, reg, 1); 30 | char data[24] = {0}; 31 | if(read(file, data, 24) != 24) 32 | { 33 | printf("Error : Input/output Error \n"); 34 | exit(1); 35 | } 36 | // Convert the data 37 | // temp coefficents 38 | int dig_T1 = data[1] * 256 + data[0]; 39 | int dig_T2 = data[3] * 256 + data[2]; 40 | if(dig_T2 > 32767) 41 | { 42 | dig_T2 -= 65536; 43 | } 44 | int dig_T3 = data[5] * 256 + data[4]; 45 | if(dig_T3 > 32767) 46 | { 47 | dig_T3 -= 65536; 48 | } 49 | // pressure coefficents 50 | int dig_P1 = data[7] * 256 + data[6]; 51 | int dig_P2 = data[9] * 256 + data[8]; 52 | if(dig_P2 > 32767) 53 | { 54 | dig_P2 -= 65536; 55 | } 56 | int dig_P3 = data[11]* 256 + data[10]; 57 | if(dig_P3 > 32767) 58 | { 59 | dig_P3 -= 65536; 60 | } 61 | int dig_P4 = data[13]* 256 + data[12]; 62 | if(dig_P4 > 32767) 63 | { 64 | dig_P4 -= 65536; 65 | } 66 | int dig_P5 = data[15]* 256 + data[14]; 67 | if(dig_P5 > 32767) 68 | { 69 | dig_P5 -= 65536; 70 | } 71 | int dig_P6 = data[17]* 256 + data[16]; 72 | if(dig_P6 > 32767) 73 | { 74 | dig_P6 -= 65536; 75 | } 76 | int dig_P7 = data[19]* 256 + data[18]; 77 | if(dig_P7 > 32767) 78 | { 79 | dig_P7 -= 65536; 80 | } 81 | int dig_P8 = data[21]* 256 + data[20]; 82 | if(dig_P8 > 32767) 83 | { 84 | dig_P8 -= 65536; 85 | } 86 | int dig_P9 = data[23]* 256 + data[22]; 87 | if(dig_P9 > 32767) 88 | { 89 | dig_P9 -= 65536; 90 | } 91 | 92 | // Select control measurement register(0xF4) 93 | // Normal mode, temp and pressure over sampling rate = 1(0x27) 94 | char config[2] = {0}; 95 | config[0] = 0xF4; 96 | config[1] = 0x27; 97 | write(file, config, 2); 98 | 99 | // Select config register(0xF5) 100 | // Stand_by time = 1000 ms(0xA0) 101 | config[0] = 0xF5; 102 | config[1] = 0xA0; 103 | write(file, config, 2); 104 | sleep(1); 105 | 106 | // Read 8 bytes of data from register(0xF7) 107 | // pressure msb1, pressure msb, pressure lsb, temp msb1, temp msb, temp lsb, humidity lsb, humidity msb 108 | reg[0] = 0xF7; 109 | write(file, reg, 1); 110 | if(read(file, data, 8) != 8) 111 | { 112 | printf("Error : Input/output Error \n"); 113 | exit(1); 114 | } 115 | 116 | // Convert pressure and temperature data to 19-bits 117 | long adc_p = (((long)data[0] * 65536) + ((long)data[1] * 256) + (long)(data[2] & 0xF0)) / 16; 118 | long adc_t = (((long)data[3] * 65536) + ((long)data[4] * 256) + (long)(data[5] & 0xF0)) / 16; 119 | 120 | // Temperature offset calculations 121 | double var1 = (((double)adc_t) / 16384.0 - ((double)dig_T1) / 1024.0) * ((double)dig_T2); 122 | double var2 = ((((double)adc_t) / 131072.0 - ((double)dig_T1) / 8192.0) *(((double)adc_t)/131072.0 - ((double)dig_T1)/8192.0)) * ((double)dig_T3); 123 | double t_fine = (long)(var1 + var2); 124 | double cTemp = (var1 + var2) / 5120.0; 125 | double fTemp = cTemp * 1.8 + 32; 126 | 127 | // Pressure offset calculations 128 | var1 = ((double)t_fine / 2.0) - 64000.0; 129 | var2 = var1 * var1 * ((double)dig_P6) / 32768.0; 130 | var2 = var2 + var1 * ((double)dig_P5) * 2.0; 131 | var2 = (var2 / 4.0) + (((double)dig_P4) * 65536.0); 132 | var1 = (((double) dig_P3) * var1 * var1 / 524288.0 + ((double) dig_P2) * var1) / 524288.0; 133 | var1 = (1.0 + var1 / 32768.0) * ((double)dig_P1); 134 | double p = 1048576.0 - (double)adc_p; 135 | p = (p - (var2 / 4096.0)) * 6250.0 / var1; 136 | var1 = ((double) dig_P9) * p * p / 2147483648.0; 137 | var2 = p * ((double) dig_P8) / 32768.0; 138 | double pressure = (p + (var1 + var2 + ((double)dig_P7)) / 16.0) / 100; 139 | 140 | // Output data to screen 141 | printf("Pressure : %.2f hPa \n", pressure); 142 | printf("Temperature in Celsius : %.2f C \n", cTemp); 143 | printf("Temperature in Fahrenheit : %.2f F \n", fTemp); 144 | } 145 | -------------------------------------------------------------------------------- /Java/BMP280.java: -------------------------------------------------------------------------------- 1 | // Distributed with a free-will license. 2 | // Use it any way you want, profit or free, provided it fits in the licenses of its associated works. 3 | // BMP280 4 | // This code is designed to work with the BMP280_I2CS I2C Mini Module available from ControlEverything.com. 5 | // https://www.controleverything.com/content/Barometer?sku=BMP280_I2CSs#tabs-0-product_tabset-2 6 | 7 | 8 | import com.pi4j.io.i2c.I2CBus; 9 | import com.pi4j.io.i2c.I2CDevice; 10 | import com.pi4j.io.i2c.I2CFactory; 11 | import java.io.IOException; 12 | 13 | public class BMP280 14 | { 15 | public static void main(String args[]) throws Exception 16 | { 17 | // Create I2C bus 18 | I2CBus bus = I2CFactory.getInstance(I2CBus.BUS_1); 19 | // Get I2C device, BMP280 I2C address is 0x76(108) 20 | I2CDevice device = bus.getDevice(0x76); 21 | 22 | // Read 24 bytes of data from address 0x88(136) 23 | byte[] b1 = new byte[24]; 24 | device.read(0x88, b1, 0, 24); 25 | 26 | // Convert the data 27 | // temp coefficents 28 | int dig_T1 = (b1[0] & 0xFF) + ((b1[1] & 0xFF) * 256); 29 | int dig_T2 = (b1[2] & 0xFF) + ((b1[3] & 0xFF) * 256); 30 | if(dig_T2 > 32767) 31 | { 32 | dig_T2 -= 65536; 33 | } 34 | int dig_T3 = (b1[4] & 0xFF) + ((b1[5] & 0xFF) * 256); 35 | if(dig_T3 > 32767) 36 | { 37 | dig_T3 -= 65536; 38 | } 39 | 40 | // pressure coefficents 41 | int dig_P1 = (b1[6] & 0xFF) + ((b1[7] & 0xFF) * 256); 42 | int dig_P2 = (b1[8] & 0xFF) + ((b1[9] & 0xFF) * 256); 43 | if(dig_P2 > 32767) 44 | { 45 | dig_P2 -= 65536; 46 | } 47 | int dig_P3 = (b1[10] & 0xFF) + ((b1[11] & 0xFF) * 256); 48 | if(dig_P3 > 32767) 49 | { 50 | dig_P3 -= 65536; 51 | } 52 | int dig_P4 = (b1[12] & 0xFF) + ((b1[13] & 0xFF) * 256); 53 | if(dig_P4 > 32767) 54 | { 55 | dig_P4 -= 65536; 56 | } 57 | int dig_P5 = (b1[14] & 0xFF) + ((b1[15] & 0xFF) * 256); 58 | if(dig_P5 > 32767) 59 | { 60 | dig_P5 -= 65536; 61 | } 62 | int dig_P6 = (b1[16] & 0xFF) + ((b1[17] & 0xFF) * 256); 63 | if(dig_P6 > 32767) 64 | { 65 | dig_P6 -= 65536; 66 | } 67 | int dig_P7 = (b1[18] & 0xFF) + ((b1[19] & 0xFF) * 256); 68 | if(dig_P7 > 32767) 69 | { 70 | dig_P7 -= 65536; 71 | } 72 | int dig_P8 = (b1[20] & 0xFF) + ((b1[21] & 0xFF) * 256); 73 | if(dig_P8 > 32767) 74 | { 75 | dig_P8 -= 65536; 76 | } 77 | int dig_P9 = (b1[22] & 0xFF) + ((b1[23] & 0xFF) * 256); 78 | if(dig_P9 > 32767) 79 | { 80 | dig_P9 -= 65536; 81 | } 82 | // Select control measurement register 83 | // Normal mode, temp and pressure over sampling rate = 1 84 | device.write(0xF4 , (byte)0x27); 85 | // Select config register 86 | // Stand_by time = 1000 ms 87 | device.write(0xF5 , (byte)0xA0); 88 | Thread.sleep(500); 89 | 90 | // Read 8 bytes of data from address 0xF7(247) 91 | // pressure msb1, pressure msb, pressure lsb, temp msb1, temp msb, temp lsb, humidity lsb, humidity msb 92 | byte[] data = new byte[8]; 93 | device.read(0xF7, data, 0, 8); 94 | 95 | // Convert pressure and temperature data to 19-bits 96 | long adc_p = (((long)(data[0] & 0xFF) * 65536) + ((long)(data[1] & 0xFF) * 256) + (long)(data[2] & 0xF0)) / 16; 97 | long adc_t = (((long)(data[3] & 0xFF) * 65536) + ((long)(data[4] & 0xFF) * 256) + (long)(data[5] & 0xF0)) / 16; 98 | 99 | // Temperature offset calculations 100 | double var1 = (((double)adc_t) / 16384.0 - ((double)dig_T1) / 1024.0) * ((double)dig_T2); 101 | double var2 = ((((double)adc_t) / 131072.0 - ((double)dig_T1) / 8192.0) * 102 | (((double)adc_t)/131072.0 - ((double)dig_T1)/8192.0)) * ((double)dig_T3); 103 | double t_fine = (long)(var1 + var2); 104 | double cTemp = (var1 + var2) / 5120.0; 105 | double fTemp = cTemp * 1.8 + 32; 106 | 107 | // Pressure offset calculations 108 | var1 = ((double)t_fine / 2.0) - 64000.0; 109 | var2 = var1 * var1 * ((double)dig_P6) / 32768.0; 110 | var2 = var2 + var1 * ((double)dig_P5) * 2.0; 111 | var2 = (var2 / 4.0) + (((double)dig_P4) * 65536.0); 112 | var1 = (((double) dig_P3) * var1 * var1 / 524288.0 + ((double) dig_P2) * var1) / 524288.0; 113 | var1 = (1.0 + var1 / 32768.0) * ((double)dig_P1); 114 | double p = 1048576.0 - (double)adc_p; 115 | p = (p - (var2 / 4096.0)) * 6250.0 / var1; 116 | var1 = ((double) dig_P9) * p * p / 2147483648.0; 117 | var2 = p * ((double) dig_P8) / 32768.0; 118 | double pressure = (p + (var1 + var2 + ((double)dig_P7)) / 16.0) / 100; 119 | 120 | // Output data to screen 121 | System.out.printf("Pressure : %.2f hPa %n", pressure); 122 | System.out.printf("Temperature in Celsius : %.2f C %n", cTemp); 123 | System.out.printf("Temperature in Fahrenheit : %.2f F %n", fTemp); 124 | } 125 | } -------------------------------------------------------------------------------- /Onion Omega Python/BMP280.py: -------------------------------------------------------------------------------- 1 | # Distributed with a free-will license. 2 | # Use it any way you want, profit or free, provided it fits in the licenses of its associated works. 3 | # BMP280 4 | # This code is designed to work with the BMP280_I2CS I2C Mini Module available from ControlEverything.com. 5 | # https://www.controleverything.com/content/Barometer?sku=BMP280_I2CSs#tabs-0-product_tabset-2 6 | 7 | 8 | from OmegaExpansion import onionI2C 9 | import time 10 | 11 | # Get I2C bus 12 | i2c = onionI2C.OnionI2C() 13 | 14 | # BMP280 address, 0x76(118) 15 | # Read data back from 0x88(136), 24 bytes 16 | b1 = i2c.readBytes(0x76, 0x88, 24) 17 | 18 | # Convert the data 19 | # Temp coefficents 20 | dig_T1 = b1[1] * 256 + b1[0] 21 | dig_T2 = b1[3] * 256 + b1[2] 22 | if dig_T2 > 32767 : 23 | dig_T2 -= 65536 24 | dig_T3 = b1[5] * 256 + b1[4] 25 | if dig_T3 > 32767 : 26 | dig_T3 -= 65536 27 | 28 | # Pressure coefficents 29 | dig_P1 = b1[7] * 256 + b1[6] 30 | dig_P2 = b1[9] * 256 + b1[8] 31 | if dig_P2 > 32767 : 32 | dig_P2 -= 65536 33 | dig_P3 = b1[11] * 256 + b1[10] 34 | if dig_P3 > 32767 : 35 | dig_P3 -= 65536 36 | dig_P4 = b1[13] * 256 + b1[12] 37 | if dig_P4 > 32767 : 38 | dig_P4 -= 65536 39 | dig_P5 = b1[15] * 256 + b1[14] 40 | if dig_P5 > 32767 : 41 | dig_P5 -= 65536 42 | dig_P6 = b1[17] * 256 + b1[16] 43 | if dig_P6 > 32767 : 44 | dig_P6 -= 65536 45 | dig_P7 = b1[19] * 256 + b1[18] 46 | if dig_P7 > 32767 : 47 | dig_P7 -= 65536 48 | dig_P8 = b1[21] * 256 + b1[20] 49 | if dig_P8 > 32767 : 50 | dig_P8 -= 65536 51 | dig_P9 = b1[23] * 256 + b1[22] 52 | if dig_P9 > 32767 : 53 | dig_P9 -= 65536 54 | 55 | # BMP280 address, 0x76(118) 56 | # Select Control measurement register, 0xF4(244) 57 | # 0x27(39) Pressure and Temperature Oversampling rate = 1 58 | # Normal mode 59 | i2c.writeByte(0x76, 0xF4, 0x27) 60 | # BMP280 address, 0x76(118) 61 | # Select Configuration register, 0xF5(245) 62 | # 0xA0(00) Stand_by time = 1000 ms 63 | i2c.writeByte(0x76, 0xF5, 0xA0) 64 | 65 | time.sleep(0.5) 66 | 67 | # BMP280 address, 0x76(118) 68 | # Read data back from 0xF7(247), 8 bytes 69 | # Pressure MSB, Pressure LSB, Pressure xLSB, Temperature MSB, Temperature LSB 70 | # Temperature xLSB, Humidity MSB, Humidity LSB 71 | data = i2c.readBytes(0x76, 0xF7, 8) 72 | 73 | # Convert pressure and temperature data to 19-bits 74 | adc_p = ((data[0] * 65536) + (data[1] * 256) + (data[2] & 0xF0)) / 16 75 | adc_t = ((data[3] * 65536) + (data[4] * 256) + (data[5] & 0xF0)) / 16 76 | 77 | # Temperature offset calculations 78 | var1 = ((adc_t) / 16384.0 - (dig_T1) / 1024.0) * (dig_T2) 79 | var2 = (((adc_t) / 131072.0 - (dig_T1) / 8192.0) * ((adc_t)/131072.0 - (dig_T1)/8192.0)) * (dig_T3) 80 | t_fine = (var1 + var2) 81 | cTemp = (var1 + var2) / 5120.0 82 | fTemp = cTemp * 1.8 + 32 83 | 84 | # Pressure offset calculations 85 | var1 = (t_fine / 2.0) - 64000.0 86 | var2 = var1 * var1 * (dig_P6) / 32768.0 87 | var2 = var2 + var1 * (dig_P5) * 2.0 88 | var2 = (var2 / 4.0) + ((dig_P4) * 65536.0) 89 | var1 = ((dig_P3) * var1 * var1 / 524288.0 + ( dig_P2) * var1) / 524288.0 90 | var1 = (1.0 + var1 / 32768.0) * (dig_P1) 91 | p = 1048576.0 - adc_p 92 | p = (p - (var2 / 4096.0)) * 6250.0 / var1 93 | var1 = (dig_P9) * p * p / 2147483648.0 94 | var2 = p * (dig_P8) / 32768.0 95 | pressure = (p + (var1 + var2 + (dig_P7)) / 16.0) / 100 96 | 97 | # Output data to screen 98 | print "Pressure : %.2f hPa " %pressure 99 | print "Temperature in Celsius : %.2f C" %cTemp 100 | print "Temperature in Fahrenheit : %.2f F" %fTemp 101 | -------------------------------------------------------------------------------- /Particle/BMP280.ino: -------------------------------------------------------------------------------- 1 | // Distributed with a free-will license. 2 | // Use it any way you want, profit or free, provided it fits in the licenses of its associated works. 3 | // BMP280 4 | // This code is designed to work with the BMP280_I2CS I2C Mini Module available from ControlEverything.com. 5 | // https://www.controleverything.com/content/Barometer?sku=BMP280_I2CSs#tabs-0-product_tabset-2 6 | 7 | #include 8 | #include 9 | 10 | // BMP280 I2C address is 0x76(108) 11 | #define Addr 0x76 12 | 13 | double cTemp = 0.0, fTemp = 0.0, pressure = 0.0; 14 | void setup() 15 | { 16 | // Set variable 17 | Particle.variable("i2cdevice", "BMP280"); 18 | Particle.variable("cTemp", cTemp); 19 | Particle.variable("fTemp", fTemp); 20 | Particle.variable("pressure", pressure); 21 | 22 | // Initialise I2C communication as MASTER 23 | Wire.begin(); 24 | // Initialise Serial communication, set baud rate = 9600 25 | Serial.begin(9600); 26 | delay(300); 27 | } 28 | 29 | void loop() 30 | { 31 | unsigned int b1[24]; 32 | unsigned int data[8]; 33 | for (int i = 0; i < 24; i++) 34 | { 35 | // Start I2C Transmission 36 | Wire.beginTransmission(Addr); 37 | // Select data register 38 | Wire.write((136 + i)); 39 | // Stop I2C Transmission 40 | Wire.endTransmission(); 41 | 42 | // Request 1 byte of data 43 | Wire.requestFrom(Addr, 1); 44 | 45 | // Read 1 byte of data 46 | if (Wire.available() == 1) 47 | { 48 | b1[i] = Wire.read(); 49 | } 50 | } 51 | 52 | // Convert the data 53 | // temp coefficents 54 | int dig_T1 = (b1[0] & 0xff) + ((b1[1] & 0xff) * 256); 55 | int dig_T2 = b1[2] + (b1[3] * 256); 56 | if (dig_T2 > 32767) 57 | dig_T2 -= 65536; 58 | int dig_T3 = b1[4] + (b1[5] * 256); 59 | if (dig_T3 > 32767) 60 | dig_T3 -= 65536; 61 | 62 | // pressure coefficents 63 | int dig_P1 = (b1[6] & 0xff) + ((b1[7] & 0xff ) * 256); 64 | int dig_P2 = b1[8] + (b1[9] * 256); 65 | if (dig_P2 > 32767) 66 | dig_P2 -= 65536; 67 | int dig_P3 = b1[10] + (b1[11] * 256); 68 | if (dig_P3 > 32767) 69 | dig_P3 -= 65536; 70 | int dig_P4 = b1[12] + (b1[13] * 256); 71 | if (dig_P4 > 32767) 72 | dig_P4 -= 65536; 73 | int dig_P5 = b1[14] + (b1[15] * 256); 74 | if (dig_P5 > 32767) 75 | dig_P5 -= 65536; 76 | int dig_P6 = b1[16] + (b1[17] * 256); 77 | if (dig_P6 > 32767) 78 | dig_P6 -= 65536; 79 | int dig_P7 = b1[18] + (b1[19] * 256); 80 | if (dig_P7 > 32767) 81 | dig_P7 -= 65536; 82 | int dig_P8 = b1[20] + (b1[21] * 256); 83 | if (dig_P8 > 32767) 84 | dig_P8 -= 65536; 85 | int dig_P9 = b1[22] + (b1[23] * 256); 86 | if (dig_P9 > 32767) 87 | dig_P9 -= 65536; 88 | 89 | for (int i = 0; i < 7; i++) 90 | { 91 | // Start I2C Transmission 92 | Wire.beginTransmission(Addr); 93 | // Select data register 94 | Wire.write((225 + i)); 95 | // Stop I2C Transmission 96 | Wire.endTransmission(); 97 | 98 | // Request 1 byte of data 99 | Wire.requestFrom(Addr, 1); 100 | 101 | // Read 1 byte of data 102 | if (Wire.available() == 1) 103 | { 104 | b1[i] = Wire.read(); 105 | } 106 | } 107 | 108 | // Start I2C Transmission 109 | Wire.beginTransmission(Addr); 110 | // Select control measurement register 111 | Wire.write(0xF4); 112 | // Normal mode, temp and pressure over sampling rate = 1 113 | Wire.write(0x27); 114 | // Stop I2C Transmission 115 | Wire.endTransmission(); 116 | 117 | // Start I2C Transmission 118 | Wire.beginTransmission(Addr); 119 | // Select config register 120 | Wire.write(0xF5); 121 | // Stand_by time = 1000ms 122 | Wire.write(0xA0); 123 | // Stop I2C Transmission 124 | Wire.endTransmission(); 125 | 126 | for (int i = 0; i < 8; i++) 127 | { 128 | // Start I2C Transmission 129 | Wire.beginTransmission(Addr); 130 | // Select data register 131 | Wire.write((247 + i)); 132 | // Stop I2C Transmission 133 | Wire.endTransmission(); 134 | 135 | // Request 1 byte of data 136 | Wire.requestFrom(Addr, 1); 137 | 138 | // Read 1 byte of data 139 | if (Wire.available() == 1) 140 | { 141 | data[i] = Wire.read(); 142 | } 143 | } 144 | 145 | // Convert pressure and temperature data to 19-bits 146 | long adc_p = (((long)(data[0] & 0xFF) * 65536) + ((long)(data[1] & 0xFF) * 256) + (long)(data[2] & 0xF0)) / 16; 147 | long adc_t = (((long)(data[3] & 0xFF) * 65536) + ((long)(data[4] & 0xFF) * 256) + (long)(data[5] & 0xF0)) / 16; 148 | 149 | // Temperature offset calculations 150 | double var1 = (((double)adc_t) / 16384.0 - ((double)dig_T1) / 1024.0) * ((double)dig_T2); 151 | double var2 = ((((double)adc_t) / 131072.0 - ((double)dig_T1) / 8192.0) * 152 | (((double)adc_t) / 131072.0 - ((double)dig_T1) / 8192.0)) * ((double)dig_T3); 153 | double t_fine = (long)(var1 + var2); 154 | cTemp = (var1 + var2) / 5120.0; 155 | fTemp = cTemp * 1.8 + 32; 156 | 157 | // Pressure offset calculations 158 | var1 = ((double)t_fine / 2.0) - 64000.0; 159 | var2 = var1 * var1 * ((double)dig_P6) / 32768.0; 160 | var2 = var2 + var1 * ((double)dig_P5) * 2.0; 161 | var2 = (var2 / 4.0) + (((double)dig_P4) * 65536.0); 162 | var1 = (((double) dig_P3) * var1 * var1 / 524288.0 + ((double) dig_P2) * var1) / 524288.0; 163 | var1 = (1.0 + var1 / 32768.0) * ((double)dig_P1); 164 | double p = 1048576.0 - (double)adc_p; 165 | p = (p - (var2 / 4096.0)) * 6250.0 / var1; 166 | var1 = ((double) dig_P9) * p * p / 2147483648.0; 167 | var2 = p * ((double) dig_P8) / 32768.0; 168 | pressure = (p + (var1 + var2 + ((double)dig_P7)) / 16.0) / 100 ; 169 | 170 | // Output data to dashboard 171 | Particle.publish("Pressure : ", String(pressure)); 172 | delay(1000); 173 | Particle.publish("Temperature in Celsius : ", String(cTemp)); 174 | delay(1000); 175 | Particle.publish("Temperature in Fahrenheit : ", String(fTemp)); 176 | delay(1000); 177 | } 178 | -------------------------------------------------------------------------------- /Python/BMP280.py: -------------------------------------------------------------------------------- 1 | # Distributed with a free-will license. 2 | # Use it any way you want, profit or free, provided it fits in the licenses of its associated works. 3 | # BMP280 4 | # This code is designed to work with the BMP280_I2CS I2C Mini Module available from ControlEverything.com. 5 | # https://www.controleverything.com/content/Barometer?sku=BMP280_I2CSs#tabs-0-product_tabset-2 6 | 7 | 8 | import smbus 9 | import time 10 | 11 | # Get I2C bus 12 | bus = smbus.SMBus(1) 13 | 14 | # BMP280 address, 0x76(118) 15 | # Read data back from 0x88(136), 24 bytes 16 | b1 = bus.read_i2c_block_data(0x76, 0x88, 24) 17 | 18 | # Convert the data 19 | # Temp coefficents 20 | dig_T1 = b1[1] * 256 + b1[0] 21 | dig_T2 = b1[3] * 256 + b1[2] 22 | if dig_T2 > 32767 : 23 | dig_T2 -= 65536 24 | dig_T3 = b1[5] * 256 + b1[4] 25 | if dig_T3 > 32767 : 26 | dig_T3 -= 65536 27 | 28 | # Pressure coefficents 29 | dig_P1 = b1[7] * 256 + b1[6] 30 | dig_P2 = b1[9] * 256 + b1[8] 31 | if dig_P2 > 32767 : 32 | dig_P2 -= 65536 33 | dig_P3 = b1[11] * 256 + b1[10] 34 | if dig_P3 > 32767 : 35 | dig_P3 -= 65536 36 | dig_P4 = b1[13] * 256 + b1[12] 37 | if dig_P4 > 32767 : 38 | dig_P4 -= 65536 39 | dig_P5 = b1[15] * 256 + b1[14] 40 | if dig_P5 > 32767 : 41 | dig_P5 -= 65536 42 | dig_P6 = b1[17] * 256 + b1[16] 43 | if dig_P6 > 32767 : 44 | dig_P6 -= 65536 45 | dig_P7 = b1[19] * 256 + b1[18] 46 | if dig_P7 > 32767 : 47 | dig_P7 -= 65536 48 | dig_P8 = b1[21] * 256 + b1[20] 49 | if dig_P8 > 32767 : 50 | dig_P8 -= 65536 51 | dig_P9 = b1[23] * 256 + b1[22] 52 | if dig_P9 > 32767 : 53 | dig_P9 -= 65536 54 | 55 | # BMP280 address, 0x76(118) 56 | # Select Control measurement register, 0xF4(244) 57 | # 0x27(39) Pressure and Temperature Oversampling rate = 1 58 | # Normal mode 59 | bus.write_byte_data(0x76, 0xF4, 0x27) 60 | # BMP280 address, 0x76(118) 61 | # Select Configuration register, 0xF5(245) 62 | # 0xA0(00) Stand_by time = 1000 ms 63 | bus.write_byte_data(0x76, 0xF5, 0xA0) 64 | 65 | time.sleep(0.5) 66 | 67 | # BMP280 address, 0x76(118) 68 | # Read data back from 0xF7(247), 8 bytes 69 | # Pressure MSB, Pressure LSB, Pressure xLSB, Temperature MSB, Temperature LSB 70 | # Temperature xLSB, Humidity MSB, Humidity LSB 71 | data = bus.read_i2c_block_data(0x76, 0xF7, 8) 72 | 73 | # Convert pressure and temperature data to 19-bits 74 | adc_p = ((data[0] * 65536) + (data[1] * 256) + (data[2] & 0xF0)) / 16 75 | adc_t = ((data[3] * 65536) + (data[4] * 256) + (data[5] & 0xF0)) / 16 76 | 77 | # Temperature offset calculations 78 | var1 = ((adc_t) / 16384.0 - (dig_T1) / 1024.0) * (dig_T2) 79 | var2 = (((adc_t) / 131072.0 - (dig_T1) / 8192.0) * ((adc_t)/131072.0 - (dig_T1)/8192.0)) * (dig_T3) 80 | t_fine = (var1 + var2) 81 | cTemp = (var1 + var2) / 5120.0 82 | fTemp = cTemp * 1.8 + 32 83 | 84 | # Pressure offset calculations 85 | var1 = (t_fine / 2.0) - 64000.0 86 | var2 = var1 * var1 * (dig_P6) / 32768.0 87 | var2 = var2 + var1 * (dig_P5) * 2.0 88 | var2 = (var2 / 4.0) + ((dig_P4) * 65536.0) 89 | var1 = ((dig_P3) * var1 * var1 / 524288.0 + ( dig_P2) * var1) / 524288.0 90 | var1 = (1.0 + var1 / 32768.0) * (dig_P1) 91 | p = 1048576.0 - adc_p 92 | p = (p - (var2 / 4096.0)) * 6250.0 / var1 93 | var1 = (dig_P9) * p * p / 2147483648.0 94 | var2 = p * (dig_P8) / 32768.0 95 | pressure = (p + (var1 + var2 + (dig_P7)) / 16.0) / 100 96 | 97 | # Output data to screen 98 | print "Temperature in Celsius : %.2f C" %cTemp 99 | print "Temperature in Fahrenheit : %.2f F" %fTemp 100 | print "Pressure : %.2f hPa " %pressure 101 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | [![BMP280](BMP280_I2CS.png)](https://www.controleverything.com/content/Barometer?sku=BMP280_I2CS) 2 | # BMP280 3 | BMP280 Digital Pressure and Temperature Sensor 4 | 5 | The BMP280 is a combined pressure and temperature sensor. 6 | 7 | This Device is available from ControlEverything.com [SKU: BMP280_I2CS] 8 | 9 | https://www.controleverything.com/content/Barometer?sku=BMP280_I2CS 10 | 11 | This Sample code can be used with Raspberry Pi, Arduino, Particle Photon, Beaglebone Black and Onion Omega. 12 | 13 | ## Java 14 | Download and install pi4j library on Raspberry pi. Steps to install pi4j are provided at: 15 | 16 | http://pi4j.com/install.html 17 | 18 | Download (or git pull) the code in pi. 19 | 20 | Compile the java program. 21 | ```cpp 22 | $> pi4j BMP280.java 23 | ``` 24 | 25 | Run the java program. 26 | ```cpp 27 | $> pi4j BMP280 28 | ``` 29 | 30 | ## Python 31 | Download and install smbus library on Raspberry pi. Steps to install smbus are provided at: 32 | 33 | https://pypi.python.org/pypi/smbus-cffi/0.5.1 34 | 35 | Download (or git pull) the code in pi. Run the program. 36 | 37 | ```cpp 38 | $> python BMP280.py 39 | ``` 40 | 41 | ## Arduino 42 | Download and install Arduino Software (IDE) on your machine. Steps to install Arduino are provided at: 43 | 44 | https://www.arduino.cc/en/Main/Software 45 | 46 | Download (or git pull) the code and double click the file to run the program. 47 | 48 | Compile and upload the code on Arduino IDE and see the output on Serial Monitor. 49 | 50 | 51 | ## Particle Photon 52 | 53 | Login to your Photon and setup your device according to steps provided at: 54 | 55 | https://docs.particle.io/guide/getting-started/connect/photon/ 56 | 57 | Download (or git pull) the code. Go to online IDE and copy the code. 58 | 59 | https://build.particle.io/build/ 60 | 61 | Verify and flash the code on your Photon. Code output is shown in logs at dashboard: 62 | 63 | https://dashboard.particle.io/user/logs 64 | 65 | ## C 66 | 67 | Download (or git pull) the code in Beaglebone Black. 68 | 69 | Compile the c program. 70 | ```cpp 71 | $>gcc BMP280.c -o BMP280 72 | ``` 73 | Run the c program. 74 | ```cpp 75 | $>./BMP280 76 | ``` 77 | 78 | ## Onion Omega 79 | 80 | Get Started and setting up the Onion Omega according to steps provided at : 81 | 82 | https://wiki.onion.io/Get-Started 83 | 84 | To install the Python module, run the following commands: 85 | ```cpp 86 | opkg update 87 | ``` 88 | ```cpp 89 | opkg install python-light pyOnionI2C 90 | ``` 91 | 92 | Download (or git pull) the code in Onion Omega. Run the program. 93 | 94 | ```cpp 95 | $> python BMP280.py 96 | ``` 97 | 98 | #####The code output is the pressure in hPa and temperature reading in degree celsius and fahrenheit. 99 | --------------------------------------------------------------------------------