Portierung auf den XIAO ESP32-C3 (MicroPython)

Die Kette laeuft auf dem Geraet gegen den Mock auf dem Mac. Getestet mit
MicroPython 1.28.0 (ESP32_GENERIC_C3): alle Module importieren, Telegrammbau
und Koordinaten-Formatierung sind byte-identisch zum Mac (inkl. Gradzeichen),
Poll-Schleife 22 Abfragen in 20 s ohne Aussetzer, Ausfall und Reconnect
verhalten sich wie vorgesehen. Offen bleibt allein die RS232-Strecke zur
Anzeige -- der Steckbrettaufbau mit MAX3232 fehlt noch.

Gemeinsamer Kern statt zweier Programme:
- displayloop.py: die Poll-Schleife, herausgeloest aus run_display. Mac und
  ESP32 fahren jetzt denselben Ablauf; drumherum liegt nur die Kommandozeile
  (run_display.py) bzw. das WLAN-Setup (run_esp32.py).
- ticks.py: Timeouts fuer beide Plattformen. time.ticks_ms() laeuft nach ~12
  Tagen ueber; das bisherige "jetzt + Timeout" haette eine Warteschleife
  danach tagelang haengen lassen. Jetzt ueber ticks_diff.
- wifi.py, run_esp32.py, wifi_config.py (gitignored, Vorlage dabei), deploy.sh.

Pinbelegung aus dem KiCad-Schaltplan uebernommen, nicht geraten: UART1 mit
TX=GPIO21 (Pad 7/D6) und RX=GPIO20 (Pad 8/D7) ueber den MAX3232, LDR an
GPIO2 (Pad 1/A0). UART0 bleibt die REPL.

LDR-Kennlinie ist auf der Platine umgekehrt: der Teiler lautet
3V3-[2k]-A0-[LDR]-GND, die Spannung faellt also mit steigender Helligkeit --
andersherum als beim MSP430, auf den die Schwellen zugeschnitten sind. Wird
im Code gespiegelt (config.LDR_INVERTED, brightness.raw_to_ldr). Die
Schwellen selbst muessen am realen Aufbau noch nachgemessen werden.

Am Geraet gefundene Fehler, die den Attrappen-Tests entgehen mussten, weil
CPython sie nicht hat:
- MicroPython kennt kein str.ljust (auch kein rjust/center/zfill).
  display._emit_line fuellt von Hand auf.
- NOLINK_LINES hatte 10 Zeichen bei 9 Zeichen Zeilenbreite und erschien als
  "MONTIERUN". Jetzt "KEIN LINK"/"TELESKOP".
Dagegen: TestMicropythonVertraeglichkeit prueft die deployten Dateien statisch
auf solche Methoden und auf modulweites argparse/threading und haelt die
Dateiliste mit deploy.sh synchron; test_display.py prueft die Breite fester
Anzeigetexte.

Weitere Portabilitaet: mount_client nutzt getaddrinfo und eine Sendeschleife
statt sendall (MicroPython laesst dessen Verhalten mit Timeout offen);
argparse in brightness wandert in die Funktion; migra._digits und die
Hex-Ausgabe verlassen sich nicht mehr auf %0*d bzw. bytes.hex(). Beides kann
1.28 zwar doch -- am Geraet nachgeprueft, die Kommentare sagen es jetzt richtig.

Widerspruch in der Dokumentation bereinigt: die Zeichenbreite stand an vier
Stellen als 9 oder 10. Gemessen sind 9; die Erklaerung duerfte sein, dass die
Sperrschrift 7 px pro Zelle braucht (9*7 = 63 von 64 px) und nicht 6, wie es
eine 5x7-Matrix mit 1 px Luecke waere. Nachgeprueft ist das nicht -- dafuer
gibt es jetzt "probe.py pitch", das den Auto-Vorschub gegen feste
Pixelabstaende stellt, statt am Umbruch abzuzaehlen.

mount_mock.py --lan bindet auf 0.0.0.0 und nennt die einzutragende LAN-IP,
damit der ESP32 den Mock erreicht.

92 Tests gruen.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

transport.py

@@ -12,15 +12,22 @@ except ImportError:
     serial = None
 
 try:                        # MicroPython
-    from machine import UART
+    from machine import UART, Pin
 except ImportError:
     UART = None
+    Pin = None
 
-try:
-    import time
-    _monotonic = time.monotonic
-except AttributeError:      # MicroPython kennt kein time.monotonic
-    _monotonic = lambda: time.ticks_ms() / 1000.0
+from ticks import deadline as _deadline, expired as _expired
+
+
+def _truncate_at_etx(buf):
+    """Alles ab dem ersten ETX abschneiden (einschliesslich).
+
+    Nach ETX ist das Antworttelegramm zu Ende; alles danach waere Stoerung und
+    wuerde die Plausibilitaetspruefung in migra.parse_response scheitern lassen.
+    """
+    idx = buf.find(b"\x03")
+    return bytes(buf if idx < 0 else buf[:idx + 1])
 
 
 class SerialTransport:
@@ -49,9 +56,9 @@ class SerialTransport:
 
     def read_response(self):
         """Bytes bis einschliesslich ETX lesen, oder bis der Timeout greift."""
-        deadline = _monotonic() + self._timeout
+        deadline = _deadline(self._timeout)
         buf = bytearray()
-        while _monotonic() < deadline:
+        while not _expired(deadline):
             chunk = self._port.read(1)
             if not chunk:
                 continue
@@ -65,7 +72,12 @@ class SerialTransport:
 
 
 class UartTransport:
-    """Serieller Port ueber machine.UART (MicroPython / ESP32-C3)."""
+    """Serieller Port ueber machine.UART (MicroPython / ESP32-C3).
+
+    Auf dem XIAO ESP32-C3 haengt die Anzeige ueber einen MAX3232 an UART1:
+    TX = GPIO21 (Pad 7 / D6) -> T2IN, RX = GPIO20 (Pad 8 / D7) <- R2OUT.
+    Die Pins stehen in config.py, weil UART1 auf dem C3 frei zuordenbar ist.
+    """
 
     def __init__(self, uart_id, baudrate, parity, bytesize, stopbits, timeout,
                  tx=None, rx=None):
@@ -80,27 +92,42 @@ class UartTransport:
             stop=stopbits,
             timeout=int(timeout * 1000),
         )
+        # Die Pins als Pin-Objekt uebergeben -- die esp32-Portierung akzeptiert
+        # zwar meist auch die nackte GPIO-Nummer, Pin() ist aber ueberall gueltig.
         if tx is not None:
-            kwargs["tx"] = tx
+            kwargs["tx"] = Pin(tx) if Pin is not None else tx
         if rx is not None:
-            kwargs["rx"] = rx
+            kwargs["rx"] = Pin(rx) if Pin is not None else rx
         self._uart = UART(uart_id, **kwargs)
         self._timeout = timeout
 
+    def _drain(self):
+        """Empfangspuffer leeren (wie SerialTransport.reset_input_buffer)."""
+        n = self._uart.any()
+        while n:
+            self._uart.read(n)
+            n = self._uart.any()
+
     def write(self, data):
+        # Wie bei pyserial: vor dem Senden den Empfangspuffer leeren, damit
+        # read_response nur die frische Antwort auf DIESES Telegramm sieht.
+        self._drain()
         self._uart.write(data)
 
     def read_response(self):
-        deadline = _monotonic() + self._timeout
+        deadline = _deadline(self._timeout)
         buf = bytearray()
-        while _monotonic() < deadline:
-            chunk = self._uart.read(1)
+        while not _expired(deadline):
+            n = self._uart.any()
+            if not n:
+                continue
+            chunk = self._uart.read(n)
             if not chunk:
                 continue
             buf.extend(chunk)
-            if chunk[0] == migra.ETX:
+            if migra.ETX in chunk:
                 break
-        return bytes(buf)
+        return _truncate_at_etx(buf)
 
     def close(self):
         self._uart.deinit()