micropython · iabdalkader · Jul 5, 2022 · Jul 5, 2022 · Jul 5, 2022 · Apr 21, 2022
diff --git a/drivers/hts221.py b/drivers/hts221.py
@@ -0,0 +1,91 @@
+"""
+The MIT License (MIT)
+
+Copyright (c) 2013-2022 Ibrahim Abdelkader <iabdalkader@openmv.io>
+Copyright (c) 2013-2022 Kwabena W. Agyeman <kwagyeman@openmv.io>
+
+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.
+
+HTS221 driver driver for MicroPython.
+Original source: https://github.com/ControlEverythingCommunity/HTS221/blob/master/Python/HTS221.py
+
+Example usage:
+
+import time
+import hts221
+from machine import Pin, I2C
+
+bus = I2C(1, scl=Pin(15), sda=Pin(14))
+hts = hts221.HTS221(bus)
+
+while (True):
+    rH   = hts.humidity()
+    temp = hts.temperature()
+    print ("rH: %.2f%% T: %.2fC" %(rH, temp))
+    time.sleep_ms(100)
+"""
+
+import struct
+
+
+class HTS221:
+    def __init__(self, i2c, data_rate=1, address=0x5F):
+        self.bus = i2c
+        self.odr = data_rate
+        self.slv_addr = address
+
+        # Set configuration register
+        # Humidity and temperature average configuration
+        self.bus.writeto_mem(self.slv_addr, 0x10, b"\x1B")
+
+        # Set control register
+        # PD | BDU | ODR
+        cfg = 0x80 | 0x04 | (self.odr & 0x3)
+        self.bus.writeto_mem(self.slv_addr, 0x20, bytes([cfg]))
+
+        # Read Calibration values from non-volatile memory of the device
+        # Humidity Calibration values
+        self.H0 = self._read_reg(0x30, 1) / 2
+        self.H1 = self._read_reg(0x31, 1) / 2
+        self.H2 = self._read_reg(0x36, 2)
+        self.H3 = self._read_reg(0x3A, 2)
+
+        # Temperature Calibration values
+        raw = self._read_reg(0x35, 1)
+        self.T0 = ((raw & 0x03) * 256) + self._read_reg(0x32, 1)
+        self.T1 = ((raw & 0x0C) * 64) + self._read_reg(0x33, 1)
+        self.T2 = self._read_reg(0x3C, 2)
+        self.T3 = self._read_reg(0x3E, 2)
+
+    def _read_reg(self, reg_addr, size):
+        fmt = "B" if size == 1 else "H"
+        reg_addr = reg_addr if size == 1 else reg_addr | 0x80
+        return struct.unpack(fmt, self.bus.readfrom_mem(self.slv_addr, reg_addr, size))[0]
+
+    def humidity(self):
+        rH = self._read_reg(0x28, 2)
+        return (self.H1 - self.H0) * (rH - self.H2) / (self.H3 - self.H2) + self.H0
+
+    def temperature(self):
+        temp = self._read_reg(0x2A, 2)
+        if temp > 32767:
+            temp -= 65536
+        return ((self.T1 - self.T0) / 8.0) * (temp - self.T2) / (self.T3 - self.T2) + (
+            self.T0 / 8.0
+        )
diff --git a/drivers/lps22h.py b/drivers/lps22h.py
@@ -0,0 +1,117 @@
+"""
+The MIT License (MIT)
+
+Copyright (c) 2016-2019 shaoziyang <shaoziyang@micropython.org.cn>
+Copyright (c) 2022 Ibrahim Abdelkader <iabdalkader@openmv.io>
+
+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.
+
+LPS22HB/HH pressure sensor driver for MicroPython.
+
+Example usage:
+
+import time
+from lps22h import LPS22H
+from machine import Pin, I2C
+
+bus = I2C(1, scl=Pin(15), sda=Pin(14))
+lps = LPS22H(bus, oneshot=False)
+
+while (True):
+    print("Pressure: %.2f hPa Temperature: %.2f C"%(lps.pressure(), lps.temperature()))
+    time.sleep_ms(10)
+"""
+import machine
+
+_LPS22_CTRL_REG1 = const(0x10)
+_LPS22_CTRL_REG2 = const(0x11)
+_LPS22_STATUS = const(0x27)
+_LPS22_TEMP_OUT_L = const(0x2B)
+_LPS22_PRESS_OUT_XL = const(0x28)
+_LPS22_PRESS_OUT_L = const(0x29)
+
+
+class LPS22H:
+    def __init__(self, i2c, address=0x5C, oneshot=False):
+        self.i2c = i2c
+        self.addr = address
+        self.oneshot = oneshot
+        self.buf = bytearray(1)
+
+        if hasattr(machine, "idle"):
+            self._go_idle = machine.idle()
+        else:
+            import time
+
+            self._go_idle = lambda: time.sleep_ms(1)
+
+        # ODR=1 EN_LPFP=1 BDU=1
+        self._write_reg(_LPS22_CTRL_REG1, 0x1A)
+        self.set_oneshot_mode(self.oneshot)
+
+    def _int16(self, d):
+        return d if d < 0x8000 else d - 0x10000
+
+    def _write_reg(self, reg, dat):
+        self.buf[0] = dat
+        self.i2c.writeto_mem(self.addr, reg, self.buf)
+
+    def _read_reg(self, reg, width=8):
+        self.i2c.readfrom_mem_into(self.addr, reg, self.buf)
+        val = self.buf[0]
+        if width == 16:
+            val |= self._read_reg(reg + 1) << 8
+        return val
+
+    def _tigger_oneshot(self, b):
+        if self.oneshot:
+            self._write_reg(_LPS22_CTRL_REG2, self._read_reg(_LPS22_CTRL_REG2) | 0x01)
+            self._read_reg(0x28 + b * 2)
+            while True:
+                if self._read_reg(_LPS22_STATUS) & b:
+                    return
+                self._go_idle()
+
+    def set_oneshot_mode(self, oneshot):
+        self._read_reg(_LPS22_CTRL_REG1)
+        self.oneshot = oneshot
+        if oneshot:
+            self.buf[0] &= 0x0F
+        else:
+            self.buf[0] |= 0x10
+        self._write_reg(_LPS22_CTRL_REG1, self.buf[0])
+
+    def pressure(self):
+        if self.oneshot:
+            self._tigger_oneshot(1)
+        return (
+            self._read_reg(_LPS22_PRESS_OUT_XL) + self._read_reg(_LPS22_PRESS_OUT_L, 16) * 256
+        ) / 4096
+
+    def temperature(self):
+        if self.oneshot:
+            self._tigger_oneshot(2)
+        return self._int16(self._read_reg(_LPS22_TEMP_OUT_L, 16)) / 100
+
+    def altitude(self):
+        return (
+            (((1013.25 / self.pressure()) ** (1 / 5.257)) - 1.0)
+            * (self.temperature() + 273.15)
+            / 0.0065
+        )
diff --git a/drivers/lsm9ds1.py b/drivers/lsm9ds1.py
@@ -0,0 +1,189 @@
+"""
+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
6DB6
 OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+
+LSM9DS1 - 9DOF inertial sensor of STMicro driver for MicroPython.
+The sensor contains an accelerometer / gyroscope / magnetometer
+Uses the internal FIFO to store up to 16 gyro/accel data, use the iter_accel_gyro generator to access it.
+
+Example usage:
+
+import time
+from lsm9ds1 import LSM9DS1
+from machine import Pin, I2C
+
+lsm = LSM9DS1(I2C(1, scl=Pin(15), sda=Pin(14)))
+
+while (True):
+    #for g,a in lsm.iter_accel_gyro(): print(g,a)    # using fifo
+    print('Accelerometer: x:{:>8.3f} y:{:>8.3f} z:{:>8.3f}'.format(*lsm.accel()))
+    print('Magnetometer:  x:{:>8.3f} y:{:>8.3f} z:{:>8.3f}'.format(*lsm.magnet()))
+    print('Gyroscope:     x:{:>8.3f} y:{:>8.3f} z:{:>8.3f}'.format(*lsm.gyro()))
+    print("")
+    time.sleep_ms(100)
+"""
+import array
+
+
+_WHO_AM_I = const(0xF)
+_CTRL_REG1_G = const(0x10)
+_INT_GEN_SRC_G = const(0x14)
+_OUT_TEMP = const(0x15)
+_OUT_G = const(0x18)
+_CTRL_REG4_G = const(0x1E)
+_STATUS_REG = const(0x27)
+_OUT_XL = const(0x28)
+_FIFO_CTRL_REG = const(0x2E)
+_FIFO_SRC = const(0x2F)
+_OFFSET_REG_X_M = const(0x05)
+_CTRL_REG1_M = const(0x20)
+_OUT_M = const(0x28)
+_SCALE_GYRO = const(((245, 0), (500, 1), (2000, 3)))
+_SCALE_ACCEL = const(((2, 0), (4, 2), (8, 3), (16, 1)))
+
+
+class LSM9DS1:
+    def __init__(self, i2c, address_gyro=0x6B, address_magnet=0x1E):
+        self.i2c = i2c
+        self.address_gyro = address_gyro
+        self.address_magnet = address_magnet
+        # check id's of accelerometer/gyro and magnetometer
+        if (self.magent_id() != b"=") or (self.gyro_id() != b"h"):
+            raise OSError(
+                "Invalid LSM9DS1 device, using address {}/{}".format(address_gyro, address_magnet)
+            )
+        # allocate scratch buffer for efficient conversions and memread op's
+        self.scratch = array.array("B", [0, 0, 0, 0, 0, 0])
+        self.scratch_int = array.array("h", [0, 0, 0])
+        self.init_gyro_accel()
+        self.init_magnetometer()
+
+    def init_gyro_accel(self, sample_rate=6, scale_gyro=0, scale_accel=0):
+        """Initalizes Gyro and Accelerator.
+        sample rate: 0-6 (off, 14.9Hz, 59.5Hz, 119Hz, 238Hz, 476Hz, 952Hz)
+        scale_gyro: 0-2 (245dps, 500dps, 2000dps )
+        scale_accel: 0-3 (+/-2g, +/-4g, +/-8g, +-16g)
+        """
+        assert sample_rate <= 6, "invalid sampling rate: %d" % sample_rate
+        assert scale_gyro <= 2, "invalid gyro scaling: %d" % scale_gyro
+        assert scale_accel <= 3, "invalid accelerometer scaling: %d" % scale_accel
+
+        i2c = self.i2c
+        addr = self.address_gyro
+        mv = memoryview(self.scratch)
+        # angular control registers 1-3 / Orientation
+        mv[0] = ((sample_rate & 0x07) << 5) | ((_SCALE_GYRO[scale_gyro][1] & 0x3) << 3)
+        mv[1:4] = b"\x00\x00\x00"
+        i2c.writeto_mem(addr, _CTRL_REG1_G, mv[:5])
+        # ctrl4 - enable x,y,z, outputs, no irq latching, no 4D
+        # ctrl5 - enable all axes, no decimation
+        # ctrl6 - set scaling and sample rate of accel
+        # ctrl7,8 - leave at default values
+        # ctrl9 - FIFO enabled
+        mv[0] = mv[1] = 0x38
+        mv[2] = ((sample_rate & 7) << 5) | ((_SCALE_ACCEL[scale_accel][1] & 0x3) << 3)
+        mv[3] = 0x00
+        mv[4] = 0x4
+        mv[5] = 0x2
+        i2c.writeto_mem(addr, _CTRL_REG4_G, mv[:6])
+
+        # fifo: use continous mode (overwrite old data if overflow)
+        i2c.writeto_mem(addr, _FIFO_CTRL_REG, b"\x00")
+        i2c.writeto_mem(addr, _FIFO_CTRL_REG, b"\xc0")
+
+        self.scale_gyro = 32768 / _SCALE_GYRO[scale_gyro][0]
+        self.scale_accel = 32768 / _SCALE_ACCEL[scale_accel][0]
+
+    def init_magnetometer(self, sample_rate=7, scale_magnet=0):
+        """
+        sample rates = 0-7 (0.625, 1.25, 2.5, 5, 10, 20, 40, 80Hz)
+        scaling = 0-3 (+/-4, +/-8, +/-12, +/-16 Gauss)
+        """
+        assert sample_rate < 8, "invalid sample rate: %d (0-7)" % sample_rate
+        assert scale_magnet < 4, "invalid scaling: %d (0-3)" % scale_magnet
+        i2c = self.i2c
+        addr = self.address_magnet
+        mv = memoryview(self.scratch)
+        mv[0] = 0x40 | (sample_rate << 2)  # ctrl1: high performance mode
+        mv[1] = scale_magnet << 5  # ctrl2: scale, normal mode, no reset
+        mv[2] = 0x00  # ctrl3: continous conversion, no low power, I2C
+        mv[3] = 0x08  # ctrl4: high performance z-axis
+        mv[4] = 0x00  # ctr5: no fast read, no block update
+        i2c.writeto_mem(addr, _CTRL_REG1_M, mv[:5])
+        self.scale_factor_magnet = 32768 / ((scale_magnet + 1) * 4)
+
+    def calibrate_magnet(self, offset):
+        """
+        offset is a magnet vecor that will be substracted by the magnetometer
+        for each measurement. It is written to the magnetometer's offset register
+        """
+        offset = [int(i * self.scale_factor_magnet) for i in offset]
+        mv = memoryview(self.scratch)
+        mv[0] = offset[0] & 0xFF
+        mv[1] = offset[0] >> 8
+        mv[2] = offset[1] & 0xFF
+        mv[3] = offset[1] >> 8
+        mv[4] = offset[2] & 0xFF
+        mv[5] = offset[2] >> 8
+        self.i2c.writeto_mem(self.address_magnet, _OFFSET_REG_X_M, mv[:6])
+
+    def gyro_id(self):
+        return self.i2c.readfrom_mem(self.address_gyro, _WHO_AM_I, 1)
+
+    def magent_id(self):
+        return self.i2c.readfrom_mem(self.address_magnet, _WHO_AM_I, 1)
+
+    def magnet(self):
+        """Returns magnetometer vector in gauss.
+        raw_values: if True, the non-scaled adc values are returned
+        """
+        mv = memoryview(self.scratch_int)
+        f = self.scale_factor_magnet
+        self.i2c.readfrom_mem_into(self.address_magnet, _OUT_M | 0x80, mv)
+        return (mv[0] / f, mv[1] / f, mv[2] / f)
+
+    def gyro(self):
+        """Returns gyroscope vector in degrees/sec."""
+        mv = memoryview(self.scratch_int)
+        f = self.scale_gyro
+        self.i2c.readfrom_mem_into(self.address_gyro, _OUT_G | 0x80, mv)
+        return (mv[0] / f, mv[1] / f, mv[2] / f)
+
+    def accel(self):
+        """Returns acceleration vector in gravity units (9.81m/s^2)."""
+        mv = memoryview(self.scratch_int)
+        f = self.scale_accel
+        self.i2c.readfrom_mem_into(self.address_gyro, _OUT_XL | 0x80, mv)
+        return (mv[0] / f, mv[1] / f, mv[2] / f)
+
+    def iter_accel_gyro(self):
+        """A generator that returns tuples of (gyro,accelerometer) data from the fifo."""
+        while True:
+            fifo_state = int.from_bytes(
+                self.i2c.readfrom_mem(self.address_gyro, _FIFO_SRC, 1), "big"
+            )
+            if fifo_state & 0x3F:
+                # print("Available samples=%d" % (fifo_state & 0x1f))
+                yield self.gyro(), self.accel()
+            else:
+                break