forked from fritob/Camper-Monitor
Kalibrierung und Einbaulage gehören in den Sensor, nicht in die Apps
Die Kalibrier-Nullpunkte lagen schon immer im ESP und wurden dort auch
abgezogen – nur verriet die Firmware sie niemandem. Die Einbaulage lag
dagegen in jeder App einzeln, und damit stand sie bei drei Endgeräten
dreimal da, im Zweifel dreimal verschieden. Sie beschreibt aber den
Einbau und nicht das Telefon.
Zwei neue Charakteristiken:
...3426 Nullpunkte, zwei Floats, nur lesen
...3428 Einbaulage, acht Byte, lesen und schreiben
0 Version, 1 = gültig gesetzt, 0 = nie geschrieben
1 Längsachse: 0 = Pitch des Sensors, 1 = Roll
2 längs umgekehrt (0/1)
3 quer umgekehrt (0/1)
4..7 Verdrehung um die Hochachse, float32, Grad
Das Versionsbyte löst die Umstellung: Steht dort 0, hat nie jemand
geschrieben – dann gilt weiter, was die App örtlich gespeichert hat, und
beim nächsten Bestimmen wandert sie hinauf. Mit älterer Firmware ohne die
Charakteristik passiert schlicht nichts.
Angewandt wird die Lage weiterhin in den Apps. Der Sensor verwahrt sie
nur: Meldete er die Winkel bereits umgerechnet, rechnete jede ältere App
die Korrektur ein zweites Mal ein.
Beim Verbinden liest jede App die Lage und übernimmt sie; nach dem
Einbaulage-Assistenten schreibt sie sie hinauf. Die Uhr braucht das
iPhone dafür nicht mehr – sie holt sie sich selbst. Die Android-App
bekommt dabei auch die Verdrehung, die ihrer Fassung bisher ganz fehlte:
Modell, Erkennung und Persistenz nachgezogen.
Geprüft: Firmware übersetzt, im erzeugten Code stehen beide
Charakteristiken mit den richtigen Rechten und der Schreib-Handler;
iPhone- und Watch-Ziel bauen; sieben neue Prüfungen in run-tests.sh
nageln das Byte-Format fest, samt Rundlauf und der Bedeutung von
Version 0. Nicht geprüft ist die Android-Fassung: Auf dieser Maschine
liegt nur Java 8, Gradle verlangt mindestens 11.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
BiasF
@@ -18,6 +18,7 @@ final class LevelSession: NSObject {
|
||||
private static let rollUUID = CBUUID(string: VanAlignProtocol.rollUUID)
|
||||
private static let offsetsUUID = CBUUID(string: VanAlignProtocol.offsetsUUID)
|
||||
private static let calibrateUUID = CBUUID(string: VanAlignProtocol.calibrateUUID)
|
||||
private static let orientationUUID = CBUUID(string: VanAlignProtocol.orientationUUID)
|
||||
|
||||
let deviceID: UUID
|
||||
private let queue: DispatchQueue
|
||||
@@ -25,11 +26,16 @@ final class LevelSession: NSObject {
|
||||
private let onUpdate: (DeviceSnapshot) -> Void
|
||||
private let onStateChange: (DeviceLinkState) -> Void
|
||||
private let onLevelState: (LevelState) -> Void
|
||||
/// Meldet die Einbaulage, die im Gerät steht. Sie gilt vor der örtlich
|
||||
/// gespeicherten: dort steht, wie der Sensor eingebaut ist, und das ist für
|
||||
/// alle Clients dasselbe.
|
||||
private let onDeviceOrientation: ((SensorOrientation) -> Void)?
|
||||
|
||||
private var pitchCharacteristic: CBCharacteristic?
|
||||
private var rollCharacteristic: CBCharacteristic?
|
||||
private var offsetsCharacteristic: CBCharacteristic?
|
||||
private var calibrateCharacteristic: CBCharacteristic?
|
||||
private var orientationCharacteristic: CBCharacteristic?
|
||||
|
||||
private var state = LevelState()
|
||||
/// Aus den Geräteeinstellungen; rechnet Sensor- in Fahrzeugachsen um.
|
||||
@@ -49,7 +55,9 @@ final class LevelSession: NSObject {
|
||||
queue: DispatchQueue,
|
||||
onUpdate: @escaping (DeviceSnapshot) -> Void,
|
||||
onStateChange: @escaping (DeviceLinkState) -> Void,
|
||||
onLevelState: @escaping (LevelState) -> Void) {
|
||||
onLevelState: @escaping (LevelState) -> Void,
|
||||
onDeviceOrientation: ((SensorOrientation) -> Void)? = nil) {
|
||||
self.onDeviceOrientation = onDeviceOrientation
|
||||
self.deviceID = deviceID
|
||||
self.queue = queue
|
||||
self.peripheral = peripheral
|
||||
@@ -89,6 +97,28 @@ final class LevelSession: NSObject {
|
||||
rollCharacteristic = nil
|
||||
offsetsCharacteristic = nil
|
||||
calibrateCharacteristic = nil
|
||||
orientationCharacteristic = nil
|
||||
}
|
||||
|
||||
// MARK: - Einbaulage im Gerät
|
||||
|
||||
/// Schreibt die Einbaulage ins Gerät, damit alle Clients dieselbe sehen.
|
||||
///
|
||||
/// Ältere Firmware hat die Charakteristik nicht; dann bleibt es bei der
|
||||
/// örtlich gespeicherten Fassung, und es passiert schlicht nichts.
|
||||
func storeOrientation(_ orientation: SensorOrientation) {
|
||||
guard let characteristic = orientationCharacteristic,
|
||||
peripheral.state == .connected else { return }
|
||||
let type: CBCharacteristicWriteType =
|
||||
characteristic.properties.contains(.write) ? .withResponse : .withoutResponse
|
||||
peripheral.writeValue(VanAlignProtocol.encoded(orientation),
|
||||
for: characteristic, type: type)
|
||||
// Zurücklesen, damit angezeigt wird, was wirklich im Gerät steht.
|
||||
queue.asyncAfter(deadline: .now() + 0.3) { [weak self] in
|
||||
guard let self, let characteristic = self.orientationCharacteristic,
|
||||
self.peripheral.state == .connected else { return }
|
||||
self.peripheral.readValue(for: characteristic)
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Kalibrieren
|
||||
@@ -169,7 +199,8 @@ extension LevelSession: CBPeripheralDelegate {
|
||||
return
|
||||
}
|
||||
peripheral.discoverCharacteristics(
|
||||
[Self.pitchUUID, Self.rollUUID, Self.offsetsUUID, Self.calibrateUUID],
|
||||
[Self.pitchUUID, Self.rollUUID, Self.offsetsUUID,
|
||||
Self.calibrateUUID, Self.orientationUUID],
|
||||
for: service
|
||||
)
|
||||
}
|
||||
@@ -188,6 +219,7 @@ extension LevelSession: CBPeripheralDelegate {
|
||||
case Self.rollUUID: rollCharacteristic = characteristic
|
||||
case Self.offsetsUUID: offsetsCharacteristic = characteristic
|
||||
case Self.calibrateUUID: calibrateCharacteristic = characteristic
|
||||
case Self.orientationUUID: orientationCharacteristic = characteristic
|
||||
default: break
|
||||
}
|
||||
}
|
||||
@@ -210,7 +242,8 @@ extension LevelSession: CBPeripheralDelegate {
|
||||
startPollingIfNeeded()
|
||||
|
||||
// Einmal alles lesen, damit sofort etwas dasteht.
|
||||
for characteristic in [pitchCharacteristic, rollCharacteristic, offsetsCharacteristic] {
|
||||
for characteristic in [pitchCharacteristic, rollCharacteristic,
|
||||
offsetsCharacteristic, orientationCharacteristic] {
|
||||
guard let characteristic, characteristic.properties.contains(.read) else { continue }
|
||||
peripheral.readValue(for: characteristic)
|
||||
}
|
||||
@@ -233,6 +266,16 @@ extension LevelSession: CBPeripheralDelegate {
|
||||
state.pitchOffset = offsets.pitch
|
||||
state.rollOffset = offsets.roll
|
||||
}
|
||||
case Self.orientationUUID:
|
||||
// Was im Gerät steht, gilt: es beschreibt den Einbau, nicht das
|
||||
// Telefon. Steht dort nichts (Version 0), bleibt es bei der
|
||||
// örtlichen Fassung – der Aufrufer schreibt sie dann hinauf.
|
||||
guard let stored = VanAlignProtocol.orientation(from: value) else { return }
|
||||
if stored != orientation {
|
||||
orientation = stored
|
||||
}
|
||||
onDeviceOrientation?(stored)
|
||||
return
|
||||
default:
|
||||
return
|
||||
}
|
||||
|
||||
@@ -16,6 +16,8 @@ enum VanAlignProtocol {
|
||||
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"
|
||||
/// Acht Byte: die Einbaulage, lesbar und schreibbar. Siehe `orientation`.
|
||||
static let orientationUUID = "CAD48E28-7FBE-41CF-BAE9-D77A6C233428"
|
||||
|
||||
static let calibrateCommand = Data([0x01])
|
||||
static let resetCommand = Data([0x00])
|
||||
@@ -41,6 +43,50 @@ enum VanAlignProtocol {
|
||||
return Double(value)
|
||||
}
|
||||
|
||||
/// Die Einbaulage, wie sie im Gerät liegt.
|
||||
///
|
||||
/// Acht Byte:
|
||||
///
|
||||
/// 0 Version, 1 = gültig gesetzt, 0 = nie geschrieben
|
||||
/// 1 Längsachse: 0 = Pitch des Sensors, 1 = Roll des Sensors
|
||||
/// 2 längs umgekehrt (0/1)
|
||||
/// 3 quer umgekehrt (0/1)
|
||||
/// 4..7 Verdrehung um die Hochachse, float32, Grad
|
||||
///
|
||||
/// Sie gehört ins Gerät, weil sie den Einbau beschreibt und nicht das
|
||||
/// Telefon: iPhone, Uhr und Android sollen dieselbe sehen, ohne sie je
|
||||
/// einzeln zu bestimmen. Gerechnet wird trotzdem in den Apps – das Gerät
|
||||
/// verwahrt sie nur, sonst rechnete ein älterer Client die Korrektur ein
|
||||
/// zweites Mal ein.
|
||||
///
|
||||
/// Version 0 heisst „hier stand noch nie etwas“ und ergibt nil; dann gilt,
|
||||
/// was die App örtlich gespeichert hat, und sie schreibt es hinauf.
|
||||
static func orientation(from data: Data) -> SensorOrientation? {
|
||||
let bytes = [UInt8](data)
|
||||
guard bytes.count >= 8, bytes[0] == 1 else { return nil }
|
||||
var orientation = SensorOrientation()
|
||||
orientation.longitudinalSource = bytes[1] == 1 ? .roll : .pitch
|
||||
orientation.invertLongitudinal = bytes[2] != 0
|
||||
orientation.invertLateral = bytes[3] != 0
|
||||
guard let twist = angle(from: data.dropFirst(4).prefix(4)) else { return nil }
|
||||
orientation.twist = twist
|
||||
return orientation
|
||||
}
|
||||
|
||||
/// Dieselben acht Byte in die andere Richtung.
|
||||
static func encoded(_ orientation: SensorOrientation) -> Data {
|
||||
var bytes = [UInt8](repeating: 0, count: 8)
|
||||
bytes[0] = 1
|
||||
bytes[1] = orientation.longitudinalSource == .roll ? 1 : 0
|
||||
bytes[2] = orientation.invertLongitudinal ? 1 : 0
|
||||
bytes[3] = orientation.invertLateral ? 1 : 0
|
||||
let raw = Float(orientation.twist).bitPattern
|
||||
for index in 0..<4 {
|
||||
bytes[4 + index] = UInt8((raw >> UInt32(8 * index)) & 0xFF)
|
||||
}
|
||||
return Data(bytes)
|
||||
}
|
||||
|
||||
/// Die beiden gespeicherten Offsets.
|
||||
static func offsets(from data: Data) -> (pitch: Double, roll: Double)? {
|
||||
guard data.count >= 8,
|
||||
|
||||
Reference in New Issue
Block a user