How to Share Data Between Interrupt Handler and The While Loop

[rbmakers]

I tried to have a fixed sampling rate of a accelerometer sensor (LSM9DS1) using a timer interrupt callback.
Error occurred as "uncaught exception in Timer(5) interrupt handler and traced back at this line :
mv = memoryview(self.scratch_int)

There is no issue if read the accelerometer data in the while loop :
while True: roll, pitch, yaw = lsm.read_accel()

Is the below error because of a heap-related memory allocation issue or anything else?

array('h', [0, 0, 0])
array('h', [0, 0, 0])
uncaught exception in Timer(5) interrupt handler
Traceback (most recent call last):
  File "<stdin>", line 16, in acctask
  File "lsm9ds1.py", line 129, in read_accel
MemoryError: 
array('h', [0, 0, 0])
array('h', [0, 0, 0])
array('h', [0, 0, 0])
array('h', [0, 0, 0])

Here attached below is the code of main.py and lsm9ds1.py

main.py

import pyb, micropython      
import time
from machine import Pin, SoftI2C
from lsm9ds1 import LSM9DS1
import array

micropython.alloc_emergency_exception_buf(100)
bus2 = SoftI2C(scl=Pin("P4"), sda=Pin("P5"))
lsm = LSM9DS1(bus2)

data = array.array("h", [0, 0, 0])

def acctask(timer):
    global data                 
    data = lsm.read_accel()
    return

Timer = pyb.Timer(5)
Timer.init(freq=1)
Timer.callback(acctask)

while True:
    
    irq_state = pyb.disable_irq()
    print(data)
    pyb.enable_irq(irq_state)

lsm9ds1.py

import time
import array

class LSM9DS1:
    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 = [(245, 0), (500, 1), (2000, 3)]
    SCALE_ACCEL = [(2, 0), (4, 2), (8, 3), (16, 1)]

    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.read_id_magnet() != b"=") or (self.read_id_gyro() != 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):

        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)
        mv[0] = ((sample_rate & 0x07) << 5) | ((self.SCALE_GYRO[scale_gyro][1] & 0x3) << 3)
        mv[1:4] = b"\x00\x00\x00"
        i2c.writeto_mem(addr, CTRL_REG1_G, mv[:5])
        mv[0] = mv[1] = 0x38
        mv[2] = ((sample_rate & 7) << 5) | ((self.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])
        i2c.writeto_mem(addr, FIFO_CTRL_REG, b"\x00")
        i2c.writeto_mem(addr, FIFO_CTRL_REG, b"\xc0")

        self.scale_gyro = 32768 / self.SCALE_GYRO[scale_gyro][0]
        self.scale_accel = 32768 / self.SCALE_ACCEL[scale_accel][0]

    def read_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)

[andrewleech]

Yep creating the memoryview requires an allocation. You can move this to init though as self.mv = self.memoryview(scratch_int) and then just use self.mv in the interrupt handler.

[rbmakers]

Ok, many thanks, it works now !!