Improved GoTool

- refactored some magic numbers

goTool/api/frontend.go

@@ -0,0 +1,55 @@
+package api
+
+const (
+	TopicFrontendCmd = "front:cmd"
+)
+
+const (
+	CmdUpdateValue = "update_value"
+	CmdInitState   = "init_state"
+	CmdConnect     = "connect"
+	CmdDisconnect  = "disconnect"
+	CmdSendMessage = "send"
+	CmdRX          = "uart_rx"
+	CmdTX          = "uart_tx"
+)
+
+var MessageReceiveRegistry = map[string]func() any{
+	CmdConnect:     func() any { return &WsUartConnect{} },
+	CmdDisconnect:  func() any { return &WsUartDisconnect{} },
+	CmdSendMessage: func() any { return &WsUartSendMessage{} },
+}
+
+type WsMessage struct {
+	Cmd     string `json:"cmd"`
+	Payload []byte `json:"payload,omitempty"`
+}
+
+type SystemState struct {
+	Adapters         []string `json:"adapters"`
+	SelectedAdapter  string   `json:"selected_adapter"`
+	Baudrates        string   `json:"baudrates"`
+	SelectedBaudrate string   `json:"selected_baudrate"`
+	UartConnected    bool     `json:"uart_connected"`
+}
+
+type WsUartConnect struct {
+	SelectedAdapter string `json:"selected_adapter"`
+	Baudrate        int    `json:"baudrate"`
+}
+
+type WsUartDisconnect struct {
+}
+
+type WsUartSendMessage struct {
+	MsgId byte   `json:"msg_id"`
+	Data  []byte `json:"data"`
+}
+
+type WsUartRX struct {
+	Data []byte `json:"data"`
+}
+
+type WsUartTX struct {
+	Data []byte `json:"data"`
+}

goTool/api/uart.go

@@ -0,0 +1,110 @@
+package api
+
+// Topics
+const (
+	TopicUARTRx     = "uart:rx"
+	TopicUARTTx     = "uart:tx"
+	TopicUARTError  = "uart:error"
+	TopicUartAction = "uart:action"
+
+	TopicOTA = "ota"
+)
+
+type Frame struct {
+	Time uint64
+	ID   byte
+	Data []byte
+}
+
+const (
+	CmdEcho        byte = 0x01
+	CmdVersion     byte = 0x02
+	CmdClientInfo  byte = 0x03
+	CmdClientInput byte = 0x04
+
+	CmdOtaStart       byte = 0x10
+	CmdOtaPayload     byte = 0x11
+	CmdOtaEnd         byte = 0x12
+	CmdOtaStatus      byte = 0x13
+	CmdOtaStartEspNow byte = 0x14
+)
+
+const (
+	ClientCountOffset = 1
+
+	// Payload Sizes
+	PayloadVersionSize     = 10
+	PayloadClientInfoSize  = 19
+	PayloadClientInputSize = 13
+)
+
+type PayloadVersion struct {
+	Version   uint16
+	Buildhash [7]uint8
+}
+
+type PayloadClientInfo struct {
+	ClientID           uint8
+	IsAvailable        uint8
+	SlotIsUsed         uint8
+	MACAddr            [6]uint8
+	LastPing           uint32
+	LastSuccessfulPing uint32
+	Version            uint16
+}
+
+type PayloadClientInput struct {
+	ClientID  byte
+	X         float32
+	Y         float32
+	InputMask uint32
+}
+
+type PayloadOtaStatus struct {
+	SequenzCounter uint16
+	WriteIndex     uint16
+	Data           []byte
+}
+
+type PayloadOtaStart struct {
+	Data     []byte
+	Parition byte
+	Error    byte
+}
+
+type PayloadOtaEnd struct {
+	Data []byte
+}
+
+type PayloadOtaPayload struct {
+	SequenzCounter uint16
+	WriteIndex     uint16
+	Data           []byte
+	Error          byte
+}
+
+type PayloadOtaStartEspNow struct {
+	Data []byte
+}
+
+type ActionUartConnect struct {
+	Adapter  string
+	Baudrate int
+}
+
+type ActionUartConnected struct {
+	Adapter  string
+	Baudrate int
+	Error    error
+}
+
+type ActionUartDisconnect struct {
+}
+
+type ActionUartDisconnected struct {
+}
+
+type ActionUartSendMessage struct {
+	MsgId byte
+	Data  []byte
+}

goTool/config.go

@@ -0,0 +1,8 @@
+package main
+
+type Config struct {
+	Port     int
+	Host     string
+	UartPort string
+	Baudrate int
+}

goTool/eventbus/bus.go

@@ -0,0 +1,64 @@
+package eventbus
+
+import (
+	"log"
+	"sync"
+)
+
+type EventBus interface {
+	Subscribe(topic string) chan any
+	Publish(topic string, data any)
+	Unsubscribe(topic string, ch chan any)
+}
+
+type EBus struct {
+	mu     sync.RWMutex
+	topics map[string][]chan any
+}
+
+func New() *EBus {
+	return &EBus{
+		mu:     sync.RWMutex{},
+		topics: map[string][]chan any{},
+	}
+}
+
+func (eb *EBus) Subscribe(topic string) chan any {
+	eb.mu.Lock()
+	defer eb.mu.Unlock()
+
+	ch := make(chan any, 20)
+	eb.topics[topic] = append(eb.topics[topic], ch)
+	return ch
+}
+
+func (eb *EBus) Publish(topic string, data any) {
+	eb.mu.RLock()
+	defer eb.mu.RUnlock()
+	for _, ch := range eb.topics[topic] {
+		select {
+		case ch <- data:
+		default:
+			log.Printf("[Event Bus]: Could not pass Message %v to %v channel full", data, topic)
+		}
+	}
+}
+
+func (eb *EBus) Unsubscribe(topic string, c chan any) {
+	eb.mu.Lock()
+	defer eb.mu.Unlock()
+
+	channels, ok := eb.topics[topic]
+	if !ok {
+		return
+	}
+
+	for i, ch := range channels {
+		if ch != c {
+			eb.topics[topic] = append(channels[:i], channels[i+1:]...) // example: 5 channels max i=3 channels[:3] (0,1,2) + channels[3+1:] (4,5)
+
+			close(ch)
+			return
+		}
+	}
+}

goTool/frontend/server.go

@@ -0,0 +1,175 @@
+package frontend
+
+import (
+	"context"
+	"embed"
+	"encoding/json"
+	"io/fs"
+	"log"
+	"net/http"
+	"time"
+
+	"alox.tool/api"
+	"alox.tool/eventbus"
+	"github.com/gorilla/websocket"
+)
+
+//go:embed www
+var staticFiles embed.FS
+
+var upgrader = websocket.Upgrader{}
+
+type FServer struct {
+	bus eventbus.EventBus
+	mux *http.ServeMux
+}
+
+func New(bus eventbus.EventBus) *FServer {
+	fsrv := &FServer{
+		bus: bus,
+		mux: http.NewServeMux(),
+	}
+	fsrv.routes()
+	return fsrv
+}
+
+func (fsrv *FServer) routes() {
+	// Static files from the Embed-FS
+	// remove "www" prefix, so index.html is reachable over /
+	root, _ := fs.Sub(staticFiles, "www")
+	fsrv.mux.Handle("/", http.FileServer(http.FS(root)))
+
+	fsrv.mux.HandleFunc("/ws", fsrv.handleWS)
+}
+
+func (fs *FServer) handleWS(w http.ResponseWriter, r *http.Request) {
+	conn, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		log.Printf("Upgrade error: %v", err)
+		return
+	}
+	defer conn.Close()
+
+	// Context nutzen, um Goroutinen zu stoppen, wenn die Verbindung abreißt
+	ctx, cancel := context.WithCancel(r.Context())
+	defer cancel()
+
+	// WRITER: Send Events to Browser
+	go fs.HandleAppEvents(ctx, conn)
+
+	// READER: Commands from Browser
+	// This Function is Blocking
+	fs.GetFrontendEvents(ctx, conn)
+}
+
+func (fs *FServer) Start(addr string) error {
+	server := &http.Server{
+		Addr:         addr,
+		Handler:      fs.mux,
+		ReadTimeout:  5 * time.Second,
+		WriteTimeout: 10 * time.Second,
+	}
+
+	ctx, cancle := context.WithCancel(context.Background())
+	defer cancle()
+
+	go fs.HandleFrontendEvents(ctx)
+
+	log.Printf("Frontend Server gestartet auf %s", addr)
+	return server.ListenAndServe()
+}
+
+func (fs *FServer) HandleAppEvents(ctx context.Context, conn *websocket.Conn) error {
+	// Kanäle für die Hardware-Events abonnieren
+	rxChan := fs.bus.Subscribe(api.TopicUARTRx)
+	txChan := fs.bus.Subscribe(api.TopicUARTTx)
+	UartActions := fs.bus.Subscribe(api.TopicUartAction)
+
+	for {
+		select {
+		case <-ctx.Done():
+			return nil
+		case f := <-rxChan:
+			if err := conn.WriteJSON(map[string]any{"type": "rx", "frame": f}); err != nil {
+				return nil
+			}
+		case f := <-txChan:
+			if err := conn.WriteJSON(map[string]any{"type": "tx", "frame": f}); err != nil {
+				return nil
+			}
+		case msgT := <-UartActions:
+			switch msg := msgT.(type) {
+			case api.ActionUartConnected:
+				// TODO: nicht hier die daten nachhaltig speichern damit sie ans frontend gesendet werden können
+				// TODO: das muss irgendwo central passieren nicht für jeden client
+				if msg.Error != nil {
+				}
+				continue
+			case api.ActionUartDisconnected:
+				continue
+			}
+		}
+	}
+}
+
+func (fs *FServer) GetFrontendEvents(ctx context.Context, conn *websocket.Conn) error {
+	for {
+		select {
+		case <-ctx.Done():
+			return nil
+		default:
+			var cmd api.WsMessage
+			if err := conn.ReadJSON(&cmd); err != nil {
+				log.Printf("WS Read Error: %v", err)
+				return err
+			}
+
+			val, ok := api.MessageReceiveRegistry[cmd.Cmd]
+			if !ok {
+				log.Printf("No Message Type mapped to %v", cmd.Cmd)
+				continue
+			}
+			valM := val()
+
+			err := json.Unmarshal(cmd.Payload, valM)
+			if err != nil {
+				log.Printf("Could not Unmarshal payload %v", cmd.Payload)
+			}
+
+			fs.bus.Publish(api.TopicFrontendCmd, valM)
+			log.Printf("Browser Action: %s auf with %v", cmd.Cmd, cmd.Payload)
+		}
+	}
+}
+
+func (fs *FServer) HandleFrontendEvents(ctx context.Context) error {
+	fChan := fs.bus.Subscribe(api.TopicFrontendCmd)
+
+	for {
+		select {
+		case <-ctx.Done():
+			return nil
+		case msg := <-fChan:
+			switch msgT := msg.(type) {
+			case api.WsUartSendMessage:
+				log.Printf("Sending Uart Data % X", msgT.Data)
+				fs.bus.Publish(api.TopicUartAction, api.ActionUartSendMessage{
+					MsgId: msgT.MsgId,
+					Data:  msgT.Data,
+				})
+				continue
+			case api.WsUartConnect:
+				log.Printf("Connect with %s : %d", msgT.SelectedAdapter, msgT.Baudrate)
+				fs.bus.Publish(api.TopicUartAction, api.ActionUartConnect{
+					Adapter:  msgT.SelectedAdapter,
+					Baudrate: msgT.Baudrate,
+				})
+				continue
+			case api.WsUartDisconnect:
+				log.Printf("Disconnect from Uart Adapter")
+				fs.bus.Publish(api.TopicUartAction, api.ActionUartDisconnect{})
+				continue
+			}
+		}
+	}
+}

goTool/frontend/www/component.tmpl

@@ -0,0 +1,32 @@
+<div x-data="windowBox('window_id' ,100, 100)"
+     @mousemove.window="onDrag" 
+     @mouseup.window="stopDrag"
+     @mousedown="focus"
+     class="card shadow-lg position-absolute"
+     :class="{ 'w-100 h-100 m-0 shadow-none': fullscreen }"
+     :style="`left: ${pos.x}px; top: ${pos.y}px; z-index: ${zIndex}; width: ${fullscreen ? '100vw' : '400px'};`"
+     x-cloak>
+
+    <div class="card-header bg-dark text-white d-flex justify-content-between align-items-center drag-handle"
+         @mousedown="startDrag" @dblclick="toggleFullscreen">
+        <h6 class="mb-0">CAN Interface</h6>
+        
+        <div class="d-flex align-items-center gap-1">
+            <span class="badge me-1" :class="socket.readyState === 1 ? 'bg-success' : 'bg-danger'">WS</span>
+            
+            <button class="btn btn-sm btn-outline-light py-0 px-2" @click="toggleFullscreen">
+                <span>▢</span>
+            </button>
+            
+            <button class="btn btn-sm btn-outline-light py-0 px-2" @click="minimized = !minimized">
+                <span x-text="minimized ? '+' : '−'"></span>
+            </button>
+        </div>
+    </div>
+
+    <div x-show="!minimized" class="flex-grow-1 overflow-auto">
+        <div class="card-body">
+		<p>HIER DER INHALT DER COMPONENT</p>
+        </div>
+    </div>
+</div>

goTool/frontend/www/index.html

@@ -0,0 +1,241 @@
+<!doctype html>
+<html>
+  <head>
+    <link href="bootstrap.min.css" rel="stylesheet" />
+    <script src="bootstrap.bundle.min.js"></script>
+    <script defer src="windows.js"></script>
+    <script defer src="alpinejs.min.js"></script>
+
+    <style>
+      [x-cloak] {
+        display: none !important;
+      }
+
+      body {
+        background-color: #f8f9fa;
+        background-image:
+          linear-gradient(90deg, rgba(0, 0, 0, 0.03) 1px, transparent 1px),
+          linear-gradient(rgba(0, 0, 0, 0.03) 1px, transparent 1px);
+        background-size: 20px 20px;
+        height: 100vh;
+        margin: 0;
+        padding-top: 56px; /* Space for navbar */
+        overflow: hidden;
+      }
+
+      .drag-handle {
+        cursor: move;
+      }
+      .card[style*="cursor: move"] {
+        transition: none;
+      }
+
+      .navbar {
+        z-index: 2000; /* Above windows */
+      }
+
+      .ws-indicator {
+        width: 12px;
+        height: 12px;
+        border: 1px solid rgba(255, 255, 255, 0.3);
+        transition: all 0.3s ease;
+      }
+      .glow-success {
+        box-shadow: 0 0 10px #198754;
+      }
+      .glow-danger {
+        box-shadow: 0 0 10px #dc3545;
+      }
+    </style>
+
+    <script>
+      document.addEventListener("alpine:init", () => {
+        Alpine.store("sys", {
+          ws_connected: false,
+          adapters: ["/dev/ttyUSB0"],
+          selected_adapter: "",
+          baudrates: ["115200", "916000"],
+          selected_baudrate: "",
+          uart_connected: false,
+        });
+      });
+    </script>
+
+    <script>
+      let socket;
+
+      function connectWS() {
+        socket = new WebSocket("ws://" + window.location.host + "/ws");
+
+        socket.onopen = () => {
+          console.log("[open] Connection established");
+          Alpine.store("sys").ws_connected = true;
+        };
+
+        socket.onmessage = (event) => {
+          try {
+            let mes = JSON.parse(event.data);
+            if (mes && mes.cmd === "value") {
+              Alpine.store(mes.name, mes.value);
+            }
+          } catch (e) {
+            console.log("Invalid JSON:", event.data);
+          }
+        };
+
+        socket.onclose = () => {
+          console.log("[close] Connection died");
+          Alpine.store("sys").ws_connected = false;
+          setTimeout(connectWS, 2000);
+        };
+
+        socket.onerror = (error) => {
+          console.log("[error]");
+          socket.close();
+        };
+      }
+
+      connectWS();
+    </script>
+  </head>
+
+  <body x-data>
+    <!-- Top Navbar -->
+    <nav class="navbar navbar-expand-lg navbar-dark bg-dark fixed-top shadow">
+      <div class="container-fluid">
+        <a class="navbar-brand fw-bold" href="#">
+          <span class="text-primary">Alox</span> Debug Tool
+        </a>
+
+        <div class="d-flex align-items-center gap-2">
+          <span class="text-light small opacity-75">Websocket:</span>
+          <div
+            class="rounded-circle ws-indicator"
+            :class="$store.sys.ws_connected ? 'bg-success glow-success' : 'bg-danger glow-danger'"
+          ></div>
+        </div>
+      </div>
+    </nav>
+
+    <!-- UART Configuration Window -->
+    <yet-window
+      id="uart_config"
+      title="UART Configuration"
+      x="50"
+      y="80"
+      width="400px"
+    >
+      <label class="form-label small fw-bold text-uppercase text-muted"
+        >Interface</label
+      >
+      <div
+        class="input-group mb-3"
+        x-data="{ open: false }"
+        @click.outside="open = false"
+      >
+        <button
+          class="btn btn-outline-secondary dropdown-toggle"
+          type="button"
+          @click="open = !open"
+          :disabled="$store.sys.uart_connected"
+        >
+          Adapter
+        </button>
+        <ul class="dropdown-menu" :class="{ 'show': open }" x-show="open">
+          <template x-for="adapter in $store.sys.adapters">
+            <li>
+              <button
+                class="dropdown-item"
+                type="button"
+                x-text="adapter"
+                @click="$store.sys.selected_adapter = adapter; open = false"
+              ></button>
+            </li>
+          </template>
+        </ul>
+        <input
+          type="text"
+          class="form-control bg-light"
+          readonly
+          :value="$store.sys.selected_adapter || 'Select Interface...'"
+        />
+      </div>
+
+      <label class="form-label small fw-bold text-uppercase text-muted"
+        >Baudrate</label
+      >
+      <div
+        class="input-group mb-4"
+        x-data="{ open: false }"
+        @click.outside="open = false"
+      >
+        <button
+          class="btn btn-outline-secondary dropdown-toggle"
+          type="button"
+          @click="open = !open"
+          :disabled="$store.sys.uart_connected"
+        >
+          Speed
+        </button>
+        <ul class="dropdown-menu" :class="{ 'show': open }" x-show="open">
+          <template x-for="rate in $store.sys.baudrates">
+            <li>
+              <button
+                class="dropdown-item"
+                type="button"
+                x-text="rate"
+                @click="$store.sys.selected_baudrate = rate; open = false"
+              ></button>
+            </li>
+          </template>
+        </ul>
+        <input
+          type="text"
+          class="form-control bg-light"
+          readonly
+          :value="$store.sys.selected_baudrate || 'Select Baudrate...'"
+        />
+      </div>
+
+      <div class="d-grid">
+        <button
+          x-show="!$store.sys.uart_connected"
+          class="btn btn-primary btn-lg"
+          type="button"
+          :disabled="!$store.sys.selected_adapter || !$store.sys.selected_baudrate"
+          @click="socket.send(JSON.stringify({cmd: 'connect', adapter: $store.sys.selected_adapter, baudrate: parseInt($store.sys.selected_baudrate)}))"
+        >
+          Connect to UART
+        </button>
+        <button
+          x-show="$store.sys.uart_connected"
+          x-cloak
+          class="btn btn-danger btn-lg"
+          type="button"
+          @click="socket.send(JSON.stringify({cmd: 'disconnect'}))"
+        >
+          Disconnect
+        </button>
+      </div>
+    </yet-window>
+
+    <!-- UART Log Window -->
+    <yet-window
+      id="uart_log"
+      title="UART Log"
+      x="500"
+      y="80"
+      width="550px"
+      header-class="bg-primary text-white"
+    >
+      <div
+        class="bg-dark text-success font-monospace small p-2 rounded shadow-inner"
+        style="height: 400px; overflow-y: auto"
+      >
+        <div class="text-muted small mt-2">
+          // UART log data will appear here...
+        </div>
+      </div>
+    </yet-window>
+  </body>
+</html>

goTool/frontend/www/windows.js

@@ -0,0 +1,153 @@
+// windows.js
+
+document.addEventListener("alpine:init", () => {
+  // 1. Globaler Store for Window Managment
+  Alpine.store("Yet_WM", {
+    topZ: 1000,
+    getNewZ() {
+      return ++this.topZ;
+    },
+  });
+
+  Alpine.data("YetWindow", (id, initialX = 50, initialY = 50) => ({
+    id: id,
+    pos: { x: parseInt(initialX), y: parseInt(initialY) },
+    lastPos: { x: 0, y: 0 },
+    dragging: false,
+    minimized: false,
+    fullscreen: false,
+    zIndex: 1000,
+    offset: { x: 0, y: 0 },
+
+    init() {
+      // Lade gespeicherten Zustand (einheitlicher Key: yet_win_)
+      const saved = JSON.parse(localStorage.getItem(`yet_win_${this.id}`));
+      if (saved) {
+        this.pos = { x: saved.x, y: saved.y };
+        this.minimized = saved.min;
+      }
+      this.focus();
+      this.keepInBounds();
+    },
+
+    focus() {
+      this.zIndex = Alpine.store("Yet_WM").getNewZ();
+    },
+
+    startDrag(e) {
+      if (e.target.closest("button") || this.fullscreen) return;
+      
+      // Verhindert Text-Markierung während des Verschiebens
+      e.preventDefault();
+      
+      this.focus();
+      this.dragging = true;
+      this.offset.x = e.clientX - this.pos.x;
+      this.offset.y = e.clientY - this.pos.y;
+    },
+
+    onDrag(e) {
+      if (!this.dragging) return;
+      let newX = e.clientX - this.offset.x;
+      let newY = e.clientY - this.offset.y;
+
+      const margin = 20;
+      this.pos.x = Math.max(margin - 350, Math.min(newX, window.innerWidth - 50));
+      this.pos.y = Math.max(0, Math.min(newY, window.innerHeight - 40));
+    },
+
+    stopDrag() {
+      if (this.dragging) {
+        this.dragging = false;
+        this.save();
+      }
+    },
+
+    toggleMinimize() {
+      this.minimized = !this.minimized;
+      this.save();
+    },
+
+    toggleFullscreen() {
+      if (!this.fullscreen) {
+        this.lastPos = { ...this.pos };
+        this.pos = { x: 0, y: 0 };
+        this.fullscreen = true;
+      } else {
+        this.pos = { ...this.lastPos };
+        this.fullscreen = false;
+      }
+      this.focus();
+    },
+
+    save() {
+      localStorage.setItem(
+        `yet_win_${this.id}`,
+        JSON.stringify({
+          x: this.pos.x,
+          y: this.pos.y,
+          min: this.minimized,
+        })
+      );
+    },
+
+    keepInBounds() {
+      if (this.pos.x > window.innerWidth) this.pos.x = 50;
+      if (this.pos.y > window.innerHeight) this.pos.y = 50;
+    },
+  }));
+});
+
+// Definition der Web Component
+class YetWindowElement extends HTMLElement {
+  connectedCallback() {
+    const id = this.getAttribute("id") || "win_" + Math.random().toString(36).substr(2, 9);
+    const title = this.getAttribute("title") || "Window";
+    const x = this.getAttribute("x") || "50";
+    const y = this.getAttribute("y") || "50";
+    const width = this.getAttribute("width") || "450px";
+    const headerClass = this.getAttribute("header-class") || "bg-dark text-white";
+
+    const content = this.innerHTML;
+
+    this.innerHTML = `
+      <div
+        x-data="YetWindow('${id}', ${x}, ${y})"
+        @mousemove.window="onDrag"
+        @mouseup.window="stopDrag"
+        @mousedown="focus"
+        class="card shadow-lg position-absolute"
+        :class="{ 'w-100 h-100 m-0 shadow-none': fullscreen }"
+        :style="\`left: \${pos.x}px; top: \${pos.y}px; z-index: \${zIndex}; width: \${fullscreen ? '100vw' : '${width}'}; user-select: \${dragging ? 'none' : 'auto'};\`"
+        x-cloak
+      >
+        <div
+          class="card-header d-flex justify-content-between align-items-center drag-handle ${headerClass}"
+          @mousedown="startDrag"
+          @dblclick="toggleFullscreen"
+          style="user-select: none;"
+        >
+          <h6 class="mb-0">${title}</h6>
+
+          <div class="d-flex align-items-center gap-1">
+            <button class="btn btn-sm btn-outline-light py-0 px-2" @click="toggleFullscreen">
+              <span>▢</span>
+            </button>
+
+            <button class="btn btn-sm btn-outline-light py-0 px-2" @click="toggleMinimize">
+              <span x-text="minimized ? '+' : '−'"></span>
+            </button>
+          </div>
+        </div>
+
+        <div x-show="!minimized" class="flex-grow-1 overflow-auto">
+          <div class="card-body">
+            ${content}
+          </div>
+        </div>
+      </div>
+    `;
+  }
+}
+
+customElements.define("yet-window", YetWindowElement);

goTool/go.mod

@@ -3,6 +3,7 @@ module alox.tool
 go 1.24.5
 
 require (
+	github.com/gorilla/websocket v1.5.3
 	github.com/pterm/pterm v0.12.81
 	go.bug.st/serial v1.6.4
 )

goTool/go.sum

@@ -28,6 +28,8 @@ github.com/gookit/color v1.4.2/go.mod h1:fqRyamkC1W8uxl+lxCQxOT09l/vYfZ+QeiX3rKQ
 github.com/gookit/color v1.5.0/go.mod h1:43aQb+Zerm/BWh2GnrgOQm7ffz7tvQXEKV6BFMl7wAo=
 github.com/gookit/color v1.5.4 h1:FZmqs7XOyGgCAxmWyPslpiok1k05wmY3SJTytgvYFs0=
 github.com/gookit/color v1.5.4/go.mod h1:pZJOeOS8DM43rXbp4AZo1n9zCU2qjpcRko0b6/QJi9w=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/klauspost/cpuid/v2 v2.0.10/go.mod h1:g2LTdtYhdyuGPqyWyv7qRAmj1WBqxuObKfj5c0PQa7c=
 github.com/klauspost/cpuid/v2 v2.0.12/go.mod h1:g2LTdtYhdyuGPqyWyv7qRAmj1WBqxuObKfj5c0PQa7c=

goTool/main.go

@@ -2,554 +2,127 @@ package main
 
 import (
 	"context"
-	"encoding/binary"
 	"flag"
 	"fmt"
 	"log"
-	"math"
 	"os"
-	"strconv"
 	"time"
 
-	"github.com/pterm/pterm"
+	"alox.tool/api"
-	"go.bug.st/serial"
+	"alox.tool/eventbus"
+	"alox.tool/frontend"
+	"alox.tool/state"
+	"alox.tool/testrunner"
+	"alox.tool/uart"
 )
 
-type ParserState int
-
-const (
-	// MISC
-	UART_ECHO         = 0x01
-	UART_VERSION      = 0x02
-	UART_CLIENT_INFO  = 0x03
-	UART_CLIENT_INPUT = 0x04
-
-	// OTA
-	UART_OTA_START        = 0x10
-	UART_OTA_PAYLOAD      = 0x11
-	UART_OTA_END          = 0x12
-	UART_OTA_STATUS       = 0x13
-	UART_OTA_START_ESPNOW = 0x14
-)
-
-const (
-	WAITING_FOR_START_BYTE ParserState = iota
-	ESCAPED_MESSAGE_ID
-	GET_MESSAGE_ID
-	IN_PAYLOD
-	ESCAPED_PAYLOAD_BYTE
-)
-
-const (
-	START_BYTE  = 0xAA
-	ESCAPE_BYTE = 0xBB
-	END_BYTE    = 0xCC
-)
-
-type ParseError int
-
-const (
-	WRONG_CHECKSUM ParseError = iota
-	UNEXPECETD_BYTE
-)
-
-type MessageReceive struct {
-	raw_message     []byte
-	parsed_message  []byte
-	checksum        byte
-	error           ParseError
-	state           ParserState
-	write_index     int
-	raw_write_index int
-}
-
-type OTASyncManager struct {
-	OTA_MessageCounter         int
-	OTA_PayloadMessageSequence int
-	NewOTAMessage              chan MessageReceive
-	TimeoutMessage             time.Duration
-}
-
-func (ot *OTASyncManager) WaitForNextMessageTimeout() (*MessageReceive, error) {
-	select {
-	case msg := <-ot.NewOTAMessage:
-		return &msg, nil
-	case <-time.After(ot.TimeoutMessage):
-		return nil, fmt.Errorf("Message Timeout")
-	}
-}
-
-func initMessageReceive(mr *MessageReceive) {
-	mr.raw_message = make([]byte, 1024*4)
-	mr.parsed_message = make([]byte, 1024*4)
-	mr.checksum = 0
-	mr.error = 0
-	mr.write_index = 0
-	mr.raw_write_index = 0
-	mr.state = WAITING_FOR_START_BYTE
-}
-
-func addByteToRawBuffer(mr *MessageReceive, pbyte byte) {
-	mr.raw_message[mr.raw_write_index] = pbyte
-	mr.raw_write_index += 1
-}
-func addByteToParsedBuffer(mr *MessageReceive, pbyte byte) {
-	mr.parsed_message[mr.write_index] = pbyte
-	mr.write_index += 1
-	mr.checksum ^= pbyte
-}
-
-func parse_uart_ota_payload_payload(payloadBuffer []byte, payload_len int) {
-	//fmt.Printf("RAW BUFFER: % 02X", payloadBuffer[:payload_len])
-	if payload_len != 4 {
-		fmt.Printf("Payload should be 4 is %v", payload_len)
-		return
-	}
-
-	fmt.Printf("Sequence %v, WriteIndex %v", binary.LittleEndian.Uint16(payloadBuffer[0:1]), binary.LittleEndian.Uint16(payloadBuffer[2:3]))
-}
-
-func parse_uart_version_payload(payloadBuffer []byte, payload_len int) {
-	type payload_data struct {
-		Version   uint16
-		BuildHash [7]uint8
-	}
-
-	tableHeaders := pterm.TableData{
-		{"Version", "Buildhash"},
-	}
-
-	tableData := tableHeaders
-
-	tableData = append(tableData, []string{
-		fmt.Sprintf("%d", binary.LittleEndian.Uint16(payloadBuffer[1:3])),
-		fmt.Sprintf("%s", payloadBuffer[3:10]),
-	})
-
-	err := pterm.DefaultTable.WithHasHeader().WithBoxed().WithData(tableData).Render()
-	if err != nil {
-		fmt.Printf("Fehler beim Rendern der Tabelle: %s\n", err)
-	}
-
-}
-
-func parse_uart_client_info_payload(payloadBuffer []byte, payload_len int) {
-
-	type payload_data struct {
-		ClientID           uint8
-		IsAvailable        uint8
-		SlotIsUsed         uint8
-		MACAddr            [6]uint8
-		LastPing           uint32
-		LastSuccessfulPing uint32
-		Version            uint16
-	}
-
-	tableHeaders := pterm.TableData{
-		{"Client ID", "Verfügbar", "Genutzt", "MAC-Adresse", "Last Ping", "Letzter Erfolg Ping", "Version"},
-	}
-
-	tableData := tableHeaders
-
-	currentOffset := 2
-
-	const (
-		ENTRY_LEN                = 19
-		OFFSET_MAC_ADDR          = 3
-		OFFSET_LAST_PING         = 9
-		OFFSET_LAST_SUCCESS_PING = 13
-		OFFSET_VERSION           = 17
-	)
-
-	for i := 0; i < int(payloadBuffer[1]); i++ {
-		if currentOffset+ENTRY_LEN > payload_len {
-			fmt.Printf("Fehler: Payload zu kurz für Client-Eintrag %d\n", i)
-			break
-		}
-
-		entryBytes := payloadBuffer[currentOffset : currentOffset+ENTRY_LEN]
-
-		var clientData payload_data
-
-		clientData.ClientID = entryBytes[0]
-		clientData.IsAvailable = entryBytes[1]
-		clientData.SlotIsUsed = entryBytes[2]
-
-		copy(clientData.MACAddr[:], entryBytes[OFFSET_MAC_ADDR:OFFSET_MAC_ADDR+6])
-
-		clientData.LastPing = binary.LittleEndian.Uint32(entryBytes[OFFSET_LAST_PING : OFFSET_LAST_PING+4])
-		clientData.LastSuccessfulPing = binary.LittleEndian.Uint32(entryBytes[OFFSET_LAST_SUCCESS_PING : OFFSET_LAST_SUCCESS_PING+4])
-		clientData.Version = binary.LittleEndian.Uint16(entryBytes[OFFSET_VERSION : OFFSET_VERSION+2])
-
-		// Füge die geparsten Daten als String-Slice zur Tabelle hinzu
-		tableData = append(tableData, []string{
-			fmt.Sprintf("%d", clientData.ClientID),
-			fmt.Sprintf("%d", clientData.IsAvailable),
-			fmt.Sprintf("%d", clientData.SlotIsUsed),
-			fmt.Sprintf("%X:%X:%X:%X:%X:%X",
-				clientData.MACAddr[0], clientData.MACAddr[1], clientData.MACAddr[2],
-				clientData.MACAddr[3], clientData.MACAddr[4], clientData.MACAddr[5]),
-			fmt.Sprintf("%d", clientData.LastPing),
-			fmt.Sprintf("%d", clientData.LastSuccessfulPing),
-			fmt.Sprintf("%d", clientData.Version),
-		})
-
-		currentOffset += ENTRY_LEN
-	}
-	err := pterm.DefaultTable.WithHasHeader().WithBoxed().WithData(tableData).Render()
-	if err != nil {
-		fmt.Printf("Fehler beim Rendern der Tabelle: %s\n", err)
-	}
-}
-
-func parse_uart_client_input(payloadBuffer []byte, payload_len int) {
-
-	clientCount := payloadBuffer[1]
-	fmt.Printf("Client Count %d\n", clientCount)
-	clientInputLen := 13
-
-	for i := 0; i < int(clientCount); i++ {
-		offset := 2 + (i * clientInputLen)
-
-		// --- Client ID (uint8) ---
-		clientID := payloadBuffer[offset]
-		offset += 1
-
-		fmt.Printf("Client: %d\n", clientID)
-
-		// --- Lage X (float32) ---
-		xBits := binary.LittleEndian.Uint32(payloadBuffer[offset : offset+4])
-		lageX := math.Float32frombits(xBits)
-		offset += 4
-
-		fmt.Printf("\tLAGE_X: %f\n", lageX)
-
-		// --- Lage Y (float32) ---
-		yBits := binary.LittleEndian.Uint32(payloadBuffer[offset : offset+4])
-		lageY := math.Float32frombits(yBits)
-		offset += 4
-
-		fmt.Printf("\tLAGE_Y: %f\n", lageY)
-
-		// --- Bitmask (int32) ---
-		maskBits := binary.LittleEndian.Uint32(payloadBuffer[offset : offset+4])
-		bitmask := uint32(maskBits)
-		offset += 4
-
-		fmt.Printf("\tBITMASK: %032b\n", bitmask)
-	}
-}
-
-func message_receive_callback(mr MessageReceive) {
-	log.Printf("Message Received: % 02X\n", mr.raw_message[:mr.raw_write_index])
-	switch mr.parsed_message[0] {
-	case byte(UART_ECHO):
-	case UART_VERSION:
-		parse_uart_version_payload(mr.parsed_message, mr.write_index)
-	case UART_CLIENT_INFO:
-		parse_uart_client_info_payload(mr.parsed_message, mr.write_index)
-	case UART_OTA_START:
-		OTA_UpdateHandler.NewOTAMessage <- mr
-	case UART_OTA_PAYLOAD:
-		parse_uart_ota_payload_payload(mr.parsed_message, mr.write_index)
-		OTA_UpdateHandler.NewOTAMessage <- mr
-	case UART_OTA_END:
-		OTA_UpdateHandler.NewOTAMessage <- mr
-	case UART_OTA_STATUS:
-		OTA_UpdateHandler.NewOTAMessage <- mr
-	case UART_CLIENT_INPUT:
-		parse_uart_client_input(mr.parsed_message, mr.write_index)
-	}
-}
-
-func message_receive_failed_callback(mr MessageReceive) {
-	log.Printf("Error Message Received: % 02X\n", mr.raw_message[:mr.raw_write_index])
-}
-
-func parseByte(mr *MessageReceive, pbyte byte) {
-	addByteToRawBuffer(mr, pbyte)
-	switch mr.state {
-	case WAITING_FOR_START_BYTE:
-		if pbyte == START_BYTE {
-			initMessageReceive(mr)
-			mr.state = GET_MESSAGE_ID
-			addByteToRawBuffer(mr, pbyte)
-		}
-		// ignore every other byte
-	case GET_MESSAGE_ID:
-		if pbyte == ESCAPE_BYTE {
-			mr.state = ESCAPED_MESSAGE_ID
-		} else {
-			addByteToParsedBuffer(mr, pbyte)
-			mr.state = IN_PAYLOD
-		}
-	case ESCAPED_MESSAGE_ID:
-		addByteToParsedBuffer(mr, pbyte)
-		mr.state = IN_PAYLOD
-	case IN_PAYLOD:
-		if pbyte == ESCAPE_BYTE {
-			mr.state = ESCAPED_PAYLOAD_BYTE
-			break
-		}
-		if pbyte == START_BYTE {
-			mr.error = UNEXPECETD_BYTE
-			go message_receive_failed_callback(*mr)
-			initMessageReceive(mr)
-			return
-		}
-		if pbyte == END_BYTE {
-			if mr.checksum != 0 { // checksum wrong
-				mr.error = WRONG_CHECKSUM
-				go message_receive_failed_callback(*mr)
-				initMessageReceive(mr)
-				return
-			}
-			go message_receive_callback(*mr)
-			initMessageReceive(mr)
-			break
-		}
-		// normal case
-		addByteToParsedBuffer(mr, pbyte)
-	case ESCAPED_PAYLOAD_BYTE:
-		addByteToParsedBuffer(mr, pbyte)
-		mr.state = IN_PAYLOD
-	default:
-		panic(fmt.Sprintf("unexpected main.ParserState: %#v", mr.state))
-	}
-}
-
-func buildMessage(payloadBuffer []byte, payload_len int, sendBuffer []byte) int {
-	var writeIndex int
-	checksum := byte(0x00)
-	writeIndex = 0
-	sendBuffer[writeIndex] = START_BYTE
-	writeIndex++
-	for i := range payload_len {
-		b := payloadBuffer[i]
-		if b == START_BYTE || b == ESCAPE_BYTE || b == END_BYTE {
-			sendBuffer[writeIndex] = ESCAPE_BYTE
-			writeIndex++
-		}
-		sendBuffer[writeIndex] = b
-		writeIndex++
-		checksum ^= b
-	}
-	if checksum == START_BYTE || checksum == ESCAPE_BYTE || checksum == END_BYTE {
-		sendBuffer[writeIndex] = ESCAPE_BYTE
-		writeIndex++
-	}
-	sendBuffer[writeIndex] = checksum
-	writeIndex++
-	sendBuffer[writeIndex] = END_BYTE
-	writeIndex++
-	return writeIndex
-}
-
-func sendMessage(port serial.Port, sendBuffer []byte) {
-	n, err := port.Write(sendBuffer)
-	if err != nil {
-		log.Printf("Could not Send %v to Serial Port", sendBuffer)
-	}
-	if n < len(sendBuffer) {
-		log.Printf("Did not send all data %v, only send %v", len(sendBuffer), n)
-	}
-	fmt.Printf("Send Message % 02X\n", sendBuffer[:n])
-}
-
 var (
-	updatePath        string
+	Tests    bool
-	OTA_UpdateHandler OTASyncManager
+	Baudrate uint
 )
 
 func main() {
-	flag.StringVar(&updatePath, "update", "", "Path to Updatefile")
+	flag.BoolVar(&Tests, "t", false, "Tests")
+	flag.UintVar(&Baudrate, "b", 921600, "Baudrate") // 115200
+
 	flag.Parse()
 
-	OTA_UpdateHandler = OTASyncManager{
+	log.Printf("Starting with Params %v", Baudrate)
-		OTA_MessageCounter:         0,
-		OTA_PayloadMessageSequence: 0,
-		NewOTAMessage:              make(chan MessageReceive),
-		TimeoutMessage:             time.Millisecond * 30000,
-	}
 
-	mode := &serial.Mode{
+	config := Config{
-		//BaudRate: 115200,
+		Port:     8000,
-		BaudRate: 921600,
+		Host:     "0.0.0.0",
+		UartPort: "/dev/ttyUSB0",
+		Baudrate: int(Baudrate),
 	}
-	port, err := serial.Open("/dev/ttyUSB0", mode)
+	if Tests {
+		StartTests(config)
+		return
+	}
+	StartApp(config)
+}
+
+func StartTests(config Config) {
+	bus := eventbus.New()
+	com, err := uart.NewCom(bus)
 	if err != nil {
-		log.Fatal(err)
+		log.Printf("Could not Create COM %v", err)
 	}
+	err = com.Connect(config.UartPort, config.Baudrate)
+	if err != nil {
+		log.Printf("Could not Connect with Uart Device %v", err)
+	}
+	defer com.Close()
+
+	tr := testrunner.New(bus, com)
+
+	testTest := make(map[string]func() error)
+	testTest["Echo Test"] = tr.RunEchoTest
+	testTest["Version Test"] = tr.RunVersionTest
+	testTest["Info Test"] = tr.RunClientInfoTest
+	testTest["Input Test"] = tr.RunClientInputTest
+	testTest["Rebuild Network"] = tr.RebuildNetwork
+
+	tr.RunTestSet(testTest)
+}
+
+func StartApp(config Config) {
+	bus := eventbus.New()
+	com, err := uart.NewCom(bus)
 
 	ctx, cancle := context.WithCancel(context.Background())
 	defer cancle()
 
-	go func() {
+	go com.EventbusHandler(ctx)
-		buff := make([]byte, 1024)
-		mr := MessageReceive{}
-		initMessageReceive(&mr)
-		for {
-			select {
-			case <-ctx.Done():
-				return
-			default:
-				n, err := port.Read(buff)
-				if err != nil {
-					log.Print(err)
-					break
-				}
-				if n == 0 {
-					fmt.Println("\nEOF")
-					break
-				}
-				for _, b := range buff[:n] {
-					parseByte(&mr, b)
-				}
-				//fmt.Printf("Empfangen: % 02X\n", string(buff[:n]))
-				break
-			}
-		}
-	}()
 
-	if updatePath != "" {
+	if err != nil {
-		// start update
+		log.Printf("Could not Create Com with Uart Device %v", err)
-		update, err := os.ReadFile(updatePath)
+		return
+	}
+	err = com.Connect(config.UartPort, config.Baudrate)
+	if err != nil {
+		log.Printf("Could not Connect with Uart Device %v", err)
+	}
+	defer com.Close()
+
+	update, err := os.ReadFile("../espAlox.bin")
 	if err != nil {
 		log.Printf("Could not read Update file %v", err)
 		return
 	}
-		log.Printf("Update Buffer read, update size %v", len(update))
+	updateSlices := SliceUpdate(update, 200)
-		log.Printf("Gonna break it down in 200 Bytes packages will send %v packages", len(update)/200)
 
-		// start
+	oManager := NewOTAManager(bus, com, updateSlices)
-		payload_buffer := make([]byte, 1024)
-		send_buffer := make([]byte, 1024)
-		payload_buffer[0] = UART_OTA_START
-		n := buildMessage(payload_buffer, 1, send_buffer)
-		sendMessage(port, send_buffer[:n])
-		msg, err := OTA_UpdateHandler.WaitForNextMessageTimeout()
-		if err != nil {
-			log.Printf("Error Message not acked %v", err)
-		} else {
-			if msg.parsed_message[2] != 0x00 {
-				log.Printf("Update Start failed %v", msg.parsed_message[2])
-				return
-			} else {
-				log.Printf("Update Start confirmed Updating Partition %v", msg.parsed_message[1])
-			}
-		}
 
-		update_write_index := 0
+	espHandle := state.New()
-		// write update parts
+	espHandle.Start(ctx, bus)
-		for update_write_index < len(update) {
+	oManager.StartUpdateHandler(ctx)
-			payload_buffer = make([]byte, 1024)
-			send_buffer = make([]byte, 1024)
-			payload_buffer[0] = UART_OTA_PAYLOAD
 
-			write_len := min(200, len(update)-update_write_index)
+	time.Sleep(time.Millisecond * 5)
 
-			//end_payload_len := min(update_write_index+200, len(update))
+	//tr := testrunner.New(bus, com)
+	//tr.RunVersionTest()
 
-			copy(payload_buffer[1:write_len+1], update[update_write_index:update_write_index+write_len])
+	time.Sleep(time.Millisecond * 5)
-			n = buildMessage(payload_buffer, write_len+1, send_buffer)
-			sendMessage(port, send_buffer[:n])
-			msg, err := OTA_UpdateHandler.WaitForNextMessageTimeout()
-			if err != nil {
-				log.Printf("Error Message not acked %v", err)
-				return
-			} else {
-				seqCounter := binary.LittleEndian.Uint16(msg.parsed_message[1:3])
-				buff_write_index := binary.LittleEndian.Uint16(msg.parsed_message[3:5])
-				log.Printf("Sequenzce Counter: %d, Update buffer Write Index: %d", seqCounter, buff_write_index)
-			}
-			update_write_index += 200
-		}
 
-		log.Printf("Update übertragen beende hier!!!")
+	//com.Send(api.CmdEcho, make([]byte, 0))
-		// end
+	//com.Send(api.CmdVersion, make([]byte, 0))
-		payload_buffer = make([]byte, 1024)
+	com.Send(api.CmdClientInfo, make([]byte, 0))
-		send_buffer = make([]byte, 1024)
+	//com.Send(api.CmdClientInput, make([]byte, 0))
-		payload_buffer[0] = UART_OTA_END
-		n = buildMessage(payload_buffer, 1, send_buffer)
-		sendMessage(port, send_buffer[:n])
 
-		_, err = OTA_UpdateHandler.WaitForNextMessageTimeout()
+	//com.Send(api.CmdOtaStart, make([]byte, 0))
-		if err != nil {
+	//com.Send(api.CmdOtaStartEspNow, make([]byte, 0))
-			log.Printf("Error Message not acked %v", err)
-			return
-		} else {
-			log.Printf("Message Waiting hat funktionioert")
-		}
-		return
-	}
 
-	for {
+	url := fmt.Sprintf("%s:%d", config.Host, config.Port)
-		var input string
+	fserver := frontend.New(bus)
-		var input2 string
+	fserver.Start(url)
-		_, err := fmt.Scanln(&input, &input2)
+}
-		if err != nil {
-			log.Fatalf("Could not read from stdin %v", err)
-			return
-		}
-		fmt.Printf("Input %v", input)
 
-		switch input {
+func SliceUpdate(update []byte, maxlen int) [][]byte {
-		case "q":
+	updateSlices := [][]byte{}
-			return
+	for i := 0; i < len(update); i += 200 {
-		case "1":
+		end := min(i+200, len(update))
-			payload_buffer := make([]byte, 1024)
+		updateSlices = append(updateSlices, update[i:end])
-			send_buffer := make([]byte, 1024)
-			payload_buffer[0] = UART_ECHO
-			n := buildMessage(payload_buffer, 1, send_buffer)
-			sendMessage(port, send_buffer[:n])
-		case "2":
-			payload_buffer := make([]byte, 1024)
-			send_buffer := make([]byte, 1024)
-			payload_buffer[0] = UART_VERSION
-			n := buildMessage(payload_buffer, 1, send_buffer)
-			sendMessage(port, send_buffer[:n])
-		case "3":
-			payload_buffer := make([]byte, 1024)
-			send_buffer := make([]byte, 1024)
-			payload_buffer[0] = UART_CLIENT_INFO
-			n := buildMessage(payload_buffer, 1, send_buffer)
-			sendMessage(port, send_buffer[:n])
-		case "4": // start update
-			payload_buffer := make([]byte, 1024)
-			send_buffer := make([]byte, 1024)
-			payload_buffer[0] = UART_OTA_START
-			n := buildMessage(payload_buffer, 1, send_buffer)
-			sendMessage(port, send_buffer[:n])
-		case "5": // send payload
-			payload_buffer := make([]byte, 1024)
-			send_buffer := make([]byte, 1024)
-			payload_buffer[0] = UART_OTA_PAYLOAD
-			for i := range 200 {
-				payload_buffer[i+1] = byte(i)
-			}
-			n := buildMessage(payload_buffer, 201, send_buffer)
-			sendMessage(port, send_buffer[:n])
-		case "6": // end update
-		case "7": // Start OTA for ESP-NOW clients
-			payload_buffer := make([]byte, 1024)
-			send_buffer := make([]byte, 1024)
-			payload_buffer[0] = UART_OTA_START_ESPNOW
-			n := buildMessage(payload_buffer, 1, send_buffer)
-			sendMessage(port, send_buffer[:n])
-		case "8": // Get Fake Client Input
-			payload_buffer := make([]byte, 1024)
-			send_buffer := make([]byte, 1024)
-			payload_buffer[0] = UART_CLIENT_INPUT
-			seed, err := strconv.Atoi(input2)
-			if err != nil {
-				log.Printf("Could not parse %v to a number", input2)
-				return
-			}
-			payload_buffer[1] = byte(seed)
-			n := buildMessage(payload_buffer, 2, send_buffer)
-			sendMessage(port, send_buffer[:n])
-		default:
-			fmt.Printf("Not a valid input")
-		}
 	}
+	return updateSlices
 }

goTool/ota.go

@@ -0,0 +1,136 @@
+package main
+
+import (
+	"context"
+	"log"
+	"time"
+
+	"alox.tool/api"
+	"alox.tool/eventbus"
+	"alox.tool/uart"
+)
+
+type OTAManager struct {
+	Bus          eventbus.EventBus
+	Com          *uart.Com
+	Update       [][]byte
+	CurrentSlice uint16
+	Partition    byte
+	StartTime    time.Time
+	EndTime      time.Time
+}
+
+func NewOTAManager(bus eventbus.EventBus, com *uart.Com, update [][]byte) OTAManager {
+	return OTAManager{
+		Bus:          bus,
+		Com:          com,
+		Update:       update,
+		CurrentSlice: 0,
+	}
+}
+
+func (om *OTAManager) StartUpdateHandler(ctx context.Context) {
+	RXC := om.Bus.Subscribe(api.TopicUARTRx)
+	defer om.Bus.Unsubscribe(api.TopicUARTRx, RXC)
+
+	go func() {
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case msg := <-RXC:
+				val, ok := msg.(api.Frame)
+				if !ok {
+					log.Printf("val is not type api.Frame its %T", val)
+					continue
+				}
+				log.Printf("[%d] Frame: %X, % X", val.Time, val.ID, val.Data)
+				om.processFrame(val)
+			}
+		}
+	}()
+}
+
+func (om *OTAManager) processFrame(val api.Frame) {
+	switch val.ID {
+	case api.CmdOtaStart:
+		msgT, err := uart.ParseFrameOtaStart(val)
+		if err != nil {
+			log.Printf("Could not Parse Client Input %v", err)
+			return
+		}
+
+		// Send First Payload
+		om.StartTime = time.Now()
+		om.Partition = msgT.Parition
+		err = om.Com.Send(api.CmdOtaPayload, om.Update[om.CurrentSlice])
+		if err != nil {
+			log.Printf("Error Sending Update Step!: %v", err)
+			return
+		}
+		om.CurrentSlice = om.CurrentSlice + 1
+		log.Printf("First Update Step %d", om.CurrentSlice)
+		log.Printf("%v", msgT)
+	case api.CmdOtaPayload:
+		msgT, err := uart.ParseFrameOtaPayload(val)
+		if err != nil {
+			log.Printf("Could not Parse Client Input %v", err)
+			return
+		}
+		// Send Next Payload until there is no more then send end package
+
+		log.Printf("msgT %v", msgT)
+
+		if msgT.Error != 0x00 {
+			log.Printf("Error in Sending Update! Check ESP Log")
+			return
+		}
+
+		log.Printf("NEXT PAYLOAD")
+		if om.CurrentSlice == uint16(len(om.Update)) {
+			log.Printf("LAST PAYLOAD SEND ENDING")
+			om.Com.Send(api.CmdOtaEnd, make([]byte, 1))
+			return
+		}
+		err = om.Com.Send(api.CmdOtaPayload, om.Update[om.CurrentSlice])
+		if err != nil {
+			log.Printf("Error Sending Update Step!: %v", err)
+			return
+		}
+		om.CurrentSlice = om.CurrentSlice + 1
+		log.Printf("UPDATE CURRENT SLICE %d/%d", om.CurrentSlice, len(om.Update))
+		log.Printf("UPDATE Part/WriteIndex %d/%d", msgT.SequenzCounter, msgT.WriteIndex)
+		log.Printf("Progress: %05.2f%%", (float32(om.CurrentSlice)/float32(len(om.Update)))*100)
+
+	case api.CmdOtaStatus:
+		v, err := uart.ParseFrameOtaStatus(val)
+		if err != nil {
+			log.Printf("Could not Parse Client Input %v", err)
+			return
+		}
+		log.Printf("%v", v)
+		// Update State Machine
+
+	case api.CmdOtaEnd:
+		msgT, err := uart.ParseFrameOtaEnd(val)
+		if err != nil {
+			log.Printf("Could not Parse Client Input %v", err)
+			return
+		}
+
+		// End bestätigung
+		om.EndTime = time.Now()
+		duration := om.EndTime.Sub(om.StartTime)
+		log.Printf("Partition %d Update done in %f.2s!", om.Partition, duration.Seconds())
+		log.Printf("%v", msgT)
+
+	case api.CmdOtaStartEspNow:
+		v, err := uart.ParseFrameOtaStartEspNow(val)
+		if err != nil {
+			log.Printf("Could not Parse Client Input %v", err)
+			return
+		}
+		//bus.Publish(api.TopicOTA, v)
+		log.Printf("%v", v)
+	}
+}

goTool/state/state.go

@@ -0,0 +1,186 @@
+package state
+
+import (
+	"context"
+	"log"
+	"sync"
+
+	"alox.tool/api"
+	"alox.tool/eventbus"
+	"alox.tool/uart"
+)
+
+type ESPStateHandler struct {
+	RWMutex sync.RWMutex
+	Master  MasterESP
+}
+
+type ESPVersion struct {
+	Version   uint16
+	Buildhash [7]byte
+}
+
+type BaseESP struct {
+	ClientId         byte
+	IsUpdating       bool
+	UpdateProgress   float32
+	Version          ESPVersion
+	RunningPartition int
+	MAC              [6]byte
+}
+
+type MasterESP struct {
+	BaseESP
+	Slaves map[byte]*SlaveESP
+}
+
+type SlaveESP struct {
+	BaseESP
+	SlotAvailable       bool
+	SlotUsed            bool
+	Bitmask             uint32
+	LageX               float32
+	LageY               float32
+	LastPing            uint32
+	LastSuccessfullPing uint32
+}
+
+func New() *ESPStateHandler {
+	return &ESPStateHandler{
+		RWMutex: sync.RWMutex{},
+		Master:  NewMasterESP(),
+	}
+}
+
+func NewMasterESP() MasterESP {
+	return MasterESP{
+		BaseESP: BaseESP{
+			ClientId:       0,
+			IsUpdating:     false,
+			UpdateProgress: 0,
+			Version: ESPVersion{
+				Version:   0,
+				Buildhash: [7]byte{},
+			},
+			RunningPartition: 0,
+			MAC:              [6]byte{},
+		},
+		Slaves: map[byte]*SlaveESP{},
+	}
+}
+
+func NewSlaveESP() *SlaveESP {
+	return &SlaveESP{
+		BaseESP: BaseESP{
+			ClientId:       0,
+			IsUpdating:     false,
+			UpdateProgress: 0,
+			Version: ESPVersion{
+				Version:   0,
+				Buildhash: [7]byte{},
+			},
+			RunningPartition: 0,
+			MAC:              [6]byte{},
+		},
+		SlotAvailable:       false,
+		SlotUsed:            false,
+		Bitmask:             0,
+		LageX:               0,
+		LageY:               0,
+		LastPing:            0,
+		LastSuccessfullPing: 0,
+	}
+}
+
+func (s *ESPStateHandler) Start(ctx context.Context, bus eventbus.EventBus) {
+	go func() {
+		RXC := bus.Subscribe(api.TopicUARTRx)
+		defer bus.Unsubscribe(api.TopicUARTRx, RXC)
+
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case msg := <-RXC:
+				val, ok := msg.(api.Frame)
+				if !ok {
+					log.Printf("val is not type api.Frame its %T", val)
+					continue
+				}
+				log.Printf("[%d] Frame: %X, % X", val.Time, val.ID, val.Data)
+				s.processFrame(val)
+			}
+		}
+	}()
+}
+
+func (s *ESPStateHandler) processFrame(val api.Frame) {
+	s.RWMutex.Lock()
+	defer s.RWMutex.Unlock()
+
+	switch val.ID {
+	case api.CmdEcho:
+		log.Printf("Echo %v", val)
+	case api.CmdVersion:
+		v, err := uart.ParseFrameVersion(val)
+		if err != nil {
+			log.Printf("Could not Parse Version %v", err)
+			return
+		}
+		log.Printf("Version Info %d %s", v.Version, v.Buildhash)
+
+		// Update State
+		s.Master.Version.Version = v.Version
+		s.Master.Version.Buildhash = v.Buildhash
+
+	case api.CmdClientInfo:
+		v, err := uart.ParseFrameClientInfo(val)
+		if err != nil {
+			log.Printf("Could not Parse Client Info %v", err)
+			return
+		}
+		for _, c := range v {
+			log.Printf("Client ID  %d", c.ClientID)
+			log.Printf("\tIsAvailable %d", c.IsAvailable)
+			log.Printf("\tLastPing %d", c.LastPing)
+			log.Printf("\tLastSuccessfulPing %d", c.LastSuccessfulPing)
+			log.Printf("\tSlotIsUsed %d", c.SlotIsUsed)
+			log.Printf("\tVersion %d", c.Version)
+			log.Printf("\tMACAddr % X", c.MACAddr)
+
+			_, ok := s.Master.Slaves[c.ClientID]
+			if !ok {
+				s.Master.Slaves[c.ClientID] = NewSlaveESP()
+			}
+
+			s.Master.Slaves[c.ClientID].SlotAvailable = c.IsAvailable != 0
+			s.Master.Slaves[c.ClientID].SlotUsed = c.SlotIsUsed != 0
+			s.Master.Slaves[c.ClientID].LastPing = c.LastPing
+			s.Master.Slaves[c.ClientID].LastSuccessfullPing = c.LastSuccessfulPing
+			s.Master.Slaves[c.ClientID].Version.Version = c.Version
+			s.Master.Slaves[c.ClientID].MAC = c.MACAddr
+		}
+
+	case api.CmdClientInput:
+		v, err := uart.ParseFrameClientInput(val)
+		if err != nil {
+			log.Printf("Could not Parse Client Input %v", err)
+			return
+		}
+		for _, c := range v {
+			log.Printf("Client ID  %d", c.ClientID)
+			log.Printf("\tX %f", c.X)
+			log.Printf("\tY %f", c.Y)
+			log.Printf("\tBitmask %08b", c.InputMask)
+
+			_, ok := s.Master.Slaves[c.ClientID]
+			if !ok {
+				s.Master.Slaves[c.ClientID] = NewSlaveESP()
+			}
+
+			s.Master.Slaves[c.ClientID].LageX = c.X
+			s.Master.Slaves[c.ClientID].LageY = c.Y
+			s.Master.Slaves[c.ClientID].Bitmask = c.InputMask
+		}
+	}
+}

goTool/testrunner/esptool.go

@@ -0,0 +1,18 @@
+package testrunner
+
+import (
+	"os/exec"
+)
+
+const (
+	ESPTOOLPATH = "/home/simon/.espressif/python_env/idf5.5_py3.14_env/bin/esptool.py"
+)
+
+func RestartESPOnPort(port string) error {
+	cmd := exec.Command(ESPTOOLPATH, "--port", port, "run")
+	err := cmd.Run()
+	if err != nil {
+		return err
+	}
+	return nil
+}

goTool/testrunner/runner.go

@@ -0,0 +1,82 @@
+package testrunner
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"time"
+
+	"alox.tool/api"
+	"alox.tool/eventbus"
+	"alox.tool/uart"
+)
+
+type TestRunner struct {
+	bus eventbus.EventBus
+	com *uart.Com
+}
+
+func New(bus eventbus.EventBus, com *uart.Com) *TestRunner {
+	return &TestRunner{
+		bus: bus,
+		com: com,
+	}
+}
+
+func (tr *TestRunner) RunTestSet(TSet map[string]func() error) {
+	null, _ := os.OpenFile(os.DevNull, os.O_WRONLY, 0)
+	defer null.Close()
+
+	// Backups der originalen Deskriptoren
+	oldStdout := os.Stdout
+	oldStderr := os.Stderr
+	oldLogOut := log.Writer()
+
+	for name, f := range TSet {
+
+		// 1. Output komplett abdrehen
+		os.Stdout = null
+		os.Stderr = null
+		log.SetOutput(io.Discard)
+
+		err := f()
+
+		// 2. Sofort wiederherstellen für das Log-Resultat
+		os.Stdout = oldStdout
+		os.Stderr = oldStderr
+		log.SetOutput(oldLogOut)
+
+		if err != nil {
+			log.Printf("[%s]: \t\tFailed: %v", name, err)
+			continue
+		}
+		log.Printf("[%s]: \t\tSucceeded", name)
+	}
+}
+
+func (tr *TestRunner) Expect(idToSend byte, payload []byte, expectedID byte, timeout time.Duration) (*api.Frame, error) {
+	rxChan := tr.bus.Subscribe(api.TopicUARTRx)
+	defer tr.bus.Unsubscribe(api.TopicUARTRx, rxChan)
+
+	if err := tr.com.Send(idToSend, payload); err != nil {
+		return nil, fmt.Errorf("send error: %w", err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return nil, fmt.Errorf("timeout waiting for ID 0x%02X", expectedID)
+		case frame := <-rxChan:
+			f := frame.(api.Frame)
+			if f.ID == expectedID {
+				return &f, nil
+			}
+			// Ignore other IDs and Messages on the Bus
+		}
+	}
+}

goTool/testrunner/tests.go

@@ -0,0 +1,139 @@
+package testrunner
+
+import (
+	"fmt"
+	"slices"
+	"time"
+
+	"alox.tool/api"
+	"alox.tool/uart"
+)
+
+func (tr *TestRunner) RunEchoTest() error {
+	frame, err := tr.Expect(api.CmdEcho, []byte{0x01}, api.CmdEcho, 1*time.Second)
+	if err != nil {
+		return err
+	}
+
+	if frame.Data[0] != 0x01 {
+		return fmt.Errorf("Got % X expected % X", frame.Data[0], 0x01)
+	}
+
+	return nil
+}
+
+func (tr *TestRunner) RunVersionTest() error {
+	frame, err := tr.Expect(api.CmdVersion, nil, api.CmdVersion, 1*time.Second)
+	if err != nil {
+		return err
+	}
+
+	// TODO: Check Version and Buildhash?
+	_, err = uart.ParseFrameVersion(*frame)
+	if err != nil {
+		return err
+	}
+
+	v, err := uart.ParseFrameVersion(*frame)
+	if v.Version != 1 {
+		return fmt.Errorf("Got %d expected %d", v.Version, 1)
+	}
+
+	return nil
+}
+
+func (tr *TestRunner) RunClientInfoTest() error {
+	_, err := tr.Expect(api.CmdClientInfo, nil, api.CmdClientInfo, 1*time.Second)
+	if err != nil {
+		return err
+	}
+
+	// TODO: Real Check
+	return nil
+}
+
+func (tr *TestRunner) RunClientInputTest() error {
+	_, err := tr.Expect(api.CmdClientInput, nil, api.CmdClientInput, 1*time.Second)
+	if err != nil {
+		return err
+	}
+
+	// TODO: Real Check
+	return nil
+}
+
+func (tr *TestRunner) RebuildNetwork() error {
+
+	// Hardcoded for now
+	Clients := map[string]string{
+		"C1": "/dev/ttyACM1",
+		"C2": "/dev/ttyACM2",
+		"C3": "/dev/ttyACM3",
+		"C4": "/dev/ttyACM4",
+	}
+
+	// Hardcoded for now
+	macAddresses := [][6]byte{
+		{0x50, 0x78, 0x7D, 0x18, 0x85, 0xA0},
+		{0x50, 0x78, 0x7D, 0x18, 0x7D, 0x74},
+		{0x50, 0x78, 0x7D, 0x18, 0x1D, 0x14},
+		{0x50, 0x78, 0x7D, 0x18, 0x00, 0x10},
+	}
+
+	// Hardcoded for now
+	err := RestartESPOnPort("/dev/ttyACM0")
+	if err != nil {
+		return fmt.Errorf("Could not Restart Master!")
+	}
+	time.Sleep(500 * time.Millisecond)
+
+	for c, p := range Clients {
+		fmt.Printf("Restarting Client %v", c)
+		err = RestartESPOnPort(p)
+		if err != nil {
+			fmt.Printf("Could not Restart Client %v on Port %v", c, p)
+			return err
+		}
+		time.Sleep(500 * time.Millisecond)
+	}
+
+	success := false
+	var frame *api.Frame
+	var clientInfos []api.PayloadClientInfo
+	var lastError string
+	for i := 0; i <= 5; i++ {
+		time.Sleep(1000 * time.Millisecond) // inital sleep for first network setup
+
+		var err error // for local error scope
+		frame, err = tr.Expect(api.CmdClientInfo, nil, api.CmdClientInfo, 1*time.Second)
+		if err != nil {
+			lastError = "No Uart Message"
+			continue
+		}
+
+		clientInfos, err = uart.ParseFrameClientInfo(*frame)
+		if err != nil {
+			lastError = fmt.Sprintf("Could not parse Message: %v", err)
+			continue
+		}
+
+		if len(clientInfos) != len(macAddresses) {
+			lastError = fmt.Sprintf("Want %v Clients, got %v Clients", len(macAddresses), len(clientInfos))
+			continue
+		}
+		success = true
+		break
+	}
+
+	if !success {
+		return fmt.Errorf("%v", lastError)
+	}
+
+	for _, client := range clientInfos {
+		if !slices.Contains(macAddresses, client.MACAddr) {
+			return fmt.Errorf("Client %v not found in expected list %v", client.MACAddr, macAddresses)
+		}
+	}
+
+	return nil
+}

goTool/uart/com.go

@@ -0,0 +1,138 @@
+package uart
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"time"
+
+	"alox.tool/api"
+	"alox.tool/eventbus"
+	"go.bug.st/serial"
+)
+
+type Com struct {
+	bus    eventbus.EventBus
+	port   serial.Port
+	cancel context.CancelFunc
+}
+
+func NewCom(bus eventbus.EventBus) (*Com, error) {
+	return &Com{
+		bus:    bus,
+		port:   nil,
+		cancel: nil,
+	}, nil
+}
+
+func (c *Com) Connect(portName string, baudrate int) error {
+	if c.port != nil {
+		return fmt.Errorf("Port already connected")
+	}
+	mode := &serial.Mode{BaudRate: baudrate}
+	port, err := serial.Open(portName, mode)
+	if err != nil {
+		return err
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	drv := New(c.bus)
+
+	go func() {
+		buff := make([]byte, 1024)
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			default:
+				n, err := port.Read(buff)
+				if err != nil {
+					log.Print("[Warning]: Read Error:", err)
+					return // Loop beenden bei Hardware-Fehler
+				}
+				if n > 0 {
+					for _, b := range buff[:n] {
+						//log.Printf("[RAW][RX] % X", b)
+						drv.ParseByte(b)
+					}
+				}
+			}
+		}
+	}()
+
+	c.port = port
+	c.cancel = cancel
+	return nil
+}
+
+func (c *Com) Close() {
+	c.cancel()
+	c.port.Close()
+}
+
+func packFrame(id byte, payload []byte) []byte {
+	out := make([]byte, 0, len(payload)+5) // Guessing extra Puffer size
+	checksum := id
+
+	out = append(out, StartByte)
+
+	// Helper für Escaping
+	writeEscaped := func(b byte) {
+		if b == StartByte || b == EscapeByte || b == EndByte {
+			out = append(out, EscapeByte)
+		}
+		out = append(out, b)
+	}
+
+	writeEscaped(id)
+	for _, b := range payload {
+		writeEscaped(b)
+		checksum ^= b
+	}
+
+	writeEscaped(checksum)
+	out = append(out, EndByte)
+	return out
+}
+
+func (c *Com) Send(id byte, payload []byte) error {
+	raw := packFrame(id, payload)
+	log.Printf("[RAW]: %v", raw)
+
+	//log.Printf("RAW: % X", raw)
+	_, err := c.port.Write(raw)
+
+	c.bus.Publish(api.TopicUARTTx, api.Frame{
+		Time: uint64(time.Now().UnixNano()),
+		ID:   id,
+		Data: payload,
+	})
+
+	return err
+}
+
+func (c *Com) EventbusHandler(ctx context.Context) error {
+	UActions := c.bus.Subscribe(api.TopicUartAction)
+
+	for {
+		select {
+		case <-ctx.Done():
+			return nil
+		case msgT := <-UActions:
+			switch msg := msgT.(type) {
+			case api.ActionUartConnect:
+				err := c.Connect(msg.Adapter, msg.Baudrate)
+				c.bus.Publish(api.TopicUartAction, api.ActionUartConnected{
+					Adapter:  msg.Adapter,
+					Baudrate: msg.Baudrate,
+					Error:    err,
+				})
+			case api.ActionUartDisconnect:
+				c.Close()
+				c.bus.Publish(api.TopicUartAction, api.ActionUartDisconnected{})
+			case api.ActionUartSendMessage:
+				c.Send(msg.MsgId, msg.Data)
+			}
+		}
+	}
+}

goTool/uart/commands.go

@@ -0,0 +1,189 @@
+package uart
+
+import (
+	"encoding/binary"
+	"fmt"
+	"log"
+	"math"
+
+	"alox.tool/api"
+)
+
+func ParseFrameVersion(frame api.Frame) (api.PayloadVersion, error) {
+	if len(frame.Data) != api.PayloadVersionSize {
+		return api.PayloadVersion{}, fmt.Errorf("payload wrong size: got %d bytes, want 10", len(frame.Data))
+	}
+
+	v := api.PayloadVersion{
+		Version:   binary.LittleEndian.Uint16(frame.Data[0:2]),
+		Buildhash: [7]uint8(frame.Data[2:10])}
+	return v, nil
+}
+
+func parseFrameClientInfoPart(data []byte) (api.PayloadClientInfo, error) {
+	if len(data) != api.PayloadClientInfoSize {
+		return api.PayloadClientInfo{}, fmt.Errorf("payload wrong size: got %d bytes, want 19", len(data))
+	}
+
+	v := api.PayloadClientInfo{
+		ClientID:           data[0],
+		IsAvailable:        data[1],
+		SlotIsUsed:         data[2],
+		MACAddr:            [6]uint8(data[3:9]),
+		LastPing:           binary.LittleEndian.Uint32(data[9:13]),
+		LastSuccessfulPing: binary.LittleEndian.Uint32(data[13:17]),
+		Version:            binary.LittleEndian.Uint16(data[17:19]),
+	}
+
+	return v, nil
+}
+
+func ParseFrameClientInfo(frame api.Frame) ([]api.PayloadClientInfo, error) {
+	if len(frame.Data) == 0 {
+		return nil, fmt.Errorf("empty frame data")
+	}
+
+	clientCount := int(frame.Data[0])
+
+	log.Printf("Clients %d", clientCount)
+
+	expectedLen := 1 + (clientCount * api.PayloadClientInfoSize)
+
+	if len(frame.Data) < expectedLen {
+		return nil, fmt.Errorf("frame data too short: got %d, want %d", len(frame.Data), expectedLen)
+	}
+
+	clientList := make([]api.PayloadClientInfo, 0, clientCount)
+
+	for i := 0; i < clientCount; i++ {
+		start := 1 + (i * api.PayloadClientInfoSize)
+		end := start + api.PayloadClientInfoSize
+
+		client, err := parseFrameClientInfoPart(frame.Data[start:end])
+		if err != nil {
+			log.Printf("Could not parse client part %d: %v", i, err)
+			continue
+		}
+		clientList = append(clientList, client)
+	}
+
+	return clientList, nil
+}
+
+func parseFrameClientInputPart(data []byte) (api.PayloadClientInput, error) {
+	if len(data) != api.PayloadClientInputSize {
+		return api.PayloadClientInput{}, fmt.Errorf("payload wrong size: got %d bytes, want 13", len(data))
+	}
+
+	v := api.PayloadClientInput{
+		ClientID:  data[0],
+		X:         math.Float32frombits(binary.LittleEndian.Uint32(data[1 : 1+4])),
+		Y:         math.Float32frombits(binary.LittleEndian.Uint32(data[5 : 5+4])),
+		InputMask: binary.LittleEndian.Uint32(data[9 : 9+4]),
+	}
+
+	return v, nil
+}
+
+func ParseFrameClientInput(frame api.Frame) ([]api.PayloadClientInput, error) {
+	if len(frame.Data) == 0 {
+		return nil, fmt.Errorf("empty frame data")
+	}
+
+	clientCount := int(frame.Data[0])
+
+	log.Printf("Clients %d", clientCount)
+
+	expectedLen := 1 + (clientCount * api.PayloadClientInputSize)
+
+	if len(frame.Data) < expectedLen {
+		return nil, fmt.Errorf("frame data too short: got %d, want %d", len(frame.Data), expectedLen)
+	}
+
+	clientList := make([]api.PayloadClientInput, 0, clientCount)
+
+	for i := 0; i < clientCount; i++ {
+		start := 1 + (i * api.PayloadClientInputSize)
+		end := start + api.PayloadClientInputSize
+
+		client, err := parseFrameClientInputPart(frame.Data[start:end])
+		if err != nil {
+			log.Printf("Could not parse client art %d: %v", i, err)
+			continue
+		}
+		clientList = append(clientList, client)
+	}
+
+	return clientList, nil
+}
+
+// Dummy for now Just get Data
+func ParseFrameOtaPayload(frame api.Frame) (api.PayloadOtaPayload, error) {
+	if len(frame.Data) == 0 {
+		return api.PayloadOtaPayload{}, fmt.Errorf("empty frame data")
+	}
+
+	status := api.PayloadOtaPayload{
+		Data:           frame.Data,
+		SequenzCounter: binary.LittleEndian.Uint16(frame.Data[0:2]),
+		WriteIndex:     binary.LittleEndian.Uint16(frame.Data[2:4]),
+		Error:          frame.Data[4],
+	}
+
+	return status, nil
+}
+
+// Dummy for now Just get Data
+func ParseFrameOtaStatus(frame api.Frame) (api.PayloadOtaStatus, error) {
+	if len(frame.Data) == 0 {
+		return api.PayloadOtaStatus{}, fmt.Errorf("empty frame data")
+	}
+
+	status := api.PayloadOtaStatus{
+		Data:           frame.Data,
+		SequenzCounter: binary.LittleEndian.Uint16(frame.Data[0:2]),
+		WriteIndex:     binary.LittleEndian.Uint16(frame.Data[2:4]),
+	}
+	return status, nil
+}
+
+// Dummy for now Just get Data
+func ParseFrameOtaStart(frame api.Frame) (api.PayloadOtaStart, error) {
+	if len(frame.Data) == 0 {
+		return api.PayloadOtaStart{}, fmt.Errorf("empty frame data")
+	}
+
+	status := api.PayloadOtaStart{
+		Data:     frame.Data,
+		Parition: frame.Data[0],
+		Error:    frame.Data[1],
+	}
+
+	return status, nil
+}
+
+// Dummy for now Just get Data
+func ParseFrameOtaEnd(frame api.Frame) (api.PayloadOtaEnd, error) {
+	if len(frame.Data) == 0 {
+		return api.PayloadOtaEnd{}, fmt.Errorf("empty frame data")
+	}
+
+	status := api.PayloadOtaEnd{
+		Data: frame.Data,
+	}
+
+	return status, nil
+}
+
+// Dummy for now Just get Data
+func ParseFrameOtaStartEspNow(frame api.Frame) (api.PayloadOtaStartEspNow, error) {
+	if len(frame.Data) == 0 {
+		return api.PayloadOtaStartEspNow{}, fmt.Errorf("empty frame data")
+	}
+
+	status := api.PayloadOtaStartEspNow{
+		Data: frame.Data,
+	}
+
+	return status, nil
+}

goTool/uart/parser.go

@@ -0,0 +1,128 @@
+package uart
+
+import (
+	"fmt"
+	"time"
+
+	"alox.tool/api"
+	"alox.tool/eventbus"
+)
+
+const (
+	StartByte  = 0xAA
+	EscapeByte = 0xBB
+	EndByte    = 0xCC
+)
+
+type parserState int
+
+const (
+	stateWaitingForStart parserState = iota
+	stateGetID
+	stateEscapedID
+	stateInPayload
+	stateEscapedPayload
+)
+
+type Parser struct {
+	bus        eventbus.EventBus
+	state      parserState
+	parsedData []byte
+	rawCapture []byte
+	checksum   byte
+}
+
+func New(bus eventbus.EventBus) *Parser {
+	return &Parser{
+		bus:        bus,
+		state:      stateWaitingForStart,
+		parsedData: make([]byte, 0, 1024*4),
+		rawCapture: make([]byte, 0, 1024*4),
+	}
+}
+
+func (p *Parser) reset() {
+	p.state = stateWaitingForStart
+	p.parsedData = p.parsedData[:0]
+	p.rawCapture = p.rawCapture[:0]
+	p.checksum = 0
+}
+
+func (p *Parser) pushError(reason string) {
+	// Throw Error on the Bus befor resetting
+	p.bus.Publish(api.TopicUARTError, fmt.Errorf("%s: %02X", reason, p.rawCapture))
+	p.reset()
+}
+
+func (p *Parser) emitFrame() {
+	if len(p.parsedData) == 0 {
+		p.reset()
+		return
+	}
+
+	// Copy Data for Message Frame
+	dataCopy := make([]byte, len(p.parsedData)-1) // Exclude ID
+	copy(dataCopy, p.parsedData[1:])
+
+	f := api.Frame{
+		Time: uint64(time.Now().UnixNano()),
+		ID:   p.parsedData[0],
+		Data: dataCopy,
+	}
+
+	p.bus.Publish(api.TopicUARTRx, f)
+	p.reset()
+}
+
+func (p *Parser) addByte(b byte) {
+	p.parsedData = append(p.parsedData, b)
+	p.checksum ^= b
+}
+
+func (p *Parser) ParseByte(b byte) {
+	p.rawCapture = append(p.rawCapture, b)
+
+	switch p.state {
+	case stateWaitingForStart:
+		if b == StartByte {
+			p.reset()
+			p.rawCapture = append(p.rawCapture, b) // Start Byte behalten
+			p.state = stateGetID
+		}
+
+	case stateGetID:
+		if b == EscapeByte {
+			p.state = stateEscapedID
+		} else {
+			p.addByte(b)
+			p.state = stateInPayload
+		}
+
+	case stateEscapedID:
+		p.addByte(b)
+		p.state = stateInPayload
+
+	case stateInPayload:
+		if b == EscapeByte {
+			p.state = stateEscapedPayload
+			return
+		}
+		if b == StartByte {
+			p.pushError("unexpected start byte")
+			return
+		}
+		if b == EndByte {
+			if p.checksum != 0 {
+				p.pushError("checksum mismatch")
+				return
+			}
+			p.emitFrame()
+			return
+		}
+		p.addByte(b)
+
+	case stateEscapedPayload:
+		p.addByte(b)
+		p.state = stateInPayload
+	}
+}

main/i2c.c

@@ -1,6 +1,6 @@
 #include "i2c.h"
 #include "bma4.h"
-#include "bma456w.h"
+#include "bma456h.h"
 #include "bma4_defs.h"
 #include "driver/gpio.h"
 #include "driver/i2c_master.h"
@@ -135,11 +135,34 @@ void read_sensor_task(void *params) {
     ret = bma4_read_accel_xyz(&sens_data, &bma456_struct);
     bma4_error_codes_print_result("bma4_read_accel_xyz", ret);
 
+    ESP_LOGI("ACC", "X: %d, Y: %d, Z: %d", sens_data.x, sens_data.y,
+             sens_data.z);
+
     if (interrupt_status) {
       ESP_LOGI("INTERRUPT", "Da war der Interrupt resetting");
       interrupt_status = 0;
-      ret = bma456w_read_int_status(&int_status, &bma456_struct);
+      ret = bma456h_read_int_status(&int_status, &bma456_struct);
       bma4_error_codes_print_result("bma456w_step_counter_output status", ret);
+
+      int8_t rslt;
+      struct bma456h_out_state tap_out = {0};
+
+      rslt = bma456h_output_state(&tap_out, &bma456_struct);
+
+      if (BMA4_OK == rslt) {
+        /* Enters only if the obtained interrupt is single-tap */
+        if (tap_out.single_tap) {
+          ESP_LOGI("INTERRUPT", "Single Tap interrupt occurred\n");
+        }
+        /* Enters only if the obtained interrupt is double-tap */
+        else if (tap_out.double_tap) {
+          ESP_LOGI("INTERRUPT", "Double Tap interrupt occurred\n");
+        }
+        /* Enters only if the obtained interrupt is triple-tap */
+        else if (tap_out.triple_tap) {
+          ESP_LOGI("INTERRUPT", "Triple Tap interrupt occurred\n");
+        }
+      }
     }
 
     // ESP_LOGI("i2c", "X:%d, Y%d, Z%d", sens_data.x, sens_data.y, sens_data.z);
@@ -167,7 +190,7 @@ void init_bma456() {
   int8_t ret;
   bma456_struct.chip_id = 0;
 
-  ret = bma456w_init(&bma456_struct);
+  ret = bma456h_init(&bma456_struct);
   bma4_error_codes_print_result("I2C Init", ret);
 
   ESP_LOGI("I2C", "Chip Init ausgelesene CHIP ID %d", bma456_struct.chip_id);
@@ -184,20 +207,35 @@ void init_bma456() {
   ESP_LOGI("I2C", "Config Pointer %p", bma456_struct.config_file_ptr);
 
   ESP_LOGI("I2C", "Starte Config-File Upload...");
-  ret = bma456w_write_config_file(&bma456_struct);
+  ret = bma456h_write_config_file(&bma456_struct);
   bma4_error_codes_print_result("bma4_write_config_file", ret);
 
+  struct bma4_accel_config accel_config;
+  bma4_get_accel_config(&accel_config, &bma456_struct);
+  accel_config.range = BMA4_ACCEL_RANGE_2G;
+  ret = bma4_set_accel_config(&accel_config, &bma456_struct);
+  bma4_error_codes_print_result("bma4_set_accel_config status", ret);
+
   /* Enable the accelerometer */
   ret = bma4_set_accel_enable(BMA4_ENABLE, &bma456_struct);
   bma4_error_codes_print_result("bma4_set_accel_enable status", ret);
 
-  ret = bma456w_feature_enable(BMA456W_STEP_CNTR, BMA4_ENABLE, &bma456_struct);
+  struct bma456h_multitap_settings tap_settings = {0};
+  ret = bma456h_tap_get_parameter(&tap_settings, &bma456_struct);
+  bma4_error_codes_print_result("bma456h_tap_get_parameter status", ret);
+  tap_settings.tap_sens_thres = 0;
+  ret = bma456h_tap_set_parameter(&tap_settings, &bma456_struct);
+  bma4_error_codes_print_result("bma456h_tap_set_parameter status", ret);
+
+  ret = bma456h_feature_enable(
+      (BMA456H_SINGLE_TAP_EN | BMA456H_DOUBLE_TAP_EN | BMA456H_TRIPLE_TAP_EN),
+      BMA4_ENABLE, &bma456_struct);
   bma4_error_codes_print_result("bma456w_feature_enable status", ret);
 
   /* Setting watermark level 1, the output step resolution is 20 steps.
    * Eg: 1 means, 1 * 20 = 20. Every 20 steps once output triggers
    */
-  ret = bma456w_step_counter_set_watermark(1, &bma456_struct);
+  ret = bma456h_step_counter_set_watermark(1, &bma456_struct);
   bma4_error_codes_print_result("bma456w_step_counter_set_watermark status",
                                 ret);
 
@@ -207,8 +245,9 @@ void init_bma456() {
   ret = bma4_get_int_pin_config(&pin_config, int_line, &bma456_struct);
   bma4_error_codes_print_result("bma4_get_int_pin_config status", ret);
 
-  ret = bma456w_map_interrupt(int_line, BMA456W_STEP_CNTR_INT, BMA4_ENABLE,
+  ret = bma456h_map_interrupt(int_line, BMA456H_TAP_OUT_INT, BMA4_ENABLE,
                               &bma456_struct);
+
   bma4_error_codes_print_result("bma456w_map_interrupt status", ret);
 
   pin_config.edge_ctrl = BMA4_EDGE_TRIGGER;

main/main.c

@@ -373,8 +373,9 @@ void app_main(void) {
     RegisterCallback(UART_CLIENT_INFO, clientInfoCallback);
     RegisterCallback(UART_CLIENT_INPUT, fakeDataCallback);
     RegisterCallback(UART_OTA_START_ESPNOW, start_ota_update_espnow);
+    RegisterUART_OTAFunctions();
 
-    init_i2c_with_all_devices();
+    // init_i2c_with_all_devices();
 
   } else {
     ESP_LOGI(TAG, "Started in Slavemode");

main/message_handler.c

@@ -13,6 +13,7 @@ void InitMessageBroker() {
 }
 
 void RegisterCallback(uint8_t msgid, RegisterFunctionCallback callback) {
+  ESP_LOGI(TAG, "Registerd Uart Callback for % X", msgid);
   mr.FunctionList[mr.num_direct_callbacks].MSGID = msgid;
   mr.FunctionList[mr.num_direct_callbacks].callback = callback;
   mr.num_direct_callbacks++;
@@ -46,11 +47,13 @@ void MessageBrokerTask(void *param) {
 
   while (1) {
     if (xQueueReceive(msg_queue, &received_msg, portMAX_DELAY)) {
-      //ESP_LOGI(TAG, "Received message from queue: MSGID=0x%02X, Length=%u",
+      // ESP_LOGI(TAG, "Received message from queue: MSGID=0x%02X, Length=%u",
       //          received_msg.msgid, received_msg.payload_len);
 
       for (int i = 0; i < mr.num_direct_callbacks; i++) {
+        //ESP_LOGI(TAG, "Searching CALLBACK for %d", received_msg.msgid);
         if (mr.FunctionList[i].MSGID == received_msg.msgid) {
+          //ESP_LOGI(TAG, "FOUND CALLBACK");
           mr.FunctionList[i].callback(
               received_msg.msgid, received_msg.data, received_msg.payload_len,
               send_payload_buffer, send_payload_buffer_size,

main/ota_update.c

@@ -353,14 +353,16 @@ void start_uart_update(uint8_t msgid, const uint8_t *payload,
 
   int part = prepare_ota_update();
 
-  // TODO: what does this do? maybe comment it out for now?
+  uart_ota_start_t *start = (uart_ota_start_t *)send_payload_buffer;
+  start->partition = part & 0xff;
+
+  // TODO: Refine Errors
+  // Set error
   if (part < 0) {
-    send_payload_buffer[1] = (part * -1) & 0xff;
+    start->error = 0x01;
-  } else {
-    send_payload_buffer[0] = part & 0xff;
   }
 
-  int send_payload_len = 2;
+  int send_payload_len = sizeof(uart_ota_start_t);
   int len = build_message(UART_OTA_START, send_payload_buffer, send_payload_len,
                           send_buffer, send_buffer_size);
   if (len < 0) {
@@ -375,9 +377,9 @@ void start_uart_update(uint8_t msgid, const uint8_t *payload,
 }
 
 esp_err_t write_ota_update(uint32_t write_len, const uint8_t *payload) {
-  ESP_LOGI(TAG, "write_ota_update: write_len: %d", write_len);
+  // ESP_LOGI(TAG, "write_ota_update: write_len: %d", write_len);
-  ESP_LOGI(TAG, "write_ota_update: update_buffer_write_index: %d",
+  // ESP_LOGI(TAG, "write_ota_update: update_buffer_write_index: %d",
-           update_buffer_write_index);
+  // update_buffer_write_index);
   if (update_buffer_write_index + write_len > UPDATE_BUFFER_SIZE) {
     ESP_LOGI(TAG, "write_ota_update: schreib das update weg!");
     esp_err_t err =
@@ -412,15 +414,17 @@ void payload_uart_update(uint8_t msgid, const uint8_t *payload_data_from_uart,
 
   esp_err_t err = write_ota_update(write_len, actual_firmware_data);
 
+  uart_ota_ack_t *ack = (uart_ota_ack_t *)send_payload_buffer;
+  ack->sequence_counter = sequenz_counter;
+  ack->write_index = update_buffer_write_index;
+  ack->error = (err == ESP_OK) ? 0x00 : 0x01;
+
+  size_t send_payload_len = sizeof(uart_ota_ack_t);
+
   if (err != ESP_OK) {
     ESP_LOGE(TAG, "GOT ESP ERROR WRITE OTA %d", err);
   }
 
-  size_t send_payload_len = 4;
-  memcpy(send_payload_buffer, &sequenz_counter, 2);
-  memcpy(&send_payload_buffer[2], &update_buffer_write_index, 2);
-  send_payload_buffer[4] = 0x00; // error
-
   int len = build_message(UART_OTA_PAYLOAD, send_payload_buffer,
                           send_payload_len, send_buffer, send_buffer_size);
   if (len < 0) {
@@ -442,8 +446,10 @@ void end_uart_update(uint8_t msgid, const uint8_t *payload, size_t payload_len,
 
   esp_err_t err = end_ota_update();
 
-  int send_payload_len = 1;
+  uart_ota_end_t *end = (uart_ota_end_t *)send_payload_buffer;
-  send_payload_buffer[0] = err & 0xff;
+  end->error = err & 0xff;
+  int send_payload_len = sizeof(uart_ota_end_t);
+
   int len = build_message(UART_OTA_END, send_payload_buffer, send_payload_len,
                           send_buffer, send_buffer_size);
   if (len < 0) {
@@ -461,7 +467,9 @@ void end_uart_update(uint8_t msgid, const uint8_t *payload, size_t payload_len,
 
 void init_ota() {
   ota_task_queue = xQueueCreate(50, sizeof(ota_task_queue_message_t));
+}
 
+void RegisterUART_OTAFunctions() {
   RegisterCallback(UART_OTA_START, start_uart_update);
   RegisterCallback(UART_OTA_PAYLOAD, payload_uart_update);
   RegisterCallback(UART_OTA_END, end_uart_update);
@@ -485,7 +493,17 @@ int prepare_ota_update() {
     ESP_LOGE(TAG, "esp_ota_begin failed (%s)", esp_err_to_name(err));
     return -2;
   }
+
+  if (update_partition->subtype == ESP_PARTITION_SUBTYPE_APP_OTA_0) {
     return 0;
+  }
+
+  if (update_partition->subtype == ESP_PARTITION_SUBTYPE_APP_OTA_1) {
+    return 1;
+  }
+
+  // TODO: Unknow partition
+  return 2;
 }
 
 esp_err_t end_ota_update() {

main/ota_update.h

@@ -33,7 +33,23 @@ typedef struct {
   ClientList *client_list;
 } MasterOTA_TaskParams_t;
 
+typedef struct __attribute__((packed)) {
+  uint16_t sequence_counter;
+  uint16_t write_index;
+  uint8_t error;
+} uart_ota_ack_t;
+
+typedef struct __attribute__((packed)) {
+  uint8_t partition;
+  uint8_t error;
+} uart_ota_start_t;
+
+typedef struct __attribute__((packed)) {
+  uint8_t error;
+} uart_ota_end_t;
+
 void init_ota();
+void RegisterUART_OTAFunctions();
 void MasterOTATask(void *pvParameter);
 void slave_ota_task(void *pvParameter);
 

main/uart_handler.c

@@ -18,7 +18,8 @@ static const char *TAG = "ALOX - UART";
 static QueueHandle_t parsed_message_queue;
 
 void init_uart(QueueHandle_t msg_queue_handle) {
-  uart_config_t uart_config = {.baud_rate = 921600, // 921600, 115200
+  uart_config_t uart_config = {// .baud_rate = 115200, // 921600, 115200
+                               .baud_rate = 921600,
                                .data_bits = UART_DATA_8_BITS,
                                .parity = UART_PARITY_DISABLE,
                                .stop_bits = UART_STOP_BITS_1,

readme.md

@@ -1,3 +1,29 @@
+# Conventions
+
+## Naming
+
+### Filenames: snake_case (ota_master.c, ota_slave.c, com_handler.c)
+
+### Functions: module_submodule_action()
+- OTA Master = ota_m_send_chunk(), ota_m_init()
+- OTA Slave = ota_s_handle_chunk(), ota_s_prepare_flash()
+- com_init(), msg_parse()
+
+### Variables:
+- Global: g_ (g_client_list)
+- Statics: s_ (s_update_handle)
+- Constants: UPPER_SNAKE_CASE (UPDATE_BUFFER_SIZE)
+
+### Types:
+- Typedefs: Ends with _t (ota_payload_t)
+- Struct-Tags: Ends with _t or spezifik name (struct ota_context)
+- Unions: Ends with _u (msg_payload_u)
+- Callbacks: End with _cb (com_m_rx_cb)
+
+### FreeRTOS-Objects
+- x for Basetypes (x_ota_queue, x_status_semaphor)
+- v for void return (v_ota_task)
+
 # UART Protokoll
 
 ## Struktur einer Nachricht

sdkconfig

@@ -1,6 +1,6 @@
 #
 # Automatically generated file. DO NOT EDIT.
-# Espressif IoT Development Framework (ESP-IDF) 5.5.0 Project Configuration
+# Espressif IoT Development Framework (ESP-IDF) 5.5.1 Project Configuration
 #
 CONFIG_SOC_ADC_SUPPORTED=y
 CONFIG_SOC_UART_SUPPORTED=y
@@ -9,9 +9,11 @@ CONFIG_SOC_PHY_SUPPORTED=y
 CONFIG_SOC_WIFI_SUPPORTED=y
 CONFIG_SOC_TWAI_SUPPORTED=y
 CONFIG_SOC_GDMA_SUPPORTED=y
+CONFIG_SOC_UHCI_SUPPORTED=y
 CONFIG_SOC_AHB_GDMA_SUPPORTED=y
 CONFIG_SOC_GPTIMER_SUPPORTED=y
 CONFIG_SOC_LCDCAM_SUPPORTED=y
+CONFIG_SOC_LCDCAM_CAM_SUPPORTED=y
 CONFIG_SOC_LCDCAM_I80_LCD_SUPPORTED=y
 CONFIG_SOC_LCDCAM_RGB_LCD_SUPPORTED=y
 CONFIG_SOC_MCPWM_SUPPORTED=y
@@ -100,7 +102,7 @@ CONFIG_SOC_CPU_HAS_FPU=y
 CONFIG_SOC_HP_CPU_HAS_MULTIPLE_CORES=y
 CONFIG_SOC_CPU_BREAKPOINTS_NUM=2
 CONFIG_SOC_CPU_WATCHPOINTS_NUM=2
-CONFIG_SOC_CPU_WATCHPOINT_MAX_REGION_SIZE=64
+CONFIG_SOC_CPU_WATCHPOINT_MAX_REGION_SIZE=0x40
 CONFIG_SOC_SIMD_PREFERRED_DATA_ALIGNMENT=16
 CONFIG_SOC_DS_SIGNATURE_MAX_BIT_LEN=4096
 CONFIG_SOC_DS_KEY_PARAM_MD_IV_LENGTH=16
@@ -211,7 +213,7 @@ CONFIG_SOC_RTCIO_INPUT_OUTPUT_SUPPORTED=y
 CONFIG_SOC_RTCIO_HOLD_SUPPORTED=y
 CONFIG_SOC_RTCIO_WAKE_SUPPORTED=y
 CONFIG_SOC_LP_IO_CLOCK_IS_INDEPENDENT=y
-CONFIG_SOC_SDM_GROUPS=y
+CONFIG_SOC_SDM_GROUPS=1
 CONFIG_SOC_SDM_CHANNELS_PER_GROUP=8
 CONFIG_SOC_SDM_CLK_SUPPORT_APB=y
 CONFIG_SOC_SPI_PERIPH_NUM=3
@@ -255,7 +257,7 @@ CONFIG_SOC_LP_TIMER_BIT_WIDTH_LO=32
 CONFIG_SOC_LP_TIMER_BIT_WIDTH_HI=16
 CONFIG_SOC_TOUCH_SENSOR_VERSION=2
 CONFIG_SOC_TOUCH_SENSOR_NUM=15
-CONFIG_SOC_TOUCH_MIN_CHAN_ID=y
+CONFIG_SOC_TOUCH_MIN_CHAN_ID=1
 CONFIG_SOC_TOUCH_MAX_CHAN_ID=14
 CONFIG_SOC_TOUCH_SUPPORT_BENCHMARK=y
 CONFIG_SOC_TOUCH_SUPPORT_SLEEP_WAKEUP=y
@@ -266,6 +268,7 @@ CONFIG_SOC_TOUCH_PROXIMITY_CHANNEL_NUM=3
 CONFIG_SOC_TOUCH_PROXIMITY_MEAS_DONE_SUPPORTED=y
 CONFIG_SOC_TOUCH_SAMPLE_CFG_NUM=1
 CONFIG_SOC_TWAI_CONTROLLER_NUM=1
+CONFIG_SOC_TWAI_MASK_FILTER_NUM=1
 CONFIG_SOC_TWAI_CLK_SUPPORT_APB=y
 CONFIG_SOC_TWAI_BRP_MIN=2
 CONFIG_SOC_TWAI_BRP_MAX=16384
@@ -280,6 +283,7 @@ CONFIG_SOC_UART_SUPPORT_APB_CLK=y
 CONFIG_SOC_UART_SUPPORT_RTC_CLK=y
 CONFIG_SOC_UART_SUPPORT_XTAL_CLK=y
 CONFIG_SOC_UART_WAKEUP_SUPPORT_ACTIVE_THRESH_MODE=y
+CONFIG_SOC_UHCI_NUM=1
 CONFIG_SOC_USB_OTG_PERIPH_NUM=1
 CONFIG_SOC_SHA_DMA_MAX_BUFFER_SIZE=3968
 CONFIG_SOC_SHA_SUPPORT_DMA=y
@@ -349,7 +353,7 @@ CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_WAIT_IDLE=y
 CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_SUSPEND=y
 CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_RESUME=y
 CONFIG_SOC_SPI_MEM_SUPPORT_SW_SUSPEND=y
-CONFIG_SOC_SPI_MEM_SUPPORT_OPI_MODE=y
+CONFIG_SOC_SPI_MEM_SUPPORT_FLASH_OPI_MODE=y
 CONFIG_SOC_SPI_MEM_SUPPORT_TIMING_TUNING=y
 CONFIG_SOC_SPI_MEM_SUPPORT_CONFIG_GPIO_BY_EFUSE=y
 CONFIG_SOC_SPI_MEM_SUPPORT_WRAP=y
@@ -378,6 +382,9 @@ CONFIG_SOC_BLE_DEVICE_PRIVACY_SUPPORTED=y
 CONFIG_SOC_BLUFI_SUPPORTED=y
 CONFIG_SOC_ULP_HAS_ADC=y
 CONFIG_SOC_PHY_COMBO_MODULE=y
+CONFIG_SOC_LCDCAM_CAM_SUPPORT_RGB_YUV_CONV=y
+CONFIG_SOC_LCDCAM_CAM_PERIPH_NUM=1
+CONFIG_SOC_LCDCAM_CAM_DATA_WIDTH_MAX=16
 CONFIG_IDF_CMAKE=y
 CONFIG_IDF_TOOLCHAIN="gcc"
 CONFIG_IDF_TOOLCHAIN_GCC=y
@@ -418,9 +425,9 @@ CONFIG_BOOTLOADER_PROJECT_VER=1
 # end of Application Rollback
 
 #
-# Bootloader Rollback
+# Recovery Bootloader and Rollback
 #
-# end of Bootloader Rollback
+# end of Recovery Bootloader and Rollback
 
 CONFIG_BOOTLOADER_OFFSET_IN_FLASH=0x0
 CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE=y
@@ -436,10 +443,10 @@ CONFIG_BOOTLOADER_LOG_VERSION=1
 # CONFIG_BOOTLOADER_LOG_LEVEL_NONE is not set
 # CONFIG_BOOTLOADER_LOG_LEVEL_ERROR is not set
 # CONFIG_BOOTLOADER_LOG_LEVEL_WARN is not set
-CONFIG_BOOTLOADER_LOG_LEVEL_INFO=y
+# CONFIG_BOOTLOADER_LOG_LEVEL_INFO is not set
-# CONFIG_BOOTLOADER_LOG_LEVEL_DEBUG is not set
+CONFIG_BOOTLOADER_LOG_LEVEL_DEBUG=y
 # CONFIG_BOOTLOADER_LOG_LEVEL_VERBOSE is not set
-CONFIG_BOOTLOADER_LOG_LEVEL=3
+CONFIG_BOOTLOADER_LOG_LEVEL=4
 
 #
 # Format
@@ -447,6 +454,13 @@ CONFIG_BOOTLOADER_LOG_LEVEL=3
 # CONFIG_BOOTLOADER_LOG_COLORS is not set
 CONFIG_BOOTLOADER_LOG_TIMESTAMP_SOURCE_CPU_TICKS=y
 # end of Format
+
+#
+# Settings
+#
+CONFIG_BOOTLOADER_LOG_MODE_TEXT_EN=y
+CONFIG_BOOTLOADER_LOG_MODE_TEXT=y
+# end of Settings
 # end of Log
 
 #
@@ -506,6 +520,7 @@ CONFIG_ESP_ROM_HAS_HAL_WDT=y
 CONFIG_ESP_ROM_NEEDS_SWSETUP_WORKAROUND=y
 CONFIG_ESP_ROM_HAS_LAYOUT_TABLE=y
 CONFIG_ESP_ROM_HAS_SPI_FLASH=y
+CONFIG_ESP_ROM_HAS_SPI_FLASH_MMAP=y
 CONFIG_ESP_ROM_HAS_ETS_PRINTF_BUG=y
 CONFIG_ESP_ROM_HAS_NEWLIB=y
 CONFIG_ESP_ROM_HAS_NEWLIB_NANO_FORMAT=y
@@ -641,6 +656,7 @@ CONFIG_APPTRACE_LOCK_ENABLE=y
 # Common Options
 #
 # CONFIG_BT_BLE_LOG_SPI_OUT_ENABLED is not set
+# CONFIG_BT_BLE_LOG_UHCI_OUT_ENABLED is not set
 # end of Common Options
 # end of Bluetooth
 
@@ -655,11 +671,11 @@ CONFIG_APPTRACE_LOCK_ENABLE=y
 #
 
 #
-# TWAI Configuration
+# Legacy TWAI Driver Configurations
 #
-# CONFIG_TWAI_ISR_IN_IRAM is not set
+# CONFIG_TWAI_SKIP_LEGACY_CONFLICT_CHECK is not set
 CONFIG_TWAI_ERRATA_FIX_LISTEN_ONLY_DOM=y
-# end of TWAI Configuration
+# end of Legacy TWAI Driver Configurations
 
 #
 # Legacy ADC Driver Configuration
@@ -757,6 +773,7 @@ CONFIG_ESP_TLS_USE_DS_PERIPHERAL=y
 # CONFIG_ESP_TLS_SERVER_MIN_AUTH_MODE_OPTIONAL is not set
 # CONFIG_ESP_TLS_PSK_VERIFICATION is not set
 # CONFIG_ESP_TLS_INSECURE is not set
+CONFIG_ESP_TLS_DYN_BUF_STRATEGY_SUPPORTED=y
 # end of ESP-TLS
 
 #
@@ -782,6 +799,12 @@ CONFIG_ESP_COEX_ENABLED=y
 CONFIG_ESP_ERR_TO_NAME_LOOKUP=y
 # end of Common ESP-related
 
+#
+# ESP-Driver:Camera Controller Configurations
+#
+# CONFIG_CAM_CTLR_DVP_CAM_ISR_CACHE_SAFE is not set
+# end of ESP-Driver:Camera Controller Configurations
+
 #
 # ESP-Driver:GPIO Configurations
 #
@@ -823,8 +846,10 @@ CONFIG_I2C_MASTER_ISR_HANDLER_IN_IRAM=y
 #
 # ESP-Driver:MCPWM Configurations
 #
-# CONFIG_MCPWM_ISR_IRAM_SAFE is not set
+CONFIG_MCPWM_ISR_HANDLER_IN_IRAM=y
+# CONFIG_MCPWM_ISR_CACHE_SAFE is not set
 # CONFIG_MCPWM_CTRL_FUNC_IN_IRAM is not set
+CONFIG_MCPWM_OBJ_CACHE_SAFE=y
 # CONFIG_MCPWM_ENABLE_DEBUG_LOG is not set
 # end of ESP-Driver:MCPWM Configurations
 
@@ -839,11 +864,15 @@ CONFIG_I2C_MASTER_ISR_HANDLER_IN_IRAM=y
 #
 # ESP-Driver:RMT Configurations
 #
-CONFIG_RMT_ISR_HANDLER_IN_IRAM=y
+CONFIG_RMT_ENCODER_FUNC_IN_IRAM=y
+CONFIG_RMT_TX_ISR_HANDLER_IN_IRAM=y
+CONFIG_RMT_RX_ISR_HANDLER_IN_IRAM=y
 # CONFIG_RMT_RECV_FUNC_IN_IRAM is not set
-# CONFIG_RMT_ISR_CACHE_SAFE is not set
+# CONFIG_RMT_TX_ISR_CACHE_SAFE is not set
+# CONFIG_RMT_RX_ISR_CACHE_SAFE is not set
 CONFIG_RMT_OBJ_CACHE_SAFE=y
 # CONFIG_RMT_ENABLE_DEBUG_LOG is not set
+# CONFIG_RMT_ISR_IRAM_SAFE is not set
 # end of ESP-Driver:RMT Configurations
 
 #
@@ -877,12 +906,28 @@ CONFIG_SPI_SLAVE_ISR_IN_IRAM=y
 # CONFIG_TEMP_SENSOR_ENABLE_DEBUG_LOG is not set
 # end of ESP-Driver:Temperature Sensor Configurations
 
+#
+# ESP-Driver:TWAI Configurations
+#
+# CONFIG_TWAI_ISR_IN_IRAM is not set
+# CONFIG_TWAI_ISR_CACHE_SAFE is not set
+# CONFIG_TWAI_ENABLE_DEBUG_LOG is not set
+# end of ESP-Driver:TWAI Configurations
+
 #
 # ESP-Driver:UART Configurations
 #
 # CONFIG_UART_ISR_IN_IRAM is not set
 # end of ESP-Driver:UART Configurations
 
+#
+# ESP-Driver:UHCI Configurations
+#
+# CONFIG_UHCI_ISR_HANDLER_IN_IRAM is not set
+# CONFIG_UHCI_ISR_CACHE_SAFE is not set
+# CONFIG_UHCI_ENABLE_DEBUG_LOG is not set
+# end of ESP-Driver:UHCI Configurations
+
 #
 # ESP-Driver:USB Serial/JTAG Configuration
 #
@@ -1032,16 +1077,18 @@ CONFIG_RTC_CLK_CAL_CYCLES=1024
 #
 # Peripheral Control
 #
-# CONFIG_PERIPH_CTRL_FUNC_IN_IRAM is not set
+CONFIG_ESP_PERIPH_CTRL_FUNC_IN_IRAM=y
+CONFIG_ESP_REGI2C_CTRL_FUNC_IN_IRAM=y
 # end of Peripheral Control
 
 #
 # GDMA Configurations
 #
 CONFIG_GDMA_CTRL_FUNC_IN_IRAM=y
-# CONFIG_GDMA_ISR_IRAM_SAFE is not set
+CONFIG_GDMA_ISR_HANDLER_IN_IRAM=y
 CONFIG_GDMA_OBJ_DRAM_SAFE=y
 # CONFIG_GDMA_ENABLE_DEBUG_LOG is not set
+# CONFIG_GDMA_ISR_IRAM_SAFE is not set
 # end of GDMA Configurations
 
 #
@@ -1072,6 +1119,7 @@ CONFIG_ESP_BROWNOUT_USE_INTR=y
 # end of Power Supplier
 
 CONFIG_ESP_SPI_BUS_LOCK_ISR_FUNCS_IN_IRAM=y
+CONFIG_ESP_INTR_IN_IRAM=y
 # end of Hardware Settings
 
 #
@@ -1123,15 +1171,19 @@ CONFIG_ESP_PHY_RF_CAL_PARTIAL=y
 # CONFIG_ESP_PHY_RF_CAL_NONE is not set
 # CONFIG_ESP_PHY_RF_CAL_FULL is not set
 CONFIG_ESP_PHY_CALIBRATION_MODE=0
+CONFIG_ESP_PHY_PLL_TRACK_PERIOD_MS=1000
 # CONFIG_ESP_PHY_PLL_TRACK_DEBUG is not set
 # CONFIG_ESP_PHY_RECORD_USED_TIME is not set
+CONFIG_ESP_PHY_IRAM_OPT=y
+# CONFIG_ESP_PHY_DEBUG is not set
 # end of PHY
 
 #
 # Power Management
 #
+CONFIG_PM_SLEEP_FUNC_IN_IRAM=y
 # CONFIG_PM_ENABLE is not set
-# CONFIG_PM_SLP_IRAM_OPT is not set
+CONFIG_PM_SLP_IRAM_OPT=y
 CONFIG_PM_POWER_DOWN_CPU_IN_LIGHT_SLEEP=y
 CONFIG_PM_RESTORE_CACHE_TAGMEM_AFTER_LIGHT_SLEEP=y
 # end of Power Management
@@ -1148,6 +1200,12 @@ CONFIG_PM_RESTORE_CACHE_TAGMEM_AFTER_LIGHT_SLEEP=y
 # CONFIG_RINGBUF_PLACE_FUNCTIONS_INTO_FLASH is not set
 # end of ESP Ringbuf
 
+#
+# ESP-ROM
+#
+CONFIG_ESP_ROM_PRINT_IN_IRAM=y
+# end of ESP-ROM
+
 #
 # ESP Security Specific
 #
@@ -1200,6 +1258,7 @@ CONFIG_ESP32S3_DATA_CACHE_LINE_SIZE=32
 CONFIG_ESP32S3_TRACEMEM_RESERVE_DRAM=0x0
 # end of Trace memory
 
+CONFIG_ESP_SYSTEM_IN_IRAM=y
 # CONFIG_ESP_SYSTEM_PANIC_PRINT_HALT is not set
 CONFIG_ESP_SYSTEM_PANIC_PRINT_REBOOT=y
 # CONFIG_ESP_SYSTEM_PANIC_SILENT_REBOOT is not set
@@ -1254,6 +1313,7 @@ CONFIG_ESP_SYSTEM_BBPLL_RECALIB=y
 #
 # IPC (Inter-Processor Call)
 #
+CONFIG_ESP_IPC_ENABLE=y
 CONFIG_ESP_IPC_TASK_STACK_SIZE=1280
 CONFIG_ESP_IPC_USES_CALLERS_PRIORITY=y
 CONFIG_ESP_IPC_ISR_ENABLE=y
@@ -1262,6 +1322,7 @@ CONFIG_ESP_IPC_ISR_ENABLE=y
 #
 # ESP Timer (High Resolution Timer)
 #
+CONFIG_ESP_TIMER_IN_IRAM=y
 # CONFIG_ESP_TIMER_PROFILING is not set
 CONFIG_ESP_TIME_FUNCS_USE_RTC_TIMER=y
 CONFIG_ESP_TIME_FUNCS_USE_ESP_TIMER=y
@@ -1304,10 +1365,12 @@ CONFIG_ESP_WIFI_IRAM_OPT=y
 CONFIG_ESP_WIFI_RX_IRAM_OPT=y
 CONFIG_ESP_WIFI_ENABLE_WPA3_SAE=y
 CONFIG_ESP_WIFI_ENABLE_SAE_PK=y
+CONFIG_ESP_WIFI_ENABLE_SAE_H2E=y
 CONFIG_ESP_WIFI_SOFTAP_SAE_SUPPORT=y
 CONFIG_ESP_WIFI_ENABLE_WPA3_OWE_STA=y
 # CONFIG_ESP_WIFI_SLP_IRAM_OPT is not set
 CONFIG_ESP_WIFI_SLP_DEFAULT_MIN_ACTIVE_TIME=50
+# CONFIG_ESP_WIFI_BSS_MAX_IDLE_SUPPORT is not set
 CONFIG_ESP_WIFI_SLP_DEFAULT_MAX_ACTIVE_TIME=10
 CONFIG_ESP_WIFI_SLP_DEFAULT_WAIT_BROADCAST_DATA_TIME=15
 # CONFIG_ESP_WIFI_FTM_ENABLE is not set
@@ -1391,6 +1454,14 @@ CONFIG_FATFS_VFS_FSTAT_BLKSIZE=0
 # CONFIG_FATFS_IMMEDIATE_FSYNC is not set
 # CONFIG_FATFS_USE_LABEL is not set
 CONFIG_FATFS_LINK_LOCK=y
+# CONFIG_FATFS_USE_DYN_BUFFERS is not set
+
+#
+# File system free space calculation behavior
+#
+CONFIG_FATFS_DONT_TRUST_FREE_CLUSTER_CNT=0
+CONFIG_FATFS_DONT_TRUST_LAST_ALLOC=0
+# end of File system free space calculation behavior
 # end of FAT Filesystem support
 
 #
@@ -1461,6 +1532,7 @@ CONFIG_FREERTOS_DEBUG_OCDAWARE=y
 CONFIG_FREERTOS_ENABLE_TASK_SNAPSHOT=y
 CONFIG_FREERTOS_PLACE_SNAPSHOT_FUNS_INTO_FLASH=y
 CONFIG_FREERTOS_NUMBER_OF_CORES=2
+CONFIG_FREERTOS_IN_IRAM=y
 # end of FreeRTOS
 
 #
@@ -1532,6 +1604,15 @@ CONFIG_LOG_TAG_LEVEL_IMPL_CACHE_SIZE=31
 CONFIG_LOG_TIMESTAMP_SOURCE_RTOS=y
 # CONFIG_LOG_TIMESTAMP_SOURCE_SYSTEM is not set
 # end of Format
+
+#
+# Settings
+#
+CONFIG_LOG_MODE_TEXT_EN=y
+CONFIG_LOG_MODE_TEXT=y
+# end of Settings
+
+CONFIG_LOG_IN_IRAM=y
 # end of Log
 
 #
@@ -1575,7 +1656,7 @@ CONFIG_LWIP_DHCP_DOES_ARP_CHECK=y
 # CONFIG_LWIP_DHCP_DISABLE_CLIENT_ID is not set
 CONFIG_LWIP_DHCP_DISABLE_VENDOR_CLASS_ID=y
 # CONFIG_LWIP_DHCP_RESTORE_LAST_IP is not set
-CONFIG_LWIP_DHCP_OPTIONS_LEN=68
+CONFIG_LWIP_DHCP_OPTIONS_LEN=69
 CONFIG_LWIP_NUM_NETIF_CLIENT_DATA=0
 CONFIG_LWIP_DHCP_COARSE_TIMER_SECS=1
 
@@ -1705,6 +1786,9 @@ CONFIG_LWIP_HOOK_ND6_GET_GW_NONE=y
 CONFIG_LWIP_HOOK_IP6_SELECT_SRC_ADDR_NONE=y
 # CONFIG_LWIP_HOOK_IP6_SELECT_SRC_ADDR_DEFAULT is not set
 # CONFIG_LWIP_HOOK_IP6_SELECT_SRC_ADDR_CUSTOM is not set
+CONFIG_LWIP_HOOK_DHCP_EXTRA_OPTION_NONE=y
+# CONFIG_LWIP_HOOK_DHCP_EXTRA_OPTION_DEFAULT is not set
+# CONFIG_LWIP_HOOK_DHCP_EXTRA_OPTION_CUSTOM is not set
 CONFIG_LWIP_HOOK_NETCONN_EXT_RESOLVE_NONE=y
 # CONFIG_LWIP_HOOK_NETCONN_EXT_RESOLVE_DEFAULT is not set
 # CONFIG_LWIP_HOOK_NETCONN_EXT_RESOLVE_CUSTOM is not set
@@ -1738,6 +1822,7 @@ CONFIG_MBEDTLS_SSL_OUT_CONTENT_LEN=4096
 # CONFIG_MBEDTLS_X509_TRUSTED_CERT_CALLBACK is not set
 # CONFIG_MBEDTLS_SSL_CONTEXT_SERIALIZATION is not set
 CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE=y
+# CONFIG_MBEDTLS_SSL_KEYING_MATERIAL_EXPORT is not set
 CONFIG_MBEDTLS_PKCS7_C=y
 # end of mbedTLS v3.x related
 
@@ -1771,6 +1856,7 @@ CONFIG_MBEDTLS_HAVE_TIME=y
 # CONFIG_MBEDTLS_PLATFORM_TIME_ALT is not set
 # CONFIG_MBEDTLS_HAVE_TIME_DATE is not set
 CONFIG_MBEDTLS_ECDSA_DETERMINISTIC=y
+CONFIG_MBEDTLS_SHA1_C=y
 CONFIG_MBEDTLS_SHA512_C=y
 # CONFIG_MBEDTLS_SHA3_C is not set
 CONFIG_MBEDTLS_TLS_SERVER_AND_CLIENT=y
@@ -1852,6 +1938,7 @@ CONFIG_MBEDTLS_ECP_NIST_OPTIM=y
 # CONFIG_MBEDTLS_THREADING_C is not set
 CONFIG_MBEDTLS_ERROR_STRINGS=y
 CONFIG_MBEDTLS_FS_IO=y
+# CONFIG_MBEDTLS_ALLOW_WEAK_CERTIFICATE_VERIFICATION is not set
 # end of mbedTLS
 
 #
@@ -1874,6 +1961,7 @@ CONFIG_MQTT_TRANSPORT_WEBSOCKET_SECURE=y
 # LibC
 #
 CONFIG_LIBC_NEWLIB=y
+CONFIG_LIBC_MISC_IN_IRAM=y
 CONFIG_LIBC_LOCKS_PLACE_IN_IRAM=y
 CONFIG_LIBC_STDOUT_LINE_ENDING_CRLF=y
 # CONFIG_LIBC_STDOUT_LINE_ENDING_LF is not set
@@ -1992,13 +2080,13 @@ CONFIG_SPI_FLASH_WRITE_CHUNK_SIZE=8192
 #
 # Auto-detect flash chips
 #
-CONFIG_SPI_FLASH_VENDOR_XMC_SUPPORTED=y
+CONFIG_SPI_FLASH_VENDOR_XMC_SUPPORT_ENABLED=y
-CONFIG_SPI_FLASH_VENDOR_GD_SUPPORTED=y
+CONFIG_SPI_FLASH_VENDOR_GD_SUPPORT_ENABLED=y
-CONFIG_SPI_FLASH_VENDOR_ISSI_SUPPORTED=y
+CONFIG_SPI_FLASH_VENDOR_ISSI_SUPPORT_ENABLED=y
-CONFIG_SPI_FLASH_VENDOR_MXIC_SUPPORTED=y
+CONFIG_SPI_FLASH_VENDOR_MXIC_SUPPORT_ENABLED=y
-CONFIG_SPI_FLASH_VENDOR_WINBOND_SUPPORTED=y
+CONFIG_SPI_FLASH_VENDOR_WINBOND_SUPPORT_ENABLED=y
-CONFIG_SPI_FLASH_VENDOR_BOYA_SUPPORTED=y
+CONFIG_SPI_FLASH_VENDOR_BOYA_SUPPORT_ENABLED=y
-CONFIG_SPI_FLASH_VENDOR_TH_SUPPORTED=y
+CONFIG_SPI_FLASH_VENDOR_TH_SUPPORT_ENABLED=y
 CONFIG_SPI_FLASH_SUPPORT_ISSI_CHIP=y
 CONFIG_SPI_FLASH_SUPPORT_MXIC_CHIP=y
 CONFIG_SPI_FLASH_SUPPORT_GD_CHIP=y
@@ -2081,6 +2169,7 @@ CONFIG_UNITY_ENABLE_DOUBLE=y
 CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER=y
 # CONFIG_UNITY_ENABLE_FIXTURE is not set
 # CONFIG_UNITY_ENABLE_BACKTRACE_ON_FAIL is not set
+# CONFIG_UNITY_TEST_ORDER_BY_FILE_PATH_AND_LINE is not set
 # end of Unity unit testing library
 
 #
@@ -2158,10 +2247,10 @@ CONFIG_WIFI_PROV_STA_ALL_CHANNEL_SCAN=y
 # CONFIG_LOG_BOOTLOADER_LEVEL_NONE is not set
 # CONFIG_LOG_BOOTLOADER_LEVEL_ERROR is not set
 # CONFIG_LOG_BOOTLOADER_LEVEL_WARN is not set
-CONFIG_LOG_BOOTLOADER_LEVEL_INFO=y
+# CONFIG_LOG_BOOTLOADER_LEVEL_INFO is not set
-# CONFIG_LOG_BOOTLOADER_LEVEL_DEBUG is not set
+CONFIG_LOG_BOOTLOADER_LEVEL_DEBUG=y
 # CONFIG_LOG_BOOTLOADER_LEVEL_VERBOSE is not set
-CONFIG_LOG_BOOTLOADER_LEVEL=3
+CONFIG_LOG_BOOTLOADER_LEVEL=4
 # CONFIG_FLASH_ENCRYPTION_ENABLED is not set
 # CONFIG_FLASHMODE_QIO is not set
 # CONFIG_FLASHMODE_QOUT is not set
@@ -2188,9 +2277,9 @@ CONFIG_ESP32_APPTRACE_DEST_NONE=y
 CONFIG_ESP32_APPTRACE_LOCK_ENABLE=y
 # CONFIG_EXTERNAL_COEX_ENABLE is not set
 # CONFIG_ESP_WIFI_EXTERNAL_COEXIST_ENABLE is not set
+# CONFIG_CAM_CTLR_DVP_CAM_ISR_IRAM_SAFE is not set
 # CONFIG_GPTIMER_ISR_IRAM_SAFE is not set
-# CONFIG_MCPWM_ISR_IN_IRAM is not set
+# CONFIG_MCPWM_ISR_IRAM_SAFE is not set
-# CONFIG_RMT_ISR_IRAM_SAFE is not set
 # CONFIG_EVENT_LOOP_PROFILING is not set
 CONFIG_POST_EVENTS_FROM_ISR=y
 CONFIG_POST_EVENTS_FROM_IRAM_ISR=y
@@ -2205,6 +2294,7 @@ CONFIG_ESP32S3_RTC_CLK_SRC_INT_RC=y
 # CONFIG_ESP32S3_RTC_CLK_SRC_EXT_OSC is not set
 # CONFIG_ESP32S3_RTC_CLK_SRC_INT_8MD256 is not set
 CONFIG_ESP32S3_RTC_CLK_CAL_CYCLES=1024
+CONFIG_PERIPH_CTRL_FUNC_IN_IRAM=y
 CONFIG_BROWNOUT_DET=y
 CONFIG_ESP32S3_BROWNOUT_DET=y
 CONFIG_BROWNOUT_DET_LVL_SEL_7=y

sdkconfig.old

@@ -436,10 +436,10 @@ CONFIG_BOOTLOADER_LOG_VERSION=1
 # CONFIG_BOOTLOADER_LOG_LEVEL_NONE is not set
 # CONFIG_BOOTLOADER_LOG_LEVEL_ERROR is not set
 # CONFIG_BOOTLOADER_LOG_LEVEL_WARN is not set
-CONFIG_BOOTLOADER_LOG_LEVEL_INFO=y
+# CONFIG_BOOTLOADER_LOG_LEVEL_INFO is not set
-# CONFIG_BOOTLOADER_LOG_LEVEL_DEBUG is not set
+CONFIG_BOOTLOADER_LOG_LEVEL_DEBUG=y
 # CONFIG_BOOTLOADER_LOG_LEVEL_VERBOSE is not set
-CONFIG_BOOTLOADER_LOG_LEVEL=3
+CONFIG_BOOTLOADER_LOG_LEVEL=4
 
 #
 # Format
@@ -548,14 +548,14 @@ CONFIG_ESPTOOLPY_FLASHFREQ_80M=y
 # CONFIG_ESPTOOLPY_FLASHFREQ_20M is not set
 CONFIG_ESPTOOLPY_FLASHFREQ="80m"
 # CONFIG_ESPTOOLPY_FLASHSIZE_1MB is not set
-CONFIG_ESPTOOLPY_FLASHSIZE_2MB=y
+# CONFIG_ESPTOOLPY_FLASHSIZE_2MB is not set
-# CONFIG_ESPTOOLPY_FLASHSIZE_4MB is not set
+CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
 # CONFIG_ESPTOOLPY_FLASHSIZE_8MB is not set
 # CONFIG_ESPTOOLPY_FLASHSIZE_16MB is not set
 # CONFIG_ESPTOOLPY_FLASHSIZE_32MB is not set
 # CONFIG_ESPTOOLPY_FLASHSIZE_64MB is not set
 # CONFIG_ESPTOOLPY_FLASHSIZE_128MB is not set
-CONFIG_ESPTOOLPY_FLASHSIZE="2MB"
+CONFIG_ESPTOOLPY_FLASHSIZE="4MB"
 # CONFIG_ESPTOOLPY_HEADER_FLASHSIZE_UPDATE is not set
 CONFIG_ESPTOOLPY_BEFORE_RESET=y
 # CONFIG_ESPTOOLPY_BEFORE_NORESET is not set
@@ -1499,17 +1499,20 @@ CONFIG_LOG_VERSION=1
 #
 # Log Level
 #
-# CONFIG_LOG_DEFAULT_LEVEL_NONE is not set
+CONFIG_LOG_DEFAULT_LEVEL_NONE=y
 # CONFIG_LOG_DEFAULT_LEVEL_ERROR is not set
 # CONFIG_LOG_DEFAULT_LEVEL_WARN is not set
-CONFIG_LOG_DEFAULT_LEVEL_INFO=y
+# CONFIG_LOG_DEFAULT_LEVEL_INFO is not set
 # CONFIG_LOG_DEFAULT_LEVEL_DEBUG is not set
 # CONFIG_LOG_DEFAULT_LEVEL_VERBOSE is not set
-CONFIG_LOG_DEFAULT_LEVEL=3
+CONFIG_LOG_DEFAULT_LEVEL=0
 CONFIG_LOG_MAXIMUM_EQUALS_DEFAULT=y
+# CONFIG_LOG_MAXIMUM_LEVEL_ERROR is not set
+# CONFIG_LOG_MAXIMUM_LEVEL_WARN is not set
+# CONFIG_LOG_MAXIMUM_LEVEL_INFO is not set
 # CONFIG_LOG_MAXIMUM_LEVEL_DEBUG is not set
 # CONFIG_LOG_MAXIMUM_LEVEL_VERBOSE is not set
-CONFIG_LOG_MAXIMUM_LEVEL=3
+CONFIG_LOG_MAXIMUM_LEVEL=0
 
 #
 # Level Settings