Verbindungssturm abstellen, Einbaulage des Sensors einrichtbar

Zwei Dinge.

Die Kühlbox piepte dauernd und die Bedienung wurde zäh. Ursache war ein
Fehler in der Verbindungslogik: nach einem fehlgeschlagenen Versuch wurde
der Eintrag freigegeben, und das nächste Advertisement löste sofort den
nächsten aus - bei laufendem Scan bis zu einmal je Sekunde. Geräte
quittieren jeden Versuch, Kühlboxen mit einem Piepton. Nebenher wechselte
der Verbindungszustand im selben Takt, was die Oberfläche in eine
Dauerneuzeichnung trieb.

Ein Versuch wird jetzt für eine Weile gesperrt, mit wachsendem Abstand von
fünf bis sechzig Sekunden. Auch nach einem Trennen durch die Gegenseite
wird nicht sofort neu angeklopft - trennt ein Gerät von sich aus, etwa
weil eine andere App verbunden ist, entstünde sonst ein Wechselspiel aus
Verbinden und Trennen. Beim Umkonfigurieren werden die Sperren
zurückgesetzt, damit ein neu eingerichtetes Gerät sofort drankommt.

Dazu entlastet: bei jeder Antwort wurden alle fünf Protokollparser
durchprobiert, auch wenn längst feststand, welches Protokoll gilt. Steht
der Dialekt, läuft nur noch dieser.

Zweitens der Neigungsmesser: je nach Einbaulage meldet er längs und quer
vertauscht oder mit falschem Vorzeichen. Statt die Lage aus einer Liste
raten zu lassen, misst der neue Assistent sie - zweimal kippen, einmal um
jede Achse, und aus der Reaktion ergibt sich die Zuordnung. Schräges oder
zu schwaches Kippen wird erkannt und gemeldet, statt eine zufällige
Zuordnung zu liefern. Die Sitzung führt die Rohwerte des Sensors weiter
mit, weil der Assistent sie unumgerechnet braucht.

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

Tests/main.swift

@@ -741,5 +741,90 @@ checkEqual("innerhalb der Toleranz kein Keil",
 checkEqual("ohne Maß kein Keil",
            LevelingWedge.across(roll: 3.0, trackWidth: 0) == nil, true)
 
+// MARK: 12 – Einbaulage des Neigungsmessers
+print("\nEinbaulage")
+
+typealias Reading = OrientationDetection.Reading
+func detect(nose: Reading, side: Reading) -> Result<SensorOrientation, OrientationDetection.Failure> {
+    OrientationDetection.orientation(nose: nose, side: side)
+}
+
+// Gerade eingebaut: Kippen nach vorne bewegt die erste Achse ins Positive,
+// Kippen nach links die zweite.
+if case .success(let straight) = detect(nose: Reading(pitch: 12, roll: 0),
+                                        side: Reading(pitch: 0, roll: 9)) {
+    checkEqual("gerade: Längsneigung von der ersten Achse",
+               straight.longitudinalSource, .pitch)
+    checkEqual("gerade: längs nicht umgekehrt", straight.invertLongitudinal, false)
+    checkEqual("gerade: quer nicht umgekehrt", straight.invertLateral, false)
+    checkEqual("gerade ist die unveränderte Lage", straight.isIdentity, true)
+    checkEqual("Beschreibung", straight.summary, "Achsen unverändert")
+} else {
+    check("gerade eingebaut wird erkannt", false)
+}
+
+// Um 180 Grad gedreht: beide Achsen kehren sich um.
+if case .success(let turned) = detect(nose: Reading(pitch: -12, roll: 0),
+                                      side: Reading(pitch: 0, roll: -9)) {
+    checkEqual("gedreht: Achse bleibt", turned.longitudinalSource, .pitch)
+    checkEqual("gedreht: längs umgekehrt", turned.invertLongitudinal, true)
+    checkEqual("gedreht: quer umgekehrt", turned.invertLateral, true)
+} else {
+    check("um 180 Grad gedreht wird erkannt", false)
+}
+
+// Quer eingebaut: die Achsen sind vertauscht.
+if case .success(let sideways) = detect(nose: Reading(pitch: 0, roll: 11),
+                                        side: Reading(pitch: -8, roll: 0)) {
+    checkEqual("quer: Längsneigung von der zweiten Achse",
+               sideways.longitudinalSource, .roll)
+    checkEqual("quer: längs nicht umgekehrt", sideways.invertLongitudinal, false)
+    checkEqual("quer: quer umgekehrt", sideways.invertLateral, true)
+    checkEqual("Beschreibung nennt den Tausch",
+               sideways.summary.contains("getauscht"), true)
+} else {
+    check("quer eingebaut wird erkannt", false)
+}
+
+// Zu wenig gekippt.
+if case .failure(let failure) = detect(nose: Reading(pitch: 2, roll: 0),
+                                       side: Reading(pitch: 0, roll: 9)) {
+    checkEqual("zu wenig Bewegung wird gemeldet", failure, .tooLittleMovement)
+} else {
+    check("zu wenig Bewegung wird abgefangen", false)
+}
+
+// Schräg gekippt: beide Achsen ähnlich stark, keine Zuordnung möglich.
+if case .failure(let failure) = detect(nose: Reading(pitch: 9, roll: 8),
+                                       side: Reading(pitch: 0, roll: 9)) {
+    checkEqual("schräges Kippen wird gemeldet", failure, .ambiguous)
+} else {
+    check("schräges Kippen wird abgefangen", false)
+}
+
+// Zweimal um dieselbe Achse gekippt ergibt keine Zuordnung.
+if case .failure(let failure) = detect(nose: Reading(pitch: 10, roll: 0),
+                                       side: Reading(pitch: 9, roll: 0)) {
+    checkEqual("zweimal dieselbe Achse wird gemeldet", failure, .ambiguous)
+} else {
+    check("zweimal dieselbe Achse wird abgefangen", false)
+}
+
+// Die Umrechnung selbst
+var swapped = SensorOrientation()
+swapped.longitudinalSource = .roll
+swapped.invertLateral = true
+let converted = swapped.apply(pitch: 3, roll: -2)
+checkEqual("umgerechnet: längs kommt aus der zweiten Achse", converted.pitch, -2)
+checkEqual("umgerechnet: quer ist umgekehrt", converted.roll, -3)
+
+let untouched = SensorOrientation.identity.apply(pitch: 1.5, roll: -0.5)
+checkEqual("unveränderte Lage lässt längs stehen", untouched.pitch, 1.5)
+checkEqual("unveränderte Lage lässt quer stehen", untouched.roll, -0.5)
+
+let missing = SensorOrientation.identity.apply(pitch: nil, roll: 2)
+checkEqual("fehlende Werte bleiben leer", missing.pitch == nil, true)
+checkEqual("vorhandene Werte kommen durch", missing.roll, 2)
+
 print(failures == 0 ? "\nAlle Prüfungen bestanden." : "\n\(failures) Prüfung(en) fehlgeschlagen.")
 exit(failures == 0 ? 0 : 1)