fritob/Camper-Monitor
1
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Kalibrierung und Einbaulage gehören in den Sensor, nicht in die Apps

Browse Source 
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
2026-08-31 20:50:23 +02:00
co-authored by Claude Opus 5
parent 0761706d98
commit f0df433421
13 changed files with 470 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Android/app/src/main/kotlin/de/fritob/campermonitor/bluetooth/BluetoothManager.kt
+30 -1
View File
@@ -372,6 +372,11 @@ class BluetoothManager(
onUpdate = { record(it) },
onStateChange = { handleLinkState(device, it) },
onLevelState = { state -> publish { levelStates[device.id] = state } },
onDeviceOrientation = { orientation ->
// Im Gerät steht, wie der Sensor eingebaut ist – für alle
// Clients dasselbe. Also übernehmen statt überschreiben.
adoptOrientation(orientation, device.id)
},
)
session.orientation = device.sensorOrientation
levelSessions[device.address] = session
@@ -642,8 +647,32 @@ class BluetoothManager(
// MARK: - Neigungsmesser
/**
* Nach einer Änderung der Einbaulage aufrufen.
*
* Die Lage wandert zusätzlich ins Gerät. Dort gehört sie hin: Sie
* beschreibt den Einbau, und iPhone wie Uhr finden sie dann vor, ohne dass
* jemand sie ein zweites Mal bestimmen muss.
*/
fun updateSensorOrientation(device: ConfiguredDevice) {
handler.post { levelSessions[device.address]?.orientation = device.sensorOrientation }
handler.post {
val session = levelSessions[device.address] ?: return@post
session.orientation = device.sensorOrientation
session.storeOrientation(device.sensorOrientation)
}
}
/**
* Übernimmt die Einbaulage, die das Gerät meldet.
*
* Steht dort noch nichts, meldet das Gerät nichts – dann bleibt es bei der
* örtlich gespeicherten Fassung, und die wird beim nächsten Bestimmen
* hinaufgeschrieben.
*/
private fun adoptOrientation(orientation: SensorOrientation, deviceID: UUID) {
val device = store.devices.firstOrNull { it.id == deviceID } ?: return
if (device.sensorOrientation == orientation) return
store.update(device.copy(sensorOrientation = orientation))
}
fun calibrateLevel(deviceID: UUID) {
Android/app/src/main/kotlin/de/fritob/campermonitor/bluetooth/LevelSession.kt
+46
View File
@@ -30,6 +30,12 @@ class LevelSession(
private val onUpdate: (DeviceSnapshot) -> Unit,
private val onStateChange: (DeviceLinkState) -> Unit,
private val onLevelState: (LevelState) -> Unit,
/**
* 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 val onDeviceOrientation: (SensorOrientation) -> Unit = {},
) {
private companion object {
val SERVICE: UUID = UUID.fromString(VanAlignProtocol.SERVICE_UUID)
@@ -37,6 +43,7 @@ class LevelSession(
val ROLL: UUID = UUID.fromString(VanAlignProtocol.ROLL_UUID)
val OFFSETS: UUID = UUID.fromString(VanAlignProtocol.OFFSETS_UUID)
val CALIBRATE: UUID = UUID.fromString(VanAlignProtocol.CALIBRATE_UUID)
val ORIENTATION: UUID = UUID.fromString(VanAlignProtocol.ORIENTATION_UUID)
val CLIENT_CONFIG: UUID = UUID.fromString("00002902-0000-1000-8000-00805F9B34FB")
const val POLL_INTERVAL_MS = 1_000L
}
@@ -53,6 +60,7 @@ class LevelSession(
private var rollCharacteristic: BluetoothGattCharacteristic? = null
private var offsetsCharacteristic: BluetoothGattCharacteristic? = null
private var calibrateCharacteristic: BluetoothGattCharacteristic? = null
private var orientationCharacteristic: BluetoothGattCharacteristic? = null
/** Ob die Firmware die Werte von sich aus meldet. */
private var needsPolling = true
@@ -84,6 +92,7 @@ class LevelSession(
rollCharacteristic = null
offsetsCharacteristic = null
calibrateCharacteristic = null
orientationCharacteristic = null
}
/** Setzt die aktuelle Lage als neue Null. */
@@ -107,6 +116,22 @@ class LevelSession(
handler.postDelayed({ readOffsets() }, 400)
}
/**
* 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.
*/
fun storeOrientation(value: SensorOrientation) {
val characteristic = orientationCharacteristic ?: return
val g = gatt ?: return
characteristic.writeType = BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT
characteristic.value = VanAlignProtocol.encoded(value)
g.writeCharacteristic(characteristic)
// Zurücklesen, damit gilt, was wirklich im Gerät steht.
handler.postDelayed({ gatt?.readCharacteristic(characteristic) }, 300)
}
private fun readOffsets() {
val characteristic = offsetsCharacteristic ?: return
gatt?.readCharacteristic(characteristic)
@@ -169,6 +194,7 @@ class LevelSession(
rollCharacteristic = service.getCharacteristic(ROLL)
offsetsCharacteristic = service.getCharacteristic(OFFSETS)
calibrateCharacteristic = service.getCharacteristic(CALIBRATE)
orientationCharacteristic = service.getCharacteristic(ORIENTATION)
val canNotify = pitchCharacteristic?.let {
it.properties and BluetoothGattCharacteristic.PROPERTY_NOTIFY != 0
@@ -267,6 +293,26 @@ class LevelSession(
state = state.copy(pitchOffset = pitch, rollOffset = roll)
}
publish()
// Android lässt nur eine Abfrage gleichzeitig zu, deshalb der
// Reihe nach: erst die Offsets, dann die Einbaulage, dann der
// Takt. Fehlt die Charakteristik – ältere Firmware –, geht es
// sofort weiter.
val characteristic = orientationCharacteristic
if (characteristic != null) {
gatt?.readCharacteristic(characteristic)
} else {
startPollingIfNeeded()
}
}
ORIENTATION -> {
// Was im Gerät steht, gilt. Steht dort nichts (Version 0),
// bleibt es bei der örtlichen Fassung, und der Aufrufer
// schreibt sie hinauf.
VanAlignProtocol.orientation(value)?.let { stored ->
if (stored != orientation) orientation = stored
onDeviceOrientation(stored)
}
startPollingIfNeeded()
}
}
Android/app/src/main/kotlin/de/fritob/campermonitor/store/DeviceStore.kt
+4
View File
@@ -206,6 +206,7 @@ class DeviceStore(context: Context) {
put("orientationSource", device.sensorOrientation.longitudinalSource.name)
put("invertLongitudinal", device.sensorOrientation.invertLongitudinal)
put("invertLateral", device.sensorOrientation.invertLateral)
put("twist", device.sensorOrientation.twist)
}
private fun deviceFrom(json: JSONObject): ConfiguredDevice? {
@@ -227,6 +228,9 @@ class DeviceStore(context: Context) {
}.getOrDefault(SensorOrientation.Source.PITCH),
invertLongitudinal = json.optBoolean("invertLongitudinal", false),
invertLateral = json.optBoolean("invertLateral", false),
// Fehlt der Wert, ist er null – so überleben Einrichtungen aus
// der Zeit vor der Verdrehung.
twist = json.optDouble("twist", 0.0),
),
)
}
Android/protocol/src/main/kotlin/de/fritob/campermonitor/protocol/SensorOrientation.kt
+58 -12
View File
@@ -1,6 +1,9 @@
package de.fritob.campermonitor.protocol
import kotlin.math.abs
import kotlin.math.atan2
import kotlin.math.cos
import kotlin.math.sin
/**
* Wie der Neigungsmesser im Fahrzeug sitzt.
@@ -21,18 +24,42 @@ data class SensorOrientation(
val longitudinalSource: Source = Source.PITCH,
val invertLongitudinal: Boolean = false,
val invertLateral: Boolean = 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.
*/
val twist: Double = 0.0,
) {
/** Welche Achse des Sensors die Längsneigung des Fahrzeugs liefert. */
enum class Source { PITCH, ROLL }
val isIdentity: Boolean get() = this == IDENTITY
/** Rechnet Sensorwerte in Fahrzeugwerte um. */
/**
* 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.
*/
fun apply(pitch: Double?, roll: Double?): Pair<Double?, Double?> {
val longitudinal = if (longitudinalSource == Source.PITCH) pitch else roll
val lateral = if (longitudinalSource == Source.PITCH) roll else pitch
return longitudinal?.let { if (invertLongitudinal) -it else it } to
lateral?.let { if (invertLateral) -it else it }
val mappedLongitudinal = longitudinal?.let { if (invertLongitudinal) -it else it }
val mappedLateral = lateral?.let { if (invertLateral) -it else it }
if (twist == 0.0 || mappedLongitudinal == null || mappedLateral == null) {
return mappedLongitudinal to mappedLateral
}
val angle = Math.toRadians(twist)
return (mappedLongitudinal * cos(angle) + mappedLateral * sin(angle)) to
(-mappedLongitudinal * sin(angle) + mappedLateral * cos(angle))
}
val summary: String
@@ -42,6 +69,7 @@ data class SensorOrientation(
if (longitudinalSource == Source.ROLL) parts.add("Achsen getauscht")
if (invertLongitudinal) parts.add("längs umgekehrt")
if (invertLateral) parts.add("quer umgekehrt")
if (twist != 0.0) parts.add("um %.0f° verdreht".format(twist))
return parts.joinToString(", ")
}
@@ -68,6 +96,9 @@ object OrientationDetection {
/** Soviel deutlicher muss die gewinnende Deutung sein als die andere. */
const val AMBIGUITY_MARGIN = 1.3
/** Ab hier gilt eine Verdrehung als echt und nicht als Wackeln der Hand. */
const val MINIMUM_TWIST = 2.0
data class Reading(val pitch: Double, val roll: Double) {
operator fun minus(other: Reading) = Reading(pitch - other.pitch, roll - other.roll)
}
@@ -131,16 +162,31 @@ object OrientationDetection {
if (abs(longitudinal) < MINIMUM_TILT || abs(lateral) < MINIMUM_TILT) {
return Result.Error(Failure.TOO_LITTLE_MOVEMENT)
}
val coarse = SensorOrientation(
longitudinalSource = source,
// Front nach unten heisst: das Heck steht höher, die
// Längsneigung des Fahrzeugs ist also positiv.
invertLongitudinal = longitudinal < 0,
// Linke Seite nach unten heisst: rechts steht höher, die
// Querneigung ist positiv.
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.
val (correctedLong, correctedLat) = coarse.apply(nose.pitch, nose.roll)
val residual = if (correctedLong != null && correctedLat != null) {
Math.toDegrees(atan2(correctedLat, correctedLong))
} else {
0.0
}
// Unter zwei Grad ist es Messrauschen. Zwei Kippbewegungen von Hand
// sind nicht genauer, und eine erfundene Verdrehung wäre schlimmer
// als keine.
return Result.Success(
SensorOrientation(
longitudinalSource = source,
// Front nach unten heisst: das Heck steht höher, die
// Längsneigung des Fahrzeugs ist also positiv.
invertLongitudinal = longitudinal < 0,
// Linke Seite nach unten heisst: rechts steht höher, die
// Querneigung ist positiv.
invertLateral = lateral < 0,
)
coarse.copy(twist = if (abs(residual) >= MINIMUM_TWIST) residual else 0.0)
)
}
}
Android/protocol/src/main/kotlin/de/fritob/campermonitor/protocol/VanAlignProtocol.kt
+52
View File
@@ -24,6 +24,9 @@ object VanAlignProtocol {
/** Ein Byte: 0 setzt zurück, alles andere kalibriert auf die aktuelle Lage. */
const val CALIBRATE_UUID = "CAD48E28-7FBE-41CF-BAE9-D77A6C233427"
/** Acht Byte: die Einbaulage, lesbar und schreibbar. Siehe [orientation]. */
const val ORIENTATION_UUID = "CAD48E28-7FBE-41CF-BAE9-D77A6C233428"
val calibrateCommand = byteArrayOf(0x01)
val resetCommand = byteArrayOf(0x00)
@@ -50,6 +53,55 @@ object VanAlignProtocol {
return value.toDouble()
}
/**
* 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 null; dann gilt,
* was die App örtlich gespeichert hat, und sie schreibt es hinauf.
*/
fun orientation(data: ByteArray): SensorOrientation? {
if (data.size < 8 || data.u(0) != 1) return null
val twist = angle(data, 4) ?: return null
return SensorOrientation(
longitudinalSource = if (data.u(1) == 1) {
SensorOrientation.Source.ROLL
} else {
SensorOrientation.Source.PITCH
},
invertLongitudinal = data.u(2) != 0,
invertLateral = data.u(3) != 0,
twist = twist,
)
}
/** Dieselben acht Byte in die andere Richtung. */
fun encoded(orientation: SensorOrientation): ByteArray {
val bytes = ByteArray(8)
bytes[0] = 1
bytes[1] = if (orientation.longitudinalSource == SensorOrientation.Source.ROLL) 1 else 0
bytes[2] = if (orientation.invertLongitudinal) 1 else 0
bytes[3] = if (orientation.invertLateral) 1 else 0
val raw = orientation.twist.toFloat().toRawBits()
for (index in 0 until 4) {
bytes[4 + index] = ((raw shr (8 * index)) and 0xFF).toByte()
}
return bytes
}
/** Die beiden gespeicherten Offsets. */
fun offsets(data: ByteArray): Pair<Double, Double>? {
if (data.size < 8) return null