kopia lustrzana https://github.com/peterhinch/mpy_bme280_esp8266
187 wiersze
7.8 KiB
Python
187 wiersze
7.8 KiB
Python
# Author: Paul Cunnane 2016
|
|
#
|
|
# This module borrows heavily from the Adafruit BME280 Python library
|
|
# and the Adafruit GPIO/I2C 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.
|
|
|
|
import time
|
|
from bme280_const import *
|
|
from i2c_device import Device
|
|
|
|
class BME280:
|
|
def __init__(self, mode=BME280_OSAMPLE_1, 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 '
|
|
'BME280_ULTRALOWPOWER, BME280_STANDARD, BME280_HIGHRES, or '
|
|
'BME280_ULTRAHIGHRES'.format(mode))
|
|
self._mode = mode
|
|
# Create I2C device.
|
|
if i2c is None:
|
|
raise ValueError('An I2C object is required.')
|
|
self._device = Device(address, i2c)
|
|
|
|
# Load calibration values.
|
|
self.dig_T1 = self._device.readU16LE(BME280_REGISTER_DIG_T1)
|
|
self.dig_T2 = self._device.readS16LE(BME280_REGISTER_DIG_T2)
|
|
self.dig_T3 = self._device.readS16LE(BME280_REGISTER_DIG_T3)
|
|
|
|
self.dig_P1 = self._device.readU16LE(BME280_REGISTER_DIG_P1)
|
|
self.dig_P2 = self._device.readS16LE(BME280_REGISTER_DIG_P2)
|
|
self.dig_P3 = self._device.readS16LE(BME280_REGISTER_DIG_P3)
|
|
self.dig_P4 = self._device.readS16LE(BME280_REGISTER_DIG_P4)
|
|
self.dig_P5 = self._device.readS16LE(BME280_REGISTER_DIG_P5)
|
|
self.dig_P6 = self._device.readS16LE(BME280_REGISTER_DIG_P6)
|
|
self.dig_P7 = self._device.readS16LE(BME280_REGISTER_DIG_P7)
|
|
self.dig_P8 = self._device.readS16LE(BME280_REGISTER_DIG_P8)
|
|
self.dig_P9 = self._device.readS16LE(BME280_REGISTER_DIG_P9)
|
|
|
|
self.dig_H1 = self._device.readU8(BME280_REGISTER_DIG_H1)
|
|
self.dig_H2 = self._device.readS16LE(BME280_REGISTER_DIG_H2)
|
|
self.dig_H3 = self._device.readU8(BME280_REGISTER_DIG_H3)
|
|
self.dig_H6 = self._device.readS8(BME280_REGISTER_DIG_H7)
|
|
|
|
h4 = self._device.readS8(BME280_REGISTER_DIG_H4)
|
|
h4 = (h4 << 24) >> 20
|
|
self.dig_H4 = h4 | (self._device.readU8(BME280_REGISTER_DIG_H5) & 0x0F)
|
|
|
|
h5 = self._device.readS8(BME280_REGISTER_DIG_H6)
|
|
h5 = (h5 << 24) >> 20
|
|
self.dig_H5 = h5 | (
|
|
self._device.readU8(BME280_REGISTER_DIG_H5) >> 4 & 0x0F)
|
|
|
|
|
|
self._device.write8(BME280_REGISTER_CONTROL, 0x3F)
|
|
self.t_fine = 0
|
|
|
|
def read_raw_temp(self):
|
|
"""Reads the raw (uncompensated) temperature from the sensor."""
|
|
meas = self._mode
|
|
self._device.write8(BME280_REGISTER_CONTROL_HUM, meas)
|
|
meas = self._mode << 5 | self._mode << 2 | 1
|
|
self._device.write8(BME280_REGISTER_CONTROL, meas)
|
|
sleep_time = 1250 + 2300 * (1 << self._mode)
|
|
sleep_time = sleep_time + 2300 * (1 << self._mode) + 575
|
|
sleep_time = sleep_time + 2300 * (1 << self._mode) + 575
|
|
time.sleep_us(sleep_time) # Wait the required time
|
|
msb = self._device.readU8(BME280_REGISTER_TEMP_DATA)
|
|
lsb = self._device.readU8(BME280_REGISTER_TEMP_DATA + 1)
|
|
xlsb = self._device.readU8(BME280_REGISTER_TEMP_DATA + 2)
|
|
raw = ((msb << 16) | (lsb << 8) | xlsb) >> 4
|
|
return raw
|
|
|
|
def read_raw_pressure(self):
|
|
"""Reads the raw (uncompensated) pressure level from the sensor."""
|
|
"""Assumes that the temperature has already been read """
|
|
"""i.e. that enough delay has been provided"""
|
|
msb = self._device.readU8(BME280_REGISTER_PRESSURE_DATA)
|
|
lsb = self._device.readU8(BME280_REGISTER_PRESSURE_DATA + 1)
|
|
xlsb = self._device.readU8(BME280_REGISTER_PRESSURE_DATA + 2)
|
|
raw = ((msb << 16) | (lsb << 8) | xlsb) >> 4
|
|
return raw
|
|
|
|
def read_raw_humidity(self):
|
|
"""Assumes that the temperature has already been read """
|
|
"""i.e. that enough delay has been provided"""
|
|
msb = self._device.readU8(BME280_REGISTER_HUMIDITY_DATA)
|
|
lsb = self._device.readU8(BME280_REGISTER_HUMIDITY_DATA + 1)
|
|
raw = (msb << 8) | lsb
|
|
return raw
|
|
|
|
def read_temperature(self):
|
|
"""Get the compensated temperature in 0.01 of a degree celsius."""
|
|
adc = self.read_raw_temp()
|
|
var1 = ((adc >> 3) - (self.dig_T1 << 1)) * (self.dig_T2 >> 11)
|
|
var2 = ((
|
|
(((adc >> 4) - self.dig_T1) * ((adc >> 4) - self.dig_T1)) >> 12) *
|
|
self.dig_T3) >> 14
|
|
self.t_fine = var1 + var2
|
|
return (self.t_fine * 5 + 128) >> 8
|
|
|
|
def read_pressure(self):
|
|
"""Gets the compensated pressure in Pascals."""
|
|
adc = self.read_raw_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:
|
|
return 0
|
|
p = 1048576 - adc
|
|
p = (((p << 31) - var2) * 3125) // var1
|
|
var1 = (self.dig_P9 * (p >> 13) * (p >> 13)) >> 25
|
|
var2 = (self.dig_P8 * p) >> 19
|
|
return ((p + var1 + var2) >> 8) + (self.dig_P7 << 4)
|
|
|
|
def read_humidity(self):
|
|
adc = self.read_raw_humidity()
|
|
# print 'Raw humidity = {0:d}'.format (adc)
|
|
h = self.t_fine - 76800
|
|
h = (((((adc << 14) - (self.dig_H4 << 20) - (self.dig_H5 * h)) +
|
|
16384) >> 15) * (((((((h * self.dig_H6) >> 10) * (((h *
|
|
self.dig_H3) >> 11) + 32768)) >> 10) + 2097152) *
|
|
self.dig_H2 + 8192) >> 14))
|
|
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
|
|
return h >> 12
|
|
|
|
@property
|
|
def temperature(self):
|
|
"Return the temperature in degrees."
|
|
t = self.read_temperature()
|
|
ti = t // 100
|
|
td = t - ti * 100
|
|
return "{}.{:02d}C".format(ti, td)
|
|
|
|
@property
|
|
def pressure(self):
|
|
"Return the temperature in hPa."
|
|
p = self.read_pressure() // 256
|
|
pi = p // 100
|
|
pd = p - pi * 100
|
|
return "{}.{:02d}hPa".format(pi, pd)
|
|
|
|
@property
|
|
def humidity(self):
|
|
"Return the humidity in percent."
|
|
h = self.read_humidity()
|
|
hi = h // 1024
|
|
hd = h * 100 // 1024 - hi * 100
|
|
return "{}.{:02d}%".format(hi, hd)
|