Uhr: Neigungsmesser direkt, Fahrzeugansicht, kein Kalibrieren

Die Uhr funkt den Neigungsmesser jetzt selbst an, statt die Werte vom
iPhone weiterreichen zu lassen. Bei diesem einen Gerät geht das, und nur
bei ihm: Es bewirbt seinen Dienst, ist also ohne Einrichtung auffindbar,
und es ist unverschlüsselt – es gibt keinen Schlüssel, der auf der Uhr
ein zweites Mal lagern müsste. Damit steht die Nivellierung am Handgelenk
ohne geöffnetes iPhone, und genau dafür hebt man beim Rangieren den Arm.

Batterie, Solar und Kühlbox bleiben beim Weg über das iPhone: Sie lassen
nur eine Verbindung zu, und die Victron-Schlüssel liegen in dessen
Keychain. Die Einbaulage des Sensors reist einmal mit dem Datensatz
herüber und bleibt auf der Uhr gespeichert – ohne sie stünden längs und
quer je nach Einbau vertauscht.

LevelSession und VanAlignProtocol wandern nach Shared/Bluetooth; beide
sind reines CoreBluetooth und laufen auf watchOS unverändert. Die
Fahrzeugansicht gibt es jetzt auch auf der Uhr, umschaltbar zur Libelle;
Überhöhung und Farbregeln stehen in Shared/VehicleTilt.swift, damit
iPhone und Uhr nicht auseinanderlaufen.

Kalibrieren fällt auf der Uhr weg, samt Befehl. Das gehört einmalig ans
iPhone mit ebenem Fahrzeug; ein Knopf dafür am Handgelenk wäre vor allem
eine Gelegenheit, die Nullage aus Versehen zu verstellen.

Zwei Fehler dabei behoben:

* Beim Start meldete die Uhr dem iPhone nie, dass jemand hinschaut –
  onChange(of: scenePhase) feuert beim ersten Erscheinen nicht. Der
  schnelle Sendetakt blieb aus, bis die App einmal im Hintergrund war.
* Ein einmal direkt gemessener Wert hatte für immer Vorrang. Blieb der
  Sensor stehen, ohne die Verbindung zu trennen, klebte die Anzeige
  daran. Jetzt gilt er drei Sekunden als frisch, danach übernimmt der
  Stand des iPhones – mit Alter und Grund daneben.

Ausserdem WATCHOS_DEPLOYMENT_TARGET auf 10.0 (Xcode hatte 11.6 gesetzt)
und die Bluetooth-Begründung für das Watch-Target.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Shared/Bluetooth/VanAlignProtocol.swift

@@ -0,0 +1,51 @@
+import Foundation
+
+/// Neigungsmesser „VanAlign Pro“ – ein ESP32 mit MPU6050, der Längs- und
+/// Querneigung des Fahrzeugs über Bluetooth bereitstellt.
+///
+/// Anders als die übrigen Geräte gibt es hier kein Rahmenprotokoll: Jede
+/// Messgrösse liegt in einer eigenen Charakteristik als 32-Bit-Float.
+enum VanAlignProtocol {
+
+    /// Wird vom Gerät beworben, das Gerät ist darüber auffindbar.
+    static let serviceUUID = "2A24B789-7AAB-4535-AF3E-EE76A35CC42D"
+
+    static let pitchUUID     = "CAD48E28-7FBE-41CF-BAE9-D77A6C233424"
+    static let rollUUID      = "CAD48E28-7FBE-41CF-BAE9-D77A6C233425"
+    /// Zwei Floats: die gespeicherten Kalibrier-Offsets.
+    static let offsetsUUID   = "CAD48E28-7FBE-41CF-BAE9-D77A6C233426"
+    /// Ein Byte: 0 setzt zurück, alles andere kalibriert auf die aktuelle Lage.
+    static let calibrateUUID = "CAD48E28-7FBE-41CF-BAE9-D77A6C233427"
+
+    static let calibrateCommand = Data([0x01])
+    static let resetCommand = Data([0x00])
+
+    /// Liest einen Winkel aus vier Bytes, little-endian.
+    ///
+    /// Die Firmware legt den Float per `memcpy` ab, und der ESP32 ist
+    /// little-endian – die Reihenfolge steht also fest. Die Web-Oberfläche des
+    /// Ursprungsprojekts probiert zusätzlich die umgekehrte Reihenfolge, falls
+    /// die erste unplausibel aussieht. Das ist nicht nur unnötig, sondern
+    /// schädlich: ein vertauschter Float von 4,25° ergibt gelesen etwa 0,0 und
+    /// wirkt damit völlig plausibel. Ein Vorzeichen- oder Wertfehler bliebe so
+    /// unbemerkt.
+    static func angle(from data: Data) -> Double? {
+        guard data.count >= 4 else { return nil }
+        var raw: UInt32 = 0
+        for (index, byte) in data.prefix(4).enumerated() {
+            raw |= UInt32(byte) << UInt32(8 * index)
+        }
+        let value = Float(bitPattern: raw)
+        // NAN meldet die Firmware, solange der Sensor nichts liefert.
+        guard value.isFinite, abs(value) <= 180 else { return nil }
+        return Double(value)
+    }
+
+    /// Die beiden gespeicherten Offsets.
+    static func offsets(from data: Data) -> (pitch: Double, roll: Double)? {
+        guard data.count >= 8,
+              let pitch = angle(from: data.prefix(4)),
+              let roll = angle(from: data.dropFirst(4).prefix(4)) else { return nil }
+        return (pitch, roll)
+    }
+}