lis2mdl: fix device + first number

Still doesnt point to north but can see rotation

Author: Charly-sketch

lib/lis2mdl/exemple/magnet.py

@@ -1,17 +1,62 @@
 from time import sleep_ms
 from machine import I2C
 from lis2mdl.device import LIS2MDL
+import math
 
-# Initialize the LIS2MDL magnetometer
 i2c = I2C(1)
-magnetometer = LIS2MDL(i2c)
+mag = LIS2MDL(i2c)
 
-print("Starting magnetometer readings...")
+print("Quick calibration: rotate the board FLAT over 360°...")
+xmin = ymin =  1e9
+xmax = ymax = -1e9
 
+# capture ~3 seconds of data for min/max
+for _ in range(150):
+    x, y, z = mag.read_magnet()
+    xmin = min(xmin, x); xmax = max(xmax, x)
+    ymin = min(ymin, y); ymax = max(ymax, y)
+    sleep_ms(20)
+
+# offsets (hard-iron) and scales (simple 2D soft-iron)
+x_off = (xmax + xmin) / 2.0
+y_off = (ymax + ymin) / 2.0
+x_scale = (xmax - xmin) / 2.0
+y_scale = (ymax - ymin) / 2.0
+# normalize the scale to have a circle (not essential but better)
+scale = (x_scale + y_scale) / 2.0
+
+print("Offsets:", x_off, y_off, "  Scales:", x_scale, y_scale)
+
+print("\nContinuous reading (compass):")
 while True:
-    # Read magnetic field data
-    magnet = magnetometer.read_magnet()
-    print(f"Magnetic field (X, Y, Z): {magnet}")
+    x, y, z = mag.read_magnet()
+
+    # recentering + normalization
+    x_c = (x - x_off) / scale
+    y_c = (y - y_off) / scale
+
+    # heading (adjust the sign according to your reference if needed)
+    angle = math.degrees(math.atan2(y_c, x_c))
+    if angle < 0:
+        angle += 360
+    
+    direction = ""
+    if angle >= 337.5 or angle < 22.5:
+        direction = "N"
+    elif angle >= 22.5 and angle < 67.5:
+        direction = "NE"
+    elif angle >= 67.5 and angle < 112.5:
+        direction = "E"
+    elif angle >= 112.5 and angle < 157.5:      
+        direction = "SE"
+    elif angle >= 157.5 and angle < 202.5:
+        direction = "S"
+    elif angle >= 202.5 and angle < 247.5:
+        direction = "SW"
+    elif angle >= 247.5 and angle < 292.5:
+        direction = "W"
+    elif angle >= 292.5 and angle < 337.5:
+        direction = "NW"
 
-    # Wait for 1 second
-    sleep_ms(1000)
+    print("{} | {:.2f},{:.2f},{:.2f}  |  angle={:.2f}°".format(direction, x, y, z, angle))
+    sleep_ms(100)

lib/lis2mdl/lis2mdl/device.py

@@ -1,27 +1,37 @@
+# device.py
 from machine import I2C
 from lis2mdl.const import *
 
 class LIS2MDL(object):
-    def __init__(self, i2c, address=LIS2MDL_I2C_ADDR):
+    def __init__(self, i2c, address=LIS2MDL_I2C_ADDR, odr_hz=10, temp_comp=True, low_power=False, drdy_pin=False):
         self.i2c = i2c
         self.address = address
-
         self.writebuffer = bytearray(1)
         self.readbuffer = bytearray(1)
 
-        # Initialize the device
-        self.reset()
-        self.configure()
-
-    def reset(self):
-        # Reset the device using CFG_REG_A
-        self.setReg(0x10, LIS2MDL_CFG_REG_A)
-
-    def configure(self):
-        # Configure the device (example: enable continuous mode)
+        # Soft reset property
+        self.setReg(0x20, LIS2MDL_CFG_REG_A)  # SOFT_RST=1 (not 0x10)
+        # small delay (if needed on the MicroPython side)
+        try:
+            import time; time.sleep_ms(10)
+        except:
+            pass
+
+        # CFG_REG_A: COMP_TEMP, LP, ODR, MD=00 (continuous)
+        odr_bits = {10:0b00, 20:0b01, 50:0b10, 100:0b11}.get(odr_hz, 0b00)
+        comp = 1 if temp_comp else 0
+        lp   = 1 if low_power else 0
+        cfg_a = (comp<<7) | (lp<<4) | (odr_bits<<2) | 0b00
+        self.setReg(cfg_a, LIS2MDL_CFG_REG_A)   # <- essential to exit IDLE
+
+        # CFG_REG_B: default 0x00 (LPF/off_canc off); you can enable LPF if desired
         self.setReg(0x00, LIS2MDL_CFG_REG_B)
-        self.setReg(0x01, LIS2MDL_CFG_REG_C)
 
+        # CFG_REG_C: BDU=1 (+ DRDY_on_PIN if requested)
+        cfg_c = 0x10 | (0x01 if drdy_pin else 0x00)
+        self.setReg(cfg_c, LIS2MDL_CFG_REG_C)
+
+    # --- identical low-level ---
     def setReg(self, data, reg):
         self.writebuffer[0] = data
         self.i2c.writeto_mem(self.address, reg, self.writebuffer)
@@ -30,22 +40,22 @@ def getReg(self, reg):
         self.i2c.readfrom_mem_into(self.address, reg, self.readbuffer)
         return self.readbuffer[0]
 
-    def get2Reg(self, reg):
-        lowerByte = self.getReg(reg)
-        higherByte = self.getReg(reg + 1)
-        return (higherByte << 8) + lowerByte
+    # signed helper
+    @staticmethod
+    def _to_int16(v):
+        return v - 0x10000 if v & 0x8000 else v
 
+    # burst read + signed
     def read_magnet(self):
-        # Read magnetic field data for X, Y, Z axes
-        x = self.get2Reg(LIS2MDL_OUTX_L_REG)
-        y = self.get2Reg(LIS2MDL_OUTY_L_REG)
-        z = self.get2Reg(LIS2MDL_OUTZ_L_REG)
+        # auto-increment: reg | 0x80 (cf. datasheet I2C op)
+        buf = self.i2c.readfrom_mem(self.address, LIS2MDL_OUTX_L_REG | 0x80, 6)
+        x = self._to_int16((buf[1] << 8) | buf[0])
+        y = self._to_int16((buf[3] << 8) | buf[2])
+        z = self._to_int16((buf[5] << 8) | buf[4])
         return (x, y, z)
 
     def whoAmI(self):
-        # Read the WHO_AM_I register
         return self.getReg(LIS2MDL_WHO_AM_I)
 
     def status(self):
-        # Read the STATUS register
-        return self.getReg(LIS2MDL_STATUS_REG)
+        return self.getReg(LIS2MDL_STATUS_REG)