feat(steami_screen): simplify gauge display to avoid missed pixels

Author: Charly-sketch

lib/steami_screen/examples/gauge_demo.py

@@ -28,9 +28,8 @@
     dist = sensor.read()
 
     screen.clear()
-    screen.gauge(dist, min_val=0, max_val=500, unit="mm", color=BLACK)
-    screen.title("Distance")
-    screen.subtitle("VL53L1X")
+    screen.gauge(dist, min_val=0, max_val=500, color=BLACK)
+    screen.value(dist, label="Distance", unit="mm")
     screen.show()
 
-    sleep_ms(100)
+    sleep_ms(10)

lib/steami_screen/steami_screen/device.py

@@ -198,7 +198,8 @@ def bar(self, val, max_val=100, y_offset=0, color=LIGHT):
         if fill_w > 0:
             self._fill_rect(bx, by, fill_w, bar_h, color)
 
-    def gauge(self, val, min_val=0, max_val=100, unit=None, color=LIGHT):
+
+    def gauge(self, val, min_val=0, max_val=100, color=LIGHT):
         """Draw a circular arc gauge (270 deg, gap at bottom).
 
         The arc is drawn close to the screen border.  Call gauge() before
@@ -217,28 +218,7 @@ def gauge(self, val, min_val=0, max_val=100, unit=None, color=LIGHT):
         # Filled arc
         if ratio > 0:
             self._draw_arc(cx, cy, r, start_angle, int(sweep * ratio),
-                           color, arc_w)
-
-        # Value + unit centered as a block
-        text = str(val)
-        char_h = self.CHAR_H * 2  # scale=2
-        tw = len(text) * self.CHAR_W * 2
-        if unit:
-            gap = char_h // 3
-            unit_h = self.CHAR_H
-            block_h = char_h + gap + unit_h
-            vy = cy - block_h // 2
-        else:
-            vy = cy - char_h // 2
-        vx = cx - tw // 2
-        self._draw_scaled_text(text, vx, vy, WHITE, 2)
-        if unit:
-            ux = cx - len(unit) * self.CHAR_W // 2
-            uy = vy + char_h + gap
-            if hasattr(self._d, 'draw_medium_text'):
-                self._d.draw_medium_text(unit, ux, uy, LIGHT)
-            else:
-                self._d.text(unit, ux, uy, LIGHT)
+                           color, arc_w + 2)  # +1 to fill gaps between segments
 
         # Min/max labels at arc endpoints (slightly inward to stay visible)
         min_t = str(int(min_val))
@@ -592,20 +572,37 @@ def _draw_scaled_text(self, text, x, y, color, scale):
             self._d.text(text, x, y, color)
 
     def _draw_arc(self, cx, cy, r, start_deg, sweep_deg, color, width=3):
-        """Draw a thick arc using individual pixels."""
+        """Draw a thick arc."""
         if hasattr(self._d, 'draw_arc'):
             self._d.draw_arc(cx, cy, r, start_deg, sweep_deg, color, width)
             return
-        steps = max(sweep_deg, 60)
+
+        # Number of steps based on arc length, with oversampling to avoid gaps
+        arc_len = abs(math.radians(sweep_deg) * r)
+        steps = max(int(arc_len * 2), 1)  # Oversample to avoid gaps
         half_w = width // 2
+
+        prev_points = None
+
         for i in range(steps + 1):
             angle = math.radians(start_deg + i * sweep_deg / steps)
+
+            curr_points = []
             for dr in range(-half_w, half_w + 1):
-                x = int(cx + (r + dr) * math.cos(angle))
-                y = int(cy + (r + dr) * math.sin(angle))
-                if 0 <= x < self.width and 0 <= y < self.height:
+                rr = r + dr
+                x = round(cx + rr * math.cos(angle))
+                y = round(cy + rr * math.sin(angle))
+                curr_points.append((x, y))
+
+                if prev_points is None and 0 <= x < self.width and 0 <= y < self.height:
                     self._d.pixel(x, y, color)
 
+            if prev_points is not None:
+                for (x0, y0), (x1, y1) in zip(prev_points, curr_points):
+                    self._line(x0, y0, x1, y1, color)
+
+            prev_points = curr_points
+
     def _draw_circle(self, cx, cy, r, color):
         """Bresenham circle."""
         x, y, d = r, 0, 1 - r