Added code in pyscan to send light and accelerometer data to pybytes

Aditya Jain · Aditya Jain · commit d9ba35ed9378 · 2018-09-24T20:22:44.000+05:30
diff --git a/pyscan/lib/LIS2HH12.py b/pyscan/lib/LIS2HH12.py
@@ -0,0 +1,168 @@
+import math
+import time
+import struct
+from machine import Pin
+
+
+FULL_SCALE_2G = const(0)
+FULL_SCALE_4G = const(2)
+FULL_SCALE_8G = const(3)
+
+ODR_POWER_DOWN = const(0)
+ODR_10_HZ = const(1)
+ODR_50_HZ = const(2)
+ODR_100_HZ = const(3)
+ODR_200_HZ = const(4)
+ODR_400_HZ = const(5)
+ODR_800_HZ = const(6)
+
+ACC_G_DIV = 1000 * 65536
+
+
+class LIS2HH12:
+
+    ACC_I2CADDR = const(30)
+
+    PRODUCTID_REG = const(0x0F)
+    CTRL1_REG = const(0x20)
+    CTRL2_REG = const(0x21)
+    CTRL3_REG = const(0x22)
+    CTRL4_REG = const(0x23)
+    CTRL5_REG = const(0x24)
+    ACC_X_L_REG = const(0x28)
+    ACC_X_H_REG = const(0x29)
+    ACC_Y_L_REG = const(0x2A)
+    ACC_Y_H_REG = const(0x2B)
+    ACC_Z_L_REG = const(0x2C)
+    ACC_Z_H_REG = const(0x2D)
+    ACT_THS = const(0x1E)
+    ACT_DUR = const(0x1F)
+
+    SCALES = {FULL_SCALE_2G: 4000, FULL_SCALE_4G: 8000, FULL_SCALE_8G: 16000}
+    ODRS = [0, 10, 50, 100, 200, 400, 800]
+
+    def __init__(self, pysense = None, sda = 'P22', scl = 'P21'):
+        if pysense is not None:
+            self.i2c = pysense.i2c
+        else:
+            from machine import I2C
+            self.i2c = I2C(0, mode=I2C.MASTER, pins=(sda, scl))
+
+        self.odr = 0
+        self.full_scale = 0
+        self.x = 0
+        self.y = 0
+        self.z = 0
+        self.int_pin = None
+        self.act_dur = 0
+        self.debounced = False
+
+        whoami = self.i2c.readfrom_mem(ACC_I2CADDR , PRODUCTID_REG, 1)
+        if (whoami[0] != 0x41):
+            raise ValueError("LIS2HH12 not found")
+
+        # enable acceleration readings at 50Hz
+        self.set_odr(ODR_50_HZ)
+
+        # change the full-scale to 4g
+        self.set_full_scale(FULL_SCALE_4G)
+
+        # set the interrupt pin as active low and open drain
+        self.set_register(CTRL5_REG, 3, 0, 3)
+
+        # make a first read
+        self.acceleration()
+
+    def acceleration(self):
+        x = self.i2c.readfrom_mem(ACC_I2CADDR , ACC_X_L_REG, 2)
+        self.x = struct.unpack('<h', x)
+        y = self.i2c.readfrom_mem(ACC_I2CADDR , ACC_Y_L_REG, 2)
+        self.y = struct.unpack('<h', y)
+        z = self.i2c.readfrom_mem(ACC_I2CADDR , ACC_Z_L_REG, 2)
+        self.z = struct.unpack('<h', z)
+        _mult = self.SCALES[self.full_scale] / ACC_G_DIV
+        return (self.x[0] * _mult, self.y[0] * _mult, self.z[0] * _mult)
+
+    def roll(self):
+        x,y,z = self.acceleration()
+        rad = math.atan2(-x, z)
+        return (180 / math.pi) * rad
+
+    def pitch(self):
+        x,y,z = self.acceleration()
+        rad = -math.atan2(y, (math.sqrt(x*x + z*z)))
+        return (180 / math.pi) * rad
+
+    def set_register(self, register, value, offset, mask):
+        reg = bytearray(self.i2c.readfrom_mem(ACC_I2CADDR, register, 1))
+        reg[0] &= ~(mask << offset)
+        reg[0] |= ((value & mask) << offset)
+        self.i2c.writeto_mem(ACC_I2CADDR, register, reg)
+
+    def set_full_scale(self, scale):
+        self.set_register(CTRL4_REG, scale, 4, 3)
+        self.full_scale = scale
+
+    def set_odr(self, odr):
+        self.set_register(CTRL1_REG, odr, 4, 7)
+        self.odr = odr
+
+    def set_high_pass(self, hp):
+        self.set_register(CTRL2_REG, 1 if hp else 0, 2, 1)
+
+    def enable_activity_interrupt(self, threshold, duration, handler=None):
+        # Threshold is in mg, duration is ms
+        self.act_dur = duration
+
+        if threshold > self.SCALES[self.full_scale]:
+            error = "threshold %d exceeds full scale %d" % (thresold, self.SCALES[self.full_scale])
+            print(error)
+            raise ValueError(error)
+
+        if threshold < self.SCALES[self.full_scale] / 128:
+            error = "threshold %d below resolution %d" % (thresold, self.SCALES[self.full_scale]/128)
+            print(error)
+            raise ValueError(error)
+
+        if duration > 255 * 1000 * 8 / self.ODRS[self.odr]:
+            error = "duration %d exceeds max possible value %d" % (duration, 255 * 1000 * 8 / self.ODRS[self.odr])
+            print(error)
+            raise ValueError(error)
+
+        if duration < 1000 * 8 / self.ODRS[self.odr]:
+            error = "duration %d below resolution %d" % (duration, 1000 * 8 / self.ODRS[self.odr])
+            print(error)
+            raise ValueError(error)
+
+        _ths = int(127 * threshold / self.SCALES[self.full_scale]) & 0x7F
+        _dur = int((duration * self.ODRS[self.odr]) / 1000 / 8)
+
+        self.i2c.writeto_mem(ACC_I2CADDR, ACT_THS, _ths)
+        self.i2c.writeto_mem(ACC_I2CADDR, ACT_DUR, _dur)
+
+        # enable the activity/inactivity interrupt
+        self.set_register(CTRL3_REG, 1, 5, 1)
+
+        self._user_handler = handler
+        self.int_pin = Pin('P13', mode=Pin.IN)
+        self.int_pin.callback(trigger=Pin.IRQ_FALLING | Pin.IRQ_RISING, handler=self._int_handler)
+
+        # return actual used thresold and duration
+        return (_ths * self.SCALES[self.full_scale] / 128, _dur * 8 * 1000 / self.ODRS[self.odr])
+
+    def activity(self):
+        if not self.debounced:
+            time.sleep_ms(self.act_dur)
+            self.debounced = True
+        if self.int_pin():
+            return True
+        return False
+
+    def _int_handler(self, pin_o):
+        if self._user_handler is not None:
+            self._user_handler(pin_o)
+        else:
+            if pin_o():
+                print('Activity interrupt')
+            else:
+                print('Inactivity interrupt')
diff --git a/pyscan/lib/LTR329ALS01.py b/pyscan/lib/LTR329ALS01.py
@@ -0,0 +1,70 @@
+import time
+from machine import I2C
+
+class LTR329ALS01:
+    ALS_I2CADDR = const(0x29) # The device's I2C address
+
+    ALS_CONTR_REG = const(0x80)
+    ALS_MEAS_RATE_REG = const(0x85)
+
+    ALS_DATA_CH1_LOW = const(0x88)
+    ALS_DATA_CH1_HIGH = const(0x89)
+    ALS_DATA_CH0_LOW = const(0x8A)
+    ALS_DATA_CH0_HIGH = const(0x8B)
+
+    ALS_GAIN_1X = const(0x00)
+    ALS_GAIN_2X = const(0x01)
+    ALS_GAIN_4X = const(0x02)
+    ALS_GAIN_8X = const(0x03)
+    ALS_GAIN_48X = const(0x06)
+    ALS_GAIN_96X = const(0x07)
+
+    ALS_INT_50 = const(0x01)
+    ALS_INT_100 = const(0x00)
+    ALS_INT_150 = const(0x04)
+    ALS_INT_200 = const(0x02)
+    ALS_INT_250 = const(0x05)
+    ALS_INT_300 = const(0x06)
+    ALS_INT_350 = const(0x07)
+    ALS_INT_400 = const(0x03)
+
+    ALS_RATE_50 = const(0x00)
+    ALS_RATE_100 = const(0x01)
+    ALS_RATE_200 = const(0x02)
+    ALS_RATE_500 = const(0x03)
+    ALS_RATE_1000 = const(0x04)
+    ALS_RATE_2000 = const(0x05)
+
+    def __init__(self, pysense = None, sda = 'P22', scl = 'P21', gain = ALS_GAIN_1X, integration = ALS_INT_100, rate = ALS_RATE_500):
+        if pysense is not None:
+            self.i2c = pysense.i2c
+        else:
+            self.i2c = I2C(0, mode=I2C.MASTER, pins=(sda, scl))
+
+        contr = self._getContr(gain)
+        self.i2c.writeto_mem(ALS_I2CADDR, ALS_CONTR_REG, bytearray([contr]))
+
+        measrate = self._getMeasRate(integration, rate)
+        self.i2c.writeto_mem(ALS_I2CADDR, ALS_MEAS_RATE_REG, bytearray([measrate]))
+
+        time.sleep(0.01)
+
+    def _getContr(self, gain):
+        return ((gain & 0x07) << 2) + 0x01
+
+    def _getMeasRate(self, integration, rate):
+        return ((integration & 0x07) << 3) + (rate & 0x07)
+
+    def _getWord(self, high, low):
+        return ((high & 0xFF) << 8) + (low & 0xFF)
+
+    def light(self):
+        ch1low = self.i2c.readfrom_mem(ALS_I2CADDR , ALS_DATA_CH1_LOW, 1)
+        ch1high = self.i2c.readfrom_mem(ALS_I2CADDR , ALS_DATA_CH1_HIGH, 1)
+        data1 = int(self._getWord(ch1high[0], ch1low[0]))
+
+        ch0low = self.i2c.readfrom_mem(ALS_I2CADDR , ALS_DATA_CH0_LOW, 1)
+        ch0high = self.i2c.readfrom_mem(ALS_I2CADDR , ALS_DATA_CH0_HIGH, 1)
+        data0 = int(self._getWord(ch0high[0], ch0low[0]))
+
+        return (data0, data1)
diff --git a/pyscan/main.py b/pyscan/main.py
@@ -12,6 +12,8 @@
 
 from pyscan import Pyscan
 from MFRC630 import MFRC630
+from LIS2HH12 import LIS2HH12
+from LTR329ALS01 import LTR329ALS01
 import binascii
 import time
 import pycom
@@ -22,6 +24,8 @@
 
 py = Pyscan()
 nfc = MFRC630(py)
+lt = LTR329ALS01(py)
+li = LIS2HH12(py)
 
 RGB_BRIGHTNESS = 0x8
 
@@ -42,6 +46,12 @@ def print_debug(msg):
     if DEBUG:
         print(msg)
 
+def send_sensor_data(name, timeout):
+    while(pybytes):
+        pybytes.send_virtual_pin_value(True, 2, lt.light())
+        pybytes.send_virtual_pin_value(True, 3, li.acceleration())
+        time.sleep(timeout)
+
 def discovery_loop(nfc, id):
     while True:
         # Send REQA for ISO14443A card type
@@ -72,3 +82,4 @@ def discovery_loop(nfc, id):
 
 # This is the start of our main execution... start the thread
 _thread.start_new_thread(discovery_loop, (nfc, 0))
+_thread.start_new_thread(send_sensor_data, ('Thread 2', 10))
