Einbaulage: Verdrehung um die Hochachse messen – und Geräte dabei nicht verlieren

Sitzt der Sensor schräg statt längs im Fahrzeug, verteilt sich eine reine
Querneigung auf beide Achsen: Das Fahrzeug kippt zur Seite, und die
Längsanzeige kippt sichtbar mit – bei 20° Verdrehung mit gut einem
Drittel des Werts. Achsentausch und Vorzeichen halfen dagegen nicht, die
springen in 90°-Schritten.

SensorOrientation bekommt deshalb "twist", einen stufenlosen Winkel. Der
Einbaulage-Assistent misst ihn ohne zusätzlichen Handgriff mit: Beim
Kippen der Front nach unten dürfte sich nur die Längsneigung ändern;
wandert die Querneigung mit, ist das der gesuchte Winkel. Unter zwei Grad
gilt es als Wackeln der Hand. Angezeigt wird er in der Zusammenfassung
("um 20° verdreht"), herausgerechnet bei jeder Anzeige.

Beim Kalibrieren liesse sich das grundsätzlich nicht ermitteln: Es misst
eine einzige Lage und zieht sie als Nullpunkt ab. Eine Drehung um die
Hochachse steckt darin nicht – eben sieht in jeder Verdrehung gleich aus.

Das neue Feld hat beim Aufspielen sämtliche eingerichteten Geräte
gekostet, und der Grund gehört hierher: Swifts erzeugte Codable-Umsetzung
verlangt beim Lesen jedes Feld, Standardwerte im Code zählen nicht.
Gespeicherte Einbaulagen hatten kein "twist", also scheiterte das Lesen
der Einbaulage, damit des Geräts, damit der ganzen Liste – und das
nächste Speichern schrieb die leere Liste über den Bestand.

Zwei Vorkehrungen dagegen:

* SensorOrientation liest jetzt von Hand und nachsichtig, mit
  decodeIfPresent und Rückfallwerten, wie Profile und ConfiguredDevice es
  längst tun. Jedes künftige Feld gehört dort hinein.
* DeviceStore liest die Liste zweistufig: scheitert sie als Ganzes, wird
  jedes Gerät einzeln versucht und behalten, was lesbar ist. Die
  Rohdaten wandern zusätzlich in einen eigenen Schlüssel, statt beim
  nächsten Speichern überschrieben zu werden.

Beides in run-tests.sh abgesichert: die Erkennung und Rückrechnung der
Verdrehung samt Gegenprobe ohne Korrektur, und das Lesen gespeicherter
Geräte ohne "twist", ganz ohne Einbaulage und mit unbrauchbarer.

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

Shared/Models/SensorOrientation.swift

@@ -23,16 +23,62 @@ struct SensorOrientation: Codable, Equatable, Hashable, Sendable {
     var invertLongitudinal = false
     var invertLateral = false
 
+    /// Verdrehung des Sensors um die Hochachse, in Grad – der Rest, den der
+    /// Achsentausch nicht abdeckt.
+    ///
+    /// Sitzt der Sensor schräg im Fahrzeug, verteilt sich eine reine
+    /// Querneigung auf beide Sensorachsen: Das Fahrzeug kippt zur Seite, die
+    /// Anzeige meldet zusätzlich Längsneigung. Achsentausch und Vorzeichen
+    /// helfen dagegen nicht, die springen in 90°-Schritten.
+    ///
+    /// Der Wert wird beim Bestimmen der Einbaulage mitgemessen und kostet
+    /// keinen zusätzlichen Handgriff. Beim **Kalibrieren** liesse er sich
+    /// nicht ermitteln: Das misst eine einzige Lage und zieht sie als Nullpunkt
+    /// ab – eine Drehung um die Hochachse ist darin nicht enthalten, denn eben
+    /// sieht in jeder Verdrehung gleich aus.
+    var twist: Double = 0
+
     static let identity = SensorOrientation()
 
+    init() {}
+
+    /// Von Hand geschrieben, nicht von Swift erzeugt – und das ist der Punkt.
+    ///
+    /// Die erzeugte Fassung verlangt beim Lesen jedes Feld; Standardwerte im
+    /// Code zählen dabei nicht. Eine Einbaulage, die vor `twist` gespeichert
+    /// wurde, liesse sich damit nicht mehr lesen, das Gerät dazu ebenso wenig,
+    /// und die Geräteliste bliebe leer. Jedes neue Feld gehört deshalb hier
+    /// hinein, mit `decodeIfPresent` und einem Rückfallwert.
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        longitudinalSource = try container.decodeIfPresent(Source.self,
+                                                           forKey: .longitudinalSource) ?? .pitch
+        invertLongitudinal = try container.decodeIfPresent(Bool.self,
+                                                           forKey: .invertLongitudinal) ?? false
+        invertLateral = try container.decodeIfPresent(Bool.self, forKey: .invertLateral) ?? false
+        twist = try container.decodeIfPresent(Double.self, forKey: .twist) ?? 0
+    }
+
     var isIdentity: Bool { self == .identity }
 
     /// Rechnet Sensorwerte in Fahrzeugwerte um.
+    ///
+    /// Zwei Schritte, in dieser Reihenfolge: erst die grobe Zuordnung der
+    /// Achsen samt Vorzeichen, dann die Verdrehung zurückdrehen. Für kleine
+    /// Winkel verhält sich das Wertepaar wie ein Vektor in der Ebene – genau
+    /// deshalb lässt sich die Verdrehung überhaupt herausrechnen.
     func apply(pitch: Double?, roll: Double?) -> (pitch: Double?, roll: Double?) {
         let longitudinal = longitudinalSource == .pitch ? pitch : roll
         let lateral = longitudinalSource == .pitch ? roll : pitch
-        return (longitudinal.map { invertLongitudinal ? -$0 : $0 },
-                lateral.map { invertLateral ? -$0 : $0 })
+        let mappedLongitudinal = longitudinal.map { invertLongitudinal ? -$0 : $0 }
+        let mappedLateral = lateral.map { invertLateral ? -$0 : $0 }
+
+        guard twist != 0, let long = mappedLongitudinal, let lat = mappedLateral else {
+            return (mappedLongitudinal, mappedLateral)
+        }
+        let angle = twist * .pi / 180
+        return (long * cos(angle) + lat * sin(angle),
+                -long * sin(angle) + lat * cos(angle))
     }
 
     var summary: String {
@@ -41,6 +87,7 @@ struct SensorOrientation: Codable, Equatable, Hashable, Sendable {
         if longitudinalSource == .roll { parts.append("Achsen getauscht") }
         if invertLongitudinal { parts.append("längs umgekehrt") }
         if invertLateral { parts.append("quer umgekehrt") }
+        if twist != 0 { parts.append(String(format: "um %.0f° verdreht", twist)) }
         return parts.joined(separator: ", ")
     }
 }
@@ -59,6 +106,9 @@ enum OrientationDetection {
     /// Soviel deutlicher muss die gewinnende Deutung sein als die andere.
     static let ambiguityMargin = 1.3
 
+    /// Ab hier gilt eine Verdrehung als echt und nicht als Wackeln der Hand.
+    static let minimumTwist = 2.0
+
     struct Reading: Equatable {
         let pitch: Double
         let roll: Double
@@ -130,6 +180,24 @@ enum OrientationDetection {
         // Linke Seite nach unten heisst: rechts steht höher, die Querneigung
         // ist positiv.
         orientation.invertLateral = lateral < 0
+
+        // Was nach dem Achsentausch noch übrig ist, ist die Verdrehung um die
+        // Hochachse. Beim Kippen der Front nach unten dürfte sich nur die
+        // Längsneigung ändern; wandert die Querneigung mit, sitzt der Sensor
+        // schräg – und zwar um genau diesen Winkel.
+        //
+        // Gemessen wird an der Frontbewegung, nicht an der Seitenbewegung: Die
+        // Front lässt sich am Fahrzeug genauer treffen, und beide Schritte
+        // gemeinsam auszuwerten brächte hier nichts, weil eine Verdrehung auf
+        // beide gleich wirkt.
+        let corrected = orientation.apply(pitch: nose.pitch, roll: nose.roll)
+        if let long = corrected.pitch, let lat = corrected.roll {
+            let residual = atan2(lat, long) * 180 / .pi
+            // Unter zwei Grad ist es Messrauschen. Zwei Kippbewegungen von Hand
+            // sind nicht genauer, und eine erfundene Verdrehung wäre schlimmer
+            // als keine.
+            orientation.twist = abs(residual) >= minimumTwist ? residual : 0
+        }
         return .success(orientation)
     }
 }