updated scripts and unique id generation with form for mqtt connection

app.py

@@ -12,8 +12,8 @@ st.title("Real-Time Sensor Data Dashboard")
 with st.form("mqtt_form"):
     MQTT_HOST = st.text_input("Enter your MQTT host:", "b6bdb89571144b3d8e5ca4bbe666ddb5.s1.eu.hivemq.cloud")
     MQTT_PORT = st.number_input("Enter the port number:", min_value=1, max_value=65535, value=8883)
-    MQTT_USERNAME = st.text_input("Enter your MQTT username:", "Luthiraa")
-    MQTT_PASSWORD = st.text_input("Enter your MQTT password:", "theboss1010", type="password")
+    MQTT_USERNAME = st.text_input("Enter your MQTT username:", "LuthiraMQ")
+    MQTT_PASSWORD = st.text_input("Enter your MQTT password:", "jLVx8y9v83gmgERTr0AP", type="password")
     MQTT_TOPIC = st.text_input("Enter your MQTT topic:", "sensors/bme680/data")
     submit_button = st.form_submit_button(label="Submit")
 

scripts/adafruit_bme680.py

@@ -0,0 +1,769 @@
+# SPDX-FileCopyrightText: 2017 ladyada for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT AND BSD-3-Clause
+
+
+"""
+`adafruit_bme680`
+================================================================================
+
+CircuitPython library for BME680 temperature, pressure and humidity sensor.
+
+
+* Author(s): Limor Fried, William Garber, many others
+
+
+Implementation Notes
+--------------------
+
+**Hardware:**
+
+* `Adafruit BME680 Temp, Humidity, Pressure and Gas Sensor <https://www.adafruit.com/product/3660>`_
+
+**Software and Dependencies:**
+
+* Adafruit CircuitPython firmware for the supported boards:
+  https://github.com/adafruit/circuitpython/releases
+* Adafruit's Bus Device library: https://github.com/adafruit/Adafruit_CircuitPython_BusDevice
+"""
+
+import math
+import struct
+import time
+
+from micropython import const
+
+
+def delay_microseconds(nusec):
+    """HELP must be same as dev->delay_us"""
+    time.sleep(nusec / 1000000.0)
+
+
+try:
+    # Used only for type annotations.
+
+    import typing
+
+    from busio import I2C, SPI
+    from circuitpython_typing import ReadableBuffer
+    from digitalio import DigitalInOut
+
+except ImportError:
+    pass
+
+__version__ = "3.7.9"
+__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_BME680.git"
+
+
+#    I2C ADDRESS/BITS/SETTINGS NEW
+#    -----------------------------------------------------------------------
+_BME68X_ENABLE_HEATER = const(0x00)
+_BME68X_DISABLE_HEATER = const(0x01)
+_BME68X_DISABLE_GAS_MEAS = const(0x00)
+_BME68X_ENABLE_GAS_MEAS_L = const(0x01)
+_BME68X_ENABLE_GAS_MEAS_H = const(0x02)
+_BME68X_SLEEP_MODE = const(0)
+_BME68X_FORCED_MODE = const(1)
+_BME68X_VARIANT_GAS_LOW = const(0x00)
+_BME68X_VARIANT_GAS_HIGH = const(0x01)
+_BME68X_HCTRL_MSK = const(0x08)
+_BME68X_HCTRL_POS = const(3)
+_BME68X_NBCONV_MSK = const(0x0F)
+_BME68X_RUN_GAS_MSK = const(0x30)
+_BME68X_RUN_GAS_POS = const(4)
+_BME68X_MODE_MSK = const(0x03)
+_BME68X_PERIOD_POLL = const(10000)
+_BME68X_REG_CTRL_GAS_0 = const(0x70)
+_BME68X_REG_CTRL_GAS_1 = const(0x71)
+
+#    I2C ADDRESS/BITS/SETTINGS
+#    -----------------------------------------------------------------------
+_BME680_CHIPID = const(0x61)
+
+_BME680_REG_CHIPID = const(0xD0)
+_BME68X_REG_VARIANT = const(0xF0)
+_BME680_BME680_COEFF_ADDR1 = const(0x89)
+_BME680_BME680_COEFF_ADDR2 = const(0xE1)
+_BME680_BME680_RES_HEAT_0 = const(0x5A)
+_BME680_BME680_GAS_WAIT_0 = const(0x64)
+
+_BME680_REG_SOFTRESET = const(0xE0)
+_BME680_REG_CTRL_GAS = const(0x71)
+_BME680_REG_CTRL_HUM = const(0x72)
+_BME680_REG_STATUS = const(0x73)
+_BME680_REG_CTRL_MEAS = const(0x74)
+_BME680_REG_CONFIG = const(0x75)
+
+_BME680_REG_MEAS_STATUS = const(0x1D)
+_BME680_REG_PDATA = const(0x1F)
+_BME680_REG_TDATA = const(0x22)
+_BME680_REG_HDATA = const(0x25)
+
+_BME680_SAMPLERATES = (0, 1, 2, 4, 8, 16)
+_BME680_FILTERSIZES = (0, 1, 3, 7, 15, 31, 63, 127)
+
+_BME680_RUNGAS = const(0x10)
+
+_LOOKUP_TABLE_1 = (
+    2147483647.0,
+    2147483647.0,
+    2147483647.0,
+    2147483647.0,
+    2147483647.0,
+    2126008810.0,
+    2147483647.0,
+    2130303777.0,
+    2147483647.0,
+    2147483647.0,
+    2143188679.0,
+    2136746228.0,
+    2147483647.0,
+    2126008810.0,
+    2147483647.0,
+    2147483647.0,
+)
+
+_LOOKUP_TABLE_2 = (
+    4096000000.0,
+    2048000000.0,
+    1024000000.0,
+    512000000.0,
+    255744255.0,
+    127110228.0,
+    64000000.0,
+    32258064.0,
+    16016016.0,
+    8000000.0,
+    4000000.0,
+    2000000.0,
+    1000000.0,
+    500000.0,
+    250000.0,
+    125000.0,
+)
+
+
+def bme_set_bits(reg_data, bitname_msk, bitname_pos, data):
+    """
+    Macro to set bits
+    data2 = data << bitname_pos
+    set masked bits from data2 in reg_data
+    """
+    return (reg_data & ~bitname_msk) | ((data << bitname_pos) & bitname_msk)
+
+
+def bme_set_bits_pos_0(reg_data, bitname_msk, data):
+    """
+    Macro to set bits starting from position 0
+    set masked bits from data in reg_data
+    """
+    return (reg_data & ~bitname_msk) | (data & bitname_msk)
+
+
+def _read24(arr: ReadableBuffer) -> float:
+    """Parse an unsigned 24-bit value as a floating point and return it."""
+    ret = 0.0
+    # print([hex(i) for i in arr])
+    for b in arr:
+        ret *= 256.0
+        ret += float(b & 0xFF)
+    return ret
+
+
+class Adafruit_BME680:
+    """Driver from BME680 air quality sensor
+
+    :param int refresh_rate: Maximum number of readings per second. Faster property reads
+      will be from the previous reading."""
+
+    def __init__(self, *, refresh_rate: int = 10) -> None:
+        """Check the BME680 was found, read the coefficients and enable the sensor for continuous
+        reads."""
+        self._write(_BME680_REG_SOFTRESET, [0xB6])
+        time.sleep(0.005)
+
+        # Check device ID.
+        chip_id = self._read_byte(_BME680_REG_CHIPID)
+        if chip_id != _BME680_CHIPID:
+            raise RuntimeError("Failed to find BME680! Chip ID 0x%x" % chip_id)
+
+        # Get variant
+        self._chip_variant = self._read_byte(_BME68X_REG_VARIANT)
+
+        self._read_calibration()
+
+        # set up heater
+        self._write(_BME680_BME680_RES_HEAT_0, [0x73])
+        self._write(_BME680_BME680_GAS_WAIT_0, [0x65])
+
+        self.sea_level_pressure = 1013.25
+        """Pressure in hectoPascals at sea level. Used to calibrate :attr:`altitude`."""
+
+        # Default oversampling and filter register values.
+        self._pressure_oversample = 0b011
+        self._temp_oversample = 0b100
+        self._humidity_oversample = 0b010
+        self._filter = 0b010
+
+        # Gas measurements, as a mask applied to _BME680_RUNGAS
+        self._run_gas = 0xFF
+
+        self._adc_pres = None
+        self._adc_temp = None
+        self._adc_hum = None
+        self._adc_gas = None
+        self._gas_range = None
+        self._t_fine = None
+
+        self._last_reading = 0
+        self._min_refresh_time = 1 / refresh_rate
+
+        self._amb_temp = 25  # Copy required parameters from reference bme68x_dev struct
+        self.set_gas_heater(320, 150)  # heater 320 deg C for 150 msec
+
+    @property
+    def pressure_oversample(self) -> int:
+        """The oversampling for pressure sensor"""
+        return _BME680_SAMPLERATES[self._pressure_oversample]
+
+    @pressure_oversample.setter
+    def pressure_oversample(self, sample_rate: int) -> None:
+        if sample_rate in _BME680_SAMPLERATES:
+            self._pressure_oversample = _BME680_SAMPLERATES.index(sample_rate)
+        else:
+            raise RuntimeError("Invalid oversample")
+
+    @property
+    def humidity_oversample(self) -> int:
+        """The oversampling for humidity sensor"""
+        return _BME680_SAMPLERATES[self._humidity_oversample]
+
+    @humidity_oversample.setter
+    def humidity_oversample(self, sample_rate: int) -> None:
+        if sample_rate in _BME680_SAMPLERATES:
+            self._humidity_oversample = _BME680_SAMPLERATES.index(sample_rate)
+        else:
+            raise RuntimeError("Invalid oversample")
+
+    @property
+    def temperature_oversample(self) -> int:
+        """The oversampling for temperature sensor"""
+        return _BME680_SAMPLERATES[self._temp_oversample]
+
+    @temperature_oversample.setter
+    def temperature_oversample(self, sample_rate: int) -> None:
+        if sample_rate in _BME680_SAMPLERATES:
+            self._temp_oversample = _BME680_SAMPLERATES.index(sample_rate)
+        else:
+            raise RuntimeError("Invalid oversample")
+
+    @property
+    def filter_size(self) -> int:
+        """The filter size for the built in IIR filter"""
+        return _BME680_FILTERSIZES[self._filter]
+
+    @filter_size.setter
+    def filter_size(self, size: int) -> None:
+        if size in _BME680_FILTERSIZES:
+            self._filter = _BME680_FILTERSIZES.index(size)
+        else:
+            raise RuntimeError("Invalid size")
+
+    @property
+    def temperature(self) -> float:
+        """The compensated temperature in degrees Celsius."""
+        self._perform_reading()
+        calc_temp = ((self._t_fine * 5) + 128) / 256
+        return calc_temp / 100
+
+    @property
+    def pressure(self) -> float:
+        """The barometric pressure in hectoPascals"""
+        self._perform_reading()
+        var1 = (self._t_fine / 2) - 64000
+        var2 = ((var1 / 4) * (var1 / 4)) / 2048
+        var2 = (var2 * self._pressure_calibration[5]) / 4
+        var2 = var2 + (var1 * self._pressure_calibration[4] * 2)
+        var2 = (var2 / 4) + (self._pressure_calibration[3] * 65536)
+        var1 = ((((var1 / 4) * (var1 / 4)) / 8192) * (self._pressure_calibration[2] * 32) / 8) + (
+            (self._pressure_calibration[1] * var1) / 2
+        )
+        var1 = var1 / 262144
+        var1 = ((32768 + var1) * self._pressure_calibration[0]) / 32768
+        calc_pres = 1048576 - self._adc_pres
+        calc_pres = (calc_pres - (var2 / 4096)) * 3125
+        calc_pres = (calc_pres / var1) * 2
+        var1 = (self._pressure_calibration[8] * (((calc_pres / 8) * (calc_pres / 8)) / 8192)) / 4096
+        var2 = ((calc_pres / 4) * self._pressure_calibration[7]) / 8192
+        var3 = (((calc_pres / 256) ** 3) * self._pressure_calibration[9]) / 131072
+        calc_pres += (var1 + var2 + var3 + (self._pressure_calibration[6] * 128)) / 16
+        return calc_pres / 100
+
+    @property
+    def relative_humidity(self) -> float:
+        """The relative humidity in RH %"""
+        return self.humidity
+
+    @property
+    def humidity(self) -> float:
+        """The relative humidity in RH %"""
+        self._perform_reading()
+        temp_scaled = ((self._t_fine * 5) + 128) / 256
+        var1 = (self._adc_hum - (self._humidity_calibration[0] * 16)) - (
+            (temp_scaled * self._humidity_calibration[2]) / 200
+        )
+        var2 = (
+            self._humidity_calibration[1]
+            * (
+                ((temp_scaled * self._humidity_calibration[3]) / 100)
+                + (
+                    ((temp_scaled * ((temp_scaled * self._humidity_calibration[4]) / 100)) / 64)
+                    / 100
+                )
+                + 16384
+            )
+        ) / 1024
+        var3 = var1 * var2
+        var4 = self._humidity_calibration[5] * 128
+        var4 = (var4 + ((temp_scaled * self._humidity_calibration[6]) / 100)) / 16
+        var5 = ((var3 / 16384) * (var3 / 16384)) / 1024
+        var6 = (var4 * var5) / 2
+        calc_hum = (((var3 + var6) / 1024) * 1000) / 4096
+        calc_hum /= 1000  # get back to RH
+
+        calc_hum = min(calc_hum, 100)
+        calc_hum = max(calc_hum, 0)
+        return calc_hum
+
+    @property
+    def altitude(self) -> float:
+        """The altitude based on current :attr:`pressure` vs the sea level pressure
+        (:attr:`sea_level_pressure`) - which you must enter ahead of time)"""
+        pressure = self.pressure  # in Si units for hPascal
+        return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))
+
+    @property
+    def gas(self) -> int:
+        """The gas resistance in ohms"""
+        self._perform_reading()
+        if self._chip_variant == 0x01:
+            # taken from https://github.com/BoschSensortec/BME68x-Sensor-API
+            var1 = 262144 >> self._gas_range
+            var2 = self._adc_gas - 512
+            var2 *= 3
+            var2 = 4096 + var2
+            calc_gas_res = (10000 * var1) / var2
+            calc_gas_res = calc_gas_res * 100
+        else:
+            var1 = ((1340 + (5 * self._sw_err)) * (_LOOKUP_TABLE_1[self._gas_range])) / 65536
+            var2 = ((self._adc_gas * 32768) - 16777216) + var1
+            var3 = (_LOOKUP_TABLE_2[self._gas_range] * var1) / 512
+            calc_gas_res = (var3 + (var2 / 2)) / var2
+        return int(calc_gas_res)
+
+    def _perform_reading(self) -> None:
+        """Perform a single-shot reading from the sensor and fill internal data structure for
+        calculations"""
+        if time.monotonic() - self._last_reading < self._min_refresh_time:
+            return
+
+        # set filter
+        self._write(_BME680_REG_CONFIG, [self._filter << 2])
+        # turn on temp oversample & pressure oversample
+        self._write(
+            _BME680_REG_CTRL_MEAS,
+            [(self._temp_oversample << 5) | (self._pressure_oversample << 2)],
+        )
+        # turn on humidity oversample
+        self._write(_BME680_REG_CTRL_HUM, [self._humidity_oversample])
+        # gas measurements enabled
+        if self._chip_variant == 0x01:
+            self._write(_BME680_REG_CTRL_GAS, [(self._run_gas & _BME680_RUNGAS) << 1])
+        else:
+            self._write(_BME680_REG_CTRL_GAS, [(self._run_gas & _BME680_RUNGAS)])
+        ctrl = self._read_byte(_BME680_REG_CTRL_MEAS)
+        ctrl = (ctrl & 0xFC) | 0x01  # enable single shot!
+        self._write(_BME680_REG_CTRL_MEAS, [ctrl])
+        new_data = False
+        while not new_data:
+            data = self._read(_BME680_REG_MEAS_STATUS, 17)
+            new_data = data[0] & 0x80 != 0
+            time.sleep(0.005)
+        self._last_reading = time.monotonic()
+
+        self._adc_pres = _read24(data[2:5]) / 16
+        self._adc_temp = _read24(data[5:8]) / 16
+        self._adc_hum = struct.unpack(">H", bytes(data[8:10]))[0]
+        if self._chip_variant == 0x01:
+            self._adc_gas = int(struct.unpack(">H", bytes(data[15:17]))[0] / 64)
+            self._gas_range = data[16] & 0x0F
+        else:
+            self._adc_gas = int(struct.unpack(">H", bytes(data[13:15]))[0] / 64)
+            self._gas_range = data[14] & 0x0F
+
+        var1 = (self._adc_temp / 8) - (self._temp_calibration[0] * 2)
+        var2 = (var1 * self._temp_calibration[1]) / 2048
+        var3 = ((var1 / 2) * (var1 / 2)) / 4096
+        var3 = (var3 * self._temp_calibration[2] * 16) / 16384
+        self._t_fine = int(var2 + var3)
+
+    def _read_calibration(self) -> None:
+        """Read & save the calibration coefficients"""
+        coeff = self._read(_BME680_BME680_COEFF_ADDR1, 25)
+        coeff += self._read(_BME680_BME680_COEFF_ADDR2, 16)
+
+        coeff = list(struct.unpack("<hbBHhbBhhbbHhhBBBHbbbBbHhbb", bytes(coeff[1:39])))
+        # print("\n\n",coeff)
+        coeff = [float(i) for i in coeff]
+        self._temp_calibration = [coeff[x] for x in [23, 0, 1]]
+        self._pressure_calibration = [coeff[x] for x in [3, 4, 5, 7, 8, 10, 9, 12, 13, 14]]
+        self._humidity_calibration = [coeff[x] for x in [17, 16, 18, 19, 20, 21, 22]]
+        self._gas_calibration = [coeff[x] for x in [25, 24, 26]]
+
+        # flip around H1 & H2
+        self._humidity_calibration[1] *= 16
+        self._humidity_calibration[1] += self._humidity_calibration[0] % 16
+        self._humidity_calibration[0] /= 16
+
+        self._heat_range = (self._read_byte(0x02) & 0x30) / 16
+        self._heat_val = self._read_byte(0x00)
+        self._sw_err = (self._read_byte(0x04) & 0xF0) / 16
+
+    def _read_byte(self, register: int) -> int:
+        """Read a byte register value and return it"""
+        return self._read(register, 1)[0]
+
+    def _read(self, register: int, length: int) -> bytearray:
+        raise NotImplementedError()
+
+    def _write(self, register: int, values: bytearray) -> None:
+        raise NotImplementedError()
+
+    def set_gas_heater(self, heater_temp: int, heater_time: int) -> bool:
+        """
+        Enable and configure gas reading + heater (None disables)
+        :param  heater_temp: Desired temperature in degrees Centigrade
+        :param  heater_time: Time to keep heater on in milliseconds
+        :return: True on success, False on failure
+        """
+        try:
+            if (heater_temp is None) or (heater_time is None):
+                self._set_heatr_conf(heater_temp or 0, heater_time or 0, enable=False)
+            else:
+                self._set_heatr_conf(heater_temp, heater_time)
+        except OSError:
+            return False
+        return True
+
+    def _set_heatr_conf(self, heater_temp: int, heater_time: int, enable: bool = True) -> None:
+        # restrict to BME68X_FORCED_MODE
+        op_mode: int = _BME68X_FORCED_MODE
+        nb_conv: int = 0
+        hctrl: int = _BME68X_ENABLE_HEATER
+        run_gas: int = 0
+        ctrl_gas_data_0: int = 0
+        ctrl_gas_data_1: int = 0
+
+        self._set_op_mode(_BME68X_SLEEP_MODE)
+        self._set_conf(heater_temp, heater_time, op_mode)
+        ctrl_gas_data_0 = self._read_byte(_BME68X_REG_CTRL_GAS_0)
+        ctrl_gas_data_1 = self._read_byte(_BME68X_REG_CTRL_GAS_1)
+        if enable:
+            hctrl = _BME68X_ENABLE_HEATER
+            if self._chip_variant == _BME68X_VARIANT_GAS_HIGH:
+                run_gas = _BME68X_ENABLE_GAS_MEAS_H
+            else:
+                run_gas = _BME68X_ENABLE_GAS_MEAS_L
+        else:
+            hctrl = _BME68X_DISABLE_HEATER
+            run_gas = _BME68X_DISABLE_GAS_MEAS
+        self._run_gas = ~(run_gas - 1)
+
+        ctrl_gas_data_0 = bme_set_bits(ctrl_gas_data_0, _BME68X_HCTRL_MSK, _BME68X_HCTRL_POS, hctrl)
+        ctrl_gas_data_1 = bme_set_bits_pos_0(ctrl_gas_data_1, _BME68X_NBCONV_MSK, nb_conv)
+        ctrl_gas_data_1 = bme_set_bits(
+            ctrl_gas_data_1, _BME68X_RUN_GAS_MSK, _BME68X_RUN_GAS_POS, run_gas
+        )
+        self._write(_BME68X_REG_CTRL_GAS_0, [ctrl_gas_data_0])
+        self._write(_BME68X_REG_CTRL_GAS_1, [ctrl_gas_data_1])
+
+    def _set_op_mode(self, op_mode: int) -> None:
+        """
+        * @brief This API is used to set the operation mode of the sensor
+        """
+        tmp_pow_mode: int = 0
+        pow_mode: int = _BME68X_FORCED_MODE
+        # Call until in sleep
+
+        # was a do {} while() loop
+        while pow_mode != _BME68X_SLEEP_MODE:
+            tmp_pow_mode = self._read_byte(_BME680_REG_CTRL_MEAS)
+            # Put to sleep before changing mode
+            pow_mode = tmp_pow_mode & _BME68X_MODE_MSK
+            if pow_mode != _BME68X_SLEEP_MODE:
+                tmp_pow_mode &= ~_BME68X_MODE_MSK  # Set to sleep
+                self._write(_BME680_REG_CTRL_MEAS, [tmp_pow_mode])
+                # dev->delay_us(_BME68X_PERIOD_POLL, dev->intf_ptr)  # HELP
+                delay_microseconds(_BME68X_PERIOD_POLL)
+        # Already in sleep
+        if op_mode != _BME68X_SLEEP_MODE:
+            tmp_pow_mode = (tmp_pow_mode & ~_BME68X_MODE_MSK) | (op_mode & _BME68X_MODE_MSK)
+            self._write(_BME680_REG_CTRL_MEAS, [tmp_pow_mode])
+
+    def _set_conf(self, heater_temp: int, heater_time: int, op_mode: int) -> None:
+        """
+        This internal API is used to set heater configurations
+        """
+
+        if op_mode != _BME68X_FORCED_MODE:
+            raise OSError("GasHeaterException: _set_conf not forced mode")
+        rh_reg_data: int = self._calc_res_heat(heater_temp)
+        gw_reg_data: int = self._calc_gas_wait(heater_time)
+        self._write(_BME680_BME680_RES_HEAT_0, [rh_reg_data])
+        self._write(_BME680_BME680_GAS_WAIT_0, [gw_reg_data])
+
+    def _calc_res_heat(self, temp: int) -> int:
+        """
+        This internal API is used to calculate the heater resistance value using float
+        """
+        gh1: int = self._gas_calibration[0]
+        gh2: int = self._gas_calibration[1]
+        gh3: int = self._gas_calibration[2]
+        htr: int = self._heat_range
+        htv: int = self._heat_val
+        amb: int = self._amb_temp
+
+        temp = min(temp, 400)  # Cap temperature
+
+        var1: int = ((int(amb) * gh3) / 1000) * 256
+        var2: int = (gh1 + 784) * (((((gh2 + 154009) * temp * 5) / 100) + 3276800) / 10)
+        var3: int = var1 + (var2 / 2)
+        var4: int = var3 / (htr + 4)
+        var5: int = (131 * htv) + 65536
+        heatr_res_x100: int = int(((var4 / var5) - 250) * 34)
+        heatr_res: int = int((heatr_res_x100 + 50) / 100)
+
+        return heatr_res
+
+    def _calc_res_heat(self, temp: int) -> int:
+        """
+        This internal API is used to calculate the heater resistance value
+        """
+        gh1: float = float(self._gas_calibration[0])
+        gh2: float = float(self._gas_calibration[1])
+        gh3: float = float(self._gas_calibration[2])
+        htr: float = float(self._heat_range)
+        htv: float = float(self._heat_val)
+        amb: float = float(self._amb_temp)
+
+        temp = min(temp, 400)  # Cap temperature
+
+        var1: float = (gh1 / (16.0)) + 49.0
+        var2: float = ((gh2 / (32768.0)) * (0.0005)) + 0.00235
+        var3: float = gh3 / (1024.0)
+        var4: float = var1 * (1.0 + (var2 * float(temp)))
+        var5: float = var4 + (var3 * amb)
+        res_heat: int = int(3.4 * ((var5 * (4 / (4 + htr)) * (1 / (1 + (htv * 0.002)))) - 25))
+        return res_heat
+
+    def _calc_gas_wait(self, dur: int) -> int:
+        """
+        This internal API is used to calculate the gas wait
+        """
+        factor: int = 0
+        durval: int = 0xFF  # Max duration
+
+        if dur >= 0xFC0:
+            return durval
+        while dur > 0x3F:
+            dur = dur / 4
+            factor += 1
+        durval = int(dur + (factor * 64))
+        return durval
+
+
+class Adafruit_BME680_I2C(Adafruit_BME680):
+    """Driver for I2C connected BME680.
+
+    :param ~busio.I2C i2c: The I2C bus the BME680 is connected to.
+    :param int address: I2C device address. Defaults to :const:`0x77`
+    :param bool debug: Print debug statements when `True`. Defaults to `False`
+    :param int refresh_rate: Maximum number of readings per second. Faster property reads
+      will be from the previous reading.
+
+    **Quickstart: Importing and using the BME680**
+
+        Here is an example of using the :class:`BMP680_I2C` class.
+        First you will need to import the libraries to use the sensor
+
+        .. code-block:: python
+
+            import board
+            import adafruit_bme680
+
+        Once this is done you can define your ``board.I2C`` object and define your sensor object
+
+        .. code-block:: python
+
+            i2c = board.I2C()   # uses board.SCL and board.SDA
+            bme680 = adafruit_bme680.Adafruit_BME680_I2C(i2c)
+
+        You need to setup the pressure at sea level
+
+        .. code-block:: python
+
+            bme680.sea_level_pressure = 1013.25
+
+        Now you have access to the :attr:`temperature`, :attr:`gas`, :attr:`relative_humidity`,
+        :attr:`pressure` and :attr:`altitude` attributes
+
+        .. code-block:: python
+
+            temperature = bme680.temperature
+            gas = bme680.gas
+            relative_humidity = bme680.relative_humidity
+            pressure = bme680.pressure
+            altitude = bme680.altitude
+
+    """
+
+    def __init__(
+        self,
+        i2c: I2C,
+        address: int = 0x77,
+        debug: bool = False,
+        *,
+        refresh_rate: int = 10,
+    ) -> None:
+        """Initialize the I2C device at the 'address' given"""
+        from adafruit_bus_device import (
+            i2c_device,
+        )
+
+        self._i2c = i2c_device.I2CDevice(i2c, address)
+        self._debug = debug
+        super().__init__(refresh_rate=refresh_rate)
+
+    def _read(self, register: int, length: int) -> bytearray:
+        """Returns an array of 'length' bytes from the 'register'"""
+        with self._i2c as i2c:
+            i2c.write(bytes([register & 0xFF]))
+            result = bytearray(length)
+            i2c.readinto(result)
+            if self._debug:
+                print(f"\t${register:02X} => {[hex(i) for i in result]}")
+            return result
+
+    def _write(self, register: int, values: ReadableBuffer) -> None:
+        """Writes an array of 'length' bytes to the 'register'"""
+        with self._i2c as i2c:
+            buffer = bytearray(2 * len(values))
+            for i, value in enumerate(values):
+                buffer[2 * i] = register + i
+                buffer[2 * i + 1] = value
+            i2c.write(buffer)
+            if self._debug:
+                print(f"\t${values[0]:02X} <= {[hex(i) for i in values[1:]]}")
+
+
+class Adafruit_BME680_SPI(Adafruit_BME680):
+    """Driver for SPI connected BME680.
+
+    :param ~busio.SPI spi: SPI device
+    :param ~digitalio.DigitalInOut cs: Chip Select
+    :param bool debug: Print debug statements when `True`. Defaults to `False`
+    :param int baudrate: Clock rate, default is :const:`100000`
+    :param int refresh_rate: Maximum number of readings per second. Faster property reads
+      will be from the previous reading.
+
+
+    **Quickstart: Importing and using the BME680**
+
+        Here is an example of using the :class:`BMP680_SPI` class.
+        First you will need to import the libraries to use the sensor
+
+        .. code-block:: python
+
+            import board
+            from digitalio import DigitalInOut, Direction
+            import adafruit_bme680
+
+        Once this is done you can define your ``board.SPI`` object and define your sensor object
+
+        .. code-block:: python
+
+            cs = digitalio.DigitalInOut(board.D10)
+            spi = board.SPI()
+            bme680 = adafruit_bme680.Adafruit_BME680_SPI(spi, cs)
+
+        You need to setup the pressure at sea level
+
+        .. code-block:: python
+
+            bme680.sea_level_pressure = 1013.25
+
+        Now you have access to the :attr:`temperature`, :attr:`gas`, :attr:`relative_humidity`,
+        :attr:`pressure` and :attr:`altitude` attributes
+
+        .. code-block:: python
+
+            temperature = bme680.temperature
+            gas = bme680.gas
+            relative_humidity = bme680.relative_humidity
+            pressure = bme680.pressure
+            altitude = bme680.altitude
+
+    """
+
+    def __init__(  # noqa: PLR0913 Too many arguments in function definition
+        self,
+        spi: SPI,
+        cs: DigitalInOut,
+        baudrate: int = 100000,
+        debug: bool = False,
+        *,
+        refresh_rate: int = 10,
+    ) -> None:
+        from adafruit_bus_device import (
+            spi_device,
+        )
+
+        self._spi = spi_device.SPIDevice(spi, cs, baudrate=baudrate)
+        self._debug = debug
+        super().__init__(refresh_rate=refresh_rate)
+
+    def _read(self, register: int, length: int) -> bytearray:
+        if register != _BME680_REG_STATUS:
+            # _BME680_REG_STATUS exists in both SPI memory pages
+            # For all other registers, we must set the correct memory page
+            self._set_spi_mem_page(register)
+
+        register = (register | 0x80) & 0xFF  # Read single, bit 7 high.
+        with self._spi as spi:
+            spi.write(bytearray([register]))
+            result = bytearray(length)
+            spi.readinto(result)
+            if self._debug:
+                print(f"\t${register:02X} => {[hex(i) for i in result]}")
+            return result
+
+    def _write(self, register: int, values: ReadableBuffer) -> None:
+        if register != _BME680_REG_STATUS:
+            # _BME680_REG_STATUS exists in both SPI memory pages
+            # For all other registers, we must set the correct memory page
+            self._set_spi_mem_page(register)
+        register &= 0x7F  # Write, bit 7 low.
+        with self._spi as spi:
+            buffer = bytearray(2 * len(values))
+            for i, value in enumerate(values):
+                buffer[2 * i] = register + i
+                buffer[2 * i + 1] = value & 0xFF
+            spi.write(buffer)
+            if self._debug:
+                print(f"\t${values[0]:02X} <= {[hex(i) for i in values[1:]]}")
+
+    def _set_spi_mem_page(self, register: int) -> None:
+        spi_mem_page = 0x00
+        if register < 0x80:
+            spi_mem_page = 0x10
+        self._write(_BME680_REG_STATUS, [spi_mem_page])

scripts/adafruit_bus_device/i2c_device.py

@@ -0,0 +1,187 @@
+# SPDX-FileCopyrightText: 2016 Scott Shawcroft for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+"""
+`adafruit_bus_device.i2c_device` - I2C Bus Device
+====================================================
+"""
+
+import time
+
+try:
+    from typing import Optional, Type
+    from types import TracebackType
+    from circuitpython_typing import ReadableBuffer, WriteableBuffer
+
+    # Used only for type annotations.
+    from busio import I2C
+except ImportError:
+    pass
+
+
+__version__ = "5.2.10"
+__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_BusDevice.git"
+
+
+class I2CDevice:
+    """
+    Represents a single I2C device and manages locking the bus and the device
+    address.
+
+    :param ~busio.I2C i2c: The I2C bus the device is on
+    :param int device_address: The 7 bit device address
+    :param bool probe: Probe for the device upon object creation, default is true
+
+    .. note:: This class is **NOT** built into CircuitPython. See
+      :ref:`here for install instructions <bus_device_installation>`.
+
+    Example:
+
+    .. code-block:: python
+
+        import busio
+        from board import *
+        from adafruit_bus_device.i2c_device import I2CDevice
+
+        with busio.I2C(SCL, SDA) as i2c:
+            device = I2CDevice(i2c, 0x70)
+            bytes_read = bytearray(4)
+            with device:
+                device.readinto(bytes_read)
+            # A second transaction
+            with device:
+                device.write(bytes_read)
+    """
+
+    def __init__(self, i2c: I2C, device_address: int, probe: bool = True) -> None:
+        self.i2c = i2c
+        self.device_address = device_address
+
+        if probe:
+            self.__probe_for_device()
+
+    def readinto(
+        self, buf: WriteableBuffer, *, start: int = 0, end: Optional[int] = None
+    ) -> None:
+        """
+        Read into ``buf`` from the device. The number of bytes read will be the
+        length of ``buf``.
+
+        If ``start`` or ``end`` is provided, then the buffer will be sliced
+        as if ``buf[start:end]``. This will not cause an allocation like
+        ``buf[start:end]`` will so it saves memory.
+
+        :param ~WriteableBuffer buffer: buffer to write into
+        :param int start: Index to start writing at
+        :param int end: Index to write up to but not include; if None, use ``len(buf)``
+        """
+        if end is None:
+            end = len(buf)
+        self.i2c.readfrom_into(self.device_address, buf, start=start, end=end)
+
+    def write(
+        self, buf: ReadableBuffer, *, start: int = 0, end: Optional[int] = None
+    ) -> None:
+        """
+        Write the bytes from ``buffer`` to the device, then transmit a stop
+        bit.
+
+        If ``start`` or ``end`` is provided, then the buffer will be sliced
+        as if ``buffer[start:end]``. This will not cause an allocation like
+        ``buffer[start:end]`` will so it saves memory.
+
+        :param ~ReadableBuffer buffer: buffer containing the bytes to write
+        :param int start: Index to start writing from
+        :param int end: Index to read up to but not include; if None, use ``len(buf)``
+        """
+        if end is None:
+            end = len(buf)
+        self.i2c.writeto(self.device_address, buf, start=start, end=end)
+
+    # pylint: disable-msg=too-many-arguments
+    def write_then_readinto(
+        self,
+        out_buffer: ReadableBuffer,
+        in_buffer: WriteableBuffer,
+        *,
+        out_start: int = 0,
+        out_end: Optional[int] = None,
+        in_start: int = 0,
+        in_end: Optional[int] = None
+    ) -> None:
+        """
+        Write the bytes from ``out_buffer`` to the device, then immediately
+        reads into ``in_buffer`` from the device. The number of bytes read
+        will be the length of ``in_buffer``.
+
+        If ``out_start`` or ``out_end`` is provided, then the output buffer
+        will be sliced as if ``out_buffer[out_start:out_end]``. This will
+        not cause an allocation like ``buffer[out_start:out_end]`` will so
+        it saves memory.
+
+        If ``in_start`` or ``in_end`` is provided, then the input buffer
+        will be sliced as if ``in_buffer[in_start:in_end]``. This will not
+        cause an allocation like ``in_buffer[in_start:in_end]`` will so
+        it saves memory.
+
+        :param ~ReadableBuffer out_buffer: buffer containing the bytes to write
+        :param ~WriteableBuffer in_buffer: buffer containing the bytes to read into
+        :param int out_start: Index to start writing from
+        :param int out_end: Index to read up to but not include; if None, use ``len(out_buffer)``
+        :param int in_start: Index to start writing at
+        :param int in_end: Index to write up to but not include; if None, use ``len(in_buffer)``
+        """
+        if out_end is None:
+            out_end = len(out_buffer)
+        if in_end is None:
+            in_end = len(in_buffer)
+
+        self.i2c.writeto_then_readfrom(
+            self.device_address,
+            out_buffer,
+            in_buffer,
+            out_start=out_start,
+            out_end=out_end,
+            in_start=in_start,
+            in_end=in_end,
+        )
+
+    # pylint: enable-msg=too-many-arguments
+
+    def __enter__(self) -> "I2CDevice":
+        while not self.i2c.try_lock():
+            time.sleep(0)
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[type]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> bool:
+        self.i2c.unlock()
+        return False
+
+    def __probe_for_device(self) -> None:
+        """
+        Try to read a byte from an address,
+        if you get an OSError it means the device is not there
+        or that the device does not support these means of probing
+        """
+        while not self.i2c.try_lock():
+            time.sleep(0)
+        try:
+            self.i2c.writeto(self.device_address, b"")
+        except OSError:
+            # some OS's dont like writing an empty bytesting...
+            # Retry by reading a byte
+            try:
+                result = bytearray(1)
+                self.i2c.readfrom_into(self.device_address, result)
+            except OSError:
+                # pylint: disable=raise-missing-from
+                raise ValueError("No I2C device at address: 0x%x" % self.device_address)
+                # pylint: enable=raise-missing-from
+        finally:
+            self.i2c.unlock()

scripts/adafruit_bus_device/spi_device.py

@@ -0,0 +1,121 @@
+# SPDX-FileCopyrightText: 2016 Scott Shawcroft for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+# pylint: disable=too-few-public-methods
+
+"""
+`adafruit_bus_device.spi_device` - SPI Bus Device
+====================================================
+"""
+
+import time
+
+try:
+    from typing import Optional, Type
+    from types import TracebackType
+
+    # Used only for type annotations.
+    from busio import SPI
+    from digitalio import DigitalInOut
+except ImportError:
+    pass
+
+
+__version__ = "5.2.10"
+__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_BusDevice.git"
+
+
+class SPIDevice:
+    """
+    Represents a single SPI device and manages locking the bus and the device
+    address.
+
+    :param ~busio.SPI spi: The SPI bus the device is on
+    :param ~digitalio.DigitalInOut chip_select: The chip select pin object that implements the
+        DigitalInOut API.
+    :param bool cs_active_value: Set to True if your device requires CS to be active high.
+        Defaults to False.
+    :param int baudrate: The desired SCK clock rate in Hertz. The actual clock rate may be
+        higher or lower due to the granularity of available clock settings (MCU dependent).
+    :param int polarity: The base state of the SCK clock pin (0 or 1).
+    :param int phase: The edge of the clock that data is captured. First (0) or second (1).
+        Rising or falling depends on SCK clock polarity.
+    :param int extra_clocks: The minimum number of clock cycles to cycle the bus after CS is high.
+        (Used for SD cards.)
+
+    .. note:: This class is **NOT** built into CircuitPython. See
+      :ref:`here for install instructions <bus_device_installation>`.
+
+    Example:
+
+    .. code-block:: python
+
+        import busio
+        import digitalio
+        from board import *
+        from adafruit_bus_device.spi_device import SPIDevice
+
+        with busio.SPI(SCK, MOSI, MISO) as spi_bus:
+            cs = digitalio.DigitalInOut(D10)
+            device = SPIDevice(spi_bus, cs)
+            bytes_read = bytearray(4)
+            # The object assigned to spi in the with statements below
+            # is the original spi_bus object. We are using the busio.SPI
+            # operations busio.SPI.readinto() and busio.SPI.write().
+            with device as spi:
+                spi.readinto(bytes_read)
+            # A second transaction
+            with device as spi:
+                spi.write(bytes_read)
+    """
+
+    def __init__(
+        self,
+        spi: SPI,
+        chip_select: Optional[DigitalInOut] = None,
+        *,
+        cs_active_value: bool = False,
+        baudrate: int = 100000,
+        polarity: int = 0,
+        phase: int = 0,
+        extra_clocks: int = 0
+    ) -> None:
+        self.spi = spi
+        self.baudrate = baudrate
+        self.polarity = polarity
+        self.phase = phase
+        self.extra_clocks = extra_clocks
+        self.chip_select = chip_select
+        self.cs_active_value = cs_active_value
+        if self.chip_select:
+            self.chip_select.switch_to_output(value=not self.cs_active_value)
+
+    def __enter__(self) -> SPI:
+        while not self.spi.try_lock():
+            time.sleep(0)
+        self.spi.configure(
+            baudrate=self.baudrate, polarity=self.polarity, phase=self.phase
+        )
+        if self.chip_select:
+            self.chip_select.value = self.cs_active_value
+        return self.spi
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[type]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> bool:
+        if self.chip_select:
+            self.chip_select.value = not self.cs_active_value
+        if self.extra_clocks > 0:
+            buf = bytearray(1)
+            buf[0] = 0xFF
+            clocks = self.extra_clocks // 8
+            if self.extra_clocks % 8 != 0:
+                clocks += 1
+            for _ in range(clocks):
+                self.spi.write(buf)
+        self.spi.unlock()
+        return False

scripts/bme60.py

@@ -0,0 +1,421 @@
+# The MIT License (MIT)
+#
+# Copyright (c) 2017 ladyada for Adafruit Industries
+#
+# 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.
+
+# We have a lot of attributes for this complex sensor.
+# pylint: disable=too-many-instance-attributes
+
+"""
+`bme680` - BME680 - Temperature, Humidity, Pressure & Gas Sensor
+================================================================
+
+MicroPython driver from BME680 air quality sensor, based on Adafruit_bme680
+
+* Author(s): Limor 'Ladyada' Fried of Adafruit
+             Jeff Raber (SPI support)
+             and many more contributors
+"""
+
+import time
+import math
+from micropython import const
+from ubinascii import hexlify as hex
+try:
+    import struct
+except ImportError:
+    import ustruct as struct
+
+#    I2C ADDRESS/BITS/SETTINGS
+#    -----------------------------------------------------------------------
+_BME680_CHIPID = const(0x61)
+
+_BME680_REG_CHIPID = const(0xD0)
+_BME680_BME680_COEFF_ADDR1 = const(0x89)
+_BME680_BME680_COEFF_ADDR2 = const(0xE1)
+_BME680_BME680_RES_HEAT_0 = const(0x5A)
+_BME680_BME680_GAS_WAIT_0 = const(0x64)
+
+_BME680_REG_SOFTRESET = const(0xE0)
+_BME680_REG_CTRL_GAS = const(0x71)
+_BME680_REG_CTRL_HUM = const(0x72)
+_BME280_REG_STATUS = const(0xF3)
+_BME680_REG_CTRL_MEAS = const(0x74)
+_BME680_REG_CONFIG = const(0x75)
+
+_BME680_REG_PAGE_SELECT = const(0x73)
+_BME680_REG_MEAS_STATUS = const(0x1D)
+_BME680_REG_PDATA = const(0x1F)
+_BME680_REG_TDATA = const(0x22)
+_BME680_REG_HDATA = const(0x25)
+
+_BME680_SAMPLERATES = (0, 1, 2, 4, 8, 16)
+_BME680_FILTERSIZES = (0, 1, 3, 7, 15, 31, 63, 127)
+
+_BME680_RUNGAS = const(0x10)
+
+_LOOKUP_TABLE_1 = (2147483647.0, 2147483647.0, 2147483647.0, 2147483647.0, 2147483647.0,
+                   2126008810.0, 2147483647.0, 2130303777.0, 2147483647.0, 2147483647.0,
+                   2143188679.0, 2136746228.0, 2147483647.0, 2126008810.0, 2147483647.0,
+                   2147483647.0)
+
+_LOOKUP_TABLE_2 = (4096000000.0, 2048000000.0, 1024000000.0, 512000000.0, 255744255.0, 127110228.0,
+                   64000000.0, 32258064.0, 16016016.0, 8000000.0, 4000000.0, 2000000.0, 1000000.0,
+                   500000.0, 250000.0, 125000.0)
+
+
+def _read24(arr):
+    """Parse an unsigned 24-bit value as a floating point and return it."""
+    ret = 0.0
+    #print([hex(i) for i in arr])
+    for b in arr:
+        ret *= 256.0
+        ret += float(b & 0xFF)
+    return ret
+
+
+class Adafruit_BME680:
+    """Driver from BME680 air quality sensor
+
+       :param int refresh_rate: Maximum number of readings per second. Faster property reads
+         will be from the previous reading."""
+    def __init__(self, *, refresh_rate=10):
+        """Check the BME680 was found, read the coefficients and enable the sensor for continuous
+           reads."""
+        self._write(_BME680_REG_SOFTRESET, [0xB6])
+        time.sleep(0.005)
+
+        # Check device ID.
+        chip_id = self._read_byte(_BME680_REG_CHIPID)
+        if chip_id != _BME680_CHIPID:
+            raise RuntimeError('Failed to find BME680! Chip ID 0x%x' % chip_id)
+
+        self._read_calibration()
+
+        # set up heater
+        self._write(_BME680_BME680_RES_HEAT_0, [0x73])
+        self._write(_BME680_BME680_GAS_WAIT_0, [0x65])
+
+        self.sea_level_pressure = 1013.25
+        """Pressure in hectoPascals at sea level. Used to calibrate ``altitude``."""
+
+        # Default oversampling and filter register values.
+        self._pressure_oversample = 0b011
+        self._temp_oversample = 0b100
+        self._humidity_oversample = 0b010
+        self._filter = 0b010
+
+        self._adc_pres = None
+        self._adc_temp = None
+        self._adc_hum = None
+        self._adc_gas = None
+        self._gas_range = None
+        self._t_fine = None
+
+        self._last_reading = time.ticks_ms()
+        self._min_refresh_time = 1000 // refresh_rate
+
+    @property
+    def pressure_oversample(self):
+        """The oversampling for pressure sensor"""
+        return _BME680_SAMPLERATES[self._pressure_oversample]
+
+    @pressure_oversample.setter
+    def pressure_oversample(self, sample_rate):
+        if sample_rate in _BME680_SAMPLERATES:
+            self._pressure_oversample = _BME680_SAMPLERATES.index(sample_rate)
+        else:
+            raise RuntimeError("Invalid oversample")
+
+    @property
+    def humidity_oversample(self):
+        """The oversampling for humidity sensor"""
+        return _BME680_SAMPLERATES[self._humidity_oversample]
+
+    @humidity_oversample.setter
+    def humidity_oversample(self, sample_rate):
+        if sample_rate in _BME680_SAMPLERATES:
+            self._humidity_oversample = _BME680_SAMPLERATES.index(sample_rate)
+        else:
+            raise RuntimeError("Invalid oversample")
+
+    @property
+    def temperature_oversample(self):
+        """The oversampling for temperature sensor"""
+        return _BME680_SAMPLERATES[self._temp_oversample]
+
+    @temperature_oversample.setter
+    def temperature_oversample(self, sample_rate):
+        if sample_rate in _BME680_SAMPLERATES:
+            self._temp_oversample = _BME680_SAMPLERATES.index(sample_rate)
+        else:
+            raise RuntimeError("Invalid oversample")
+
+    @property
+    def filter_size(self):
+        """The filter size for the built in IIR filter"""
+        return _BME680_FILTERSIZES[self._filter]
+
+    @filter_size.setter
+    def filter_size(self, size):
+        if size in _BME680_FILTERSIZES:
+            self._filter = _BME680_FILTERSIZES[size]
+        else:
+            raise RuntimeError("Invalid size")
+
+    @property
+    def temperature(self):
+        """The compensated temperature in degrees celsius."""
+        self._perform_reading()
+        calc_temp = (((self._t_fine * 5) + 128) / 256)
+        return calc_temp / 100
+
+    @property
+    def pressure(self):
+        """The barometric pressure in hectoPascals"""
+        self._perform_reading()
+        var1 = (self._t_fine / 2) - 64000
+        var2 = ((var1 / 4) * (var1 / 4)) / 2048
+        var2 = (var2 * self._pressure_calibration[5]) / 4
+        var2 = var2 + (var1 * self._pressure_calibration[4] * 2)
+        var2 = (var2 / 4) + (self._pressure_calibration[3] * 65536)
+        var1 = (((((var1 / 4) * (var1 / 4)) / 8192) *
+                (self._pressure_calibration[2] * 32) / 8) +
+                ((self._pressure_calibration[1] * var1) / 2))
+        var1 = var1 / 262144
+        var1 = ((32768 + var1) * self._pressure_calibration[0]) / 32768
+        calc_pres = 1048576 - self._adc_pres
+        calc_pres = (calc_pres - (var2 / 4096)) * 3125
+        calc_pres = (calc_pres / var1) * 2
+        var1 = (self._pressure_calibration[8] * (((calc_pres / 8) * (calc_pres / 8)) / 8192)) / 4096
+        var2 = ((calc_pres / 4) * self._pressure_calibration[7]) / 8192
+        var3 = (((calc_pres / 256) ** 3) * self._pressure_calibration[9]) / 131072
+        calc_pres += ((var1 + var2 + var3 + (self._pressure_calibration[6] * 128)) / 16)
+        return calc_pres/100
+
+    @property
+    def humidity(self):
+        """The relative humidity in RH %"""
+        self._perform_reading()
+        temp_scaled = ((self._t_fine * 5) + 128) / 256
+        var1 = ((self._adc_hum - (self._humidity_calibration[0] * 16)) -
+                ((temp_scaled * self._humidity_calibration[2]) / 200))
+        var2 = (self._humidity_calibration[1] *
+                (((temp_scaled * self._humidity_calibration[3]) / 100) +
+                 (((temp_scaled * ((temp_scaled * self._humidity_calibration[4]) / 100)) /
+                   64) / 100) + 16384)) / 1024
+        var3 = var1 * var2
+        var4 = self._humidity_calibration[5] * 128
+        var4 = (var4 + ((temp_scaled * self._humidity_calibration[6]) / 100)) / 16
+        var5 = ((var3 / 16384) * (var3 / 16384)) / 1024
+        var6 = (var4 * var5) / 2
+        calc_hum = (((var3 + var6) / 1024) * 1000) / 4096
+        calc_hum /= 1000  # get back to RH
+
+        if calc_hum > 100:
+            calc_hum = 100
+        if calc_hum < 0:
+            calc_hum = 0
+        return calc_hum
+
+    @property
+    def altitude(self):
+        """The altitude based on current ``pressure`` vs the sea level pressure
+           (``sea_level_pressure``) - which you must enter ahead of time)"""
+        pressure = self.pressure # in Si units for hPascal
+        return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))
+
+    @property
+    def gas(self):
+        """The gas resistance in ohms"""
+        self._perform_reading()
+        var1 = ((1340 + (5 * self._sw_err)) * (_LOOKUP_TABLE_1[self._gas_range])) / 65536
+        var2 = ((self._adc_gas * 32768) - 16777216) + var1
+        var3 = (_LOOKUP_TABLE_2[self._gas_range] * var1) / 512
+        calc_gas_res = (var3 + (var2 / 2)) / var2
+        return int(calc_gas_res)
+
+    def _perform_reading(self):
+        """Perform a single-shot reading from the sensor and fill internal data structure for
+           calculations"""
+        expired = time.ticks_diff(self._last_reading, time.ticks_ms()) * time.ticks_diff(0, 1)
+        if 0 <= expired < self._min_refresh_time:
+            time.sleep_ms(self._min_refresh_time - expired)
+
+        # set filter
+        self._write(_BME680_REG_CONFIG, [self._filter << 2])
+        # turn on temp oversample & pressure oversample
+        self._write(_BME680_REG_CTRL_MEAS,
+                    [(self._temp_oversample << 5)|(self._pressure_oversample << 2)])
+        # turn on humidity oversample
+        self._write(_BME680_REG_CTRL_HUM, [self._humidity_oversample])
+        # gas measurements enabled
+        self._write(_BME680_REG_CTRL_GAS, [_BME680_RUNGAS])
+
+        ctrl = self._read_byte(_BME680_REG_CTRL_MEAS)
+        ctrl = (ctrl & 0xFC) | 0x01  # enable single shot!
+        self._write(_BME680_REG_CTRL_MEAS, [ctrl])
+        new_data = False
+        while not new_data:
+            data = self._read(_BME680_REG_MEAS_STATUS, 15)
+            new_data = data[0] & 0x80 != 0
+            time.sleep(0.005)
+        self._last_reading = time.ticks_ms()
+
+        self._adc_pres = _read24(data[2:5]) / 16
+        self._adc_temp = _read24(data[5:8]) / 16
+        self._adc_hum = struct.unpack('>H', bytes(data[8:10]))[0]
+        self._adc_gas = int(struct.unpack('>H', bytes(data[13:15]))[0] / 64)
+        self._gas_range = data[14] & 0x0F
+
+        var1 = (self._adc_temp / 8) - (self._temp_calibration[0] * 2)
+        var2 = (var1 * self._temp_calibration[1]) / 2048
+        var3 = ((var1 / 2) * (var1 / 2)) / 4096
+        var3 = (var3 * self._temp_calibration[2] * 16) / 16384
+
+        self._t_fine = int(var2 + var3)
+
+    def _read_calibration(self):
+        """Read & save the calibration coefficients"""
+        coeff = self._read(_BME680_BME680_COEFF_ADDR1, 25)
+        coeff += self._read(_BME680_BME680_COEFF_ADDR2, 16)
+
+        coeff = list(struct.unpack('<hbBHhbBhhbbHhhBBBHbbbBbHhbb', bytes(coeff[1:39])))
+        # print("\n\n",coeff)
+        coeff = [float(i) for i in coeff]
+        self._temp_calibration = [coeff[x] for x in [23, 0, 1]]
+        self._pressure_calibration = [coeff[x] for x in [3, 4, 5, 7, 8, 10, 9, 12, 13, 14]]
+        self._humidity_calibration = [coeff[x] for x in [17, 16, 18, 19, 20, 21, 22]]
+        self._gas_calibration = [coeff[x] for x in [25, 24, 26]]
+
+        # flip around H1 & H2
+        self._humidity_calibration[1] *= 16
+        self._humidity_calibration[1] += self._humidity_calibration[0] % 16
+        self._humidity_calibration[0] /= 16
+
+        self._heat_range = (self._read_byte(0x02) & 0x30) / 16
+        self._heat_val = self._read_byte(0x00)
+        self._sw_err = (self._read_byte(0x04) & 0xF0) / 16
+
+    def _read_byte(self, register):
+        """Read a byte register value and return it"""
+        return self._read(register, 1)[0]
+
+    def _read(self, register, length):
+        raise NotImplementedError()
+
+    def _write(self, register, values):
+        raise NotImplementedError()
+
+class BME680_I2C(Adafruit_BME680):
+    """Driver for I2C connected BME680.
+
+        :param i2c: I2C device object
+        :param int address: I2C device address
+        :param bool debug: Print debug statements when True.
+        :param int refresh_rate: Maximum number of readings per second. Faster property reads
+          will be from the previous reading."""
+    def __init__(self, i2c, address=0x77, debug=False, *, refresh_rate=10):
+        """Initialize the I2C device at the 'address' given"""
+        self._i2c = i2c
+        self._address = address
+        self._debug = debug
+        super().__init__(refresh_rate=refresh_rate)
+
+    def _read(self, register, length):
+        """Returns an array of 'length' bytes from the 'register'"""
+        result = bytearray(length)
+        self._i2c.readfrom_mem_into(self._address, register & 0xff, result)
+        if self._debug:
+            print("\t${:x} read ".format(register), " ".join(["{:02x}".format(i) for i in result]))
+        return result
+
+    def _write(self, register, values):
+        """Writes an array of 'length' bytes to the 'register'"""
+        if self._debug:
+            print("\t${:x} write".format(register), " ".join(["{:02x}".format(i) for i in values]))
+        for value in values:
+            self._i2c.writeto_mem(self._address, register, bytearray([value & 0xFF]))
+            register += 1
+
+
+class BME680_SPI(Adafruit_BME680):
+    """Driver for SPI connected BME680.
+
+        :param spi: SPI device object, configured
+        :param cs: Chip Select Pin object, configured to OUT mode
+        :param bool debug: Print debug statements when True.
+        :param int refresh_rate: Maximum number of readings per second. Faster property reads
+          will be from the previous reading.
+      """
+
+    def __init__(self, spi, cs, debug=False, *, refresh_rate=10):
+        self._spi = spi
+        self._cs = cs
+        self._debug = debug
+        self._cs(1)
+        super().__init__(refresh_rate=refresh_rate)
+
+    def _read(self, register, length):
+        if register != _BME680_REG_PAGE_SELECT:
+            # _BME680_REG_PAGE_SELECT exists in both SPI memory pages
+            # For all other registers, we must set the correct memory page
+            self._set_spi_mem_page(register)
+        register = (register | 0x80) & 0xFF  # Read single, bit 7 high.
+
+        try:
+            self._cs(0)
+            self._spi.write(bytearray([register]))  # pylint: disable=no-member
+            result = bytearray(length)
+            self._spi.readinto(result)  # pylint: disable=no-member
+            if self._debug:
+                print("\t${:x} read ".format(register), " ".join(["{:02x}".format(i) for i in result]))
+        except Exception as e:
+            print (e)
+            result = None
+        finally:
+            self._cs(1)
+        return result
+
+    def _write(self, register, values):
+        if register != _BME680_REG_PAGE_SELECT:
+            # _BME680_REG_PAGE_SELECT exists in both SPI memory pages
+            # For all other registers, we must set the correct memory page
+            self._set_spi_mem_page(register)
+        register &= 0x7F  # Write, bit 7 low.
+        try:
+            self._cs(0)
+            buffer = bytearray(2 * len(values))
+            for i, value in enumerate(values):
+                buffer[2 * i] = register + i
+                buffer[2 * i + 1] = value & 0xFF
+            self._spi.write(buffer)  # pylint: disable=no-member
+            if self._debug:
+                print("\t${:x} write".format(register), " ".join(["{:02x}".format(i) for i in values]))
+        except Exception as e:
+            print (e)
+        finally:
+            self._cs(1)
+
+    def _set_spi_mem_page(self, register):
+        spi_mem_page = 0x00
+        if register < 0x80:
+            spi_mem_page = 0x10
+        self._write(_BME680_REG_PAGE_SELECT, [spi_mem_page])

scripts/bme680.py

@@ -0,0 +1,421 @@
+# The MIT License (MIT)
+#
+# Copyright (c) 2017 ladyada for Adafruit Industries
+#
+# 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.
+
+# We have a lot of attributes for this complex sensor.
+# pylint: disable=too-many-instance-attributes
+
+"""
+`bme680` - BME680 - Temperature, Humidity, Pressure & Gas Sensor
+================================================================
+
+MicroPython driver from BME680 air quality sensor, based on Adafruit_bme680
+
+* Author(s): Limor 'Ladyada' Fried of Adafruit
+             Jeff Raber (SPI support)
+             and many more contributors
+"""
+
+import time
+import math
+from micropython import const
+from ubinascii import hexlify as hex
+try:
+    import struct
+except ImportError:
+    import ustruct as struct
+
+#    I2C ADDRESS/BITS/SETTINGS
+#    -----------------------------------------------------------------------
+_BME680_CHIPID = const(0x61)
+
+_BME680_REG_CHIPID = const(0xD0)
+_BME680_BME680_COEFF_ADDR1 = const(0x89)
+_BME680_BME680_COEFF_ADDR2 = const(0xE1)
+_BME680_BME680_RES_HEAT_0 = const(0x5A)
+_BME680_BME680_GAS_WAIT_0 = const(0x64)
+
+_BME680_REG_SOFTRESET = const(0xE0)
+_BME680_REG_CTRL_GAS = const(0x71)
+_BME680_REG_CTRL_HUM = const(0x72)
+_BME280_REG_STATUS = const(0xF3)
+_BME680_REG_CTRL_MEAS = const(0x74)
+_BME680_REG_CONFIG = const(0x75)
+
+_BME680_REG_PAGE_SELECT = const(0x73)
+_BME680_REG_MEAS_STATUS = const(0x1D)
+_BME680_REG_PDATA = const(0x1F)
+_BME680_REG_TDATA = const(0x22)
+_BME680_REG_HDATA = const(0x25)
+
+_BME680_SAMPLERATES = (0, 1, 2, 4, 8, 16)
+_BME680_FILTERSIZES = (0, 1, 3, 7, 15, 31, 63, 127)
+
+_BME680_RUNGAS = const(0x10)
+
+_LOOKUP_TABLE_1 = (2147483647.0, 2147483647.0, 2147483647.0, 2147483647.0, 2147483647.0,
+                   2126008810.0, 2147483647.0, 2130303777.0, 2147483647.0, 2147483647.0,
+                   2143188679.0, 2136746228.0, 2147483647.0, 2126008810.0, 2147483647.0,
+                   2147483647.0)
+
+_LOOKUP_TABLE_2 = (4096000000.0, 2048000000.0, 1024000000.0, 512000000.0, 255744255.0, 127110228.0,
+                   64000000.0, 32258064.0, 16016016.0, 8000000.0, 4000000.0, 2000000.0, 1000000.0,
+                   500000.0, 250000.0, 125000.0)
+
+
+def _read24(arr):
+    """Parse an unsigned 24-bit value as a floating point and return it."""
+    ret = 0.0
+    #print([hex(i) for i in arr])
+    for b in arr:
+        ret *= 256.0
+        ret += float(b & 0xFF)
+    return ret
+
+
+class Adafruit_BME680:
+    """Driver from BME680 air quality sensor
+
+       :param int refresh_rate: Maximum number of readings per second. Faster property reads
+         will be from the previous reading."""
+    def __init__(self, *, refresh_rate=10):
+        """Check the BME680 was found, read the coefficients and enable the sensor for continuous
+           reads."""
+        self._write(_BME680_REG_SOFTRESET, [0xB6])
+        time.sleep(0.005)
+
+        # Check device ID.
+        chip_id = self._read_byte(_BME680_REG_CHIPID)
+        if chip_id != _BME680_CHIPID:
+            raise RuntimeError('Failed to find BME680! Chip ID 0x%x' % chip_id)
+
+        self._read_calibration()
+
+        # set up heater
+        self._write(_BME680_BME680_RES_HEAT_0, [0x73])
+        self._write(_BME680_BME680_GAS_WAIT_0, [0x65])
+
+        self.sea_level_pressure = 1013.25
+        """Pressure in hectoPascals at sea level. Used to calibrate ``altitude``."""
+
+        # Default oversampling and filter register values.
+        self._pressure_oversample = 0b011
+        self._temp_oversample = 0b100
+        self._humidity_oversample = 0b010
+        self._filter = 0b010
+
+        self._adc_pres = None
+        self._adc_temp = None
+        self._adc_hum = None
+        self._adc_gas = None
+        self._gas_range = None
+        self._t_fine = None
+
+        self._last_reading = time.ticks_ms()
+        self._min_refresh_time = 1000 // refresh_rate
+
+    @property
+    def pressure_oversample(self):
+        """The oversampling for pressure sensor"""
+        return _BME680_SAMPLERATES[self._pressure_oversample]
+
+    @pressure_oversample.setter
+    def pressure_oversample(self, sample_rate):
+        if sample_rate in _BME680_SAMPLERATES:
+            self._pressure_oversample = _BME680_SAMPLERATES.index(sample_rate)
+        else:
+            raise RuntimeError("Invalid oversample")
+
+    @property
+    def humidity_oversample(self):
+        """The oversampling for humidity sensor"""
+        return _BME680_SAMPLERATES[self._humidity_oversample]
+
+    @humidity_oversample.setter
+    def humidity_oversample(self, sample_rate):
+        if sample_rate in _BME680_SAMPLERATES:
+            self._humidity_oversample = _BME680_SAMPLERATES.index(sample_rate)
+        else:
+            raise RuntimeError("Invalid oversample")
+
+    @property
+    def temperature_oversample(self):
+        """The oversampling for temperature sensor"""
+        return _BME680_SAMPLERATES[self._temp_oversample]
+
+    @temperature_oversample.setter
+    def temperature_oversample(self, sample_rate):
+        if sample_rate in _BME680_SAMPLERATES:
+            self._temp_oversample = _BME680_SAMPLERATES.index(sample_rate)
+        else:
+            raise RuntimeError("Invalid oversample")
+
+    @property
+    def filter_size(self):
+        """The filter size for the built in IIR filter"""
+        return _BME680_FILTERSIZES[self._filter]
+
+    @filter_size.setter
+    def filter_size(self, size):
+        if size in _BME680_FILTERSIZES:
+            self._filter = _BME680_FILTERSIZES[size]
+        else:
+            raise RuntimeError("Invalid size")
+
+    @property
+    def temperature(self):
+        """The compensated temperature in degrees celsius."""
+        self._perform_reading()
+        calc_temp = (((self._t_fine * 5) + 128) / 256)
+        return calc_temp / 100
+
+    @property
+    def pressure(self):
+        """The barometric pressure in hectoPascals"""
+        self._perform_reading()
+        var1 = (self._t_fine / 2) - 64000
+        var2 = ((var1 / 4) * (var1 / 4)) / 2048
+        var2 = (var2 * self._pressure_calibration[5]) / 4
+        var2 = var2 + (var1 * self._pressure_calibration[4] * 2)
+        var2 = (var2 / 4) + (self._pressure_calibration[3] * 65536)
+        var1 = (((((var1 / 4) * (var1 / 4)) / 8192) *
+                (self._pressure_calibration[2] * 32) / 8) +
+                ((self._pressure_calibration[1] * var1) / 2))
+        var1 = var1 / 262144
+        var1 = ((32768 + var1) * self._pressure_calibration[0]) / 32768
+        calc_pres = 1048576 - self._adc_pres
+        calc_pres = (calc_pres - (var2 / 4096)) * 3125
+        calc_pres = (calc_pres / var1) * 2
+        var1 = (self._pressure_calibration[8] * (((calc_pres / 8) * (calc_pres / 8)) / 8192)) / 4096
+        var2 = ((calc_pres / 4) * self._pressure_calibration[7]) / 8192
+        var3 = (((calc_pres / 256) ** 3) * self._pressure_calibration[9]) / 131072
+        calc_pres += ((var1 + var2 + var3 + (self._pressure_calibration[6] * 128)) / 16)
+        return calc_pres/100
+
+    @property
+    def humidity(self):
+        """The relative humidity in RH %"""
+        self._perform_reading()
+        temp_scaled = ((self._t_fine * 5) + 128) / 256
+        var1 = ((self._adc_hum - (self._humidity_calibration[0] * 16)) -
+                ((temp_scaled * self._humidity_calibration[2]) / 200))
+        var2 = (self._humidity_calibration[1] *
+                (((temp_scaled * self._humidity_calibration[3]) / 100) +
+                 (((temp_scaled * ((temp_scaled * self._humidity_calibration[4]) / 100)) /
+                   64) / 100) + 16384)) / 1024
+        var3 = var1 * var2
+        var4 = self._humidity_calibration[5] * 128
+        var4 = (var4 + ((temp_scaled * self._humidity_calibration[6]) / 100)) / 16
+        var5 = ((var3 / 16384) * (var3 / 16384)) / 1024
+        var6 = (var4 * var5) / 2
+        calc_hum = (((var3 + var6) / 1024) * 1000) / 4096
+        calc_hum /= 1000  # get back to RH
+
+        if calc_hum > 100:
+            calc_hum = 100
+        if calc_hum < 0:
+            calc_hum = 0
+        return calc_hum
+
+    @property
+    def altitude(self):
+        """The altitude based on current ``pressure`` vs the sea level pressure
+           (``sea_level_pressure``) - which you must enter ahead of time)"""
+        pressure = self.pressure # in Si units for hPascal
+        return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))
+
+    @property
+    def gas(self):
+        """The gas resistance in ohms"""
+        self._perform_reading()
+        var1 = ((1340 + (5 * self._sw_err)) * (_LOOKUP_TABLE_1[self._gas_range])) / 65536
+        var2 = ((self._adc_gas * 32768) - 16777216) + var1
+        var3 = (_LOOKUP_TABLE_2[self._gas_range] * var1) / 512
+        calc_gas_res = (var3 + (var2 / 2)) / var2
+        return int(calc_gas_res)
+
+    def _perform_reading(self):
+        """Perform a single-shot reading from the sensor and fill internal data structure for
+           calculations"""
+        expired = time.ticks_diff(self._last_reading, time.ticks_ms()) * time.ticks_diff(0, 1)
+        if 0 <= expired < self._min_refresh_time:
+            time.sleep_ms(self._min_refresh_time - expired)
+
+        # set filter
+        self._write(_BME680_REG_CONFIG, [self._filter << 2])
+        # turn on temp oversample & pressure oversample
+        self._write(_BME680_REG_CTRL_MEAS,
+                    [(self._temp_oversample << 5)|(self._pressure_oversample << 2)])
+        # turn on humidity oversample
+        self._write(_BME680_REG_CTRL_HUM, [self._humidity_oversample])
+        # gas measurements enabled
+        self._write(_BME680_REG_CTRL_GAS, [_BME680_RUNGAS])
+
+        ctrl = self._read_byte(_BME680_REG_CTRL_MEAS)
+        ctrl = (ctrl & 0xFC) | 0x01  # enable single shot!
+        self._write(_BME680_REG_CTRL_MEAS, [ctrl])
+        new_data = False
+        while not new_data:
+            data = self._read(_BME680_REG_MEAS_STATUS, 15)
+            new_data = data[0] & 0x80 != 0
+            time.sleep(0.005)
+        self._last_reading = time.ticks_ms()
+
+        self._adc_pres = _read24(data[2:5]) / 16
+        self._adc_temp = _read24(data[5:8]) / 16
+        self._adc_hum = struct.unpack('>H', bytes(data[8:10]))[0]
+        self._adc_gas = int(struct.unpack('>H', bytes(data[13:15]))[0] / 64)
+        self._gas_range = data[14] & 0x0F
+
+        var1 = (self._adc_temp / 8) - (self._temp_calibration[0] * 2)
+        var2 = (var1 * self._temp_calibration[1]) / 2048
+        var3 = ((var1 / 2) * (var1 / 2)) / 4096
+        var3 = (var3 * self._temp_calibration[2] * 16) / 16384
+
+        self._t_fine = int(var2 + var3)
+
+    def _read_calibration(self):
+        """Read & save the calibration coefficients"""
+        coeff = self._read(_BME680_BME680_COEFF_ADDR1, 25)
+        coeff += self._read(_BME680_BME680_COEFF_ADDR2, 16)
+
+        coeff = list(struct.unpack('<hbBHhbBhhbbHhhBBBHbbbBbHhbb', bytes(coeff[1:39])))
+        # print("\n\n",coeff)
+        coeff = [float(i) for i in coeff]
+        self._temp_calibration = [coeff[x] for x in [23, 0, 1]]
+        self._pressure_calibration = [coeff[x] for x in [3, 4, 5, 7, 8, 10, 9, 12, 13, 14]]
+        self._humidity_calibration = [coeff[x] for x in [17, 16, 18, 19, 20, 21, 22]]
+        self._gas_calibration = [coeff[x] for x in [25, 24, 26]]
+
+        # flip around H1 & H2
+        self._humidity_calibration[1] *= 16
+        self._humidity_calibration[1] += self._humidity_calibration[0] % 16
+        self._humidity_calibration[0] /= 16
+
+        self._heat_range = (self._read_byte(0x02) & 0x30) / 16
+        self._heat_val = self._read_byte(0x00)
+        self._sw_err = (self._read_byte(0x04) & 0xF0) / 16
+
+    def _read_byte(self, register):
+        """Read a byte register value and return it"""
+        return self._read(register, 1)[0]
+
+    def _read(self, register, length):
+        raise NotImplementedError()
+
+    def _write(self, register, values):
+        raise NotImplementedError()
+
+class BME680_I2C(Adafruit_BME680):
+    """Driver for I2C connected BME680.
+
+        :param i2c: I2C device object
+        :param int address: I2C device address
+        :param bool debug: Print debug statements when True.
+        :param int refresh_rate: Maximum number of readings per second. Faster property reads
+          will be from the previous reading."""
+    def __init__(self, i2c, address=0x77, debug=False, *, refresh_rate=10):
+        """Initialize the I2C device at the 'address' given"""
+        self._i2c = i2c
+        self._address = address
+        self._debug = debug
+        super().__init__(refresh_rate=refresh_rate)
+
+    def _read(self, register, length):
+        """Returns an array of 'length' bytes from the 'register'"""
+        result = bytearray(length)
+        self._i2c.readfrom_mem_into(self._address, register & 0xff, result)
+        if self._debug:
+            print("\t${:x} read ".format(register), " ".join(["{:02x}".format(i) for i in result]))
+        return result
+
+    def _write(self, register, values):
+        """Writes an array of 'length' bytes to the 'register'"""
+        if self._debug:
+            print("\t${:x} write".format(register), " ".join(["{:02x}".format(i) for i in values]))
+        for value in values:
+            self._i2c.writeto_mem(self._address, register, bytearray([value & 0xFF]))
+            register += 1
+
+
+class BME680_SPI(Adafruit_BME680):
+    """Driver for SPI connected BME680.
+
+        :param spi: SPI device object, configured
+        :param cs: Chip Select Pin object, configured to OUT mode
+        :param bool debug: Print debug statements when True.
+        :param int refresh_rate: Maximum number of readings per second. Faster property reads
+          will be from the previous reading.
+      """
+
+    def __init__(self, spi, cs, debug=False, *, refresh_rate=10):
+        self._spi = spi
+        self._cs = cs
+        self._debug = debug
+        self._cs(1)
+        super().__init__(refresh_rate=refresh_rate)
+
+    def _read(self, register, length):
+        if register != _BME680_REG_PAGE_SELECT:
+            # _BME680_REG_PAGE_SELECT exists in both SPI memory pages
+            # For all other registers, we must set the correct memory page
+            self._set_spi_mem_page(register)
+        register = (register | 0x80) & 0xFF  # Read single, bit 7 high.
+
+        try:
+            self._cs(0)
+            self._spi.write(bytearray([register]))  # pylint: disable=no-member
+            result = bytearray(length)
+            self._spi.readinto(result)  # pylint: disable=no-member
+            if self._debug:
+                print("\t${:x} read ".format(register), " ".join(["{:02x}".format(i) for i in result]))
+        except Exception as e:
+            print (e)
+            result = None
+        finally:
+            self._cs(1)
+        return result
+
+    def _write(self, register, values):
+        if register != _BME680_REG_PAGE_SELECT:
+            # _BME680_REG_PAGE_SELECT exists in both SPI memory pages
+            # For all other registers, we must set the correct memory page
+            self._set_spi_mem_page(register)
+        register &= 0x7F  # Write, bit 7 low.
+        try:
+            self._cs(0)
+            buffer = bytearray(2 * len(values))
+            for i, value in enumerate(values):
+                buffer[2 * i] = register + i
+                buffer[2 * i + 1] = value & 0xFF
+            self._spi.write(buffer)  # pylint: disable=no-member
+            if self._debug:
+                print("\t${:x} write".format(register), " ".join(["{:02x}".format(i) for i in values]))
+        except Exception as e:
+            print (e)
+        finally:
+            self._cs(1)
+
+    def _set_spi_mem_page(self, register):
+        spi_mem_page = 0x00
+        if register < 0x80:
+            spi_mem_page = 0x10
+        self._write(_BME680_REG_PAGE_SELECT, [spi_mem_page])

scripts/bme680i.py

@@ -0,0 +1,418 @@
+# The MIT License (MIT)
+#
+# Copyright (c) 2017 ladyada for Adafruit Industries
+#
+# 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.
+
+# We have a lot of attributes for this complex sensor.
+# pylint: disable=too-many-instance-attributes
+
+"""
+`adafruit_bme680` - Adafruit BME680 - Temperature, Humidity, Pressure & Gas Sensor
+===================================================================================
+
+CircuitPython driver from BME680 air quality sensor
+
+* Author(s): ladyada
+"""
+
+import time
+import math
+from micropython import const
+from ubinascii import hexlify as hex
+try:
+    import struct
+except ImportError:
+    import ustruct as struct
+
+#    I2C ADDRESS/BITS/SETTINGS
+#    -----------------------------------------------------------------------
+_BME680_CHIPID = const(0x61)
+
+_BME680_REG_CHIPID = const(0xD0)
+_BME680_BME680_COEFF_ADDR1 = const(0x89)
+_BME680_BME680_COEFF_ADDR2 = const(0xE1)
+_BME680_BME680_RES_HEAT_0 = const(0x5A)
+_BME680_BME680_GAS_WAIT_0 = const(0x64)
+
+_BME680_REG_SOFTRESET = const(0xE0)
+_BME680_REG_CTRL_GAS = const(0x71)
+_BME680_REG_CTRL_HUM = const(0x72)
+_BME280_REG_STATUS = const(0xF3)
+_BME680_REG_CTRL_MEAS = const(0x74)
+_BME680_REG_CONFIG = const(0x75)
+
+_BME680_REG_PAGE_SELECT = const(0x73)
+_BME680_REG_MEAS_STATUS = const(0x1D)
+_BME680_REG_PDATA = const(0x1F)
+_BME680_REG_TDATA = const(0x22)
+_BME680_REG_HDATA = const(0x25)
+
+_BME680_SAMPLERATES = (0, 1, 2, 4, 8, 16)
+_BME680_FILTERSIZES = (0, 1, 3, 7, 15, 31, 63, 127)
+
+_BME680_RUNGAS = const(0x10)
+
+_LOOKUP_TABLE_1 = (2147483647, 2147483647, 2147483647, 2147483647, 2147483647,
+                   2126008810, 2147483647, 2130303777, 2147483647, 2147483647,
+                   2143188679, 2136746228, 2147483647, 2126008810, 2147483647,
+                   2147483647)
+
+_LOOKUP_TABLE_2 = (4096000000, 2048000000, 1024000000, 512000000, 255744255, 127110228,
+                   64000000, 32258064, 16016016, 8000000, 4000000, 2000000, 1000000,
+                   500000, 250000, 125000)
+
+
+def _read24(arr):
+    """Parse an unsigned 24-bit value as a floating point and return it."""
+    ret = 0
+    #print([hex(i) for i in arr])
+    for b in arr:
+        ret <<= 8
+        ret += b & 0xFF
+    return ret
+
+
+class Adafruit_BME680:
+    """Driver from BME680 air quality sensor
+
+       :param int refresh_rate: Maximum number of readings per second. Faster property reads
+         will be from the previous reading."""
+    def __init__(self, *, refresh_rate=10):
+        """Check the BME680 was found, read the coefficients and enable the sensor for continuous
+           reads."""
+        self._write(_BME680_REG_SOFTRESET, [0xB6])
+        time.sleep(0.005)
+
+        # Check device ID.
+        chip_id = self._read_byte(_BME680_REG_CHIPID)
+        if chip_id != _BME680_CHIPID:
+            raise RuntimeError('Failed to find BME680! Chip ID 0x%x' % chip_id)
+
+        self._read_calibration()
+
+        # set up heater
+        self._write(_BME680_BME680_RES_HEAT_0, [0x73])
+        self._write(_BME680_BME680_GAS_WAIT_0, [0x65])
+
+        self.sea_level_pressure = 1013.25
+        """Pressure in hectoPascals at sea level. Used to calibrate ``altitude``."""
+
+        # Default oversampling and filter register values.
+        self._pressure_oversample = 0b011
+        self._temp_oversample = 0b100
+        self._humidity_oversample = 0b010
+        self._filter = 0b010
+
+        self._adc_pres = None
+        self._adc_temp = None
+        self._adc_hum = None
+        self._adc_gas = None
+        self._gas_range = None
+        self._t_fine = None
+
+        self._last_reading = time.ticks_ms()
+        self._min_refresh_time = 1000 // refresh_rate
+
+    @property
+    def pressure_oversample(self):
+        """The oversampling for pressure sensor"""
+        return _BME680_SAMPLERATES[self._pressure_oversample]
+
+    @pressure_oversample.setter
+    def pressure_oversample(self, sample_rate):
+        if sample_rate in _BME680_SAMPLERATES:
+            self._pressure_oversample = _BME680_SAMPLERATES.index(sample_rate)
+        else:
+            raise RuntimeError("Invalid oversample")
+
+    @property
+    def humidity_oversample(self):
+        """The oversampling for humidity sensor"""
+        return _BME680_SAMPLERATES[self._humidity_oversample]
+
+    @humidity_oversample.setter
+    def humidity_oversample(self, sample_rate):
+        if sample_rate in _BME680_SAMPLERATES:
+            self._humidity_oversample = _BME680_SAMPLERATES.index(sample_rate)
+        else:
+            raise RuntimeError("Invalid oversample")
+
+    @property
+    def temperature_oversample(self):
+        """The oversampling for temperature sensor"""
+        return _BME680_SAMPLERATES[self._temp_oversample]
+
+    @temperature_oversample.setter
+    def temperature_oversample(self, sample_rate):
+        if sample_rate in _BME680_SAMPLERATES:
+            self._temp_oversample = _BME680_SAMPLERATES.index(sample_rate)
+        else:
+            raise RuntimeError("Invalid oversample")
+
+    @property
+    def filter_size(self):
+        """The filter size for the built in IIR filter"""
+        return _BME680_FILTERSIZES[self._filter]
+
+    @filter_size.setter
+    def filter_size(self, size):
+        if size in _BME680_FILTERSIZES:
+            self._filter = _BME680_FILTERSIZES[size]
+        else:
+            raise RuntimeError("Invalid size")
+
+    @property
+    def temperature(self):
+        """The compensated temperature in degrees celsius."""
+        self._perform_reading()
+        calc_temp = (((self._t_fine * 5) + 128) // 256)
+        return calc_temp / 100
+
+    @property
+    def pressure(self):
+        """The barometric pressure in hectoPascals"""
+        self._perform_reading()
+        
+        var1 = (int(self._t_fine) >> 1) - 64000
+        var2 = ((var1 >> 2) * (var1 >> 2 )) >> 11
+        var2 = (var2 * self._pressure_calibration[5]) >> 2
+        var2 = var2 + ((var1 * self._pressure_calibration[4]) << 1)
+        var2 = (var2 >> 2) + (self._pressure_calibration[3] << 16)
+        var1 = (((((var1 >> 2) * (var1 >> 2)) >> 13) *
+                (self._pressure_calibration[2] << 5) >> 3) +
+                ((self._pressure_calibration[1] * var1) >> 1))
+        var1 = var1 >> 18
+        var1 = ((32768 + var1) * self._pressure_calibration[0]) >> 15
+        calc_pres = 1048576 - int(self._adc_pres)
+        calc_pres = (calc_pres - (var2 >> 12)) * 3125
+        calc_pres = (calc_pres << 1) // var1
+        var1 = (self._pressure_calibration[8] * (((calc_pres >> 3) * (calc_pres >> 3)) >> 13)) >> 12
+        var2 = ((calc_pres >> 2) * self._pressure_calibration[7]) >> 13
+        var3 = (((calc_pres >> 8) * (calc_pres >> 8) * (calc_pres >> 8)) * self._pressure_calibration[9]) >> 17
+        calc_pres += ((var1 + var2 + var3 + (self._pressure_calibration[6] << 7)) >> 4)
+        return calc_pres / 100
+
+    @property
+    def humidity(self):
+        """The relative humidity in RH %"""
+        self._perform_reading()
+
+        temp_scaled = ((self._t_fine * 5) + 128) >> 8
+        var1 = ((self._adc_hum - (self._humidity_calibration[0] * 16)) -
+                (((temp_scaled * self._humidity_calibration[2]) // 100) >> 1))
+        var2 = (self._humidity_calibration[1] *
+                (((temp_scaled * self._humidity_calibration[3]) // 100) +
+                 (((temp_scaled * ((temp_scaled * self._humidity_calibration[4]) 
+                    // 100)) >> 6) // 100) + 16384)) >> 10
+        var3 = var1 * var2
+        var4 = self._humidity_calibration[5] << 7
+        var4 = (var4 + ((temp_scaled * self._humidity_calibration[6]) // 100)) >> 4
+        var5 = ((var3 >> 14) * (var3 >> 14)) >> 10
+        var6 = (var4 * var5) >> 1
+        calc_hum = ((var3 + var6) >> 10) / 4096 
+
+        if calc_hum > 10000:
+            calc_hum = 10000
+        if calc_hum < 0:
+            calc_hum = 0
+        return calc_hum
+
+    @property
+    def altitude(self):
+        """The altitude based on current ``pressure`` vs the sea level pressure
+           (``sea_level_pressure``) - which you must enter ahead of time)"""
+        pressure = self.pressure # in Si units for hPascal
+        return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))
+
+    @property
+    def gas(self):
+        """The gas resistance in ohms"""
+        self._perform_reading()
+        var1 = ((1340 + (5 * self._sw_err)) * (_LOOKUP_TABLE_1[self._gas_range])) >> 16
+        var2 = ((self._adc_gas << 15) - 16777216) + var1
+        var3 = (_LOOKUP_TABLE_2[self._gas_range] * var1) >> 9
+        calc_gas_res = (var3 + (var2 >> 1)) // var2
+        return int(calc_gas_res)
+
+    def _perform_reading(self):
+        """Perform a single-shot reading from the sensor and fill internal data structure for
+           calculations"""
+        expired = time.ticks_diff(self._last_reading, time.ticks_ms()) * time.ticks_diff(0, 1)
+        if 0 <= expired < self._min_refresh_time:
+            time.sleep_ms(self._min_refresh_time - expired)
+
+        # set filter
+        self._write(_BME680_REG_CONFIG, [self._filter << 2])
+        # turn on temp oversample & pressure oversample
+        self._write(_BME680_REG_CTRL_MEAS,
+                    [(self._temp_oversample << 5)|(self._pressure_oversample << 2)])
+        # turn on humidity oversample
+        self._write(_BME680_REG_CTRL_HUM, [self._humidity_oversample])
+        # gas measurements enabled
+        self._write(_BME680_REG_CTRL_GAS, [_BME680_RUNGAS])
+
+        ctrl = self._read_byte(_BME680_REG_CTRL_MEAS)
+        ctrl = (ctrl & 0xFC) | 0x01  # enable single shot!
+        self._write(_BME680_REG_CTRL_MEAS, [ctrl])
+        new_data = False
+        while not new_data:
+            data = self._read(_BME680_REG_MEAS_STATUS, 15)
+            new_data = data[0] & 0x80 != 0
+            time.sleep(0.005)
+        self._last_reading = time.ticks_ms()
+
+        self._adc_pres = _read24(data[2:5]) / 16
+        self._adc_temp = _read24(data[5:8]) / 16
+        self._adc_hum = struct.unpack('>H', bytes(data[8:10]))[0]
+        self._adc_gas = int(struct.unpack('>H', bytes(data[13:15]))[0] / 64)
+        self._gas_range = data[14] & 0x0F
+
+        var1 = (int(self._adc_temp) >> 3) - (self._temp_calibration[0] << 1)
+        var2 = (var1 * self._temp_calibration[1]) >> 11
+        var3 = ((var1 >> 1) * (var1 >> 1)) >> 12
+        var3 = (var3 * self._temp_calibration[2] << 4) >> 14
+        self._t_fine = int(var2 + var3)
+
+    def _read_calibration(self):
+        """Read & save the calibration coefficients"""
+        coeff = self._read(_BME680_BME680_COEFF_ADDR1, 25)
+        coeff += self._read(_BME680_BME680_COEFF_ADDR2, 16)
+
+        coeff = list(struct.unpack('<hbBHhbBhhbbHhhBBBHbbbBbHhbb', bytes(coeff[1:39])))
+        # print("\n\n",coeff)
+        self._temp_calibration = [coeff[x] for x in [23, 0, 1]]
+        self._pressure_calibration = [coeff[x] for x in [3, 4, 5, 7, 8, 10, 9, 12, 13, 14]]
+        self._humidity_calibration = [coeff[x] for x in [17, 16, 18, 19, 20, 21, 22]]
+        self._gas_calibration = [coeff[x] for x in [25, 24, 26]]
+
+        # flip around H1 & H2
+        self._humidity_calibration[1] <<= 4
+        self._humidity_calibration[1] |= self._humidity_calibration[0] & 0x0f
+        self._humidity_calibration[0] >>= 4
+
+        self._heat_range = (self._read_byte(0x02) & 0x30) >> 4
+        self._heat_val = self._read_byte(0x00)
+        self._sw_err = (self._read_byte(0x04) & 0xF0) >> 4
+
+    def _read_byte(self, register):
+        """Read a byte register value and return it"""
+        return self._read(register, 1)[0]
+
+    def _read(self, register, length):
+        raise NotImplementedError()
+
+    def _write(self, register, values):
+        raise NotImplementedError()
+
+class BME680_I2C(Adafruit_BME680):
+    """Driver for I2C connected BME680.
+
+        :param i2c: I2C device object
+        :param int address: I2C device address
+        :param bool debug: Print debug statements when True.
+        :param int refresh_rate: Maximum number of readings per second. Faster property reads
+          will be from the previous reading."""
+    def __init__(self, i2c, address=0x77, debug=False, *, refresh_rate=10):
+        """Initialize the I2C device at the 'address' given"""
+        self._i2c = i2c
+        self._address = address
+        self._debug = debug
+        super().__init__(refresh_rate=refresh_rate)
+
+    def _read(self, register, length):
+        """Returns an array of 'length' bytes from the 'register'"""
+        result = bytearray(length)
+        self._i2c.readfrom_mem_into(self._address, register & 0xff, result)
+        if self._debug:
+            print("\t${:x} read ".format(register), " ".join(["{:02x}".format(i) for i in result]))
+        return result
+
+    def _write(self, register, values):
+        """Writes an array of 'length' bytes to the 'register'"""
+        if self._debug:
+            print("\t${:x} write".format(register), " ".join(["{:02x}".format(i) for i in values]))
+        for value in values:
+            self._i2c.writeto_mem(self._address, register, bytearray([value & 0xFF]))
+            register += 1
+
+
+class BME680_SPI(Adafruit_BME680):
+    """Driver for SPI connected BME680.
+
+        :param spi: SPI device object, configured
+        :param cs: Chip Select Pin object, configured to OUT mode
+        :param bool debug: Print debug statements when True.
+        :param int refresh_rate: Maximum number of readings per second. Faster property reads
+          will be from the previous reading.
+      """
+
+    def __init__(self, spi, cs, debug=False, *, refresh_rate=10):
+        self._spi = spi
+        self._cs = cs
+        self._debug = debug
+        self._cs(1)
+        super().__init__(refresh_rate=refresh_rate)
+
+    def _read(self, register, length):
+        if register != _BME680_REG_PAGE_SELECT:
+            # _BME680_REG_PAGE_SELECT exists in both SPI memory pages
+            # For all other registers, we must set the correct memory page
+            self._set_spi_mem_page(register)
+        register = (register | 0x80) & 0xFF  # Read single, bit 7 high.
+
+        try:
+            self._cs(0)
+            self._spi.write(bytearray([register]))  # pylint: disable=no-member
+            result = bytearray(length)
+            self._spi.readinto(result)  # pylint: disable=no-member
+            if self._debug:
+                print("\t${:x} read ".format(register), " ".join(["{:02x}".format(i) for i in result]))
+        except Exception as e:
+            print (e)
+            result = None
+        finally:
+            self._cs(1)
+        return result
+
+    def _write(self, register, values):
+        if register != _BME680_REG_PAGE_SELECT:
+            # _BME680_REG_PAGE_SELECT exists in both SPI memory pages
+            # For all other registers, we must set the correct memory page
+            self._set_spi_mem_page(register)
+        register &= 0x7F  # Write, bit 7 low.
+        try:
+            self._cs(0)
+            buffer = bytearray(2 * len(values))
+            for i, value in enumerate(values):
+                buffer[2 * i] = register + i
+                buffer[2 * i + 1] = value & 0xFF
+            self._spi.write(buffer)  # pylint: disable=no-member
+            if self._debug:
+                print("\t${:x} write".format(register), " ".join(["{:02x}".format(i) for i in values]))
+        except Exception as e:
+            print (e)
+        finally:
+            self._cs(1)
+
+    def _set_spi_mem_page(self, register):
+        spi_mem_page = 0x00
+        if register < 0x80:
+            spi_mem_page = 0x10
+        self._write(_BME680_REG_PAGE_SELECT, [spi_mem_page])

scripts/constants.py

@@ -0,0 +1,12 @@
+# constants.py
+
+# Wi-Fi Configuration
+WIFI_SSID = 'Pixel 8'
+WIFI_PASSWORD = '123456789'
+
+# MQTT Configuration
+MQTT_BROKER = 'b6bdb89571144b3d8e5ca4bbe666ddb5.s1.eu.hivemq.cloud'
+MQTT_PORT = 8883
+MQTT_TOPIC = 'sensors/bme680/data'
+MQTT_USER = 'LuthiraMQ'
+MQTT_PASSWORD = 'Password1118.'

scripts/demo.py

@@ -0,0 +1,18 @@
+from bme680 import *   
+from machine import I2C, Pin  
+import time                  
+
+i2c = I2C(0, scl=Pin(5), sda=Pin(4))  
+
+bme = BME680_I2C(i2c)
+
+while True:
+    print("--------------------------------------------------")
+    print()
+    print("Temperature: {:.2f} °C".format(bme.temperature))
+    print("Humidity: {:.2f} %".format(bme.humidity))
+    print("Pressure: {:.2f} hPa".format(bme.pressure))
+    print("Gas: {:.2f} ohms".format(bme.gas))
+    print()
+    time.sleep(3)  
+

scripts/lib/CHANGELOG.md

@@ -0,0 +1,50 @@
+2.0.0
+-----
+
+* Repackage to hatch/pyproject.toml
+* Drop Python 2.7 support
+* Switch from smbu2 to smbus2
+
+1.1.1
+-----
+
+* New: constants to clarify heater on/off states
+
+1.1.0
+-----
+
+* New: support for BME688 "high" gas resistance variant
+* New: set/get gas heater disable bit
+* Enhancement: fail with descriptive RuntimeError when chip is not detected
+
+1.0.5
+-----
+
+* New: set_temp_offset to calibrate temperature offset in degrees C
+
+1.0.4
+-----
+
+* Fix to range_sw_err for extremely high gas readings
+* Convert to unsigned int to fix negative gas readings
+
+1.0.3
+-----
+
+* Merged temperature compensation fix from Bosch's BME680_driver 3.5.3
+
+1.0.2
+-----
+
+* Fixed set_gas_heater_temperature to avoid i2c TypeError
+
+1.0.1
+-----
+
+* Added Manifest to Python package
+
+1.0.0
+-----
+
+* Initial release
+

scripts/lib/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Pimoroni Ltd
+
+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.

scripts/lib/README.md

@@ -0,0 +1,56 @@
+# BME680
+
+[![Build Status](https://img.shields.io/github/actions/workflow/status/pimoroni/bme680-python/test.yml?branch=main)](https://github.com/pimoroni/bme680-python/actions/workflows/test.yml)
+[![Coverage Status](https://coveralls.io/repos/github/pimoroni/bme680-python/badge.svg?branch=main)](https://coveralls.io/github/pimoroni/bme680-python?branch=main)
+[![PyPi Package](https://img.shields.io/pypi/v/bme680.svg)](https://pypi.python.org/pypi/bme680)
+[![Python Versions](https://img.shields.io/pypi/pyversions/bme680.svg)](https://pypi.python.org/pypi/bme680)
+
+https://shop.pimoroni.com/products/bme680
+
+The state-of-the-art BME680 breakout lets you measure temperature, pressure, humidity, and indoor air quality.
+
+## Installing
+
+### Full install (recommended):
+
+We've created an easy installation script that will install all pre-requisites and get your BME680
+up and running with minimal efforts. To run it, fire up Terminal which you'll find in Menu -> Accessories -> Terminal
+on your Raspberry Pi desktop, as illustrated below:
+
+![Finding the terminal](http://get.pimoroni.com/resources/github-repo-terminal.png)
+
+In the new terminal window type the command exactly as it appears below (check for typos) and follow the on-screen instructions:
+
+```bash
+git clone https://github.com/pimoroni/bme680-python
+cd bme680-python
+./install.sh
+```
+
+**Note** Libraries will be installed in the "pimoroni" virtual environment, you will need to activate it to run examples:
+
+```
+source ~/.virtualenvs/pimoroni/bin/activate
+```
+
+### Development:
+
+If you want to contribute, or like living on the edge of your seat by having the latest code, you can install the development version like so:
+
+```bash
+git clone https://github.com/pimoroni/bme680-python
+cd bme680-python
+./install.sh --unstable
+```
+
+In all cases you will have to enable the i2c bus:
+
+```
+sudo raspi-config nonint do_i2c 0
+```
+
+## Documentation & Support
+
+* Guides and tutorials - https://learn.pimoroni.com/bme680-breakout
+* Get help - http://forums.pimoroni.com/c/support
+

scripts/lib/adafruit_blinka-8.49.0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.1
+Name: adafruit-blinka
+Version: 8.49.0
+Summary: Dummy package for satisfying formal requirements
+Home-page: ?
+Author: ?
+
+?

scripts/lib/adafruit_blinka-8.49.0.dist-info/RECORD

@@ -0,0 +1,2 @@
+adafruit_blinka-8.49.0.dist-info/METADATA,,
+adafruit_blinka-8.49.0.dist-info/RECORD,,

scripts/lib/as7341.py

@@ -0,0 +1,608 @@
+"""
+This file licensed under the MIT License and incorporates work covered by
+the following copyright and permission notice:
+
+The MIT License (MIT)
+
+Copyright (c) 2022-2022 Rob Hamerling
+
+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.
+
+Rob Hamerling, Version 0.0, August 2022
+
+ Original by WaveShare for Raspberry Pi, part of:
+    https://www.waveshare.com/w/upload/b/b3/AS7341_Spectral_Color_Sensor_code.7z
+
+ Converted to Micropython for use with MicroPython devices such as ESP32
+    - pythonized (in stead of 'literal' translation of C code)
+    - instance of AS7341 requires specification of I2C interface
+    - added I2C read/write error detection
+    - added check for connected AS7341 incl. device ID
+    - some code optimization (esp. adding I2C word/block reads/writes)
+    - Replaced bit addressing like (1<<5) by symbolic name with bit mask
+    - moved SMUX settings for predefined channel mappings to a dictionary
+      and as a separate file to allow changes or additional configurations
+      by the user without changing the driver
+    - several changes of names of functions and constants
+      (incl. camel case -> word separators with underscores)
+    - added comments, doc-strings with explanation and/or argumentation
+    - several other improvements and some corrections
+
+  Remarks:
+    - Automatic Gain Control (AGC) is not supported
+    - No provisions for SYND mode
+
+"""
+
+from time import sleep_ms
+
+from as7341_smux_select import *  # predefined SMUX configurations
+
+AS7341_I2C_ADDRESS = const(0x39)  # I2C address of AS7341
+AS7341_ID_VALUE = const(0x24)  # AS7341 Part Number Identification
+# (excl 2 low order bits)
+
+# Symbolic names for registers and some selected bit fields
+# Note: ASTATUS, ITIME and CHx_DATA in address range 0x60--0x6F are not used
+AS7341_CONFIG = const(0x70)
+AS7341_CONFIG_INT_MODE_SPM = const(0x00)
+AS7341_MODE_SPM = AS7341_CONFIG_INT_MODE_SPM  # alias
+AS7341_CONFIG_INT_MODE_SYNS = const(0x01)
+AS7341_MODE_SYNS = AS7341_CONFIG_INT_MODE_SYNS  # alias
+AS7341_CONFIG_INT_MODE_SYND = const(0x03)
+AS7341_MODE_SYND = AS7341_CONFIG_INT_MODE_SYND  # alias
+AS7341_CONFIG_INT_SEL = const(0x04)
+AS7341_CONFIG_LED_SEL = const(0x08)
+AS7341_STAT = const(0x71)
+AS7341_STAT_READY = const(0x01)
+AS7341_STAT_WAIT_SYNC = const(0x02)
+AS7341_EDGE = const(0x72)
+AS7341_GPIO = const(0x73)
+AS7341_GPIO_PD_INT = const(0x01)
+AS7341_GPIO_PD_GPIO = const(0x02)
+AS7341_LED = const(0x74)
+AS7341_LED_LED_ACT = const(0x80)
+AS7341_ENABLE = const(0x80)
+AS7341_ENABLE_PON = const(0x01)
+AS7341_ENABLE_SP_EN = const(0x02)
+AS7341_ENABLE_WEN = const(0x08)
+AS7341_ENABLE_SMUXEN = const(0x10)
+AS7341_ENABLE_FDEN = const(0x40)
+AS7341_ATIME = const(0x81)
+AS7341_WTIME = const(0x83)
+AS7341_SP_TH_LOW = const(0x84)
+AS7341_SP_TH_L_LSB = const(0x84)
+AS7341_SP_TH_L_MSB = const(0x85)
+AS7341_SP_TH_HIGH = const(0x86)
+AS7341_SP_TH_H_LSB = const(0x86)
+AS7341_SP_TH_H_MSB = const(0x87)
+AS7341_AUXID = const(0x90)
+AS7341_REVID = const(0x91)
+AS7341_ID = const(0x92)
+AS7341_STATUS = const(0x93)
+AS7341_STATUS_ASAT = const(0x80)
+AS7341_STATUS_AINT = const(0x08)
+AS7341_STATUS_FINT = const(0x04)
+AS7341_STATUS_C_INT = const(0x02)
+AS7341_STATUS_SINT = const(0x01)
+AS7341_ASTATUS = const(0x94)  # start of bulk read (incl 6 counts)
+AS7341_ASTATUS_ASAT_STATUS = const(0x80)
+AS7341_ASTATUS_AGAIN_STATUS = const(0x0F)
+AS7341_CH_DATA = const(0x95)  # start of the 6 channel counts
+AS7341_CH0_DATA_L = const(0x95)
+AS7341_CH0_DATA_H = const(0x96)
+AS7341_CH1_DATA_L = const(0x97)
+AS7341_CH1_DATA_H = const(0x98)
+AS7341_CH2_DATA_L = const(0x99)
+AS7341_CH2_DATA_H = const(0x9A)
+AS7341_CH3_DATA_L = const(0x9B)
+AS7341_CH3_DATA_H = const(0x9C)
+AS7341_CH4_DATA_L = const(0x9D)
+AS7341_CH4_DATA_H = const(0x9E)
+AS7341_CH5_DATA_L = const(0x9F)
+AS7341_CH5_DATA_H = const(0xA0)
+AS7341_STATUS_2 = const(0xA3)
+AS7341_STATUS_2_AVALID = const(0x40)
+AS7341_STATUS_3 = const(0xA4)
+AS7341_STATUS_5 = const(0xA6)
+AS7341_STATUS_6 = const(0xA7)
+AS7341_CFG_0 = const(0xA9)
+AS7341_CFG_0_WLONG = const(0x04)
+AS7341_CFG_0_REG_BANK = const(0x10)  # datasheet fig 82 (! fig 32)
+AS7341_CFG_0_LOW_POWER = const(0x20)
+AS7341_CFG_1 = const(0xAA)
+AS7341_CFG_3 = const(0xAC)
+AS7341_CFG_6 = const(0xAF)
+AS7341_CFG_6_SMUX_CMD_ROM = const(0x00)
+AS7341_CFG_6_SMUX_CMD_READ = const(0x08)
+AS7341_CFG_6_SMUX_CMD_WRITE = const(0x10)
+AS7341_CFG_8 = const(0xB1)
+AS7341_CFG_9 = const(0xB2)
+AS7341_CFG_10 = const(0xB3)
+AS7341_CFG_12 = const(0xB5)
+AS7341_PERS = const(0xBD)
+AS7341_GPIO_2 = const(0xBE)
+AS7341_GPIO_2_GPIO_IN = const(0x01)
+AS7341_GPIO_2_GPIO_OUT = const(0x02)
+AS7341_GPIO_2_GPIO_IN_EN = const(0x04)
+AS7341_GPIO_2_GPIO_INV = const(0x08)
+AS7341_ASTEP = const(0xCA)
+AS7341_ASTEP_L = const(0xCA)
+AS7341_ASTEP_H = const(0xCB)
+AS7341_AGC_GAIN_MAX = const(0xCF)
+AS7341_AZ_CONFIG = const(0xD6)
+AS7341_FD_TIME_1 = const(0xD8)
+AS7341_FD_TIME_2 = const(0xDA)
+AS7341_FD_CFG0 = const(0xD7)
+AS7341_FD_STATUS = const(0xDB)
+AS7341_FD_STATUS_FD_100HZ = const(0x01)
+AS7341_FD_STATUS_FD_120HZ = const(0x02)
+AS7341_FD_STATUS_FD_100_VALID = const(0x04)
+AS7341_FD_STATUS_FD_120_VALID = const(0x08)
+AS7341_FD_STATUS_FD_SAT_DETECT = const(0x10)
+AS7341_FD_STATUS_FD_MEAS_VALID = const(0x20)
+AS7341_INTENAB = const(0xF9)
+AS7341_INTENAB_SP_IEN = const(0x08)
+AS7341_CONTROL = const(0xFA)
+AS7341_FIFO_MAP = const(0xFC)
+AS7341_FIFO_LVL = const(0xFD)
+AS7341_FDATA = const(0xFE)
+AS7341_FDATA_L = const(0xFE)
+AS7341_FDATA_H = const(0xFF)
+
+
+class AS7341:
+    """Class for AS7341: 11 Channel Multi-Spectral Digital Sensor"""
+
+    def __init__(self, i2c, addr=AS7341_I2C_ADDRESS):
+        """specification of active I2C object is mandatory
+        specification of I2C address of AS7341 is optional
+        """
+        self.__bus = i2c
+        self.__address = addr
+        self.__buffer1 = bytearray(1)  # I2C I/O buffer for byte
+        self.__buffer2 = bytearray(2)  # I2C I/O buffer for word
+        self.__buffer13 = bytearray(13)  # I2C I/O buffer ASTATUS + 6 counts
+        self.__measuremode = AS7341_MODE_SPM  # default measurement mode
+        self.__connected = self.reset()  # recycle power, check AS7341 presence
+
+    """ --------- 'private' functions ----------- """
+
+    def __read_byte(self, reg):
+        """read byte, return byte (integer) value"""
+        try:
+            self.__bus.readfrom_mem_into(self.__address, reg, self.__buffer1)
+            return self.__buffer1[0]  # return integer value
+        except Exception as err:
+            print("I2C read_byte at 0x{:02X}, error".format(reg), err)
+            return -1  # indication 'no receive'
+
+    def __read_word(self, reg):
+        """read 2 consecutive bytes, return integer value (little Endian)"""
+        try:
+            self.__bus.readfrom_mem_into(self.__address, reg, self.__buffer2)
+            return int.from_bytes(self.__buffer2, "little")  # return word value
+        except Exception as err:
+            print("I2C read_word at 0x{:02X}, error".format(reg), err)
+            return -1  # indication 'no receive'
+
+    def __read_all_channels(self):
+        """read ASTATUS register and all channels, return list of 6 integer values"""
+        try:
+            self.__bus.readfrom_mem_into(
+                self.__address, AS7341_ASTATUS, self.__buffer13
+            )
+            return [
+                int.from_bytes(self.__buffer13[1 + 2 * i : 3 + 2 * i], "little")
+                for i in range(6)
+            ]
+        except Exception as err:
+            print(
+                "I2C read_all_channels at 0x{:02X}, error".format(AS7341_ASTATUS), err
+            )
+            return []  # empty list
+
+    def __write_byte(self, reg, value):
+        """write a single byte to the specified register"""
+        self.__buffer1[0] = value & 0xFF
+        try:
+            self.__bus.writeto_mem(self.__address, reg, self.__buffer1)
+            sleep_ms(10)
+        except Exception as err:
+            print("I2C write_byte at 0x{:02X}, error".format(reg), err)
+            return False
+        return True
+
+    def __write_word(self, reg, value):
+        """write a word as 2 bytes (little endian encoding)
+        to adresses <reg> + 0 and <reg> + 1
+        """
+        self.__buffer2[0] = value & 0xFF  # low byte
+        self.__buffer2[1] = (value >> 8) & 0xFF  # high byte
+        try:
+            self.__bus.writeto_mem(self.__address, reg, self.__buffer2)
+            sleep_ms(20)
+        except Exception as err:
+            print("I2C write_word at 0x{:02X}, error".format(reg), err)
+            return False
+        return True
+
+    def __write_burst(self, reg, value):
+        """write an array of bytes to consucutive addresses starting <reg>"""
+        try:
+            self.__bus.writeto_mem(self.__address, reg, value)
+            sleep_ms(100)
+        except Exception as err:
+            print("I2C write_burst at 0x{:02X}, error".format(reg), err)
+            return False
+        return True
+
+    def __modify_reg(self, reg, mask, flag=True):
+        """modify register <reg> with <mask>
+        <flag> True  means 'or' with <mask> : set the bit(s)
+        <flag> False means 'and' with inverted <mask> : reset the bit(s)
+        Notes: 1. Works only with '1' bits in <mask>
+                  (in most cases <mask> contains a single 1-bit!)
+               2. When <reg> is in region 0x60-0x74
+                  bank 1 is supposed be set by caller
+        """
+        data = self.__read_byte(reg)  # read <reg>
+        if flag:
+            data |= mask
+        else:
+            data &= ~mask
+        self.__write_byte(reg, data)  # rewrite <reg>
+
+    def __set_bank(self, bank=1):
+        """select registerbank
+        <bank> 1 for access to regs 0x60-0x74
+        <bank> 0 for access to regs 0x80-0xFF
+        Note: It seems that reg CFG_0 (0x93) is accessible
+              even when REG_BANK bit is set for 0x60-0x74,
+              otherwise it wouldn't be possible to reset REG_BANK
+              Datasheet isn't clear about this.
+        """
+        if bank in (0, 1):
+            self.__modify_reg(AS7341_CFG_0, AS7341_CFG_0_REG_BANK, bank == 1)
+
+    """ ----------- 'public' functions ----------- """
+
+    def enable(self):
+        """enable device (only power on)"""
+        self.__write_byte(AS7341_ENABLE, AS7341_ENABLE_PON)
+
+    def disable(self):
+        """disable all functions and power off"""
+        self.__set_bank(1)  # CONFIG register is in bank 1
+        self.__write_byte(AS7341_CONFIG, 0x00)  # INT, LED off, SPM mode
+        self.__set_bank(0)
+        self.__write_byte(AS7341_ENABLE, 0x00)  # power off
+
+    def isconnected(self):
+        """determine if AS7341 is successfully initialized (True/False)"""
+        return self.__connected
+
+    def reset(self):
+        """Cycle power and check if AS7341 is (re-)connected
+        When connected set (restore) measurement mode
+        """
+        self.disable()  # power-off ('reset')
+        sleep_ms(50)  # quisce
+        self.enable()  # (only) power-on
+        sleep_ms(50)  # settle
+        id = self.__read_byte(AS7341_ID)  # obtain Part Number ID
+        if id < 0:  # read error
+            print(
+                "Failed to contact AS7341 at I2C address 0x{:02X}".format(
+                    self.__address
+                )
+            )
+            return False
+        else:
+            if not (id & (~0x03)) == AS7341_ID_VALUE:  # ID in bits 7..2 bits
+                print(
+                    "No AS7341: ID = 0x{:02X}, expected 0x{:02X}".format(
+                        id, AS7341_ID_VALUE
+                    )
+                )
+                return False
+        self.set_measure_mode(self.__measuremode)  # configure chip
+        return True
+
+    def measurement_completed(self):
+        """check if measurement completed (return True) or otherwise return False"""
+        return bool(self.__read_byte(AS7341_STATUS_2) & AS7341_STATUS_2_AVALID)
+
+    def set_spectral_measurement(self, flag=True):
+        """enable (flag == True) spectral measurement or otherwise disable it"""
+        self.__modify_reg(AS7341_ENABLE, AS7341_ENABLE_SP_EN, flag)
+
+    def set_smux(self, flag=True):
+        """enable (flag == True) SMUX or otherwise disable it"""
+        self.__modify_reg(AS7341_ENABLE, AS7341_ENABLE_SMUXEN, flag)
+
+    def set_measure_mode(self, mode=AS7341_CONFIG_INT_MODE_SPM):
+        """configure the AS7341 for a specific measurement mode
+        when interrupt needed it must be configured separately
+        """
+        if mode in (
+            AS7341_CONFIG_INT_MODE_SPM,  # meas. started by SP_EN
+            AS7341_CONFIG_INT_MODE_SYNS,  # meas. started by GPIO
+            AS7341_CONFIG_INT_MODE_SYND,
+        ):  # meas. started by GPIO + EDGE
+            self.__measuremode = mode  # store new measurement mode
+            self.__set_bank(1)  # CONFIG register is in bank 1
+            data = self.__read_byte(AS7341_CONFIG) & (~3)  # discard 2 LSbs (mode)
+            data |= mode  # insert new mode
+            self.__write_byte(AS7341_CONFIG, data)  # modify measurement mode
+            self.__set_bank(0)
+
+    def channel_select(self, selection):
+        """select one from a series of predefined SMUX configurations
+        <selection> should be a key in dictionary AS7341_SMUX_SELECT
+        20 bytes of memory starting from address 0 will be overwritten.
+        """
+        if selection in AS7341_SMUX_SELECT:
+            self.__write_burst(0x00, AS7341_SMUX_SELECT[selection])
+        else:
+            print(selection, "is unknown in AS7341_SMUX_SELECT")
+
+    def start_measure(self, selection):
+        """select SMUX configuration, prepare and start measurement"""
+        self.__modify_reg(AS7341_CFG_0, AS7341_CFG_0_LOW_POWER, False)  # no low power
+        self.set_spectral_measurement(False)  # quiesce
+        self.__write_byte(AS7341_CFG_6, AS7341_CFG_6_SMUX_CMD_WRITE)  # write mode
+        if self.__measuremode == AS7341_CONFIG_INT_MODE_SPM:
+            self.channel_select(selection)
+            self.set_smux(True)
+        elif self.__measuremode == AS7341_CONFIG_INT_MODE_SYNS:
+            self.channel_select(selection)
+            self.set_smux(True)
+            self.set_gpio_mode(AS7341_GPIO_2_GPIO_IN_EN)
+        self.set_spectral_measurement(True)
+        if self.__measuremode == AS7341_CONFIG_INT_MODE_SPM:
+            while not self.measurement_completed():
+                sleep_ms(50)
+
+    def get_channel_data(self, channel):
+        """read count of a single channel (channel in range 0..5)
+        with or without measurement, just read count of one channel
+        contents depend on previous selection with 'start_measure'
+        auto-zero feature may result in value 0!
+        """
+        data = 0  # default
+        if 0 <= channel <= 5:
+            data = self.__read_word(AS7341_CH_DATA + channel * 2)
+        return data  # return integer value
+
+    def get_spectral_data(self):
+        """obtain counts of all channels
+        return a tuple of 6 counts (integers) of the channels
+        contents depend on previous selection with 'start_measure'
+        """
+        return self.__read_all_channels()  # return a tuple!
+
+    def set_flicker_detection(self, flag=True):
+        """enable (flag == True) flicker detection or otherwise disable it"""
+        self.__modify_reg(AS7341_ENABLE, AS7341_ENABLE_FDEN, flag)
+
+    def get_flicker_frequency(self):
+        """Determine flicker frequency in Hz. Returns 100, 120 or 0
+        Integration time and gain for flicker detection is the same as for
+        other channels, the dedicated FD_TIME and FD_GAIN are not supported
+        """
+        self.__modify_reg(AS7341_CFG_0, AS7341_CFG_0_LOW_POWER, False)  # no low power
+        self.set_spectral_measurement(False)
+        self.__write_byte(AS7341_CFG_6, AS7341_CFG_6_SMUX_CMD_WRITE)
+        self.channel_select("FD")  # select flicker detection only
+        self.set_smux(True)
+        self.set_spectral_measurement(True)
+        self.set_flicker_detection(True)
+        for _ in range(10):  # limited wait for completion
+            fd_status = self.__read_byte(AS7341_FD_STATUS)
+            if fd_status & AS7341_FD_STATUS_FD_MEAS_VALID:
+                break
+            # print("Flicker measurement not completed")
+            sleep_ms(100)
+        else:  # timeout
+            print("Flicker measurement timed out")
+            return 0
+        for _ in range(10):  # limited wait for calculation
+            fd_status = self.__read_byte(AS7341_FD_STATUS)
+            if (fd_status & AS7341_FD_STATUS_FD_100_VALID) or (
+                fd_status & AS7341_FD_STATUS_FD_120_VALID
+            ):
+                break
+            # print("Flicker calculation not completed")
+            sleep_ms(100)
+        else:  # timeout
+            print("Flicker frequency calculation timed out")
+            return 0
+        # print("FD_STATUS", "0x{:02X}".format(fd_status))
+        self.set_flicker_detection(False)  # disable
+        self.__write_byte(AS7341_FD_STATUS, 0x3C)  # clear all FD STATUS bits
+        if (fd_status & AS7341_FD_STATUS_FD_100_VALID) and (
+            fd_status & AS7341_FD_STATUS_FD_100HZ
+        ):
+            return 100
+        elif (fd_status & AS7341_FD_STATUS_FD_120_VALID) and (
+            fd_status & AS7341_FD_STATUS_FD_120HZ
+        ):
+            return 120
+        return 0
+
+    def set_gpio_mode(self, mode):
+        """Configure mode of GPIO pin.
+        Allow only input-enable or output (with or without inverted)
+        specify 0x00 to reset the mode of the GPIO pin.
+        Notes: 1. It seems that GPIO_INV bit must be set
+                  together with GPIO_IN_EN.
+                  Proof: Use a pull-up resistor between GPIO and 3.3V:
+                   - when program is ot started GPIO is high
+                   - when program is started (GPIO_IN_EN=1) GPIO becomes low
+                   - when also GPIO_INV=1 GPIO behaves normally
+                  Maybe it is a quirk of the used test-board.
+               2. GPIO output is not tested
+                  (dataset lacks info how to set/reset GPIO)
+        """
+        if mode in (
+            0x00,
+            AS7341_GPIO_2_GPIO_OUT,
+            AS7341_GPIO_2_GPIO_OUT | AS7341_GPIO_2_GPIO_INV,
+            AS7341_GPIO_2_GPIO_IN_EN,
+            AS7341_GPIO_2_GPIO_IN_EN | AS7341_GPIO_2_GPIO_INV,
+        ):
+            if mode == AS7341_GPIO_2_GPIO_IN_EN:  # input mode
+                mode |= AS7341_GPIO_2_GPIO_INV  # add 'inverted'
+            self.__write_byte(AS7341_GPIO_2, mode)
+
+    def get_gpio_value(self):
+        """Determine GPIO value (when GPIO enabled for IN_EN)
+        returns 0 (low voltage) or 1 (high voltage)
+        """
+        # print("GPIO_2 = 0x{:02X}".format(self.__read_byte(AS7341_GPIO_2)))
+        return self.__read_byte(AS7341_GPIO_2) & AS7341_GPIO_2_GPIO_IN
+
+    def set_astep(self, value):
+        """set ASTEP size (range 0..65534 -> 2.78 usec .. 182 msec)"""
+        if 0 <= value <= 65534:
+            self.__write_word(AS7341_ASTEP, value)
+
+    def set_atime(self, value):
+        """set number of integration steps (range 0..255 -> 1..256 ASTEPs)"""
+        self.__write_byte(AS7341_ATIME, value)
+
+    def get_integration_time(self):
+        """return actual total integration time (atime * astep)
+        in milliseconds (valid with SPM and SYNS measurement mode)
+        """
+        return (
+            (self.__read_word(AS7341_ASTEP) + 1)
+            * (self.__read_byte(AS7341_ATIME) + 1)
+            * 2.78
+            / 1000
+        )
+
+    def set_again(self, code):
+        """set AGAIN (code in range 0..10 -> gain factor 0.5 .. 512)
+        value     0    1    2    3    4    5      6     7      8      9     10
+        gain:  *0.5 | *1 | *2 | *4 | *8 | *16 | *32 | *64 | *128 | *256 | *512
+        """
+        if 0 <= code <= 10:
+            self.__write_byte(AS7341_CFG_1, code)
+
+    def get_again(self):
+        """obtain actual gain code (in range 0 .. 10)"""
+        return self.__read_byte(AS7341_CFG_1)
+
+    def set_again_factor(self, factor):
+        """'inverse' of 'set_again': gain factor -> code 0 .. 10
+        <factor> is rounded down to nearest power of 2 (in range 0.5 .. 512)
+        """
+        code = 10
+        gain = 512
+        while gain > factor and code > 0:
+            gain /= 2
+            code -= 1
+        # print("factor", factor, "gain", gain, "code", code)
+        self.__write_byte(AS7341_CFG_1, code)
+
+    def get_again_factor(self):
+        """obtain actual gain factor (in range 0.5 .. 512)"""
+        return 2 ** (self.__read_byte(AS7341_CFG_1) - 1)
+
+    def set_wen(self, flag=True):
+        """enable (flag=True) or otherwise disable use of WTIME (auto re-start)"""
+        self.__modify_reg(AS7341_ENABLE, AS7341_ENABLE_WEN, flag)
+
+    def set_wtime(self, wtime):
+        """set WTIME when auto-re-start is desired (in range 0 .. 0xFF)
+        0 -> 2.78ms, 0xFF -> 711.7 ms
+        Note: The WEN bit in ENABLE should be set as well: set_wen()
+        """
+        self.__write_byte(AS7341_WTIME, wtime)
+
+    def set_led_current(self, current):
+        """Control current of onboard LED in milliamperes
+        LED-current is (here) limited to the range 4..20 mA
+        use only even numbers (4,6,8,... etc)
+        Specification outside this range results in LED OFF
+        """
+        self.__set_bank(1)  # CONFIG and LED registers in bank 1
+        if 4 <= current <= 20:  # within limits: 4..20 mA
+            self.__modify_reg(AS7341_CONFIG, AS7341_CONFIG_LED_SEL, True)
+            # print("Reg. CONFIG (0x70) now 0x{:02X}".format(self.__read_byte(0x70)))
+            data = AS7341_LED_LED_ACT + ((current - 4) // 2)  # LED on with PWM
+        else:
+            self.__modify_reg(AS7341_CONFIG, AS7341_CONFIG_LED_SEL, False)
+            data = 0  # LED off, PWM 0
+        self.__write_byte(AS7341_LED, data)
+        # print("reg 0x74 (LED) now 0x{:02X}".format(self.__read_byte(0x74)))
+        self.__set_bank(0)
+        sleep_ms(100)
+
+    def check_interrupt(self):
+        """Check for Spectral or Flicker Detect saturation interrupt"""
+        data = self.__read_byte(AS7341_STATUS)
+        if data & AS7341_STATUS_ASAT:
+            print("Spectral interrupt generation！")
+            return True
+        return False
+
+    def clear_interrupt(self):
+        """clear all interrupt signals"""
+        self.__write_byte(AS7341_STATUS, 0xFF)
+
+    def set_spectral_interrupt(self, flag=True):
+        """enable (flag == True) or otherwise disable spectral interrupts"""
+        self.__modify_reg(AS7341_INTENAB, AS7341_INTENAB_SP_IEN, flag)
+
+    def set_interrupt_persistence(self, value):
+        """configure interrupt persistance"""
+        if 0 <= value <= 15:
+            self.__write_byte(AS7341_PERS, value)
+
+    def set_spectral_threshold_channel(self, value):
+        """select channel (0..4) for interrupts, persistence and AGC"""
+        if 0 <= value <= 4:
+            self.__write_byte(AS7341_CFG_12, value)
+
+    def set_thresholds(self, lo, hi):
+        """Set thresholds (when lo < hi)"""
+        if lo < hi:
+            self.__write_word(AS7341_SP_TH_LOW, lo)
+            self.__write_word(AS7341_SP_TH_HIGH, hi)
+            sleep_ms(20)
+
+    def get_thresholds(self):
+        """obtain and return tuple with low and high threshold values"""
+        lo = self.__read_word(AS7341_SP_TH_LOW)
+        hi = self.__read_word(AS7341_SP_TH_HIGH)
+        return (lo, hi)
+
+    def set_syns_int(self):
+        """select SYNS mode and signal SYNS interrupt on Pin INT"""
+        self.__set_bank(1)  # CONFIG register is in bank 1
+        self.__write_byte(
+            AS7341_CONFIG, AS7341_CONFIG_INT_SEL | AS7341_CONFIG_INT_MODE_SYNS
+        )
+        self.__set_bank(0)
+
+
+#

scripts/lib/as7341_sensor.py

@@ -0,0 +1,149 @@
+"""Sterling Baird: wrapper class for AS7341 sensor."""
+
+from math import log
+
+from as7341 import AS7341, AS7341_MODE_SPM
+from machine import I2C, Pin
+
+
+class ExternalDeviceNotFound(OSError):
+    pass
+
+
+class Sensor:
+    def __init__(
+        self, atime=100, astep=999, gain=8, i2c=I2C(1, scl=Pin(27), sda=Pin(26))
+    ):
+        """Wrapper for Rob Hamerling's AS7341 implementation.
+
+        Mimics the original CircuitPython class a bit more, specific to the needs of
+        SDL-Demo.
+
+        Rob Hamerling's implementation:
+        - https://gitlab.com/robhamerling/micropython-as7341
+
+        Original Circuit Python repo:
+        - https://github.com/adafruit/Adafruit_CircuitPython_AS7341
+
+        Parameters
+        ----------
+        atime : int, optional
+            The integration time step size in 2.78 microsecond increments, by default 100
+        astep : int, optional
+            The integration time step count. Total integration time will be (ATIME + 1)
+            * (ASTEP + 1) * 2.78µS, by default 999, meaning 281 ms assuming atime=100
+        gain : int, optional
+            The ADC gain multiplier, by default 128
+        i2c : I2C, optional
+            The I2C bus, by default machine.I2C(1, scl=machine.Pin(27),
+            sda=machine.Pin(26))
+
+        Raises
+        ------
+        ExternalDeviceNotFound
+            Couldn't connect to AS7341.
+
+        Examples
+        --------
+        >>> sensor = Sensor(atime=29, astep=599, again=4)
+        >>> channel_data = sensor.all_channels
+        """
+
+        # i2c = machine.SoftI2C(scl=Pin(27), sda=Pin(26))
+        self.i2c = i2c
+        addrlist = " ".join(["0x{:02X}".format(x) for x in i2c.scan()])  # type: ignore
+        print("Detected devices at I2C-addresses:", addrlist)
+
+        sensor = AS7341(i2c)
+
+        if not sensor.isconnected():
+            raise ExternalDeviceNotFound("Failed to contact AS7341, terminating")
+
+        sensor.set_measure_mode(AS7341_MODE_SPM)
+
+        sensor.set_atime(atime)
+        sensor.set_astep(astep)
+        sensor.set_again(gain)
+
+        self.sensor = sensor
+
+        self.__atime = atime
+        self.__astep = astep
+        self.__gain = gain
+
+    @property
+    def _atime(self):
+        return self.__atime
+
+    @_atime.setter
+    def _atime(self, value):
+        self.__atime = value
+        self.sensor.set_atime(value)
+
+    @property
+    def _astep(self):
+        return self.__astep
+
+    @_astep.setter
+    def _astep(self, value):
+        self.__atime = value
+        self.sensor.set_astep(value)
+
+    @property
+    def _gain(self):
+        return self.__gain
+
+    @_gain.setter
+    def _gain(self, gain):
+        """set AGAIN (code in range 0..10 -> gain factor 0.5 .. 512)
+        gain:  *0.5 | *1 | *2 | *4 | *8 | *16 | *32 | *64 | *128 | *256 | *512
+        code      0    1    2    3    4    5      6     7      8      9     10
+        """
+        self.__gain = gain
+        # gain == 0.5 * 2 ** code --> code == 1.4427 Ln[2 * gain] (via Mathematica)
+        code = int(round(1.4427 * log(2 * gain)))
+        self.sensor.set_again(code)
+
+    @property
+    def all_channels(self):
+        self.sensor.start_measure("F1F4CN")
+        f1, f2, f3, f4, clr, nir = self.sensor.get_spectral_data()
+
+        self.sensor.start_measure("F5F8CN")
+        f5, f6, f7, f8, clr, nir = self.sensor.get_spectral_data()
+
+        clr, nir  # to ignore "unused" linting warnings
+
+        return [f1, f2, f3, f4, f5, f6, f7, f8]
+
+    @property
+    def all_channels_clr_nir(self):
+        self.sensor.start_measure("F1F4CN")
+        f1, f2, f3, f4, clr, nir = self.sensor.get_spectral_data()
+
+        self.sensor.start_measure("F5F8CN")
+        f5, f6, f7, f8, clr, nir = self.sensor.get_spectral_data()
+
+        clr, nir  # to ignore "unused" linting warnings
+
+        return [f1, f2, f3, f4, f5, f6, f7, f8, clr, nir]
+
+    def disable(self):
+        self.sensor.disable()
+
+
+# %% Code Graveyard
+# gain_to_code_lookup = {
+#     0.5: 1,
+#     1: 1,
+#     2: 2,
+#     4: 3,
+#     8: 4,
+#     16: 5,
+#     32: 6,
+#     64: 7,
+#     128: 8,
+#     256: 9,
+#     512: 10,
+# }
+# code = gain_to_code_lookup[gain]

scripts/lib/as7341_smux_select.py

@@ -0,0 +1,49 @@
+"""
+This file licensed under the MIT License and incorporates work covered by
+the following copyright and permission notice:
+
+The MIT License (MIT)
+
+Copyright (c) 2022-2022 Rob Hamerling
+
+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.
+
+"""
+
+""" Dictionary with specific SMUX configurations for AS7341
+    See AMS Application Note AS7341_AN000666_1.01.pdf
+    for detailed instructions how to configure the channel mapping.
+    The Application Note can be found in one of the evaluation packages, e.g.
+    AS7341_EvalSW_Reflection_v1-26-3/Documents/application notes/SMUX/
+
+    This file should be imported by AS7341.py with:
+        from as7341_smux_select import *
+"""
+AS7341_SMUX_SELECT = {
+    # F1 through F4, CLEAR, NIR:
+    "F1F4CN": b"\x30\x01\x00\x00\x00\x42\x00\x00\x50\x00\x00\x00\x20\x04\x00\x30\x01\x50\x00\x06",
+    # F5 through F8, CLEAR, NIR:
+    "F5F8CN": b"\x00\x00\x00\x40\x02\x00\x10\x03\x50\x10\x03\x00\x00\x00\x24\x00\x00\x50\x00\x06",
+    # F2 through F7:
+    "F2F7": b"\x20\x00\x00\x00\x05\x31\x40\x06\x00\x40\x06\x00\x10\x03\x50\x20\x00\x00\x00\x00",
+    # Flicker Detection only:
+    "FD": b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60",
+}
+
+#

scripts/lib/bme680-2.0.0.dist-info/METADATA

@@ -0,0 +1,156 @@
+Metadata-Version: 2.3
+Name: bme680
+Version: 2.0.0
+Summary: Python library for the BME680 temperature, humidity and gas sensor
+Project-URL: GitHub, https://www.github.com/pimoroni/bme680-python
+Project-URL: Homepage, https://www.pimoroni.com
+Author-email: Philip Howard <phil@pimoroni.com>
+Maintainer-email: Philip Howard <phil@pimoroni.com>
+License: MIT License
+        
+        Copyright (c) 2018 Pimoroni Ltd
+        
+        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.
+License-File: LICENSE
+Keywords: Pi,Raspberry
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Hardware
+Requires-Python: >=3.7
+Requires-Dist: smbus2
+Description-Content-Type: text/markdown
+
+# BME680
+
+[![Build Status](https://img.shields.io/github/actions/workflow/status/pimoroni/bme680-python/test.yml?branch=main)](https://github.com/pimoroni/bme680-python/actions/workflows/test.yml)
+[![Coverage Status](https://coveralls.io/repos/github/pimoroni/bme680-python/badge.svg?branch=main)](https://coveralls.io/github/pimoroni/bme680-python?branch=main)
+[![PyPi Package](https://img.shields.io/pypi/v/bme680.svg)](https://pypi.python.org/pypi/bme680)
+[![Python Versions](https://img.shields.io/pypi/pyversions/bme680.svg)](https://pypi.python.org/pypi/bme680)
+
+https://shop.pimoroni.com/products/bme680
+
+The state-of-the-art BME680 breakout lets you measure temperature, pressure, humidity, and indoor air quality.
+
+## Installing
+
+### Full install (recommended):
+
+We've created an easy installation script that will install all pre-requisites and get your BME680
+up and running with minimal efforts. To run it, fire up Terminal which you'll find in Menu -> Accessories -> Terminal
+on your Raspberry Pi desktop, as illustrated below:
+
+![Finding the terminal](http://get.pimoroni.com/resources/github-repo-terminal.png)
+
+In the new terminal window type the command exactly as it appears below (check for typos) and follow the on-screen instructions:
+
+```bash
+git clone https://github.com/pimoroni/bme680-python
+cd bme680-python
+./install.sh
+```
+
+**Note** Libraries will be installed in the "pimoroni" virtual environment, you will need to activate it to run examples:
+
+```
+source ~/.virtualenvs/pimoroni/bin/activate
+```
+
+### Development:
+
+If you want to contribute, or like living on the edge of your seat by having the latest code, you can install the development version like so:
+
+```bash
+git clone https://github.com/pimoroni/bme680-python
+cd bme680-python
+./install.sh --unstable
+```
+
+In all cases you will have to enable the i2c bus:
+
+```
+sudo raspi-config nonint do_i2c 0
+```
+
+## Documentation & Support
+
+* Guides and tutorials - https://learn.pimoroni.com/bme680-breakout
+* Get help - http://forums.pimoroni.com/c/support
+
+
+2.0.0
+-----
+
+* Repackage to hatch/pyproject.toml
+* Drop Python 2.7 support
+* Switch from smbu2 to smbus2
+
+1.1.1
+-----
+
+* New: constants to clarify heater on/off states
+
+1.1.0
+-----
+
+* New: support for BME688 "high" gas resistance variant
+* New: set/get gas heater disable bit
+* Enhancement: fail with descriptive RuntimeError when chip is not detected
+
+1.0.5
+-----
+
+* New: set_temp_offset to calibrate temperature offset in degrees C
+
+1.0.4
+-----
+
+* Fix to range_sw_err for extremely high gas readings
+* Convert to unsigned int to fix negative gas readings
+
+1.0.3
+-----
+
+* Merged temperature compensation fix from Bosch's BME680_driver 3.5.3
+
+1.0.2
+-----
+
+* Fixed set_gas_heater_temperature to avoid i2c TypeError
+
+1.0.1
+-----
+
+* Added Manifest to Python package
+
+1.0.0
+-----
+
+* Initial release
+

scripts/lib/bme680-2.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+CHANGELOG.md,,
+LICENSE,,
+README.md,,
+bme680-2.0.0.dist-info/METADATA,,
+bme680/__init__.py,,
+bme680/constants.py,,
+bme680-2.0.0.dist-info/RECORD,,

scripts/lib/bme680/__init__.py

@@ -0,0 +1,486 @@
+"""BME680 Temperature, Pressure, Humidity & Gas Sensor."""
+import math
+import time
+
+from . import constants
+from .constants import BME680Data, lookupTable1, lookupTable2
+
+__version__ = '2.0.0'
+
+
+# Export constants to global namespace
+# so end-users can "from BME680 import NAME"
+if hasattr(constants, '__dict__'):
+    for key in constants.__dict__:
+        value = constants.__dict__[key]
+        if key not in globals():
+            globals()[key] = value
+
+
+class BME680(BME680Data):
+    """BOSCH BME680.
+
+    Gas, pressure, temperature and humidity sensor.
+
+    :param i2c_addr: One of I2C_ADDR_PRIMARY (0x76) or I2C_ADDR_SECONDARY (0x77)
+    :param i2c_device: Optional smbus or compatible instance for facilitating i2c communications.
+
+    """
+
+    def __init__(self, i2c_addr=constants.I2C_ADDR_PRIMARY, i2c_device=None):
+        """Initialise BME680 sensor instance and verify device presence.
+
+        :param i2c_addr: i2c address of BME680
+        :param i2c_device: Optional SMBus-compatible instance for i2c transport
+
+        """
+        BME680Data.__init__(self)
+
+        self.i2c_addr = i2c_addr
+        self._i2c = i2c_device
+        if self._i2c is None:
+            import smbus2
+            self._i2c = smbus2.SMBus(1)
+
+        try:
+            self.chip_id = self._get_regs(constants.CHIP_ID_ADDR, 1)
+            if self.chip_id != constants.CHIP_ID:
+                raise RuntimeError('BME680 Not Found. Invalid CHIP ID: 0x{0:02x}'.format(self.chip_id))
+        except IOError:
+            raise RuntimeError("Unable to identify BME680 at 0x{:02x} (IOError)".format(self.i2c_addr))
+
+        self._variant = self._get_regs(constants.CHIP_VARIANT_ADDR, 1)
+
+        self.soft_reset()
+        self.set_power_mode(constants.SLEEP_MODE)
+
+        self._get_calibration_data()
+
+        self.set_humidity_oversample(constants.OS_2X)
+        self.set_pressure_oversample(constants.OS_4X)
+        self.set_temperature_oversample(constants.OS_8X)
+        self.set_filter(constants.FILTER_SIZE_3)
+        if self._variant == constants.VARIANT_HIGH:
+            self.set_gas_status(constants.ENABLE_GAS_MEAS_HIGH)
+        else:
+            self.set_gas_status(constants.ENABLE_GAS_MEAS_LOW)
+        self.set_temp_offset(0)
+        self.get_sensor_data()
+
+    def _get_calibration_data(self):
+        """Retrieve the sensor calibration data and store it in .calibration_data."""
+        calibration = self._get_regs(constants.COEFF_ADDR1, constants.COEFF_ADDR1_LEN)
+        calibration += self._get_regs(constants.COEFF_ADDR2, constants.COEFF_ADDR2_LEN)
+
+        heat_range = self._get_regs(constants.ADDR_RES_HEAT_RANGE_ADDR, 1)
+        heat_value = constants.twos_comp(self._get_regs(constants.ADDR_RES_HEAT_VAL_ADDR, 1), bits=8)
+        sw_error = constants.twos_comp(self._get_regs(constants.ADDR_RANGE_SW_ERR_ADDR, 1), bits=8)
+
+        self.calibration_data.set_from_array(calibration)
+        self.calibration_data.set_other(heat_range, heat_value, sw_error)
+
+    def soft_reset(self):
+        """Trigger a soft reset."""
+        self._set_regs(constants.SOFT_RESET_ADDR, constants.SOFT_RESET_CMD)
+        time.sleep(constants.RESET_PERIOD / 1000.0)
+
+    def set_temp_offset(self, value):
+        """Set temperature offset in celsius.
+
+        If set, the temperature t_fine will be increased by given value in celsius.
+        :param value: Temperature offset in Celsius, eg. 4, -8, 1.25
+
+        """
+        if value == 0:
+            self.offset_temp_in_t_fine = 0
+        else:
+            self.offset_temp_in_t_fine = int(math.copysign((((int(abs(value) * 100)) << 8) - 128) / 5, value))
+
+    def set_humidity_oversample(self, value):
+        """Set humidity oversampling.
+
+        A higher oversampling value means more stable sensor readings,
+        with less noise and jitter.
+
+        However each step of oversampling adds about 2ms to the latency,
+        causing a slower response time to fast transients.
+
+        :param value: Oversampling value, one of: OS_NONE, OS_1X, OS_2X, OS_4X, OS_8X, OS_16X
+
+        """
+        self.tph_settings.os_hum = value
+        self._set_bits(constants.CONF_OS_H_ADDR, constants.OSH_MSK, constants.OSH_POS, value)
+
+    def get_humidity_oversample(self):
+        """Get humidity oversampling."""
+        return (self._get_regs(constants.CONF_OS_H_ADDR, 1) & constants.OSH_MSK) >> constants.OSH_POS
+
+    def set_pressure_oversample(self, value):
+        """Set temperature oversampling.
+
+        A higher oversampling value means more stable sensor readings,
+        with less noise and jitter.
+
+        However each step of oversampling adds about 2ms to the latency,
+        causing a slower response time to fast transients.
+
+        :param value: Oversampling value, one of: OS_NONE, OS_1X, OS_2X, OS_4X, OS_8X, OS_16X
+
+        """
+        self.tph_settings.os_pres = value
+        self._set_bits(constants.CONF_T_P_MODE_ADDR, constants.OSP_MSK, constants.OSP_POS, value)
+
+    def get_pressure_oversample(self):
+        """Get pressure oversampling."""
+        return (self._get_regs(constants.CONF_T_P_MODE_ADDR, 1) & constants.OSP_MSK) >> constants.OSP_POS
+
+    def set_temperature_oversample(self, value):
+        """Set pressure oversampling.
+
+        A higher oversampling value means more stable sensor readings,
+        with less noise and jitter.
+
+        However each step of oversampling adds about 2ms to the latency,
+        causing a slower response time to fast transients.
+
+        :param value: Oversampling value, one of: OS_NONE, OS_1X, OS_2X, OS_4X, OS_8X, OS_16X
+
+        """
+        self.tph_settings.os_temp = value
+        self._set_bits(constants.CONF_T_P_MODE_ADDR, constants.OST_MSK, constants.OST_POS, value)
+
+    def get_temperature_oversample(self):
+        """Get temperature oversampling."""
+        return (self._get_regs(constants.CONF_T_P_MODE_ADDR, 1) & constants.OST_MSK) >> constants.OST_POS
+
+    def set_filter(self, value):
+        """Set IIR filter size.
+
+        Optionally remove short term fluctuations from the temperature and pressure readings,
+        increasing their resolution but reducing their bandwidth.
+
+        Enabling the IIR filter does not slow down the time a reading takes, but will slow
+        down the BME680s response to changes in temperature and pressure.
+
+        When the IIR filter is enabled, the temperature and pressure resolution is effectively 20bit.
+        When it is disabled, it is 16bit + oversampling-1 bits.
+
+        """
+        self.tph_settings.filter = value
+        self._set_bits(constants.CONF_ODR_FILT_ADDR, constants.FILTER_MSK, constants.FILTER_POS, value)
+
+    def get_filter(self):
+        """Get filter size."""
+        return (self._get_regs(constants.CONF_ODR_FILT_ADDR, 1) & constants.FILTER_MSK) >> constants.FILTER_POS
+
+    def select_gas_heater_profile(self, value):
+        """Set current gas sensor conversion profile.
+
+        Select one of the 10 configured heating durations/set points.
+
+        :param value: Profile index from 0 to 9
+
+        """
+        if value > constants.NBCONV_MAX or value < constants.NBCONV_MIN:
+            raise ValueError("Profile '{}' should be between {} and {}".format(value, constants.NBCONV_MIN, constants.NBCONV_MAX))
+
+        self.gas_settings.nb_conv = value
+        self._set_bits(constants.CONF_ODR_RUN_GAS_NBC_ADDR, constants.NBCONV_MSK, constants.NBCONV_POS, value)
+
+    def get_gas_heater_profile(self):
+        """Get gas sensor conversion profile: 0 to 9."""
+        return self._get_regs(constants.CONF_ODR_RUN_GAS_NBC_ADDR, 1) & constants.NBCONV_MSK
+
+    def set_gas_heater_status(self, value):
+        """Enable/disable gas heater."""
+        self.gas_settings.heater = value
+        self._set_bits(constants.CONF_HEAT_CTRL_ADDR, constants.HCTRL_MSK, constants.HCTRL_POS, value)
+
+    def get_gas_heater_status(self):
+        """Get current heater status."""
+        return (self._get_regs(constants.CONF_HEAT_CTRL_ADDR, 1) & constants.HCTRL_MSK) >> constants.HCTRL_POS
+
+    def set_gas_status(self, value):
+        """Enable/disable gas sensor."""
+        if value == -1:
+            if self._variant == constants.VARIANT_HIGH:
+                value = constants.ENABLE_GAS_MEAS_HIGH
+            else:
+                value = constants.ENABLE_GAS_MEAS_LOW
+        self.gas_settings.run_gas = value
+        self._set_bits(constants.CONF_ODR_RUN_GAS_NBC_ADDR, constants.RUN_GAS_MSK, constants.RUN_GAS_POS, value)
+
+    def get_gas_status(self):
+        """Get the current gas status."""
+        return (self._get_regs(constants.CONF_ODR_RUN_GAS_NBC_ADDR, 1) & constants.RUN_GAS_MSK) >> constants.RUN_GAS_POS
+
+    def set_gas_heater_profile(self, temperature, duration, nb_profile=0):
+        """Set temperature and duration of gas sensor heater.
+
+        :param temperature: Target temperature in degrees celsius, between 200 and 400
+        :param durarion: Target duration in milliseconds, between 1 and 4032
+        :param nb_profile: Target profile, between 0 and 9
+
+        """
+        self.set_gas_heater_temperature(temperature, nb_profile=nb_profile)
+        self.set_gas_heater_duration(duration, nb_profile=nb_profile)
+
+    def set_gas_heater_temperature(self, value, nb_profile=0):
+        """Set gas sensor heater temperature.
+
+        :param value: Target temperature in degrees celsius, between 200 and 400
+
+        When setting an nb_profile other than 0,
+        make sure to select it with select_gas_heater_profile.
+
+        """
+        if nb_profile > constants.NBCONV_MAX or value < constants.NBCONV_MIN:
+            raise ValueError('Profile "{}" should be between {} and {}'.format(nb_profile, constants.NBCONV_MIN, constants.NBCONV_MAX))
+
+        self.gas_settings.heatr_temp = value
+        temp = int(self._calc_heater_resistance(self.gas_settings.heatr_temp))
+        self._set_regs(constants.RES_HEAT0_ADDR + nb_profile, temp)
+
+    def set_gas_heater_duration(self, value, nb_profile=0):
+        """Set gas sensor heater duration.
+
+        Heating durations between 1 ms and 4032 ms can be configured.
+        Approximately 20-30 ms are necessary for the heater to reach the intended target temperature.
+
+        :param value: Heating duration in milliseconds.
+
+        When setting an nb_profile other than 0,
+        make sure to select it with select_gas_heater_profile.
+
+        """
+        if nb_profile > constants.NBCONV_MAX or value < constants.NBCONV_MIN:
+            raise ValueError('Profile "{}" should be between {} and {}'.format(nb_profile, constants.NBCONV_MIN, constants.NBCONV_MAX))
+
+        self.gas_settings.heatr_dur = value
+        temp = self._calc_heater_duration(self.gas_settings.heatr_dur)
+        self._set_regs(constants.GAS_WAIT0_ADDR + nb_profile, temp)
+
+    def set_power_mode(self, value, blocking=True):
+        """Set power mode."""
+        if value not in (constants.SLEEP_MODE, constants.FORCED_MODE):
+            raise ValueError('Power mode should be one of SLEEP_MODE or FORCED_MODE')
+
+        self.power_mode = value
+
+        self._set_bits(constants.CONF_T_P_MODE_ADDR, constants.MODE_MSK, constants.MODE_POS, value)
+
+        while blocking and self.get_power_mode() != self.power_mode:
+            time.sleep(constants.POLL_PERIOD_MS / 1000.0)
+
+    def get_power_mode(self):
+        """Get power mode."""
+        self.power_mode = self._get_regs(constants.CONF_T_P_MODE_ADDR, 1)
+        return self.power_mode
+
+    def get_sensor_data(self):
+        """Get sensor data.
+
+        Stores data in .data and returns True upon success.
+
+        """
+        self.set_power_mode(constants.FORCED_MODE)
+
+        for attempt in range(10):
+            status = self._get_regs(constants.FIELD0_ADDR, 1)
+
+            if (status & constants.NEW_DATA_MSK) == 0:
+                time.sleep(constants.POLL_PERIOD_MS / 1000.0)
+                continue
+
+            regs = self._get_regs(constants.FIELD0_ADDR, constants.FIELD_LENGTH)
+
+            self.data.status = regs[0] & constants.NEW_DATA_MSK
+            # Contains the nb_profile used to obtain the current measurement
+            self.data.gas_index = regs[0] & constants.GAS_INDEX_MSK
+            self.data.meas_index = regs[1]
+
+            adc_pres = (regs[2] << 12) | (regs[3] << 4) | (regs[4] >> 4)
+            adc_temp = (regs[5] << 12) | (regs[6] << 4) | (regs[7] >> 4)
+            adc_hum = (regs[8] << 8) | regs[9]
+            adc_gas_res_low = (regs[13] << 2) | (regs[14] >> 6)
+            adc_gas_res_high = (regs[15] << 2) | (regs[16] >> 6)
+            gas_range_l = regs[14] & constants.GAS_RANGE_MSK
+            gas_range_h = regs[16] & constants.GAS_RANGE_MSK
+
+            if self._variant == constants.VARIANT_HIGH:
+                self.data.status |= regs[16] & constants.GASM_VALID_MSK
+                self.data.status |= regs[16] & constants.HEAT_STAB_MSK
+            else:
+                self.data.status |= regs[14] & constants.GASM_VALID_MSK
+                self.data.status |= regs[14] & constants.HEAT_STAB_MSK
+
+            self.data.heat_stable = (self.data.status & constants.HEAT_STAB_MSK) > 0
+
+            temperature = self._calc_temperature(adc_temp)
+            self.data.temperature = temperature / 100.0
+            self.ambient_temperature = temperature  # Saved for heater calc
+
+            self.data.pressure = self._calc_pressure(adc_pres) / 100.0
+            self.data.humidity = self._calc_humidity(adc_hum) / 1000.0
+
+            if self._variant == constants.VARIANT_HIGH:
+                self.data.gas_resistance = self._calc_gas_resistance_high(adc_gas_res_high, gas_range_h)
+            else:
+                self.data.gas_resistance = self._calc_gas_resistance_low(adc_gas_res_low, gas_range_l)
+
+            return True
+
+        return False
+
+    def _set_bits(self, register, mask, position, value):
+        """Mask out and set one or more bits in a register."""
+        temp = self._get_regs(register, 1)
+        temp &= ~mask
+        temp |= value << position
+        self._set_regs(register, temp)
+
+    def _set_regs(self, register, value):
+        """Set one or more registers."""
+        if isinstance(value, int):
+            self._i2c.write_byte_data(self.i2c_addr, register, value)
+        else:
+            self._i2c.write_i2c_block_data(self.i2c_addr, register, value)
+
+    def _get_regs(self, register, length):
+        """Get one or more registers."""
+        if length == 1:
+            return self._i2c.read_byte_data(self.i2c_addr, register)
+        else:
+            return self._i2c.read_i2c_block_data(self.i2c_addr, register, length)
+
+    def _calc_temperature(self, temperature_adc):
+        """Convert the raw temperature to degrees C using calibration_data."""
+        var1 = (temperature_adc >> 3) - (self.calibration_data.par_t1 << 1)
+        var2 = (var1 * self.calibration_data.par_t2) >> 11
+        var3 = ((var1 >> 1) * (var1 >> 1)) >> 12
+        var3 = ((var3) * (self.calibration_data.par_t3 << 4)) >> 14
+
+        # Save teperature data for pressure calculations
+        self.calibration_data.t_fine = (var2 + var3) + self.offset_temp_in_t_fine
+        calc_temp = (((self.calibration_data.t_fine * 5) + 128) >> 8)
+
+        return calc_temp
+
+    def _calc_pressure(self, pressure_adc):
+        """Convert the raw pressure using calibration data."""
+        var1 = ((self.calibration_data.t_fine) >> 1) - 64000
+        var2 = ((((var1 >> 2) * (var1 >> 2)) >> 11) *
+                self.calibration_data.par_p6) >> 2
+        var2 = var2 + ((var1 * self.calibration_data.par_p5) << 1)
+        var2 = (var2 >> 2) + (self.calibration_data.par_p4 << 16)
+        var1 = (((((var1 >> 2) * (var1 >> 2)) >> 13) *
+                ((self.calibration_data.par_p3 << 5)) >> 3) +
+                ((self.calibration_data.par_p2 * var1) >> 1))
+        var1 = var1 >> 18
+
+        var1 = ((32768 + var1) * self.calibration_data.par_p1) >> 15
+        calc_pressure = 1048576 - pressure_adc
+        calc_pressure = ((calc_pressure - (var2 >> 12)) * (3125))
+
+        if calc_pressure >= (1 << 31):
+            calc_pressure = ((calc_pressure // var1) << 1)
+        else:
+            calc_pressure = ((calc_pressure << 1) // var1)
+
+        var1 = (self.calibration_data.par_p9 * (((calc_pressure >> 3) *
+                (calc_pressure >> 3)) >> 13)) >> 12
+        var2 = ((calc_pressure >> 2) *
+                self.calibration_data.par_p8) >> 13
+        var3 = ((calc_pressure >> 8) * (calc_pressure >> 8) *
+                (calc_pressure >> 8) *
+                self.calibration_data.par_p10) >> 17
+
+        calc_pressure = (calc_pressure) + ((var1 + var2 + var3 +
+                                           (self.calibration_data.par_p7 << 7)) >> 4)
+
+        return calc_pressure
+
+    def _calc_humidity(self, humidity_adc):
+        """Convert the raw humidity using calibration data."""
+        temp_scaled = ((self.calibration_data.t_fine * 5) + 128) >> 8
+        var1 = (humidity_adc - ((self.calibration_data.par_h1 * 16))) -\
+               (((temp_scaled * self.calibration_data.par_h3) // (100)) >> 1)
+        var2 = (self.calibration_data.par_h2 *
+                (((temp_scaled * self.calibration_data.par_h4) // (100)) +
+                 (((temp_scaled * ((temp_scaled * self.calibration_data.par_h5) // (100))) >> 6) //
+                 (100)) + (1 * 16384))) >> 10
+        var3 = var1 * var2
+        var4 = self.calibration_data.par_h6 << 7
+        var4 = ((var4) + ((temp_scaled * self.calibration_data.par_h7) // (100))) >> 4
+        var5 = ((var3 >> 14) * (var3 >> 14)) >> 10
+        var6 = (var4 * var5) >> 1
+        calc_hum = (((var3 + var6) >> 10) * (1000)) >> 12
+
+        return min(max(calc_hum, 0), 100000)
+
+    def _calc_gas_resistance(self, gas_res_adc, gas_range):
+        """Convert the raw gas resistance using calibration data."""
+        if self._variant == constants.VARIANT_HIGH:
+            return self._calc_gas_resistance_high(gas_res_adc, gas_range)
+        else:
+            return self._calc_gas_resistance_low(gas_res_adc, gas_range)
+
+    def _calc_gas_resistance_high(self, gas_res_adc, gas_range):
+        """Convert the raw gas resistance using calibration data.
+
+        Applies to Variant ID == 0x01 only.
+
+        """
+        var1 = 262144 >> gas_range
+        var2 = gas_res_adc - 512
+
+        var2 *= 3
+        var2 = 4096 + var2
+
+        calc_gas_res = (10000 * var1) / var2
+        calc_gas_res *= 100
+
+        return calc_gas_res
+
+    def _calc_gas_resistance_low(self, gas_res_adc, gas_range):
+        """Convert the raw gas resistance using calibration data.
+
+        Applies to Variant ID == 0x00 only.
+
+        """
+        var1 = ((1340 + (5 * self.calibration_data.range_sw_err)) * (lookupTable1[gas_range])) >> 16
+        var2 = (((gas_res_adc << 15) - (16777216)) + var1)
+        var3 = ((lookupTable2[gas_range] * var1) >> 9)
+        calc_gas_res = ((var3 + (var2 >> 1)) / var2)
+
+        if calc_gas_res < 0:
+            calc_gas_res = (1 << 32) + calc_gas_res
+
+        return calc_gas_res
+
+    def _calc_heater_resistance(self, temperature):
+        """Convert raw heater resistance using calibration data."""
+        temperature = min(max(temperature, 200), 400)
+
+        var1 = ((self.ambient_temperature * self.calibration_data.par_gh3) / 1000) * 256
+        var2 = (self.calibration_data.par_gh1 + 784) * (((((self.calibration_data.par_gh2 + 154009) * temperature * 5) / 100) + 3276800) / 10)
+        var3 = var1 + (var2 / 2)
+        var4 = (var3 / (self.calibration_data.res_heat_range + 4))
+        var5 = (131 * self.calibration_data.res_heat_val) + 65536
+        heatr_res_x100 = (((var4 / var5) - 250) * 34)
+        heatr_res = ((heatr_res_x100 + 50) / 100)
+
+        return heatr_res
+
+    def _calc_heater_duration(self, duration):
+        """Calculate correct value for heater duration setting from milliseconds."""
+        if duration < 0xfc0:
+            factor = 0
+
+            while duration > 0x3f:
+                duration /= 4
+                factor += 1
+
+            return int(duration + (factor * 64))
+
+        return 0xff

scripts/lib/bme680/constants.py

@@ -0,0 +1,413 @@
+"""BME680 constants, structures and utilities."""
+
+# BME680 General config
+POLL_PERIOD_MS = 10
+
+# BME680 I2C addresses
+I2C_ADDR_PRIMARY = 0x76
+I2C_ADDR_SECONDARY = 0x77
+
+# BME680 unique chip identifier
+CHIP_ID = 0x61
+
+# BME680 coefficients related defines
+COEFF_SIZE = 41
+COEFF_ADDR1_LEN = 25
+COEFF_ADDR2_LEN = 16
+
+# BME680 field_x related defines
+FIELD_LENGTH = 17
+FIELD_ADDR_OFFSET = 17
+
+# Soft reset command
+SOFT_RESET_CMD = 0xb6
+
+# Error code definitions
+OK = 0
+# Errors
+E_NULL_PTR = -1
+E_COM_FAIL = -2
+E_DEV_NOT_FOUND = -3
+E_INVALID_LENGTH = -4
+
+# Warnings
+W_DEFINE_PWR_MODE = 1
+W_NO_NEW_DATA = 2
+
+# Info's
+I_MIN_CORRECTION = 1
+I_MAX_CORRECTION = 2
+
+# Register map
+# Other coefficient's address
+ADDR_RES_HEAT_VAL_ADDR = 0x00
+ADDR_RES_HEAT_RANGE_ADDR = 0x02
+ADDR_RANGE_SW_ERR_ADDR = 0x04
+ADDR_SENS_CONF_START = 0x5A
+ADDR_GAS_CONF_START = 0x64
+
+# Field settings
+FIELD0_ADDR = 0x1d
+
+# Heater settings
+RES_HEAT0_ADDR = 0x5a
+GAS_WAIT0_ADDR = 0x64
+
+# Sensor configuration registers
+CONF_HEAT_CTRL_ADDR = 0x70
+CONF_ODR_RUN_GAS_NBC_ADDR = 0x71
+CONF_OS_H_ADDR = 0x72
+MEM_PAGE_ADDR = 0xf3
+CONF_T_P_MODE_ADDR = 0x74
+CONF_ODR_FILT_ADDR = 0x75
+
+# Coefficient's address
+COEFF_ADDR1 = 0x89
+COEFF_ADDR2 = 0xe1
+
+# Chip identifier
+CHIP_ID_ADDR = 0xd0
+CHIP_VARIANT_ADDR = 0xf0
+
+VARIANT_LOW = 0x00
+VARIANT_HIGH = 0x01
+
+# Soft reset register
+SOFT_RESET_ADDR = 0xe0
+
+# Heater control settings
+ENABLE_HEATER = 0x00
+DISABLE_HEATER = 0x08
+
+# Gas measurement settings
+DISABLE_GAS_MEAS = 0x00
+ENABLE_GAS_MEAS = -1  # Now used as auto-select
+ENABLE_GAS_MEAS_LOW = 0x01
+ENABLE_GAS_MEAS_HIGH = 0x02
+
+# Over-sampling settings
+OS_NONE = 0
+OS_1X = 1
+OS_2X = 2
+OS_4X = 3
+OS_8X = 4
+OS_16X = 5
+
+# IIR filter settings
+FILTER_SIZE_0 = 0
+FILTER_SIZE_1 = 1
+FILTER_SIZE_3 = 2
+FILTER_SIZE_7 = 3
+FILTER_SIZE_15 = 4
+FILTER_SIZE_31 = 5
+FILTER_SIZE_63 = 6
+FILTER_SIZE_127 = 7
+
+# Power mode settings
+SLEEP_MODE = 0
+FORCED_MODE = 1
+
+# Delay related macro declaration
+RESET_PERIOD = 10
+
+# SPI memory page settings
+MEM_PAGE0 = 0x10
+MEM_PAGE1 = 0x00
+
+# Ambient humidity shift value for compensation
+HUM_REG_SHIFT_VAL = 4
+
+# Run gas enable and disable settings
+RUN_GAS_DISABLE = 0
+RUN_GAS_ENABLE = 1
+
+# Gas heater enable and disable settings
+GAS_HEAT_ENABLE = 0
+GAS_HEAT_DISABLE = 1
+
+# Buffer length macro declaration
+TMP_BUFFER_LENGTH = 40
+REG_BUFFER_LENGTH = 6
+FIELD_DATA_LENGTH = 3
+GAS_REG_BUF_LENGTH = 20
+GAS_HEATER_PROF_LEN_MAX = 10
+
+# Settings selector
+OST_SEL = 1
+OSP_SEL = 2
+OSH_SEL = 4
+GAS_MEAS_SEL = 8
+FILTER_SEL = 16
+HCNTRL_SEL = 32
+RUN_GAS_SEL = 64
+NBCONV_SEL = 128
+GAS_SENSOR_SEL = GAS_MEAS_SEL | RUN_GAS_SEL | NBCONV_SEL
+
+# Number of conversion settings
+NBCONV_MIN = 0
+NBCONV_MAX = 9  # Was 10, but there are only 10 settings: 0 1 2 ... 8 9
+
+# Mask definitions
+GAS_MEAS_MSK = 0x30
+NBCONV_MSK = 0X0F
+FILTER_MSK = 0X1C
+OST_MSK = 0XE0
+OSP_MSK = 0X1C
+OSH_MSK = 0X07
+HCTRL_MSK = 0x08
+RUN_GAS_MSK = 0x30
+MODE_MSK = 0x03
+RHRANGE_MSK = 0x30
+RSERROR_MSK = 0xf0
+NEW_DATA_MSK = 0x80
+GAS_INDEX_MSK = 0x0f
+GAS_RANGE_MSK = 0x0f
+GASM_VALID_MSK = 0x20
+HEAT_STAB_MSK = 0x10
+MEM_PAGE_MSK = 0x10
+SPI_RD_MSK = 0x80
+SPI_WR_MSK = 0x7f
+BIT_H1_DATA_MSK = 0x0F
+
+# Bit position definitions for sensor settings
+GAS_MEAS_POS = 4
+FILTER_POS = 2
+OST_POS = 5
+OSP_POS = 2
+OSH_POS = 0
+HCTRL_POS = 3
+RUN_GAS_POS = 4
+MODE_POS = 0
+NBCONV_POS = 0
+
+# Array Index to Field data mapping for Calibration Data
+T2_LSB_REG = 1
+T2_MSB_REG = 2
+T3_REG = 3
+P1_LSB_REG = 5
+P1_MSB_REG = 6
+P2_LSB_REG = 7
+P2_MSB_REG = 8
+P3_REG = 9
+P4_LSB_REG = 11
+P4_MSB_REG = 12
+P5_LSB_REG = 13
+P5_MSB_REG = 14
+P7_REG = 15
+P6_REG = 16
+P8_LSB_REG = 19
+P8_MSB_REG = 20
+P9_LSB_REG = 21
+P9_MSB_REG = 22
+P10_REG = 23
+H2_MSB_REG = 25
+H2_LSB_REG = 26
+H1_LSB_REG = 26
+H1_MSB_REG = 27
+H3_REG = 28
+H4_REG = 29
+H5_REG = 30
+H6_REG = 31
+H7_REG = 32
+T1_LSB_REG = 33
+T1_MSB_REG = 34
+GH2_LSB_REG = 35
+GH2_MSB_REG = 36
+GH1_REG = 37
+GH3_REG = 38
+
+# BME680 register buffer index settings
+REG_FILTER_INDEX = 5
+REG_TEMP_INDEX = 4
+REG_PRES_INDEX = 4
+REG_HUM_INDEX = 2
+REG_NBCONV_INDEX = 1
+REG_RUN_GAS_INDEX = 1
+REG_HCTRL_INDEX = 0
+
+# Look up tables for the possible gas range values
+lookupTable1 = [2147483647, 2147483647, 2147483647, 2147483647,
+                2147483647, 2126008810, 2147483647, 2130303777, 2147483647,
+                2147483647, 2143188679, 2136746228, 2147483647, 2126008810,
+                2147483647, 2147483647]
+
+lookupTable2 = [4096000000, 2048000000, 1024000000, 512000000,
+                255744255, 127110228, 64000000, 32258064,
+                16016016, 8000000, 4000000, 2000000,
+                1000000, 500000, 250000, 125000]
+
+
+def bytes_to_word(msb, lsb, bits=16, signed=False):
+    """Convert a most and least significant byte into a word."""
+    # TODO: Reimplement with struct
+    word = (msb << 8) | lsb
+    if signed:
+        word = twos_comp(word, bits)
+    return word
+
+
+def twos_comp(val, bits=16):
+    """Convert two bytes into a two's compliment signed word."""
+    # TODO: Reimplement with struct
+    if val & (1 << (bits - 1)) != 0:
+        val = val - (1 << bits)
+    return val
+
+
+class FieldData:
+    """Structure for storing BME680 sensor data."""
+
+    def __init__(self):  # noqa D107
+        # Contains new_data, gasm_valid & heat_stab
+        self.status = None
+        self.heat_stable = False
+        # The index of the heater profile used
+        self.gas_index = None
+        # Measurement index to track order
+        self.meas_index = None
+        # Temperature in degree celsius x100
+        self.temperature = None
+        # Pressure in Pascal
+        self.pressure = None
+        # Humidity in % relative humidity x1000
+        self.humidity = None
+        # Gas resistance in Ohms
+        self.gas_resistance = None
+
+
+class CalibrationData:
+    """Structure for storing BME680 calibration data."""
+
+    def __init__(self):  # noqa D107
+        self.par_h1 = None
+        self.par_h2 = None
+        self.par_h3 = None
+        self.par_h4 = None
+        self.par_h5 = None
+        self.par_h6 = None
+        self.par_h7 = None
+        self.par_gh1 = None
+        self.par_gh2 = None
+        self.par_gh3 = None
+        self.par_t1 = None
+        self.par_t2 = None
+        self.par_t3 = None
+        self.par_p1 = None
+        self.par_p2 = None
+        self.par_p3 = None
+        self.par_p4 = None
+        self.par_p5 = None
+        self.par_p6 = None
+        self.par_p7 = None
+        self.par_p8 = None
+        self.par_p9 = None
+        self.par_p10 = None
+        # Variable to store t_fine size
+        self.t_fine = None
+        # Variable to store heater resistance range
+        self.res_heat_range = None
+        # Variable to store heater resistance value
+        self.res_heat_val = None
+        # Variable to store error range
+        self.range_sw_err = None
+
+    def set_from_array(self, calibration):
+        """Set parameters from an array of bytes."""
+        # Temperature related coefficients
+        self.par_t1 = bytes_to_word(calibration[T1_MSB_REG], calibration[T1_LSB_REG])
+        self.par_t2 = bytes_to_word(calibration[T2_MSB_REG], calibration[T2_LSB_REG], bits=16, signed=True)
+        self.par_t3 = twos_comp(calibration[T3_REG], bits=8)
+
+        # Pressure related coefficients
+        self.par_p1 = bytes_to_word(calibration[P1_MSB_REG], calibration[P1_LSB_REG])
+        self.par_p2 = bytes_to_word(calibration[P2_MSB_REG], calibration[P2_LSB_REG], bits=16, signed=True)
+        self.par_p3 = twos_comp(calibration[P3_REG], bits=8)
+        self.par_p4 = bytes_to_word(calibration[P4_MSB_REG], calibration[P4_LSB_REG], bits=16, signed=True)
+        self.par_p5 = bytes_to_word(calibration[P5_MSB_REG], calibration[P5_LSB_REG], bits=16, signed=True)
+        self.par_p6 = twos_comp(calibration[P6_REG], bits=8)
+        self.par_p7 = twos_comp(calibration[P7_REG], bits=8)
+        self.par_p8 = bytes_to_word(calibration[P8_MSB_REG], calibration[P8_LSB_REG], bits=16, signed=True)
+        self.par_p9 = bytes_to_word(calibration[P9_MSB_REG], calibration[P9_LSB_REG], bits=16, signed=True)
+        self.par_p10 = calibration[P10_REG]
+
+        # Humidity related coefficients
+        self.par_h1 = (calibration[H1_MSB_REG] << HUM_REG_SHIFT_VAL) | (calibration[H1_LSB_REG] & BIT_H1_DATA_MSK)
+        self.par_h2 = (calibration[H2_MSB_REG] << HUM_REG_SHIFT_VAL) | (calibration[H2_LSB_REG] >> HUM_REG_SHIFT_VAL)
+        self.par_h3 = twos_comp(calibration[H3_REG], bits=8)
+        self.par_h4 = twos_comp(calibration[H4_REG], bits=8)
+        self.par_h5 = twos_comp(calibration[H5_REG], bits=8)
+        self.par_h6 = calibration[H6_REG]
+        self.par_h7 = twos_comp(calibration[H7_REG], bits=8)
+
+        # Gas heater related coefficients
+        self.par_gh1 = twos_comp(calibration[GH1_REG], bits=8)
+        self.par_gh2 = bytes_to_word(calibration[GH2_MSB_REG], calibration[GH2_LSB_REG], bits=16, signed=True)
+        self.par_gh3 = twos_comp(calibration[GH3_REG], bits=8)
+
+    def set_other(self, heat_range, heat_value, sw_error):
+        """Set other values."""
+        self.res_heat_range = (heat_range & RHRANGE_MSK) // 16
+        self.res_heat_val = heat_value
+        self.range_sw_err = (sw_error & RSERROR_MSK) // 16
+
+
+class TPHSettings:
+    """Structure for storing BME680 sensor settings.
+
+    Comprises of output data rate, over-sampling and filter settings.
+
+    """
+
+    def __init__(self):  # noqa D107
+        # Humidity oversampling
+        self.os_hum = None
+        # Temperature oversampling
+        self.os_temp = None
+        # Pressure oversampling
+        self.os_pres = None
+        # Filter coefficient
+        self.filter = None
+
+
+class GasSettings:
+    """Structure for storing BME680 gas settings and status."""
+
+    def __init__(self):  # noqa D107
+        # Variable to store nb conversion
+        self.nb_conv = None
+        # Variable to store heater control
+        self.heatr_ctrl = None
+        # Run gas enable value
+        self.run_gas = None
+        # Pointer to store heater temperature
+        self.heatr_temp = None
+        # Pointer to store duration profile
+        self.heatr_dur = None
+
+
+class BME680Data:
+    """Structure to represent BME680 device."""
+
+    def __init__(self):  # noqa D107
+        # Chip Id
+        self.chip_id = None
+        # Device Id
+        self.dev_id = None
+        # SPI/I2C interface
+        self.intf = None
+        # Memory page used
+        self.mem_page = None
+        # Ambient temperature in Degree C
+        self.ambient_temperature = None
+        # Field Data
+        self.data = FieldData()
+        # Sensor calibration data
+        self.calibration_data = CalibrationData()
+        # Sensor settings
+        self.tph_settings = TPHSettings()
+        # Gas Sensor settings
+        self.gas_settings = GasSettings()
+        # Sensor power modes
+        self.power_mode = None
+        # New sensor fields
+        self.new_fields = None

scripts/lib/data_logging.py

@@ -0,0 +1,166 @@
+import json
+import sys
+from time import gmtime, localtime, time
+
+import machine
+import ntptime
+import uos
+import urequests
+from machine import SPI, Pin
+from sdcard import sdcard
+from uio import StringIO
+
+# # uses a more robust ntptime
+# from lib.ntptime import ntptime
+
+
+def get_traceback(err):
+    try:
+        with StringIO() as f:  # type: ignore
+            sys.print_exception(err, f)
+            return f.getvalue()
+    except Exception as err2:
+        print(err2)
+        return f"Failed to extract file and line number due to {err2}.\nOriginal error: {err}"  # noqa: E501
+
+
+def initialize_sdcard(
+    spi_id=1,
+    cs_pin=15,
+    sck_pin=10,
+    mosi_pin=11,
+    miso_pin=12,
+    baudrate=1000000,
+    polarity=0,
+    phase=0,
+    bits=8,
+    firstbit=SPI.MSB,
+    verbose=True,
+):
+    try:
+        cs = Pin(cs_pin, Pin.OUT)
+
+        spi = SPI(
+            spi_id,
+            baudrate=baudrate,
+            polarity=polarity,
+            phase=phase,
+            bits=bits,
+            firstbit=firstbit,
+            sck=Pin(sck_pin),
+            mosi=Pin(mosi_pin),
+            miso=Pin(miso_pin),
+        )
+
+        # Initialize SD card
+        sd = sdcard.SDCard(spi, cs)
+
+        vfs = uos.VfsFat(sd)
+        uos.mount(vfs, "/sd")  # type: ignore
+        if verbose:
+            print("SD Card initialized successfully")
+        return True
+    except Exception as e:
+        if verbose:
+            print(get_traceback(e))
+            print("SD Card failed to initialize")
+        return False
+
+
+def write_payload_backup(payload_data: str, fpath: str = "/sd/experiments.txt"):
+    payload = json.dumps(payload_data)
+    with open(fpath, "a") as file:
+        # line = ",".join([str(payload[key]) for key in payload.keys()])
+        file.write(f"{payload}\r\n")
+
+
+def log_to_mongodb(
+    document: dict,
+    api_key: str,
+    url: str,
+    cluster_name: str,
+    database_name: str,
+    collection_name: str,
+    verbose: bool = True,
+    retries: int = 2,
+):
+    # based on https://medium.com/@johnlpage/introduction-to-microcontrollers-and-the-pi-pico-w-f7a2d9ad1394
+    headers = {"api-key": api_key}
+
+    insertPayload = {
+        "dataSource": cluster_name,
+        "database": database_name,
+        "collection": collection_name,
+        "document": document,
+    }
+
+    if verbose:
+        print(f"sending document to {cluster_name}:{database_name}:{collection_name}")
+
+    for _ in range(retries):
+        response = None
+        if _ > 0:
+            print(f"retrying... ({_} of {retries})")
+
+        try:
+            response = urequests.post(url, headers=headers, json=insertPayload)
+            txt = str(response.text)
+            status_code = response.status_code
+
+            if verbose:
+                print(f"Response: ({status_code}), msg = {txt}")
+                if response.status_code == 201:
+                    print("Added Successfully")
+                    break
+                else:
+                    print("Error")
+
+            # Always close response objects so we don't leak memory
+            response.close()
+        except Exception as e:
+            if response is not None:
+                response.close()
+            if _ == retries - 1:
+                raise e
+            else:
+                print(e)
+
+
+def get_timestamp(timeout=2, return_str=False):
+    ntptime.timeout = timeout  # type: ignore
+    time_int = ntptime.time()
+    utc_tuple = gmtime(time_int)
+    year, month, mday, hour, minute, second, weekday, yearday = utc_tuple
+
+    time_str = f"{year}-{month}-{mday} {hour:02}:{minute:02}:{second:02}"
+
+    if return_str:
+        return time_int, time_str
+
+    return time_int
+
+
+def get_local_timestamp(return_str=False):
+    t = time()
+    year, month, mday, hour, minute, second, _, _ = localtime(t)
+    time_str = f"{year}-{month}-{mday} {hour:02}:{minute:02}:{second:02}"
+
+    if return_str:
+        return t, time_str
+
+    return t
+
+
+def get_onboard_temperature(unit="K"):
+    sensor_temp = machine.ADC(4)
+    conversion_factor = 3.3 / (65535)
+    reading = sensor_temp.read_u16() * conversion_factor
+    celsius_degrees = 27 - (reading - 0.706) / 0.001721
+    if unit == "C":
+        return celsius_degrees
+    elif unit == "K":
+        return celsius_degrees + 273.15
+    elif unit == "F":
+        return celsius_degrees * 9 / 5 + 32
+    else:
+        raise ValueError("Invalid unit. Must be one of 'C', 'K', or 'F")

scripts/lib/functools.py

@@ -0,0 +1,28 @@
+def partial(func, *args, **kwargs):
+    def _partial(*more_args, **more_kwargs):
+        kw = kwargs.copy()
+        kw.update(more_kwargs)
+        func(*(args + more_args), **kw)
+
+    return _partial
+
+
+def update_wrapper(wrapper, wrapped):
+    # Dummy impl
+    return wrapper
+
+
+def wraps(wrapped):
+    # Dummy impl
+    return lambda x: x
+
+
+def reduce(function, iterable, initializer=None):
+    it = iter(iterable)
+    if initializer is None:
+        value = next(it)
+    else:
+        value = initializer
+    for element in it:
+        value = function(value, element)
+    return value

scripts/lib/mqtt_as.py

@@ -0,0 +1,824 @@
+# mqtt_as.py Asynchronous version of umqtt.robust
+# (C) Copyright Peter Hinch 2017-2023.
+# Released under the MIT licence.
+
+# Pyboard D support added also RP2/default
+# Various improvements contributed by Kevin Köck.
+
+import gc
+
+import usocket as socket
+import ustruct as struct
+
+gc.collect()
+import uasyncio as asyncio
+from ubinascii import hexlify
+
+gc.collect()
+from uerrno import EINPROGRESS, ETIMEDOUT
+from utime import ticks_diff, ticks_ms
+
+gc.collect()
+import network
+from machine import unique_id
+from micropython import const
+
+gc.collect()
+from sys import platform
+
+VERSION = (0, 7, 1)
+
+# Default short delay for good SynCom throughput (avoid sleep(0) with SynCom).
+_DEFAULT_MS = const(20)
+_SOCKET_POLL_DELAY = const(5)  # 100ms added greatly to publish latency
+
+# Legitimate errors while waiting on a socket. See uasyncio __init__.py open_connection().
+ESP32 = platform == "esp32"
+RP2 = platform == "rp2"
+if ESP32:
+    # https://forum.micropython.org/viewtopic.php?f=16&t=3608&p=20942#p20942
+    BUSY_ERRORS = [EINPROGRESS, ETIMEDOUT, 118, 119]  # Add in weird ESP32 errors
+elif RP2:
+    BUSY_ERRORS = [EINPROGRESS, ETIMEDOUT, -110]
+else:
+    BUSY_ERRORS = [EINPROGRESS, ETIMEDOUT]
+
+ESP8266 = platform == "esp8266"
+PYBOARD = platform == "pyboard"
+
+
+# Default "do little" coro for optional user replacement
+async def eliza(*_):  # e.g. via set_wifi_handler(coro): see test program
+    await asyncio.sleep_ms(_DEFAULT_MS)
+
+
+class MsgQueue:
+    def __init__(self, size):
+        self._q = [0 for _ in range(max(size, 4))]
+        self._size = size
+        self._wi = 0
+        self._ri = 0
+        self._evt = asyncio.Event()
+        self.discards = 0
+
+    def put(self, *v):
+        self._q[self._wi] = v
+        self._evt.set()
+        self._wi = (self._wi + 1) % self._size
+        if self._wi == self._ri:  # Would indicate empty
+            self._ri = (self._ri + 1) % self._size  # Discard a message
+            self.discards += 1
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        if self._ri == self._wi:  # Empty
+            self._evt.clear()
+            await self._evt.wait()
+        r = self._q[self._ri]
+        self._ri = (self._ri + 1) % self._size
+        return r
+
+
+config = {
+    "client_id": hexlify(unique_id()),
+    "server": None,
+    "port": 0,
+    "user": "",
+    "password": "",
+    "keepalive": 60,
+    "ping_interval": 0,
+    "ssl": False,
+    "ssl_params": {},
+    "response_time": 10,
+    "clean_init": True,
+    "clean": True,
+    "max_repubs": 4,
+    "will": None,
+    "subs_cb": lambda *_: None,
+    "wifi_coro": eliza,
+    "connect_coro": eliza,
+    "ssid": None,
+    "wifi_pw": None,
+    "queue_len": 0,
+    "gateway": False,
+}
+
+
+class MQTTException(Exception):
+    pass
+
+
+def pid_gen():
+    pid = 0
+    while True:
+        pid = pid + 1 if pid < 65535 else 1
+        yield pid
+
+
+def qos_check(qos):
+    if not (qos == 0 or qos == 1):
+        raise ValueError("Only qos 0 and 1 are supported.")
+
+
+# MQTT_base class. Handles MQTT protocol on the basis of a good connection.
+# Exceptions from connectivity failures are handled by MQTTClient subclass.
+class MQTT_base:
+    REPUB_COUNT = 0  # TEST
+    DEBUG = False
+
+    def __init__(self, config):
+        self._events = config["queue_len"] > 0
+        # MQTT config
+        self._client_id = config["client_id"]
+        self._user = config["user"]
+        self._pswd = config["password"]
+        self._keepalive = config["keepalive"]
+        if self._keepalive >= 65536:
+            raise ValueError("invalid keepalive time")
+        self._response_time = (
+            config["response_time"] * 1000
+        )  # Repub if no PUBACK received (ms).
+        self._max_repubs = config["max_repubs"]
+        self._clean_init = config[
+            "clean_init"
+        ]  # clean_session state on first connection
+        self._clean = config["clean"]  # clean_session state on reconnect
+        will = config["will"]
+        if will is None:
+            self._lw_topic = False
+        else:
+            self._set_last_will(*will)
+        # WiFi config
+        self._ssid = config["ssid"]  # Required for ESP32 / Pyboard D. Optional ESP8266
+        self._wifi_pw = config["wifi_pw"]
+        self._ssl = config["ssl"]
+        self._ssl_params = config["ssl_params"]
+        # Callbacks and coros
+        if self._events:
+            self.up = asyncio.Event()
+            self.down = asyncio.Event()
+            self.queue = MsgQueue(config["queue_len"])
+        else:  # Callbacks
+            self._cb = config["subs_cb"]
+            self._wifi_handler = config["wifi_coro"]
+            self._connect_handler = config["connect_coro"]
+        # Network
+        self.port = config["port"]
+        if self.port == 0:
+            self.port = 8883 if self._ssl else 1883
+        self.server = config["server"]
+        if self.server is None:
+            raise ValueError("no server specified.")
+        self._sock = None
+        self._sta_if = network.WLAN(network.STA_IF)
+        self._sta_if.active(True)
+        if config["gateway"]:  # Called from gateway (hence ESP32).
+            import aioespnow  # Set up ESPNOW
+
+            while not (sta := self._sta_if).active():
+                time.sleep(0.1)
+            sta.config(pm=sta.PM_NONE)  # No power management
+            sta.active(True)
+            self._espnow = (
+                aioespnow.AIOESPNow()
+            )  # Returns AIOESPNow enhanced with async support
+            self._espnow.active(True)
+
+        self.newpid = pid_gen()
+        self.rcv_pids = set()  # PUBACK and SUBACK pids awaiting ACK response
+        self.last_rx = ticks_ms()  # Time of last communication from broker
+        self.lock = asyncio.Lock()
+
+    def _set_last_will(self, topic, msg, retain=False, qos=0):
+        qos_check(qos)
+        if not topic:
+            raise ValueError("Empty topic.")
+        self._lw_topic = topic
+        self._lw_msg = msg
+        self._lw_qos = qos
+        self._lw_retain = retain
+
+    def dprint(self, msg, *args):
+        if self.DEBUG:
+            print(msg % args)
+
+    def _timeout(self, t):
+        return ticks_diff(ticks_ms(), t) > self._response_time
+
+    async def _as_read(self, n, sock=None):  # OSError caught by superclass
+        if sock is None:
+            sock = self._sock
+        # Declare a byte array of size n. That space is needed anyway, better
+        # to just 'allocate' it in one go instead of appending to an
+        # existing object, this prevents reallocation and fragmentation.
+        data = bytearray(n)
+        buffer = memoryview(data)
+        size = 0
+        t = ticks_ms()
+        while size < n:
+            if self._timeout(t) or not self.isconnected():
+                raise OSError(-1, "Timeout on socket read")
+            try:
+                msg_size = sock.readinto(buffer[size:], n - size)
+            except OSError as e:  # ESP32 issues weird 119 errors here
+                msg_size = None
+                if e.args[0] not in BUSY_ERRORS:
+                    raise
+            if msg_size == 0:  # Connection closed by host
+                raise OSError(-1, "Connection closed by host")
+            if msg_size is not None:  # data received
+                size += msg_size
+                t = ticks_ms()
+                self.last_rx = ticks_ms()
+            await asyncio.sleep_ms(_SOCKET_POLL_DELAY)
+        return data
+
+    async def _as_write(self, bytes_wr, length=0, sock=None):
+        if sock is None:
+            sock = self._sock
+
+        # Wrap bytes in memoryview to avoid copying during slicing
+        bytes_wr = memoryview(bytes_wr)
+        if length:
+            bytes_wr = bytes_wr[:length]
+        t = ticks_ms()
+        while bytes_wr:
+            if self._timeout(t) or not self.isconnected():
+                raise OSError(-1, "Timeout on socket write")
+            try:
+                n = sock.write(bytes_wr)
+            except OSError as e:  # ESP32 issues weird 119 errors here
+                n = 0
+                if e.args[0] not in BUSY_ERRORS:
+                    raise
+            if n:
+                t = ticks_ms()
+                bytes_wr = bytes_wr[n:]
+            await asyncio.sleep_ms(_SOCKET_POLL_DELAY)
+
+    async def _send_str(self, s):
+        await self._as_write(struct.pack("!H", len(s)))
+        await self._as_write(s)
+
+    async def _recv_len(self):
+        n = 0
+        sh = 0
+        while 1:
+            res = await self._as_read(1)
+            b = res[0]
+            n |= (b & 0x7F) << sh
+            if not b & 0x80:
+                return n
+            sh += 7
+
+    async def _connect(self, clean):
+        self._sock = socket.socket()
+        self._sock.setblocking(False)
+        try:
+            self._sock.connect(self._addr)
+        except OSError as e:
+            if e.args[0] not in BUSY_ERRORS:
+                raise
+        await asyncio.sleep_ms(_DEFAULT_MS)
+        self.dprint("Connecting to broker.")
+        if self._ssl:
+            import ssl
+
+            self._sock = ssl.wrap_socket(self._sock, **self._ssl_params)
+        premsg = bytearray(b"\x10\0\0\0\0\0")
+        msg = bytearray(b"\x04MQTT\x04\0\0\0")  # Protocol 3.1.1
+
+        sz = 10 + 2 + len(self._client_id)
+        msg[6] = clean << 1
+        if self._user:
+            sz += 2 + len(self._user) + 2 + len(self._pswd)
+            msg[6] |= 0xC0
+        if self._keepalive:
+            msg[7] |= self._keepalive >> 8
+            msg[8] |= self._keepalive & 0x00FF
+        if self._lw_topic:
+            sz += 2 + len(self._lw_topic) + 2 + len(self._lw_msg)
+            msg[6] |= 0x4 | (self._lw_qos & 0x1) << 3 | (self._lw_qos & 0x2) << 3
+            msg[6] |= self._lw_retain << 5
+
+        i = 1
+        while sz > 0x7F:
+            premsg[i] = (sz & 0x7F) | 0x80
+            sz >>= 7
+            i += 1
+        premsg[i] = sz
+        await self._as_write(premsg, i + 2)
+        await self._as_write(msg)
+        await self._send_str(self._client_id)
+        if self._lw_topic:
+            await self._send_str(self._lw_topic)
+            await self._send_str(self._lw_msg)
+        if self._user:
+            await self._send_str(self._user)
+            await self._send_str(self._pswd)
+        # Await CONNACK
+        # read causes ECONNABORTED if broker is out; triggers a reconnect.
+        resp = await self._as_read(4)
+        self.dprint("Connected to broker.")  # Got CONNACK
+        if (
+            resp[3] != 0 or resp[0] != 0x20 or resp[1] != 0x02
+        ):  # Bad CONNACK e.g. authentication fail.
+            raise OSError(
+                -1,
+                f"Connect fail: 0x{(resp[0] << 8) + resp[1]:04x} {resp[3]} (README 7)",
+            )
+
+    async def _ping(self):
+        async with self.lock:
+            await self._as_write(b"\xc0\0")
+
+    # Check internet connectivity by sending DNS lookup to Google's 8.8.8.8
+    async def wan_ok(
+        self,
+        packet=b"$\x1a\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x03www\x06google\x03com\x00\x00\x01\x00\x01",
+    ):
+        if not self.isconnected():  # WiFi is down
+            return False
+        length = 32  # DNS query and response packet size
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.setblocking(False)
+        s.connect(("8.8.8.8", 53))
+        await asyncio.sleep(1)
+        try:
+            await self._as_write(packet, sock=s)
+            await asyncio.sleep(2)
+            res = await self._as_read(length, s)
+            if len(res) == length:
+                return True  # DNS response size OK
+        except OSError:  # Timeout on read: no connectivity.
+            return False
+        finally:
+            s.close()
+        return False
+
+    async def broker_up(self):  # Test broker connectivity
+        if not self.isconnected():
+            return False
+        tlast = self.last_rx
+        if ticks_diff(ticks_ms(), tlast) < 1000:
+            return True
+        try:
+            await self._ping()
+        except OSError:
+            return False
+        t = ticks_ms()
+        while not self._timeout(t):
+            await asyncio.sleep_ms(100)
+            if ticks_diff(self.last_rx, tlast) > 0:  # Response received
+                return True
+        return False
+
+    async def disconnect(self):
+        if self._sock is not None:
+            await self._kill_tasks(False)  # Keep socket open
+            try:
+                async with self.lock:
+                    self._sock.write(b"\xe0\0")  # Close broker connection
+                    await asyncio.sleep_ms(100)
+            except OSError:
+                pass
+            self._close()
+        self._has_connected = False
+
+    def _close(self):
+        if self._sock is not None:
+            self._sock.close()
+
+    def close(
+        self,
+    ):  # API. See https://github.com/peterhinch/micropython-mqtt/issues/60
+        self._close()
+        try:
+            self._sta_if.disconnect()  # Disconnect Wi-Fi to avoid errors
+        except OSError:
+            self.dprint("Wi-Fi not started, unable to disconnect interface")
+        self._sta_if.active(False)
+
+    async def _await_pid(self, pid):
+        t = ticks_ms()
+        while pid in self.rcv_pids:  # local copy
+            if self._timeout(t) or not self.isconnected():
+                break  # Must repub or bail out
+            await asyncio.sleep_ms(100)
+        else:
+            return True  # PID received. All done.
+        return False
+
+    # qos == 1: coro blocks until wait_msg gets correct PID.
+    # If WiFi fails completely subclass re-publishes with new PID.
+    async def publish(self, topic, msg, retain, qos):
+        pid = next(self.newpid)
+        if qos:
+            self.rcv_pids.add(pid)
+        async with self.lock:
+            await self._publish(topic, msg, retain, qos, 0, pid)
+        if qos == 0:
+            return
+
+        count = 0
+        while 1:  # Await PUBACK, republish on timeout
+            if await self._await_pid(pid):
+                return
+            # No match
+            if count >= self._max_repubs or not self.isconnected():
+                raise OSError(-1)  # Subclass to re-publish with new PID
+            async with self.lock:
+                await self._publish(topic, msg, retain, qos, dup=1, pid=pid)  # Add pid
+            count += 1
+            self.REPUB_COUNT += 1
+
+    async def _publish(self, topic, msg, retain, qos, dup, pid):
+        pkt = bytearray(b"\x30\0\0\0")
+        pkt[0] |= qos << 1 | retain | dup << 3
+        sz = 2 + len(topic) + len(msg)
+        if qos > 0:
+            sz += 2
+        if sz >= 2097152:
+            raise MQTTException("Strings too long.")
+        i = 1
+        while sz > 0x7F:
+            pkt[i] = (sz & 0x7F) | 0x80
+            sz >>= 7
+            i += 1
+        pkt[i] = sz
+        await self._as_write(pkt, i + 1)
+        await self._send_str(topic)
+        if qos > 0:
+            struct.pack_into("!H", pkt, 0, pid)
+            await self._as_write(pkt, 2)
+        await self._as_write(msg)
+
+    # Can raise OSError if WiFi fails. Subclass traps.
+    async def subscribe(self, topic, qos):
+        pkt = bytearray(b"\x82\0\0\0")
+        pid = next(self.newpid)
+        self.rcv_pids.add(pid)
+        struct.pack_into("!BH", pkt, 1, 2 + 2 + len(topic) + 1, pid)
+        async with self.lock:
+            await self._as_write(pkt)
+            await self._send_str(topic)
+            await self._as_write(qos.to_bytes(1, "little"))
+
+        if not await self._await_pid(pid):
+            raise OSError(-1)
+
+    # Can raise OSError if WiFi fails. Subclass traps.
+    async def unsubscribe(self, topic):
+        pkt = bytearray(b"\xa2\0\0\0")
+        pid = next(self.newpid)
+        self.rcv_pids.add(pid)
+        struct.pack_into("!BH", pkt, 1, 2 + 2 + len(topic), pid)
+        async with self.lock:
+            await self._as_write(pkt)
+            await self._send_str(topic)
+
+        if not await self._await_pid(pid):
+            raise OSError(-1)
+
+    # Wait for a single incoming MQTT message and process it.
+    # Subscribed messages are delivered to a callback previously
+    # set by .setup() method. Other (internal) MQTT
+    # messages processed internally.
+    # Immediate return if no data available. Called from ._handle_msg().
+    async def wait_msg(self):
+        try:
+            res = self._sock.read(1)  # Throws OSError on WiFi fail
+        except OSError as e:
+            if e.args[0] in BUSY_ERRORS:  # Needed by RP2
+                await asyncio.sleep_ms(0)
+                return
+            raise
+        if res is None:
+            return
+        if res == b"":
+            raise OSError(-1, "Empty response")
+
+        if res == b"\xd0":  # PINGRESP
+            await self._as_read(1)  # Update .last_rx time
+            return
+        op = res[0]
+
+        if op == 0x40:  # PUBACK: save pid
+            sz = await self._as_read(1)
+            if sz != b"\x02":
+                raise OSError(-1, "Invalid PUBACK packet")
+            rcv_pid = await self._as_read(2)
+            pid = rcv_pid[0] << 8 | rcv_pid[1]
+            if pid in self.rcv_pids:
+                self.rcv_pids.discard(pid)
+            else:
+                raise OSError(-1, "Invalid pid in PUBACK packet")
+
+        if op == 0x90:  # SUBACK
+            resp = await self._as_read(4)
+            if resp[3] == 0x80:
+                raise OSError(-1, "Invalid SUBACK packet")
+            pid = resp[2] | (resp[1] << 8)
+            if pid in self.rcv_pids:
+                self.rcv_pids.discard(pid)
+            else:
+                raise OSError(-1, "Invalid pid in SUBACK packet")
+
+        if op == 0xB0:  # UNSUBACK
+            resp = await self._as_read(3)
+            pid = resp[2] | (resp[1] << 8)
+            if pid in self.rcv_pids:
+                self.rcv_pids.discard(pid)
+            else:
+                raise OSError(-1)
+
+        if op & 0xF0 != 0x30:
+            return
+        sz = await self._recv_len()
+        topic_len = await self._as_read(2)
+        topic_len = (topic_len[0] << 8) | topic_len[1]
+        topic = await self._as_read(topic_len)
+        sz -= topic_len + 2
+        if op & 6:
+            pid = await self._as_read(2)
+            pid = pid[0] << 8 | pid[1]
+            sz -= 2
+        msg = await self._as_read(sz)
+        retained = op & 0x01
+        if self._events:
+            self.queue.put(topic, msg, bool(retained))
+        else:
+            self._cb(topic, msg, bool(retained))
+        if op & 6 == 2:  # qos 1
+            pkt = bytearray(b"\x40\x02\0\0")  # Send PUBACK
+            struct.pack_into("!H", pkt, 2, pid)
+            await self._as_write(pkt)
+        elif op & 6 == 4:  # qos 2 not supported
+            raise OSError(-1, "QoS 2 not supported")
+
+
+# MQTTClient class. Handles issues relating to connectivity.
+
+
+class MQTTClient(MQTT_base):
+    def __init__(self, config):
+        super().__init__(config)
+        self._isconnected = False  # Current connection state
+        keepalive = 1000 * self._keepalive  # ms
+        self._ping_interval = keepalive // 4 if keepalive else 20000
+        p_i = (
+            config["ping_interval"] * 1000
+        )  # Can specify shorter e.g. for subscribe-only
+        if p_i and p_i < self._ping_interval:
+            self._ping_interval = p_i
+        self._in_connect = False
+        self._has_connected = False  # Define 'Clean Session' value to use.
+        self._tasks = []
+        if ESP8266:
+            import esp
+
+            esp.sleep_type(
+                0
+            )  # Improve connection integrity at cost of power consumption.
+
+    async def wifi_connect(self, quick=False):
+        s = self._sta_if
+        if ESP8266:
+            if s.isconnected():  # 1st attempt, already connected.
+                return
+            s.active(True)
+            s.connect()  # ESP8266 remembers connection.
+            for _ in range(60):
+                if (
+                    s.status() != network.STAT_CONNECTING
+                ):  # Break out on fail or success. Check once per sec.
+                    break
+                await asyncio.sleep(1)
+            if (
+                s.status() == network.STAT_CONNECTING
+            ):  # might hang forever awaiting dhcp lease renewal or something else
+                s.disconnect()
+                await asyncio.sleep(1)
+            if (
+                not s.isconnected()
+                and self._ssid is not None
+                and self._wifi_pw is not None
+            ):
+                s.connect(self._ssid, self._wifi_pw)
+                while (
+                    s.status() == network.STAT_CONNECTING
+                ):  # Break out on fail or success. Check once per sec.
+                    await asyncio.sleep(1)
+        else:
+            s.active(True)
+            if RP2:  # Disable auto-sleep.
+                # https://datasheets.raspberrypi.com/picow/connecting-to-the-internet-with-pico-w.pdf
+                # para 3.6.3
+                s.config(pm=0xA11140)
+            s.connect(self._ssid, self._wifi_pw)
+            for _ in range(60):  # Break out on fail or success. Check once per sec.
+                await asyncio.sleep(1)
+                # Loop while connecting or no IP
+                if s.isconnected():
+                    break
+                if ESP32:
+                    if s.status() != network.STAT_CONNECTING:  # 1001
+                        break
+                elif PYBOARD:  # No symbolic constants in network
+                    if not 1 <= s.status() <= 2:
+                        break
+                elif RP2:  # 1 is STAT_CONNECTING. 2 reported by user (No IP?)
+                    if not 1 <= s.status() <= 2:
+                        break
+            else:  # Timeout: still in connecting state
+                s.disconnect()
+                await asyncio.sleep(1)
+
+        if not s.isconnected():  # Timed out
+            raise OSError("Wi-Fi connect timed out")
+        if not quick:  # Skip on first connection only if power saving
+            # Ensure connection stays up for a few secs.
+            self.dprint("Checking WiFi integrity.")
+            for _ in range(5):
+                if not s.isconnected():
+                    raise OSError("Connection Unstable")  # in 1st 5 secs
+                await asyncio.sleep(1)
+            self.dprint("Got reliable connection")
+
+    async def connect(
+        self, *, quick=False
+    ):  # Quick initial connect option for battery apps
+        if not self._has_connected:
+            await self.wifi_connect(quick)  # On 1st call, caller handles error
+            # Note this blocks if DNS lookup occurs. Do it once to prevent
+            # blocking during later internet outage:
+            self._addr = socket.getaddrinfo(self.server, self.port)[0][-1]
+        self._in_connect = True  # Disable low level ._isconnected check
+        try:
+            if not self._has_connected and self._clean_init and not self._clean:
+                # Power up. Clear previous session data but subsequently save it.
+                # Issue #40
+                await self._connect(True)  # Connect with clean session
+                try:
+                    async with self.lock:
+                        self._sock.write(
+                            b"\xe0\0"
+                        )  # Force disconnect but keep socket open
+                except OSError:
+                    pass
+                self.dprint("Waiting for disconnect")
+                await asyncio.sleep(2)  # Wait for broker to disconnect
+                self.dprint("About to reconnect with unclean session.")
+            await self._connect(self._clean)
+        except Exception:
+            self._close()
+            self._in_connect = False  # Caller may run .isconnected()
+            raise
+        self.rcv_pids.clear()
+        # If we get here without error broker/LAN must be up.
+        self._isconnected = True
+        self._in_connect = False  # Low level code can now check connectivity.
+        if not self._events:
+            asyncio.create_task(self._wifi_handler(True))  # User handler.
+        if not self._has_connected:
+            self._has_connected = True  # Use normal clean flag on reconnect.
+            asyncio.create_task(self._keep_connected())
+            # Runs forever unless user issues .disconnect()
+
+        asyncio.create_task(self._handle_msg())  # Task quits on connection fail.
+        self._tasks.append(asyncio.create_task(self._keep_alive()))
+        if self.DEBUG:
+            self._tasks.append(asyncio.create_task(self._memory()))
+        if self._events:
+            self.up.set()  # Connectivity is up
+        else:
+            asyncio.create_task(self._connect_handler(self))  # User handler.
+
+    # Launched by .connect(). Runs until connectivity fails. Checks for and
+    # handles incoming messages.
+    async def _handle_msg(self):
+        try:
+            while self.isconnected():
+                async with self.lock:
+                    await self.wait_msg()  # Immediate return if no message
+                await asyncio.sleep_ms(_DEFAULT_MS)  # Let other tasks get lock
+
+        except OSError:
+            pass
+        self._reconnect()  # Broker or WiFi fail.
+
+    # Keep broker alive MQTT spec 3.1.2.10 Keep Alive.
+    # Runs until ping failure or no response in keepalive period.
+    async def _keep_alive(self):
+        while self.isconnected():
+            pings_due = ticks_diff(ticks_ms(), self.last_rx) // self._ping_interval
+            if pings_due >= 4:
+                self.dprint("Reconnect: broker fail.")
+                break
+            await asyncio.sleep_ms(self._ping_interval)
+            try:
+                await self._ping()
+            except OSError:
+                break
+        self._reconnect()  # Broker or WiFi fail.
+
+    async def _kill_tasks(self, kill_skt):  # Cancel running tasks
+        for task in self._tasks:
+            task.cancel()
+        self._tasks.clear()
+        await asyncio.sleep_ms(0)  # Ensure cancellation complete
+        if kill_skt:  # Close socket
+            self._close()
+
+    # DEBUG: show RAM messages.
+    async def _memory(self):
+        while True:
+            await asyncio.sleep(20)
+            gc.collect()
+            self.dprint("RAM free %d alloc %d", gc.mem_free(), gc.mem_alloc())
+
+    def isconnected(self):
+        if self._in_connect:  # Disable low-level check during .connect()
+            return True
+        if self._isconnected and not self._sta_if.isconnected():  # It's going down.
+            self._reconnect()
+        return self._isconnected
+
+    def _reconnect(self):  # Schedule a reconnection if not underway.
+        if self._isconnected:
+            self._isconnected = False
+            asyncio.create_task(self._kill_tasks(True))  # Shut down tasks and socket
+            if self._events:  # Signal an outage
+                self.down.set()
+            else:
+                asyncio.create_task(self._wifi_handler(False))  # User handler.
+
+    # Await broker connection.
+    async def _connection(self):
+        while not self._isconnected:
+            await asyncio.sleep(1)
+
+    # Scheduled on 1st successful connection. Runs forever maintaining wifi and
+    # broker connection. Must handle conditions at edge of WiFi range.
+    async def _keep_connected(self):
+        while self._has_connected:
+            if self.isconnected():  # Pause for 1 second
+                await asyncio.sleep(1)
+                gc.collect()
+            else:  # Link is down, socket is closed, tasks are killed
+                try:
+                    self._sta_if.disconnect()
+                except OSError:
+                    self.dprint("Wi-Fi not started, unable to disconnect interface")
+                await asyncio.sleep(1)
+                try:
+                    await self.wifi_connect()
+                except OSError:
+                    continue
+                if (
+                    not self._has_connected
+                ):  # User has issued the terminal .disconnect()
+                    self.dprint("Disconnected, exiting _keep_connected")
+                    break
+                try:
+                    await self.connect()
+                    # Now has set ._isconnected and scheduled _connect_handler().
+                    self.dprint("Reconnect OK!")
+                except OSError as e:
+                    self.dprint("Error in reconnect. %s", e)
+                    # Can get ECONNABORTED or -1. The latter signifies no or bad CONNACK received.
+                    self._close()  # Disconnect and try again.
+                    self._in_connect = False
+                    self._isconnected = False
+        self.dprint("Disconnected, exited _keep_connected")
+
+    async def subscribe(self, topic, qos=0):
+        qos_check(qos)
+        while 1:
+            await self._connection()
+            try:
+                return await super().subscribe(topic, qos)
+            except OSError:
+                pass
+            self._reconnect()  # Broker or WiFi fail.
+
+    async def unsubscribe(self, topic):
+        while 1:
+            await self._connection()
+            try:
+                return await super().unsubscribe(topic)
+            except OSError:
+                pass
+            self._reconnect()  # Broker or WiFi fail.
+
+    async def publish(self, topic, msg, retain=False, qos=0):
+        qos_check(qos)
+        while 1:
+            await self._connection()
+            try:
+                return await super().publish(topic, msg, retain, qos)
+            except OSError:
+                pass
+            self._reconnect()  # Broker or WiFi fail.

scripts/lib/netman.py

@@ -0,0 +1,73 @@
+#              .';:cc;.
+#            .,',;lol::c.
+#            ;';lddddlclo
+#            lcloxxoddodxdool:,.
+#            cxdddxdodxdkOkkkkkkkd:.
+#          .ldxkkOOOOkkOO000Okkxkkkkx:.
+#        .lddxkkOkOOO0OOO0000Okxxxxkkkk:
+#       'ooddkkkxxkO0000KK00Okxdoodxkkkko
+#      .ooodxkkxxxOO000kkkO0KOxolooxkkxxkl
+#      lolodxkkxxkOx,.      .lkdolodkkxxxO.
+#      doloodxkkkOk           ....   .,cxO;
+#      ddoodddxkkkk:         ,oxxxkOdc'..o'
+#      :kdddxxxxd,  ,lolccldxxxkkOOOkkkko,
+#       lOkxkkk;  :xkkkkkkkkOOO000OOkkOOk.
+#        ;00Ok' 'O000OO0000000000OOOO0Od.
+#         .l0l.;OOO000000OOOOOO000000x,
+#            .'OKKKK00000000000000kc.
+#               .:ox0KKKKKKK0kdc,.
+#                      ...
+#
+# Author: peppe8o
+# Date: Jul 24th, 2022
+# Version: 1.0
+# https://peppe8o.com
+
+# modified by @sgbaird from source:
+# https://peppe8o.com/getting-started-with-wifi-on-raspberry-pi-pico-w-and-micropython/
+
+import time
+
+import network
+import rp2
+from ubinascii import hexlify
+
+
+def connectWiFi(ssid, password, country=None, wifi_energy_saver=False, retries=3):
+    for _ in range(retries):
+        try:
+            if country is not None:
+                # https://www.google.com/search?q=wifi+country+codes
+                rp2.country(country)
+            wlan = network.WLAN(network.STA_IF)
+            if not wifi_energy_saver:
+                wlan.config(pm=0xA11140)  # avoid the energy-saving WiFi mode
+            wlan.active(True)
+
+            mac = hexlify(network.WLAN().config("mac"), ":").decode()
+            print(f"MAC address: {mac}")
+
+            wlan.connect(ssid, password)
+            # Wait for connect or fail
+            max_wait = 10
+            while max_wait > 0:
+                if wlan.status() < 0 or wlan.status() >= 3:
+                    break
+                max_wait -= 1
+                print("waiting for connection...")
+                time.sleep(1)
+
+            # Handle connection error
+            if wlan.status() != 3:
+                raise RuntimeError("network connection failed")
+            else:
+                print("connected")
+                status = wlan.ifconfig()
+                print("ip = " + status[0])
+            return status
+        except RuntimeError as e:
+            print(f"Attempt failed with error: {e}. Retrying...")
+    raise RuntimeError(
+        "All attempts to connect to the network failed. Ensure you are using a 2.4 GHz WiFi network with WPA-2 authentication. See the additional prerequisites section from https://doi.org/10.1016/j.xpro.2023.102329 or the https://github.com/sparks-baird/self-driving-lab-demo/issues/76 for additional troubleshooting help."
+    )
+

scripts/lib/sdcard/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013, 2014 Damien P. George
+
+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.

scripts/lib/sdcard/sdcard.py

@@ -0,0 +1,302 @@
+"""
+MicroPython driver for SD cards using SPI bus.
+
+Requires an SPI bus and a CS pin.  Provides readblocks and writeblocks
+methods so the device can be mounted as a filesystem.
+
+Example usage on pyboard:
+
+    import pyb, sdcard, os
+    sd = sdcard.SDCard(pyb.SPI(1), pyb.Pin.board.X5)
+    pyb.mount(sd, '/sd2')
+    os.listdir('/')
+
+Example usage on ESP8266:
+
+    import machine, sdcard, os
+    sd = sdcard.SDCard(machine.SPI(1), machine.Pin(15))
+    os.mount(sd, '/sd')
+    os.listdir('/')
+
+Copied from source: https://raw.githubusercontent.com/micropython/micropython-lib/master/micropython/drivers/storage/sdcard/sdcard.py
+
+"""
+
+import time
+
+from micropython import const
+
+_CMD_TIMEOUT = const(100)
+
+_R1_IDLE_STATE = const(1 << 0)
+# R1_ERASE_RESET = const(1 << 1)
+_R1_ILLEGAL_COMMAND = const(1 << 2)
+# R1_COM_CRC_ERROR = const(1 << 3)
+# R1_ERASE_SEQUENCE_ERROR = const(1 << 4)
+# R1_ADDRESS_ERROR = const(1 << 5)
+# R1_PARAMETER_ERROR = const(1 << 6)
+_TOKEN_CMD25 = const(0xFC)
+_TOKEN_STOP_TRAN = const(0xFD)
+_TOKEN_DATA = const(0xFE)
+
+
+class SDCard:
+    def __init__(self, spi, cs, baudrate=1320000):
+        self.spi = spi
+        self.cs = cs
+
+        self.cmdbuf = bytearray(6)
+        self.dummybuf = bytearray(512)
+        self.tokenbuf = bytearray(1)
+        for i in range(512):
+            self.dummybuf[i] = 0xFF
+        self.dummybuf_memoryview = memoryview(self.dummybuf)
+
+        # initialise the card
+        self.init_card(baudrate)
+
+    def init_spi(self, baudrate):
+        try:
+            master = self.spi.MASTER
+        except AttributeError:
+            # on ESP8266
+            self.spi.init(baudrate=baudrate, phase=0, polarity=0)
+        else:
+            # on pyboard
+            self.spi.init(master, baudrate=baudrate, phase=0, polarity=0)
+
+    def init_card(self, baudrate):
+        # init CS pin
+        self.cs.init(self.cs.OUT, value=1)
+
+        # init SPI bus; use low data rate for initialisation
+        self.init_spi(100000)
+
+        # clock card at least 100 cycles with cs high
+        for i in range(16):
+            self.spi.write(b"\xff")
+
+        # CMD0: init card; should return _R1_IDLE_STATE (allow 5 attempts)
+        for _ in range(5):
+            if self.cmd(0, 0, 0x95) == _R1_IDLE_STATE:
+                break
+        else:
+            raise OSError("no SD card")
+
+        # CMD8: determine card version
+        r = self.cmd(8, 0x01AA, 0x87, 4)
+        if r == _R1_IDLE_STATE:
+            self.init_card_v2()
+        elif r == (_R1_IDLE_STATE | _R1_ILLEGAL_COMMAND):
+            self.init_card_v1()
+        else:
+            raise OSError("couldn't determine SD card version")
+
+        # get the number of sectors
+        # CMD9: response R2 (R1 byte + 16-byte block read)
+        if self.cmd(9, 0, 0, 0, False) != 0:
+            raise OSError("no response from SD card")
+        csd = bytearray(16)
+        self.readinto(csd)
+        if csd[0] & 0xC0 == 0x40:  # CSD version 2.0
+            self.sectors = ((csd[8] << 8 | csd[9]) + 1) * 1024
+        elif csd[0] & 0xC0 == 0x00:  # CSD version 1.0 (old, <=2GB)
+            c_size = (csd[6] & 0b11) << 10 | csd[7] << 2 | csd[8] >> 6
+            c_size_mult = (csd[9] & 0b11) << 1 | csd[10] >> 7
+            read_bl_len = csd[5] & 0b1111
+            capacity = (c_size + 1) * (2 ** (c_size_mult + 2)) * (2**read_bl_len)
+            self.sectors = capacity // 512
+        else:
+            raise OSError("SD card CSD format not supported")
+        # print('sectors', self.sectors)
+
+        # CMD16: set block length to 512 bytes
+        if self.cmd(16, 512, 0) != 0:
+            raise OSError("can't set 512 block size")
+
+        # set to high data rate now that it's initialised
+        self.init_spi(baudrate)
+
+    def init_card_v1(self):
+        for i in range(_CMD_TIMEOUT):
+            time.sleep_ms(50)
+            self.cmd(55, 0, 0)
+            if self.cmd(41, 0, 0) == 0:
+                # SDSC card, uses byte addressing in read/write/erase commands
+                self.cdv = 512
+                # print("[SDCard] v1 card")
+                return
+        raise OSError("timeout waiting for v1 card")
+
+    def init_card_v2(self):
+        for i in range(_CMD_TIMEOUT):
+            time.sleep_ms(50)
+            self.cmd(58, 0, 0, 4)
+            self.cmd(55, 0, 0)
+            if self.cmd(41, 0x40000000, 0) == 0:
+                self.cmd(
+                    58, 0, 0, -4
+                )  # 4-byte response, negative means keep the first byte
+                ocr = self.tokenbuf[0]  # get first byte of response, which is OCR
+                if not ocr & 0x40:
+                    # SDSC card, uses byte addressing in read/write/erase commands
+                    self.cdv = 512
+                else:
+                    # SDHC/SDXC card, uses block addressing in read/write/erase commands
+                    self.cdv = 1
+                # print("[SDCard] v2 card")
+                return
+        raise OSError("timeout waiting for v2 card")
+
+    def cmd(self, cmd, arg, crc, final=0, release=True, skip1=False):
+        self.cs(0)
+
+        # create and send the command
+        buf = self.cmdbuf
+        buf[0] = 0x40 | cmd
+        buf[1] = arg >> 24
+        buf[2] = arg >> 16
+        buf[3] = arg >> 8
+        buf[4] = arg
+        buf[5] = crc
+        self.spi.write(buf)
+
+        if skip1:
+            self.spi.readinto(self.tokenbuf, 0xFF)
+
+        # wait for the response (response[7] == 0)
+        for i in range(_CMD_TIMEOUT):
+            self.spi.readinto(self.tokenbuf, 0xFF)
+            response = self.tokenbuf[0]
+            if not (response & 0x80):
+                # this could be a big-endian integer that we are getting here
+                # if final<0 then store the first byte to tokenbuf and discard the rest
+                if final < 0:
+                    self.spi.readinto(self.tokenbuf, 0xFF)
+                    final = -1 - final
+                for j in range(final):
+                    self.spi.write(b"\xff")
+                if release:
+                    self.cs(1)
+                    self.spi.write(b"\xff")
+                return response
+
+        # timeout
+        self.cs(1)
+        self.spi.write(b"\xff")
+        return -1
+
+    def readinto(self, buf):
+        self.cs(0)
+
+        # read until start byte (0xff)
+        for i in range(_CMD_TIMEOUT):
+            self.spi.readinto(self.tokenbuf, 0xFF)
+            if self.tokenbuf[0] == _TOKEN_DATA:
+                break
+            time.sleep_ms(1)
+        else:
+            self.cs(1)
+            raise OSError("timeout waiting for response")
+
+        # read data
+        mv = self.dummybuf_memoryview
+        if len(buf) != len(mv):
+            mv = mv[: len(buf)]
+        self.spi.write_readinto(mv, buf)
+
+        # read checksum
+        self.spi.write(b"\xff")
+        self.spi.write(b"\xff")
+
+        self.cs(1)
+        self.spi.write(b"\xff")
+
+    def write(self, token, buf):
+        self.cs(0)
+
+        # send: start of block, data, checksum
+        self.spi.read(1, token)
+        self.spi.write(buf)
+        self.spi.write(b"\xff")
+        self.spi.write(b"\xff")
+
+        # check the response
+        if (self.spi.read(1, 0xFF)[0] & 0x1F) != 0x05:
+            self.cs(1)
+            self.spi.write(b"\xff")
+            return
+
+        # wait for write to finish
+        while self.spi.read(1, 0xFF)[0] == 0:
+            pass
+
+        self.cs(1)
+        self.spi.write(b"\xff")
+
+    def write_token(self, token):
+        self.cs(0)
+        self.spi.read(1, token)
+        self.spi.write(b"\xff")
+        # wait for write to finish
+        while self.spi.read(1, 0xFF)[0] == 0x00:
+            pass
+
+        self.cs(1)
+        self.spi.write(b"\xff")
+
+    def readblocks(self, block_num, buf):
+        nblocks = len(buf) // 512
+        assert nblocks and not len(buf) % 512, "Buffer length is invalid"
+        if nblocks == 1:
+            # CMD17: set read address for single block
+            if self.cmd(17, block_num * self.cdv, 0, release=False) != 0:
+                # release the card
+                self.cs(1)
+                raise OSError(5)  # EIO
+            # receive the data and release card
+            self.readinto(buf)
+        else:
+            # CMD18: set read address for multiple blocks
+            if self.cmd(18, block_num * self.cdv, 0, release=False) != 0:
+                # release the card
+                self.cs(1)
+                raise OSError(5)  # EIO
+            offset = 0
+            mv = memoryview(buf)
+            while nblocks:
+                # receive the data and release card
+                self.readinto(mv[offset : offset + 512])
+                offset += 512
+                nblocks -= 1
+            if self.cmd(12, 0, 0xFF, skip1=True):
+                raise OSError(5)  # EIO
+
+    def writeblocks(self, block_num, buf):
+        nblocks, err = divmod(len(buf), 512)
+        assert nblocks and not err, "Buffer length is invalid"
+        if nblocks == 1:
+            # CMD24: set write address for single block
+            if self.cmd(24, block_num * self.cdv, 0) != 0:
+                raise OSError(5)  # EIO
+
+            # send the data
+            self.write(_TOKEN_DATA, buf)
+        else:
+            # CMD25: set write address for first block
+            if self.cmd(25, block_num * self.cdv, 0) != 0:
+                raise OSError(5)  # EIO
+            # send the data
+            offset = 0
+            mv = memoryview(buf)
+            while nblocks:
+                self.write(_TOKEN_CMD25, mv[offset : offset + 512])
+                offset += 512
+                nblocks -= 1
+            self.write_token(_TOKEN_STOP_TRAN)
+
+    def ioctl(self, op, arg):
+        if op == 4:  # get number of blocks
+            return self.sectors
+        if op == 5:  # get block size in bytes
+            return 512

scripts/lib/sdl_demo_utils.py

@@ -0,0 +1,276 @@
+import json
+import sys
+from time import localtime, sleep, ticks_diff, ticks_ms  # type: ignore
+
+import uos
+from data_logging import (
+    get_local_timestamp,
+    get_onboard_temperature,
+    write_payload_backup,
+)
+from machine import PWM, Pin
+from ufastrsa.genprime import genrsa
+from ufastrsa.rsa import RSA
+from uio import StringIO
+
+
+def beep(buzzer, power=0.005):
+    buzzer.freq(300)
+    buzzer.duty_u16(round(65535 * power))
+    sleep(0.15)
+    buzzer.duty_u16(0)
+
+
+def get_traceback(err):
+    try:
+        with StringIO() as f:  # type: ignore
+            sys.print_exception(err, f)
+            return f.getvalue()
+    except Exception as err2:
+        print(err2)
+        return f"Failed to extract file and line number due to {err2}.\nOriginal error: {err}"  # noqa: E501
+
+
+def merge_two_dicts(x, y):
+    z = x.copy()  # start with keys and values of x
+    z.update(y)  # modifies z with keys and values of y
+    return z
+
+
+def path_exists(path):
+    # Check if path exists.
+    # Works for relative and absolute path.
+    parent = ""  # parent folder name
+    name = path  # name of file/folder
+
+    # Check if file/folder has a parent folder
+    index = path.rstrip("/").rfind("/")
+    if index >= 0:
+        index += 1
+        parent = path[: index - 1]
+        name = path[index:]
+
+    # Searching with iterator is more efficient if the parent contains lost of files/folders
+    # return name in uos.listdir(parent)
+    return any((name == x[0]) for x in uos.ilistdir(parent))
+
+
+def encrypt_id(my_id, verbose=False):
+    rsa_path = "rsa.json"
+    # if path_exists(rsa_path):
+    try:
+        with open(rsa_path, "r") as f:
+            cipher_data = json.load(f)
+            cipher = RSA(
+                cipher_data["bits"],
+                n=cipher_data["n"],
+                e=cipher_data["e"],
+                d=cipher_data["d"],
+            )
+    except (KeyError, OSError) as e:
+        print(e)
+        print("Generating new RSA parameters...")
+        bits = 256
+        bits, n, e, d = genrsa(bits, e=65537)  # type: ignore
+        cipher = RSA(bits, n=n, e=e, d=d)
+        with open("rsa.json", "w") as f:
+            json.dump(dict(bits=bits, n=n, e=e, d=d), f)
+
+    if verbose:
+        with open(rsa_path, "r") as f:
+            cipher_data = json.load(f)
+            print("RSA parameters (keep private):")
+            print(cipher_data)
+
+    my_id = int.from_bytes(cipher.pkcs_encrypt(my_id), "big")
+    return my_id
+
+
+def decrypt_id(my_id):
+    rsa_path = "rsa.json"
+    if path_exists(rsa_path):
+        with open(rsa_path, "r") as f:
+            cipher_data = json.load(f)
+            cipher = RSA(
+                cipher_data["bits"],
+                n=cipher_data["n"],
+                e=cipher_data["e"],
+                d=cipher_data["d"],
+            )
+    else:
+        bits = 256
+        bits, n, e, d = genrsa(bits, e=65537)  # type: ignore
+        cipher = RSA(bits, n=n, e=e, d=d)
+        with open("rsa.json", "w") as f:
+            json.dump(dict(bits=bits, n=n, e=e, d=d), f)
+
+    my_id = int.from_bytes(cipher.pkcs_decrypt(my_id), "big")
+    return my_id
+
+
+def get_onboard_led():
+    try:
+        onboard_led = Pin("LED", Pin.OUT)  # only works for Pico W
+    except Exception as e:
+        print(e)
+        onboard_led = Pin(25, Pin.OUT)
+    return onboard_led
+
+
+class Experiment(object):
+    def __init__(
+        self,
+        run_experiment_fn,
+        devices,
+        reset_experiment_fn=None,
+        validate_inputs_fn=None,
+        emergency_shutdown_fn=None,
+        buzzer=None,
+        sdcard_ready=False,
+    ) -> None:
+        self.validate_inputs_fn = validate_inputs_fn
+        self.run_experiment_fn = run_experiment_fn
+        self.reset_experiment_fn = reset_experiment_fn
+        self.devices = devices
+        self.emergency_shutdown_fn = emergency_shutdown_fn
+        self.buzzer = buzzer
+        self.sdcard_ready = sdcard_ready
+
+        if self.reset_experiment_fn is None:
+
+            def do_nothing(*args, **kwargs):
+                pass
+
+            self.reset_experiment_fn = do_nothing
+
+        if self.emergency_shutdown_fn is None:
+            self.emergency_shutdown_fn = self.reset_experiment_fn
+
+        if self.validate_inputs_fn is None:
+
+            def no_input_validation(*args, **kwargs):
+                return True
+
+            self.validate_inputs_fn = no_input_validation
+
+        if self.buzzer is None:
+            self.buzzer = PWM(Pin(18))
+
+    def try_experiment(self, msg):
+        payload_data = {}
+        # # pin numbers not used here, but can help with organization for complex tasks
+        # p = int(t[5:])  # pin number
+
+        print(msg)
+
+        # careful not to throw an unrecoverable error due to bad request
+        # Perform the experiment and record the results
+        try:
+            parameters = json.loads(msg)
+            payload_data["_input_message"] = parameters
+
+            # don't allow access to hardware if any input values are out of bounds
+            self.validate_inputs_fn(parameters)  # type: ignore
+
+            beep(self.buzzer)
+            sensor_data = self.run_experiment_fn(parameters, self.devices)
+            payload_data = merge_two_dicts(payload_data, sensor_data)
+
+        except Exception as err:
+            print(err)
+            if "_input_message" not in payload_data.keys():
+                payload_data["_input_message"] = msg
+            payload_data["error"] = get_traceback(err)
+
+        try:
+            payload_data["onboard_temperature_K"] = get_onboard_temperature(unit="K")
+            payload_data["sd_card_ready"] = self.sdcard_ready
+            stamp, time_str = get_local_timestamp(return_str=True)  # type: ignore
+            payload_data["utc_timestamp"] = stamp
+            payload_data["utc_time_str"] = time_str
+        except OverflowError as e:
+            print(get_traceback(e))
+        except Exception as e:
+            print(get_traceback(e))
+
+        try:
+            parameters = json.loads(msg)
+            self.reset_experiment_fn(parameters, devices=self.devices)  # type: ignore
+        except Exception as e:
+            try:
+                self.emergency_shutdown_fn(devices=self.devices)  # type: ignore
+                payload_data["reset_error"] = get_traceback(e)
+            except Exception as e:
+                payload_data["emergency_error"] = get_traceback(e)
+
+        return payload_data
+
+    def write_to_sd_card(self, payload_data, fpath="/sd/experiments.txt"):
+        try:
+            write_payload_backup(payload_data, fpath=fpath)
+        except Exception as e:
+            w = f"Failed to write to SD card: {get_traceback(e)}"
+            print(w)
+            payload_data["warning"] = w
+
+        return payload_data
+
+    # def log_to_mongodb(
+    #     self,
+    #     payload_data,
+    #     api_key: str,
+    #     url: str,
+    #     cluster_name: str,
+    #     database_name: str,
+    #     collection_name: str,
+    #     verbose: bool = True,
+    #     retries: int = 2,
+    # ):
+    #     try:
+    #         log_to_mongodb(
+    #             payload_data,
+    #             url=url,
+    #             api_key=api_key,
+    #             cluster_name=cluster_name,
+    #             database_name=database_name,
+    #             collection_name=collection_name,
+    #             verbose=verbose,
+    #             retries=retries,
+    #         )
+    #     except Exception as e:
+    #         print(f"Failed to log to MongoDB backend: {get_traceback(e)}")
+
+
+def heartbeat(client, first, ping_interval_ms=15000):
+    global lastping
+    if first:
+        client.ping()
+        lastping = ticks_ms()
+    if ticks_diff(ticks_ms(), lastping) >= ping_interval_ms:
+        client.ping()
+        lastping = ticks_ms()
+    return
+
+
+def sign_of_life(led, first, blink_interval_ms=5000):
+    global last_blink
+    if first:
+        led.on()
+        last_blink = ticks_ms()
+    time_since = ticks_diff(ticks_ms(), last_blink)
+    if led.value() == 0 and time_since >= blink_interval_ms:
+        led.toggle()
+        last_blink = ticks_ms()
+    elif led.value() == 1 and time_since >= 500:
+        led.toggle()
+        last_blink = ticks_ms()
+
+
+class DummyMotor:
+    def __init__(self):
+        pass
+
+
+class DummySensor:
+    def __init__(self):
+        pass

scripts/lib/smbus2-0.5.0.dist-info/METADATA

@@ -0,0 +1,234 @@
+Metadata-Version: 2.1
+Name: smbus2
+Version: 0.5.0
+Summary: smbus2 is a drop-in replacement for smbus-cffi/smbus-python in pure Python
+Home-page: https://github.com/kplindegaard/smbus2
+Author: Karl-Petter Lindegaard
+Author-email: kp.lindegaard@gmail.com
+License: MIT
+Keywords: smbus,smbus2,python,i2c,raspberrypi,linux
+Classifier: Development Status :: 4 - Beta
+Classifier: Topic :: Utilities
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: docs
+Requires-Dist: sphinx>=1.5.3; extra == "docs"
+Provides-Extra: qa
+Requires-Dist: flake8; extra == "qa"
+
+# smbus2
+A drop-in replacement for smbus-cffi/smbus-python in pure Python
+
+[![Build Status](https://github.com/kplindegaard/smbus2/actions/workflows/python-build-test.yml/badge.svg?branch=master)](https://github.com/kplindegaard/smbus2/actions/workflows/python-build-test.yml)
+[![Documentation Status](https://readthedocs.org/projects/smbus2/badge/?version=latest)](http://smbus2.readthedocs.io/en/latest/?badge=latest)
+![CodeQL](https://github.com/kplindegaard/smbus2/actions/workflows/codeql-analysis.yml/badge.svg?branch=master)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=kplindegaard_smbus2&metric=alert_status)](https://sonarcloud.io/dashboard?id=kplindegaard_smbus2)
+
+![Python Verions](https://img.shields.io/pypi/pyversions/smbus2.svg)
+[![PyPi Version](https://img.shields.io/pypi/v/smbus2.svg)](https://pypi.org/project/smbus2/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/smbus2)](https://pypi.org/project/smbus2/)
+
+# Introduction
+
+smbus2 is (yet another) pure Python implementation of the [python-smbus](http://www.lm-sensors.org/browser/i2c-tools/trunk/py-smbus/) package.
+
+It was designed from the ground up with two goals in mind:
+
+1. It should be a drop-in replacement of smbus. The syntax shall be the same.
+2. Use the inherent i2c structs and unions to a greater extent than other pure Python implementations like [pysmbus](https://github.com/bjornt/pysmbus) does. By doing so, it will be more feature complete and easier to extend.
+
+Currently supported features are:
+
+* Get i2c capabilities (I2C_FUNCS)
+* SMBus Packet Error Checking (PEC) support
+* read_byte
+* write_byte
+* read_byte_data
+* write_byte_data
+* read_word_data
+* write_word_data
+* read_i2c_block_data
+* write_i2c_block_data
+* write_quick
+* process_call
+* read_block_data
+* write_block_data
+* block_process_call
+* i2c_rdwr - *combined write/read transactions with repeated start*
+
+It is developed on Python 2.7 but works without any modifications in Python 3.X too.
+
+More information about updates and general changes are recorded in the [change log](https://github.com/kplindegaard/smbus2/blob/master/CHANGELOG.md).
+
+# SMBus code examples
+
+smbus2 installs next to smbus as the package, so it's not really a 100% replacement. You must change the module name.
+
+## Example 1a: Read a byte
+
+```python
+from smbus2 import SMBus
+
+# Open i2c bus 1 and read one byte from address 80, offset 0
+bus = SMBus(1)
+b = bus.read_byte_data(80, 0)
+print(b)
+bus.close()
+```
+
+## Example 1b: Read a byte using 'with'
+
+This is the very same example but safer to use since the smbus will be closed automatically when exiting the with block.
+
+```python
+from smbus2 import SMBus
+
+with SMBus(1) as bus:
+    b = bus.read_byte_data(80, 0)
+    print(b)
+```
+
+## Example 1c: Read a byte with PEC enabled
+
+Same example with Packet Error Checking enabled.
+
+```python
+from smbus2 import SMBus
+
+with SMBus(1) as bus:
+    bus.pec = 1  # Enable PEC
+    b = bus.read_byte_data(80, 0)
+    print(b)
+```
+
+## Example 2: Read a block of data
+
+You can read up to 32 bytes at once.
+
+```python
+from smbus2 import SMBus
+
+with SMBus(1) as bus:
+    # Read a block of 16 bytes from address 80, offset 0
+    block = bus.read_i2c_block_data(80, 0, 16)
+    # Returned value is a list of 16 bytes
+    print(block)
+```
+
+## Example 3: Write a byte
+
+```python
+from smbus2 import SMBus
+
+with SMBus(1) as bus:
+    # Write a byte to address 80, offset 0
+    data = 45
+    bus.write_byte_data(80, 0, data)
+```
+
+## Example 4: Write a block of data
+
+It is possible to write 32 bytes at the time, but I have found that error-prone. Write less and add a delay in between if you run into trouble.
+
+```python
+from smbus2 import SMBus
+
+with SMBus(1) as bus:
+    # Write a block of 8 bytes to address 80 from offset 0
+    data = [1, 2, 3, 4, 5, 6, 7, 8]
+    bus.write_i2c_block_data(80, 0, data)
+```
+
+# I2C
+
+Starting with v0.2, the smbus2 library also has support for combined read and write transactions. *i2c_rdwr* is not really a SMBus feature but comes in handy when the master needs to:
+
+1. read or write bulks of data larger than SMBus' 32 bytes limit.
+1. write some data and then read from the slave with a repeated start and no stop bit between.
+
+Each operation is represented by a *i2c_msg* message object.
+
+
+## Example 5: Single i2c_rdwr
+
+```python
+from smbus2 import SMBus, i2c_msg
+
+with SMBus(1) as bus:
+    # Read 64 bytes from address 80
+    msg = i2c_msg.read(80, 64)
+    bus.i2c_rdwr(msg)
+    
+    # Write a single byte to address 80
+    msg = i2c_msg.write(80, [65])
+    bus.i2c_rdwr(msg)
+    
+    # Write some bytes to address 80
+    msg = i2c_msg.write(80, [65, 66, 67, 68])
+    bus.i2c_rdwr(msg)
+```
+
+## Example 6: Dual i2c_rdwr
+
+To perform dual operations just add more i2c_msg instances to the bus call:
+
+```python
+from smbus2 import SMBus, i2c_msg
+
+# Single transaction writing two bytes then read two at address 80
+write = i2c_msg.write(80, [40, 50])
+read = i2c_msg.read(80, 2)
+with SMBus(1) as bus:
+    bus.i2c_rdwr(write, read)
+```
+
+## Example 7: Access i2c_msg data
+
+All data is contained in the i2c_msg instances. Here are some data access alternatives.
+
+```python
+# 1: Convert message content to list
+msg = i2c_msg.write(60, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+data = list(msg)  # data = [1, 2, 3, ...]
+print(len(data))  # => 10
+
+# 2: i2c_msg is iterable
+for value in msg:
+    print(value)
+
+# 3: Through i2c_msg properties
+for k in range(msg.len):
+    print(msg.buf[k])
+```
+
+# Installation instructions
+
+From [PyPi](https://pypi.org/) with `pip`:
+
+```
+pip install smbus2
+```
+
+From [conda-forge](https://anaconda.org/conda-forge) using `conda`:
+
+```
+conda install -c conda-forge smbus2
+```
+
+Installation from source code is straight forward:
+
+```
+python setup.py install
+```

scripts/lib/smbus2-0.5.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+smbus2-0.5.0.dist-info/METADATA,,
+smbus2/__init__.py,,
+smbus2/py.typed,,
+smbus2/smbus2.py,,
+smbus2/smbus2.pyi,,
+smbus2-0.5.0.dist-info/RECORD,,

scripts/lib/smbus2/__init__.py

@@ -0,0 +1,26 @@
+"""smbus2 - A drop-in replacement for smbus-cffi/smbus-python"""
+# The MIT License (MIT)
+# Copyright (c) 2020 Karl-Petter Lindegaard
+#
+# 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.
+
+from .smbus2 import SMBus, i2c_msg, I2cFunc  # noqa: F401
+
+__version__ = "0.5.0"
+__all__ = ["SMBus", "i2c_msg", "I2cFunc"]

scripts/lib/smbus2/smbus2.py

@@ -0,0 +1,660 @@
+"""smbus2 - A drop-in replacement for smbus-cffi/smbus-python"""
+# The MIT License (MIT)
+# Copyright (c) 2020 Karl-Petter Lindegaard
+#
+# 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 os
+import sys
+from fcntl import ioctl
+from ctypes import c_uint32, c_uint8, c_uint16, c_char, POINTER, Structure, Array, Union, create_string_buffer, string_at
+
+
+# Commands from uapi/linux/i2c-dev.h
+I2C_SLAVE = 0x0703  # Use this slave address
+I2C_SLAVE_FORCE = 0x0706  # Use this slave address, even if it is already in use by a driver!
+I2C_FUNCS = 0x0705  # Get the adapter functionality mask
+I2C_RDWR = 0x0707  # Combined R/W transfer (one STOP only)
+I2C_SMBUS = 0x0720  # SMBus transfer. Takes pointer to i2c_smbus_ioctl_data
+I2C_PEC = 0x0708  # != 0 to use PEC with SMBus
+
+# SMBus transfer read or write markers from uapi/linux/i2c.h
+I2C_SMBUS_WRITE = 0
+I2C_SMBUS_READ = 1
+
+# Size identifiers uapi/linux/i2c.h
+I2C_SMBUS_QUICK = 0
+I2C_SMBUS_BYTE = 1
+I2C_SMBUS_BYTE_DATA = 2
+I2C_SMBUS_WORD_DATA = 3
+I2C_SMBUS_PROC_CALL = 4
+I2C_SMBUS_BLOCK_DATA = 5  # This isn't supported by Pure-I2C drivers with SMBUS emulation, like those in RaspberryPi, OrangePi, etc :(
+I2C_SMBUS_BLOCK_PROC_CALL = 7  # Like I2C_SMBUS_BLOCK_DATA, it isn't supported by Pure-I2C drivers either.
+I2C_SMBUS_I2C_BLOCK_DATA = 8
+I2C_SMBUS_BLOCK_MAX = 32
+
+# To determine what functionality is present (uapi/linux/i2c.h)
+try:
+    from enum import IntFlag
+except ImportError:
+    IntFlag = int
+
+
+class I2cFunc(IntFlag):
+    """
+    These flags identify the operations supported by an I2C/SMBus device.
+
+    You can test these flags on your `smbus.funcs`
+
+    On newer python versions, I2cFunc is an IntFlag enum, but it
+    falls back to class with a bunch of int constants on older releases.
+    """
+    I2C = 0x00000001
+    ADDR_10BIT = 0x00000002
+    PROTOCOL_MANGLING = 0x00000004  # I2C_M_IGNORE_NAK etc.
+    SMBUS_PEC = 0x00000008
+    NOSTART = 0x00000010  # I2C_M_NOSTART
+    SLAVE = 0x00000020
+    SMBUS_BLOCK_PROC_CALL = 0x00008000  # SMBus 2.0
+    SMBUS_QUICK = 0x00010000
+    SMBUS_READ_BYTE = 0x00020000
+    SMBUS_WRITE_BYTE = 0x00040000
+    SMBUS_READ_BYTE_DATA = 0x00080000
+    SMBUS_WRITE_BYTE_DATA = 0x00100000
+    SMBUS_READ_WORD_DATA = 0x00200000
+    SMBUS_WRITE_WORD_DATA = 0x00400000
+    SMBUS_PROC_CALL = 0x00800000
+    SMBUS_READ_BLOCK_DATA = 0x01000000
+    SMBUS_WRITE_BLOCK_DATA = 0x02000000
+    SMBUS_READ_I2C_BLOCK = 0x04000000  # I2C-like block xfer
+    SMBUS_WRITE_I2C_BLOCK = 0x08000000  # w/ 1-byte reg. addr.
+    SMBUS_HOST_NOTIFY = 0x10000000
+
+    SMBUS_BYTE = 0x00060000
+    SMBUS_BYTE_DATA = 0x00180000
+    SMBUS_WORD_DATA = 0x00600000
+    SMBUS_BLOCK_DATA = 0x03000000
+    SMBUS_I2C_BLOCK = 0x0c000000
+    SMBUS_EMUL = 0x0eff0008
+
+
+# i2c_msg flags from uapi/linux/i2c.h
+I2C_M_RD = 0x0001
+
+# Pointer definitions
+LP_c_uint8 = POINTER(c_uint8)
+LP_c_uint16 = POINTER(c_uint16)
+LP_c_uint32 = POINTER(c_uint32)
+
+
+#############################################################
+# Type definitions as in i2c.h
+
+
+class i2c_smbus_data(Array):
+    """
+    Adaptation of the i2c_smbus_data union in ``i2c.h``.
+
+    Data for SMBus messages.
+    """
+    _length_ = I2C_SMBUS_BLOCK_MAX + 2
+    _type_ = c_uint8
+
+
+class union_i2c_smbus_data(Union):
+    _fields_ = [
+        ("byte", c_uint8),
+        ("word", c_uint16),
+        ("block", i2c_smbus_data)
+    ]
+
+
+union_pointer_type = POINTER(union_i2c_smbus_data)
+
+
+class i2c_smbus_ioctl_data(Structure):
+    """
+    As defined in ``i2c-dev.h``.
+    """
+    _fields_ = [
+        ('read_write', c_uint8),
+        ('command', c_uint8),
+        ('size', c_uint32),
+        ('data', union_pointer_type)]
+    __slots__ = [name for name, type in _fields_]
+
+    @staticmethod
+    def create(read_write=I2C_SMBUS_READ, command=0, size=I2C_SMBUS_BYTE_DATA):
+        u = union_i2c_smbus_data()
+        return i2c_smbus_ioctl_data(
+            read_write=read_write, command=command, size=size,
+            data=union_pointer_type(u))
+
+
+#############################################################
+# Type definitions for i2c_rdwr combined transactions
+
+
+class i2c_msg(Structure):
+    """
+    As defined in ``i2c.h``.
+    """
+    _fields_ = [
+        ('addr', c_uint16),
+        ('flags', c_uint16),
+        ('len', c_uint16),
+        ('buf', POINTER(c_char))]
+
+    def __iter__(self):
+        """ Iterator / Generator
+
+        :return: iterates over :py:attr:`buf`
+        :rtype: :py:class:`generator` which returns int values
+        """
+        idx = 0
+        while idx < self.len:
+            yield ord(self.buf[idx])
+            idx += 1
+
+    def __len__(self):
+        return self.len
+
+    def __bytes__(self):
+        return string_at(self.buf, self.len)
+
+    def __repr__(self):
+        return 'i2c_msg(%d,%d,%r)' % (self.addr, self.flags, self.__bytes__())
+
+    def __str__(self):
+        s = self.__bytes__()
+        # Throw away non-decodable bytes
+        s = s.decode(errors="ignore")
+        return s
+
+    @staticmethod
+    def read(address, length):
+        """
+        Prepares an i2c read transaction.
+
+        :param address: Slave address.
+        :type address: int
+        :param length: Number of bytes to read.
+        :type length: int
+        :return: New :py:class:`i2c_msg` instance for read operation.
+        :rtype: :py:class:`i2c_msg`
+        """
+        arr = create_string_buffer(length)
+        return i2c_msg(
+            addr=address, flags=I2C_M_RD, len=length,
+            buf=arr)
+
+    @staticmethod
+    def write(address, buf):
+        """
+        Prepares an i2c write transaction.
+
+        :param address: Slave address.
+        :type address: int
+        :param buf: Bytes to write. Either list of values or str.
+        :type buf: list
+        :return: New :py:class:`i2c_msg` instance for write operation.
+        :rtype: :py:class:`i2c_msg`
+        """
+        if sys.version_info.major >= 3:
+            if type(buf) is str:
+                buf = bytes(map(ord, buf))
+            else:
+                buf = bytes(buf)
+        else:
+            if type(buf) is not str:
+                buf = ''.join([chr(x) for x in buf])
+        arr = create_string_buffer(buf, len(buf))
+        return i2c_msg(
+            addr=address, flags=0, len=len(arr),
+            buf=arr)
+
+
+class i2c_rdwr_ioctl_data(Structure):
+    """
+    As defined in ``i2c-dev.h``.
+    """
+    _fields_ = [
+        ('msgs', POINTER(i2c_msg)),
+        ('nmsgs', c_uint32)
+    ]
+    __slots__ = [name for name, type in _fields_]
+
+    @staticmethod
+    def create(*i2c_msg_instances):
+        """
+        Factory method for creating a i2c_rdwr_ioctl_data struct that can
+        be called with ``ioctl(fd, I2C_RDWR, data)``.
+
+        :param i2c_msg_instances: Up to 42 i2c_msg instances
+        :rtype: i2c_rdwr_ioctl_data
+        """
+        n_msg = len(i2c_msg_instances)
+        msg_array = (i2c_msg * n_msg)(*i2c_msg_instances)
+        return i2c_rdwr_ioctl_data(
+            msgs=msg_array,
+            nmsgs=n_msg
+        )
+
+
+#############################################################
+
+
+class SMBus(object):
+
+    def __init__(self, bus=None, force=False):
+        """
+        Initialize and (optionally) open an i2c bus connection.
+
+        :param bus: i2c bus number (e.g. 0 or 1)
+            or an absolute file path (e.g. `/dev/i2c-42`).
+            If not given, a subsequent  call to ``open()`` is required.
+        :type bus: int or str
+        :param force: force using the slave address even when driver is
+            already using it.
+        :type force: boolean
+        """
+        self.fd = None
+        self.funcs = I2cFunc(0)
+        if bus is not None:
+            self.open(bus)
+        self.address = None
+        self.force = force
+        self._force_last = None
+        self._pec = 0
+
+    def __enter__(self):
+        """Enter handler."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Exit handler."""
+        self.close()
+
+    def open(self, bus):
+        """
+        Open a given i2c bus.
+
+        :param bus: i2c bus number (e.g. 0 or 1)
+            or an absolute file path (e.g. '/dev/i2c-42').
+        :type bus: int or str
+        :raise TypeError: if type(bus) is not in (int, str)
+        """
+        if isinstance(bus, int):
+            filepath = "/dev/i2c-{}".format(bus)
+        elif isinstance(bus, str):
+            filepath = bus
+        else:
+            raise TypeError("Unexpected type(bus)={}".format(type(bus)))
+
+        self.fd = os.open(filepath, os.O_RDWR)
+        self.funcs = self._get_funcs()
+
+    def close(self):
+        """
+        Close the i2c connection.
+        """
+        if self.fd:
+            os.close(self.fd)
+            self.fd = None
+            self._pec = 0
+            self.address = None
+            self._force_last = None
+
+    def _get_pec(self):
+        return self._pec
+
+    def enable_pec(self, enable=True):
+        """
+        Enable/Disable PEC (Packet Error Checking) - SMBus 1.1 and later
+
+        :param enable:
+        :type enable: Boolean
+        """
+        if not (self.funcs & I2cFunc.SMBUS_PEC):
+            raise IOError('SMBUS_PEC is not a feature')
+        self._pec = int(enable)
+        ioctl(self.fd, I2C_PEC, self._pec)
+
+    pec = property(_get_pec, enable_pec)  # Drop-in replacement for smbus member "pec"
+    """Get and set SMBus PEC. 0 = disabled (default), 1 = enabled."""
+
+    def _set_address(self, address, force=None):
+        """
+        Set i2c slave address to use for subsequent calls.
+
+        :param address:
+        :type address: int
+        :param force:
+        :type force: Boolean
+        """
+        force = force if force is not None else self.force
+        if self.address != address or self._force_last != force:
+            if force is True:
+                ioctl(self.fd, I2C_SLAVE_FORCE, address)
+            else:
+                ioctl(self.fd, I2C_SLAVE, address)
+            self.address = address
+            self._force_last = force
+
+    def _get_funcs(self):
+        """
+        Returns a 32-bit value stating supported I2C functions.
+
+        :rtype: int
+        """
+        f = c_uint32()
+        ioctl(self.fd, I2C_FUNCS, f)
+        return f.value
+
+    def write_quick(self, i2c_addr, force=None):
+        """
+        Perform quick transaction. Throws IOError if unsuccessful.
+        :param i2c_addr: i2c address
+        :type i2c_addr: int
+        :param force:
+        :type force: Boolean
+        """
+        self._set_address(i2c_addr, force=force)
+        msg = i2c_smbus_ioctl_data.create(
+            read_write=I2C_SMBUS_WRITE, command=0, size=I2C_SMBUS_QUICK)
+        ioctl(self.fd, I2C_SMBUS, msg)
+
+    def read_byte(self, i2c_addr, force=None):
+        """
+        Read a single byte from a device.
+
+        :rtype: int
+        :param i2c_addr: i2c address
+        :type i2c_addr: int
+        :param force:
+        :type force: Boolean
+        :return: Read byte value
+        """
+        self._set_address(i2c_addr, force=force)
+        msg = i2c_smbus_ioctl_data.create(
+            read_write=I2C_SMBUS_READ, command=0, size=I2C_SMBUS_BYTE
+        )
+        ioctl(self.fd, I2C_SMBUS, msg)
+        return msg.data.contents.byte
+
+    def write_byte(self, i2c_addr, value, force=None):
+        """
+        Write a single byte to a device.
+
+        :param i2c_addr: i2c address
+        :type i2c_addr: int
+        :param value: value to write
+        :type value: int
+        :param force:
+        :type force: Boolean
+        """
+        self._set_address(i2c_addr, force=force)
+        msg = i2c_smbus_ioctl_data.create(
+            read_write=I2C_SMBUS_WRITE, command=value, size=I2C_SMBUS_BYTE
+        )
+        ioctl(self.fd, I2C_SMBUS, msg)
+
+    def read_byte_data(self, i2c_addr, register, force=None):
+        """
+        Read a single byte from a designated register.
+
+        :param i2c_addr: i2c address
+        :type i2c_addr: int
+        :param register: Register to read
+        :type register: int
+        :param force:
+        :type force: Boolean
+        :return: Read byte value
+        :rtype: int
+        """
+        self._set_address(i2c_addr, force=force)
+        msg = i2c_smbus_ioctl_data.create(
+            read_write=I2C_SMBUS_READ, command=register, size=I2C_SMBUS_BYTE_DATA
+        )
+        ioctl(self.fd, I2C_SMBUS, msg)
+        return msg.data.contents.byte
+
+    def write_byte_data(self, i2c_addr, register, value, force=None):
+        """
+        Write a byte to a given register.
+
+        :param i2c_addr: i2c address
+        :type i2c_addr: int
+        :param register: Register to write to
+        :type register: int
+        :param value: Byte value to transmit
+        :type value: int
+        :param force:
+        :type force: Boolean
+        :rtype: None
+        """
+        self._set_address(i2c_addr, force=force)
+        msg = i2c_smbus_ioctl_data.create(
+            read_write=I2C_SMBUS_WRITE, command=register, size=I2C_SMBUS_BYTE_DATA
+        )
+        msg.data.contents.byte = value
+        ioctl(self.fd, I2C_SMBUS, msg)
+
+    def read_word_data(self, i2c_addr, register, force=None):
+        """
+        Read a single word (2 bytes) from a given register.
+
+        :param i2c_addr: i2c address
+        :type i2c_addr: int
+        :param register: Register to read
+        :type register: int
+        :param force:
+        :type force: Boolean
+        :return: 2-byte word
+        :rtype: int
+        """
+        self._set_address(i2c_addr, force=force)
+        msg = i2c_smbus_ioctl_data.create(
+            read_write=I2C_SMBUS_READ, command=register, size=I2C_SMBUS_WORD_DATA
+        )
+        ioctl(self.fd, I2C_SMBUS, msg)
+        return msg.data.contents.word
+
+    def write_word_data(self, i2c_addr, register, value, force=None):
+        """
+        Write a single word (2 bytes) to a given register.
+
+        :param i2c_addr: i2c address
+        :type i2c_addr: int
+        :param register: Register to write to
+        :type register: int
+        :param value: Word value to transmit
+        :type value: int
+        :param force:
+        :type force: Boolean
+        :rtype: None
+        """
+        self._set_address(i2c_addr, force=force)
+        msg = i2c_smbus_ioctl_data.create(
+            read_write=I2C_SMBUS_WRITE, command=register, size=I2C_SMBUS_WORD_DATA
+        )
+        msg.data.contents.word = value
+        ioctl(self.fd, I2C_SMBUS, msg)
+
+    def process_call(self, i2c_addr, register, value, force=None):
+        """
+        Executes a SMBus Process Call, sending a 16-bit value and receiving a 16-bit response
+
+        :param i2c_addr: i2c address
+        :type i2c_addr: int
+        :param register: Register to read/write to
+        :type register: int
+        :param value: Word value to transmit
+        :type value: int
+        :param force:
+        :type force: Boolean
+        :rtype: int
+        """
+        self._set_address(i2c_addr, force=force)
+        msg = i2c_smbus_ioctl_data.create(
+            read_write=I2C_SMBUS_WRITE, command=register, size=I2C_SMBUS_PROC_CALL
+        )
+        msg.data.contents.word = value
+        ioctl(self.fd, I2C_SMBUS, msg)
+        return msg.data.contents.word
+
+    def read_block_data(self, i2c_addr, register, force=None):
+        """
+        Read a block of up to 32-bytes from a given register.
+
+        :param i2c_addr: i2c address
+        :type i2c_addr: int
+        :param register: Start register
+        :type register: int
+        :param force:
+        :type force: Boolean
+        :return: List of bytes
+        :rtype: list
+        """
+        self._set_address(i2c_addr, force=force)
+        msg = i2c_smbus_ioctl_data.create(
+            read_write=I2C_SMBUS_READ, command=register, size=I2C_SMBUS_BLOCK_DATA
+        )
+        ioctl(self.fd, I2C_SMBUS, msg)
+        length = msg.data.contents.block[0]
+        return msg.data.contents.block[1:length + 1]
+
+    def write_block_data(self, i2c_addr, register, data, force=None):
+        """
+        Write a block of byte data to a given register.
+
+        :param i2c_addr: i2c address
+        :type i2c_addr: int
+        :param register: Start register
+        :type register: int
+        :param data: List of bytes
+        :type data: list
+        :param force:
+        :type force: Boolean
+        :rtype: None
+        """
+        length = len(data)
+        if length > I2C_SMBUS_BLOCK_MAX:
+            raise ValueError("Data length cannot exceed %d bytes" % I2C_SMBUS_BLOCK_MAX)
+        self._set_address(i2c_addr, force=force)
+        msg = i2c_smbus_ioctl_data.create(
+            read_write=I2C_SMBUS_WRITE, command=register, size=I2C_SMBUS_BLOCK_DATA
+        )
+        msg.data.contents.block[0] = length
+        msg.data.contents.block[1:length + 1] = data
+        ioctl(self.fd, I2C_SMBUS, msg)
+
+    def block_process_call(self, i2c_addr, register, data, force=None):
+        """
+        Executes a SMBus Block Process Call, sending a variable-size data
+        block and receiving another variable-size response
+
+        :param i2c_addr: i2c address
+        :type i2c_addr: int
+        :param register: Register to read/write to
+        :type register: int
+        :param data: List of bytes
+        :type data: list
+        :param force:
+        :type force: Boolean
+        :return: List of bytes
+        :rtype: list
+        """
+        length = len(data)
+        if length > I2C_SMBUS_BLOCK_MAX:
+            raise ValueError("Data length cannot exceed %d bytes" % I2C_SMBUS_BLOCK_MAX)
+        self._set_address(i2c_addr, force=force)
+        msg = i2c_smbus_ioctl_data.create(
+            read_write=I2C_SMBUS_WRITE, command=register, size=I2C_SMBUS_BLOCK_PROC_CALL
+        )
+        msg.data.contents.block[0] = length
+        msg.data.contents.block[1:length + 1] = data
+        ioctl(self.fd, I2C_SMBUS, msg)
+        length = msg.data.contents.block[0]
+        return msg.data.contents.block[1:length + 1]
+
+    def read_i2c_block_data(self, i2c_addr, register, length, force=None):
+        """
+        Read a block of byte data from a given register.
+
+        :param i2c_addr: i2c address
+        :type i2c_addr: int
+        :param register: Start register
+        :type register: int
+        :param length: Desired block length
+        :type length: int
+        :param force:
+        :type force: Boolean
+        :return: List of bytes
+        :rtype: list
+        """
+        if length > I2C_SMBUS_BLOCK_MAX:
+            raise ValueError("Desired block length over %d bytes" % I2C_SMBUS_BLOCK_MAX)
+        self._set_address(i2c_addr, force=force)
+        msg = i2c_smbus_ioctl_data.create(
+            read_write=I2C_SMBUS_READ, command=register, size=I2C_SMBUS_I2C_BLOCK_DATA
+        )
+        msg.data.contents.byte = length
+        ioctl(self.fd, I2C_SMBUS, msg)
+        return msg.data.contents.block[1:length + 1]
+
+    def write_i2c_block_data(self, i2c_addr, register, data, force=None):
+        """
+        Write a block of byte data to a given register.
+
+        :param i2c_addr: i2c address
+        :type i2c_addr: int
+        :param register: Start register
+        :type register: int
+        :param data: List of bytes
+        :type data: list
+        :param force:
+        :type force: Boolean
+        :rtype: None
+        """
+        length = len(data)
+        if length > I2C_SMBUS_BLOCK_MAX:
+            raise ValueError("Data length cannot exceed %d bytes" % I2C_SMBUS_BLOCK_MAX)
+        self._set_address(i2c_addr, force=force)
+        msg = i2c_smbus_ioctl_data.create(
+            read_write=I2C_SMBUS_WRITE, command=register, size=I2C_SMBUS_I2C_BLOCK_DATA
+        )
+        msg.data.contents.block[0] = length
+        msg.data.contents.block[1:length + 1] = data
+        ioctl(self.fd, I2C_SMBUS, msg)
+
+    def i2c_rdwr(self, *i2c_msgs):
+        """
+        Combine a series of i2c read and write operations in a single
+        transaction (with repeated start bits but no stop bits in between).
+
+        This method takes i2c_msg instances as input, which must be created
+        first with :py:meth:`i2c_msg.read` or :py:meth:`i2c_msg.write`.
+
+        :param i2c_msgs: One or more i2c_msg class instances.
+        :type i2c_msgs: i2c_msg
+        :rtype: None
+        """
+        ioctl_data = i2c_rdwr_ioctl_data.create(*i2c_msgs)
+        ioctl(self.fd, I2C_RDWR, ioctl_data)

scripts/lib/smbus2/smbus2.pyi

@@ -0,0 +1,148 @@
+from enum import IntFlag
+from typing import Optional, Sequence, List, Type, SupportsBytes, Iterable
+from typing import Union as _UnionT
+from types import TracebackType
+from ctypes import c_uint32, c_uint8, c_uint16, pointer, Structure, Array, Union
+
+I2C_SLAVE: int
+I2C_SLAVE_FORCE: int
+I2C_FUNCS: int
+I2C_RDWR: int
+I2C_SMBUS: int
+I2C_PEC: int
+I2C_SMBUS_WRITE: int
+I2C_SMBUS_READ: int
+I2C_SMBUS_QUICK: int
+I2C_SMBUS_BYTE: int
+I2C_SMBUS_BYTE_DATA: int
+I2C_SMBUS_WORD_DATA: int
+I2C_SMBUS_PROC_CALL: int
+I2C_SMBUS_BLOCK_DATA: int
+I2C_SMBUS_BLOCK_PROC_CALL: int
+I2C_SMBUS_I2C_BLOCK_DATA: int
+I2C_SMBUS_BLOCK_MAX: int
+
+class I2cFunc(IntFlag):
+    I2C = ...
+    ADDR_10BIT = ...
+    PROTOCOL_MANGLING = ...
+    SMBUS_PEC = ...
+    NOSTART = ...
+    SLAVE = ...
+    SMBUS_BLOCK_PROC_CALL = ...
+    SMBUS_QUICK = ...
+    SMBUS_READ_BYTE = ...
+    SMBUS_WRITE_BYTE = ...
+    SMBUS_READ_BYTE_DATA = ...
+    SMBUS_WRITE_BYTE_DATA = ...
+    SMBUS_READ_WORD_DATA = ...
+    SMBUS_WRITE_WORD_DATA = ...
+    SMBUS_PROC_CALL = ...
+    SMBUS_READ_BLOCK_DATA = ...
+    SMBUS_WRITE_BLOCK_DATA = ...
+    SMBUS_READ_I2C_BLOCK = ...
+    SMBUS_WRITE_I2C_BLOCK = ...
+    SMBUS_HOST_NOTIFY = ...
+    SMBUS_BYTE = ...
+    SMBUS_BYTE_DATA = ...
+    SMBUS_WORD_DATA = ...
+    SMBUS_BLOCK_DATA = ...
+    SMBUS_I2C_BLOCK = ...
+    SMBUS_EMUL = ...
+
+I2C_M_RD: int
+LP_c_uint8: Type[pointer[c_uint8]]
+LP_c_uint16: Type[pointer[c_uint16]]
+LP_c_uint32: Type[pointer[c_uint32]]
+
+class i2c_smbus_data(Array): ...
+class union_i2c_smbus_data(Union): ...
+
+union_pointer_type: pointer[union_i2c_smbus_data]
+
+class i2c_smbus_ioctl_data(Structure):
+    @staticmethod
+    def create(
+        read_write: int = ..., command: int = ..., size: int = ...
+    ) -> "i2c_smbus_ioctl_data": ...
+
+class i2c_msg(Structure):
+    def __iter__(self) -> int: ...
+    def __len__(self) -> int: ...
+    def __bytes__(self) -> str: ...
+    @staticmethod
+    def read(address: int, length: int) -> "i2c_msg": ...
+    @staticmethod
+    def write(address: int, buf: _UnionT[str, Iterable[int], SupportsBytes]) -> "i2c_msg": ...
+
+class i2c_rdwr_ioctl_data(Structure):
+    @staticmethod
+    def create(*i2c_msg_instances: Sequence[i2c_msg]) -> "i2c_rdwr_ioctl_data": ...
+
+class SMBus:
+    fd: Optional[int] = ...
+    funcs: I2cFunc = ...
+    address: Optional[int] = ...
+    force: bool = ...
+    pec: int = ...
+    def __init__(
+        self, bus: _UnionT[None, int, str] = ..., force: bool = ...
+    ) -> None: ...
+    def __enter__(self) -> "SMBus": ...
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None: ...
+    def open(self, bus: _UnionT[int, str]) -> None: ...
+    def close(self) -> None: ...
+    def enable_pec(self, enable: bool = ...) -> None: ...
+    def write_quick(self, i2c_addr: int, force: Optional[bool] = ...) -> None: ...
+    def read_byte(self, i2c_addr: int, force: Optional[bool] = ...) -> int: ...
+    def write_byte(
+        self, i2c_addr: int, value: int, force: Optional[bool] = ...
+    ) -> None: ...
+    def read_byte_data(
+        self, i2c_addr: int, register: int, force: Optional[bool] = ...
+    ) -> int: ...
+    def write_byte_data(
+        self, i2c_addr: int, register: int, value: int, force: Optional[bool] = ...
+    ) -> None: ...
+    def read_word_data(
+        self, i2c_addr: int, register: int, force: Optional[bool] = ...
+    ) -> int: ...
+    def write_word_data(
+        self, i2c_addr: int, register: int, value: int, force: Optional[bool] = ...
+    ) -> None: ...
+    def process_call(
+        self, i2c_addr: int, register: int, value: int, force: Optional[bool] = ...
+    ): ...
+    def read_block_data(
+        self, i2c_addr: int, register: int, force: Optional[bool] = ...
+    ) -> List[int]: ...
+    def write_block_data(
+        self,
+        i2c_addr: int,
+        register: int,
+        data: Sequence[int],
+        force: Optional[bool] = ...,
+    ) -> None: ...
+    def block_process_call(
+        self,
+        i2c_addr: int,
+        register: int,
+        data: Sequence[int],
+        force: Optional[bool] = ...,
+    ) -> List[int]: ...
+    def read_i2c_block_data(
+        self, i2c_addr: int, register: int, length: int, force: Optional[bool] = ...
+    ) -> List[int]: ...
+    def write_i2c_block_data(
+        self,
+        i2c_addr: int,
+        register: int,
+        data: Sequence[int],
+        force: Optional[bool] = ...,
+    ) -> None: ...
+    def i2c_rdwr(self, *i2c_msgs: i2c_msg) -> None: ...

scripts/lib/ufastrsa/genprime.py

@@ -0,0 +1,136 @@
+from ufastrsa import srandom
+
+try:
+    from _crypto import NUMBER as tomsfastmath
+
+    pow3_ = tomsfastmath.exptmod
+    invmod_ = tomsfastmath.invmod
+    generate_prime_ = tomsfastmath.generate_prime
+
+    def genprime(num=1024, test=25, safe=False):
+        return generate_prime_(num, test, safe)
+
+except ImportError:
+    pow3_ = pow
+
+    def invmod_(a, b):
+        c, d, e, f, g = 1, 0, 0, 1, b
+        while b:
+            q = a // b
+            a, c, d, b, e, f = b, e, f, a - q * b, c - q * e, d - q * f
+        assert a >= 0 and c % g >= 0
+        return a == 1 and c % g or 0
+
+    def miller_rabin_pass(a, n):
+        n_minus_one = n - 1
+        s, d = get_lowest_set_bit(n_minus_one)
+        a_to_power = pow3(a, d, n)
+        if a_to_power == 1:
+            return True
+        for i in range(s):
+            if a_to_power == n_minus_one:
+                return True
+            a_to_power = pow3(a_to_power, 2, n)
+        if a_to_power == n_minus_one:
+            return True
+        return False
+
+    class MillerRabinTest:
+        def __init__(self, randint, repeat):
+            self.randint = randint
+            self.repeat = repeat
+
+        def __call__(self, n):
+            randint = self.randint
+            n_minus_one = n - 1
+            for repeat in range(self.repeat):
+                a = randint(1, n_minus_one)
+                if not miller_rabin_pass(a, n):
+                    return False
+            return True
+
+    class GenPrime:
+        def __init__(self, getrandbits, testfn):
+            self.getrandbits = getrandbits
+            self.testfn = testfn
+
+        def __call__(self, bits):
+            getrandbits = self.getrandbits
+            testfn = self.testfn
+            while True:
+                p = (1 << (bits - 1)) | getrandbits(bits - 1) | 1
+                if p % 3 != 0 and p % 5 != 0 and p % 7 != 0 and testfn(p):
+                    break
+            return p
+
+    miller_rabin_test = MillerRabinTest(srandom.randint, 25)
+    genprime = GenPrime(srandom.getrandbits, miller_rabin_test)
+
+
+def pow3(x, y, z):
+    return pow3_(x, y, z)
+
+
+def invmod(a, b):
+    return invmod_(a, b)
+
+
+def get_lowest_set_bit(n):
+    i = 0
+    while n:
+        if n & 1:
+            return i, n
+        n >>= 1
+        i += 1
+    raise "Error"
+
+
+def gcd(a, b):
+    while b:
+        a, b = b, a % b
+    return a
+
+
+def get_bit_length(n):
+    return srandom.get_bit_length(n)
+
+
+class GenRSA:
+    def __init__(self, genprime):
+        self.genprime = genprime
+
+    def __call__(self, bits, e=None, with_crt=False):
+        pbits = (bits + 1) >> 1
+        qbits = bits - pbits
+        if e is None:
+            e = 65537
+        elif e < 0:
+            e = self.genprime(-e)
+        while True:
+            p = self.genprime(pbits)
+            if gcd(e, p - 1) == 1:
+                break
+        while True:
+            while True:
+                q = self.genprime(qbits)
+                if gcd(e, q - 1) == 1 and p != q:
+                    break
+            n = p * q
+            if get_bit_length(n) == bits:
+                break
+            p = max(p, q)
+        p_minus_1 = p - 1
+        q_minus_1 = q - 1
+        phi = p_minus_1 * q_minus_1
+        d = invmod(e, phi)
+        if with_crt:
+            dp = d % p_minus_1
+            dq = d % q_minus_1
+            qinv = invmod(q, p)
+            assert qinv < p
+            return bits, n, e, d, p, q, dp, dq, qinv
+        else:
+            return bits, n, e, d
+
+
+genrsa = GenRSA(genprime)

scripts/lib/ufastrsa/rsa.py

@@ -0,0 +1,46 @@
+from ufastrsa.genprime import pow3
+from ufastrsa.srandom import rndsrcnz
+
+
+class RSA:
+    def __init__(self, bits, n=None, e=None, d=None):
+        self.bits = bits
+        self.bytes = (bits + 7) >> 3
+        self.n = n
+        self.e = e
+        self.d = d
+        self.rndsrcnz = rndsrcnz
+
+    def pkcs_sign(self, value):
+        len_padding = self.bytes - 3 - len(value)
+        assert len_padding >= 0, len_padding
+        base = int.from_bytes(
+            b"\x00\x01" + len_padding * b"\xff" + b"\x00" + value, "big"
+        )
+        return int.to_bytes(pow3(base, self.d, self.n), self.bytes, "big")
+
+    def pkcs_verify(self, value):
+        assert len(value) == self.bytes
+        signed = int.to_bytes(
+            pow3(int.from_bytes(value, "big"), self.e, self.n), self.bytes, "big"
+        )
+        idx = signed.find(b"\0", 1)
+        assert idx != -1 and signed[:idx] == b"\x00\x01" + (idx - 2) * b"\xff"
+        return signed[idx + 1 :]
+
+    def pkcs_encrypt(self, value):
+        len_padding = self.bytes - 3 - len(value)
+        assert len_padding >= 0
+        base = int.from_bytes(
+            b"\x00\x02" + self.rndsrcnz(len_padding) + b"\x00" + value, "big"
+        )
+        return int.to_bytes(pow3(base, self.e, self.n), self.bytes, "big")
+
+    def pkcs_decrypt(self, value):
+        assert len(value) == self.bytes
+        decrypted = int.to_bytes(
+            pow3(int.from_bytes(value, "big"), self.d, self.n), self.bytes, "big"
+        )
+        idx = decrypted.find(b"\0", 2)
+        assert idx != -1 and decrypted[:2] == b"\x00\x02"
+        return decrypted[idx + 1 :]

scripts/lib/ufastrsa/srandom.py

@@ -0,0 +1,47 @@
+from functools import reduce
+from os import urandom
+
+from ufastrsa.util import get_bit_length
+
+
+class Random:
+    def __init__(self, seed=None, rndsrc=None):
+        if rndsrc is None:
+            rndsrc = urandom
+        self.rndsrc = rndsrc
+
+    def getrandbits(self, k):
+        if not k >= 0:
+            raise ValueError("number of bits must be >= 0")
+        return reduce(
+            lambda x, y: x << 8 | y,
+            self.rndsrc(k >> 3),
+            int.from_bytes(self.rndsrc(1), "little") & ((1 << (k & 7)) - 1),
+        )
+
+    def randint(self, a, b):
+        if a > b:
+            raise ValueError("empty range for randint(): %d, %d" % (a, b))
+        c = 1 + b - a
+        k = get_bit_length(c - 1)
+        while True:
+            r = self.getrandbits(k)
+            if r <= c:
+                break
+        return a + r
+
+    def rndsrcnz(self, size):
+        rv = self.rndsrc(size).replace(b"\x00", b"")
+        mv = size - len(rv)
+        while mv > 0:
+            rv += self.rndsrc(mv).replace(b"\x00", b"")
+            mv = size - len(rv)
+        assert len(rv) == size
+        return rv
+
+
+basernd = Random()
+rndsrc = basernd.rndsrc
+getrandbits = basernd.getrandbits
+randint = basernd.randint
+rndsrcnz = basernd.rndsrcnz

scripts/lib/ufastrsa/util.py

@@ -0,0 +1,14 @@
+try:
+    int.bit_length(0)
+
+    def get_bit_length(n):
+        return n.bit_length()
+
+except:
+    # Work around
+    def get_bit_length(n):
+        i = 0
+        while n:
+            n >>= 1
+            i += 1
+        return i

scripts/lib/umqtt/robust.py

@@ -0,0 +1,44 @@
+import utime
+
+from . import simple
+
+
+class MQTTClient(simple.MQTTClient):
+    DELAY = 2
+    DEBUG = False
+
+    def delay(self, i):
+        utime.sleep(self.DELAY)
+
+    def log(self, in_reconnect, e):
+        if self.DEBUG:
+            if in_reconnect:
+                print("mqtt reconnect: %r" % e)
+            else:
+                print("mqtt: %r" % e)
+
+    def reconnect(self):
+        i = 0
+        while 1:
+            try:
+                return super().connect(False)
+            except OSError as e:
+                self.log(True, e)
+                i += 1
+                self.delay(i)
+
+    def publish(self, topic, msg, retain=False, qos=0):
+        while 1:
+            try:
+                return super().publish(topic, msg, retain, qos)
+            except OSError as e:
+                self.log(False, e)
+            self.reconnect()
+
+    def wait_msg(self):
+        while 1:
+            try:
+                return super().wait_msg()
+            except OSError as e:
+                self.log(False, e)
+            self.reconnect()

scripts/lib/umqtt/simple.py

@@ -0,0 +1,217 @@
+import usocket as socket
+import ustruct as struct
+
+
+class MQTTException(Exception):
+    pass
+
+
+class MQTTClient:
+    def __init__(
+        self,
+        client_id,
+        server,
+        port=0,
+        user=None,
+        password=None,
+        keepalive=0,
+        ssl=False,
+        ssl_params={},
+    ):
+        if port == 0:
+            port = 8883 if ssl else 1883
+        self.client_id = client_id
+        self.sock = None
+        self.server = server
+        self.port = port
+        self.ssl = ssl
+        self.ssl_params = ssl_params
+        self.pid = 0
+        self.cb = None
+        self.user = user
+        self.pswd = password
+        self.keepalive = keepalive
+        self.lw_topic = None
+        self.lw_msg = None
+        self.lw_qos = 0
+        self.lw_retain = False
+
+    def _send_str(self, s):
+        self.sock.write(struct.pack("!H", len(s)))
+        self.sock.write(s)
+
+    def _recv_len(self):
+        n = 0
+        sh = 0
+        while 1:
+            b = self.sock.read(1)[0]
+            n |= (b & 0x7F) << sh
+            if not b & 0x80:
+                return n
+            sh += 7
+
+    def set_callback(self, f):
+        self.cb = f
+
+    def set_last_will(self, topic, msg, retain=False, qos=0):
+        assert 0 <= qos <= 2
+        assert topic
+        self.lw_topic = topic
+        self.lw_msg = msg
+        self.lw_qos = qos
+        self.lw_retain = retain
+
+    def connect(self, clean_session=True):
+        self.sock = socket.socket()
+        addr = socket.getaddrinfo(self.server, self.port)[0][-1]
+        self.sock.connect(addr)
+        if self.ssl:
+            # replaced ussl with ssl due to deprecation in MicroPython 1.23.0
+            # (not PR'd on source repo, but I'm using mqtt_as in my workflows
+            # instead, anyway)
+            import ssl
+
+            self.sock = ssl.wrap_socket(self.sock, **self.ssl_params)
+        premsg = bytearray(b"\x10\0\0\0\0\0")
+        msg = bytearray(b"\x04MQTT\x04\x02\0\0")
+
+        sz = 10 + 2 + len(self.client_id)
+        msg[6] = clean_session << 1
+        if self.user is not None:
+            sz += 2 + len(self.user) + 2 + len(self.pswd)
+            msg[6] |= 0xC0
+        if self.keepalive:
+            assert self.keepalive < 65536
+            msg[7] |= self.keepalive >> 8
+            msg[8] |= self.keepalive & 0x00FF
+        if self.lw_topic:
+            sz += 2 + len(self.lw_topic) + 2 + len(self.lw_msg)
+            msg[6] |= 0x4 | (self.lw_qos & 0x1) << 3 | (self.lw_qos & 0x2) << 3
+            msg[6] |= self.lw_retain << 5
+
+        i = 1
+        while sz > 0x7F:
+            premsg[i] = (sz & 0x7F) | 0x80
+            sz >>= 7
+            i += 1
+        premsg[i] = sz
+
+        self.sock.write(premsg, i + 2)
+        self.sock.write(msg)
+        # print(hex(len(msg)), hexlify(msg, ":"))
+        self._send_str(self.client_id)
+        if self.lw_topic:
+            self._send_str(self.lw_topic)
+            self._send_str(self.lw_msg)
+        if self.user is not None:
+            self._send_str(self.user)
+            self._send_str(self.pswd)
+        resp = self.sock.read(4)
+        assert resp[0] == 0x20 and resp[1] == 0x02
+        if resp[3] != 0:
+            raise MQTTException(resp[3])
+        return resp[2] & 1
+
+    def disconnect(self):
+        self.sock.write(b"\xe0\0")
+        self.sock.close()
+
+    def ping(self):
+        self.sock.write(b"\xc0\0")
+
+    def publish(self, topic, msg, retain=False, qos=0):
+        pkt = bytearray(b"\x30\0\0\0")
+        pkt[0] |= qos << 1 | retain
+        sz = 2 + len(topic) + len(msg)
+        if qos > 0:
+            sz += 2
+        assert sz < 2097152
+        i = 1
+        while sz > 0x7F:
+            pkt[i] = (sz & 0x7F) | 0x80
+            sz >>= 7
+            i += 1
+        pkt[i] = sz
+        # print(hex(len(pkt)), hexlify(pkt, ":"))
+        self.sock.write(pkt, i + 1)
+        self._send_str(topic)
+        if qos > 0:
+            self.pid += 1
+            pid = self.pid
+            struct.pack_into("!H", pkt, 0, pid)
+            self.sock.write(pkt, 2)
+        self.sock.write(msg)
+        if qos == 1:
+            while 1:
+                op = self.wait_msg()
+                if op == 0x40:
+                    sz = self.sock.read(1)
+                    assert sz == b"\x02"
+                    rcv_pid = self.sock.read(2)
+                    rcv_pid = rcv_pid[0] << 8 | rcv_pid[1]
+                    if pid == rcv_pid:
+                        return
+        elif qos == 2:
+            assert 0
+
+    def subscribe(self, topic, qos=0):
+        assert self.cb is not None, "Subscribe callback is not set"
+        pkt = bytearray(b"\x82\0\0\0")
+        self.pid += 1
+        struct.pack_into("!BH", pkt, 1, 2 + 2 + len(topic) + 1, self.pid)
+        # print(hex(len(pkt)), hexlify(pkt, ":"))
+        self.sock.write(pkt)
+        self._send_str(topic)
+        self.sock.write(qos.to_bytes(1, "little"))
+        while 1:
+            op = self.wait_msg()
+            if op == 0x90:
+                resp = self.sock.read(4)
+                # print(resp)
+                assert resp[1] == pkt[2] and resp[2] == pkt[3]
+                if resp[3] == 0x80:
+                    raise MQTTException(resp[3])
+                return
+
+    # Wait for a single incoming MQTT message and process it.
+    # Subscribed messages are delivered to a callback previously
+    # set by .set_callback() method. Other (internal) MQTT
+    # messages processed internally.
+    def wait_msg(self):
+        res = self.sock.read(1)
+        self.sock.setblocking(True)
+        if res is None:
+            return None
+        if res == b"":
+            raise OSError(-1)
+        if res == b"\xd0":  # PINGRESP
+            sz = self.sock.read(1)[0]
+            assert sz == 0
+            return None
+        op = res[0]
+        if op & 0xF0 != 0x30:
+            return op
+        sz = self._recv_len()
+        topic_len = self.sock.read(2)
+        topic_len = (topic_len[0] << 8) | topic_len[1]
+        topic = self.sock.read(topic_len)
+        sz -= topic_len + 2
+        if op & 6:
+            pid = self.sock.read(2)
+            pid = pid[0] << 8 | pid[1]
+            sz -= 2
+        msg = self.sock.read(sz)
+        self.cb(topic, msg)
+        if op & 6 == 2:
+            pkt = bytearray(b"\x40\x02\0\0")
+            struct.pack_into("!H", pkt, 2, pid)
+            self.sock.write(pkt)
+        elif op & 6 == 4:
+            assert 0
+
+    # Checks whether a pending message from server is available.
+    # If not, returns immediately with None. Otherwise, does
+    # the same processing as wait_msg.
+    def check_msg(self):
+        self.sock.setblocking(False)
+        return self.wait_msg()

scripts/lib/unique_id-1.0.1.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: unique-id
+Version: 1.0.1
+Summary: Unique-ID is a small lib to generate unique ids - string values.
+Home-page: 
+Download-URL: https://github.com/slawek87/unique-id
+Author: Sławomir Kabik
+Author-email: slawek@redsoftware.pl
+Keywords: Python Unique ID,Python ID,Python Unique string
+Requires-Dist: setuptools
+

scripts/lib/unique_id-1.0.1.dist-info/RECORD

@@ -0,0 +1,5 @@
+unique_id-1.0.1.dist-info/METADATA,,
+unique_id/__init__.py,,
+unique_id/main.py,,
+unique_id/tests.py,,
+unique_id-1.0.1.dist-info/RECORD,,

scripts/lib/unique_id/__init__.py

@@ -0,0 +1 @@
+from unique_id.main import get_unique_id

scripts/lib/unique_id/main.py

@@ -0,0 +1,58 @@
+import random
+
+
+class UniqueID(object):
+    """
+    Generates Unique ID.
+    """
+    DEFAULT_ID_LENGTH = 14
+    DEFAULT_EXCLUDED_CHARS = ":*^`\",.~;%+-'"
+
+    def __init__(self, length=DEFAULT_ID_LENGTH, excluded_chars=DEFAULT_EXCLUDED_CHARS):
+        """
+        `length` - defines length of unique ID.
+        `excluded_chars` - defines chars excluded during generate process of unique ID.
+        """
+        self.id_length = length
+        self.excluded_chars = excluded_chars
+
+    def get_random_bits(self):
+        """
+        Method returns random number included in max 8 bits.
+        """
+        return random.getrandbits(8)
+
+    def is_approved_ascii(self, ascii_number):
+        return 126 >= ascii_number >= 33
+
+    def is_excluded_char(self, current_char):
+        """
+        Method checks if given char is not in excluded chars list.
+        """
+        return current_char in self.excluded_chars
+
+    def generate_id(self):
+        """
+        Method generates unique ID.
+        """
+        unique_id = ""
+
+        while len(unique_id) < self.id_length:
+            ascii_number = self.get_random_bits()
+
+            if self.is_approved_ascii(ascii_number):
+                random_char = chr(ascii_number)
+
+                if not self.is_excluded_char(random_char):
+                    unique_id += chr(ascii_number)
+
+        return unique_id
+
+
+def get_unique_id(length=UniqueID.DEFAULT_ID_LENGTH, excluded_chars=UniqueID.DEFAULT_EXCLUDED_CHARS):
+    """
+    Function returns unique ID.
+    """
+    unique_id = UniqueID(length=length, excluded_chars=excluded_chars)
+    return unique_id.generate_id()
+

scripts/lib/unique_id/tests.py

@@ -0,0 +1,40 @@
+from random import randint
+import unittest
+
+from unique_id import get_unique_id
+
+
+class TestStringMethods(unittest.TestCase):
+    def test_unique_id(self):
+        unique_ids = list()
+
+        for item in range(1000):
+            unique_id = get_unique_id()
+
+            is_duplicated = unique_id in unique_ids
+            self.assertFalse(is_duplicated)
+
+            unique_ids.append(unique_id)
+
+    def test_max_length(self):
+        for item in range(1000):
+            id_length = randint(1, 128)
+            unique_id = get_unique_id(length=id_length)
+
+            is_over_length = len(unique_id) != id_length
+            self.assertFalse(is_over_length)
+
+    def test_excluded_chars(self):
+        id_length = 256
+        excluded_chars = [1, 'f', 'm', 'a', 4, 5, 'Z', 'w', '_']
+
+        for item in range(1000):
+            unique_id = get_unique_id(length=id_length, excluded_chars=excluded_chars)
+
+            for seed in unique_id:
+                is_excluded_char = seed in excluded_chars
+                self.assertFalse(is_excluded_char)
+
+
+if __name__ == '__main__':
+    unittest.main()

scripts/lib/urequests_2.py

@@ -0,0 +1,203 @@
+# Workaround for the `urequests` module to support HTTP/1.1
+# Based on https://github.com/micropython/micropython-lib/blob/e025c843b60e93689f0f991d753010bb5bd6a722/python-ecosys/requests/requests/__init__.py
+# See https://github.com/micropython/micropython-lib/pull/861 and https://github.com/orgs/micropython/discussions/15112
+# `1.0` replaced with `1.1, i.e.:
+# `s.write(b"%s /%s HTTP/1.0\r\n" % (method, path))` changed to `s.write(b"%s /%s HTTP/1.1\r\n" % (method, path))`
+import usocket
+
+
+class Response:
+    def __init__(self, f):
+        self.raw = f
+        self.encoding = "utf-8"
+        self._cached = None
+
+    def close(self):
+        if self.raw:
+            self.raw.close()
+            self.raw = None
+        self._cached = None
+
+    @property
+    def content(self):
+        if self._cached is None:
+            try:
+                self._cached = self.raw.read()
+            finally:
+                self.raw.close()
+                self.raw = None
+        return self._cached
+
+    @property
+    def text(self):
+        return str(self.content, self.encoding)
+
+    def json(self):
+        import ujson
+
+        return ujson.loads(self.content)
+
+
+def request(
+    method,
+    url,
+    data=None,
+    json=None,
+    headers={},
+    stream=None,
+    auth=None,
+    timeout=None,
+    parse_headers=True,
+):
+    redirect = None  # redirection url, None means no redirection
+    chunked_data = (
+        data and getattr(data, "__next__", None) and not getattr(data, "__len__", None)
+    )
+
+    if auth is not None:
+        import ubinascii
+
+        username, password = auth
+        formated = b"{}:{}".format(username, password)
+        formated = str(ubinascii.b2a_base64(formated)[:-1], "ascii")
+        headers["Authorization"] = "Basic {}".format(formated)
+
+    try:
+        proto, dummy, host, path = url.split("/", 3)
+    except ValueError:
+        proto, dummy, host = url.split("/", 2)
+        path = ""
+    if proto == "http:":
+        port = 80
+    elif proto == "https:":
+        import ussl
+
+        port = 443
+    else:
+        raise ValueError("Unsupported protocol: " + proto)
+
+    if ":" in host:
+        host, port = host.split(":", 1)
+        port = int(port)
+
+    ai = usocket.getaddrinfo(host, port, 0, usocket.SOCK_STREAM)
+    ai = ai[0]
+
+    resp_d = None
+    if parse_headers is not False:
+        resp_d = {}
+
+    s = usocket.socket(ai[0], usocket.SOCK_STREAM, ai[2])
+
+    if timeout is not None:
+        # Note: settimeout is not supported on all platforms, will raise
+        # an AttributeError if not available.
+        s.settimeout(timeout)
+
+    try:
+        s.connect(ai[-1])
+        if proto == "https:":
+            s = ussl.wrap_socket(s, server_hostname=host)
+        s.write(b"%s /%s HTTP/1.1\r\n" % (method, path))
+        if "Host" not in headers:
+            s.write(b"Host: %s\r\n" % host)
+        # Iterate over keys to avoid tuple alloc
+        for k in headers:
+            s.write(k)
+            s.write(b": ")
+            s.write(headers[k])
+            s.write(b"\r\n")
+        if json is not None:
+            assert data is None
+            import ujson
+
+            data = ujson.dumps(json)
+            s.write(b"Content-Type: application/json\r\n")
+        if data:
+            if chunked_data:
+                s.write(b"Transfer-Encoding: chunked\r\n")
+            else:
+                s.write(b"Content-Length: %d\r\n" % len(data))
+        s.write(b"Connection: close\r\n\r\n")
+        if data:
+            if chunked_data:
+                for chunk in data:
+                    s.write(b"%x\r\n" % len(chunk))
+                    s.write(chunk)
+                    s.write(b"\r\n")
+                s.write("0\r\n\r\n")
+            else:
+                s.write(data)
+
+        l = s.readline()
+        # print(l)
+        l = l.split(None, 2)
+        if len(l) < 2:
+            # Invalid response
+            raise ValueError("HTTP error: BadStatusLine:\n%s" % l)
+        status = int(l[1])
+        reason = ""
+        if len(l) > 2:
+            reason = l[2].rstrip()
+        while True:
+            l = s.readline()
+            if not l or l == b"\r\n":
+                break
+            # print(l)
+            if l.startswith(b"Transfer-Encoding:"):
+                if b"chunked" in l:
+                    raise ValueError("Unsupported " + str(l, "utf-8"))
+            elif l.startswith(b"Location:") and not 200 <= status <= 299:
+                if status in [301, 302, 303, 307, 308]:
+                    redirect = str(l[10:-2], "utf-8")
+                else:
+                    raise NotImplementedError("Redirect %d not yet supported" % status)
+            if parse_headers is False:
+                pass
+            elif parse_headers is True:
+                l = str(l, "utf-8")
+                k, v = l.split(":", 1)
+                resp_d[k] = v.strip()
+            else:
+                parse_headers(l, resp_d)
+    except OSError:
+        s.close()
+        raise
+
+    if redirect:
+        s.close()
+        if status in [301, 302, 303]:
+            return request("GET", redirect, None, None, headers, stream)
+        else:
+            return request(method, redirect, data, json, headers, stream)
+    else:
+        resp = Response(s)
+        resp.status_code = status
+        resp.reason = reason
+        if resp_d is not None:
+            resp.headers = resp_d
+        return resp
+
+
+def head(url, **kw):
+    return request("HEAD", url, **kw)
+
+
+def get(url, **kw):
+    return request("GET", url, **kw)
+
+
+def post(url, **kw):
+    return request("POST", url, **kw)
+
+
+def put(url, **kw):
+    return request("PUT", url, **kw)
+
+
+def patch(url, **kw):
+    return request("PATCH", url, **kw)
+
+
+def delete(url, **kw):
+    return request("DELETE", url, **kw)