MSP protocol implementation and settings menu

2026-07-30 21:18:48 +02:00
parent 5994aee7ad
commit 078d58dbc0
16 changed files with 1132 additions and 29 deletions
@@ -0,0 +1,101 @@
+import 'dart:typed_data';
+
+import 'msp_frame.dart';
+
+enum _State { idle, waitingForX, waitingForDirection, header, payload, checksum }
+
+/// Streaming-Dekodierer fuer MSPv2-Rahmen (Doku Kommunikationsschicht
+/// Abschnitt 4): der Byte-Strom von der Gegenstelle kommt fragmentiert an
+/// (RFCOMM liefert kein "ein Paket pro Lesevorgang"), also ein
+/// Zustandsautomat statt eines naiven Parsers - ein Byte pro Aufruf, egal
+/// wie [addBytes] geschnitten wird. Zustaende gespiegelt aus iNAVs
+/// `msp_serial.c` (`mspState_e`), reduziert auf den MSPv2-Native-Pfad, da
+/// die Gegenstelle (mLRS-Backpack) ausschliesslich MSPv2 spricht - iNAV
+/// benoetigt MSPv2, MSPv1 reicht laut Doku nicht.
+///
+/// Fehlerhafte Rahmen (CRC-Mismatch, unbekanntes Richtungszeichen, zu grosse
+/// gemeldete Payload-Groesse) werden stillschweigend verworfen und der
+/// Automat kehrt in den Idle-Zustand zurueck, ohne den weiteren Strom zu
+/// verlieren (Abnahmekriterium: "Fehlerhafte Rahmen werden verworfen, ohne
+/// den Strom zu verlieren").
+class MspFrameDecoder {
+  /// Schutz vor unbegrenztem Speicherwachstum, falls eine als Muell
+  /// interpretierte Payload-Groesse absurd gross waere - kein reales
+  /// MSP-Kommando braucht mehr.
+  static const int maxPayloadSize = 4096;
+
+  _State _state = _State.idle;
+  MspDirection _direction = MspDirection.response;
+  final List<int> _headerBytes = [];
+  int _function = 0;
+  int _payloadSize = 0;
+  final List<int> _payloadBytes = [];
+  int _crc = 0;
+
+  /// Verarbeitet [chunk] und liefert alle Rahmen, die dadurch vollstaendig
+  /// wurden (0, 1 oder mehrere, je nachdem wie der Strom geschnitten ist).
+  List<MspFrame> addBytes(Uint8List chunk) {
+    final frames = <MspFrame>[];
+    for (final byte in chunk) {
+      final frame = _consume(byte);
+      if (frame != null) frames.add(frame);
+    }
+    return frames;
+  }
+
+  MspFrame? _consume(int byte) {
+    switch (_state) {
+      case _State.idle:
+        if (byte == mspDollarByte) _state = _State.waitingForX;
+        return null;
+
+      case _State.waitingForX:
+        _state = byte == mspXByte ? _State.waitingForDirection : _State.idle;
+        return null;
+
+      case _State.waitingForDirection:
+        final direction = mspDirectionForByte(byte);
+        if (direction == null) {
+          _state = _State.idle;
+          return null;
+        }
+        _direction = direction;
+        _headerBytes.clear();
+        _crc = 0;
+        _state = _State.header;
+        return null;
+
+      case _State.header:
+        _headerBytes.add(byte);
+        _crc = crc8DvbS2(_crc, byte);
+        if (_headerBytes.length == 5) {
+          _function = _headerBytes[1] | (_headerBytes[2] << 8);
+          _payloadSize = _headerBytes[3] | (_headerBytes[4] << 8);
+          if (_payloadSize > maxPayloadSize) {
+            _state = _State.idle;
+            return null;
+          }
+          _payloadBytes.clear();
+          _state = _payloadSize == 0 ? _State.checksum : _State.payload;
+        }
+        return null;
+
+      case _State.payload:
+        _payloadBytes.add(byte);
+        _crc = crc8DvbS2(_crc, byte);
+        if (_payloadBytes.length == _payloadSize) {
+          _state = _State.checksum;
+        }
+        return null;
+
+      case _State.checksum:
+        _state = _State.idle;
+        if (byte != _crc) return null;
+        return MspFrame(
+          direction: _direction,
+          function: _function,
+          payload: Uint8List.fromList(_payloadBytes),
+        );
+    }
+  }
+}