From 6a81e5481fb4c9b0f9422e3690858eeee8af59f6 Mon Sep 17 00:00:00 2001 From: Pavel Machek Date: Tue, 17 Feb 2026 13:36:06 +0100 Subject: [PATCH] compass: Add an application for magnetometer / accelerometer debugging This is more of a debugging tool for now, but should point north when calibrated properly. For best results, place on flat surface and rotate device few times. --- .../META-INF/MANIFEST.JSON | 24 + .../apps/cz.ucw.pavel.compass/assets/main.py | 687 ++++++++++++++++++ .../res/mipmap-mdpi/icon_64x64.png | Bin 0 -> 9440 bytes 3 files changed, 711 insertions(+) create mode 100644 internal_filesystem/apps/cz.ucw.pavel.compass/META-INF/MANIFEST.JSON create mode 100644 internal_filesystem/apps/cz.ucw.pavel.compass/assets/main.py create mode 100644 internal_filesystem/apps/cz.ucw.pavel.compass/res/mipmap-mdpi/icon_64x64.png diff --git a/internal_filesystem/apps/cz.ucw.pavel.compass/META-INF/MANIFEST.JSON b/internal_filesystem/apps/cz.ucw.pavel.compass/META-INF/MANIFEST.JSON new file mode 100644 index 00000000..dd52c192 --- /dev/null +++ b/internal_filesystem/apps/cz.ucw.pavel.compass/META-INF/MANIFEST.JSON @@ -0,0 +1,24 @@ +{ +"name": "Compass", +"publisher": "Pavel Machek", +"short_description": "Application for testing accelerometer and magnetometer", +"long_description": "Simple compass application, allowing tests of accelerometer and magnetometer.", +"icon_url": "https://apps.micropythonos.com/apps/cz.ucw.pavel.compass/icons/cz.ucw.pavel.compass_0.0.1_64x64.png", +"download_url": "https://apps.micropythonos.com/apps/cz.ucw.pavel.compass/mpks/cz.ucw.pavel.compass_0.0.1.mpk", +"fullname": "cz.ucw.pavel.compass", +"version": "0.0.1", +"category": "utilities", +"activities": [ + { + "entrypoint": "assets/main.py", + "classname": "Main", + "intent_filters": [ + { + "action": "main", + "category": "launcher" + } + ] + } + ] +} + diff --git a/internal_filesystem/apps/cz.ucw.pavel.compass/assets/main.py b/internal_filesystem/apps/cz.ucw.pavel.compass/assets/main.py new file mode 100644 index 00000000..383da538 --- /dev/null +++ b/internal_filesystem/apps/cz.ucw.pavel.compass/assets/main.py @@ -0,0 +1,687 @@ +""" +Robot translated that from bwatch/magcali.js + +""" + +import time +import os +import math + +try: + import lvgl as lv +except ImportError: + pass + +from mpos import Activity, MposKeyboard, SensorManager + +# ----------------------------- +# Utilities +# ----------------------------- + +def clamp(v, lo, hi): + if v < lo: + return lo + if v > hi: + return hi + return v + +def to_rad(deg): + return deg * math.pi / 180.0 + +def to_deg(rad): + return rad * 180.0 / math.pi + +# ----------------------------- +# Calibration + heading +# ----------------------------- + +class Compass: + def __init__(self): + self.reset() + + def reset(self): + self.vmin = [10000.0, 10000.0, 10000.0] + self.vmax = [-10000.0, -10000.0, -10000.0] + + def step(self, v): + """ + Update min/max. Returns True if calibration box changed ("bad" in JS). + """ + bad = False + for i in range(3): + if v[i] < self.vmin[i]: + self.vmin[i] = v[i] + bad = True + if v[i] > self.vmax[i]: + self.vmax[i] = v[i] + bad = True + return bad + + def compensated(self, v): + """ + Returns: + vh = v - center + sc = scaled to [-1..+1] + """ + vh = [0.0, 0.0, 0.0] + sc = [0.0, 0.0, 0.0] + + for i in range(3): + center = (self.vmin[i] + self.vmax[i]) / 2.0 + vh[i] = v[i] - center + + denom = (self.vmax[i] - self.vmin[i]) + if denom == 0: + sc[i] = 0.0 + else: + sc[i] = (v[i] - self.vmin[i]) / denom * 2.0 - 1.0 + + return vh, sc + + def heading_flat(self): + """ + Equivalent of: + heading = atan2(sc[1], sc[0]) * 180/pi - 90 + + Compute heading based on last update(). This will only work well + on flat surface. + """ + vh, sc = self.compensated(self.val) + + h = to_deg(math.atan2(sc[1], sc[0])) - 90.0 + while h < 0: + h += 360.0 + while h >= 360.0: + h -= 360.0 + return h + + +class TiltCompass(Compass): + def __init__(self): + super().__init__() + + def tilt_calibrate(self): + """ + JS tiltCalibrate(min,max) + vmin/vmax are dicts with x,y,z + """ + vmin = self.vmin + vmax = self.vmax + + offset = ( (vmax[0] + vmin[0]) / 2.0, + (vmax[1] + vmin[1]) / 2.0, + (vmax[2] + vmin[2]) / 2.0 ) + delta = ( (vmax[0] - vmin[0]) / 2.0, + (vmax[1] - vmin[1]) / 2.0, + (vmax[2] - vmin[2]) / 2.0 ) + + avg = (delta[0] + delta[1] + delta[2]) / 3.0 + + # Avoid division by zero + scale = ( + avg / delta[0] if delta[0] else 1.0, + avg / delta[1] if delta[1] else 1.0, + avg / delta[2] if delta[2] else 1.0, + ) + + self.offset = offset + self.scale = scale + + def heading_tilted(self): + """ + Returns heading 0..360 + """ + mag_xyz = self.val + acc_xyz = self.acc + + if mag_xyz is None or acc_xyz is None: + return None + + self.tilt_calibrate() + + mx, my, mz = mag_xyz + ax, ay, az = acc_xyz + + dx = (mx - self.offset[0]) * self.scale[0] + dy = (my - self.offset[1]) * self.scale[1] + dz = (mz - self.offset[2]) * self.scale[2] + + # JS: + # phi = atan(-g.x/-g.z) + # theta = atan(-g.y/(-g.x*sinphi-g.z*cosphi)) + # ... + # psi = atan2(yh,xh) + # + # Keep the same structure. + + # Avoid pathological az=0 + if az == 0: + az = 1e-9 + + phi = math.atan((-ax) / (-az)) + cosphi = math.cos(phi) + sinphi = math.sin(phi) + + denom = (-ax * sinphi - az * cosphi) + if denom == 0: + denom = 1e-9 + + theta = math.atan((-ay) / denom) + costheta = math.cos(theta) + sintheta = math.sin(theta) + + xh = dy * costheta + dx * sinphi * sintheta + dz * cosphi * sintheta + yh = dz * sinphi - dx * cosphi + + psi = to_deg(math.atan2(yh, xh)) + if psi < 0: + psi += 360.0 + return psi + +# ----------------------------- +# Canvas (LVGL) +# ----------------------------- + +class Canvas: + """ + LVGL canvas + layer drawing Canvas. + + This matches ports where: + - lv.canvas has init_layer() / finish_layer() + - primitives are drawn via lv.draw_* into lv.layer_t + """ + + def __init__(self, scr, canvas): + self.scr = scr + + # Screen size + self.W = scr.get_width() + self.H = scr.get_height() + + # Bottom button bar + self.margin = 2 + self.bar_h = 39 + + # Canvas drawing area (everything above button bar) + self.draw_w = self.W + self.draw_h = self.H - (self.bar_h + self.margin * 2) + + self.canvas = canvas + + # Background: white (change if you want dark theme) + self.canvas.set_style_bg_color(lv.color_white(), lv.PART.MAIN) + + # Buffer: your working example uses 4 bytes/pixel + # Reality filter: this depends on LV_COLOR_DEPTH; but your example proves it works. + self.buf = bytearray(self.draw_w * self.draw_h * 4) + self.canvas.set_buffer(self.buf, self.draw_w, self.draw_h, lv.COLOR_FORMAT.NATIVE) + + # Layer used for draw engine + self.layer = lv.layer_t() + self.canvas.init_layer(self.layer) + + # Persistent draw descriptors (avoid allocations) + self._line_dsc = lv.draw_line_dsc_t() + lv.draw_line_dsc_t.init(self._line_dsc) + self._line_dsc.width = 1 + self._line_dsc.color = lv.color_black() + self._line_dsc.round_end = 1 + self._line_dsc.round_start = 1 + + self._label_dsc = lv.draw_label_dsc_t() + lv.draw_label_dsc_t.init(self._label_dsc) + self._label_dsc.color = lv.color_black() + self._label_dsc.font = lv.font_montserrat_24 + + self._rect_dsc = lv.draw_rect_dsc_t() + lv.draw_rect_dsc_t.init(self._rect_dsc) + self._rect_dsc.bg_opa = lv.OPA.TRANSP + self._rect_dsc.border_opa = lv.OPA.COVER + self._rect_dsc.border_width = 1 + self._rect_dsc.border_color = lv.color_black() + + self._fill_dsc = lv.draw_rect_dsc_t() + lv.draw_rect_dsc_t.init(self._fill_dsc) + self._fill_dsc.bg_opa = lv.OPA.COVER + self._fill_dsc.bg_color = lv.color_black() + self._fill_dsc.border_width = 1 + + # Clear once + self.clear() + + # ---------------------------- + # Layer lifecycle + # ---------------------------- + + def _begin(self): + # Start drawing into the layer + self.canvas.init_layer(self.layer) + + def _end(self): + # Commit drawing + self.canvas.finish_layer(self.layer) + + # ---------------------------- + # Public API: drawing + # ---------------------------- + + def clear(self): + # Clear the canvas background + self.canvas.fill_bg(lv.color_white(), lv.OPA.COVER) + + def text(self, x, y, s, fg = lv.color_black()): + self._begin() + + dsc = lv.draw_label_dsc_t() + lv.draw_label_dsc_t.init(dsc) + dsc.text = str(s) + dsc.font = lv.font_montserrat_24 + dsc.color = lv.color_black() + + area = lv.area_t() + area.x1 = x + area.y1 = y + area.x2 = x + self.W + area.y2 = y + self.H + + lv.draw_label(self.layer, dsc, area) + + self._end() + + def line(self, x1, y1, x2, y2, fg = lv.color_black()): + self._begin() + + dsc = self._line_dsc + dsc.p1 = lv.point_precise_t() + dsc.p2 = lv.point_precise_t() + dsc.p1.x = int(x1) + dsc.p1.y = int(y1) + dsc.p2.x = int(x2) + dsc.p2.y = int(y2) + + lv.draw_line(self.layer, dsc) + + self._end() + + def circle(self, x, y, r, fg = lv.color_black()): + # Rounded rectangle trick (works everywhere) + self._begin() + + a = lv.area_t() + a.x1 = int(x - r) + a.y1 = int(y - r) + a.x2 = int(x + r) + a.y2 = int(y + r) + + dsc = self._rect_dsc + dsc.radius = lv.RADIUS_CIRCLE + dsc.border_color = fg + + lv.draw_rect(self.layer, dsc, a) + + self._end() + + def fill_circle(self, x, y, r, fg = lv.color_black(), bg = lv.color_white()): + self._begin() + + a = lv.area_t() + a.x1 = int(x - r) + a.y1 = int(y - r) + a.x2 = int(x + r) + a.y2 = int(y + r) + + dsc = self._rect_dsc + dsc.radius = lv.RADIUS_CIRCLE + dsc.border_color = fg + dsc.bg_color = bg + + lv.draw_rect(self.layer, dsc, a) + + self._end() + + def fill_rect(self, x, y, sx, sy, fg = lv.color_black(), bg = lv.color_white()): + self._begin() + + a = lv.area_t() + a.x1 = x + a.y1 = y + a.x2 = x+sx + a.y2 = y+sy + + dsc = self._fill_dsc + dsc.border_color = fg + dsc.bg_color = bg + + lv.draw_rect(self.layer, dsc, a) + + self._end() + + def update(self): + # Nothing needed; drawing is committed per primitive. + # If you want, you can change the implementation so that: + # - draw ops happen between clear() and update() + # But then you must ensure the app calls update() once per frame. + pass + +# ---------------------------- +# App logic +# ---------------------------- + +class PagedCanvas(Activity): + def __init__(self): + super().__init__() + self.page = 0 + self.pages = 3 + + def onCreate(self): + self.scr = lv.obj() + scr = self.scr + + # Screen size + self.W = scr.get_width() + self.H = scr.get_height() + + # Bottom button bar + self.margin = 2 + self.bar_h = 39 + + # Canvas drawing area (everything above button bar) + self.draw_w = self.W + self.draw_h = self.H - (self.bar_h + self.margin * 2) + + # Canvas + self.canvas = lv.canvas(self.scr) + self.canvas.set_size(self.draw_w, self.draw_h) + self.canvas.align(lv.ALIGN.TOP_LEFT, 0, 0) + self.canvas.set_style_border_width(0, 0) + + self.c = Canvas(self.scr, self.canvas) + + # Build buttons + self.build_buttons() + self.setContentView(self.c.scr) + + # ---------------------------- + # Button bar + # ---------------------------- + + def _make_btn(self, parent, x, y, w, h, label): + b = lv.button(parent) + b.set_pos(x, y) + b.set_size(w, h) + + l = lv.label(b) + l.set_text(label) + l.center() + + return b + + def _btn_cb(self, evt, tag): + self.page = tag + + def template_buttons(self, names): + margin = self.margin + y = self.H - self.bar_h - margin + + num = len(names) + if num == 0: + self.buttons = [] + return + + w = (self.W - margin * (num + 1)) // num + h = self.bar_h + x0 = margin + + self.buttons = [] + + for i, label in enumerate(names): + x = x0 + (w + margin) * i + btn = self._make_btn(self.scr, x, y, w, h, label) + + # capture index correctly + btn.add_event_cb( + lambda evt, idx=i: self._btn_cb(evt, idx), + lv.EVENT.CLICKED, + None + ) + + self.buttons.append(btn) + + def build_buttons(self): + self.template_buttons(["Pg0", "Pg1", "Pg2", "Pg3", "..."]) + + def onResume(self, screen): + self.timer = lv.timer_create(self.tick, 1000, None) + + def onPause(self, screen): + if self.timer: + self.timer.delete() + self.timer = None + + def tick(self, t): + self.update() + self.draw() + + def update(self): + pass + + def draw_page_example(self): + ui = self.c + ui.clear() + + st = 28 + y = 2*st + ui.text(0, y, "Hello world, page is %d" % self.page) + y += st + + def draw(self): + self.draw_page_example() + + def handle_buttons(self): + ui = self.c + +# ---------------------------- +# App logic +# ---------------------------- + +class UCompass(TiltCompass): + # val (+vfirst, vmin, vmax) -- vector from magnetometer + # acc -- vector from accelerometer + + # FIXME: we need to scale acc to similar values we used on watch; + # 90 degrees should correspond to outer circle + + def __init__(self): + super().__init__() + + self.accel = SensorManager.get_default_sensor(SensorManager.TYPE_ACCELEROMETER) + self.magn = SensorManager.get_default_sensor(SensorManager.TYPE_MAGNETIC_FIELD) + + self.val = None + self.vfirst = None + + def update(self): + v = SensorManager.read_sensor_once(self.magn) + sc = 1000 + v = [float(v[1]) * sc, -float(v[0]) * sc, float(v[2]) * sc] + self.val = v + + if self.vfirst is None: + self.vfirst = self.val[:] + + acc = SensorManager.read_sensor_once(self.accel) + acc = ( -acc[1], -acc[0], acc[2] ) + self.acc = acc + +class Main(PagedCanvas): + def __init__(self): + super().__init__() + + self.cal = UCompass() + + self.bad = False + + self.heading = 0.0 + self.heading2 = None + + self.Ypos = 40 + self.brg = None # bearing target, degrees or None + + def draw(self): + pass + + def onResume(self, screen): + self.timer = lv.timer_create(self.tick, 50, None) + + def update(self): + self.c.clear() + st = 14 + y = 2*st + + self.cal.update() + if self.cal.val is None: + self.c.text(0, y, f"No compass data") + y += st + return + + self.bad = self.cal.step(self.cal.val) + self.heading = self.cal.heading_flat() + + acc = self.cal.acc + + #self.c.text(0, y, f"Compass, raw is {self.cal.val}, bad is {self.bad}, acc is {acc}") + y += st + + self.heading2 = self.cal.heading_tilted() + + if self.page == 0: + self.draw_top(acc) + elif self.page == 1: + self.draw_values() + elif self.page == 2: + self.c.text(0, y, f"Resetting calibration") + self.page = 0 + self.cal.reset() + + def build_buttons(self): + self.template_buttons(["Graph", "Values", "Reset"]) + + def draw_values(self): + self.c.text(0, 28, f""" +Acccelerometer +X {self.cal.acc[0]:.2f} Y {self.cal.acc[1]:.2f} Z {self.cal.acc[2]:.2f} +Magnetometer +X {self.cal.val[0]:.2f} Y {self.cal.val[1]:.2f} Z {self.cal.val[2]:.2f} +""") + + def _px_per_deg(self): + # JS used deg->px: (deg/90)*(width/2.1) + s = min(self.c.W, self.c.H) + return (s / 2.1) / 90.0 + + def _degrees_to_pixels(self, deg): + return deg * self._px_per_deg() + + # ---- TOP VIEW ---- + + def draw_top(self, acc): + heading=self.heading + heading2=self.heading2 + vmin=self.cal.vmin + vmax=self.cal.vmax + vfirst=self.cal.vfirst + v=self.cal.val + bad=self.bad + + cx = self.c.W // 2 + cy = self.c.H // 2 + + # Crosshair + self.c.line(0, cy, self.c.W, cy) + self.c.line(cx, 0, cx, self.c.H) + + # Circles (30/60/90 deg) + for rdeg in (30, 60, 90): + r = int(self._degrees_to_pixels(rdeg)) + self.c.circle(cx, cy, r) + + # Calibration box + current point + self._draw_calib_box(vmin, vmax, vfirst, v, bad) + + # Accel circle + if acc is not None: + self._draw_accel(acc) + + # Heading arrow(s) + self._draw_heading_arrow(heading, color=lv.color_make(255, 0, 0)) + self.c.text(265, 22, "%d°" % int(heading)) + if heading2 is not None: + self._draw_heading_arrow(heading2, color=lv.color_make(255, 255, 255), size = 100) + self.c.text(10, 22, "%d°" % int(heading2)) + + def _draw_heading_arrow(self, heading, color, size = 80): + cx = self.c.W / 2.0 + cy = self.c.H / 2.0 + + rad = -to_rad(heading) + x2 = cx + math.sin(rad - 0.1) * size + y2 = cy - math.cos(rad - 0.1) * size + x3 = cx + math.sin(rad + 0.1) * size + y3 = cy - math.cos(rad + 0.1) * size + + poly = [ + int(cx), int(cy), + int(x2), int(y2), + int(x3), int(y3), + ] + + self.c.line(poly[0], poly[1], poly[2], poly[3]) + self.c.line(poly[2], poly[3], poly[4], poly[5]) + self.c.line(poly[4], poly[5], poly[0], poly[1]) + + def _draw_accel(self, acc): + ax, ay, az = acc + cx = self.c.W / 2.0 + cy = self.c.H / 2.0 + + x2 = cx + ax * self.c.W + y2 = cy + ay * self.c.W + + self.c.circle(int(x2), int(y2), int(self.c.W / 8)) + + def _draw_calib_box(self, vmin, vmax, vfirst, v, bad): + if v is None or vfirst is None: + return + + scale = 0.15 + + boxW = (vmax[0] - vmin[0]) * scale + boxH = -(vmax[1] - vmin[1]) * scale + boxX = (vmin[0] - vfirst[0]) * scale + self.c.W / 2.0 + boxY = -(vmin[1] - vfirst[1]) * scale + self.c.H / 2.0 + + x = (v[0] - vfirst[0]) * scale + self.c.W / 2.0 + y = -(v[1] - vfirst[1]) * scale + self.c.H / 2.0 + + # box rect + if bad: + bg = lv.color_make(255, 0, 0) + else: + bg = lv.color_make(0, 150, 0) + + x1 = int(boxX) + y1 = int(boxY) + x2 = int(boxX + boxW) + y2 = int(boxY + boxH) + + # normalize coords + xa = min(x1, x2) + xb = max(x1, x2) + ya = min(y1, y2) + yb = max(y1, y2) + + self.c.fill_rect(xa, ya, xb - xa, yb - ya, bg = bg) + + # point + self.c.fill_circle(int(x), int(y), 3, bg = lv.color_make(255, 255, 0)) + diff --git a/internal_filesystem/apps/cz.ucw.pavel.compass/res/mipmap-mdpi/icon_64x64.png b/internal_filesystem/apps/cz.ucw.pavel.compass/res/mipmap-mdpi/icon_64x64.png new file mode 100644 index 0000000000000000000000000000000000000000..2b1f919fbaed011489c8794dc854a97b36ecb4a0 GIT binary patch literal 9440 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