2020-12-07 08:17:00 +00:00
|
|
|
# Updated 2018 and 2020
|
2019-01-01 10:10:11 +00:00
|
|
|
# This module is based on the below cited resources, which are all
|
|
|
|
# based on the documentation as provided in the Bosch Data Sheet and
|
|
|
|
# the sample implementation provided therein.
|
|
|
|
#
|
|
|
|
# Final Document: BST-BME280-DS002-15
|
|
|
|
#
|
2018-11-11 15:01:02 +00:00
|
|
|
# Authors: Paul Cunnane 2016, Peter Dahlebrg 2016
|
|
|
|
#
|
|
|
|
# This module borrows from the Adafruit BME280 Python library. Original
|
|
|
|
# Copyright notices are reproduced below.
|
|
|
|
#
|
|
|
|
# Those libraries were written for the Raspberry Pi. This modification is
|
|
|
|
# intended for the MicroPython and esp8266 boards.
|
|
|
|
#
|
|
|
|
# Copyright (c) 2014 Adafruit Industries
|
|
|
|
# Author: Tony DiCola
|
|
|
|
#
|
|
|
|
# Based on the BMP280 driver with BME280 changes provided by
|
|
|
|
# David J Taylor, Edinburgh (www.satsignal.eu)
|
|
|
|
#
|
|
|
|
# Based on Adafruit_I2C.py created by Kevin Townsend.
|
|
|
|
#
|
|
|
|
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
# of this software and associated documentation files (the "Software"), to deal
|
|
|
|
# in the Software without restriction, including without limitation the rights
|
|
|
|
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
# copies of the Software, and to permit persons to whom the Software is
|
|
|
|
# furnished to do so, subject to the following conditions:
|
|
|
|
#
|
|
|
|
# The above copyright notice and this permission notice shall be included in
|
|
|
|
# all copies or substantial portions of the Software.
|
|
|
|
#
|
|
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
# THE SOFTWARE.
|
2019-01-01 10:10:11 +00:00
|
|
|
#
|
2018-11-11 15:01:02 +00:00
|
|
|
|
|
|
|
import time
|
|
|
|
from ustruct import unpack, unpack_from
|
|
|
|
from array import array
|
|
|
|
|
|
|
|
# BME280 default address.
|
|
|
|
BME280_I2CADDR = 0x76
|
|
|
|
|
|
|
|
# Operating Modes
|
|
|
|
BME280_OSAMPLE_1 = 1
|
|
|
|
BME280_OSAMPLE_2 = 2
|
|
|
|
BME280_OSAMPLE_4 = 3
|
|
|
|
BME280_OSAMPLE_8 = 4
|
|
|
|
BME280_OSAMPLE_16 = 5
|
|
|
|
|
|
|
|
BME280_REGISTER_CONTROL_HUM = 0xF2
|
2018-11-19 20:47:38 +00:00
|
|
|
BME280_REGISTER_STATUS = 0xF3
|
2018-11-11 15:01:02 +00:00
|
|
|
BME280_REGISTER_CONTROL = 0xF4
|
|
|
|
|
2019-12-19 14:49:15 +00:00
|
|
|
MODE_SLEEP = const(0)
|
|
|
|
MODE_FORCED = const(1)
|
|
|
|
MODE_NORMAL = const(3)
|
|
|
|
|
2020-11-28 12:12:37 +00:00
|
|
|
BME280_TIMEOUT = const(100) # about 1 second timeout
|
|
|
|
|
2018-11-11 15:01:02 +00:00
|
|
|
|
|
|
|
class BME280:
|
|
|
|
|
|
|
|
def __init__(self,
|
|
|
|
mode=BME280_OSAMPLE_8,
|
|
|
|
address=BME280_I2CADDR,
|
|
|
|
i2c=None,
|
|
|
|
**kwargs):
|
|
|
|
# Check that mode is valid.
|
|
|
|
if mode not in [BME280_OSAMPLE_1, BME280_OSAMPLE_2, BME280_OSAMPLE_4,
|
|
|
|
BME280_OSAMPLE_8, BME280_OSAMPLE_16]:
|
|
|
|
raise ValueError(
|
|
|
|
'Unexpected mode value {0}. Set mode to one of '
|
2019-12-27 16:56:58 +00:00
|
|
|
'BME280_OSAMPLE_1, BME280_OSAMPLE_2, BME280_OSAMPLE_4,'
|
|
|
|
'BME280_OSAMPLE_8, BME280_OSAMPLE_16'.format(mode))
|
2018-11-11 15:01:02 +00:00
|
|
|
self._mode = mode
|
|
|
|
self.address = address
|
|
|
|
if i2c is None:
|
|
|
|
raise ValueError('An I2C object is required.')
|
|
|
|
self.i2c = i2c
|
2018-11-18 19:20:08 +00:00
|
|
|
self.__sealevel = 101325
|
2018-11-11 15:01:02 +00:00
|
|
|
|
|
|
|
# load calibration data
|
|
|
|
dig_88_a1 = self.i2c.readfrom_mem(self.address, 0x88, 26)
|
|
|
|
dig_e1_e7 = self.i2c.readfrom_mem(self.address, 0xE1, 7)
|
|
|
|
self.dig_T1, self.dig_T2, self.dig_T3, self.dig_P1, \
|
|
|
|
self.dig_P2, self.dig_P3, self.dig_P4, self.dig_P5, \
|
|
|
|
self.dig_P6, self.dig_P7, self.dig_P8, self.dig_P9, \
|
|
|
|
_, self.dig_H1 = unpack("<HhhHhhhhhhhhBB", dig_88_a1)
|
|
|
|
|
2018-11-27 20:41:35 +00:00
|
|
|
self.dig_H2, self.dig_H3, self.dig_H4,\
|
2019-01-01 10:10:11 +00:00
|
|
|
self.dig_H5, self.dig_H6 = unpack("<hBbhb", dig_e1_e7)
|
2018-11-27 20:41:35 +00:00
|
|
|
# unfold H4, H5, keeping care of a potential sign
|
|
|
|
self.dig_H4 = (self.dig_H4 * 16) + (self.dig_H5 & 0xF)
|
|
|
|
self.dig_H5 //= 16
|
2018-11-11 15:01:02 +00:00
|
|
|
|
|
|
|
self.t_fine = 0
|
|
|
|
|
|
|
|
# temporary data holders which stay allocated
|
|
|
|
self._l1_barray = bytearray(1)
|
|
|
|
self._l8_barray = bytearray(8)
|
|
|
|
self._l3_resultarray = array("i", [0, 0, 0])
|
|
|
|
|
2019-12-19 14:49:15 +00:00
|
|
|
self._l1_barray[0] = self._mode << 5 | self._mode << 2 | MODE_SLEEP
|
|
|
|
self.i2c.writeto_mem(self.address, BME280_REGISTER_CONTROL,
|
|
|
|
bytearray([0x3c | MODE_SLEEP]))
|
|
|
|
|
2018-11-11 15:01:02 +00:00
|
|
|
def read_raw_data(self, result):
|
|
|
|
""" Reads the raw (uncompensated) data from the sensor.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
result: array of length 3 or alike where the result will be
|
|
|
|
stored, in temperature, pressure, humidity order
|
|
|
|
Returns:
|
|
|
|
None
|
|
|
|
"""
|
|
|
|
|
|
|
|
self._l1_barray[0] = self._mode
|
|
|
|
self.i2c.writeto_mem(self.address, BME280_REGISTER_CONTROL_HUM,
|
|
|
|
self._l1_barray)
|
2019-12-19 14:49:15 +00:00
|
|
|
self._l1_barray[0] = self._mode << 5 | self._mode << 2 | MODE_FORCED
|
2018-11-11 15:01:02 +00:00
|
|
|
self.i2c.writeto_mem(self.address, BME280_REGISTER_CONTROL,
|
|
|
|
self._l1_barray)
|
|
|
|
|
2018-11-19 20:47:38 +00:00
|
|
|
# Wait for conversion to complete
|
2020-11-28 12:12:37 +00:00
|
|
|
for _ in range(BME280_TIMEOUT):
|
|
|
|
if self.i2c.readfrom_mem(self.address, BME280_REGISTER_STATUS, 1)[0] & 0x08:
|
|
|
|
time.sleep_ms(10) # still busy
|
|
|
|
else:
|
|
|
|
break # Sensor ready
|
|
|
|
else:
|
|
|
|
raise RuntimeError("Sensor BME280 not ready")
|
2018-11-11 15:01:02 +00:00
|
|
|
|
|
|
|
# burst readout from 0xF7 to 0xFE, recommended by datasheet
|
|
|
|
self.i2c.readfrom_mem_into(self.address, 0xF7, self._l8_barray)
|
|
|
|
readout = self._l8_barray
|
|
|
|
# pressure(0xF7): ((msb << 16) | (lsb << 8) | xlsb) >> 4
|
|
|
|
raw_press = ((readout[0] << 16) | (readout[1] << 8) | readout[2]) >> 4
|
|
|
|
# temperature(0xFA): ((msb << 16) | (lsb << 8) | xlsb) >> 4
|
|
|
|
raw_temp = ((readout[3] << 16) | (readout[4] << 8) | readout[5]) >> 4
|
|
|
|
# humidity(0xFD): (msb << 8) | lsb
|
|
|
|
raw_hum = (readout[6] << 8) | readout[7]
|
|
|
|
|
|
|
|
result[0] = raw_temp
|
|
|
|
result[1] = raw_press
|
|
|
|
result[2] = raw_hum
|
|
|
|
|
|
|
|
def read_compensated_data(self, result=None):
|
|
|
|
""" Reads the data from the sensor and returns the compensated data.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
result: array of length 3 or alike where the result will be
|
|
|
|
stored, in temperature, pressure, humidity order. You may use
|
|
|
|
this to read out the sensor without allocating heap memory
|
|
|
|
|
|
|
|
Returns:
|
2019-01-01 10:10:11 +00:00
|
|
|
array with temperature, pressure, humidity. Will be the one
|
|
|
|
from the result parameter if not None
|
2018-11-11 15:01:02 +00:00
|
|
|
"""
|
|
|
|
self.read_raw_data(self._l3_resultarray)
|
|
|
|
raw_temp, raw_press, raw_hum = self._l3_resultarray
|
|
|
|
# temperature
|
|
|
|
var1 = (((raw_temp // 8) - (self.dig_T1 * 2)) * self.dig_T2) // 2048
|
|
|
|
var2 = (raw_temp // 16) - self.dig_T1
|
|
|
|
var2 = (((var2 * var2) // 4096) * self.dig_T3) // 16384
|
|
|
|
self.t_fine = var1 + var2
|
|
|
|
temp = (self.t_fine * 5 + 128) // 256
|
|
|
|
|
|
|
|
# pressure
|
|
|
|
var1 = self.t_fine - 128000
|
|
|
|
var2 = var1 * var1 * self.dig_P6
|
|
|
|
var2 = var2 + ((var1 * self.dig_P5) << 17)
|
|
|
|
var2 = var2 + (self.dig_P4 << 35)
|
|
|
|
var1 = (((var1 * var1 * self.dig_P3) >> 8) +
|
|
|
|
((var1 * self.dig_P2) << 12))
|
|
|
|
var1 = (((1 << 47) + var1) * self.dig_P1) >> 33
|
|
|
|
if var1 == 0:
|
|
|
|
pressure = 0
|
|
|
|
else:
|
|
|
|
p = ((((1048576 - raw_press) << 31) - var2) * 3125) // var1
|
|
|
|
var1 = (self.dig_P9 * (p >> 13) * (p >> 13)) >> 25
|
|
|
|
var2 = (self.dig_P8 * p) >> 19
|
|
|
|
pressure = ((p + var1 + var2) >> 8) + (self.dig_P7 << 4)
|
|
|
|
|
|
|
|
# humidity
|
|
|
|
h = self.t_fine - 76800
|
|
|
|
h = (((((raw_hum << 14) - (self.dig_H4 << 20) -
|
2019-01-01 10:10:11 +00:00
|
|
|
(self.dig_H5 * h)) + 16384) >> 15) *
|
|
|
|
(((((((h * self.dig_H6) >> 10) *
|
|
|
|
(((h * self.dig_H3) >> 11) + 32768)) >> 10) + 2097152) *
|
|
|
|
self.dig_H2 + 8192) >> 14))
|
2018-11-11 15:01:02 +00:00
|
|
|
h = h - (((((h >> 15) * (h >> 15)) >> 7) * self.dig_H1) >> 4)
|
|
|
|
h = 0 if h < 0 else h
|
|
|
|
h = 419430400 if h > 419430400 else h
|
|
|
|
humidity = h >> 12
|
|
|
|
|
|
|
|
if result:
|
|
|
|
result[0] = temp
|
|
|
|
result[1] = pressure
|
|
|
|
result[2] = humidity
|
|
|
|
return result
|
|
|
|
|
|
|
|
return array("i", (temp, pressure, humidity))
|
|
|
|
|
2018-11-18 19:20:08 +00:00
|
|
|
@property
|
|
|
|
def sealevel(self):
|
|
|
|
return self.__sealevel
|
|
|
|
|
|
|
|
@sealevel.setter
|
|
|
|
def sealevel(self, value):
|
2019-01-01 10:10:11 +00:00
|
|
|
if 300 < value < 1200: # just ensure some reasonable value
|
2018-11-18 19:20:08 +00:00
|
|
|
self.__sealevel = value
|
|
|
|
|
|
|
|
@property
|
|
|
|
def altitude(self):
|
|
|
|
'''
|
|
|
|
Altitude in m.
|
|
|
|
'''
|
|
|
|
from math import pow
|
|
|
|
try:
|
2019-01-01 10:10:11 +00:00
|
|
|
p = 44330 * (1.0 - pow((self.read_compensated_data()[1] / 256) /
|
|
|
|
self.__sealevel, 0.1903))
|
2018-11-18 19:20:08 +00:00
|
|
|
except:
|
|
|
|
p = 0.0
|
|
|
|
return p
|
|
|
|
|
|
|
|
@property
|
|
|
|
def dew_point(self):
|
|
|
|
"""
|
|
|
|
Compute the dew point temperature for the current Temperature
|
|
|
|
and Humidity measured pair
|
|
|
|
"""
|
|
|
|
from math import log
|
|
|
|
t, p, h = self.read_compensated_data()
|
|
|
|
t /= 100
|
|
|
|
h /= 1024
|
|
|
|
h = (log(h, 10) - 2) / 0.4343 + (17.62 * t) / (243.12 + t)
|
|
|
|
return (243.12 * h / (17.62 - h)) * 100
|
|
|
|
|
2018-11-11 15:01:02 +00:00
|
|
|
@property
|
|
|
|
def values(self):
|
|
|
|
""" human readable values """
|
|
|
|
|
|
|
|
t, p, h = self.read_compensated_data()
|
|
|
|
|
|
|
|
p = p / 256
|
|
|
|
|
|
|
|
h = h / 1024
|
|
|
|
return ("{}C".format(t / 100), "{:.02f}hPa".format(p/100),
|
|
|
|
"{:.02f}%".format(h))
|