Initial commit

Eoin Fennessy · Eoin Fennessy · commit 7efd457b2de5 · 2022-05-03T16:45:27.000+01:00
diff --git a/bme280.py b/bme280.py
@@ -0,0 +1,203 @@
+# 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.
+
+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
+BME280_REGISTER_CONTROL = 0xF4
+
+
+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
+        self.address = address
+        if i2c is None:
+            raise ValueError('An I2C object is required.')
+        self.i2c = i2c
+
+        # 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)
+
+        self.dig_H2, self.dig_H3 = unpack("<hB", dig_e1_e7)
+        e4_sign = unpack_from("<b", dig_e1_e7, 3)[0]
+        self.dig_H4 = (e4_sign << 4) | (dig_e1_e7[4] & 0xF)
+
+        e6_sign = unpack_from("<b", dig_e1_e7, 5)[0]
+        self.dig_H5 = (e6_sign << 4) | (dig_e1_e7[4] >> 4)
+
+        self.dig_H6 = unpack_from("<b", dig_e1_e7, 6)[0]
+
+        self.i2c.writeto_mem(self.address, BME280_REGISTER_CONTROL,
+                             bytearray([0x3F]))
+        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])
+
+    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)
+        self._l1_barray[0] = self._mode << 5 | self._mode << 2 | 1
+        self.i2c.writeto_mem(self.address, BME280_REGISTER_CONTROL,
+                             self._l1_barray)
+
+        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
+
+        # 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:
+                array with temperature, pressure, humidity. Will be the one from
+                the result parameter if not None
+        """
+        self.read_raw_data(self._l3_resultarray)
+        raw_temp, raw_press, raw_hum = self._l3_resultarray
+        # temperature
+        var1 = ((raw_temp >> 3) - (self.dig_T1 << 1)) * (self.dig_T2 >> 11)
+        var2 = (((((raw_temp >> 4) - self.dig_T1) *
+                  ((raw_temp >> 4) - self.dig_T1)) >> 12) * self.dig_T3) >> 14
+        self.t_fine = var1 + var2
+        temp = (self.t_fine * 5 + 128) >> 8
+
+        # 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
+            p = (((p << 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) -
+                (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
+        humidity = h >> 12
+
+        if result:
+            result[0] = temp
+            result[1] = pressure
+            result[2] = humidity
+            return result
+
+        return array("i", (temp, pressure, humidity))
+
+    @property
+    def values(self):
+        """ human readable values """
+
+        t, p, h = self.read_compensated_data()
+
+        p = p // 256
+        pi = p // 100
+        pd = p - pi * 100
+
+        hi = h // 1024
+        hd = h * 100 // 1024 - hi * 100
+        return ("{}C".format(t / 100), "{}.{:02d}hPa".format(pi, pd),
+                "{}.{:02d}%".format(hi, hd))
diff --git a/config.json b/config.json
@@ -0,0 +1,7 @@
+{
+    "filename": "test",
+    "minutes_between_logs": 1,
+    "i2c_bus_id": 1,
+    "scl_pin": 7,
+    "sda_pin": 6
+}
diff --git a/main.py b/main.py
@@ -0,0 +1,62 @@
+'''
+Weather-logging MicroPython script for Raspberry Pico and BME280 sensor
+
+Logs timestamped readings of temperature in celsius, humidity percentage,
+and air pressure in hPa to a CSV file
+
+Use config.json to change filename, log frequency and hardware settings
+
+Note that because the Pico does not have a real-time clock, UTC timestamp
+always starts at 1609459201 on battery power
+'''
+
+import bme280
+import json
+import machine
+import os
+import time
+
+config = json.load(open('config.json'))
+filename = config['filename'] + '.csv'
+
+# Set up hardware config and create sensor reader
+i2c = machine.I2C(id=config['i2c_bus_id'],
+                  scl=machine.Pin(config['scl_pin']),
+                  sda=machine.Pin(config['sda_pin']))
+bme = bme280.BME280(i2c=i2c)
+led = machine.Pin(25, machine.Pin.OUT)
+
+# Discard erroneous initial reading
+bme.read_compensated_data()
+
+# Sleep for a millisecond to prevent further bad readings
+time.sleep(.01)
+
+# Create file and write headers if file doesn't already exist
+if filename not in os.listdir():
+    with open(filename, 'w') as file:
+        file.write('Timestamp, Temperature, Pressure, Humidity\n')
+
+while True:
+    # If current second is zero
+    if time.localtime()[5] == 0:
+        timestamp = time.time()
+        
+        # Take reading and apply conversions
+        t, p, h = bme.read_compensated_data()
+        temperature = t / 100
+        pressure = p // 256 / 100
+        humidity = round(h / 1024, 2)
+        
+        
+        # Append row to CSV file
+        with open(filename, 'a') as file:
+            file.write('{}, {}, {}, {}\n'.format(timestamp, temperature,
+                                                 pressure, humidity))
+            
+        # Blink LED after log
+        led.value(1)
+        time.sleep(.25)
+        led.value(0)
+    
+        time.sleep(config['minutes_between_logs'] * 60 - 1)
