goTool/main.go

@@ -3,11 +3,8 @@ package main
 import (
 	"context"
 	"encoding/binary"
-	"flag"
 	"fmt"
 	"log"
-	"os"
-	"time"
 
 	"github.com/pterm/pterm"
 	"go.bug.st/serial"
@@ -15,19 +12,6 @@ import (
 
 type ParserState int
 
-const (
-	// MISC
-	UART_ECHO        = 0x01
-	UART_VERSION     = 0x02
-	UART_CLIENT_INFO = 0x03
-
-	// OTA
-	UART_OTA_START   = 0x10
-	UART_OTA_PAYLOAD = 0x11
-	UART_OTA_END     = 0x12
-	UART_OTA_STATUS  = 0x13
-)
-
 const (
 	WAITING_FOR_START_BYTE ParserState = iota
 	ESCAPED_MESSAGE_ID
@@ -59,23 +43,6 @@ type MessageReceive struct {
 	raw_write_index int
 }
 
-type OTASyncManager struct {
-	OTA_MessageCounter         int
-	OTA_PayloadMessageSequence int
-	NewOTAMessage              chan MessageReceive
-	TimeoutMessage             time.Duration
-}
-
-func (ot *OTASyncManager) WaitForNextMessageTimeout() (*MessageReceive, error) {
-	select {
-	case msg := <-ot.NewOTAMessage:
-		log.Printf("OTASyncManager MessageReceive %v", msg)
-		return &msg, nil
-	case <-time.After(ot.TimeoutMessage):
-		return nil, fmt.Errorf("Message Timeout")
-	}
-}
-
 func initMessageReceive(mr *MessageReceive) {
 	mr.raw_message = make([]byte, 1024*4)
 	mr.parsed_message = make([]byte, 1024*4)
@@ -96,17 +63,7 @@ func addByteToParsedBuffer(mr *MessageReceive, pbyte byte) {
 	mr.checksum ^= pbyte
 }
 
-func parse_uart_ota_payload_payload(payloadBuffer []byte, payload_len int) {
+func parse_03_payload(payloadBuffer []byte, payload_len int) {
-	fmt.Printf("RAW BUFFER: % 02X", payloadBuffer[:payload_len])
-	if payload_len != 4 {
-		fmt.Printf("Payload should be 4 is %v", payload_len)
-		return
-	}
-
-	fmt.Printf("Sequence %v, WriteIndex %v", binary.LittleEndian.Uint16(payloadBuffer[0:1]), binary.LittleEndian.Uint16(payloadBuffer[2:3]))
-}
-
-func parse_uart_client_info_payload(payloadBuffer []byte, payload_len int) {
 
 	type payload_data struct {
 		ClientID           uint8
@@ -178,25 +135,12 @@ func parse_uart_client_info_payload(payloadBuffer []byte, payload_len int) {
 func message_receive_callback(mr MessageReceive) {
 	log.Printf("Message Received: % 02X\n", mr.raw_message[:mr.raw_write_index])
 	switch mr.parsed_message[0] {
-	case byte(UART_ECHO):
+	case 0x01:
 		break
-	case UART_VERSION:
+	case 0x02:
 		break
-	case UART_CLIENT_INFO:
+	case 0x03:
-		parse_uart_client_info_payload(mr.parsed_message, mr.write_index)
+		parse_03_payload(mr.parsed_message, mr.write_index)
-		break
-	case UART_OTA_START:
-		OTA_UpdateHandler.NewOTAMessage <- mr
-		break
-	case UART_OTA_PAYLOAD:
-		parse_uart_ota_payload_payload(mr.parsed_message, mr.write_index)
-		OTA_UpdateHandler.NewOTAMessage <- mr
-		break
-	case UART_OTA_END:
-		OTA_UpdateHandler.NewOTAMessage <- mr
-		break
-	case UART_OTA_STATUS:
-		OTA_UpdateHandler.NewOTAMessage <- mr
 		break
 	}
 }
@@ -206,7 +150,6 @@ func message_receive_failed_callback(mr MessageReceive) {
 }
 
 func parseByte(mr *MessageReceive, pbyte byte) {
-	fmt.Printf("Parsing %v", pbyte)
 	addByteToRawBuffer(mr, pbyte)
 	switch mr.state {
 	case WAITING_FOR_START_BYTE:
@@ -236,18 +179,18 @@ func parseByte(mr *MessageReceive, pbyte byte) {
 		}
 		if pbyte == START_BYTE {
 			mr.error = UNEXPECETD_BYTE
-			go message_receive_failed_callback(*mr)
+			message_receive_failed_callback(*mr)
 			initMessageReceive(mr)
 			return
 		}
 		if pbyte == END_BYTE {
 			if mr.checksum != 0 { // checksum wrong
 				mr.error = WRONG_CHECKSUM
-				go message_receive_failed_callback(*mr)
+				message_receive_failed_callback(*mr)
 				initMessageReceive(mr)
 				return
 			}
-			go message_receive_callback(*mr)
+			message_receive_callback(*mr)
 			initMessageReceive(mr)
 			break
 		}
@@ -297,22 +240,7 @@ func sendMessage(port serial.Port, sendBuffer []byte) {
 	fmt.Printf("Send Message % 02X\n", sendBuffer[:n])
 }
 
-var (
-	updatePath        string
-	OTA_UpdateHandler OTASyncManager
-)
-
 func main() {
-	flag.StringVar(&updatePath, "update", "", "Path to Updatefile")
-	flag.Parse()
-
-	OTA_UpdateHandler = OTASyncManager{
-		OTA_MessageCounter:         0,
-		OTA_PayloadMessageSequence: 0,
-		NewOTAMessage:              make(chan MessageReceive),
-		TimeoutMessage:             time.Millisecond * 1000,
-	}
-
 	mode := &serial.Mode{
 		BaudRate: 115200,
 	}
@@ -351,47 +279,6 @@ func main() {
 		}
 	}()
 
-	if updatePath != "" {
-		// start update
-		update, err := os.ReadFile(updatePath)
-		if err != nil {
-			log.Printf("Could not read Update file %v", err)
-			return
-		}
-		log.Printf("Update Buffer read, update size %v", len(update))
-		log.Printf("Gonna break it down in 200 Bytes packages will send %v packages", len(update)/200)
-
-		// start
-		payload_buffer := make([]byte, 1024)
-		send_buffer := make([]byte, 1024)
-		payload_buffer[0] = UART_OTA_START
-		n := buildMessage(payload_buffer, 1, send_buffer)
-		sendMessage(port, send_buffer[:n])
-		_, err = OTA_UpdateHandler.WaitForNextMessageTimeout()
-		if err != nil {
-			log.Printf("Error Message not acked %v", err)
-		} else {
-			log.Printf("Message Waiting hat funktionioert")
-		}
-
-		// write update parts
-
-		// end
-		payload_buffer = make([]byte, 1024)
-		send_buffer = make([]byte, 1024)
-		payload_buffer[0] = UART_OTA_END
-		n = buildMessage(payload_buffer, 1, send_buffer)
-		sendMessage(port, send_buffer[:n])
-
-		_, err = OTA_UpdateHandler.WaitForNextMessageTimeout()
-		if err != nil {
-			log.Printf("Error Message not acked %v", err)
-		} else {
-			log.Printf("Message Waiting hat funktionioert")
-		}
-		return
-	}
-
 	for {
 		var input string
 		_, err := fmt.Scanln(&input)
@@ -406,42 +293,24 @@ func main() {
 		case "1":
 			payload_buffer := make([]byte, 1024)
 			send_buffer := make([]byte, 1024)
-			payload_buffer[0] = UART_ECHO
+			payload_buffer[0] = 0x01
 			n := buildMessage(payload_buffer, 1, send_buffer)
 			sendMessage(port, send_buffer[:n])
 			break
 		case "2":
 			payload_buffer := make([]byte, 1024)
 			send_buffer := make([]byte, 1024)
-			payload_buffer[0] = UART_VERSION
+			payload_buffer[0] = 0x02
 			n := buildMessage(payload_buffer, 1, send_buffer)
 			sendMessage(port, send_buffer[:n])
 			break
 		case "3":
 			payload_buffer := make([]byte, 1024)
 			send_buffer := make([]byte, 1024)
-			payload_buffer[0] = UART_CLIENT_INFO
+			payload_buffer[0] = 0x03
 			n := buildMessage(payload_buffer, 1, send_buffer)
 			sendMessage(port, send_buffer[:n])
 			break
-		case "4": // start update
-			payload_buffer := make([]byte, 1024)
-			send_buffer := make([]byte, 1024)
-			payload_buffer[0] = UART_OTA_START
-			n := buildMessage(payload_buffer, 1, send_buffer)
-			sendMessage(port, send_buffer[:n])
-			break
-		case "5": // send payload
-			payload_buffer := make([]byte, 1024)
-			send_buffer := make([]byte, 1024)
-			payload_buffer[0] = UART_OTA_PAYLOAD
-			for i := range 200 {
-				payload_buffer[i+1] = byte(i)
-			}
-			n := buildMessage(payload_buffer, 201, send_buffer)
-			sendMessage(port, send_buffer[:n])
-			break
-		case "6": // end update
 		default:
 			fmt.Printf("Not a valid input")
 		}

main/main.c

@@ -19,7 +19,6 @@
 
 #include "communication_handler.h"
 #include "main.h"
-#include "ota_update.h"
 #include "uart_handler.h"
 #include <stdbool.h>
 #include <stddef.h>
@@ -290,8 +289,6 @@ void app_main(void) {
     RegisterCallback(0x02, versionCallback);
     RegisterCallback(0x03, clientInfoCallback);
 
-    init_ota(); 
-
     // xTaskCreate(uart_status_task, "MasterUartStatusTask", 4096, NULL, 1,
     // NULL); xTaskCreate(SendClientInfoTask, "SendCientInfo", 4096, NULL, 1,
     // NULL);

main/message_parser.h

@@ -4,7 +4,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#define MAX_MESSAGE_PAYLOAD_LENGTH 512
+#define MAX_MESSAGE_PAYLOAD_LENGTH 128
 #define MAX_TOTAL_CONTENT_LENGTH (MAX_MESSAGE_PAYLOAD_LENGTH + 1)
 
 enum ParserState {
@@ -33,7 +33,7 @@ struct MessageReceive {
   enum ParserError error;
   uint8_t messageid;
   uint8_t message[MAX_MESSAGE_PAYLOAD_LENGTH];
-  uint16_t index;
+  uint8_t index;
   uint8_t checksum;
 };
 

main/ota_update.c

@@ -1,70 +1,25 @@
 #include "ota_update.h"
-#include "driver/uart.h"
-#include "esp_err.h"
 #include "esp_log.h"
-#include "esp_ota_ops.h"
-#include "esp_partition.h"
-#include "message_builder.h"
 #include "message_handler.h"
-#include "uart_handler.h"
-#include "uart_msg_ids.h"
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
+static uint8_t updateBuffer[4000];
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-
-static uint8_t update_buffer[UPDATE_BUFFER_SIZE];
-static uint16_t update_buffer_write_index;
-static uint16_t sequenz_counter; // how often the update buffer gets written
 static const char *TAG = "ALOX - OTA";
-static esp_ota_handle_t update_handle;
-
-void prepare_ota_update() {
-  const esp_partition_t *running = esp_ota_get_running_partition();
-  ESP_LOGI(TAG, "OTA: Running Partition: %s", running->label);
-
-  char partition_to_update[] = "ota_0";
-  if (strcmp(running->label, "ota_0") == 0) {
-    strcpy(partition_to_update, "ota_1");
-  }
-
-  const esp_partition_t *update_partition = esp_partition_find_first(
-      ESP_PARTITION_TYPE_APP, ESP_PARTITION_SUBTYPE_ANY, partition_to_update);
-
-  // Check if the partition was found
-  if (update_partition == NULL) {
-    ESP_LOGE(TAG, "Failed to find OTA partition: %s", partition_to_update);
-    return; // Or handle the error appropriately
-  }
-
-  ESP_LOGI(TAG, "Gonna write OTA Update in Partition: %s",
-           update_partition->label);
-
-  esp_err_t err =
-      esp_ota_begin(update_partition, OTA_SIZE_UNKNOWN, &update_handle);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "esp_ota_begin failed (%s)", esp_err_to_name(err));
-    esp_ota_abort(update_handle);
-    return;
-  }
-
-  ESP_LOGI(TAG, "OTA update started successfully.");
-  // Proceed with writing the new firmware to the partition...
-}
 
 void start_uart_update(uint8_t msgid, const uint8_t *payload,
                        size_t payload_len, uint8_t *send_payload_buffer,
                        size_t send_payload_buffer_size, uint8_t *send_buffer,
                        size_t send_buffer_size) {
-  ESP_LOGI(TAG, "OTA Update Start Uart Command");
+  ESP_LOGI(TAG, "OTA Update Uart Command");
 
-  prepare_ota_update();
+  // prepare for writing new partition with ota api
+  // will get 200 bytes each uart message
+  // fill update buffer
+  // write update buffer complete
 
-  int send_payload_len = 2;
+  /*int len = build_message(0x02, send_payload_buffer, needed_buffer_size,
-  send_payload_buffer[0] = 0xff;
-  int len = build_message(UART_OTA_START, send_payload_buffer, send_payload_len,
                           send_buffer, send_buffer_size);
   if (len < 0) {
     ESP_LOGE(TAG,
@@ -73,81 +28,23 @@ void start_uart_update(uint8_t msgid, const uint8_t *payload,
              payload_len, send_buffer_size, len);
     return;
   }
-
+  uart_write_bytes(MASTER_UART, send_buffer, len - 1);*/
-  uart_write_bytes(MASTER_UART, send_buffer, len);
 }
 
 void payload_uart_update(uint8_t msgid, const uint8_t *payload,
                          size_t payload_len, uint8_t *send_payload_buffer,
                          size_t send_payload_buffer_size, uint8_t *send_buffer,
                          size_t send_buffer_size) {
-  ESP_LOGI(TAG, "OTA Update Payload Uart Command");
+  ESP_LOGI(TAG, "OTA Update Uart Command");
-
-  if (update_buffer_write_index < UPDATE_BUFFER_SIZE - UPDATE_PAYLOAD_SIZE) {
-    uint32_t write_len = MIN(UPDATE_PAYLOAD_SIZE, payload_len);
-    ESP_LOGI(TAG, "Writing Data to Update BUffer Sequence %d, writing Data %d",
-             sequenz_counter, write_len);
-    memcpy(&update_buffer[update_buffer_write_index], payload, write_len);
-    update_buffer_write_index += write_len;
-  } else {
-    ESP_LOGI(TAG, "Update Buffer full, writing it to OTA Update");
-
-    // write to ota
-    esp_err_t err =
-        esp_ota_write(update_handle, update_buffer, update_buffer_write_index);
-    if (err != ESP_OK) {
-      ESP_LOGE(TAG, "GOT ESP ERROR WRITE OTA %d", err);
-    }
-
-    update_buffer_write_index = 0;
-    sequenz_counter++;
-  }
-
-  size_t send_payload_len = 4;
-  memcpy(send_payload_buffer, &sequenz_counter, 2);
-  memcpy(&send_payload_buffer[2], &update_buffer_write_index, 2);
-
-  int len = build_message(UART_OTA_PAYLOAD, send_payload_buffer,
-                          send_payload_len, send_buffer, send_buffer_size);
-  if (len < 0) {
-    ESP_LOGE(TAG,
-             "Error Building UART Message: payload_len, %d, sendbuffer_size: "
-             "%d, mes_len(error): %d",
-             payload_len, send_buffer_size, len);
-    return;
-  }
-
-  uart_write_bytes(MASTER_UART, send_buffer, len);
 }
 
 void end_uart_update(uint8_t msgid, const uint8_t *payload, size_t payload_len,
                      uint8_t *send_payload_buffer,
                      size_t send_payload_buffer_size, uint8_t *send_buffer,
                      size_t send_buffer_size) {
-  ESP_LOGI(TAG, "OTA Update End Uart Command");
+  ESP_LOGI(TAG, "OTA Update Uart Command");
-  esp_err_t err = esp_ota_end(update_handle);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "GOT ESP ERROR WRITE OTA %d", err);
-  }
-
-  int send_payload_len = 0;
-  int len = build_message(UART_OTA_END, send_payload_buffer, send_payload_len,
-                          send_buffer, send_buffer_size);
-  if (len < 0) {
-    ESP_LOGE(TAG,
-             "Error Building UART Message: payload_len, %d, sendbuffer_size: "
-             "%d, mes_len(error): %d",
-             payload_len, send_buffer_size, len);
-    return;
-  }
-
-  uart_write_bytes(MASTER_UART, send_buffer, len);
 }
 
-void write_ota_update_from_uart_task(void *param) {}
-
 void init_ota() {
-  RegisterCallback(UART_OTA_START, start_uart_update);
+  RegisterCallback(uint8_t msgid, RegisterFunctionCallback callback);
-  RegisterCallback(UART_OTA_PAYLOAD, payload_uart_update);
-  RegisterCallback(UART_OTA_END, end_uart_update);
 }

main/ota_update.h

@@ -1,20 +1,4 @@
 #ifndef OTA_UPDATE_H
 #define OTA_UPDATE_H
 
-#define UPDATE_BUFFER_SIZE 4000
-#define UPDATE_PAYLOAD_SIZE 200
-#define UPDATE_MAX_SEQUENZES (UPDATE_BUFFER_SIZE/UPDATE_PAYLOAD_SIZE)
-
-void init_ota();
-
-enum OTA_UPDATE_STATES {
-	IDEL,
-	START_REQUESTED,
-	WAITING_FOR_PAYLOAD,
-	WRITING_OTA_TO_PARTITION,
-
-	
-	
-};
-
 #endif

tools/main.py

@@ -0,0 +1,248 @@
+import queue  # Zum sicheren Datenaustausch zwischen Threads
+import serial
+import time
+import threading
+import sys
+from parser import UartMessageParser, ParserError
+from message_builder import MessageBuilder, MessageBuilderError, PayloadTooLargeError, BufferOverflowError
+import payload_parser
+from rich.console import Console
+from rich.table import Table
+
+SERIAL_PORT = "/dev/ttyUSB0"
+BAUDRATE = 115200
+WRITE_TIMEOUT = 1.5
+READ_TIMEOUT = 2.0
+
+payload_parser = payload_parser.PayloadParser()
+
+
+def on_message_received_from_uart(parsed_message):
+    print(f"[CALLBACK] Nachricht empfangen: MSGID=0x{
+          parsed_message.msgid:02X}, Length={parsed_message.payload_len}")
+    received_message_queue.put(parsed_message)
+
+
+def on_message_fail_from_uart(error_message):
+    print(f"[CALLBACK] Fehler beim Parsen: {error_message}")
+
+
+class ParsedMessage:
+    def __init__(self, msgid, payload_len):
+        self.msgid = msgid
+        self.payload_len = payload_len
+
+
+received_message_queue = queue.Queue()
+
+
+class SerialReader(threading.Thread):
+    # Ändere den Konstruktor, um eine bereits geöffnete serielle Instanz zu akzeptieren
+    def __init__(self, ser_instance, read_timeout, parser):
+        super().__init__()
+        # Speichere die übergebene serielle Instanz
+        self.ser = ser_instance
+        self.read_timeout = read_timeout
+        self.parser = parser
+        self.running = False
+        self.daemon = True  # Thread beendet sich mit dem Hauptprogramm
+
+    def run(self):
+        # Überprüfe, ob die serielle Schnittstelle wirklich offen ist, bevor du beginnst
+        if not self.ser or not self.ser.is_open:
+            print(
+                f"[{self.name}] Fehler: Serielle Schnittstelle ist nicht geöffnet.")
+            return
+
+        print(f"[{self.name}] Lese-Thread gestartet. Überwache {self.ser.port}...")
+        self.ser.timeout = self.read_timeout  # Setze den Timeout für byteweises Lesen
+        self.running = True
+
+        while self.running:
+            try:
+                byte = self.ser.read(1)
+                if byte:
+                    self.parser.parse_byte(byte[0])
+                else:
+                    pass  # Timeout, kein Byte verfügbar, Thread läuft weiter
+            except serial.SerialException as e:
+                print(f"[{self.name}] Lesefehler: {e}")
+                self.running = False
+            except Exception as e:
+                print(f"[{self.name}] Unerwarteter Fehler im Lese-Thread: {e}")
+                self.running = False
+
+        # Der Thread schließt den Port NICHT mehr, das ist Aufgabe des Hauptprogramms.
+        print(f"[{self.name}] Lese-Thread beendet.")
+
+    def stop(self):
+        self.running = False
+        print(f"[{self.name}] Lese-Thread wird beendet...")
+
+
+def on_message_received_from_uart(message_id: int, payload: bytes, payload_length: int):
+    """
+    Callback-Funktion, die aufgerufen wird, wenn der Parser eine vollständige,
+    gültige Nachricht empfangen hat.
+    """
+    print(f"\n[MAIN] Nachricht erfolgreich empfangen! ID: 0x{
+          message_id:02X}")
+    print(f"[MAIN]    Payload ({payload_length} Bytes): {
+          payload[:payload_length].hex().upper()}")
+
+    parsed_object = payload_parser.parse_payload(
+        message_id, payload[:payload_length])
+
+    if message_id == 0x04:
+        print(parsed_object)
+        table = Table(title="Clients")
+        columns = ["ClientId", "IsAvailable",
+                   "IsSlotUsed", "MAC", "LastPing", "LastSuccesfullPing"]
+
+        rows = []
+        for x in parsed_object.clients:
+            mac_string = ':'.join(f'{byte:02x}' for byte in x.mac_address)
+            rows.append([str(x.client_id), str(x.is_available), str(x.is_slot_used), mac_string,
+                        str(x.last_ping), str(x.last_successfull_ping)])
+
+        for column in columns:
+            table.add_column(column)
+
+        for row in rows:
+            table.add_row(*row, style='bright_green')
+
+        console = Console()
+        console.print(table)
+
+
+def on_message_fail_from_uart(message_id: int, current_message_buffer: bytes,
+                              current_index: int, error_type: ParserError):
+    """
+    Callback-Funktion, die aufgerufen wird, wenn der Parser einen Fehler
+    beim Empfang einer Nachricht feststellt.
+    """
+    print(f"\n[MAIN] Fehler beim Parsen der Nachricht! ID: 0x{
+          message_id:02X}")
+    print(f"[MAIN]    Fehler: {error_type.name}")
+    print(f"[MAIN]    Bisheriger Puffer ({current_index} Bytes): {
+          current_message_buffer[:current_index].hex().upper()}")
+
+
+def run_uart_test():
+    """
+    Führt den UART-Test durch: Sendet eine Nachricht und liest alle Antworten.
+    """
+    ser = None
+
+    parser = UartMessageParser(
+        on_message_received_callback=on_message_received_from_uart,
+        on_message_fail_callback=on_message_fail_from_uart
+    )
+    message_builder = MessageBuilder()
+
+    try:
+        ser = serial.Serial(
+            port=SERIAL_PORT,
+            baudrate=BAUDRATE,
+            timeout=READ_TIMEOUT,
+            write_timeout=WRITE_TIMEOUT
+        )
+        print(f"Serielle Schnittstelle {
+              SERIAL_PORT} mit Baudrate {BAUDRATE} geöffnet.")
+
+        reader_thread = SerialReader(
+            ser_instance=ser,
+            read_timeout=10,
+            parser=parser
+        )
+        reader_thread.start()  # Starte den Lese-Thread
+
+        while not reader_thread.running:
+            time.sleep(0.1)
+
+        print("\n--- UART Testkonsole ---")
+        print("Gib eine Zahl (1-10) ein, um eine Nachricht zu senden.")
+        print("Gib 'q' oder 'exit' ein, um das Programm zu beenden.")
+
+        while True:
+            # Warte auf Benutzereingabe
+            user_input = sys.stdin.readline().strip().lower()
+
+            if user_input in ('q', 'exit'):
+                break
+
+            try:
+                choice = int(user_input)
+                if choice in MESSAGES:
+                    msg_info = MESSAGES[choice]
+                    print(f"\n[MAIN] Sende Nachricht für Option {
+                          choice} (MSGID: 0x{msg_info['msg_id']:02X})...")
+                    try:
+                        message_to_send = message_builder.build_message(
+                            msg_info["msg_id"],
+                            msg_info["payload"],
+                            255  # Max Payload Length
+                        )
+                        print(f"[MAIN] Gebaute Nachricht zum Senden: {
+                              message_to_send.hex().upper()}")
+                        bytes_written = ser.write(message_to_send)
+                        print(f"[MAIN] {bytes_written} Bytes gesendet.")
+                    except (PayloadTooLargeError, BufferOverflowError) as e:
+                        print(f"[MAIN] Fehler beim Bauen der Nachricht: {e}")
+                    except Exception as e:
+                        print(
+                            f"[MAIN] Ein unerwarteter Fehler beim Senden der Nachricht ist aufgetreten: {e}")
+                else:
+                    print(
+                        "Ungültige Option. Bitte gib eine Zahl zwischen 1 und 10 ein.")
+            except ValueError:
+                print("Ungültige Eingabe. Bitte gib eine Zahl oder 'q' ein.")
+            except Exception as e:
+                print(
+                    f"[MAIN] Ein unerwarteter Fehler bei der Eingabeverarbeitung ist aufgetreten: {e}")
+
+            # Verarbeite empfangene Nachrichten, die sich in der Queue angesammelt haben
+            while not received_message_queue.empty():
+                msg = received_message_queue.get()
+                print(
+                    f"  > [MAIN-Loop] Verarbeitet: MSGID=0x{msg.msgid:02X}, Length={msg.payload_len}")
+                received_message_queue.task_done()
+
+    except serial.SerialException as e:
+        print(f"Fehler beim Zugriff auf die serielle Schnittstelle: {e}")
+        print(f"Stelle sicher, dass '{
+              SERIAL_PORT}' der korrekte Port ist und nicht von einer anderen Anwendung verwendet wird.")
+    except KeyboardInterrupt:
+        print("\n[MAIN] Test durch Benutzer abgebrochen (Ctrl+C).")
+    except Exception as e:
+        print(f"Ein unerwarteter Fehler im Hauptprogramm ist aufgetreten: {e}")
+    finally:
+        if 'reader_thread' in locals() and reader_thread.is_alive():
+            reader_thread.stop()
+            reader_thread.join(timeout=5)
+            if reader_thread.is_alive():
+                print(
+                    "[MAIN] Warnung: Lese-Thread konnte nicht sauber beendet werden.")
+        if ser and ser.is_open:
+            ser.close()
+            print("Serielle Schnittstelle geschlossen.")
+        print("[MAIN] Programm beendet.")
+
+
+# Nachrichten-Mapping
+MESSAGES = {
+    1: {"msg_id": 0x01, "payload": b"Echo Message 1"},
+    2: {"msg_id": 0x02, "payload": b"Version Request"},
+    3: {"msg_id": 0x03, "payload": b"Client Info Request"},
+    4: {"msg_id": 0x04, "payload": b"Custom Data 4"},
+    5: {"msg_id": 0x05, "payload": b"Custom Data 5"},
+    6: {"msg_id": 0x06, "payload": b"Custom Data 6"},
+    7: {"msg_id": 0x07, "payload": b"Custom Data 7"},
+    8: {"msg_id": 0x08, "payload": b"Custom Data 8"},
+    9: {"msg_id": 0x09, "payload": b"Custom Data 9"},
+    10: {"msg_id": 0x0A, "payload": b"Custom Data 10 - Last One!"},
+}
+
+# Führe den Test aus
+if __name__ == "__main__":
+    run_uart_test()

tools/message_builder.py

@@ -0,0 +1,115 @@
+import enum
+
+START_BYTE = 0xAA
+ESCAPE_BYTE = 0xBB
+END_BYTE = 0xCC
+
+
+class MessageBuilderError(Exception):
+    """Basisklasse für Fehler des Message Builders."""
+    pass
+
+
+class PayloadTooLargeError(MessageBuilderError):
+    """Ausnahme, wenn der Payload zu groß für den Puffer ist."""
+
+    def __init__(self, required_size, buffer_size):
+        super().__init__(f"Payload ({
+            required_size} bytes) ist größer als der verfügbare Puffer ({buffer_size} bytes).")
+        self.required_size = required_size
+        self.buffer_size = buffer_size
+
+
+class BufferOverflowError(MessageBuilderError):
+    """Ausnahme, wenn der Puffer während des Bauens überläuft."""
+
+    def __init__(self, current_size, max_size, byte_to_add=None):
+        msg = f"Pufferüberlauf: Aktuelle Größe {
+            current_size}, Max. Größe {max_size}."
+        if byte_to_add is not None:
+            msg += f" Versuch, Byte 0x{byte_to_add:02X} hinzuzufügen."
+        super().__init__(msg)
+        self.current_size = current_size
+        self.max_size = max_size
+        self.byte_to_add = byte_to_add
+
+
+class MessageBuilder:
+    """
+    Klasse zum Aufbau von UART-Nachrichten gemäß dem definierten Protokoll,
+    inklusive Stuffing und Checksummenberechnung.
+    """
+
+    def __init__(self):
+        pass
+
+    def _needs_stuffing_byte(self, byte: int) -> bool:
+        """
+        Prüft, ob ein Byte ein Stuffing-Byte benötigt (d.h. ob es ein Steuerbyte ist).
+        """
+        return (byte == START_BYTE or byte == ESCAPE_BYTE or byte == END_BYTE)
+
+    def _add_byte_with_length_check(self, byte: int, buffer: bytearray, max_length: int):
+        """
+        Fügt ein Byte zum Puffer hinzu und prüft auf Pufferüberlauf.
+        Löst BufferOverflowError aus, wenn der Puffer voll ist.
+        """
+        if len(buffer) >= max_length:
+            raise BufferOverflowError(len(buffer), max_length, byte)
+        buffer.append(byte)
+
+    def build_message(self, msgid: int, payload: bytes, msg_buffer_size: int) -> bytes:
+        """
+        Baut eine vollständige UART-Nachricht.
+
+        Args:
+            msgid (int): Die Message ID (0-255).
+            payload (bytes): Die Nutzdaten der Nachricht als Byte-Objekt.
+            msg_buffer_size (int): Die maximale Größe des Ausgabepuffers.
+                                   Dies ist die maximale Länge der *fertigen* Nachricht.
+
+        Returns:
+            bytes: Die fertig aufgebaute Nachricht als Byte-Objekt.
+
+        Raises:
+            PayloadTooLargeError: Wenn der Payload (mit Overhead) den Puffer überschreiten würde.
+            BufferOverflowError: Wenn während des Bauens ein Pufferüberlauf auftritt.
+        """
+
+        if len(payload) + 4 > msg_buffer_size:
+            raise PayloadTooLargeError(len(payload) + 4, msg_buffer_size)
+
+        checksum = 0
+        msg_buffer = bytearray()
+
+        # 1. StartByte hinzufügen
+        self._add_byte_with_length_check(
+            START_BYTE, msg_buffer, msg_buffer_size)
+
+        # 2. Message ID hinzufügen (mit Stuffing)
+        if self._needs_stuffing_byte(msgid):
+            self._add_byte_with_length_check(
+                ESCAPE_BYTE, msg_buffer, msg_buffer_size)
+        self._add_byte_with_length_check(msgid, msg_buffer, msg_buffer_size)
+        checksum ^= msgid
+
+        # 3. Payload-Bytes hinzufügen (mit Stuffing)
+        for byte_val in payload:
+            if self._needs_stuffing_byte(byte_val):
+                self._add_byte_with_length_check(
+                    ESCAPE_BYTE, msg_buffer, msg_buffer_size)
+            self._add_byte_with_length_check(
+                byte_val, msg_buffer, msg_buffer_size)
+            checksum ^= byte_val
+
+        # 4. Checksumme hinzufügen (mit Stuffing)
+        if self._needs_stuffing_byte(checksum):
+            self._add_byte_with_length_check(
+                ESCAPE_BYTE, msg_buffer, msg_buffer_size)
+        self._add_byte_with_length_check(checksum, msg_buffer, msg_buffer_size)
+
+        # 5. EndByte hinzufügen
+        self._add_byte_with_length_check(END_BYTE, msg_buffer, msg_buffer_size)
+
+        # Konvertiere bytearray zu unveränderlichem bytes-Objekt
+        return bytes(msg_buffer)

tools/parser.py

@@ -0,0 +1,170 @@
+import enum
+
+# --- Konstanten für das UART-Protokoll ---
+# Diese Werte müssen mit denen auf deinem Embedded-System übereinstimmen
+START_BYTE = 0xAA
+END_BYTE = 0xCC
+ESCAPE_BYTE = 0x7D # Beispielwert, bitte an dein Protokoll anpassen
+
+MAX_PAYLOAD_LENGTH = 255 # Maximale Länge des Nachrichten-Payloads (ohne Message ID und Checksumme)
+# MAX_TOTAL_CONTENT_LENGTH in C beinhaltet Message ID, Payload und Checksumme.
+# Hier definieren wir MAX_PAYLOAD_LENGTH, da der Parser den Payload sammelt.
+# Die Gesamtgröße des empfangenen Puffers (message + checksum) darf MAX_PAYLOAD_LENGTH + 1 nicht überschreiten,
+# da die Checksumme als letztes Byte des Payloads behandelt wird.
+
+# --- Enumerationen für Parser-Zustände und Fehler ---
+class ParserState(enum.Enum):
+    WAITING_FOR_START_BYTE = 0
+    GET_MESSAGE_TYPE = 1
+    ESCAPED_MESSAGE_TYPE = 2
+    IN_PAYLOAD = 3
+    ESCAPE_PAYLOAD_BYTE = 4
+
+class ParserError(enum.Enum):
+    NO_ERROR = 0
+    UNEXPECTED_COMMAND_BYTE = 1
+    WRONG_CHECKSUM = 2
+    MESSAGE_TOO_LONG = 3
+
+class UartMessageParser:
+    """
+    Ein State-Machine-Parser für UART-Nachrichten basierend auf der bereitgestellten C-Logik.
+
+    Nachrichtenformat (angenommen):
+    [START_BYTE] [MESSAGE_ID] [PAYLOAD_BYTES...] [CHECKSUM_BYTE] [END_BYTE]
+
+    Escape-Sequenzen:
+    Wenn START_BYTE, END_BYTE oder ESCAPE_BYTE im MESSAGE_ID oder PAYLOAD vorkommen,
+    werden sie durch ESCAPE_BYTE gefolgt vom ursprünglichen Byte (nicht XORed) ersetzt.
+    Die Checksumme wird über die unescaped Bytes berechnet.
+    """
+
+    def __init__(self, on_message_received_callback=None, on_message_fail_callback=None):
+        """
+        Initialisiert den UART-Nachrichten-Parser.
+
+        Args:
+            on_message_received_callback (callable, optional): Eine Funktion, die aufgerufen wird,
+                wenn eine gültige Nachricht empfangen wurde.
+                Signatur: on_message_received(message_id: int, payload: bytes, payload_length: int)
+            on_message_fail_callback (callable, optional): Eine Funktion, die aufgerufen wird,
+                wenn ein Nachrichtenfehler auftritt.
+                Signatur: on_message_fail(message_id: int, current_message_buffer: bytes,
+                                          current_index: int, error_type: ParserError)
+        """
+        self.state = ParserState.WAITING_FOR_START_BYTE
+        self.index = 0
+        self.checksum = 0
+        self.message_id = 0
+        self.message_buffer = bytearray(MAX_PAYLOAD_LENGTH + 1) # +1 für Checksummen-Byte
+        self.error = ParserError.NO_ERROR
+
+        # Callbacks für die Anwendung. Standardmäßig None oder einfache Print-Funktionen.
+        self.on_message_received = on_message_received_callback if on_message_received_callback else self._default_on_message_received
+        self.on_message_fail = on_message_fail_callback if on_message_fail_callback else self._default_on_message_fail
+
+    def _default_on_message_received(self, message_id, payload, payload_length):
+        """Standard-Callback für empfangene Nachrichten, falls keiner angegeben ist."""
+        print(f"Parser: Nachricht empfangen! ID: 0x{message_id:02X}, "
+              f"Payload ({payload_length} Bytes): {payload[:payload_length].hex().upper()}")
+
+    def _default_on_message_fail(self, message_id, current_message_buffer, current_index, error_type):
+        """Standard-Callback für Nachrichtenfehler, falls keiner angegeben ist."""
+        print(f"Parser: Fehler bei Nachricht! ID: 0x{message_id:02X}, "
+              f"Fehler: {error_type.name}, "
+              f"Bisheriger Puffer ({current_index} Bytes): {current_message_buffer[:current_index].hex().upper()}")
+
+    def parse_byte(self, pbyte: int):
+        """
+        Verarbeitet ein einzelnes empfangenes Byte.
+
+        Args:
+            pbyte (int): Das empfangene Byte (0-255).
+        """
+        # Sicherstellen, dass pbyte ein Integer im Bereich 0-255 ist
+        if not isinstance(pbyte, int) or not (0 <= pbyte <= 255):
+            print(f"Parser: Ungültiges Byte empfangen: {pbyte}. Muss ein Integer von 0-255 sein.")
+            return
+
+        current_state = self.state # Für bessere Lesbarkeit
+
+        if current_state == ParserState.WAITING_FOR_START_BYTE:
+            if pbyte == START_BYTE:
+                self.index = 0
+                self.checksum = 0
+                self.message_id = 0 # Reset message_id
+                self.error = ParserError.NO_ERROR # Reset error
+                self.state = ParserState.GET_MESSAGE_TYPE
+            # Andernfalls ignorieren wir Bytes, bis ein Start-Byte gefunden wird
+
+        elif current_state == ParserState.ESCAPED_MESSAGE_TYPE:
+            self.message_id = pbyte
+            self.checksum ^= pbyte
+            self.state = ParserState.IN_PAYLOAD
+
+        elif current_state == ParserState.GET_MESSAGE_TYPE:
+            if pbyte == ESCAPE_BYTE:
+                self.state = ParserState.ESCAPED_MESSAGE_TYPE
+                return # Dieses Byte wurde als Escape-Sequenz verarbeitet, nicht zum Payload hinzufügen
+            if pbyte == START_BYTE or pbyte == END_BYTE:
+                self.state = ParserState.WAITING_FOR_START_BYTE
+                self.error = ParserError.UNEXPECTED_COMMAND_BYTE
+                self.on_message_fail(self.message_id, self.message_buffer, self.index, self.error)
+                return
+            self.message_id = pbyte
+            self.checksum ^= pbyte
+            self.state = ParserState.IN_PAYLOAD
+
+        elif current_state == ParserState.ESCAPE_PAYLOAD_BYTE:
+            # Das escapte Byte ist Teil des Payloads
+            if self.index < MAX_PAYLOAD_LENGTH + 1: # +1 für Checksummen-Byte
+                self.message_buffer[self.index] = pbyte
+                self.index += 1
+                self.checksum ^= pbyte
+                self.state = ParserState.IN_PAYLOAD
+            else:
+                self.state = ParserState.WAITING_FOR_START_BYTE
+                self.error = ParserError.MESSAGE_TOO_LONG
+                self.on_message_fail(self.message_id, self.message_buffer, self.index, self.error)
+                return
+
+        elif current_state == ParserState.IN_PAYLOAD:
+            if pbyte == ESCAPE_BYTE:
+                self.state = ParserState.ESCAPE_PAYLOAD_BYTE
+                return # Dieses Byte wurde als Escape-Sequenz verarbeitet
+            if pbyte == START_BYTE:
+                self.state = ParserState.WAITING_FOR_START_BYTE
+                self.error = ParserError.UNEXPECTED_COMMAND_BYTE
+                self.on_message_fail(self.message_id, self.message_buffer, self.index, self.error)
+                return
+            if pbyte == END_BYTE:
+                if self.checksum != 0x00:
+                    # Checksummenfehler: Die Checksumme wurde bis zum End-Byte XORed.
+                    # Wenn die empfangene Checksumme korrekt war, sollte das Ergebnis 0 sein.
+                    self.state = ParserState.WAITING_FOR_START_BYTE
+                    self.error = ParserError.WRONG_CHECKSUM
+                    self.on_message_fail(self.message_id, self.message_buffer, self.index, self.error)
+                    return
+                
+                # Erfolgreich empfangen! Die Checksumme ist das letzte Byte im Puffer.
+                # Die Länge des Payloads ist index - 1 (da das letzte Byte die Checksumme war).
+                payload_length = self.index - 1
+                if payload_length < 0: # Falls nur Message ID und Checksumme, aber kein Payload
+                    payload_length = 0
+
+                self.on_message_received(self.message_id, self.message_buffer, payload_length)
+                self.state = ParserState.WAITING_FOR_START_BYTE
+                return # EndByte wurde verarbeitet, nicht zum Payload hinzufügen
+
+            # Normales Payload-Byte
+            if self.index < MAX_PAYLOAD_LENGTH + 1: # +1 für Checksummen-Byte
+                self.message_buffer[self.index] = pbyte
+                self.index += 1
+                self.checksum ^= pbyte
+            else:
+                # Nachricht zu lang
+                self.state = ParserState.WAITING_FOR_START_BYTE
+                self.error = ParserError.MESSAGE_TOO_LONG
+                self.on_message_fail(self.message_id, self.message_buffer, self.index, self.error)
+                return
+

tools/payload_parser.py

@@ -0,0 +1,192 @@
+import dataclasses
+import struct
+from typing import Optional, Union, List
+
+
+@dataclasses.dataclass
+class StatusMessage:
+    """
+    Repräsentiert eine Status-Nachricht (z.B. Message ID 0x01).
+    Payload-Format: [status_code: uint8], [battery_level: uint8], [uptime_seconds: uint16]
+    """
+    status_code: int
+    battery_level: int  # 0-100%
+    uptime_seconds: int
+
+
+@dataclasses.dataclass
+class SensorDataMessage:
+    """
+    Repräsentiert eine Sensor-Daten-Nachricht (z.B. Message ID 0x02).
+    Payload-Format: [temperature_celsius: int16], [humidity_percent: uint16]
+    """
+    temperature_celsius: int  # signed short
+    humidity_percent: int    # unsigned short
+
+
+@dataclasses.dataclass
+class ClientEntry:
+    """
+    Repräsentiert die Informationen für einen einzelnen Client innerhalb der ClientInfoMessage.
+    Payload-Format:
+    [client_id: uint8]
+    [is_available: uint8] (0=false, >0=true)
+    [is_slot_used: uint8] (0=false, >0=true)
+    [mac_address: bytes (6)]
+    [unoccupied_value_1: uint32]
+    [unoccupied_value_2: uint32]
+    Gesamt: 1 + 1 + 1 + 6 + 4 + 4 = 17 Bytes pro Eintrag.
+    """
+    client_id: int
+    is_available: bool
+    is_slot_used: bool
+    mac_address: bytes  # 6 Bytes MAC-Adresse
+    last_ping: int  # 4 Bytes, unbelegt
+    last_successfull_ping: int  # 4 Bytes, unbelegt
+
+
+@dataclasses.dataclass
+class ClientInfoMessage:
+    """
+    Repräsentiert eine Nachricht mit Client-Informationen (Message ID 0x03).
+    Payload-Format:
+    [num_clients: uint8]
+    [client_entry_1: ClientEntry]
+    [client_entry_2: ClientEntry]
+    ...
+    """
+    num_clients: int
+    clients: List[ClientEntry]
+
+
+@dataclasses.dataclass
+class UnknownMessage:
+    """
+    Repräsentiert eine Nachricht mit unbekannter ID oder fehlerhaftem Payload.
+    """
+    message_id: int
+    raw_payload: bytes
+    error_message: str
+
+# --- Payload Parser Klasse ---
+
+
+class PayloadParser:
+    """
+    Interpretiert den Payload einer UART-Nachricht basierend auf ihrer Message ID
+    und wandelt ihn in ein strukturiertes Python-Objekt (dataclass) um.
+    """
+
+    def __init__(self):
+        # Ein Dictionary, das Message IDs auf ihre entsprechenden Parsing-Funktionen abbildet.
+        self._parser_map = {
+            0x01: self._parse_status_message,
+            0x02: self._parse_sensor_data_message,
+            # Aktualisiert für die neue 0x03 Struktur
+            0x03: self._parse_client_info_message,
+            0x04: self._parse_client_info_message,
+            # Füge hier weitere Message IDs und ihre Parsing-Funktionen hinzu
+        }
+
+    def _parse_status_message(self, payload: bytes) -> Union[StatusMessage, UnknownMessage]:
+        """Parsen des Payloads für Message ID 0x01 (StatusMessage)."""
+        # Erwartetes Format: 1 Byte Status, 1 Byte Battery, 2 Bytes Uptime (Little-Endian)
+        if len(payload) != 4:
+            return UnknownMessage(0x01, payload, f"Falsche Payload-Länge für StatusMessage: Erwartet 4, Got {len(payload)}")
+        try:
+            # '<BBH' bedeutet: Little-Endian, Byte (unsigned char), Byte (unsigned char), Half-word (unsigned short)
+            status_code, battery_level, uptime_seconds = struct.unpack(
+                '<BBH', payload)
+            return StatusMessage(status_code, battery_level, uptime_seconds)
+        except struct.error as e:
+            return UnknownMessage(0x01, payload, f"Fehler beim Entpacken der StatusMessage: {e}")
+
+    def _parse_sensor_data_message(self, payload: bytes) -> Union[SensorDataMessage, UnknownMessage]:
+        """Parsen des Payloads für Message ID 0x02 (SensorDataMessage)."""
+        # Erwartetes Format: 2 Bytes Temperatur (signed short), 2 Bytes Feuchtigkeit (unsigned short) (Little-Endian)
+        if len(payload) != 4:
+            return UnknownMessage(0x02, payload, f"Falsche Payload-Länge für SensorDataMessage: Erwartet 4, Got {len(payload)}")
+        try:
+            # '<hH' bedeutet: Little-Endian, short (signed), unsigned short
+            temperature_celsius, humidity_percent = struct.unpack(
+                '<hH', payload)
+            return SensorDataMessage(temperature_celsius, humidity_percent)
+        except struct.error as e:
+            return UnknownMessage(0x02, payload, f"Fehler beim Entpacken der SensorDataMessage: {e}")
+
+    def _parse_client_info_message(self, payload: bytes) -> Union[ClientInfoMessage, UnknownMessage]:
+        """Parsen des Payloads für Message ID 0x03 (ClientInfoMessage)."""
+        if not payload:
+            # Wenn der Payload leer ist, aber num_clients erwartet wird, ist das ein Fehler
+            return UnknownMessage(0x03, payload, "Payload für ClientInfoMessage ist leer, aber num_clients erwartet.")
+
+        try:
+            # Das erste Byte ist die Anzahl der Clients
+            num_clients = payload[0]
+            # Die restlichen Bytes sind die Client-Einträge
+            client_data_bytes = payload[1:]
+
+            # 1 (ID) + 1 (Avail) + 1 (Used) + 6 (MAC) + 4 (Val1) + 4 (Val2)
+            EXPECTED_CLIENT_ENTRY_SIZE = 17
+
+            if len(client_data_bytes) != num_clients * EXPECTED_CLIENT_ENTRY_SIZE:
+                return UnknownMessage(0x03, payload,
+                                      f"Falsche Payload-Länge für Client-Einträge: Erwartet {
+                                          num_clients * EXPECTED_CLIENT_ENTRY_SIZE}, "
+                                      f"Got {len(client_data_bytes)} nach num_clients.")
+
+            clients_list: List[ClientEntry] = []
+            # Formatstring für einen Client-Eintrag:
+            # < : Little-Endian
+            # B : uint8 (client_id, is_available, is_slot_used)
+            # 6s: 6 Bytes (mac_address)
+            # I : uint32 (unoccupied_value_1, unoccupied_value_2)
+            CLIENT_ENTRY_FORMAT = '<BBB6sII'
+
+            for i in range(num_clients):
+                start_index = i * EXPECTED_CLIENT_ENTRY_SIZE
+                end_index = start_index + EXPECTED_CLIENT_ENTRY_SIZE
+                entry_bytes = client_data_bytes[start_index:end_index]
+
+                # Entpacke die Daten für einen Client-Eintrag
+                client_id, is_available_byte, is_slot_used_byte, mac_address, val1, val2 = \
+                    struct.unpack(CLIENT_ENTRY_FORMAT, entry_bytes)
+
+                # Konvertiere 0/1 Bytes zu boolschen Werten
+                is_available = bool(is_available_byte)
+                is_slot_used = bool(is_slot_used_byte)
+
+                clients_list.append(ClientEntry(
+                    client_id=client_id,
+                    is_available=is_available,
+                    is_slot_used=is_slot_used,
+                    mac_address=mac_address,
+                    last_ping=val1,
+                    last_successfull_ping=val2
+                ))
+
+            return ClientInfoMessage(num_clients=num_clients, clients=clients_list)
+
+        except struct.error as e:
+            return UnknownMessage(0x03, payload, f"Fehler beim Entpacken der ClientInfoMessage-Einträge: {e}")
+        except Exception as e:
+            return UnknownMessage(0x03, payload, f"Unerwarteter Fehler beim Parsen der ClientInfoMessage: {e}")
+
+    def parse_payload(self, message_id: int, payload: bytes) -> Union[StatusMessage, SensorDataMessage, ClientInfoMessage, UnknownMessage]:
+        """
+        Interpretiert den gegebenen Payload basierend auf der Message ID.
+
+        Args:
+            message_id (int): Die ID der Nachricht.
+            payload (bytes): Die rohen Nutzdaten der Nachricht.
+
+        Returns:
+            Union[StatusMessage, SensorDataMessage, ClientInfoMessage, UnknownMessage]:
+            Ein dataclass-Objekt, das die dekodierten Daten repräsentiert,
+            oder ein UnknownMessage-Objekt bei unbekannter ID oder Parsing-Fehler.
+        """
+        parser_func = self._parser_map.get(message_id)
+        if parser_func:
+            return parser_func(payload)
+        else:
+            return UnknownMessage(message_id, payload, "Unbekannte Message ID.")