pre uart exchange

buzzer_tool/buzzer.py

@@ -1,217 +0,0 @@
-# buzzer.py
-import argparse
-import sys
-
-def main():
-    parser = argparse.ArgumentParser(description="Edis Buzzer Host Tool")
-    
-    # Globale Argumente (gelten für alle Befehle)
-    parser.add_argument("-p", "--port", type=str, help="Serielle Schnittstelle (z.B. COM15)")
-    parser.add_argument("-b", "--baudrate", type=int, help="Verbindungsgeschwindigkeit")
-    parser.add_argument("-t", "--timeout", type=float, help="Timeout in Sekunden (Standard: 5.0)")
-    parser.add_argument("--no-auto-info", action="store_true", help="Überspringt den automatischen Info-Call beim Start")
-    
-    # Subkommandos einrichten
-    subparsers = parser.add_subparsers(dest="command", help="Verfügbare Befehle")
-    
-    # Befehl: info (expliziter Aufruf, obwohl es ohnehin immer angezeigt wird)
-    subparsers.add_parser("info", help="Zeigt nur die Systeminformationen an")
-    
-    # Befehl: ls
-    ls_parser = subparsers.add_parser("ls", help="Listet Dateien und Verzeichnisse auf")
-    ls_parser.add_argument("path", nargs="?", default="/", help="Zielpfad (Standard: /)")
-    ls_parser.add_argument("-r", "--recursive", action="store_true", help="Rekursiv auflisten")
-    
-    # Befehl: put
-    put_parser = subparsers.add_parser("put", help="Lädt eine oder mehrere Dateien auf den Controller hoch")
-    put_parser.add_argument("sources", nargs="+", help="Lokale Quelldatei(en), Verzeichnisse oder Wildcards (z.B. *.raw)")
-    put_parser.add_argument("target", type=str, help="Zielpfad auf dem Controller (Verzeichnis muss mit '/' enden)")
-    put_parser.add_argument("-r", "--recursive", action="store_true", help="Verzeichnisse rekursiv hochladen")
-
-    # Befehl: put_many
-    put_many_parser = subparsers.add_parser("put_many", help="Lädt mehrere Dateien/Verzeichnisse (typisch rekursiv) hoch")
-    put_many_parser.add_argument("sources", nargs="+", help="Lokale Quelldatei(en), Verzeichnisse oder Wildcards")
-    put_many_parser.add_argument("target", type=str, help="Zielpfad auf dem Controller")
-    put_many_parser.add_argument("-r", "--recursive", action="store_true", help="Verzeichnisse rekursiv hochladen (Standard für put_many)")
-
-    # Befehl: fw_put
-    fw_put_parser = subparsers.add_parser("fw_put", help="Lädt eine Firmware in den Secondary Slot (Test-Upgrade)")
-    fw_put_parser.add_argument("source", type=str, help="Lokale Firmware-Datei (.bin)")
-
-    # Befehl: mkdir
-    mkdir_parser = subparsers.add_parser("mkdir", help="Erstellt ein neues Verzeichnis")
-    mkdir_parser.add_argument("path", type=str, help="Pfad des neuen Verzeichnisses (z.B. /lfs/a/neu)")
-
-    # Befehl: rm
-    rm_parser = subparsers.add_parser("rm", help="Löscht eine Datei oder ein Verzeichnis")
-    rm_parser.add_argument("path", type=str, help="Pfad der zu löschenden Datei/Ordner")
-    rm_parser.add_argument("-r", "--recursive", action="store_true", help="Ordnerinhalte rekursiv löschen")
-
-    # Befehl: stat
-    stat_parser = subparsers.add_parser("stat", help="Zeigt Typ und Größe einer Datei/eines Verzeichnisses")
-    stat_parser.add_argument("path", type=str, help="Pfad der Datei/des Verzeichnisses")
-
-    # Befehl: mv
-    mv_parser = subparsers.add_parser("mv", help="Benennt eine Datei/ein Verzeichnis um oder verschiebt es")
-    mv_parser.add_argument("source", type=str, help="Alter Pfad")
-    mv_parser.add_argument("target", type=str, help="Neuer Pfad")
-
-    # Befehl: pull
-    pull_parser = subparsers.add_parser("pull", help="Lädt eine Datei vom Controller herunter")
-    pull_parser.add_argument("source", type=str, help="Quellpfad auf dem Controller")
-    pull_parser.add_argument("target", nargs="?", default=None, help="Optionaler lokaler Zielpfad")
-
-    # Alias: get_file
-    get_file_parser = subparsers.add_parser("get_file", help="Alias für pull")
-    get_file_parser.add_argument("source", type=str, help="Quellpfad auf dem Controller")
-    get_file_parser.add_argument("target", nargs="?", default=None, help="Optionaler lokaler Zielpfad")
-
-    # Befehl: play
-    play_parser = subparsers.add_parser("play", help="Spielt eine Datei auf dem Controller ab")
-    play_parser.add_argument("path", type=str, help="Pfad der abzuspielenden Datei (z.B. /lfs/a/neu)")
-
-    # Befehl: check
-    check_parser = subparsers.add_parser("check", help="Holt die CRC32 einer Datei und zeigt sie an")
-    check_parser.add_argument("path", type=str, help="Pfad der zu prüfenden Datei (z.B. /lfs/a/neu)")
-    
-    # Befehl: confirm
-    confirm_parser = subparsers.add_parser("confirm", help="Bestätigt die aktuell laufende Firmware")
-
-    # Befehl: reboot
-    reboot_parser = subparsers.add_parser("reboot", help="Startet den Buzzer neu")
-
-    # Befehl: get_tags (neuer Blob/TLV-Parser)
-    get_tags_parser = subparsers.add_parser("get_tags", help="Holt alle Tags einer Datei als JSON")
-    get_tags_parser.add_argument("path", type=str, help="Pfad der Datei")
-
-    # Befehl: write_tags (merge/replace per JSON)
-    write_tags_parser = subparsers.add_parser("write_tags", help="Fügt Tags ein/ersetzt bestehende Tags per JSON")
-    write_tags_parser.add_argument("path", type=str, help="Pfad der Datei")
-    write_tags_parser.add_argument("json", type=str, help="JSON-Objekt oder @datei.json")
-
-    # Befehl: remove_tag
-    remove_tag_parser = subparsers.add_parser("remove_tag", help="Entfernt einen Tag und schreibt den Rest zurück")
-    remove_tag_parser.add_argument("path", type=str, help="Pfad der Datei")
-    remove_tag_parser.add_argument("key", type=str, choices=["description", "author", "crc32", "fileformat"], help="Zu entfernender Tag-Key")
-
-    # Argumente parsen
-    args = parser.parse_args()
-    from core.config import load_config
-    config = load_config(args)
-    
-    print("--- Aktuelle Verbindungsparameter -------------------------------")
-    print(f"Port:     {config.get('port', 'Nicht definiert')}")
-    print(f"Baudrate: {config.get('baudrate')}")
-    print(f"Timeout:  {config.get('timeout')}s")
-    print("-" * 65)
-
-    if not config.get("port"):
-        print("Abbruch: Es muss ein Port in der config.yaml oder via --port definiert werden.")
-        sys.exit(1)
-
-    from core.connection import BuzzerConnection, BuzzerError
-
-    try:
-        with BuzzerConnection(config) as conn:
-            if not args.no_auto_info:
-                from core.commands import info
-                sys_info = info.execute(conn)
-
-                status = sys_info.get("image_status", "UNKNOWN")
-                status_colors = {
-                    "CONFIRMED": "\033[32m",
-                    "TESTING": "\033[33m",
-                    "PENDING": "\033[36m",
-                }
-                status_color = status_colors.get(status, "\033[37m")
-
-                print(f"Buzzer Firmware: v{sys_info['app_version']} [{status_color}{status}\033[0m] (Protokoll v{sys_info['protocol_version']})")
-                print(f"LittleFS Status: {sys_info['used_kb']:.1f} KB / {sys_info['total_kb']:.1f} KB belegt ({sys_info['percent_used']:.1f}%)")
-                print("-" * 65)
-
-            # 2. Spezifisches Kommando ausführen
-            if args.command == "ls":
-                from core.commands import ls
-                print(f"Inhalt von '{args.path}':\n")
-                tree = ls.get_file_tree(conn, target_path=args.path, recursive=args.recursive)
-                if not tree:
-                    print("  (Leer)")
-                else:
-                    ls.print_tree(tree, path=args.path )
-            elif args.command == "put":
-                from core.commands import put
-                put.execute(conn, sources=args.sources, target=args.target, recursive=args.recursive)
-            elif args.command == "put_many":
-                from core.commands import put
-                recursive = True if not args.recursive else args.recursive
-                put.execute(conn, sources=args.sources, target=args.target, recursive=recursive)
-            elif args.command == "fw_put":
-                from core.commands import fw_put
-                fw_put.execute(conn, source=args.source)
-            elif args.command == "mkdir":
-                from core.commands import mkdir
-                mkdir.execute(conn, path=args.path)
-            elif args.command == "rm":
-                from core.commands import rm
-                rm.execute(conn, path=args.path, recursive=args.recursive)
-            elif args.command == "stat":
-                from core.commands import stat
-                stat.execute(conn, path=args.path)
-            elif args.command == "mv":
-                from core.commands import mv
-                mv.execute(conn, source=args.source, target=args.target)
-            elif args.command == "pull" or args.command == "get_file":
-                from core.commands import pull
-                pull.execute(conn, source=args.source, target=args.target)
-            elif args.command == "confirm":
-                from core.commands import confirm
-                confirm.execute(conn)
-            elif args.command == "reboot":
-                from core.commands import reboot
-                reboot.execute(conn)           
-            elif args.command == "play":
-                from core.commands import play
-                play.execute(conn, path=args.path)
-            elif args.command == "check":
-                from core.commands import check
-                CRC32 = check.execute(conn, path=args.path)
-                if CRC32:
-                    size_bytes = CRC32.get("size_bytes")
-                    if isinstance(size_bytes, int) and size_bytes >= 0:
-                        size_kb = size_bytes / 1024.0
-                        print(f"CRC32 von '{args.path}': 0x{CRC32['crc32']:08x} (Größe: {size_bytes} B / {size_kb:.1f} KB)")
-                    else:
-                        print(f"CRC32 von '{args.path}': 0x{CRC32['crc32']:08x}")
-                else:
-                    print(f"Fehler: Keine CRC32-Information für '{args.path}' erhalten.")
-            elif args.command == "get_tags":
-                from core.commands import tags
-                tag_map = tags.get_tags(conn, args.path)
-                print(tag_map)
-            elif args.command == "write_tags":
-                from core.commands import tags
-                updates = tags.parse_tags_json_input(args.json)
-                result = tags.write_tags(conn, args.path, updates)
-                print("Aktuelle Tags:")
-                print(result)
-            elif args.command == "remove_tag":
-                from core.commands import tags
-                result = tags.remove_tag(conn, args.path, args.key)
-                print("Aktuelle Tags:")
-                print(result)
-            elif args.command == "info" or args.command is None:
-                # Wurde kein Befehl oder explizit 'info' angegeben, sind wir hier schon fertig
-                pass
-            
-    except TimeoutError as e:
-        print(f"Fehler: {e}")
-        sys.exit(1)
-    except BuzzerError as e:
-        print(f"Buzzer hat die Aktion abgelehnt: {e}")
-        sys.exit(1)
-    except Exception as e:
-        print(f"Verbindungsfehler auf {config.get('port')}: {e}")
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()

buzzer_tool/config.yaml

@@ -1,5 +0,0 @@
-# config.yaml
-serial:
-  port: "/dev/cu.usbmodem83401"
-  baudrate: 2500000
-  timeout: 1

buzzer_tool/config.yaml.example

@@ -1,7 +0,0 @@
-# config.yaml
-serial:
-  port: "COM17"
-  baudrate: 250000
-  timeout: 20
-  crc_timeout_min_seconds: 2.0
-  crc_timeout_ms_per_100kb: 1.5

buzzer_tool/core/commands/check.py

@@ -1,60 +0,0 @@
-# core/commands/check.py
-from core.connection import BuzzerError
-
-def _split_parent_and_name(path: str) -> tuple[str, str]:
-    normalized = path.rstrip("/")
-    if not normalized or normalized == "/":
-        raise BuzzerError("Für CHECK wird ein Dateipfad benötigt.")
-
-    idx = normalized.rfind("/")
-    if idx <= 0:
-        return "/", normalized
-
-    parent = normalized[:idx]
-    name = normalized[idx + 1:]
-    if not name:
-        raise BuzzerError("Ungültiger Dateipfad für CHECK.")
-    return parent, name
-
-
-def _lookup_file_size_bytes(conn, path: str) -> int | None:
-    parent, filename = _split_parent_and_name(path)
-    lines = conn.list_directory(parent)
-
-    for line in lines:
-        parts = line.split(",", 2)
-        if len(parts) != 3:
-            continue
-
-        entry_type, entry_size, entry_name = parts
-        if entry_type == "F" and entry_name == filename:
-            try:
-                return int(entry_size)
-            except ValueError:
-                return None
-
-    return None
-
-
-def _estimate_crc_timeout_seconds(conn, size_bytes: int | None) -> float:
-    min_timeout = float(getattr(conn, "crc_timeout_min_seconds", 2.0))
-    ms_per_100kb = float(getattr(conn, "crc_timeout_ms_per_100kb", 1.5))
-
-    base = max(float(conn.timeout), min_timeout)
-    if size_bytes is None or size_bytes <= 0:
-        return base
-
-    blocks_100kb = size_bytes / (100.0 * 1024.0)
-    extra = blocks_100kb * (ms_per_100kb / 1000.0)
-    return base + extra
-
-def execute(conn, path: str) -> dict:
-    """Holt die CRC32 nur über Audiodaten und passt Timeout für große Dateien an."""
-    size_bytes = _lookup_file_size_bytes(conn, path)
-    timeout = _estimate_crc_timeout_seconds(conn, size_bytes)
-    crc32 = conn.check_file_crc(path, timeout=timeout)
-
-    return {
-        "crc32": crc32,
-        "size_bytes": size_bytes,
-    }

buzzer_tool/core/commands/confirm.py

@@ -1,11 +0,0 @@
-# core/commands/confirm.py
-from core.connection import BuzzerError
-
-
-def execute(conn):
-    """Bestätigt die aktuell laufende Firmware per Binary-Protokoll."""
-    try:
-        conn.confirm_firmware()
-        print("✅ Firmware erfolgreich bestätigt.")
-    except BuzzerError as e:
-        print(f"❌ Fehler beim Bestätigen der Firmware: {e}")

buzzer_tool/core/commands/fw_put.py

@@ -1,57 +0,0 @@
-import os
-import time
-import sys
-
-
-def _estimate_fw_timeout_seconds(conn, total_size: int) -> float:
-    base = float(getattr(conn, "timeout", 5.0))
-    erase_budget = 8.0
-    stream_and_write_budget = total_size / (25.0 * 1024.0)
-    return max(base, erase_budget + stream_and_write_budget)
-
-
-def execute(conn, source: str):
-    if not os.path.isfile(source):
-        raise FileNotFoundError(f"Firmware-Datei nicht gefunden: {source}")
-
-    with open(source, "rb") as f:
-        data = f.read()
-
-    total_size = len(data)
-    if total_size == 0:
-        raise ValueError("Firmware-Datei ist leer.")
-
-    print(f"Sende 🧩 Firmware ({total_size / 1024:.1f} KB) -> secondary slot")
-    fw_timeout = _estimate_fw_timeout_seconds(conn, total_size)
-    print(f"  Timeout fw_put: {fw_timeout:.1f}s")
-    print("  Phase 1/3: Lösche secondary slot und initialisiere Flash...")
-
-    start_time = time.monotonic()
-    last_ui_update = start_time
-    transfer_started = False
-
-    def progress_handler(chunk_len, sent_file, total_file):
-        nonlocal last_ui_update, transfer_started
-        if not transfer_started:
-            transfer_started = True
-            print("  Phase 2/3: Übertrage Firmware...")
-        now = time.monotonic()
-        if now - last_ui_update < 0.2 and sent_file < total_file:
-            return
-        last_ui_update = now
-
-        elapsed = now - start_time
-        speed = (sent_file / 1024.0) / elapsed if elapsed > 0 else 0.0
-        perc = (sent_file / total_file) * 100.0 if total_file > 0 else 100.0
-        eta_sec = ((total_file - sent_file) / (sent_file / elapsed)) if sent_file > 0 and elapsed > 0 else 0.0
-        eta_str = f"{int(eta_sec // 60):02d}:{int(eta_sec % 60):02d}"
-
-        sys.stdout.write(
-            f"\r  \033[90mProg: {perc:3.0f}% | {speed:6.1f} KB/s | ETA: {eta_str}\033[0m"
-        )
-        sys.stdout.flush()
-
-    crc32 = conn.fw_put_data(data, timeout=fw_timeout, progress_callback=progress_handler)
-    print("\n  Phase 3/3: Finalisiere und warte auf Geräte-ACK...")
-    print(f"\r  \033[32mFertig: Firmware übertragen (CRC32: 0x{crc32:08x}).{' ' * 16}\033[0m")
-    print("ℹ️  Nächste Schritte: reboot -> testen -> confirm")

buzzer_tool/core/commands/info.py

@@ -1,37 +0,0 @@
-# core/commands/info.py
-from core.connection import BuzzerError
-
-def execute(conn) -> dict:
-    """Holt die Systeminformationen und gibt sie als strukturiertes Dictionary zurück."""
-    protocol_version = conn.get_protocol_version()
-    if protocol_version != 1:
-        raise BuzzerError(f"Inkompatibles Protokoll: Gerät nutzt v{protocol_version}, Host erwartet v1.")
-
-    status_code, app_version = conn.get_firmware_status()
-    flash = conn.get_flash_status()
-
-    f_frsize = flash["block_size"]
-    f_blocks = flash["total_blocks"]
-    f_bfree = flash["free_blocks"]
-
-    status_map = {
-        1: "CONFIRMED",
-        2: "TESTING",
-        3: "PENDING",
-    }
-    image_status = status_map.get(status_code, f"UNKNOWN({status_code})")
-
-    total_kb = (f_blocks * f_frsize) / 1024
-    free_kb = (f_bfree * f_frsize) / 1024
-    used_kb = total_kb - free_kb
-    percent_used = (used_kb / total_kb) * 100 if total_kb > 0 else 0
-
-    return {
-        "protocol_version": protocol_version,
-        "app_version": app_version,
-        "total_kb": total_kb,
-        "free_kb": free_kb,
-        "used_kb": used_kb,
-        "percent_used": percent_used,
-        "image_status": image_status
-    }

buzzer_tool/core/commands/ls.py

@@ -1,84 +0,0 @@
-# core/commands/ls.py
-from core.connection import BuzzerError
-
-def get_file_tree(conn, target_path="/", recursive=False) -> list:
-    """
-    Liest das Dateisystem aus und gibt eine hierarchische Baumstruktur zurück.
-    """
-    if not target_path.endswith('/'):
-        target_path += '/'
-        
-    cmd_path = target_path.rstrip('/') if target_path != '/' else '/'
-    
-    try:
-        lines = conn.list_directory(cmd_path)
-    except BuzzerError as e:
-        return [{"type": "E", "name": f"Fehler beim Lesen: {e}", "path": target_path}]
-
-    nodes = []
-    if not lines:
-        return nodes
-
-    for line in lines:
-        parts = line.split(',', 2)
-        if len(parts) != 3:
-            continue
-        
-        entry_type, entry_size, entry_name = parts
-        node = {
-            "type": entry_type,
-            "name": entry_name,
-            "path": f"{target_path}{entry_name}"
-        }
-        
-        if entry_type == 'D':
-            if recursive:
-                # Rekursiver Aufruf auf dem Host für Unterverzeichnisse
-                node["children"] = get_file_tree(conn, f"{target_path}{entry_name}/", recursive=True)
-            else:
-                node["children"] = []
-        elif entry_type == 'F':
-            node["size"] = int(entry_size)
-            
-        nodes.append(node)
-        
-    return nodes
-
-def print_tree(nodes, prefix="", path=""):
-    """
-    Gibt die Baumstruktur optisch formatiert auf der Konsole aus.
-    """
-    if path:
-        if path == "/":
-            display_path = "💾 "+"/ (Root)"
-        else:
-            display_path = "📁 " + path
-        print(f"{prefix}{display_path}")
-    for i, node in enumerate(nodes):
-        is_last = (i == len(nodes) - 1)
-        connector = " └─" if is_last else " ├─"
-        
-        if node["type"] == 'D':
-            print(f"{prefix}{connector}📁 {node['name']}")
-            extension = "   " if is_last else " │ "
-            if "children" in node and node["children"]:
-                print_tree(node["children"], prefix + extension)
-        elif node["type"] == 'F':
-            size_kb = node["size"] / 1024
-            # \033[90m macht den Text dunkelgrau, \033[0m setzt die Farbe zurück
-            print(f"{prefix}{connector}📄 {node['name']} \033[90m({size_kb:.1f} KB)\033[0m")
-        elif node["type"] == 'E':
-            print(f"{prefix}{connector}❌ \033[31m{node['name']}\033[0m")
-
-def get_flat_file_list(nodes) -> list:
-    """
-    Wandelt die Baumstruktur in eine flache Liste von Dateipfaden um.
-    Wird von 'rm -r' benötigt, um nacheinander alle Dateien zu löschen.
-    """
-    flat_list = []
-    for node in nodes:
-        if node["type"] == 'F':
-            flat_list.append(node)
-        elif node["type"] == 'D' and "children" in node:
-            flat_list.extend(get_flat_file_list(node["children"]))
-    return flat_list

buzzer_tool/core/commands/mkdir.py

@@ -1,10 +0,0 @@
-# core/commands/mkdir.py
-from core.connection import BuzzerError
-
-def execute(conn, path: str):
-    """Erstellt ein Verzeichnis auf dem Controller."""
-    try:
-        conn.mkdir(path)
-        print(f"📁 Verzeichnis '{path}' erfolgreich erstellt.")
-    except BuzzerError as e:
-        print(f"❌ Fehler beim Erstellen von '{path}': {e}")

buzzer_tool/core/commands/mv.py

@@ -1,10 +0,0 @@
-from core.connection import BuzzerError
-
-
-def execute(conn, source: str, target: str):
-    try:
-        conn.rename(source, target)
-        print(f"✅ Umbenannt/Verschoben: '{source}' -> '{target}'")
-    except BuzzerError as e:
-        print(f"❌ Fehler beim Umbenennen/Verschieben: {e}")
-        raise

buzzer_tool/core/commands/play.py

@@ -1,10 +0,0 @@
-# core/commands/mkdir.py
-from core.connection import BuzzerError
-
-def execute(conn, path: str):
-    """Spielt eine Datei auf dem Controller ab."""
-    try:
-        conn.send_command(f"play {path}")
-        print(f"▶️ Datei '{path}' wird abgespielt.")
-    except BuzzerError as e:
-        print(f"❌ Fehler beim Abspielen von '{path}': {e}")

buzzer_tool/core/commands/pull.py

@@ -1,62 +0,0 @@
-import os
-import posixpath
-import time
-
-
-def _resolve_local_target(remote_path: str, target: str | None) -> str:
-    if target:
-        return target
-
-    basename = posixpath.basename(remote_path.rstrip("/"))
-    if not basename:
-        raise ValueError("Kann keinen lokalen Dateinamen aus dem Remote-Pfad ableiten. Bitte Zielpfad angeben.")
-    return basename
-
-
-def execute(conn, source: str, target: str | None = None):
-    local_path = _resolve_local_target(source, target)
-
-    os.makedirs(os.path.dirname(local_path) or ".", exist_ok=True)
-
-    last_print = 0.0
-    start_time = time.monotonic()
-
-    def _progress(_chunk_len: int, received: int, expected: int | None):
-        nonlocal last_print
-        now = time.monotonic()
-        if now - last_print < 0.2:
-            return
-        last_print = now
-
-        elapsed = max(now - start_time, 1e-6)
-        speed_kb_s = (received / 1024.0) / elapsed
-
-        if expected is not None and expected > 0:
-            percent = (received * 100.0) / expected
-            remaining = max(expected - received, 0)
-            eta_sec = (remaining / 1024.0) / speed_kb_s if speed_kb_s > 0 else 0.0
-            eta_str = f"{int(eta_sec // 60):02d}:{int(eta_sec % 60):02d}"
-            print(
-                f"\r⬇️  {received}/{expected} B ({percent:5.1f}%) | {speed_kb_s:6.1f} KB/s | ETA {eta_str}",
-                end="",
-                flush=True,
-            )
-        else:
-            print(f"\r⬇️  {received} B | {speed_kb_s:6.1f} KB/s", end="", flush=True)
-
-    data = conn.get_file_data(source, progress_callback=_progress)
-
-    if len(data) > 0:
-        print()
-
-    with open(local_path, "wb") as f:
-        f.write(data)
-
-    total_duration = max(time.monotonic() - start_time, 1e-6)
-    avg_speed_kb_s = (len(data) / 1024.0) / total_duration
-    print(f"✅ Heruntergeladen: '{source}' -> '{local_path}' ({len(data)} B, {avg_speed_kb_s:.1f} KB/s)")
-    return {
-        "source": source,
-        "target": local_path,
-        "size": len(data),
-    }

buzzer_tool/core/commands/put.py

@@ -1,220 +0,0 @@
-import glob
-import os
-import sys
-import time
-
-from core.connection import BuzzerError
-
-TAG_MAGIC = b"TAG!"
-TAG_FOOTER_LEN = 7
-TAG_VERSION_V1 = 0x01
-TAG_TYPE_CRC32 = 0x10
-
-
-def _split_audio_and_tag_blob(filepath: str) -> tuple[bytes, bytes | None]:
-    with open(filepath, "rb") as f:
-        data = f.read()
-
-    if len(data) < TAG_FOOTER_LEN:
-        return data, None
-
-    if data[-4:] != TAG_MAGIC:
-        return data, None
-
-    tag_total_len = int.from_bytes(data[-6:-4], byteorder="little", signed=False)
-    tag_version = data[-7]
-    if tag_version != TAG_VERSION_V1:
-        return data, None
-
-    if tag_total_len < TAG_FOOTER_LEN or tag_total_len > len(data):
-        return data, None
-
-    audio_end = len(data) - tag_total_len
-    tag_payload_len = tag_total_len - TAG_FOOTER_LEN
-    tag_payload = data[audio_end:audio_end + tag_payload_len]
-    audio_data = data[:audio_end]
-    return audio_data, tag_payload
-
-
-def _upsert_crc32_tag(tag_blob: bytes | None, crc32: int) -> tuple[bytes, bool]:
-    crc_payload = int(crc32).to_bytes(4, byteorder="little", signed=False)
-    crc_tlv = bytes([TAG_TYPE_CRC32, 0x04, 0x00]) + crc_payload
-
-    if not tag_blob:
-        return crc_tlv, True
-
-    pos = 0
-    out = bytearray()
-    found_crc = False
-
-    while pos < len(tag_blob):
-        if pos + 3 > len(tag_blob):
-            return crc_tlv, True
-
-        tag_type = tag_blob[pos]
-        tag_len = tag_blob[pos + 1] | (tag_blob[pos + 2] << 8)
-        header = tag_blob[pos:pos + 3]
-        pos += 3
-
-        if pos + tag_len > len(tag_blob):
-            return crc_tlv, True
-
-        value = tag_blob[pos:pos + tag_len]
-        pos += tag_len
-
-        if tag_type == TAG_TYPE_CRC32:
-            if not found_crc:
-                out.extend(crc_tlv)
-                found_crc = True
-            continue
-
-        out.extend(header)
-        out.extend(value)
-
-    if not found_crc:
-        out.extend(crc_tlv)
-
-    return bytes(out), True
-
-
-def _collect_source_files(sources: list[str], recursive: bool) -> list[dict]:
-    entries = []
-
-    for source in sources:
-        matches = glob.glob(source)
-        if not matches:
-            print(f"⚠️  Keine Treffer für Quelle: {source}")
-            continue
-
-        for match in matches:
-            if os.path.isfile(match):
-                entries.append({"local": match, "relative": os.path.basename(match)})
-                continue
-
-            if os.path.isdir(match):
-                if recursive:
-                    for root, _, files in os.walk(match):
-                        for name in sorted(files):
-                            local_path = os.path.join(root, name)
-                            rel = os.path.relpath(local_path, match)
-                            entries.append({"local": local_path, "relative": rel.replace("\\", "/")})
-                else:
-                    for name in sorted(os.listdir(match)):
-                        local_path = os.path.join(match, name)
-                        if os.path.isfile(local_path):
-                            entries.append({"local": local_path, "relative": name})
-
-    return entries
-
-
-def _remote_parent(path: str) -> str:
-    idx = path.rfind("/")
-    if idx <= 0:
-        return "/"
-    return path[:idx]
-
-
-def _ensure_remote_dir(conn, remote_dir: str) -> None:
-    if not remote_dir or remote_dir == "/":
-        return
-
-    current = ""
-    for part in [p for p in remote_dir.split("/") if p]:
-        current = f"{current}/{part}"
-        try:
-            conn.mkdir(current)
-        except BuzzerError as e:
-            msg = str(e)
-            if "0x11" in msg or "existiert bereits" in msg:
-                continue
-            raise
-
-
-def _build_upload_plan(entries: list[dict], target: str) -> list[dict]:
-    if not entries:
-        return []
-
-    needs_dir_semantics = target.endswith("/") or len(entries) > 1 or any("/" in e["relative"] for e in entries)
-    if not needs_dir_semantics:
-        return [{"local": entries[0]["local"], "remote": target}]
-
-    base = target.rstrip("/")
-    if not base:
-        base = "/"
-
-    plan = []
-    for entry in entries:
-        rel = entry["relative"].lstrip("/")
-        if base == "/":
-            remote = f"/{rel}"
-        else:
-            remote = f"{base}/{rel}"
-        plan.append({"local": entry["local"], "remote": remote})
-
-    return plan
-
-
-def execute(conn, sources: list[str], target: str, recursive: bool = False):
-    uploads = _build_upload_plan(_collect_source_files(sources, recursive=recursive), target)
-    if not uploads:
-        print("Keine gültigen Dateien gefunden.")
-        return
-
-    total_size_all = sum(os.path.getsize(item["local"]) for item in uploads)
-    sent_all = 0
-    start_time_all = time.monotonic()
-    last_ui_update = start_time_all
-
-    for item in uploads:
-        local_path = item["local"]
-        remote_path = item["remote"]
-        filename = os.path.basename(local_path)
-
-        audio_data, tag_blob = _split_audio_and_tag_blob(local_path)
-        audio_size = len(audio_data)
-
-        _ensure_remote_dir(conn, _remote_parent(remote_path))
-
-        print(f"Sende 📄 {filename} ({audio_size / 1024:.1f} KB Audio) -> {remote_path}")
-        start_time_file = time.monotonic()
-
-        def progress_handler(chunk_len, sent_file, total_file):
-            nonlocal sent_all, last_ui_update
-            sent_all += chunk_len
-
-            now = time.monotonic()
-            if now - last_ui_update < 0.2 and sent_file < total_file:
-                return
-            last_ui_update = now
-
-            elapsed = now - start_time_file
-            speed = (sent_file / 1024.0) / elapsed if elapsed > 0 else 0.0
-            perc_file = (sent_file / total_file) * 100.0 if total_file > 0 else 100.0
-            perc_all = (sent_all / total_size_all) * 100.0 if total_size_all > 0 else 100.0
-
-            elapsed_all = now - start_time_all
-            avg_speed_all = sent_all / elapsed_all if elapsed_all > 0 else 0.0
-            eta_sec = (total_size_all - sent_all) / avg_speed_all if avg_speed_all > 0 else 0.0
-            eta_str = f"{int(eta_sec // 60):02d}:{int(eta_sec % 60):02d}"
-
-            sys.stdout.write(
-                f"\r  \033[90mProg: {perc_file:3.0f}% | Gesamt: {perc_all:3.0f}% | "
-                f"{speed:6.1f} KB/s | ETA: {eta_str}\033[0m"
-            )
-            sys.stdout.flush()
-
-        try:
-            audio_crc32 = conn.put_file_data(remote_path, audio_data, progress_callback=progress_handler)
-
-            rewritten_blob, _ = _upsert_crc32_tag(tag_blob, audio_crc32)
-            conn.set_tag_blob(remote_path, rewritten_blob)
-            tag_note = " (CRC32-Tag gesetzt)"
-
-            print(f"\r  \033[32mFertig: {filename} übertragen{tag_note}.{' ' * 20}\033[0m")
-        except Exception as e:
-            print(f"\n  ❌ \033[31mFehler: {e}\033[0m")
-
-    total_duration = time.monotonic() - start_time_all
-    total_kb = total_size_all / 1024.0
-    avg_speed = total_kb / total_duration if total_duration > 0 else 0.0
-    print(f"\nÜbertragung abgeschlossen: {total_kb:.1f} KB in {total_duration:.1f}s ({avg_speed:.1f} KB/s)")

buzzer_tool/core/commands/reboot.py

@@ -1,11 +0,0 @@
-# core/commands/reboot.py
-from core.connection import BuzzerError
-
-
-def execute(conn):
-    """Startet den Buzzer per Binary-Protokoll neu."""
-    try:
-        conn.reboot_device()
-        print("🔄 Buzzer wird neu gestartet.")
-    except BuzzerError as e:
-        print(f"❌ Fehler beim Neustarten des Buzzers: {e}")

buzzer_tool/core/commands/rm.py

@@ -1,68 +0,0 @@
-# core/commands/rm.py
-import fnmatch
-import posixpath
-from core.connection import BuzzerError
-from core.commands.ls import get_file_tree
-
-def _delete_recursive(conn, nodes):
-    """Löscht Knoten Bottom-Up (erst Dateien/Unterordner, dann den Ordner selbst)"""
-    for node in nodes:
-        if node["type"] == 'D':
-            if "children" in node and node["children"]:
-                _delete_recursive(conn, node["children"])
-            _try_rm(conn, node["path"], is_dir=True)
-        elif node["type"] == 'F':
-            _try_rm(conn, node["path"], is_dir=False)
-
-def _try_rm(conn, path, is_dir=False):
-    icon = "📁" if is_dir else "📄"
-    try:
-        conn.rm(path)
-        print(f"  🗑️ {icon} Gelöscht: {path}")
-    except BuzzerError as e:
-        print(f"  ❌ Fehler bei {path}: {e}")
-
-def execute(conn, path: str, recursive: bool = False):
-    """Löscht eine Datei, ein Verzeichnis oder löst Wildcards (*) auf."""
-    
-    # 1. Wildcard-Behandlung (z.B. /lfs/a/* oder *.wav)
-    if '*' in path or '?' in path:
-        dirname, pattern = posixpath.split(path)
-        if not dirname:
-            dirname = "/"
-            
-        print(f"Suche nach Dateien passend zu '{pattern}' in '{dirname}'...")
-        tree = get_file_tree(conn, target_path=dirname, recursive=False)
-        
-        # Fehler beim Verzeichnis-Lesen abfangen
-        if len(tree) == 1 and tree[0].get("type") == "E":
-            print(f"❌ Verzeichnis '{dirname}' nicht gefunden.")
-            return
-            
-        # Filtern mit fnmatch (funktioniert wie in der Linux-Shell)
-        matches = [node for node in tree if node.get("type") == "F" and fnmatch.fnmatch(node["name"], pattern)]
-        
-        if not matches:
-            print(f"Keine passenden Dateien für '{path}' gefunden.")
-            return
-            
-        for match in matches:
-            _try_rm(conn, match["path"], is_dir=False)
-            
-        return # Fertig mit Wildcard-Löschen
-
-    # 2. Rekursives Löschen (-r)
-    if recursive:
-        try:
-            conn.rm_recursive(path)
-            print(f"🗑️ '{path}' rekursiv gelöscht.")
-        except BuzzerError as e:
-            print(f"❌ Fehler beim rekursiven Löschen von '{path}': {e}")
-        return
-
-    # 3. Standard-Löschen (Einzeldatei oder leeres Verzeichnis)
-    try:
-        conn.rm(path)
-        print(f"🗑️ '{path}' erfolgreich gelöscht.")
-    except BuzzerError as e:
-        print(f"❌ Fehler beim Löschen von '{path}': {e}")

buzzer_tool/core/commands/stat.py

@@ -1,5 +0,0 @@
-def execute(conn, path: str):
-    info = conn.stat(path)
-    entry_type = "Ordner" if info["type"] == "D" else "Datei"
-    print(f"{path}: {entry_type}, Größe: {info['size']} B")
-    return info

buzzer_tool/core/commands/tags.py

@@ -1,140 +0,0 @@
-import json
-from core.connection import BuzzerError
-
-TAG_TYPE_TO_KEY = {
-    0x00: "description",
-    0x01: "author",
-    0x10: "crc32",
-    0x20: "fileformat",
-}
-
-KEY_TO_TAG_TYPE = {v: k for k, v in TAG_TYPE_TO_KEY.items()}
-VALID_TAG_KEYS = frozenset(KEY_TO_TAG_TYPE.keys())
-
-def _u16le(value: int) -> bytes:
-    return bytes((value & 0xFF, (value >> 8) & 0xFF))
-
-
-def _parse_tlv(blob: bytes) -> dict:
-    tags = {}
-    pos = 0
-
-    while pos < len(blob):
-        if pos + 3 > len(blob):
-            raise BuzzerError("Ungültiger Tag-Blob: TLV-Header abgeschnitten")
-
-        tag_type = blob[pos]
-        tag_len = blob[pos + 1] | (blob[pos + 2] << 8)
-        pos += 3
-
-        if pos + tag_len > len(blob):
-            raise BuzzerError("Ungültiger Tag-Blob: TLV-Wert abgeschnitten")
-
-        value = blob[pos:pos + tag_len]
-        pos += tag_len
-
-        key = TAG_TYPE_TO_KEY.get(tag_type, f"unknown_0x{tag_type:02x}")
-
-        if tag_type in (0x00, 0x01):
-            tags[key] = value.decode("utf-8", errors="replace")
-        elif tag_type == 0x10:
-            if tag_len != 4:
-                raise BuzzerError("Ungültiger crc32-Tag: len muss 4 sein")
-            crc32 = int.from_bytes(value, byteorder="little", signed=False)
-            tags[key] = f"0x{crc32:08x}"
-        elif tag_type == 0x20:
-            if tag_len != 5:
-                raise BuzzerError("Ungültiger fileformat-Tag: len muss 5 sein")
-            bits = value[0]
-            samplerate = int.from_bytes(value[1:5], byteorder="little", signed=False)
-            tags[key] = {"bits_per_sample": bits, "sample_rate": samplerate}
-        else:
-            tags[key] = value.hex()
-
-    return tags
-
-
-def _build_tlv(tags: dict) -> bytes:
-    entries = []
-
-    if "description" in tags and tags["description"] is not None:
-        data = str(tags["description"]).encode("utf-8")
-        entries.append(bytes([KEY_TO_TAG_TYPE["description"]]) + _u16le(len(data)) + data)
-
-    if "author" in tags and tags["author"] is not None:
-        data = str(tags["author"]).encode("utf-8")
-        entries.append(bytes([KEY_TO_TAG_TYPE["author"]]) + _u16le(len(data)) + data)
-
-    if "crc32" in tags and tags["crc32"] is not None:
-        crc_val = tags["crc32"]
-        if isinstance(crc_val, str):
-            crc_val = int(crc_val, 16) if crc_val.lower().startswith("0x") else int(crc_val)
-        data = int(crc_val).to_bytes(4, byteorder="little", signed=False)
-        entries.append(bytes([KEY_TO_TAG_TYPE["crc32"]]) + _u16le(4) + data)
-
-    if "fileformat" in tags and tags["fileformat"] is not None:
-        ff = tags["fileformat"]
-        if not isinstance(ff, dict):
-            raise BuzzerError("fileformat muss ein Objekt sein: {bits_per_sample, sample_rate}")
-        bits = int(ff.get("bits_per_sample", 16))
-        samplerate = int(ff.get("sample_rate", 16000))
-        data = bytes([bits]) + samplerate.to_bytes(4, byteorder="little", signed=False)
-        entries.append(bytes([KEY_TO_TAG_TYPE["fileformat"]]) + _u16le(5) + data)
-
-    return b"".join(entries)
-
-
-def get_tags(conn, path: str) -> dict:
-    blob = conn.get_tag_blob(path)
-    if not blob:
-        return {}
-    return _parse_tlv(blob)
-
-
-def write_tags(conn, path: str, tags_update: dict) -> dict:
-    unknown_keys = [k for k in tags_update.keys() if k not in VALID_TAG_KEYS]
-    if unknown_keys:
-        unknown_str = ", ".join(sorted(str(k) for k in unknown_keys))
-        valid_str = ", ".join(sorted(VALID_TAG_KEYS))
-        raise BuzzerError(
-            f"Unbekannter Tag-Key in write_tags: {unknown_str}. Erlaubte Keys: {valid_str}"
-        )
-
-    current = get_tags(conn, path)
-    merged = dict(current)
-
-    for key, value in tags_update.items():
-        if value is None:
-            merged.pop(key, None)
-        else:
-            merged[key] = value
-
-    blob = _build_tlv(merged)
-    conn.set_tag_blob(path, blob)
-    return merged
-
-
-def remove_tag(conn, path: str, key: str) -> dict:
-    current = get_tags(conn, path)
-    current.pop(key, None)
-    blob = _build_tlv(current)
-    conn.set_tag_blob(path, blob)
-    return current
-
-
-def parse_tags_json_input(raw: str) -> dict:
-    text = raw.strip()
-    if text.startswith("@"):
-        file_path = text[1:]
-        with open(file_path, "r", encoding="utf-8") as f:
-            text = f.read()
-
-    try:
-        data = json.loads(text)
-    except json.JSONDecodeError as e:
-        raise BuzzerError(f"Ungültiges JSON für write_tags: {e}")
-
-    if not isinstance(data, dict):
-        raise BuzzerError("write_tags erwartet ein JSON-Objekt.")
-
-    return data

buzzer_tool/core/config.py

@@ -1,48 +0,0 @@
-# core/config.py
-import os
-import sys
-import yaml
-
-DEFAULT_CONFIG = {
-    "port": None,
-    "baudrate": 115200,
-    "timeout": 5.0,
-    "crc_timeout_min_seconds": 2.0,
-    "crc_timeout_ms_per_100kb": 1.5,
-}
-
-def load_config(cli_args=None):
-    config = DEFAULT_CONFIG.copy()
-
-    cwd_config = os.path.join(os.getcwd(), "config.yaml")
-    script_dir = os.path.dirname(os.path.abspath(sys.argv[0]))
-    script_config = os.path.join(script_dir, "config.yaml")
-
-    yaml_path = cwd_config if os.path.exists(cwd_config) else script_config if os.path.exists(script_config) else None
-
-    if yaml_path:
-        try:
-            with open(yaml_path, "r", encoding="utf-8") as f:
-                yaml_data = yaml.safe_load(f)
-                if yaml_data and "serial" in yaml_data:
-                    config["port"] = yaml_data["serial"].get("port", config["port"])
-                    config["baudrate"] = yaml_data["serial"].get("baudrate", config["baudrate"])
-                    config["timeout"] = yaml_data["serial"].get("timeout", config["timeout"])
-                    config["crc_timeout_min_seconds"] = yaml_data["serial"].get(
-                        "crc_timeout_min_seconds", config["crc_timeout_min_seconds"]
-                    )
-                    config["crc_timeout_ms_per_100kb"] = yaml_data["serial"].get(
-                        "crc_timeout_ms_per_100kb", config["crc_timeout_ms_per_100kb"]
-                    )
-        except Exception as e:
-            print(f"Fehler beim Laden der Konfigurationsdatei {yaml_path}: {e}")
-
-    if cli_args:
-        if getattr(cli_args, "port", None) is not None:
-            config["port"] = cli_args.port
-        if getattr(cli_args, "baudrate", None) is not None:
-            config["baudrate"] = cli_args.baudrate
-        if getattr(cli_args, "timeout", None) is not None:
-            config["timeout"] = cli_args.timeout
-
-    return config

buzzer_tool/core/connection.py

@@ -1,866 +0,0 @@
-# core/connection.py
-import time
-import os
-import struct
-import binascii
-
-PROTOCOL_ERROR_MESSAGES = {
-    0x01: "Ungültiger Befehl.",
-    0x02: "Ungültige Parameter.",
-    0x03: "Befehl oder Parameter sind zu lang.",
-    0x10: "Datei oder Verzeichnis wurde nicht gefunden.",
-    0x11: "Ziel existiert bereits.",
-    0x12: "Pfad ist kein Verzeichnis.",
-    0x13: "Pfad ist ein Verzeichnis.",
-    0x14: "Zugriff verweigert.",
-    0x15: "Kein freier Speicher mehr vorhanden.",
-    0x16: "Datei ist zu groß.",
-    0x20: "Allgemeiner Ein-/Ausgabefehler auf dem Gerät.",
-    0x21: "Zeitüberschreitung auf dem Gerät.",
-    0x22: "CRC-Prüfung fehlgeschlagen (Daten beschädigt).",
-    0x23: "Übertragung wurde vom Gerät abgebrochen.",
-    0x30: "Befehl wird vom Gerät nicht unterstützt.",
-    0x31: "Gerät ist beschäftigt.",
-    0x32: "Interner Gerätefehler.",
-}
-
-SYNC = b"BUZZ"
-HEADER_SIZE = 14
-DEFAULT_MAX_PATH_LEN = 32
-FRAME_REQ = 0x01
-FRAME_RESP_ACK = 0x10
-FRAME_RESP_DATA = 0x11
-FRAME_RESP_STREAM_START = 0x12
-FRAME_RESP_STREAM_CHUNK = 0x13
-FRAME_RESP_STREAM_END = 0x14
-FRAME_RESP_ERROR = 0x7F
-POLL_SLEEP_SECONDS = 0.002
-
-CMD_GET_PROTOCOL_VERSION = 0x00
-CMD_GET_FIRMWARE_STATUS = 0x01
-CMD_GET_FLASH_STATUS = 0x02
-CMD_CONFIRM_FIRMWARE = 0x03
-CMD_REBOOT = 0x04
-CMD_LIST_DIR = 0x10
-CMD_CHECK_FILE_CRC = 0x11
-CMD_MKDIR = 0x12
-CMD_RM = 0x13
-CMD_PUT_FILE_START = 0x14
-CMD_PUT_FILE_CHUNK = 0x15
-CMD_PUT_FILE_END = 0x16
-CMD_PUT_FW_START = 0x17
-CMD_STAT = 0x18
-CMD_RENAME = 0x19
-CMD_RM_R = 0x1A
-CMD_GET_FILE = 0x1B
-CMD_GET_TAG_BLOB = 0x20
-CMD_SET_TAG_BLOB_START = 0x21
-CMD_SET_TAG_BLOB_CHUNK = 0x22
-CMD_SET_TAG_BLOB_END = 0x23
-
-class BuzzerError(Exception):
-    pass
-
-class BuzzerConnection:
-    def __init__(self, config):
-        self.port = config.get("port")
-        self.baudrate = config.get("baudrate", 115200)
-        self.timeout = config.get("timeout", 5.0)
-        self.crc_timeout_min_seconds = float(config.get("crc_timeout_min_seconds", 2.0))
-        self.crc_timeout_ms_per_100kb = float(config.get("crc_timeout_ms_per_100kb", 1.5))
-        self.serial = None
-        self._sequence = 0
-        self._max_path_len = DEFAULT_MAX_PATH_LEN
-
-    def __enter__(self):
-        if not self.port:
-            raise ValueError("Kein serieller Port konfiguriert.")
-
-        try:
-            import serial
-        except ImportError as e:
-            raise BuzzerError("PySerial ist nicht installiert. Bitte 'pip install -r requirements.txt' ausführen.") from e
-        
-        # write_timeout verhindert endloses Blockieren auf inaktiven Ports
-        self.serial = serial.Serial(
-            port=self.port, 
-            baudrate=self.baudrate, 
-            timeout=self.timeout,
-            write_timeout=self.timeout
-        )
-        self.serial.reset_input_buffer()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if self.serial and self.serial.is_open:
-            self.serial.close()
-
-    def _parse_controller_error(self, line: str) -> str:
-        code_str = line.split(" ", 1)[1].strip() if " " in line else ""
-        try:
-            code = int(code_str, 10)
-        except ValueError:
-            return f"Controller meldet einen unbekannten Fehler: '{line}'"
-
-        message = PROTOCOL_ERROR_MESSAGES.get(code, "Unbekannter Fehlercode vom Gerät.")
-        return f"Controller-Fehler {code} (0x{code:02X}): {message}"
-
-    def _parse_controller_error_code(self, code: int) -> str:
-        message = PROTOCOL_ERROR_MESSAGES.get(code, "Unbekannter Fehlercode vom Gerät.")
-        return f"Controller-Fehler {code} (0x{code:02X}): {message}"
-
-    def _raise_error_from_payload(self, payload: bytes) -> None:
-        error_code = payload[0] if len(payload) >= 1 else 0x32
-        detail = ""
-        if len(payload) >= 2:
-            detail_len = payload[1]
-            if detail_len > 0 and len(payload) >= 2 + detail_len:
-                detail = payload[2:2 + detail_len].decode("utf-8", errors="replace")
-
-        msg = self._parse_controller_error_code(error_code)
-        if detail:
-            msg = f"{msg} Detail: {detail}"
-        raise BuzzerError(msg)
-
-    def _next_sequence(self) -> int:
-        seq = self._sequence
-        self._sequence = (self._sequence + 1) & 0xFFFF
-        return seq
-
-    def _crc16_ccitt_false(self, data: bytes) -> int:
-        crc = 0xFFFF
-        for b in data:
-            crc ^= b
-            for _ in range(8):
-                if crc & 0x0001:
-                    crc = ((crc >> 1) ^ 0x8408) & 0xFFFF
-                else:
-                    crc = (crc >> 1) & 0xFFFF
-        return crc
-
-    def _read_exact(self, size: int, timeout: float) -> bytes:
-        deadline = time.monotonic() + timeout
-        chunks = bytearray()
-        while len(chunks) < size:
-            remaining_time = deadline - time.monotonic()
-            if remaining_time <= 0:
-                raise TimeoutError(f"Lese-Timeout beim Warten auf {size} Bytes.")
-            old_timeout = self.serial.timeout
-            self.serial.timeout = min(remaining_time, 0.25)
-            try:
-                chunk = self.serial.read(size - len(chunks))
-            finally:
-                self.serial.timeout = old_timeout
-            if chunk:
-                chunks.extend(chunk)
-        return bytes(chunks)
-
-    def _build_frame(self, frame_type: int, command_id: int, sequence: int, payload: bytes) -> bytes:
-        payload = payload or b""
-        payload_len = len(payload)
-        header_no_sync_crc = struct.pack("<BBHI", frame_type, command_id, sequence, payload_len)
-        header_crc = self._crc16_ccitt_false(header_no_sync_crc)
-        header = SYNC + header_no_sync_crc + struct.pack("<H", header_crc)
-        payload_crc = binascii.crc32(payload) & 0xFFFFFFFF
-        return header + payload + struct.pack("<I", payload_crc)
-
-    def _write_frame(self, frame: bytes) -> None:
-        try:
-            self.serial.write(frame)
-            self.serial.flush()
-        except Exception as e:
-            if e.__class__.__name__ == "SerialTimeoutException":
-                raise TimeoutError(f"Schreib-Timeout am Port {self.port}. Ist das Gerät blockiert?") from e
-            raise
-
-    def _send_binary_frame_no_wait(self, command_id: int, payload: bytes = b"") -> int:
-        if self.serial is None:
-            raise BuzzerError("Serielle Verbindung ist nicht geöffnet.")
-        sequence = self._next_sequence()
-        frame = self._build_frame(FRAME_REQ, command_id, sequence, payload)
-        self._write_frame(frame)
-        return sequence
-
-    def _read_frame(self, timeout: float = None) -> dict:
-        eff_timeout = timeout if timeout is not None else self.timeout
-        deadline = time.monotonic() + eff_timeout
-
-        sync_idx = 0
-        while sync_idx < len(SYNC):
-            remaining = deadline - time.monotonic()
-            if remaining <= 0:
-                raise TimeoutError("Timeout beim Warten auf Sync 'BUZZ'.")
-            b = self._read_exact(1, remaining)
-            if b[0] == SYNC[sync_idx]:
-                sync_idx += 1
-            else:
-                sync_idx = 1 if b[0] == SYNC[0] else 0
-
-        remaining = deadline - time.monotonic()
-        if remaining <= 0:
-            raise TimeoutError("Timeout beim Lesen des Frame-Headers.")
-        rest_header = self._read_exact(HEADER_SIZE - len(SYNC), remaining)
-        frame_type, command_id, sequence, payload_len, rx_header_crc = struct.unpack("<BBHIH", rest_header)
-
-        calc_header_crc = self._crc16_ccitt_false(struct.pack("<BBHI", frame_type, command_id, sequence, payload_len))
-        if rx_header_crc != calc_header_crc:
-            raise BuzzerError(
-                f"Ungültige Header-CRC: empfangen 0x{rx_header_crc:04X}, erwartet 0x{calc_header_crc:04X}"
-            )
-
-        remaining = deadline - time.monotonic()
-        if remaining <= 0:
-            raise TimeoutError("Timeout beim Lesen des Payloads.")
-        payload = self._read_exact(payload_len, remaining) if payload_len else b""
-
-        remaining = deadline - time.monotonic()
-        if remaining <= 0:
-            raise TimeoutError("Timeout beim Lesen der Payload-CRC.")
-        rx_payload_crc = struct.unpack("<I", self._read_exact(4, remaining))[0]
-        calc_payload_crc = binascii.crc32(payload) & 0xFFFFFFFF
-        if rx_payload_crc != calc_payload_crc:
-            raise BuzzerError(
-                f"Ungültige Payload-CRC: empfangen 0x{rx_payload_crc:08X}, erwartet 0x{calc_payload_crc:08X}"
-            )
-
-        return {
-            "frame_type": frame_type,
-            "command_id": command_id,
-            "sequence": sequence,
-            "payload": payload,
-        }
-
-    def send_binary_command(self, command_id: int, payload: bytes = b"", timeout: float = None) -> bytes:
-        if self.serial is None:
-            raise BuzzerError("Serielle Verbindung ist nicht geöffnet.")
-
-        eff_timeout = timeout if timeout is not None else self.timeout
-        self.serial.reset_input_buffer()
-
-        sequence = self._next_sequence()
-        frame = self._build_frame(FRAME_REQ, command_id, sequence, payload)
-
-        self._write_frame(frame)
-
-        response = self._read_frame(timeout=eff_timeout)
-
-        if response["sequence"] != sequence:
-            raise BuzzerError(
-                f"Antwort-Sequenz passt nicht: erwartet {sequence}, erhalten {response['sequence']}"
-            )
-
-        if response["command_id"] != command_id:
-            raise BuzzerError(
-                f"Antwort-Kommando passt nicht: erwartet 0x{command_id:02X}, erhalten 0x{response['command_id']:02X}"
-            )
-
-        if response["frame_type"] == FRAME_RESP_ERROR:
-            self._raise_error_from_payload(response["payload"])
-
-        if response["frame_type"] not in (FRAME_RESP_ACK, FRAME_RESP_DATA):
-            raise BuzzerError(f"Unerwarteter Response-Typ: 0x{response['frame_type']:02X}")
-
-        return response["payload"]
-
-    def get_protocol_version(self, timeout: float = None) -> int:
-        payload = self.send_binary_command(CMD_GET_PROTOCOL_VERSION, b"", timeout=timeout)
-        if len(payload) != 2:
-            raise BuzzerError(f"Ungültige Antwortlänge für GET_PROTOCOL_VERSION: {len(payload)}")
-        return struct.unpack("<H", payload)[0]
-
-    def get_firmware_status(self, timeout: float = None) -> tuple[int, str]:
-        payload = self.send_binary_command(CMD_GET_FIRMWARE_STATUS, b"", timeout=timeout)
-        if len(payload) < 2:
-            raise BuzzerError("Ungültige Antwort für GET_FIRMWARE_STATUS: zu kurz")
-
-        status = payload[0]
-        version_len = payload[1]
-        if len(payload) != 2 + version_len:
-            raise BuzzerError(
-                f"Ungültige Antwort für GET_FIRMWARE_STATUS: erwartete Länge {2 + version_len}, erhalten {len(payload)}"
-            )
-        version = payload[2:2 + version_len].decode("utf-8", errors="replace")
-        return status, version
-
-    def get_flash_status(self, timeout: float = None) -> dict:
-        payload = self.send_binary_command(CMD_GET_FLASH_STATUS, b"", timeout=timeout)
-        if len(payload) != 16:
-            raise BuzzerError(f"Ungültige Antwortlänge für GET_FLASH_STATUS: {len(payload)}")
-
-        block_size, total_blocks, free_blocks, path_max_len = struct.unpack("<IIII", payload)
-        if path_max_len > 0:
-            self._max_path_len = int(path_max_len)
-
-        return {
-            "block_size": block_size,
-            "total_blocks": total_blocks,
-            "free_blocks": free_blocks,
-            "path_max_len": path_max_len,
-        }
-
-    def confirm_firmware(self, timeout: float = None) -> None:
-        payload = self.send_binary_command(CMD_CONFIRM_FIRMWARE, b"", timeout=timeout)
-        if len(payload) != 0:
-            raise BuzzerError(f"Unerwartete Payload für CONFIRM_FIRMWARE: {len(payload)} Bytes")
-
-    def reboot_device(self, timeout: float = None) -> None:
-        payload = self.send_binary_command(CMD_REBOOT, b"", timeout=timeout)
-        if len(payload) != 0:
-            raise BuzzerError(f"Unerwartete Payload für REBOOT: {len(payload)} Bytes")
-
-    def _encode_path_payload(self, path: str) -> bytes:
-        path_bytes = path.encode("utf-8")
-        if len(path_bytes) == 0:
-            raise BuzzerError("Pfad darf nicht leer sein.")
-        max_path_len = min(self._max_path_len, 255)
-        if len(path_bytes) > max_path_len:
-            raise BuzzerError(f"Pfad ist zu lang (max. {max_path_len} Bytes).")
-        return bytes([len(path_bytes)]) + path_bytes
-
-    def list_directory(self, path: str, timeout: float = None) -> list[str]:
-        if self.serial is None:
-            raise BuzzerError("Serielle Verbindung ist nicht geöffnet.")
-
-        eff_timeout = timeout if timeout is not None else self.timeout
-        self.serial.reset_input_buffer()
-
-        sequence = self._next_sequence()
-        frame = self._build_frame(FRAME_REQ, CMD_LIST_DIR, sequence, self._encode_path_payload(path))
-
-        try:
-            self.serial.write(frame)
-            self.serial.flush()
-        except Exception as e:
-            if e.__class__.__name__ == "SerialTimeoutException":
-                raise TimeoutError(f"Schreib-Timeout am Port {self.port}. Ist das Gerät blockiert?") from e
-            raise
-
-        lines = []
-        stream_started = False
-
-        while True:
-            response = self._read_frame(timeout=eff_timeout)
-
-            if response["sequence"] != sequence:
-                raise BuzzerError(
-                    f"Antwort-Sequenz passt nicht: erwartet {sequence}, erhalten {response['sequence']}"
-                )
-
-            if response["command_id"] != CMD_LIST_DIR:
-                raise BuzzerError(
-                    f"Antwort-Kommando passt nicht: erwartet 0x{CMD_LIST_DIR:02X}, erhalten 0x{response['command_id']:02X}"
-                )
-
-            frame_type = response["frame_type"]
-            payload = response["payload"]
-
-            if frame_type == FRAME_RESP_ERROR:
-                error_code = payload[0] if len(payload) >= 1 else 0x32
-                detail = ""
-                if len(payload) >= 2:
-                    detail_len = payload[1]
-                    if detail_len > 0 and len(payload) >= 2 + detail_len:
-                        detail = payload[2:2 + detail_len].decode("utf-8", errors="replace")
-
-                msg = self._parse_controller_error_code(error_code)
-                if detail:
-                    msg = f"{msg} Detail: {detail}"
-                raise BuzzerError(msg)
-
-            if frame_type == FRAME_RESP_STREAM_START:
-                stream_started = True
-                continue
-
-            if frame_type == FRAME_RESP_STREAM_CHUNK:
-                if len(payload) < 6:
-                    raise BuzzerError("Ungültiger LIST_DIR Chunk: zu kurz")
-
-                entry_type = payload[0]
-                name_len = payload[1]
-                if len(payload) != 6 + name_len:
-                    raise BuzzerError("Ungültiger LIST_DIR Chunk: inkonsistente Namenslänge")
-
-                size = struct.unpack("<I", payload[2:6])[0]
-                name = payload[6:6 + name_len].decode("utf-8", errors="replace")
-
-                if entry_type == 0:
-                    type_char = "F"
-                elif entry_type == 1:
-                    type_char = "D"
-                else:
-                    raise BuzzerError(f"Ungültiger LIST_DIR entry_type: {entry_type}")
-
-                lines.append(f"{type_char},{size},{name}")
-                continue
-
-            if frame_type == FRAME_RESP_STREAM_END:
-                return lines
-
-            if not stream_started and frame_type == FRAME_RESP_DATA:
-                text = payload.decode("utf-8", errors="replace")
-                return [line for line in text.splitlines() if line]
-
-            if frame_type == FRAME_RESP_ACK:
-                return lines
-
-            raise BuzzerError(f"Unerwarteter LIST_DIR Response-Typ: 0x{frame_type:02X}")
-
-    def check_file_crc(self, path: str, timeout: float = None) -> int:
-        payload = self.send_binary_command(CMD_CHECK_FILE_CRC, self._encode_path_payload(path), timeout=timeout)
-        if len(payload) != 4:
-            raise BuzzerError(f"Ungültige Antwortlänge für CHECK_FILE_CRC: {len(payload)}")
-        return struct.unpack("<I", payload)[0]
-
-    def mkdir(self, path: str, timeout: float = None) -> None:
-        payload = self.send_binary_command(CMD_MKDIR, self._encode_path_payload(path), timeout=timeout)
-        if len(payload) != 0:
-            raise BuzzerError(f"Unerwartete Payload für MKDIR: {len(payload)} Bytes")
-
-    def rm(self, path: str, timeout: float = None) -> None:
-        payload = self.send_binary_command(CMD_RM, self._encode_path_payload(path), timeout=timeout)
-        if len(payload) != 0:
-            raise BuzzerError(f"Unerwartete Payload für RM: {len(payload)} Bytes")
-
-    def stat(self, path: str, timeout: float = None) -> dict:
-        payload = self.send_binary_command(CMD_STAT, self._encode_path_payload(path), timeout=timeout)
-        if len(payload) != 5:
-            raise BuzzerError(f"Ungültige Antwortlänge für STAT: {len(payload)}")
-
-        entry_type = payload[0]
-        if entry_type == 0:
-            type_char = "F"
-        elif entry_type == 1:
-            type_char = "D"
-        else:
-            raise BuzzerError(f"Ungültiger STAT entry_type: {entry_type}")
-
-        size = struct.unpack("<I", payload[1:5])[0]
-        return {
-            "type": type_char,
-            "size": int(size),
-        }
-
-    def rename(self, old_path: str, new_path: str, timeout: float = None) -> None:
-        old_payload = self._encode_path_payload(old_path)
-        new_payload = self._encode_path_payload(new_path)
-        payload = old_payload + new_payload
-        response = self.send_binary_command(CMD_RENAME, payload, timeout=timeout)
-        if len(response) != 0:
-            raise BuzzerError(f"Unerwartete Payload für RENAME: {len(response)} Bytes")
-
-    def rm_recursive(self, path: str, timeout: float = None) -> None:
-        payload = self.send_binary_command(CMD_RM_R, self._encode_path_payload(path), timeout=timeout)
-        if len(payload) != 0:
-            raise BuzzerError(f"Unerwartete Payload für RM_R: {len(payload)} Bytes")
-
-    def get_file_data(self, path: str, timeout: float = None, progress_callback=None) -> bytes:
-        if self.serial is None:
-            raise BuzzerError("Serielle Verbindung ist nicht geöffnet.")
-
-        eff_timeout = timeout if timeout is not None else self.timeout
-        self.serial.reset_input_buffer()
-
-        sequence = self._next_sequence()
-        frame = self._build_frame(FRAME_REQ, CMD_GET_FILE, sequence, self._encode_path_payload(path))
-        self._write_frame(frame)
-
-        start_response = self._read_frame(timeout=eff_timeout)
-        if start_response["sequence"] != sequence:
-            raise BuzzerError(
-                f"Antwort-Sequenz passt nicht: erwartet {sequence}, erhalten {start_response['sequence']}"
-            )
-        if start_response["command_id"] != CMD_GET_FILE:
-            raise BuzzerError(
-                f"Antwort-Kommando passt nicht: erwartet 0x{CMD_GET_FILE:02X}, erhalten 0x{start_response['command_id']:02X}"
-            )
-        if start_response["frame_type"] == FRAME_RESP_ERROR:
-            self._raise_error_from_payload(start_response["payload"])
-        if start_response["frame_type"] != FRAME_RESP_DATA or len(start_response["payload"]) != 4:
-            raise BuzzerError("Ungültige GET_FILE-Startantwort (erwartet DATA mit 4 Byte Länge)")
-
-        expected_len = struct.unpack("<I", start_response["payload"])[0]
-        received = 0
-        running_crc = 0
-        chunks = bytearray()
-        chunk_size = 4096
-
-        while received < expected_len:
-            to_read = min(chunk_size, expected_len - received)
-            chunk = self._read_exact(to_read, eff_timeout)
-            chunks.extend(chunk)
-            running_crc = binascii.crc32(chunk, running_crc) & 0xFFFFFFFF
-            received += len(chunk)
-            if progress_callback:
-                progress_callback(len(chunk), received, expected_len)
-
-        end_response = self._read_frame(timeout=eff_timeout)
-        if end_response["sequence"] != sequence:
-            raise BuzzerError(
-                f"Antwort-Sequenz passt nicht: erwartet {sequence}, erhalten {end_response['sequence']}"
-            )
-        if end_response["command_id"] != CMD_GET_FILE:
-            raise BuzzerError(
-                f"Antwort-Kommando passt nicht: erwartet 0x{CMD_GET_FILE:02X}, erhalten 0x{end_response['command_id']:02X}"
-            )
-        if end_response["frame_type"] == FRAME_RESP_ERROR:
-            self._raise_error_from_payload(end_response["payload"])
-        if end_response["frame_type"] != FRAME_RESP_DATA or len(end_response["payload"]) != 4:
-            raise BuzzerError("Ungültige GET_FILE-Endantwort (erwartet DATA mit 4 Byte CRC32)")
-
-        expected_crc32 = struct.unpack("<I", end_response["payload"])[0]
-        if running_crc != expected_crc32:
-            raise BuzzerError(
-                f"GET_FILE CRC32-Mismatch: empfangen 0x{running_crc:08X}, erwartet 0x{expected_crc32:08X}"
-            )
-
-        return bytes(chunks)
-
-    def put_file_start(self, path: str, total_len: int, expected_crc32: int, timeout: float = None) -> None:
-        if total_len < 0:
-            raise BuzzerError("Dateigröße darf nicht negativ sein.")
-        payload = self._encode_path_payload(path) + struct.pack("<II", int(total_len), int(expected_crc32) & 0xFFFFFFFF)
-        response = self.send_binary_command(CMD_PUT_FILE_START, payload, timeout=timeout)
-        if len(response) != 0:
-            raise BuzzerError(f"Unerwartete Payload für PUT_FILE_START: {len(response)} Bytes")
-
-    def put_file_chunk(self, chunk: bytes, timeout: float = None) -> None:
-        self._send_binary_frame_no_wait(CMD_PUT_FILE_CHUNK, chunk)
-
-    def put_file_end(self, timeout: float = None) -> None:
-        eff_timeout = timeout if timeout is not None else self.timeout
-        end_sequence = self._send_binary_frame_no_wait(CMD_PUT_FILE_END, b"")
-
-        deadline = time.monotonic() + eff_timeout
-        while True:
-            remaining = deadline - time.monotonic()
-            if remaining <= 0:
-                raise TimeoutError("Lese-Timeout beim Warten auf PUT_FILE_END Antwort.")
-
-            response = self._read_frame(timeout=remaining)
-
-            if response["frame_type"] == FRAME_RESP_ERROR and response["command_id"] in (
-                CMD_PUT_FILE_START,
-                CMD_PUT_FILE_CHUNK,
-                CMD_PUT_FILE_END,
-            ):
-                self._raise_error_from_payload(response["payload"])
-
-            if response["command_id"] != CMD_PUT_FILE_END or response["sequence"] != end_sequence:
-                continue
-
-            if response["frame_type"] not in (FRAME_RESP_ACK, FRAME_RESP_DATA):
-                raise BuzzerError(f"Unerwarteter Response-Typ für PUT_FILE_END: 0x{response['frame_type']:02X}")
-
-            if len(response["payload"]) != 0:
-                raise BuzzerError(f"Unerwartete Payload für PUT_FILE_END: {len(response['payload'])} Bytes")
-
-            return
-
-    def put_file_data(
-        self,
-        path: str,
-        data: bytes,
-        timeout: float = None,
-        chunk_size: int = 4096,
-        progress_callback=None,
-    ) -> int:
-        if data is None:
-            data = b""
-        if chunk_size <= 0:
-            raise BuzzerError("chunk_size muss größer als 0 sein.")
-
-        expected_crc32 = binascii.crc32(data) & 0xFFFFFFFF
-        if self.serial is None:
-            raise BuzzerError("Serielle Verbindung ist nicht geöffnet.")
-
-        eff_timeout = timeout if timeout is not None else self.timeout
-        self.serial.reset_input_buffer()
-
-        sequence = self._next_sequence()
-        start_payload = self._encode_path_payload(path) + struct.pack("<II", len(data), expected_crc32)
-        start_frame = self._build_frame(FRAME_REQ, CMD_PUT_FILE_START, sequence, start_payload)
-        self._write_frame(start_frame)
-
-        sent = 0
-        while sent < len(data):
-            chunk = data[sent:sent + chunk_size]
-            try:
-                self.serial.write(chunk)
-            except Exception as e:
-                if e.__class__.__name__ == "SerialTimeoutException":
-                    raise TimeoutError(f"Schreib-Timeout am Port {self.port}. Ist das Gerät blockiert?") from e
-                raise
-            sent += len(chunk)
-            if progress_callback:
-                progress_callback(len(chunk), sent, len(data))
-
-        self.serial.flush()
-
-        response = self._read_frame(timeout=eff_timeout)
-
-        if response["sequence"] != sequence:
-            raise BuzzerError(
-                f"Antwort-Sequenz passt nicht: erwartet {sequence}, erhalten {response['sequence']}"
-            )
-
-        if response["command_id"] != CMD_PUT_FILE_START:
-            raise BuzzerError(
-                f"Antwort-Kommando passt nicht: erwartet 0x{CMD_PUT_FILE_START:02X}, erhalten 0x{response['command_id']:02X}"
-            )
-
-        if response["frame_type"] == FRAME_RESP_ERROR:
-            self._raise_error_from_payload(response["payload"])
-
-        if response["frame_type"] not in (FRAME_RESP_ACK, FRAME_RESP_DATA):
-            raise BuzzerError(f"Unerwarteter Response-Typ für PUT_FILE_START: 0x{response['frame_type']:02X}")
-
-        if len(response["payload"]) != 0:
-            raise BuzzerError(f"Unerwartete Payload für PUT_FILE_START: {len(response['payload'])} Bytes")
-        return expected_crc32
-
-    def fw_put_data(
-        self,
-        data: bytes,
-        timeout: float = None,
-        chunk_size: int = 4096,
-        progress_callback=None,
-    ) -> int:
-        if data is None:
-            data = b""
-        if chunk_size <= 0:
-            raise BuzzerError("chunk_size muss größer als 0 sein.")
-        if len(data) == 0:
-            raise BuzzerError("Firmware-Datei ist leer.")
-
-        expected_crc32 = binascii.crc32(data) & 0xFFFFFFFF
-        if self.serial is None:
-            raise BuzzerError("Serielle Verbindung ist nicht geöffnet.")
-
-        eff_timeout = timeout if timeout is not None else self.timeout
-        old_write_timeout = self.serial.write_timeout
-        self.serial.write_timeout = max(float(old_write_timeout or 0.0), float(eff_timeout))
-        self.serial.reset_input_buffer()
-
-        try:
-            sequence = self._next_sequence()
-            start_payload = struct.pack("<II", len(data), expected_crc32)
-            start_frame = self._build_frame(FRAME_REQ, CMD_PUT_FW_START, sequence, start_payload)
-            self._write_frame(start_frame)
-
-            sent = 0
-            while sent < len(data):
-                chunk = data[sent:sent + chunk_size]
-                try:
-                    self.serial.write(chunk)
-                except Exception as e:
-                    if e.__class__.__name__ == "SerialTimeoutException":
-                        raise TimeoutError(f"Schreib-Timeout am Port {self.port}. Ist das Gerät blockiert?") from e
-                    raise
-                sent += len(chunk)
-                if progress_callback:
-                    progress_callback(len(chunk), sent, len(data))
-
-            self.serial.flush()
-
-            response = self._read_frame(timeout=eff_timeout)
-        finally:
-            self.serial.write_timeout = old_write_timeout
-
-        if response["sequence"] != sequence:
-            raise BuzzerError(
-                f"Antwort-Sequenz passt nicht: erwartet {sequence}, erhalten {response['sequence']}"
-            )
-
-        if response["command_id"] != CMD_PUT_FW_START:
-            raise BuzzerError(
-                f"Antwort-Kommando passt nicht: erwartet 0x{CMD_PUT_FW_START:02X}, erhalten 0x{response['command_id']:02X}"
-            )
-
-        if response["frame_type"] == FRAME_RESP_ERROR:
-            self._raise_error_from_payload(response["payload"])
-
-        if response["frame_type"] not in (FRAME_RESP_ACK, FRAME_RESP_DATA):
-            raise BuzzerError(f"Unerwarteter Response-Typ für PUT_FW_START: 0x{response['frame_type']:02X}")
-
-        if len(response["payload"]) != 0:
-            raise BuzzerError(f"Unerwartete Payload für PUT_FW_START: {len(response['payload'])} Bytes")
-
-        return expected_crc32
-
-    def get_tag_blob(self, path: str, timeout: float = None) -> bytes:
-        if self.serial is None:
-            raise BuzzerError("Serielle Verbindung ist nicht geöffnet.")
-
-        eff_timeout = timeout if timeout is not None else self.timeout
-        self.serial.reset_input_buffer()
-
-        sequence = self._next_sequence()
-        frame = self._build_frame(FRAME_REQ, CMD_GET_TAG_BLOB, sequence, self._encode_path_payload(path))
-
-        try:
-            self.serial.write(frame)
-            self.serial.flush()
-        except Exception as e:
-            if e.__class__.__name__ == "SerialTimeoutException":
-                raise TimeoutError(f"Schreib-Timeout am Port {self.port}. Ist das Gerät blockiert?") from e
-            raise
-
-        expected_len = None
-        chunks = bytearray()
-
-        while True:
-            response = self._read_frame(timeout=eff_timeout)
-
-            if response["sequence"] != sequence:
-                raise BuzzerError(
-                    f"Antwort-Sequenz passt nicht: erwartet {sequence}, erhalten {response['sequence']}"
-                )
-
-            if response["command_id"] != CMD_GET_TAG_BLOB:
-                raise BuzzerError(
-                    f"Antwort-Kommando passt nicht: erwartet 0x{CMD_GET_TAG_BLOB:02X}, erhalten 0x{response['command_id']:02X}"
-                )
-
-            frame_type = response["frame_type"]
-            payload = response["payload"]
-
-            if frame_type == FRAME_RESP_ERROR:
-                error_code = payload[0] if len(payload) >= 1 else 0x32
-                raise BuzzerError(self._parse_controller_error_code(error_code))
-
-            if frame_type == FRAME_RESP_STREAM_START:
-                if len(payload) != 4:
-                    raise BuzzerError("Ungültiger GET_TAG_BLOB START-Frame")
-                expected_len = struct.unpack("<I", payload)[0]
-                continue
-
-            if frame_type == FRAME_RESP_STREAM_CHUNK:
-                chunks.extend(payload)
-                continue
-
-            if frame_type == FRAME_RESP_STREAM_END:
-                if expected_len is not None and len(chunks) != expected_len:
-                    raise BuzzerError(
-                        f"Tag-Blob-Länge inkonsistent: erwartet {expected_len}, erhalten {len(chunks)}"
-                    )
-                return bytes(chunks)
-
-            if frame_type == FRAME_RESP_DATA:
-                return payload
-
-            raise BuzzerError(f"Unerwarteter GET_TAG_BLOB Response-Typ: 0x{frame_type:02X}")
-
-    def set_tag_blob(self, path: str, blob: bytes, timeout: float = None, chunk_size: int = 192) -> None:
-        if blob is None:
-            blob = b""
-
-        if len(blob) > 1024:
-            raise BuzzerError("Tag-Blob ist zu groß (max. 1024 Bytes).")
-
-        path_payload = self._encode_path_payload(path)
-        start_payload = path_payload + struct.pack("<H", len(blob))
-        self.send_binary_command(CMD_SET_TAG_BLOB_START, start_payload, timeout=timeout)
-
-        offset = 0
-        while offset < len(blob):
-            chunk = blob[offset:offset + chunk_size]
-            self.send_binary_command(CMD_SET_TAG_BLOB_CHUNK, chunk, timeout=timeout)
-            offset += len(chunk)
-
-        self.send_binary_command(CMD_SET_TAG_BLOB_END, b"", timeout=timeout)
-
-    def send_command(self, command: str, custom_timeout: float = None) -> list:
-        eff_timeout = custom_timeout if custom_timeout is not None else self.timeout
-        self.serial.reset_input_buffer()
-        
-        try:
-            self.serial.write(f"{command}\n".encode('utf-8'))
-            self.serial.flush()
-        except Exception as e:
-            if e.__class__.__name__ == "SerialTimeoutException":
-                raise TimeoutError(f"Schreib-Timeout am Port {self.port}. Ist das Gerät blockiert?") from e
-            raise
-
-        lines = []
-        start_time = time.monotonic()
-
-        while (time.monotonic() - start_time) < eff_timeout:
-            if self.serial.in_waiting > 0:
-                try:
-                    line = self.serial.readline().decode('utf-8', errors='ignore').strip()
-                    if not line:
-                        continue
-                    if line == "OK":
-                        return lines
-                    elif line.startswith("ERR"):
-                        raise BuzzerError(self._parse_controller_error(line))
-                    else:
-                        lines.append(line)
-                except BuzzerError:
-                    raise
-                except Exception as e:
-                    raise BuzzerError(f"Fehler beim Lesen der Antwort: {e}")
-            else:
-                time.sleep(POLL_SLEEP_SECONDS)
-
-        raise TimeoutError(f"Lese-Timeout ({eff_timeout}s) beim Warten auf Antwort für: '{command}'")
-    
-    def send_binary(self, filepath: str, chunk_size: int = 4096, timeout: float = 10.0, progress_callback=None):
-        """
-        Überträgt eine Binärdatei in Chunks, nachdem das READY-Signal empfangen wurde.
-        """
-        # 1. Warte auf die READY-Bestätigung vom Controller
-        start_time = time.time()
-        ready = False
-        while (time.time() - start_time) < timeout:
-            if self.serial.in_waiting > 0:
-                line = self.serial.readline().decode('utf-8', errors='ignore').strip()
-                if line == "READY":
-                    ready = True
-                    break
-                elif line.startswith("ERR"):
-                    raise BuzzerError(f"Fehler vor Binärtransfer: {self._parse_controller_error(line)}")
-            time.sleep(POLL_SLEEP_SECONDS)
-
-        if not ready:
-            raise TimeoutError("Kein READY-Signal vom Controller empfangen.")
-
-        # 2. Sende die Datei in Blöcken
-        file_size = os.path.getsize(filepath)
-        bytes_sent = 0
-
-        with open(filepath, 'rb') as f:
-            while bytes_sent < file_size:
-                # 1. Nicht blockierende Fehlerprüfung vor jedem Chunk
-                if self.serial.in_waiting > 0:
-                    line = self.serial.readline().decode('utf-8', errors='ignore').strip()
-                    if line.startswith("ERR"):
-                        raise BuzzerError(f"Controller hat Transfer abgebrochen: {self._parse_controller_error(line)}")
-
-                # 2. Chunk lesen und schreiben
-                chunk = f.read(chunk_size)
-                if not chunk:
-                    break
-                
-                self.serial.write(chunk)
-                # WICHTIG: self.serial.flush() hier entfernen. 
-                # Dies verhindert den Deadlock mit dem OS-USB-Puffer.
-                
-                bytes_sent += len(chunk)
-                
-                # 3. Callback für UI
-                if progress_callback:
-                    progress_callback(len(chunk))
-                    
-        # 3. Warte auf das finale OK (oder ERR bei CRC/Schreib-Fehlern)
-        start_time = time.time()
-        while (time.time() - start_time) < timeout:
-            if self.serial.in_waiting > 0:
-                line = self.serial.readline().decode('utf-8', errors='ignore').strip()
-                if line == "OK":
-                    return True
-                elif line.startswith("ERR"):
-                    raise BuzzerError(f"Fehler beim Speichern der Binärdatei: {self._parse_controller_error(line)}")
-            time.sleep(POLL_SLEEP_SECONDS)
-
-        raise TimeoutError("Zeitüberschreitung nach Binärtransfer (kein OK empfangen).")

buzzer_tool/core/util.py

@@ -1,25 +0,0 @@
-def hex_to_bytearray(hex_string):
-    """
-    Wandelt einen Hex-String (z.B. "deadbeef") in ein bytearray um.
-    Entfernt vorher Leerzeichen und prüft auf Gültigkeit.
-    """
-    try:
-        # Whitespace entfernen (falls vorhanden)
-        clean_hex = hex_string.strip().replace(" ", "")
-        
-        # Konvertierung
-        return bytearray.fromhex(clean_hex)
-    
-    except ValueError as e:
-        print(f"Fehler bei der Konvertierung: {e}")
-        return None
-
-def string_to_hexstring(text):
-    """
-    Wandelt einen String in einen UTF-8-kodierten Hex-String um.
-    """
-    # 1. String zu UTF-8 Bytes
-    utf8_bytes = text.encode('utf-8')
-    
-    # 2. Bytes zu Hex-String
-    return utf8_bytes.hex()

buzzer_tool/requirements.txt

@@ -1,2 +0,0 @@
-pyyaml
-pyserial

buzzer_tool/smoke_test.sh

@@ -1,165 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
-ROOT_DIR="$(cd -- "$SCRIPT_DIR/.." && pwd)"
-CLI="$ROOT_DIR/buzzer_tool/buzzer.py"
-
-PORT=""
-BAUDRATE=""
-TIMEOUT=""
-REMOTE_BASE="/lfs/smoke"
-KEEP_TMP=0
-
-usage() {
-  cat <<EOF
-Usage: $(basename "$0") -p <port> [-b baudrate] [-t timeout] [--remote-base /lfs/path] [--keep-tmp]
-
-Beispiel:
-  $(basename "$0") -p /dev/tty.usbmodem14101 -b 115200 -t 5
-EOF
-}
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    -p|--port)
-      PORT="$2"
-      shift 2
-      ;;
-    -b|--baudrate)
-      BAUDRATE="$2"
-      shift 2
-      ;;
-    -t|--timeout)
-      TIMEOUT="$2"
-      shift 2
-      ;;
-    --remote-base)
-      REMOTE_BASE="$2"
-      shift 2
-      ;;
-    --keep-tmp)
-      KEEP_TMP=1
-      shift
-      ;;
-    -h|--help)
-      usage
-      exit 0
-      ;;
-    *)
-      echo "Unbekanntes Argument: $1" >&2
-      usage
-      exit 1
-      ;;
-  esac
-done
-
-if [[ -z "$PORT" ]]; then
-  echo "Fehler: --port ist erforderlich" >&2
-  usage
-  exit 1
-fi
-
-COMMON_ARGS=("-p" "$PORT" "--no-auto-info")
-if [[ -n "$BAUDRATE" ]]; then
-  COMMON_ARGS+=("-b" "$BAUDRATE")
-fi
-if [[ -n "$TIMEOUT" ]]; then
-  COMMON_ARGS+=("-t" "$TIMEOUT")
-fi
-
-run_cli() {
-  python3 "$CLI" "${COMMON_ARGS[@]}" "$@"
-}
-
-TMP_DIR="$(mktemp -d -t buzzer-smoke-XXXXXX)"
-cleanup() {
-  if [[ "$KEEP_TMP" -eq 0 ]]; then
-    rm -rf "$TMP_DIR"
-  else
-    echo "Temporärer Ordner bleibt erhalten: $TMP_DIR"
-  fi
-}
-trap cleanup EXIT
-
-echo "[1/9] Erzeuge sehr kleine Testdateien mit Nullen in $TMP_DIR"
-python3 - "$TMP_DIR" <<'PY'
-import os
-import sys
-base = sys.argv[1]
-files = {
-    "z0.bin": 0,
-    "z1.bin": 1,
-    "z8.bin": 8,
-    "z16.bin": 16,
-    "z64.bin": 64,
-    "z100k.bin": 102400,
-}
-for name, size in files.items():
-    with open(os.path.join(base, name), "wb") as f:
-        f.write(b"\x00" * size)
-print("Created:", ", ".join(f"{k}:{v}B" for k,v in files.items()))
-PY
-
-echo "[2/9] Bereinige altes Remote-Testverzeichnis (falls vorhanden)"
-run_cli rm -r "$REMOTE_BASE" >/dev/null 2>&1 || true
-
-echo "[3/9] Lege Remote-Verzeichnis an"
-run_cli mkdir "$REMOTE_BASE"
-
-echo "[4/9] Upload der kleinen Null-Dateien"
-run_cli put "$TMP_DIR"/*.bin "$REMOTE_BASE/"
-
-echo "[5/9] Prüfe remote stat"
-run_cli stat "$REMOTE_BASE/z0.bin"
-run_cli stat "$REMOTE_BASE/z64.bin"
-
-echo "[6/9] Teste rename/mv"
-run_cli mv "$REMOTE_BASE/z16.bin" "$REMOTE_BASE/z16_renamed.bin"
-run_cli stat "$REMOTE_BASE/z16_renamed.bin"
-
-echo "[7/9] Pull + get_file (Alias)"
-run_cli pull "$REMOTE_BASE/z1.bin" "$TMP_DIR/pull_z1.bin"
-run_cli get_file "$REMOTE_BASE/z100k.bin" "$TMP_DIR/get_file_z100k.bin"
-
-echo "[8/9] Vergleiche heruntergeladene Dateien"
-python3 - "$TMP_DIR" <<'PY'
-import os
-import sys
-
-TAG_MAGIC = b"TAG!"
-TAG_FOOTER_LEN = 7
-
-base = sys.argv[1]
-
-checks = [
-  ("z1.bin", "pull_z1.bin"),
-  ("z8.bin", "get_file_z8.bin"),
-]
-
-for original_name, pulled_name in checks:
-  original_path = os.path.join(base, original_name)
-  pulled_path = os.path.join(base, pulled_name)
-
-  with open(original_path, "rb") as f:
-    original = f.read()
-  with open(pulled_path, "rb") as f:
-    pulled = f.read()
-
-  if len(pulled) < len(original) + TAG_FOOTER_LEN:
-    raise SystemExit(f"Pulled file zu kurz: {pulled_name}")
-
-  if pulled[:len(original)] != original:
-    raise SystemExit(f"Audio-Präfix stimmt nicht: {pulled_name}")
-
-  if pulled[-4:] != TAG_MAGIC:
-    raise SystemExit(f"TAG-Footer fehlt: {pulled_name}")
-
-print("Vergleich OK (audio + tags)")
-PY
-
-echo "[9/9] Rekursives Löschen + Abschlussliste"
-run_cli rm -r "$REMOTE_BASE"
-run_cli ls /lfs
-
-echo "✅ Smoke-Test erfolgreich abgeschlossen"

firmware/prj.conf

@@ -13,7 +13,6 @@ CONFIG_FLASH_MAP=y
 CONFIG_FILE_SYSTEM=y
 CONFIG_FILE_SYSTEM_LITTLEFS=y
 CONFIG_FILE_SYSTEM_MKFS=y
-CONFIG_CRC=y
 CONFIG_FS_LITTLEFS_READ_SIZE=64
 CONFIG_FS_LITTLEFS_PROG_SIZE=256
 CONFIG_FS_LITTLEFS_CACHE_SIZE=512
@@ -25,7 +24,7 @@ CONFIG_MAIN_STACK_SIZE=2048
 CONFIG_USB_DEVICE_STACK=y
 CONFIG_DEPRECATION_TEST=y
 CONFIG_USB_DEVICE_MANUFACTURER="Eduard Iten"
-CONFIG_USB_DEVICE_PRODUCT="Edi's Buzzer"
+CONFIG_USB_DEVICE_PRODUCT="Edis Buzzer"
 CONFIG_USB_DEVICE_PID=0x0001
 CONFIG_USB_DRIVER_LOG_LEVEL_ERR=y
 CONFIG_USB_DEVICE_LOG_LEVEL_ERR=y

firmware/src/fs.c

@@ -1,5 +1,6 @@
 #include <zephyr/fs/littlefs.h>
 #include <zephyr/drivers/flash.h>
+#include <zephyr/storage/flash_map.h>
 #include <zephyr/dfu/flash_img.h>
 #include <zephyr/dfu/mcuboot.h>
 #include <zephyr/pm/device.h>
@@ -416,4 +417,79 @@ int flash_write_firmware_block(const uint8_t *buffer, size_t length, bool is_las
         return rc;
     }
     return 0;
+}
+
+size_t fs_get_external_flash_page_size(void) {
+    const struct flash_area *fa;
+    const struct device *dev;
+    struct flash_pages_info info;
+    int rc;
+
+    rc = flash_area_open(STORAGE_PARTITION_ID, &fa);
+    if (rc != 0) {
+        LOG_ERR("Failed to open flash area for page size retrieval");
+        return 256; // Fallback to a common page size
+    }
+
+    dev = flash_area_get_device(fa);
+    if (dev == NULL) {
+        flash_area_close(fa);
+        LOG_ERR("Failed to get flash device for page size retrieval");
+        return 256; // Fallback to a common page size
+    }
+
+    rc = flash_get_page_info_by_offs(dev, fa->fa_off, &info);
+    flash_area_close(fa);
+
+    if (rc != 0) {
+        LOG_ERR("Failed to get flash page info: %d", rc);
+        return 256; // Fallback to a common page size
+    }
+
+    return info.size;
+}
+
+size_t fs_get_fw_slot_size(void) {
+    const struct flash_area *fa;
+    int rc;
+
+    rc = flash_area_open(SLOT1_ID, &fa);
+    if (rc != 0) {
+        LOG_ERR("Failed to open flash area for slot size retrieval");
+        return 0;
+    }
+
+    size_t slot_size = fa->fa_size;
+    flash_area_close(fa);
+    return slot_size;
+}
+
+size_t fs_get_internal_flash_page_size(void) {
+    const struct flash_area *fa;
+    const struct device *dev;
+    struct flash_pages_info info;
+    int rc;
+
+    rc = flash_area_open(SLOT1_ID, &fa);
+    if (rc != 0) {
+        LOG_ERR("Failed to open flash area for page size retrieval");
+        return 256; // Fallback to a common page size
+    }
+
+    dev = flash_area_get_device(fa);
+    if (dev == NULL) {
+        flash_area_close(fa);
+        LOG_ERR("Failed to get flash device for page size retrieval");
+        return 256; // Fallback to a common page size
+    }
+
+    rc = flash_get_page_info_by_offs(dev, fa->fa_off, &info);
+    flash_area_close(fa);
+
+    if (rc != 0) {
+        LOG_ERR("Failed to get flash page info: %d", rc);
+        return 256; // Fallback to a common page size
+    }
+
+    return info.size;
 }

firmware/src/fs.h

@@ -3,6 +3,8 @@
 
 #include <zephyr/fs/fs.h>
 
+#define MAX_PATH_LEN 32U
+
 typedef struct slot_info_t {
     size_t start_addr;
     size_t size;
@@ -182,4 +184,21 @@ int flash_init_firmware_upload(void);
  */
 int flash_write_firmware_block(const uint8_t *buffer, size_t length, bool is_last_block);
 
+/**
+ * @brief Gets the page size of the internal flash, which is needed for proper write operations
+ * @return Page size in bytes
+ */
+size_t fs_get_internal_flash_page_size(void);
+
+/**
+ * @brief Gets the size of the firmware slot, which is needed for proper write operations
+ * @return Size in bytes
+ */
+size_t fs_get_fw_slot_size(void);
+
+/**
+ * @brief Gets the page size of the external flash, which is needed for proper write operations
+ * @return Page size in bytes
+ */
+size_t fs_get_external_flash_page_size(void);
 #endif // FS_H

firmware/src/protocol.h

@@ -8,44 +8,42 @@
 
 typedef enum {
     PS_WAIT_SYNC = 0,
-    PS_READ_HEADER,
+    PS_READ_FRAME_TYPE,
-    PS_READ_PAYLOAD,
+    PS_READ_REQ,
-    PS_READ_PAYLOAD_CRC,
+    PS_READ_REQ_DATA,
 } protocol_state_t;
 
 typedef enum {
-    CMD_INVALID = 0,
     CMD_GET_PROTOCOL_VERSION = 0x00,
     CMD_GET_FIRMWARE_STATUS = 0x01,
     CMD_GET_FLASH_STATUS = 0x02,
     CMD_CONFIRM_FIRMWARE = 0x03,
     CMD_REBOOT = 0x04,
+
     CMD_LIST_DIR = 0x10,
     CMD_CHECK_FILE_CRC = 0x11,
     CMD_MKDIR = 0x12,
     CMD_RM = 0x13,
-    CMD_PUT_FILE_START = 0x14,
-    CMD_PUT_FILE_CHUNK = 0x15,
-    CMD_PUT_FILE_END = 0x16,
-    CMD_PUT_FW_START = 0x17,
     CMD_STAT = 0x18,
     CMD_RENAME = 0x19,
-    CMD_RM_R = 0x1A,
+
-    CMD_GET_FILE = 0x1B,
+    CMD_PUT_FILE = 0x20,
-    CMD_GET_TAG_BLOB = 0x20,
+    CMD_PUT_FW = 0x21,
-    CMD_SET_TAG_BLOB_START = 0x21,
+    CMD_GET_FILE = 0x22,
-    CMD_SET_TAG_BLOB_CHUNK = 0x22,
-    CMD_SET_TAG_BLOB_END = 0x23,
 } protocol_cmd_t;
 
 typedef enum {
     FRAME_REQ = 0x01,
+    FRAME_REQ_DATA = 0x02,
     FRAME_RESP_ACK = 0x10,
     FRAME_RESP_DATA = 0x11,
     FRAME_RESP_STREAM_START = 0x12,
-    FRAME_RESP_STREAM_CHUNK = 0x13,
+    // FRAME_RESP_STREAM_CHUNK = 0x13, 
     FRAME_RESP_STREAM_END = 0x14,
-    FRAME_RESP_ERROR = 0x7F,
+    FRAME_RESP_LIST_START = 0x15,
+    FRAME_RESP_LIST_CHUNK = 0x16,
+    FRAME_RESP_LIST_END = 0x17,
+    FRAME_RESP_ERROR = 0xFF,
 } protocol_frame_type_t;
 
 typedef enum {
@@ -72,6 +70,13 @@ typedef enum {
     P_ERR_INTERNAL = 0x32,
 } protocol_error_t;
 
+typedef enum
+{
+    FW_STATUS_CONFIRMED = 0x00,
+    FW_STATUS_PENDING = 0x01,
+    FW_STATUS_TESTING = 0x02,
+} firmware_status_t;
+
 void protocol_thread_entry(void *p1, void *p2, void *p3);
 
 #endif // PROTOCOL_H 

firmware/src/usb.c

@@ -6,6 +6,8 @@
 
 #include <io.h>
 
+#define RX_RING_BUF_SIZE 1024
+
 LOG_MODULE_REGISTER(usb, LOG_LEVEL_INF);
 
 K_SEM_DEFINE(usb_rx_sem, 0, 1);
@@ -13,9 +15,8 @@ K_SEM_DEFINE(usb_tx_sem, 0, 1);
 
 #define UART_NODE DT_ALIAS(usb_uart)
 const struct device *cdc_dev = DEVICE_DT_GET(UART_NODE);
+static volatile bool rx_interrupt_enabled = false;
 
-/* NEU: Ringbuffer für stabilen asynchronen USB-Empfang */
-#define RX_RING_BUF_SIZE 5*1024 /* 8 KB Ringpuffer für eingehende USB-Daten */
 RING_BUF_DECLARE(rx_ringbuf, RX_RING_BUF_SIZE);
 
 static void cdc_acm_irq_cb(const struct device *dev, void *user_data)
@@ -36,7 +37,6 @@ static void cdc_acm_irq_cb(const struct device *dev, void *user_data)
                und der USB-Stack den Host drosselt (NAK). */
             uart_irq_rx_disable(dev);
         } else {
-            /* Nur so viele Daten lesen, wie Platz im Ringpuffer ist */
             int to_read = MIN(sizeof(buffer), space);
             int len = uart_fifo_read(dev, buffer, to_read);
             
@@ -68,23 +68,15 @@ bool usb_wait_for_data(k_timeout_t timeout)
     return (k_sem_take(&usb_rx_sem, timeout) == 0);
 }
 
-int usb_read_char(uint8_t *c)
+bool usb_read_byte(uint8_t *c)
 {
     int ret = ring_buf_get(&rx_ringbuf, c, 1);
-    if (ret > 0 && device_is_ready(cdc_dev)) {
+    return (ret > 0);
-        /* Platz geschaffen -> Empfang wieder aktivieren */
-        uart_irq_rx_enable(cdc_dev);
-    }
-    return ret;
 }
 
 int usb_read_buffer(uint8_t *buf, size_t max_len)
 {
     int ret = ring_buf_get(&rx_ringbuf, buf, max_len);
-    if (ret > 0 && device_is_ready(cdc_dev)) {
-        /* Platz geschaffen -> Empfang wieder aktivieren */
-        uart_irq_rx_enable(cdc_dev);
-    }
     return ret;
 }
 
@@ -95,7 +87,7 @@ void usb_resume_rx(void)
     }
 }
 
-void usb_write_char(uint8_t c)
+void usb_write_byte(uint8_t c)
 {
     if (!device_is_ready(cdc_dev)) {
         return;
@@ -103,11 +95,11 @@ void usb_write_char(uint8_t c)
     uart_poll_out(cdc_dev, c);
 }
 
-void usb_write_buffer(const uint8_t *buf, size_t len)
+int usb_write_buffer(const uint8_t *buf, size_t len)
 {
     if (!device_is_ready(cdc_dev))
     {
-        return;
+        return -ENODEV;
     }
 
     size_t written;
@@ -126,10 +118,11 @@ void usb_write_buffer(const uint8_t *buf, size_t len)
             if (k_sem_take(&usb_tx_sem, K_MSEC(100)) != 0)
             {
                 LOG_WRN("USB TX timeout - consumer not reading?");
-                return;
+                return -ETIMEDOUT;
             }
         }
     }
+    return 0;
 }
 
 void usb_flush_rx(void)

firmware/src/usb.h

@@ -17,9 +17,9 @@ bool usb_wait_for_data(k_timeout_t timeout);
 /**
  * @brief Reads a single character from the USB RX FIFO
  * @param c Pointer to store the read character
- * @return 1 if a character was read, 0 if no data was available
+ * @return true if a character was read, false if no data was available
  */
-int usb_read_char(uint8_t *c);
+bool usb_read_byte(uint8_t *c);
 
 /**
  * @brief Reads a block of data from the USB RX FIFO
@@ -36,16 +36,16 @@ void usb_resume_rx(void);
 
 /**
  * @brief Writes a single character to the USB TX FIFO
- * @param c Character to write 
+ * @param c Character to write
  */
-void usb_write_char(uint8_t c);
+void usb_write_byte(uint8_t c);
 
 /**
  * @brief Writes a block of data to the USB TX FIFO
  * @param buf Buffer containing the data to write
  * @param len Number of bytes to write
  */
-void usb_write_buffer(const uint8_t *buf, size_t len);
+int usb_write_buffer(const uint8_t *buf, size_t len);
 
 /**
  * @brief Flushes the USB RX FIFO

tool/buzz.py

@@ -0,0 +1,170 @@
+import sys
+import os
+import argparse
+
+# # Falls buzz.py tief in Unterordnern liegt, stellen wir sicher, 
+# # dass das Hauptverzeichnis im Pfad ist:
+# sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+def main():
+    try:
+        parser = argparse.ArgumentParser(description="Buzzer Serial Comm Tool")
+
+        # Allgemeine Parameter
+        parser.add_argument("-c", "--config", help="Pfad zur config.yaml (optional)", type=str)
+        parser.add_argument("-d", "--debug", help="Aktiviert detaillierte Hex-Logs", action="store_true")
+
+        # Verbindungsparameter (können auch in config.yaml definiert werden)
+        parser.add_argument("-p", "--port", help="Serieller Port", type=str)
+        parser.add_argument("-b", "--baud", help="Baudrate", type=int)
+        parser.add_argument("-t", "--timeout", help="Timeout in Sekunden", type=float)
+
+        # Subparser für Befehle
+        subparsers = parser.add_subparsers(dest="command", help="Verfügbare Befehle")
+
+        # Befehl: flash_info
+        flash_info_parser = subparsers.add_parser("flash_info", help="Informationen über den Flash-Speicher des Controllers abfragen")
+
+        # Befehl: fw_status
+        fw_status_parser = subparsers.add_parser("fw_status", help="Firmware- und Kernel-Status des Controllers abfragen")
+        
+        # Befehl: get_file
+        get_file_parser = subparsers.add_parser("get_file", help="Datei vom Zielsystem herunterladen")
+        get_file_parser.add_argument("source_path", help="Pfad der Datei auf dem Zielsystem")
+        get_file_parser.add_argument("dest_path", help="Zielpfad auf dem lokalen System")
+
+        # Befehl: ls
+        ls_parser = subparsers.add_parser("ls", help="Listet Dateien/Ordner in einem Verzeichnis auf")
+        ls_parser.add_argument("path", help="Pfad auf dem Zielsystem")
+        ls_parser.add_argument("-r", "--recursive", help="Rekursiv durch die Verzeichnisse durchsuchen", action="store_true")
+
+        # Befehl: proto
+        proto_parser = subparsers.add_parser("proto", help="Protokollversion des Controllers abfragen")
+
+        # Befehl: rename
+        rename_parser = subparsers.add_parser("rename", help="Benennen Sie eine Datei oder einen Ordner auf dem Zielsystem um")
+        rename_parser.add_argument("source_path", help="Aktueller Pfad der Datei/des Ordners auf dem Zielsystem")
+        rename_parser.add_argument("dest_path", help="Neuer Pfad der Datei/des Ordners auf dem Zielsystem")
+        
+        # Befehl: rm
+        rm_parser = subparsers.add_parser("rm", help="Entfernt eine Datei oder einen Ordner auf dem Zielsystem")
+        rm_parser.add_argument("path", help="Pfad auf dem Zielsystem")
+
+        # Befehl: stat
+        stat_parser = subparsers.add_parser("stat", help="Informationen zu einer Datei/Ordner")
+        stat_parser.add_argument("path", help="Pfad auf dem Zielsystem")
+
+        args = parser.parse_args()
+
+        if not args.command:
+            parser.print_help()
+            sys.exit(0)
+
+        from core.config import cfg
+        from core.utils import console, console_err
+
+        if args.config:
+            cfg.custom_path = args.config
+
+        if args.debug:
+            cfg.debug = True
+
+        console.print("[bold blue]Buzzer Tool v1.0[/bold blue]", justify="left")
+        
+        settings = cfg.serial_settings
+
+        settings['debug'] = args.debug
+
+        # Überschreibe Einstellungen mit Kommandozeilenparametern, falls vorhanden
+        if args.port:
+            settings['port'] = args.port
+        if args.baud:
+            settings['baudrate'] = args.baud
+        if args.timeout:
+            settings['timeout'] = args.timeout
+
+        # Ausgabe der aktuellen Einstellungen
+        port = settings.get('port')
+        baud = settings.get('baudrate', 'N/A')
+        timeout = settings.get('timeout', 'N/A')
+
+        if not port:
+            console_err.print("[error]Fehler: Kein serieller Port angegeben.[/error]")
+            sys.exit(1)
+
+        if args.debug:
+            console.print(f"  • Port:    [info]{port}[/info]")
+            console.print(f"  • Baud:    [info]{baud}[/info]")
+            console.print(f"  • Timeout: [info]{timeout:1.2f}s[/info]")
+            console.print("-" * 78)
+
+        from core.serial_conn import SerialBus
+        bus = SerialBus(settings)
+
+        try:
+            bus.open()
+            if args.command == "get_file":
+                from core.cmd.get_file import get_file
+                cmd = get_file(bus)
+                result = cmd.get(args.source_path, args.dest_path)
+                cmd.print(result)
+            elif args.command == "flash_info":
+                from core.cmd.flash_info import flash_info
+                cmd = flash_info(bus)
+                result = cmd.get()
+                cmd.print(result)
+            elif args.command == "fw_status":
+                from core.cmd.fw_status import fw_status
+                cmd = fw_status(bus)
+                result = cmd.get()
+                cmd.print(result)
+            elif args.command == "ls":
+                from core.cmd.list_dir import list_dir
+                cmd = list_dir(bus)
+                result = cmd.get(args.path, recursive=args.recursive)
+                cmd.print(result, args.path)
+            elif args.command == "proto":
+                from core.cmd.proto import proto
+                cmd = proto(bus)
+                result = cmd.get()
+                cmd.print(result)
+            elif args.command == "rename":
+                from core.cmd.rename import rename
+                cmd = rename(bus)
+                result = cmd.get(args.source_path, args.dest_path)
+                cmd.print(result)
+            elif args.command == "rm":
+                from core.cmd.rm import rm
+                cmd = rm(bus)
+                result = cmd.get(args.path)
+                cmd.print(result, args.path)
+            elif args.command == "stat":
+                from core.cmd.stat import stat
+                cmd = stat(bus)
+                result = cmd.get(args.path)
+                cmd.print(result, args.path)
+
+        finally:
+            bus.close()
+
+    except FileNotFoundError as e:
+        console_err.print(f"[error]Fehler: {e}[/error]")
+        sys.exit(1)
+    except (TimeoutError, IOError, ValueError) as e:
+        console_err.print(f"[bold red]KOMMUNIKATIONSFEHLER:[/bold red] [error_msg]{e}[/error_msg]")
+        sys.exit(1) # Beendet das Script mit Fehlercode 1 für Tests
+    except Exception as e:
+        # Hier fangen wir auch deinen neuen ControllerError ab
+        from core.serial_conn import ControllerError
+        if isinstance(e, ControllerError):
+             console_err.print(f"[bold red]CONTROLLER FEHLER:[/bold red] [error_msg]{e}[/error_msg]")
+        else:
+             console_err.print(f"[bold red]UNERWARTETER FEHLER:[/bold red] [error_msg]{e}[/error_msg]")
+        
+        if args.debug:
+            import traceback
+            traceback.print_exc()
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

tool/config.yaml

@@ -0,0 +1,4 @@
+serial:
+  port: "/dev/cu.usbmodem83401"
+  baudrate: 115200
+  timeout: 1.0

tool/core/cmd/flash_info.py

@@ -0,0 +1,53 @@
+# tool/core/cmd/flash_info.py
+import struct
+from core.utils import console, console_err
+from core.protocol import COMMANDS, ERRORS
+
+class flash_info:
+    def __init__(self, bus):
+        self.bus = bus
+
+
+    def get(self):
+        import struct
+        self.bus.send_request(COMMANDS['get_flash_info'])
+        
+        data = self.bus.receive_response(length=21)
+        if not data or data.get('type') == 'error':
+            return None
+
+        payload = data['data']
+        ext_block_size = struct.unpack('<I', payload[0:4])[0]
+        ext_total_blocks = struct.unpack('<I', payload[4:8])[0]
+        ext_free_blocks = struct.unpack('<I', payload[8:12])[0]
+        int_slot_size = struct.unpack('<I', payload[12:16])[0]
+        ext_page_size = struct.unpack('<H', payload[16:18])[0]
+        int_page_size = struct.unpack('<H', payload[18:20])[0]
+        max_path_len = payload[20]
+
+        result = {
+            'ext_block_size': ext_block_size,
+            'ext_total_blocks': ext_total_blocks,
+            'ext_free_blocks': ext_free_blocks,
+            'int_slot_size': int_slot_size,
+            'ext_page_size': ext_page_size,
+            'int_page_size': int_page_size,
+            'max_path_len': max_path_len,
+            'ext_total_size': ext_block_size * ext_total_blocks,
+            'ext_free_size': ext_block_size * ext_free_blocks,
+            'ext_used_size': ext_block_size * (ext_total_blocks - ext_free_blocks)
+        }
+        return result
+
+    def print(self, result):
+        if not result:
+            return
+
+        console.print(f"[info]Flash-Informationen:[/info]")
+        console.print(f"  • [info]Externer Flash:[/info] {result['ext_total_size']/1024/1024:.2f} MB ({result['ext_total_blocks']} Blöcke à {result['ext_block_size']} Bytes)")
+        console.print(f"    - Belegt: {result['ext_used_size']/1024/1024:.2f} MB ({result['ext_total_blocks'] - result['ext_free_blocks']} Blöcke)")
+        console.print(f"    - Frei: {result['ext_free_size']/1024/1024:.2f} MB ({result['ext_free_blocks']} Blöcke)")
+        console.print(f"  • [info]FW Flash Slot:[/info] {result['int_slot_size']/1024:.2f} KB")
+        console.print(f"  • [info]EXTFLASH Seitengröße:[/info] {result['ext_page_size']} Bytes")
+        console.print(f"  • [info]INTFLASH Seitengröße:[/info] {result['int_page_size']} Bytes")
+        console.print(f"  • [info]Maximale Pfadlänge:[/info] {result['max_path_len']} Zeichen")

tool/core/cmd/fw_status.py

@@ -0,0 +1,53 @@
+# tool/core/cmd/fw_status.py
+import struct
+from core.utils import console, console_err
+from core.protocol import COMMANDS, ERRORS
+
+class fw_status:
+    def __init__(self, bus):
+        self.bus = bus
+
+
+    def get(self):
+        import struct
+        self.bus.send_request(COMMANDS['get_firmware_status'])
+        
+        data = self.bus.receive_response(length=10)
+        if not data or data.get('type') == 'error':
+            return None
+
+        header = data['data']
+        status = header[0]
+        app_version_raw = struct.unpack('<I', header[1:5])[0]
+        ker_version_raw = struct.unpack('<I', header[5:9])[0]
+        str_len = header[9]
+
+        fw_string_bytes = self.bus.connection.read(str_len)
+        fw_string = fw_string_bytes.decode('utf-8')
+
+        result = {
+            'status': status,
+            'fw_version_raw': hex(app_version_raw),
+            'kernel_version_raw': hex(ker_version_raw),
+            'fw_major': (app_version_raw >> 24) & 0xFF,
+            'fw_minor': (app_version_raw >> 16) & 0xFF,
+            'fw_patch': (app_version_raw >> 8)& 0xFF,
+            'kernel_major': (ker_version_raw >> 16) & 0xFF,
+            'kernel_minor': (ker_version_raw >> 8) & 0xFF,
+            'kernel_patch': ker_version_raw & 0xFF,
+            'fw_string': fw_string,
+            'kernel_string': f"{(ker_version_raw >> 16) & 0xFF}.{(ker_version_raw >> 8) & 0xFF}.{ker_version_raw & 0xFF}"
+        }
+        return result
+
+    def print(self, result):
+        if not result:
+            return
+
+        status = "UNKNOWN"
+        if  result['status'] == 0x00: status = "CONFIRMED"
+        elif result['status'] == 0x01: status = "PENDING"
+        elif result['status'] == 0x02: status = "TESTING"
+        console.print(f"[info]Firmware Status[/info] des Controllers ist [info]{status}[/info]:")
+        console.print(f"  • Firmware: [info]{result['fw_string']}[/info] ({result['fw_major']}.{result['fw_minor']}.{result['fw_patch']})")
+        console.print(f"  • Kernel:   [info]{result['kernel_string']}[/info] ({result['kernel_major']}.{result['kernel_minor']}.{result['kernel_patch']})")

tool/core/cmd/get_file.py

@@ -0,0 +1,76 @@
+# tool/core/cmd/get_file.py
+import struct
+import zlib
+from pathlib import Path
+from core.utils import console, console_err
+from core.protocol import COMMANDS
+
+class get_file:
+    def __init__(self, bus):
+        self.bus = bus
+
+    def get(self, source_path: str, dest_path: str):
+        try:
+            p = Path(dest_path)
+            p.parent.mkdir(parents=True, exist_ok=True)
+            with open(p, 'wb') as f:
+                pass 
+        except Exception as e:
+            console_err.print(f"Fehler: Kann Zieldatei nicht anlegen: {e}")
+            return None
+
+        source_path_bytes = source_path.encode('utf-8')
+        payload = struct.pack('B', len(source_path_bytes)) + source_path_bytes
+        device_file_crc = None
+        try:
+            self.bus.send_request(COMMANDS['crc_32'], payload)
+            crc_resp = self.bus.receive_response(length=4)
+            if crc_resp and crc_resp.get('type') == 'response':
+                device_file_crc = struct.unpack('<I', crc_resp['data'])[0]
+        except Exception:
+            device_file_crc = None
+
+        self.bus.send_request(COMMANDS['get_file'], payload)
+        
+        stream_res = self.bus.receive_stream()  
+        
+        if not stream_res or stream_res.get('type') == 'error':
+            return None
+
+        file_data = stream_res['data']
+        remote_crc = stream_res['crc32']
+
+        if local_crc == remote_crc:
+            with open(p, 'wb') as f:
+                f.write(file_data)
+            success = True
+        else:
+            with open(p, 'wb') as f:
+                f.write(file_data)
+            success = False
+
+        return {
+            'success': success,
+            'source_path': source_path,
+            'dest_path': dest_path,
+            'crc32_remote': remote_crc,
+            'crc32_local': local_crc,
+            'crc32_device_file': device_file_crc,
+            'size': len(file_data)
+        }
+
+    def print(self, result):
+        if not result:
+            return
+
+        if result['success']:
+            console.print(f"✓ Datei [info]{result['source_path']}[/info] erfolgreich heruntergeladen.")
+            console.print(f"  • Größe:      [info]{result['size'] / 1024:.2f} KB[/info]")
+        else:
+            console_err.print(f"❌ CRC-FEHLER: Datei [error]{result['source_path']}[/error] wurde nicht korrekt empfangen!")
+        
+        console.print(f"  • Remote CRC: [info]{result['crc32_remote']:08X}[/info]")
+        console.print(f"  • Local CRC:  [info]{result['crc32_local']:08X}[/info]")
+        if result.get('crc32_device_file') is not None:
+            console.print(f"  • Device CRC: [info]{result['crc32_device_file']:08X}[/info]")
+        console.print(f"  • Zielpfad:   [info]{result['dest_path']}[/info]")

tool/core/cmd/list_dir.py

@@ -0,0 +1,71 @@
+# tool/core/cmd/list_dir.py
+import struct
+from core.utils import console
+from core.protocol import COMMANDS
+
+class list_dir:
+    def __init__(self, bus):
+        self.bus = bus
+
+    def get(self, path: str, recursive: bool = False):
+        # Wir stellen sicher, dass der Pfad nicht leer ist und normalisieren ihn leicht
+        clean_path = path if path == "/" else path.rstrip('/')
+        path_bytes = clean_path.encode('utf-8')
+        
+        payload = struct.pack('B', len(path_bytes)) + path_bytes
+        self.bus.send_request(COMMANDS['list_dir'], payload)
+        
+        chunks = self.bus.receive_list() 
+        if chunks is None:
+            return None
+
+        entries = []
+        for chunk in chunks:
+            if len(chunk) < 6: # Typ(1) + Size(4) + min 1 char Name
+                continue
+                
+            is_dir = chunk[0] == 1
+            size = struct.unpack('<I', chunk[1:5])[0] if not is_dir else None
+            name = chunk[5:].decode('utf-8').rstrip('\x00')
+            
+            entry = {
+                'name': name,
+                'is_dir': is_dir,
+                'size': size
+            }
+
+            if recursive and is_dir:
+                # Rekursiver Aufruf: Pfad sauber zusammenfügen
+                sub_path = f"{clean_path}/{name}"
+                entry['children'] = self.get(sub_path, recursive=True)
+            
+            entries.append(entry)
+
+        return entries
+
+    def print(self, entries, path: str, prefix: str = ""):
+        if prefix == "":
+            console.print(f"Inhalt von [info]{path}[/info]:")
+        
+        if not entries:
+            return
+
+        # Sortierung: Verzeichnisse zuerst
+        entries.sort(key=lambda x: (not x['is_dir'], x['name'].lower()))
+
+        for i, entry in enumerate(entries):
+            # Prüfen, ob es das letzte Element auf dieser Ebene ist
+            is_last = (i == len(entries) - 1)
+            connector = "└" if is_last else "├"
+            
+            icon = "📁" if entry['is_dir'] else "📄"
+            size_str = f" ({entry['size']/1024:.2f} KB)" if entry['size'] is not None else ""
+            
+            # Ausgabe der aktuellen Zeile
+            console.print(f"{prefix}{connector}{icon} [info]{entry['name']}[/info]{size_str}")
+            
+            # Wenn Kinder vorhanden sind, rekursiv weiter
+            if 'children' in entry and entry['children']:
+                # Für die Kinder-Ebene das Prefix anpassen
+                extension = "  " if is_last else "│ "
+                self.print(entry['children'], "", prefix=prefix + extension)

tool/core/cmd/proto.py

@@ -0,0 +1,28 @@
+# tool/core/cmd/proto.py
+import struct
+from core.utils import console, console_err
+from core.protocol import COMMANDS, ERRORS
+
+class proto:
+    def __init__(self, bus):
+        self.bus = bus
+
+    def get(self):
+        self.bus.send_request(COMMANDS['get_protocol_version'], None)
+
+        data = self.bus.receive_response(length=1)  
+        if not data or data.get('type') == 'error':
+            return None
+
+        payload = data['data']
+        result = {
+            'protocol_version': payload[0]
+        }
+        return result
+
+    def print(self, result):
+        if not result:
+            return
+
+        protocol_version = result['protocol_version']
+        console.print(f"[title]Protokoll Version[/info] des Controllers ist [info]{protocol_version}[/info]:")

tool/core/cmd/rename.py

@@ -0,0 +1,37 @@
+# tool/core/cmd/rename.py
+import struct
+from core.utils import console, console_err
+from core.protocol import COMMANDS, ERRORS
+
+class rename:
+    def __init__(self, bus):
+        self.bus = bus
+
+    def get(self, source_path: str, dest_path: str):
+        source_path_bytes = source_path.encode('utf-8')
+        dest_path_bytes = dest_path.encode('utf-8')
+        
+        payload = struct.pack('B', len(source_path_bytes)) + source_path_bytes
+        payload += struct.pack('B', len(dest_path_bytes)) + dest_path_bytes
+        
+        self.bus.send_request(COMMANDS['rename'], payload)
+        
+        data = self.bus.receive_ack()  
+        
+        if not data or data.get('type') == 'error':
+            return None
+
+        return {
+            'success': data.get('type') == 'ack',
+            'source_path': source_path,
+            'dest_path': dest_path
+        }
+
+    def print(self, result):
+        if not result or not result.get('success'):
+            return
+
+        console.print(
+            f"Pfad [info]{result['source_path']}[/info] wurde erfolgreich in "
+            f"[info]{result['dest_path']}[/info] umbenannt."
+        )

tool/core/cmd/rm.py

@@ -0,0 +1,32 @@
+# tool/core/cmd/rm.py
+import struct
+from core.utils import console, console_err
+from core.protocol import COMMANDS, ERRORS
+
+class rm:
+    def __init__(self, bus):
+        self.bus = bus
+
+    def get(self, path: str):
+        path_bytes = path.encode('utf-8')
+        payload = struct.pack('B', len(path_bytes)) + path_bytes
+        self.bus.send_request(COMMANDS['rm'], payload)
+        
+        # 1 Byte Type + 4 Byte Size = 5
+        data = self.bus.receive_ack()  
+        
+        if not data or data.get('type') == 'error':
+            return None
+
+        if data.get('type') == 'ack':
+            return True
+        return False
+
+
+    def print(self, result, path: str):
+        if result is None:
+            console_err.print(f"Fehler: Pfad [error]{path}[/error] konnte nicht entfernt werden.")
+        elif result is False:
+            console_err.print(f"Fehler: Pfad [error]{path}[/error] existiert nicht oder konnte nicht entfernt werden.")
+        else:
+            console.print(f"Pfad [info]{path}[/info] wurde erfolgreich entfernt.")

tool/core/cmd/stat.py

@@ -0,0 +1,36 @@
+# tool/core/cmd/stat.py
+import struct
+from core.utils import console, console_err
+from core.protocol import COMMANDS, ERRORS
+
+class stat:
+    def __init__(self, bus):
+        self.bus = bus
+
+    def get(self, path: str):
+        path_bytes = path.encode('utf-8')
+        payload = struct.pack('B', len(path_bytes)) + path_bytes
+        self.bus.send_request(COMMANDS['stat'], payload)
+        
+        # 1 Byte Type + 4 Byte Size = 5
+        data = self.bus.receive_response(length=5)  
+        
+        if not data or data.get('type') == 'error':
+            return None
+
+        payload = data['data']
+        result = {
+            'is_directory': payload[0] == 1,
+            'size': struct.unpack('<I', payload[1:5])[0]
+        }
+        return result
+
+    def print(self, result, path: str):
+        if not result:
+            return
+
+        t_name = "📁 Verzeichnis" if result['is_directory'] else "📄 Datei"
+        console.print(f"[info_title]Stat[/info_title] für [info]{path}[/info]:")
+        console.print(f"  • Typ:    [info]{t_name}[/info]")
+        if not result['is_directory']:
+            console.print(f"  • Grösse: [info]{result['size']/1024:.2f} KB[/info] ({result['size']} Bytes)")

tool/core/config.py

@@ -0,0 +1,48 @@
+# tool/core/config.py
+import os
+import yaml
+from pathlib import Path
+
+class Config:
+    def __init__(self):
+        self._config = None
+        self.config_name = "config.yaml"
+        self.custom_path = None  # Speicher für den Parameter-Pfad
+        self.debug = False
+
+    def _load(self):
+        if self._config is not None:
+            return
+        
+        from core.utils import console
+
+        search_paths = []
+        if self.custom_path:
+            search_paths.append(Path(self.custom_path))
+        
+        search_paths.append(Path(os.getcwd()) / self.config_name)
+        search_paths.append(Path(__file__).parent.parent / self.config_name)
+
+        config_path = None
+        for p in search_paths:
+            if p.exists():
+                config_path = p
+                break
+
+        if not config_path:
+            raise FileNotFoundError(f"Konfiguration konnte an keinem Ort gefunden werden.")
+
+        if not config_path.exists():
+            raise FileNotFoundError(f"Konfiguration nicht gefunden: {self.config_name}")
+        else:
+            if self.debug: console.print(f"[bold green]✓[/bold green] Konfiguration geladen: [info]{config_path}[/info]")
+
+        with open(config_path, 'r') as f:
+            self._config = yaml.safe_load(f)
+
+    @property
+    def serial_settings(self):
+        self._load()
+        return self._config.get('serial', {})
+
+cfg = Config()

tool/core/protocol.py

@@ -0,0 +1,88 @@
+# tool/core/protocol.py
+VERSION = {
+    "min_protocol_version": 1,
+    "max_protocol_version": 1,
+    "current_protocol_version": None
+}
+
+SYNC_SEQ = b'BUZZ'
+
+ERRORS = {
+    0x00: "NONE",
+    0x01: "INVALID_COMMAND",
+    0x02: "INVALID_PARAMETERS",
+    0x03: "MISSING_PARAMETERS",
+
+    0x10: "FILE_NOT_FOUND",
+    0x11: "ALREADY_EXISTS",
+    0x12: "NOT_A_DIRECTORY",
+    0x13: "IS_A_DIRECTORY",
+    0x14: "ACCESS_DENIED",
+    0x15: "NO_SPACE",
+    0x16: "FILE_TOO_LARGE",
+
+    0x20: "IO_ERROR",
+    0x21: "TIMEOUT",
+    0x22: "CRC_MISMATCH",
+    0x23: "TRANSFER_ABORTED",
+
+    0x30: "NOT_SUPPORTED",
+    0x31: "BUSY",
+    0x32: "INTERNAL_ERROR",
+
+    0x40: "NOT_IMPLEMENTED",
+}
+
+FRAME_TYPE_REQUEST = 0x01
+FRAME_TYPE_ACK = 0x10
+FRAME_TYPE_RESPONSE = 0x11
+FRAME_TYPE_STREAM_START = 0x12
+FRAME_TYPE_STREAM_CHUNK = 0x13
+FRAME_TYPE_STREAM_END = 0x14
+FRAME_TYPE_LIST_START = 0x15
+FRAME_TYPE_LIST_CHUNK = 0x16
+FRAME_TYPE_LIST_END = 0x17
+FRAME_TYPE_ERROR = 0xFF
+
+FRAME_TYPES = {
+    'request': FRAME_TYPE_REQUEST,
+    'ack': FRAME_TYPE_ACK,
+    'response': FRAME_TYPE_RESPONSE,
+    'error': FRAME_TYPE_ERROR,
+    'stream_start': FRAME_TYPE_STREAM_START,
+    'stream_chunk': FRAME_TYPE_STREAM_CHUNK,
+    'stream_end': FRAME_TYPE_STREAM_END,
+    'list_start': FRAME_TYPE_LIST_START,
+    'list_chunk': FRAME_TYPE_LIST_CHUNK,
+    'list_end': FRAME_TYPE_LIST_END
+}
+
+CMD_GET_PROTOCOL_VERSION = 0x00
+CMD_GET_FIRMWARE_STATUS = 0x01
+CMD_GET_FLASH_INFO = 0x02
+
+CMD_LIST_DIR = 0x10
+CMD_CRC_32 = 0x11
+CMD_MKDIR = 0x12
+CMD_RM = 0x13
+CMD_STAT = 0x18
+CMD_RENAME = 0x19
+
+CMD_PUT_FILE = 0x20
+CMD_PUT_FW = 0x21
+CMD_GET_FILE = 0x22
+
+COMMANDS = {
+    'get_protocol_version': CMD_GET_PROTOCOL_VERSION,
+    'get_firmware_status': CMD_GET_FIRMWARE_STATUS,
+    'get_flash_info': CMD_GET_FLASH_INFO,
+    'list_dir': CMD_LIST_DIR,
+    'stat': CMD_STAT,
+    'rm': CMD_RM,
+    'rename': CMD_RENAME,
+    'mkdir': CMD_MKDIR,
+    'crc_32': CMD_CRC_32,
+    'put_file': CMD_PUT_FILE,
+    'get_file': CMD_GET_FILE,
+    'put_fw': CMD_PUT_FW,
+}

tool/core/serial_conn.py

@@ -0,0 +1,279 @@
+# tool/core/serial_conn.py
+import struct
+import serial
+import time
+from core.utils import console, console_err
+from core.protocol import SYNC_SEQ, ERRORS, FRAME_TYPES, VERSION
+
+class SerialBus:
+    def __init__(self, settings: dict):
+        """
+        Initialisiert den Bus mit den (ggf. übersteuerten) Settings.
+        """
+        self.port = settings.get('port')
+        self.baudrate = settings.get('baudrate', 115200)
+        self.timeout = settings.get('timeout', 1.0)
+        self.debug = settings.get('debug', False)
+        self.connection = None
+
+    def open(self):
+        """Öffnet die serielle Schnittstelle."""
+        try:
+            self.connection = serial.Serial(
+                port=self.port,
+                baudrate=self.baudrate,
+                timeout=self.timeout
+            )
+            self.flush_input()
+            if self.debug: console.print(f"[bold green]✓[/bold green] Port [info]{self.port}[/info] erfolgreich geöffnet.")
+            from core.cmd.proto import proto
+            cmd = proto(self)
+            data = cmd.get()
+            VERSION["current_protocol_version"] = data['protocol_version'] if data else None
+            if data:
+                if self.debug: console.print(f"  • Protokoll Version: [info]{data['protocol_version']}[/info]")
+                if data['protocol_version'] < VERSION["min_protocol_version"] or data['protocol_version'] > VERSION["max_protocol_version"]:
+                    if VERSION["min_protocol_version"] == VERSION["max_protocol_version"]:
+                        expected = f"Version {VERSION['min_protocol_version']}"
+                    else:
+                        expected = f"Version {VERSION['min_protocol_version']} bis {VERSION['max_protocol_version']}"
+                    raise ValueError(f"Inkompatibles Protokoll. Controller spricht {data['protocol_version']}, erwartet wird {expected}.")
+            else:
+                raise ValueError("Keine gültige Antwort auf Protokollversion erhalten.")
+        except serial.SerialException as e:
+            console_err.print(f"[bold red]Serieller Fehler:[/bold red] [error_msg]{e}[/error_msg]")
+            raise
+        except Exception as e:
+            console_err.print(f"[bold red]Unerwarteter Fehler beim Öffnen:[/bold red] [error_msg]{e}[/error_msg]")
+            raise
+
+    def flush_input(self):
+        """Leert den Empfangspuffer der seriellen Schnittstelle."""
+        if self.connection and self.connection.is_open:
+            self.connection.reset_input_buffer()
+
+    def close(self):
+        """Schließt die Verbindung sauber."""
+        if self.connection and self.connection.is_open:
+            self.connection.close()
+            if self.debug: console.print(f"Verbindung zu [info]{self.port}[/info] geschlossen.")
+
+    def send_binary(self, data: bytes):
+        """Sendet Rohdaten und loggt sie im Hex-Format."""
+        if not self.connection or not self.connection.is_open:
+            raise ConnectionError("Port ist nicht geöffnet.")
+        
+        self.connection.write(data)
+        
+        if self.debug:
+            hex_data = data.hex(' ').upper()
+            console.print(f"TX -> [grey62]{hex_data}[/grey62]")
+
+    def _read_exact(self, length: int, context: str = "Daten") -> bytes:
+        data = bytearray()
+        while len(data) < length:
+            try:
+                chunk = self.connection.read(length - len(data))
+            except serial.SerialException as e:
+                raise IOError(f"Serielle Verbindung verloren beim Lesen von {context}: {e}") from e
+            if not chunk:
+                raise TimeoutError(f"Timeout beim Lesen von {context}: {len(data)}/{length} Bytes.")
+            data.extend(chunk)
+        return bytes(data)
+
+    def wait_for_sync(self, sync_seq: bytes, max_time: float = 2.0):
+        """Wartet maximal max_time Sekunden auf die Sync-Sequenz."""
+        buffer = b""
+        start_time = time.time()
+        
+        if self.debug: 
+            console.print(f"[bold cyan]Warte auf SYNC-Sequenz:[/bold cyan] [grey62]{sync_seq.hex(' ').upper()}[/grey62]")
+
+        # Kurzer interner Timeout für reaktive Schleife
+        original_timeout = self.connection.timeout
+        self.connection.timeout = 0.1 
+
+        try:
+            while (time.time() - start_time) < max_time:
+                char = self.connection.read(1)
+                if not char:
+                    continue
+                
+                buffer += char
+                if len(buffer) > len(sync_seq):
+                    buffer = buffer[1:]
+                    
+                if buffer == sync_seq:
+                    if self.debug: console.print("[bold cyan]RX <- SYNC OK[/bold cyan]")
+                    return True
+            return False
+        finally:
+            self.connection.timeout = original_timeout
+
+    def send_request(self, cmd_id: int, payload: bytes = b''):
+        self.flush_input()
+        frame_type = struct.pack('B', FRAME_TYPES['request'])
+        cmd_byte = struct.pack('B', cmd_id)
+        
+        full_frame = SYNC_SEQ + frame_type + cmd_byte
+        if payload:
+            full_frame += payload
+        self.send_binary(full_frame)
+
+    def receive_ack(self, timeout: float = None):
+        wait_time = timeout if timeout is not None else self.timeout
+
+        if not self.wait_for_sync(SYNC_SEQ, max_time=wait_time):
+            raise TimeoutError(f"SYNC-Sequenz nicht innerhalb von {wait_time}s gefunden.")
+
+        ftype_raw = self.connection.read(1)
+        if not ftype_raw: 
+            raise TimeoutError("Timeout beim Lesen des Frame-Typs.")
+        ftype = ftype_raw[0]
+
+        if ftype == FRAME_TYPES['error']: 
+            err_code_raw = self.connection.read(1)
+            err_code = err_code_raw[0] if err_code_raw else 0xFF
+            err_name = ERRORS.get(err_code, "UNKNOWN")
+            raise ControllerError(err_code, err_name)
+
+        elif ftype == FRAME_TYPES['ack']: 
+            if self.debug: 
+                console.print(f"[green]ACK empfangen[/green]")
+            return {"type": "ack"}
+        raise ValueError(f"Unerwarteter Frame-Typ (0x{FRAME_TYPES['ack']:02X} (ACK) erwartet): 0x{ftype:02X}")
+
+    def receive_response(self, length: int, timeout: float = None, varlen_params: int = 0):
+        wait_time = timeout if timeout is not None else self.timeout
+
+        if not self.wait_for_sync(SYNC_SEQ, max_time=wait_time):
+            raise TimeoutError(f"SYNC-Sequenz nicht innerhalb von {wait_time}s gefunden.")
+
+        ftype_raw = self.connection.read(1)
+        if not ftype_raw: 
+            raise TimeoutError("Timeout beim Lesen des Frame-Typs.")
+        ftype = ftype_raw[0]
+
+        if ftype == FRAME_TYPES['error']: 
+            err_code_raw = self.connection.read(1)
+            err_code = err_code_raw[0] if err_code_raw else 0xFF
+            err_name = ERRORS.get(err_code, "UNKNOWN")
+            raise ControllerError(err_code, err_name)
+
+        elif ftype == FRAME_TYPES['response']: 
+            data = self.connection.read(length)
+            for varlen_param in range(varlen_params):
+                length_byte = self.connection.read(1)
+                if not length_byte:
+                    raise TimeoutError("Timeout beim Lesen der Länge eines variablen Parameters.")
+                param_length = length_byte[0]
+                param_data = self.connection.read(param_length)
+                if not param_data:
+                    raise TimeoutError("Timeout beim Lesen eines variablen Parameters.")    
+                data += length_byte + param_data
+            if self.debug: 
+                console.print(f"RX <- [grey62]{data.hex(' ').upper()}[/grey62]")
+            if len(data) < length:
+                raise IOError(f"Unvollständiges Paket: {len(data)}/{length} Bytes.")
+            return {"type": "response", "data": data}
+        
+        raise ValueError(f"Unerwarteter Frame-Typ: 0x{ftype:02X}")
+
+    def receive_list(self):
+        """Liest eine Liste von Einträgen, bis list_end kommt."""
+        is_list = False
+        list_items = []
+        
+        while True:
+            if not self.wait_for_sync(SYNC_SEQ):
+                raise TimeoutError("Timeout beim Warten auf Sync im List-Modus.")
+
+            ftype = self.connection.read(1)[0]
+
+            if ftype == FRAME_TYPES['list_start']:
+                is_list = True
+                list_items = []
+            elif ftype == FRAME_TYPES['list_chunk']:
+                if not is_list: raise ValueError("Chunk ohne Start.")
+                length = struct.unpack('<H', self.connection.read(2))[0]
+                if self.debug: console.print(f"Erwarte List-Chunk mit Länge: {length} Bytes")
+                data = self.connection.read(length)
+                if self.debug: console.print(f"Rohdaten List-Chunk: [grey62]{data.hex(' ').upper()}[/grey62]")  # Debug-Ausgabe des rohen Chunks
+                list_items.append(data)
+            elif ftype == FRAME_TYPES['list_end']:
+                if not is_list: raise ValueError("Ende ohne Start.")
+                num_entries = struct.unpack('<H', self.connection.read(2))[0]
+                if len(list_items) != num_entries:
+                    console_err.print(f"[warning]Warnung: Erwartete {num_entries} Items, bekam {len(list_items)}[/warning]")
+                return list_items
+            elif ftype == FRAME_TYPES['error']:
+                err_code_raw = self.connection.read(1)
+                err_code = err_code_raw[0] if err_code_raw else 0xFF
+                err_name = ERRORS.get(err_code, "UNKNOWN")
+                raise ControllerError(err_code, err_name)
+
+    def receive_stream(self, chunk_size: int = 1024):
+        """Liest einen Datenstrom in Chunks, bis ein Fehler oder Ende-Signal kommt."""
+        is_stream = False
+        data_chunks = []
+        
+        while True:
+            if not self.wait_for_sync(SYNC_SEQ):
+                raise TimeoutError("Timeout beim Warten auf Sync im Stream-Modus.")
+
+            ftype = self._read_exact(1, "Frame-Typ")[0]
+            if self.debug: console.print(f"Empfangener Frame-Typ: 0x{ftype:02X} (start: 0x{FRAME_TYPES['stream_start']:02X}, chunk: 0x{FRAME_TYPES['stream_chunk']:02X}, end: 0x{FRAME_TYPES['stream_end']:02X})")
+
+            if ftype == FRAME_TYPES['stream_start']:
+                is_stream = True
+                data_chunks = []
+                size = struct.unpack('<I', self._read_exact(4, "Stream-Größe"))[0]
+                if self.debug: console.print(f"Stream gestartet, erwartete Gesamtgröße: {size} Bytes")
+
+                received_size = 0
+                while received_size < size:
+                    chunk_length = min(chunk_size, size - received_size)
+                    try:
+                        chunk_data = self._read_exact(chunk_length, f"Daten-Chunk @ {received_size}/{size}")
+                    except Exception as e:
+                        raise IOError(f"Stream-Abbruch bei {received_size}/{size} Bytes: {e}") from e
+                    data_chunks.append(chunk_data)
+                    received_size += len(chunk_data)
+                    if self.debug: console.print(f"Empfangen: {received_size}/{size} Bytes ({(received_size/size)*100:.2f}%)")
+                if self.debug: console.print("Stream vollständig empfangen.")
+
+            elif ftype == FRAME_TYPES['stream_end']:
+                if not is_stream: raise ValueError("Ende ohne Start.")
+                crc32 = struct.unpack('<I', self._read_exact(4, "CRC32"))[0]
+                if self.debug: console.print(f"Stream-Ende empfangen, CRC32: 0x{crc32:08X}")
+                
+                return {'data': b''.join(data_chunks), 'crc32': crc32}
+
+            # elif ftype == FRAME_TYPES['list_chunk']:
+            #     if not is_list: raise ValueError("Chunk ohne Start.")
+            #     length = struct.unpack('<H', self.connection.read(2))[0]
+            #     if self.debug: console.print(f"Erwarte List-Chunk mit Länge: {length} Bytes")
+            #     data = self.connection.read(length)
+            #     if self.debug: console.print(f"Rohdaten List-Chunk: [grey62]{data.hex(' ').upper()}[/grey62]")  # Debug-Ausgabe des rohen Chunks
+            #     list_items.append(data)
+            # elif ftype == FRAME_TYPES['list_end']:
+            #     if not is_list: raise ValueError("Ende ohne Start.")
+            #     num_entries = struct.unpack('<H', self.connection.read(2))[0]
+            #     if len(list_items) != num_entries:
+            #         console_err.print(f"[warning]Warnung: Erwartete {num_entries} Items, bekam {len(list_items)}[/warning]")
+            #     return list_items
+            elif ftype == FRAME_TYPES['error']:
+                err_code_raw = self.connection.read(1)
+                err_code = err_code_raw[0] if err_code_raw else 0xFF
+                err_name = ERRORS.get(err_code, "UNKNOWN")
+                raise ControllerError(err_code, err_name)
+            
+            else:
+                raise ValueError(f"Unerwarteter Frame-Typ: 0x{ftype:02X}")
+                
+class ControllerError(Exception):
+    """Wird ausgelöst, wenn der Controller einen Error-Frame (0xFF) sendet."""
+    def __init__(self, code, name):
+        self.code = code
+        self.name = name
+        super().__init__(f"Controller Error 0x{code:02X} ({name})")

tool/core/utils.py

@@ -0,0 +1,14 @@
+from rich.console import Console
+from rich.theme import Theme
+
+custom_theme = Theme({
+    "info": "bold blue",
+    "warning": "yellow",
+    "error": "bold red",
+    "error_msg": "red",
+    "sync": "bold magenta",
+    "wait": "italic grey50"
+})
+
+console = Console(theme=custom_theme, highlight=False)
+console_err = Console(theme=custom_theme, stderr=True, highlight=False)

tool/requirements.txt

@@ -0,0 +1,3 @@
+PyYAML
+pyserial
+rich