RA in Zehntelminuten mit Beschriftung: "RA 18h36.9m" / "DE +38°47'"

Die GM4000 liefert im Auslieferzustand keine Sekunden, sondern Zehntelminuten.
Bisher wurde daraus eine Sekundenanzeige gerechnet -- die sprang in
6-Sekunden-Schritten, weil die Rohdaten sie gar nicht hergeben. Die Zehntelform
ist ehrlicher und kuerzer, und der gewonnene Platz traegt die Beschriftung:

    RA 18h36.9m
    DE +38°47'

Bei Hochpraezision entfaellt die Beschriftung, dort braucht die Deklination mit
+38°47'01" alle Zellen.

Der Mock konnte das gar nicht nachstellen -- er sendete immer das
Hochpraezisionsformat. Neu: "mount_mock.py --low" bildet den Auslieferzustand ab
(RA als HH:MM.T, DEC ohne Bogensekunden). Vorgabe bleibt hoch, damit die
bestehenden Tests mit ihren festen Erwartungen unveraendert durchlaufen.

Zur Darstellung, alles am Geraet ausprobiert:

- **Schmale Zeichen** (config.CELL_NARROW): Dezimalpunkt und der Abstand
  zwischen Beschriftung und Wert bekommen 3 statt 6 px -- in der Sperrschrift
  standen sie sonst sehr luftig. Fuer die Leerzeichen am Zeilenende gilt das
  nicht, die sollen den Rest der Zeile ueberschreiben.
- Damit entscheidet die **Pixelbreite** ueber das Abschneiden, nicht mehr die
  Zeichenzahl: "RA 18h36.9m" sind 11 Zeichen und trotzdem nur 60 px.
- **Linksbuendig ab LINE_X = 0**, der Schalter zum Zentrieren ist entfallen.
  Zentriert standen die Zeilen um wenige Pixel gegeneinander versetzt, weil die
  RA-Zeile mit ihrem schmalen Punkt kuerzer ist als die DEC-Zeile.

Ein Zwischenschritt, der wieder verworfen wurde und als Warnung im Code steht:
Ein Doppelpunkt als Trenner ("RA:18h36.9m") sah in Zeichensatz 0 zu wuchtig aus;
der aus Zeichensatz 1 ist schlanker, steht aber mitten in der obersten Zeile --
und jeder Zeichensatzwechsel zerstoert die Home-Zelle. Das erste Zeichen danach
noch einmal zu schreiben machte es schlimmer: Das nachgezogene Zeichen bemalt
GLYPH_WIDTH Pixel und frisst die linke Spalte seines rechten Nachbarn. Deshalb
steht in der obersten Zeile jetzt bewusst kein Sonderzeichen.

161 Tests gruen, am Geraet bestaetigt.

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

test_migra.py

@@ -136,14 +136,38 @@ class TestKoordinaten(unittest.TestCase):
         self.assertEqual(coords.format_dec("+45d12m30s", width=7, **hp), "+45°12'")
 
     def test_formatierung_niedrigpraezision(self):
+        """RA in Zehntelminuten -- so, wie die Montierung sie liefert.
+
+        Bis 2026-07-27 wurde hier in Sekunden umgerechnet (11h36m54s). Die
+        sprangen aber in 6-Sekunden-Schritten, weil die Rohdaten sie nicht
+        hergeben. Die Zehntelform ist ehrlicher und laesst mit sieben Zeichen
+        Platz fuer die Beschriftung "RA:".
+        """
         lp = dict(high_precision=False)
-        # RA: Zehntel-Minute (0.9 min) kommt als Sekunden (54 s) heraus
-        self.assertEqual(coords.format_ra("11:36.9", width=9, **lp), "11h36m54s")
+        # Breiteste passende Form: mit Minutenzeichen am Ende, sonst ohne.
+        self.assertEqual(coords.format_ra("11:36.9", width=9, **lp), "11h36.9m")
+        self.assertEqual(coords.format_ra("11:36.9", width=8, **lp), "11h36.9m")
+        self.assertEqual(coords.format_ra("11:36.9", width=7, **lp), "11h36.9")
         self.assertEqual(coords.format_ra("11:36.9", width=6, **lp), "11h36m")
         # DEC: ohne Sekunden
         self.assertEqual(coords.format_dec("-00°55", width=9, **lp), "-00°55'")
         self.assertEqual(coords.format_dec("-00°55", width=6, **lp), "-00:55")
 
+    def test_zehntelminuten_mit_uebertrag(self):
+        """18:36:57 sind 36,95 Minuten -- das muss auf 18:37.0 aufgehen."""
+        lp = dict(high_precision=False, width=7)
+        self.assertEqual(coords.format_ra("18:36:57", **lp), "18h37.0")
+        self.assertEqual(coords.format_ra("18:36:00", **lp), "18h36.0")
+        self.assertEqual(coords.format_ra("18:36:54", **lp), "18h36.9")
+        # Auch ueber die Stunde und ueber Mitternacht hinweg.
+        self.assertEqual(coords.format_ra("18:59:58", **lp), "19h00.0")
+        self.assertEqual(coords.format_ra("23:59:58", **lp), "00h00.0")
+
+    def test_hochpraezision_behaelt_die_sekundenform(self):
+        hp = dict(high_precision=True, width=10)
+        self.assertEqual(coords.format_ra("18:36:56", **hp), "18h36m56s")
+        self.assertEqual(coords.format_dec("+38*47:01", **hp), "+38°47'01\"")
+
 
 class TestDisplay(unittest.TestCase):
 
@@ -173,20 +197,19 @@ class TestDisplay(unittest.TestCase):
         def zelle(i, y):
             return b"\x1bC%03d%03d" % (config.LINE_X + i * config.CELL_WIDTH, y)
 
-        # "12:34:56" hat 8 Zeichen und wird in 10 Zellen mittig gesetzt (ab Zelle 1),
-        # "+45:12:30" hat 9 und beginnt daher schon bei Zelle 0.
-        self.assertIn(zelle(1, 0) + b"\x1f1", oben)
-        self.assertIn(zelle(2, 0) + b"\x1f2", oben)
+        # Linksbuendig (config.CENTER_LINES): beide Zeilen beginnen bei Zelle 0.
+        self.assertIn(zelle(0, 0) + b"\x1f1", oben)
+        self.assertIn(zelle(1, 0) + b"\x1f2", oben)
         self.assertIn(zelle(0, 9) + b"\x1f+", unten)
 
     def test_ohne_clear_kein_fill_aber_aufgefuellt(self):
         """Standard (clear=False): kein Vollbild-Loeschen, Zeilen auf volle Breite."""
-        from test_display import zeile, zentriert
+        from test_display import zeile, aufbereitet
         t = FakeTransport(echo=False)
         Display(t, response=True).show_lines("12:34:56", clear=False)
         self.assertNotIn(b"\x1bF0", t.frames[0])
         # auf CHARS_PER_LINE mit Leerzeichen aufgefuellt (mittig, siehe CENTER_LINES)
-        self.assertEqual(zeile(t.frames, 0), zentriert("12:34:56"))
+        self.assertEqual(zeile(t.frames, 0), aufbereitet("12:34:56"))
 
     def test_gradzeichen_via_zeichensatz(self):
         """Gradzeichen wird durch kurzen Wechsel auf Zeichensatz 1 erzeugt."""