Makefile

@@ -49,12 +49,6 @@ flashCluster:
 monitorMini:
 	idf.py monitor -p /dev/ttyACM0 
 
-monitorMini1:
-	idf.py monitor -p /dev/ttyACM1 
-
-monitorMini2:
-	idf.py monitor -p /dev/ttyACM2 
-
 flash0:
 	idf.py flash -p /dev/ttyUSB0
 
@@ -72,6 +66,3 @@ monitor1:
 
 monitor2:
 	idf.py monitor -p /dev/ttyUSB2
-
-flash_second_ota:
-	parttool.py --port /dev/ttyACM0 write_partition --partition-name="ota_1" --input build/espAlox.bin

goTool/main.go

@@ -6,9 +6,7 @@ import (
 	"flag"
 	"fmt"
 	"log"
-	"math"
 	"os"
-	"strconv"
 	"time"
 
 	"github.com/pterm/pterm"
@@ -19,17 +17,15 @@ type ParserState int
 
 const (
 	// MISC
-	UART_ECHO         = 0x01
+	UART_ECHO        = 0x01
-	UART_VERSION      = 0x02
+	UART_VERSION     = 0x02
-	UART_CLIENT_INFO  = 0x03
+	UART_CLIENT_INFO = 0x03
-	UART_CLIENT_INPUT = 0x04
 
 	// OTA
-	UART_OTA_START        = 0x10
+	UART_OTA_START   = 0x10
-	UART_OTA_PAYLOAD      = 0x11
+	UART_OTA_PAYLOAD = 0x11
-	UART_OTA_END          = 0x12
+	UART_OTA_END     = 0x12
-	UART_OTA_STATUS       = 0x13
+	UART_OTA_STATUS  = 0x13
-	UART_OTA_START_ESPNOW = 0x14
 )
 
 const (
@@ -202,63 +198,30 @@ func parse_uart_client_info_payload(payloadBuffer []byte, payload_len int) {
 	}
 }
 
-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):
+		break
 	case UART_VERSION:
 		parse_uart_version_payload(mr.parsed_message, mr.write_index)
+		break
 	case UART_CLIENT_INFO:
 		parse_uart_client_info_payload(mr.parsed_message, mr.write_index)
+		break
 	case UART_OTA_START:
 		OTA_UpdateHandler.NewOTAMessage <- mr
+		break
 	case UART_OTA_PAYLOAD:
 		parse_uart_ota_payload_payload(mr.parsed_message, mr.write_index)
 		OTA_UpdateHandler.NewOTAMessage <- mr
+		break
 	case UART_OTA_END:
 		OTA_UpdateHandler.NewOTAMessage <- mr
+		break
 	case UART_OTA_STATUS:
 		OTA_UpdateHandler.NewOTAMessage <- mr
-	case UART_CLIENT_INPUT:
+		break
-		parse_uart_client_input(mr.parsed_message, mr.write_index)
 	}
 }
 
@@ -276,6 +239,7 @@ func parseByte(mr *MessageReceive, pbyte byte) {
 			addByteToRawBuffer(mr, pbyte)
 		}
 		// ignore every other byte
+		break
 	case GET_MESSAGE_ID:
 		if pbyte == ESCAPE_BYTE {
 			mr.state = ESCAPED_MESSAGE_ID
@@ -283,9 +247,11 @@ func parseByte(mr *MessageReceive, pbyte byte) {
 			addByteToParsedBuffer(mr, pbyte)
 			mr.state = IN_PAYLOD
 		}
+		break
 	case ESCAPED_MESSAGE_ID:
 		addByteToParsedBuffer(mr, pbyte)
 		mr.state = IN_PAYLOD
+		break
 	case IN_PAYLOD:
 		if pbyte == ESCAPE_BYTE {
 			mr.state = ESCAPED_PAYLOAD_BYTE
@@ -310,9 +276,11 @@ func parseByte(mr *MessageReceive, pbyte byte) {
 		}
 		// normal case
 		addByteToParsedBuffer(mr, pbyte)
+		break
 	case ESCAPED_PAYLOAD_BYTE:
 		addByteToParsedBuffer(mr, pbyte)
 		mr.state = IN_PAYLOD
+		break
 	default:
 		panic(fmt.Sprintf("unexpected main.ParserState: %#v", mr.state))
 	}
@@ -485,11 +453,9 @@ func main() {
 
 	for {
 		var input string
-		var input2 string
+		_, err := fmt.Scanln(&input)
-		_, err := fmt.Scanln(&input, &input2)
 		if err != nil {
-			log.Fatalf("Could not read from stdin %v", err)
+			log.Fatalf("Could not read from stdin")
-			return
 		}
 		fmt.Printf("Input %v", input)
 
@@ -502,24 +468,28 @@ func main() {
 			payload_buffer[0] = UART_ECHO
 			n := buildMessage(payload_buffer, 1, send_buffer)
 			sendMessage(port, send_buffer[:n])
+			break
 		case "2":
 			payload_buffer := make([]byte, 1024)
 			send_buffer := make([]byte, 1024)
 			payload_buffer[0] = UART_VERSION
 			n := buildMessage(payload_buffer, 1, send_buffer)
 			sendMessage(port, send_buffer[:n])
+			break
 		case "3":
 			payload_buffer := make([]byte, 1024)
 			send_buffer := make([]byte, 1024)
 			payload_buffer[0] = UART_CLIENT_INFO
 			n := buildMessage(payload_buffer, 1, send_buffer)
 			sendMessage(port, send_buffer[:n])
+			break
 		case "4": // start update
 			payload_buffer := make([]byte, 1024)
 			send_buffer := make([]byte, 1024)
 			payload_buffer[0] = UART_OTA_START
 			n := buildMessage(payload_buffer, 1, send_buffer)
 			sendMessage(port, send_buffer[:n])
+			break
 		case "5": // send payload
 			payload_buffer := make([]byte, 1024)
 			send_buffer := make([]byte, 1024)
@@ -529,25 +499,8 @@ func main() {
 			}
 			n := buildMessage(payload_buffer, 201, send_buffer)
 			sendMessage(port, send_buffer[:n])
+			break
 		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")
 		}

main/client_handler.c

@@ -1,7 +1,6 @@
 #include "client_handler.h"
-
+#include "communication_handler.h"
 #include "esp_log.h"
-#include "freertos/task.h"
 #include <stdbool.h>
 #include <stdint.h>
 #include <string.h>
@@ -41,8 +40,6 @@ int add_client(ClientList *list, const uint8_t *client_mac) {
 
   list->Clients[slot].slotIsUsed = true;
   list->Clients[slot].isAvailable = true;
-  list->Clients[slot].last_seen = xTaskGetTickCount();
-  list->Clients[slot].retry_counter = 0;
   memcpy(list->Clients[slot].macAddr, client_mac, MAC_LENGTH);
   list->ClientCount++;
   return CLIENT_OK;

main/client_handler.h

@@ -21,16 +21,6 @@ enum ClientErrors {
   CLIENT_INVALID_ID = -4,
 };
 
-typedef enum {
-  OTA_IDLE,
-  OTA_AWAITING_ACK,
-  OTA_PREPARING,
-  OTA_READY,
-  OTA_UPDATING,
-  OTA_FAILED,
-  OTA_SUCCESS,
-} ota_status_t;
-
 typedef struct {
   bool slotIsUsed;
   bool isAvailable;
@@ -39,12 +29,6 @@ typedef struct {
   TickType_t lastSuccessfullPing;
   TickType_t lastPing;
   uint16_t clientVersion;
-  ota_status_t ota_status;
-  uint16_t current_block_id;
-  uint32_t chunk_bitmask;
-  uint32_t resent_chunks_counter;
-  uint8_t retry_counter;
-  TickType_t last_seen;
 } ClientInfo;
 
 typedef struct {

main/communication_handler.c

@@ -1,28 +1,19 @@
-#include "communication_handler.h"
 #include "esp_err.h"
 #include "esp_log.h"
 #include "esp_now.h"
-#include "esp_ota_ops.h"
-#include "esp_partition.h"
 #include "esp_timer.h"
 #include "freertos/idf_additions.h"
-#include "freertos/task.h"
-#include "message_structs.h"
-#include "ota_update.h"
 
 #include "client_handler.h"
+#include "communication_handler.h"
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 
-uint8_t broadcast_address[ESP_NOW_ETH_ALEN] = {0xFF, 0xFF, 0xFF,
-                                               0xFF, 0xFF, 0xFF};
-
 static const char *TAG = "ALOX - COM";
 
-static QueueHandle_t messageQueue = NULL;
 static struct ESP_MessageBroker mr;
 static QueueHandle_t ESP_recieved_message_queue;
 
@@ -71,6 +62,7 @@ void ESP_MessageBrokerTask(void *param) {
   ESP_MessageBrokerTaskParams_t *task_params =
       (ESP_MessageBrokerTaskParams_t *)param;
 
+  // Extrahiere die einzelnen Parameter
   QueueHandle_t msg_queue = task_params->message_queue;
 
   if (msg_queue == NULL) {
@@ -83,23 +75,40 @@ void ESP_MessageBrokerTask(void *param) {
   while (1) {
     if (xQueueReceive(msg_queue, &received_msg, portMAX_DELAY)) {
 
+      ESP_LOGI(TAG, "Broker got message trying to relay it now");
       const BaseMessage *message = (const BaseMessage *)received_msg.data;
-      for (int i = 0; i < mr.num_direct_callbacks; i++) {
+      ESP_LOGI(TAG, "Broker searching for command page %d",
+               message->commandPage);
+      for (int i = 0; i < mr.num_direct_callbacks;
+           i++) { // TODO: there should not be a loop needed here
         if (mr.FunctionList[i].MSGID == message->commandPage) {
           mr.FunctionList[i].callback(&received_msg.esp_now_info,
                                       received_msg.data, received_msg.data_len);
+          ESP_LOGI(TAG, "Broker found matching msgid %d",
+                   mr.FunctionList[i].MSGID);
           free_ESPNOW_MessageInfo(&received_msg);
         }
       }
+      for (int i = 0; i < mr.num_direct_callbacks; i++) {
+        // if (mr.FunctionList[i].MSGID == received_msg.msgid) {
+        //  TODO: Not yet implemented
+        //  Only send data to task, task should be created beforhead and wait
+        //  for new data in the queue.
+        //}
+      }
     }
   }
 }
 
+QueueHandle_t messageQueue = NULL; // Warteschlange für empfangene Nachrichten
 static bool hasMaster = false;
 static ClientList *esp_client_list;
 static uint8_t channelNumber = 0;
 
+#define MAC_STRING_BUFFER_SIZE 18
+
 int init_com(ClientList *clients, uint8_t wifi_channel) {
+  // Initialisiere die Kommunikations-Warteschlange
   messageQueue = xQueueCreate(MESSAGE_QUEUE_SIZE, sizeof(ESPNOW_MessageInfo));
   if (messageQueue == NULL) {
     ESP_LOGE(TAG, "Message queue creation failed");
@@ -116,13 +125,13 @@ int add_peer(uint8_t *macAddr) {
   esp_now_peer_info_t peerInfo = {
       .channel = channelNumber,
       .ifidx = ESP_IF_WIFI_STA,
-      .encrypt = false,
+      .encrypt = false, // Keine Verschlüsselung // TODO: should be changed
   };
   memcpy(peerInfo.peer_addr, macAddr, ESP_NOW_ETH_ALEN);
 
   esp_err_t result = esp_now_add_peer(&peerInfo);
   if (result == ESP_OK) {
-    ESP_LOGI(TAG, "Peer added");
+    ESP_LOGI(TAG, "Peer added: " MACSTR, MAC2STR(peerInfo.peer_addr));
 
     if (!IS_BROADCAST_ADDR(macAddr)) {
       int ret = add_client(esp_client_list, peerInfo.peer_addr);
@@ -138,6 +147,7 @@ int add_peer(uint8_t *macAddr) {
     ESP_LOGW(TAG, "Peer already exists.");
     int id = get_client_id(esp_client_list, peerInfo.peer_addr);
     if (id >= 0) {
+      ESP_LOGI(TAG, "Client found again, welcome back!");
       esp_client_list->Clients[id].isAvailable = true;
     }
   } else {
@@ -170,6 +180,8 @@ void master_broadcast_task(void *param) {
 
     ESP_ERROR_CHECK(esp_now_send(broadcast_address, (uint8_t *)&message,
                                  sizeof(BaseMessage)));
+
+    // ESP_LOGI(TAG, "Broadcast Message sent");
     vTaskDelay(pdMS_TO_TICKS(5000));
   }
 }
@@ -182,6 +194,7 @@ void master_broadcast_ping(void *param) {
         MessageBuilder(PingPage, *(PayloadUnion *)&payload, sizeof(payload));
     ESP_ERROR_CHECK(esp_now_send(broadcast_address, (uint8_t *)&message,
                                  sizeof(BaseMessage)));
+    // ESP_LOGI(TAG, "Broadcast PING Message sent");
     vTaskDelay(pdMS_TO_TICKS(2500));
   }
 }
@@ -190,12 +203,15 @@ void master_ping_task(void *param) {
   while (1) {
     for (size_t i = 0; i < MAX_CLIENTS; i++) {
       if (esp_client_list->Clients[i].isAvailable) {
+        ESP_LOGI(TAG, "SEND PING TO %zu: " MACSTR, i,
+                 MAC2STR(esp_client_list->Clients[i].macAddr));
         PingPayload payload = {};
         payload.timestamp = esp_timer_get_time();
         BaseMessage message = MessageBuilder(
             PingPage, *(PayloadUnion *)&payload, sizeof(payload));
         esp_now_send(esp_client_list->Clients[i].macAddr, (uint8_t *)&message,
                      sizeof(BaseMessage));
+        ESP_LOGI(TAG, "SENDING PING!!!!");
       }
     }
     vTaskDelay(pdMS_TO_TICKS(1000));
@@ -205,7 +221,8 @@ void master_ping_task(void *param) {
 void master_StatusCallback(const esp_now_recv_info_t *esp_now_info,
                            const uint8_t *data, int data_len) {
   const BaseMessage *message = (const BaseMessage *)data;
-  ESP_LOGI(TAG, "SRC");
+
+  ESP_LOGI(TAG, "SRC " MACSTR, MAC2STR(esp_now_info->src_addr));
   ESP_LOGI(TAG,
            "Status Message Received: status: %d, runningPartition: %d, uptime: "
            "%d, version: %d",
@@ -218,45 +235,81 @@ void master_StatusCallback(const esp_now_recv_info_t *esp_now_info,
 void master_RegisterCallback(const esp_now_recv_info_t *esp_now_info,
                              const uint8_t *data, int data_len) {
   BaseMessage replyMessage = {};
+  const BaseMessage *message = (const BaseMessage *)data;
 
+  ESP_LOGI(TAG, "WILL REGISTER DEVICE");
   esp_now_peer_info_t checkPeerInfo;
   esp_err_t checkPeer =
       esp_now_get_peer(esp_now_info->src_addr, &checkPeerInfo);
   switch (checkPeer) {
   case (ESP_OK):
+    ESP_LOGI(TAG, "CLIENT BEKANNT");
     int id = get_client_id(esp_client_list, esp_now_info->src_addr);
     esp_client_list->Clients[id].isAvailable = true;
     esp_client_list->Clients[id].lastSuccessfullPing = xTaskGetTickCount();
+    ESP_LOGI(TAG, "Updated client %d last ping time to %lu", id,
+             esp_client_list->Clients[id].lastSuccessfullPing);
+    break;
+  case (ESP_ERR_ESPNOW_NOT_INIT):
+    ESP_LOGI(TAG, "Not initalised");
+    break;
+  case (ESP_ERR_ESPNOW_ARG):
+    ESP_LOGI(TAG, "ESP ERR ESPNOW_ARG");
     break;
   case (ESP_ERR_ESPNOW_NOT_FOUND):
-    add_peer(esp_now_info->src_addr);
+    ESP_LOGI(TAG, "CLIENT WIRD IN DIE LISTE AUFGENOMMEN " MACSTR,
+             MAC2STR(esp_now_info->src_addr));
+    int peer_err = add_peer(esp_now_info->src_addr);
+    if (peer_err < 0) {
+      ESP_LOGE(TAG, "Could not add ESP TO ClientList %d", peer_err);
+    }
+    ESP_LOGI(TAG, "FRAGE CLIENT STATUS AN");
+
     GetStatusPayload payload = {};
     replyMessage = MessageBuilder(GetStatusPage, *(PayloadUnion *)&payload,
                                   sizeof(payload));
-    esp_now_send(esp_now_info->src_addr, (uint8_t *)&replyMessage,
+    esp_err_t err = esp_now_send(esp_now_info->src_addr,
-                 sizeof(BaseMessage));
+                                 (uint8_t *)&replyMessage, sizeof(BaseMessage));
+    if (err != ESP_OK) {
+      ESP_LOGE(TAG, "Could not send Message Error %s", esp_err_to_name(err));
+    }
+
     break;
   default:
-    break;
+    ESP_LOGI(TAG, "Unknown Message %i", checkPeer);
   }
 }
 
 void master_pingCallback(const esp_now_recv_info_t *esp_now_info,
                          const uint8_t *data, int data_len) {
+  BaseMessage replyMessage = {};
   const BaseMessage *message = (const BaseMessage *)data;
 
+  ESP_LOGI(TAG, "GOT PING MESSAGE");
   uint32_t currentTime = esp_timer_get_time();
   uint32_t diff = currentTime - message->payload.ping_payload.timestamp;
 
+  ESP_LOGI(TAG, "Start: %lu, End: %lu, Diff: %lu, Ping: %lu",
+           message->payload.ping_payload.timestamp, currentTime, diff,
+           diff / 1000); // ping in ms
+
   int id = get_client_id(esp_client_list, esp_now_info->src_addr);
   if (id >= 0) {
     esp_client_list->Clients[id].lastSuccessfullPing = xTaskGetTickCount();
     esp_client_list->Clients[id].lastPing = (diff / 1000);
+    ESP_LOGI(TAG, "Updated client %d: " MACSTR " last ping time to %lu", id,
+             MAC2STR(esp_now_info->src_addr),
+             esp_client_list->Clients[id].lastSuccessfullPing);
   }
 }
 
 void master_broadcastCallback(const esp_now_recv_info_t *esp_now_info,
-                              const uint8_t *data, int data_len) {}
+                              const uint8_t *data, int data_len) {
+  ESP_LOGI(TAG,
+           "Master should not recieve Broadcast is there another master "
+           "Calling got message from " MACSTR,
+           MAC2STR(esp_now_info->src_addr));
+}
 
 void ESPNOW_RegisterMasterCallbacks() {
   ESP_RegisterFunction(StatusPage, master_StatusCallback);
@@ -267,22 +320,31 @@ void ESPNOW_RegisterMasterCallbacks() {
 
 void slave_broadcastCallback(const esp_now_recv_info_t *esp_now_info,
                              const uint8_t *data, int data_len) {
+  BaseMessage replyMessage = {};
+  const BaseMessage *message = (const BaseMessage *)data;
+
+  ESP_LOGI(TAG, "GOT BROADCAST MESSAGE");
   if (!hasMaster) {
     if (IS_BROADCAST_ADDR(esp_now_info->des_addr)) {
+      ESP_LOGI(TAG, "GOT BROADCAST MESSAGE ATTEMPTING TO REGISTER TO MASTER!");
       add_peer(esp_now_info->src_addr);
-      BaseMessage replyMessage = {};
       replyMessage =
-          MessageBuilder(RegisterPage, *(PayloadUnion *)&replyMessage.payload,
+          MessageBuilder(RegisterPage, *(PayloadUnion *)&message->payload,
-                         sizeof(replyMessage.payload));
+                         sizeof(message->payload));
-      esp_now_send(esp_now_info->src_addr, (uint8_t *)&replyMessage,
+      ESP_ERROR_CHECK(esp_now_send(esp_now_info->src_addr,
-                   sizeof(BaseMessage));
+                                   (uint8_t *)&replyMessage,
+                                   sizeof(BaseMessage)));
       hasMaster = true;
     }
+  } else {
+    ESP_LOGI(TAG, "Already have master wont register by the new one");
   }
 }
-
 void slave_getstatusCallback(const esp_now_recv_info_t *esp_now_info,
                              const uint8_t *data, int data_len) {
+  BaseMessage replyMessage = {};
+  const BaseMessage *message = (const BaseMessage *)data;
+
   StatusPayload payload = {
       .status = 1,
       .runningPartition = 1,
@@ -290,22 +352,24 @@ void slave_getstatusCallback(const esp_now_recv_info_t *esp_now_info,
       .version = 0x0002,
 
   };
-  BaseMessage replyMessage =
+  replyMessage =
       MessageBuilder(StatusPage, *(PayloadUnion *)&payload, sizeof(payload));
-  esp_now_send(esp_now_info->src_addr, (uint8_t *)&replyMessage,
+  ESP_ERROR_CHECK(esp_now_send(esp_now_info->src_addr, (uint8_t *)&replyMessage,
-               sizeof(BaseMessage));
+                               sizeof(BaseMessage)));
 }
-
 void slave_pingCallback(const esp_now_recv_info_t *esp_now_info,
                         const uint8_t *data, int data_len) {
   if (!hasMaster)
     return;
 
+  BaseMessage replyMessage = {};
   const BaseMessage *message = (const BaseMessage *)data;
-  BaseMessage replyMessage = MessageBuilder(
+
-      PingPage, *(PayloadUnion *)&message->payload, sizeof(message->payload));
+  ESP_LOGI(TAG, "GOT PING MESSAGE");
-  esp_now_send(esp_now_info->src_addr, (uint8_t *)&replyMessage,
+  replyMessage = MessageBuilder(PingPage, *(PayloadUnion *)&message->payload,
-               sizeof(BaseMessage));
+                                sizeof(message->payload));
+  ESP_ERROR_CHECK(esp_now_send(esp_now_info->src_addr, (uint8_t *)&replyMessage,
+                               sizeof(BaseMessage)));
 }
 
 void ESPNOW_RegisterSlaveCallbacks() {
@@ -316,23 +380,30 @@ void ESPNOW_RegisterSlaveCallbacks() {
 
 void master_receive_callback(const esp_now_recv_info_t *esp_now_info,
                              const uint8_t *data, int data_len) {
+  ESP_LOGI(TAG, "MASTER GOT MESSAGE");
+
+  // Allokiere Speicher für die Daten und kopiere sie
   uint8_t *copied_data = (uint8_t *)malloc(data_len);
   if (copied_data == NULL) {
+    ESP_LOGE(TAG, "Failed to allocate memory for message data.");
     return;
   }
   memcpy(copied_data, data, data_len);
 
+  // Fülle die neue Struktur mit kopierten Daten
   ESPNOW_MessageInfo msg_info;
   msg_info.esp_now_info.src_addr = malloc(6);
   if (msg_info.esp_now_info.src_addr) {
     memcpy(msg_info.esp_now_info.src_addr, esp_now_info->src_addr, 6);
   }
 
+  // Speicher für des_addr kopieren
   msg_info.esp_now_info.des_addr = malloc(6);
   if (msg_info.esp_now_info.des_addr) {
     memcpy(msg_info.esp_now_info.des_addr, esp_now_info->des_addr, 6);
   }
 
+  // rx_ctrl Struktur kopieren
   msg_info.esp_now_info.rx_ctrl = malloc(sizeof(wifi_pkt_rx_ctrl_t));
   if (msg_info.esp_now_info.rx_ctrl) {
     memcpy(msg_info.esp_now_info.rx_ctrl, esp_now_info->rx_ctrl,
@@ -342,47 +413,48 @@ void master_receive_callback(const esp_now_recv_info_t *esp_now_info,
   msg_info.data = copied_data;
   msg_info.data_len = data_len;
 
-  xQueueSend(ESP_recieved_message_queue, &msg_info, portMAX_DELAY);
+  if (xQueueSend(ESP_recieved_message_queue, &msg_info, portMAX_DELAY) !=
+      pdPASS) {
+    // Fehlerbehandlung: Queue voll oder Senden fehlgeschlagen
+    ESP_LOGE(TAG, "Failed to send parsed message to queue.");
+  }
+  return;
 }
 
 void client_receive_callback(const esp_now_recv_info_t *esp_now_info,
                              const uint8_t *data, int data_len) {
+  ESP_LOGI(TAG, "SLAVE GOT MESSAGE");
+  ESP_LOGI(TAG, "Received message from: " MACSTR,
+           MAC2STR(esp_now_info->src_addr));
+
   uint8_t *copied_data = (uint8_t *)malloc(data_len);
   if (copied_data == NULL) {
+    ESP_LOGE(TAG, "Failed to allocate memory for message data.");
     return;
   }
   memcpy(copied_data, data, data_len);
 
+  // Fülle die neue Struktur mit kopierten Daten
   ESPNOW_MessageInfo msg_info;
-  // Initialize the esp_now_info struct to zeros
+  memcpy(&msg_info.esp_now_info, esp_now_info, sizeof(esp_now_recv_info_t));
-  memset(&msg_info.esp_now_info, 0, sizeof(esp_now_recv_info_t));
-
-  // Now, allocate and copy the data pointed to by the pointers within
-  // esp_now_info src_addr
-  msg_info.esp_now_info.src_addr = malloc(6);
-  if (msg_info.esp_now_info.src_addr) {
-    memcpy(msg_info.esp_now_info.src_addr, esp_now_info->src_addr, 6);
-  } else {
-    free(copied_data);
-    return;
-  }
-
-  // des_addr
-  msg_info.esp_now_info.des_addr = malloc(6);
-  if (msg_info.esp_now_info.des_addr) {
-    memcpy(msg_info.esp_now_info.des_addr, esp_now_info->des_addr, 6);
-  } else {
-    free(msg_info.esp_now_info.src_addr);
-    free(copied_data);
-    return;
-  }
-
-  msg_info.esp_now_info.rx_ctrl = NULL; // Set to NULL as we are not copying it
-
   msg_info.data = copied_data;
   msg_info.data_len = data_len;
 
-  xQueueSend(ESP_recieved_message_queue, &msg_info, portMAX_DELAY);
+  if (xQueueSend(ESP_recieved_message_queue, &msg_info, portMAX_DELAY) !=
+      pdPASS) {
+    // Fehlerbehandlung: Queue voll oder Senden fehlgeschlagen
+    ESP_LOGE(TAG, "Failed to send parsed message to queue.");
+  }
+  return;
+}
+
+void client_data_sending_task(void *param) {
+  while (1) {
+    const char *dataToSend = "DATA:42";
+    ESP_LOGI(TAG, "SEND DATA");
+    esp_now_send(NULL, (uint8_t *)dataToSend, strlen(dataToSend));
+    vTaskDelay(pdMS_TO_TICKS(5000));
+  }
 }
 
 void client_monitor_task(void *pvParameters) {
@@ -399,34 +471,11 @@ void client_monitor_task(void *pvParameters) {
 
         if (time_diff > timeout_ticks) {
           esp_client_list->Clients[i].isAvailable = false;
+          ESP_LOGW(TAG, "Client %d (MAC: " MACSTR ") is unavailable",
+                   MAC2STR(esp_client_list->Clients[i].macAddr));
         }
       }
     }
     vTaskDelay(interval_ticks);
   }
 }
-
-const esp_partition_t *ota_update_partition = NULL;
-
-void ESPNOW_RegisterOTAMaster() {
-  // Observe this States for all Slaves in ClientList
-  // OTA_SLAVE_PREPARING
-  // OTA_SLAVE_READY
-  // OTA_SLAVE_ERROR
-  // OTA_SLAVE_WRITE_FINISHED
-  // OTA_SLAVE_FINISHED
-
-  ESP_RegisterFunction(OTA_PREPARE_ACKNOWLEDGED,
-                       master_ota_prepare_acknowledge_callback);
-  ESP_RegisterFunction(OTA_READY_TO_RECEIVE,
-                       master_ota_ready_to_recieve_callback);
-  ESP_RegisterFunction(OTA_UPDATE_SLAVE_ACKED,
-                       master_ota_update_slave_acknowledge_callback);
-}
-
-void ESPNOW_RegisterOTASlave() {
-  ESP_RegisterFunction(OTA_PREPARE_FOR_UPDATE, slave_Prep_Upgrade_Callback);
-  ESP_RegisterFunction(OTA_CHUNK, slave_Update_Chunk_Callback);
-
-  ESP_RegisterFunction(OTA_FINISH_UPDATE, slave_Update_Finished_Callback);
-}

main/communication_handler.h

@@ -12,30 +12,91 @@
 #include <stdio.h>
 #include <string.h>
 #include <sys/types.h>
-#include "esp_partition.h"
-#include "message_structs.h"
 
 #define BROADCAST_INTERVAL_MS 500
 
 #define CLIENT_TIMEOUT_MS 5000 // 5 Sekunden Timeout
 #define CHECK_INTERVAL_MS 1000 // Jede Sekunde überprüfen
+static uint8_t broadcast_address[ESP_NOW_ETH_ALEN] = {0xFF, 0xFF, 0xFF,
+                                                      0xFF, 0xFF, 0xFF};
+#define IS_BROADCAST_ADDR(addr)                                                \
+  (memcmp(addr, broadcast_address, ESP_NOW_ETH_ALEN) == 0)
 
-extern uint8_t broadcast_address[ESP_NOW_ETH_ALEN];
+#define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
-#define IS_BROADCAST_ADDR(addr) (memcmp(addr, broadcast_address, ESP_NOW_ETH_ALEN) == 0)
+#define MACSTR "%02X:%02X:%02X:%02X:%02X:%02X"
 
 #define MESSAGE_QUEUE_SIZE 10
 
+typedef enum {
+  OTA_PREP_UPGRADE,
+  OTA_SEND_PAYLOAD,
+  OTA_WRITE_UPDATE_BUFFER,
+  OTA_SEND_MISSING,
+  OTA_UPDATE_INFO,
+  OTA_END_UPGRADE,
+  StatusPage,
+  GetStatusPage,
+  ConfigPage,
+  PingPage,
+  BroadCastPage,
+  RegisterPage,
+} CommandPages;
+
+typedef struct __attribute__((packed)) {
+
+} OTA_PREP_UPGRADE_Payload;
+
+typedef struct __attribute__((packed)) {
+} OTA_SEND_PAYLOAD_Payload;
+typedef struct __attribute__((packed)) {
+} OTA_WRITE_UPDATE_BUFFER_Payload;
+typedef struct __attribute__((packed)) {
+} OTA_SEND_MISSING_Payload;
+typedef struct __attribute__((packed)) {
+} OTA_UPDATE_INFO_Payload;
+typedef struct __attribute__((packed)) {
+} OTA_END_UPGRADE_Payload;
+
+typedef struct __attribute__((packed)) {
+  uint16_t version; // software version
+  uint8_t runningPartition;
+  uint8_t status;
+  uint32_t uptime;
+} StatusPayload;
+
+typedef struct __attribute__((packed)) {
+} GetStatusPayload;
+
+typedef struct __attribute__((packed)) {
+  uint8_t timeslot;
+} ConfigPayload;
+
+typedef struct __attribute__((packed)) {
+  uint32_t timestamp;
+} PingPayload;
+
+typedef struct __attribute__((packed)) {
+} BroadCastPayload;
+
+typedef struct __attribute__((packed)) {
+  bool familierClient;
+} RegisterPayload;
+
+// TODO: Check checksum fields
+typedef struct __attribute__((packed)) {
+  uint16_t length;  // length of complete firmware
+  uint8_t checksum; // checksum of firmware
+} FirmwarePrepPayload;
+
+// TODO: Check checksum fields
+typedef struct __attribute__((packed)) {
+  uint8_t length;
+  uint8_t checksum;
+  uint32_t address;
+  uint8_t payload[240]; // TODO: need a way to figure out a safe value for this
+} FirmwarePayload;
+
 typedef union __attribute__((packed)) {
-  OTA_PREPARE_FOR_UPDATE_Payload ota_prepare_for_update_payload;
-  OTA_PREPARE_ACKNOWLEDGED_Payload ota_prepare_acknowledged_payload;
-  OTA_READY_TO_RECEIVE_Payload ota_ready_to_receive_payload;
-  OTA_CHUNK_Payload ota_chunk_payload;
-  OTA_REQUEST_BLOCK_STATUS_Payload ota_request_block_status_payload;
-  OTA_BLOCK_STATUS_REPORT_Payload ota_block_status_report_payload;
-  OTA_COMMIT_BLOCK_Payload ota_commit_block_payload;
-  OTA_BLOCK_COMMITTED_Payload ota_block_committed_payload;
-  OTA_FINISH_UPDATE_Payload ota_finish_update_payload;
-  OTA_UPDATE_STATUS_Payload ota_update_status_payload;
   StatusPayload status_payload;
   ConfigPayload config_payload;
   PingPayload ping_payload;
@@ -95,8 +156,6 @@ void ESP_MessageBrokerTask(void *param);
 
 void ESPNOW_RegisterMasterCallbacks();
 void ESPNOW_RegisterSlaveCallbacks();
-void ESPNOW_RegisterOTAMaster();
-void ESPNOW_RegisterOTASlave();
 
 int init_com(ClientList *clients, uint8_t wifi_channel);
 int getNextFreeClientId();
@@ -114,9 +173,6 @@ void client_receive_callback(const esp_now_recv_info_t *esp_now_info,
                              const uint8_t *data, int data_len);
 void client_data_sending_task(void *param);
 void client_send_random_data_task(void *param);
-
 void client_monitor_task(void *pvParameters);
 
-void send_ota_block_chunks(uint8_t client_id, uint16_t block_id);
-
 #endif

main/main.c

@@ -1,11 +1,7 @@
 #include "client_handler.h"
 #include "driver/gpio.h"
 #include "driver/uart.h"
-#include "esp_app_desc.h"
-#include "esp_app_format.h"
 #include "esp_err.h"
-#include "esp_flash_partitions.h"
-#include "esp_image_format.h"
 #include "esp_log.h"
 #include "esp_log_buffer.h"
 #include "esp_ota_ops.h"
@@ -25,11 +21,9 @@
 #include "main.h"
 #include "ota_update.h"
 #include "uart_handler.h"
-#include <math.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
-#include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 
@@ -40,72 +34,12 @@ static const char *TAG = "ALOX - MAIN";
 static const uint16_t version = 0x0001;
 static uint8_t send_message_buffer[1024];
 static uint8_t send_message_payload_buffer[512];
-uint32_t g_uart_firmware_total_size = 0;
 
 static MessageBrokerTaskParams_t broker_task_params;
-static MasterOTA_TaskParams_t master_ota_task_params;
 static ESP_MessageBrokerTaskParams_t esp_broker_task_params;
 
 ClientList clientList = {.Clients = {{0}}, .ClientCount = 0};
 
-size_t build_ClientInfoPart(uint8_t clientid, float_t lagex, float_t lagey,
-                            int32_t bitmask, uint8_t *outputArray,
-                            size_t outputArrayOffset, size_t outputArraySize) {
-
-  size_t offset = outputArrayOffset;
-  memcpy(&outputArray[offset], &clientid, sizeof(clientid));
-  offset += sizeof(clientid);
-
-  // lagex (typischerweise 4 Bytes)
-  memcpy(&outputArray[offset], &lagex, sizeof(lagex));
-  offset += sizeof(lagex);
-
-  // lagey (typischerweise 4 Bytes)
-  memcpy(&outputArray[offset], &lagey, sizeof(lagey));
-  offset += sizeof(lagey);
-
-  // bitmask (4 Bytes)
-  memcpy(&outputArray[offset], &bitmask, sizeof(bitmask));
-  offset += sizeof(bitmask);
-
-  return offset - outputArrayOffset;
-}
-
-void fakeDataCallback(uint8_t msgid, const uint8_t *payload, size_t payload_len,
-                      uint8_t *send_payload_buffer,
-                      size_t send_payload_buffer_size, uint8_t *send_buffer,
-                      size_t send_buffer_size) {
-
-  uint8_t seed = payload[1];
-  ESP_LOGI(TAG, "Sending Fake Client Infos with seed %d", seed);
-  srand(seed);
-
-  size_t offset = 1;
-  send_payload_buffer[0] = 3; // Client Count
-  offset +=
-      build_ClientInfoPart(1, rand() * 1.0, rand() * 1.0, rand() * 1,
-                           send_payload_buffer, 1, send_payload_buffer_size);
-  offset += build_ClientInfoPart(2, rand() * 2.0, rand() * 2.0, rand() * 2,
-                                 send_payload_buffer, offset,
-                                 send_payload_buffer_size);
-  offset += build_ClientInfoPart(3, rand() * 3.0, rand() * 3.0, rand() * 3,
-                                 send_payload_buffer, offset,
-                                 send_payload_buffer_size);
-
-  int len = build_message(UART_CLIENT_INPUT, send_payload_buffer, offset,
-                          send_buffer, send_buffer_size);
-
-  if (len < 0) {
-    ESP_LOGE(TAG,
-             "Error Building UART Message: payload_len, %d, sendbuffer_size: "
-             "%d, mes_len(error): %d",
-             payload_len, send_buffer_size, len);
-    return;
-  }
-
-  uart_write_bytes(MASTER_UART, send_buffer, len);
-}
-
 void echoCallback(uint8_t msgid, const uint8_t *payload, size_t payload_len,
                   uint8_t *send_payload_buffer, size_t send_payload_buffer_size,
                   uint8_t *send_buffer, size_t send_buffer_size) {
@@ -170,9 +104,27 @@ void clientInfoCallback(uint8_t msgid, const uint8_t *payload,
   send_payload_buffer[0] = clientList.ClientCount;
   uint8_t offsetMult = 0;
 
+  uint8_t used_slots = 0;
   for (int i = 0; i < MAX_CLIENTS; i++) {
     if (clientList.Clients[i].slotIsUsed) {
+      used_slots++;
+    }
+  }
+
+  uint8_t loop_sanity_counter = 0;
+
+  for (int i = 0; i < MAX_CLIENTS; i++) {
+    if (clientList.Clients[i].slotIsUsed) {
+      loop_sanity_counter++;
+      if (loop_sanity_counter > clientList.ClientCount) {
+        ESP_LOGE("SPECIAL",
+                 "ERROR SANITY CHECK FAILED: loop_sanity_count: %d, "
+                 "client_count: %d",
+                 loop_sanity_counter, clientList.ClientCount);
+      }
       size_t offset = 1 + (entryLength * offsetMult++);
+
+      ESP_LOGE("SPECIAL", "OFFSET %d", offset);
       send_payload_buffer[offset] = i;
       send_payload_buffer[offset + 1] = clientList.Clients[i].isAvailable;
       send_payload_buffer[offset + 2] = clientList.Clients[i].slotIsUsed;
@@ -190,6 +142,8 @@ void clientInfoCallback(uint8_t msgid, const uint8_t *payload,
   int len = build_message(UART_CLIENT_INFO, send_payload_buffer,
                           needed_buffer_size, send_buffer, send_buffer_size);
 
+  // ESP_LOG_BUFFER_HEX("SEND BUFFER: ", send_buffer, send_buffer_size);
+
   if (len < 0) {
     ESP_LOGE(TAG,
              "Error Building UART Message: payload_len, %d, sendbuffer_size: "
@@ -200,69 +154,6 @@ void clientInfoCallback(uint8_t msgid, const uint8_t *payload,
   uart_write_bytes(MASTER_UART, send_buffer, len);
 }
 
-bool g_ota_in_progress = false;
-
-void ota_monitor_task(void *param) {
-  const TickType_t timeout = pdMS_TO_TICKS(10000); // 10 seconds
-
-  while (g_ota_in_progress) {
-    bool all_done = true;
-    for (int i = 0; i < MAX_CLIENTS; i++) {
-      if (clientList.Clients[i].slotIsUsed) {
-        if (clientList.Clients[i].ota_status != OTA_SUCCESS &&
-            clientList.Clients[i].ota_status != OTA_FAILED) {
-          all_done = false;
-
-          if ((xTaskGetTickCount() - clientList.Clients[i].last_seen) >
-              timeout) {
-            ESP_LOGE(TAG, "Client %d timed out", i);
-            clientList.Clients[i].ota_status = OTA_FAILED;
-          }
-        }
-      }
-    }
-
-    if (all_done) {
-      g_ota_in_progress = false;
-    }
-
-    vTaskDelay(pdMS_TO_TICKS(1000));
-  }
-
-  ESP_LOGI(TAG, "OTA Operation Finished.");
-  for (int i = 0; i < MAX_CLIENTS; i++) {
-    if (clientList.Clients[i].slotIsUsed) {
-      ESP_LOGI(TAG, "Client %d [MAC: " MACSTR "]: %s, Resent Chunks: %d", i,
-               MAC2STR(clientList.Clients[i].macAddr),
-               clientList.Clients[i].ota_status == OTA_SUCCESS ? "SUCCESS"
-                                                               : "FAILED",
-               clientList.Clients[i].resent_chunks_counter);
-    }
-  }
-
-  vTaskDelete(NULL);
-}
-
-void send_client_ota_start_message(uint8_t clientID, uint32_t app_size) {
-  BaseMessage message = {};
-  OTA_PREPARE_FOR_UPDATE_Payload ota_payload = {
-      .total_size = app_size,
-  };
-  message = MessageBuilder(OTA_PREPARE_FOR_UPDATE,
-                           *(PayloadUnion *)&ota_payload, sizeof(ota_payload));
-
-  esp_err_t err = esp_now_send(clientList.Clients[clientID].macAddr,
-                               (uint8_t *)&message, sizeof(BaseMessage));
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "Could not send OTA PREPARE FOR UPDATE to " MACSTR ", %s",
-             MAC2STR(clientList.Clients[clientID].macAddr),
-             esp_err_to_name(err));
-  } else {
-    ESP_LOGI(TAG, "Sent OTA PREPARE FOR UPDATE to " MACSTR,
-             MAC2STR(clientList.Clients[clientID].macAddr));
-  }
-}
-
 void app_main(void) {
   ESP_LOGI(TAG, "Starting Alox Powerpod Version %d Build: %s", version,
            BUILD_GIT_HASH);
@@ -275,10 +166,12 @@ void app_main(void) {
   }
   ESP_ERROR_CHECK(ret);
 
+  // GPIO-Pin für Moduserkennung
   gpio_reset_pin(MASTER_MODE_PIN);
   gpio_set_direction(MASTER_MODE_PIN, GPIO_MODE_INPUT);
   bool isMaster = (gpio_get_level(MASTER_MODE_PIN) == 0);
 
+  // ESP-NOW Initialisieren
   ESP_ERROR_CHECK(esp_netif_init());
   ESP_ERROR_CHECK(esp_event_loop_create_default());
   wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
@@ -305,27 +198,65 @@ void app_main(void) {
     ESP_LOGE(TAG, "Could not Init ESP NOW Communication!");
   }
 
+  esp_partition_iterator_t partition_iter = esp_partition_find(
+      ESP_PARTITION_TYPE_ANY, ESP_PARTITION_SUBTYPE_ANY, NULL);
+
+  while (partition_iter != NULL) {
+    const esp_partition_t *part1 = esp_partition_get(partition_iter);
+    ESP_LOGI(TAG, "Partition: %s, Address: %d, Size %d", part1->label,
+             part1->address, part1->size);
+    partition_iter = esp_partition_next(partition_iter);
+  }
+
   const esp_partition_t *running = esp_ota_get_running_partition();
   ESP_LOGI(TAG, "OTA: Running Partition: %s", running->label);
+  uint8_t ota_part_count = esp_ota_get_app_partition_count();
+  ESP_LOGI(TAG, "OTA: Got %d OTA Partitions", ota_part_count);
 
   esp_ota_img_states_t ota_state;
   if (esp_ota_get_state_partition(running, &ota_state) == ESP_OK) {
+    ESP_LOGI(TAG, "OTA: Partition State : %d", ota_state);
     if (ota_state == ESP_OTA_IMG_PENDING_VERIFY) {
-      bool diagnostic_is_ok = true; // TODO build in valid diagnostics
+      // run diagnostic function ...
+      bool diagnostic_is_ok = true; // TODO: a real function that checks if
+                                    // everything is running properly
       if (diagnostic_is_ok) {
-        esp_ota_mark_app_valid_cancel_rollback();
+        ESP_LOGI(
+            TAG,
+            "Diagnostics completed successfully! Continuing execution ...");
+        // esp_ota_mark_app_valid_cancel_rollback();
       } else {
-        // esp_ota_mark_app_invalid_rollback(); Put this function at the start
+        ESP_LOGE(
-        // so when the esp crashes it can rollback
+            TAG,
-        esp_ota_mark_app_invalid_rollback_and_reboot();
+            "Diagnostics failed! Start rollback to the previous version ...");
+        // esp_ota_mark_app_invalid_rollback_and_reboot();
       }
     }
   }
 
-  const esp_partition_t *next_ota_partition =
+  const char nvs_part_name[] = "nvs_data";
-      esp_ota_get_next_update_partition(NULL);
+  const char nvs_namespace_name[] = "saved_clients";
-  int app_size = get_app_size(next_ota_partition);
+  ret = nvs_flash_init_partition(nvs_part_name);
-  ESP_LOGE(TAG, "App Size in Other Partition %d", app_size);
+  if (ret == ESP_ERR_NVS_NO_FREE_PAGES ||
+      ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
+    ESP_ERROR_CHECK(nvs_flash_erase_partition(nvs_part_name));
+    ret = nvs_flash_init_partition(nvs_part_name);
+  }
+  ESP_ERROR_CHECK(ret);
+  nvs_handle_t nt;
+  ESP_ERROR_CHECK(nvs_open_from_partition(nvs_part_name, nvs_namespace_name,
+                                          NVS_READWRITE, &nt));
+
+  int32_t outval;
+  ret = nvs_get_i32(nt, "test_entry", &outval);
+  if (ret == ESP_ERR_NVS_NOT_FOUND) {
+    ESP_ERROR_CHECK(nvs_set_i32(nt, "test_entry", 6969));
+    ESP_ERROR_CHECK(nvs_commit(nt));
+    ESP_LOGE(TAG, "Nichts im Flash gefunden hab was dahin geschrieben");
+  } else if (ret == ESP_OK) {
+    ESP_LOGE(TAG, "DAS WAR IM FLASH %d", outval);
+  }
+  nvs_close(nt);
 
   QueueHandle_t espnow_message_queue =
       xQueueCreate(10, sizeof(ESPNOW_MessageInfo));
@@ -335,23 +266,25 @@ void app_main(void) {
   xTaskCreate(ESP_MessageBrokerTask, "espnow_message_broker_task", 4096,
               (void *)&esp_broker_task_params, 4, NULL);
 
-  init_ota();
+  // Tasks starten basierend auf Master/Client
-
   if (isMaster) {
     ESP_LOGI(TAG, "Started in Mastermode");
     ESPNOW_RegisterMasterCallbacks();
-    ESPNOW_RegisterOTAMaster();
 
     add_peer(broadcast_address);
     xTaskCreate(master_broadcast_task, "MasterBroadcast", 4096, NULL, 1, NULL);
+    //  xTaskCreate(master_ping_task, "MasterPing", 4096, NULL, 1, NULL);
     xTaskCreate(master_broadcast_ping, "MasterBroadcastPing", 4096, NULL, 1,
                 NULL);
+    // xTaskCreate(client_monitor_task, "MonitorClientTask", 4096, NULL, 1,
+    // NULL);
 
     QueueHandle_t parsed_message_queue =
         xQueueCreate(10, sizeof(ParsedMessage_t));
     init_uart(parsed_message_queue);
     InitMessageBroker();
 
+    // Initialisiere die Parameterstruktur
     broker_task_params.message_queue = parsed_message_queue;
     broker_task_params.send_buffer = send_message_buffer;
     broker_task_params.send_buffer_size = sizeof(send_message_buffer);
@@ -359,23 +292,22 @@ void app_main(void) {
     broker_task_params.payload_buffer_size =
         sizeof(send_message_payload_buffer);
 
-    xTaskCreate(MessageBrokerTask, "MessageHandler", 4096,
+    xTaskCreate(MessageBrokerTask, "message_handler_task", 4096,
                 (void *)&broker_task_params, 5, NULL);
 
-    master_ota_task_params.client_list = &clientList;
+    RegisterCallback(0x01, echoCallback);
-    xTaskCreate(MasterOTATask, "MasterOTATask", 4096,
+    RegisterCallback(0x02, versionCallback);
-                (void *)&master_ota_task_params, 4, NULL);
+    RegisterCallback(0x03, clientInfoCallback);
 
-    RegisterCallback(UART_ECHO, echoCallback);
+    init_ota();
-    RegisterCallback(UART_VERSION, versionCallback);
-    RegisterCallback(UART_CLIENT_INFO, clientInfoCallback);
-    RegisterCallback(UART_CLIENT_INPUT, fakeDataCallback);
-    RegisterCallback(UART_OTA_START_ESPNOW, start_ota_update_espnow);
 
+    // xTaskCreate(uart_status_task, "MasterUartStatusTask", 4096, NULL, 1,
+    // NULL); xTaskCreate(SendClientInfoTask, "SendCientInfo", 4096, NULL, 1,
+    // NULL);
   } else {
     ESP_LOGI(TAG, "Started in Slavemode");
     ESPNOW_RegisterSlaveCallbacks();
-    xTaskCreate(slave_ota_task, "SlaveOTATask", 4096, NULL, 4, NULL);
+    // xTaskCreate(client_data_sending_task, "ClientDataSending", 4096, NULL, 1,
-    ESPNOW_RegisterOTASlave();
+    //             NULL);
   }
 }

main/main.h

@@ -19,4 +19,5 @@
 #elif CONFIG_IDF_TARGET_ESP32C3
 #define MASTER_MODE_PIN GPIO_NUM_0 // Jumper-Erkennungspin
 #endif
+
 #endif

main/message_structs.h

@@ -1,124 +0,0 @@
-#ifndef MESSAGE_STRUCTS_H
-#define MESSAGE_STRUCTS_H
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <sys/types.h>
-
-#define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
-#define MACSTR "%02X:%02X:%02X:%02X:%02X:%02X"
-
-typedef enum {
-  OTA_PREPARE_FOR_UPDATE,
-  OTA_PREPARE_ACKNOWLEDGED,
-  OTA_READY_TO_RECEIVE,
-  OTA_CHUNK,
-  OTA_REQUEST_BLOCK_STATUS,
-  OTA_BLOCK_STATUS_REPORT,
-  OTA_COMMIT_BLOCK,
-  OTA_BLOCK_COMMITTED,
-  OTA_FINISH_UPDATE,
-  OTA_UPDATE_STATUS,
-  OTA_UPDATE_SLAVE_ACKED,
-  MASTER_READY_TO_SEND_CHUNKS,
-  StatusPage,
-  GetStatusPage,
-  ConfigPage,
-  PingPage,
-  BroadCastPage,
-  RegisterPage,
-} CommandPages;
-
-typedef struct __attribute__((packed)) {
-  uint32_t total_size;
-  uint32_t block_size;
-} OTA_PREPARE_FOR_UPDATE_Payload;
-
-typedef struct __attribute__((packed)) {
-  // Empty
-} OTA_PREPARE_ACKNOWLEDGED_Payload;
-
-typedef struct __attribute__((packed)) {
-  uint8_t status; // 0 = READY, 1 = ERROR
-} OTA_READY_TO_RECEIVE_Payload;
-
-typedef struct __attribute__((packed)) {
-  uint16_t block_id;
-  uint8_t chunk_id;
-  uint8_t data_len;
-  uint8_t data[200];
-} OTA_CHUNK_Payload;
-
-typedef struct __attribute__((packed)) {
-  uint16_t block_id;
-} OTA_REQUEST_BLOCK_STATUS_Payload;
-
-typedef struct __attribute__((packed)) {
-  uint16_t block_id;
-  uint32_t chunk_bitmask;
-} OTA_BLOCK_STATUS_REPORT_Payload;
-
-typedef struct __attribute__((packed)) {
-  uint16_t block_id;
-} OTA_COMMIT_BLOCK_Payload;
-
-typedef struct __attribute__((packed)) {
-  uint16_t block_id;
-} OTA_BLOCK_COMMITTED_Payload;
-
-typedef struct __attribute__((packed)) {
-  // Empty
-} OTA_FINISH_UPDATE_Payload;
-
-typedef struct __attribute__((packed)) {
-  uint8_t status; // 0 = SUCCESS, 1 = FAILED
-} OTA_UPDATE_STATUS_Payload;
-
-typedef struct __attribute__((packed)) {
-  uint16_t current_block_id;
-  uint16_t update_buffer_write_index;
-  uint32_t update_size;
-  uint16_t sequenz_counter; // how often the update buffer gets written
-  uint8_t status;           // 0 = SUCCESS, 1 = FAILED
-} OTA_UPDATE_ACK_Payload;
-
-typedef struct __attribute__((packed)) {
-  uint16_t version; // software version
-  uint8_t runningPartition;
-  uint8_t status;
-  uint32_t uptime;
-} StatusPayload;
-
-typedef struct __attribute__((packed)) {
-} GetStatusPayload;
-
-typedef struct __attribute__((packed)) {
-  uint8_t timeslot;
-} ConfigPayload;
-
-typedef struct __attribute__((packed)) {
-  uint32_t timestamp;
-} PingPayload;
-
-typedef struct __attribute__((packed)) {
-} BroadCastPayload;
-
-typedef struct __attribute__((packed)) {
-  bool familierClient;
-} RegisterPayload;
-
-// TODO: Check checksum fields
-typedef struct __attribute__((packed)) {
-  uint16_t length;  // length of complete firmware
-  uint8_t checksum; // checksum of firmware
-} FirmwarePrepPayload;
-
-// TODO: Check checksum fields
-typedef struct __attribute__((packed)) {
-  uint8_t length;
-  uint8_t checksum;
-  uint32_t address;
-  uint8_t payload[240]; // TODO: need a way to figure out a safe value for this
-} FirmwarePayload;
-
-#endif // MESSAGE_STRUCTS_H

main/ota_update.c

@@ -1,340 +1,61 @@
 #include "ota_update.h"
-#include "client_handler.h"
-#include "communication_handler.h"
 #include "driver/uart.h"
-#include "esp_app_format.h"
 #include "esp_err.h"
 #include "esp_log.h"
-#include "esp_log_buffer.h"
-#include "esp_now.h"
 #include "esp_ota_ops.h"
 #include "esp_partition.h"
 #include "esp_system.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/queue.h"
-#include "freertos/task.h"
 #include "message_builder.h"
 #include "message_handler.h"
-#include "message_structs.h"
 #include "uart_handler.h"
 #include "uart_msg_ids.h"
-#include <stdbool.h>
 #include <stddef.h>
+#include <stdint.h>
 #include <string.h>
 
-static const char *TAG = "ALOX - OTA";
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
 
-static QueueHandle_t ota_task_queue = NULL;
-
-static esp_ota_handle_t update_handle = 0;
 static uint8_t update_buffer[UPDATE_BUFFER_SIZE];
-static uint8_t update_buffer_chunk[250];
-static uint8_t update_buffer_chunk_len;
-static uint32_t chunk_bitmask;
-static uint16_t current_block_id;
 static uint16_t update_buffer_write_index;
 static uint32_t update_size;
 static uint16_t sequenz_counter; // how often the update buffer gets written
-static esp_partition_t partition_to_read_update_from;
+static const char *TAG = "ALOX - OTA";
-static uint32_t partition_to_read_from_read_index;
+static esp_ota_handle_t update_handle;
-static ClientList *client_list;
-static bool all_chunks_send;
-static bool finished;
 
-uint32_t get_app_size(const esp_partition_t *app_size_partition) {
+int prepare_ota_update() {
-  esp_app_desc_t app_desc;
+  const esp_partition_t *running = esp_ota_get_running_partition();
-  esp_ota_get_partition_description(app_size_partition, &app_desc);
+  ESP_LOGI(TAG, "OTA: Running Partition: %s", running->label);
+  int part = 0;
 
-  esp_image_header_t header;
+  char partition_to_update[] = "ota_0";
-
+  if (strcmp(running->label, "ota_0") == 0) {
-  esp_partition_read(app_size_partition, 0, &header, sizeof(header));
+    strcpy(partition_to_update, "ota_1");
-  if (header.magic != ESP_IMAGE_HEADER_MAGIC) {
+    part = 1;
-    ESP_LOGE(TAG, "KEIN VALIDER HEADER");
-    return 0;
   }
 
-  uint32_t data_len = sizeof(header);
+  const esp_partition_t *update_partition = esp_partition_find_first(
+      ESP_PARTITION_TYPE_APP, ESP_PARTITION_SUBTYPE_ANY, partition_to_update);
 
-  for (int i = 0; i < header.segment_count; i++) {
+  // Check if the partition was found
-    esp_image_segment_header_t segment_header;
+  if (update_partition == NULL) {
-    esp_partition_read(app_size_partition, data_len, &segment_header,
+    ESP_LOGE(TAG, "Failed to find OTA partition: %s", partition_to_update);
-                       sizeof(segment_header));
+    return -1; // Or handle the error appropriately
-    ESP_LOGI(TAG, "SEGMENT %d Address %d, Segment DataLen %d", i,
-             segment_header.load_addr, segment_header.data_len);
-    uint32_t padded_len = (segment_header.data_len + 3) & ~3;
-    data_len += padded_len + sizeof(segment_header);
   }
 
-  data_len += 1;
+  ESP_LOGI(TAG, "Gonna write OTA Update in Partition: %s",
-  data_len += 32;
+           update_partition->label);
-  uint32_t padding = (16 - (data_len % 16)) % 16;
-  data_len += padding;
-
-  return data_len;
-}
-
-int ota_send_finish(ClientList *client_list) {
-  // read flash and send data
-  BaseMessage replyMessage = {};
-  OTA_FINISH_UPDATE_Payload payload = {};
-
-  ESP_LOGI(TAG, "OTA SEND FINISH");
-
-  replyMessage = MessageBuilder(OTA_FINISH_UPDATE, *(PayloadUnion *)&payload,
-                                sizeof(payload));
-
-  for (int i = 0; i < MAX_CLIENTS; i++) {
-    if (client_list->Clients[i].slotIsUsed) {
-      if (client_list->Clients[i].ota_status == OTA_UPDATING) {
-        esp_now_send(client_list->Clients[i].macAddr, (uint8_t *)&replyMessage,
-                     sizeof(BaseMessage));
-        client_list->Clients[i].ota_status = OTA_AWAITING_ACK;
-      }
-    }
-  }
-  finished = true;
-  return 0;
-}
-
-int ota_send_next_update_chunk(ClientList *client_list) {
-  // read flash and send data
-  BaseMessage replyMessage = {};
-  OTA_CHUNK_Payload payload = {};
-
-  size_t actual_read = 200;
-  if (partition_to_read_from_read_index + actual_read > update_size) {
-    actual_read = update_size - partition_to_read_from_read_index;
-  }
-
-  esp_err_t err = esp_partition_read(&partition_to_read_update_from,
-                                     partition_to_read_from_read_index,
-                                     payload.data, actual_read);
-
-  if (actual_read < 200) {
-    ESP_LOG_BUFFER_HEX(TAG, payload.data, actual_read);
-  }
 
+  esp_err_t err =
+      esp_ota_begin(update_partition, OTA_SIZE_UNKNOWN, &update_handle);
   if (err != ESP_OK) {
-    ESP_LOGE(TAG, "Could not read partition");
+    ESP_LOGE(TAG, "esp_ota_begin failed (%s)", esp_err_to_name(err));
+    esp_ota_abort(update_handle);
+    return -2;
   }
 
-  partition_to_read_from_read_index += actual_read;
+  ESP_LOGI(TAG, "OTA update started successfully.");
-  payload.data_len = actual_read;
+  return part;
-
-  ESP_LOGI(TAG, "READ %d Bytes Sendig it to all Clients waiting", actual_read);
-  ESP_LOGI(TAG, "READ PARTITION AT %d Bytes MAX Bytes %d",
-           partition_to_read_from_read_index, update_size);
-
-  replyMessage =
-      MessageBuilder(OTA_CHUNK, *(PayloadUnion *)&payload, sizeof(payload));
-
-  for (int i = 0; i < MAX_CLIENTS; i++) {
-    if (client_list->Clients[i].slotIsUsed) {
-      if (client_list->Clients[i].ota_status == OTA_UPDATING) {
-        esp_now_send(client_list->Clients[i].macAddr, (uint8_t *)&replyMessage,
-                     sizeof(BaseMessage));
-        client_list->Clients[i].ota_status = OTA_AWAITING_ACK;
-      }
-    }
-  }
-
-  if (partition_to_read_from_read_index == update_size)
-    return 1; // last update chunk send now finish it!
-
-  return 0;
-}
-
-void MasterOTATask(void *pvParameter) {
-  ESP_LOGI(TAG, "master_ota_task started");
-  ota_task_queue_message_t msg;
-  MasterOTA_TaskParams_t task_params = *(MasterOTA_TaskParams_t *)pvParameter;
-  client_list = task_params.client_list;
-
-  while (1) {
-    if (xQueueReceive(ota_task_queue, &msg, portMAX_DELAY)) {
-      ESP_LOGI(TAG, "master ota_task received command: %d", msg.command);
-      BaseMessage replyMessage = {};
-
-      switch (msg.command) {
-      case OTA_SEND_SLAVES_PREPARE_MESSAGE: {
-      }
-      case OTA_SLAVE_WILL_PREPARE: {
-        int id = get_client_id(client_list, msg.mac_addr);
-        if (id < 0) {
-          // error
-          ESP_LOGE(TAG, "Error set OTA_PREPARE could not get client id");
-        }
-        // just wait
-        // mark client that it will wait
-        ESP_LOGI(TAG, "MASTER OTA TASK: Marking Client %d as OTA_PREPARING",
-                 id);
-        client_list->Clients[id].ota_status = OTA_PREPARING;
-        break;
-      }
-      case OTA_SLAVE_IS_PREPARED: {
-        // client is prepared check if all clients are preapred to send chunks
-        int id = get_client_id(client_list, msg.mac_addr);
-        if (id < 0) {
-          // error
-        }
-        if (client_list->Clients[id].ota_status == OTA_PREPARING) {
-          ESP_LOGI(TAG, "MASTER OTA TASK: Marking Client %d as OTA_UPDATING",
-                   id);
-          client_list->Clients[id].ota_status = OTA_UPDATING;
-        } else {
-          ESP_LOGE(TAG, "MASTER OTA TASK: Client this should not happend");
-        }
-
-        bool start = true;
-        // check if all clients are prepared
-        for (int i = 0; i < MAX_CLIENTS; i++) {
-          if (client_list->Clients[i].slotIsUsed) {
-            if (client_list->Clients[i].ota_status != OTA_UPDATING)
-              start = false;
-          }
-        }
-        if (start)
-          ota_send_next_update_chunk(client_list);
-        break;
-      }
-      case OTA_SLAVE_ACKED: {
-        // mark client as acked check if all clients acked to send next message
-        int id = get_client_id(client_list, msg.mac_addr);
-        if (id < 0) {
-          // error
-        }
-        if (client_list->Clients[id].ota_status == OTA_AWAITING_ACK) {
-          ESP_LOGI(TAG, "OTA_SLAVE_ACKED Client %d Status Update OTA_UPDATING",
-                   id);
-          client_list->Clients[id].ota_status = OTA_UPDATING;
-        } else {
-          ESP_LOGE(TAG, "OTA_SLAVE_ACKED Client %d Status Should not HAPPEND",
-                   id);
-        }
-
-        bool start = true;
-        // check if all clients are prepared
-        for (int i = 0; i < MAX_CLIENTS; i++) {
-          if (client_list->Clients[i].slotIsUsed) {
-            ESP_LOGI(TAG, "SLOT %d is USED", i);
-            if (client_list->Clients[i].ota_status != OTA_UPDATING)
-              start = false;
-          }
-        }
-        if (start) {
-          if (finished)
-            break; // dont need to send anything else
-          if (all_chunks_send) {
-            ota_send_finish(client_list);
-            break;
-          }
-          ESP_LOGE(TAG, "OTA_SLAVE_ACKED all clients have the status "
-                        "OTA_UPDATING SENDING NEXT CHUNK");
-          int end = ota_send_next_update_chunk(client_list);
-          if (end) {
-            all_chunks_send = true;
-          }
-        }
-
-        break;
-      }
-      case OTA_SLAVE_ERROR:
-        break;
-        // mark client as error
-      case OTA_MASTER_SEND_PREAPRE_REQUEST:
-        break;
-      case OTA_MASTER_SEND_CHUNK:
-        break;
-      case OTA_MASTER_SEND_FINISH:
-        break;
-      }
-    }
-  }
-}
-
-void slave_ota_task(void *pvParameter) {
-  ESP_LOGI(TAG, "slave_ota_task started");
-  ota_task_queue_message_t msg;
-  BaseMessage replyMessage = {};
-  while (1) {
-    if (xQueueReceive(ota_task_queue, &msg, portMAX_DELAY)) {
-      ESP_LOGI(TAG, "slave ota_task received command: %d", msg.command);
-
-      switch (msg.command) {
-      case OTA_SEND_SLAVES_PREPARE_MESSAGE:
-        break;
-      case OTA_SLAVE_WILL_PREPARE:
-        break;
-      case OTA_SLAVE_IS_PREPARED:
-        break;
-      case OTA_SLAVE_ACKED:
-        break;
-      case OTA_SLAVE_ERROR:
-        break;
-      case OTA_MASTER_SEND_PREAPRE_REQUEST: {
-        ESP_LOGE(TAG, "START PREAPRE CALL");
-        int part = prepare_ota_update(); // this part function is blocking
-        OTA_READY_TO_RECEIVE_Payload payload = {};
-        if (part < 0) {
-          payload.status = 1; // ERROR
-        } else {
-          payload.status = 0; // READY
-        }
-        ESP_LOGE(TAG, "PREPARED %d", part);
-
-        replyMessage = MessageBuilder(
-            OTA_READY_TO_RECEIVE, *(PayloadUnion *)&payload, sizeof(payload));
-        esp_now_send(msg.mac_addr, (uint8_t *)&replyMessage,
-                     sizeof(BaseMessage));
-        break;
-      }
-      case OTA_MASTER_SEND_CHUNK: {
-        // TODO: Move Update_buffer_chunk in normal update buffer no need for
-        // the extra step...
-        // TODO: at the moment its just so i can use the write_ota_update
-        // function unmodified
-        ESP_LOGI(TAG, "Master send Chunk writing it!");
-
-        write_ota_update(update_buffer_chunk_len, update_buffer_chunk);
-
-        ESP_LOGI(TAG, "AFTER WRITE_OTA_UPDATE!");
-
-        OTA_UPDATE_ACK_Payload payload = {
-            .update_buffer_write_index = update_buffer_write_index,
-            .current_block_id = current_block_id,
-            .sequenz_counter = sequenz_counter,
-            .status = 0,
-        };
-        replyMessage = MessageBuilder(
-            OTA_UPDATE_SLAVE_ACKED, *(PayloadUnion *)&payload, sizeof(payload));
-        esp_now_send(msg.mac_addr, (uint8_t *)&replyMessage,
-                     sizeof(BaseMessage));
-        break;
-      }
-      case OTA_MASTER_SEND_FINISH: {
-        esp_err_t err = end_ota_update();
-        int status = 0;
-        if (err != ESP_OK) {
-          status = 1; // TODO: Set real error
-        }
-
-        ESP_LOGI(TAG, "UPDATE FERTIG STATUS %d should be 0", status);
-
-        OTA_UPDATE_ACK_Payload payload = {
-            .update_buffer_write_index = update_buffer_write_index,
-            .current_block_id = current_block_id,
-            .sequenz_counter = sequenz_counter,
-            .status = status,
-        };
-        replyMessage = MessageBuilder(
-            OTA_UPDATE_SLAVE_ACKED, *(PayloadUnion *)&payload, sizeof(payload));
-        esp_now_send(msg.mac_addr, (uint8_t *)&replyMessage,
-                     sizeof(BaseMessage));
-        break;
-      }
-      }
-    }
-  }
 }
 
 void start_uart_update(uint8_t msgid, const uint8_t *payload,
@@ -346,14 +67,13 @@ void start_uart_update(uint8_t msgid, const uint8_t *payload,
   vTaskPrioritySet(NULL, 2);
 
   update_size = 0;
-  update_buffer_write_index = 0;
-  sequenz_counter = 0;
-  all_chunks_send = false;
-  finished = false;
 
   int part = prepare_ota_update();
 
-  // TODO: what does this do? maybe comment it out for now?
+  // Message:
+  // byte partition
+  // byte error
+
   if (part < 0) {
     send_payload_buffer[1] = (part * -1) & 0xff;
   } else {
@@ -375,18 +95,20 @@ 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);
+  if (update_buffer_write_index > UPDATE_BUFFER_SIZE - write_len) {
-  ESP_LOGI(TAG, "write_ota_update: update_buffer_write_index: %d",
+    // ESP_LOGI(TAG, "Writing Data to Update BUffer Sequence %d, writing Data
-           update_buffer_write_index);
+    // %d",
-  if (update_buffer_write_index + write_len > UPDATE_BUFFER_SIZE) {
+    //          sequenz_counter, write_len);
-    ESP_LOGI(TAG, "write_ota_update: schreib das update weg!");
+    // write to ota
     esp_err_t err =
         esp_ota_write(update_handle, update_buffer, update_buffer_write_index);
     if (err != ESP_OK) {
       return err;
     }
+
     update_buffer_write_index = 0;
     sequenz_counter++;
+    return err;
   }
 
   memcpy(&update_buffer[update_buffer_write_index], payload, write_len);
@@ -394,23 +116,16 @@ esp_err_t write_ota_update(uint32_t write_len, const uint8_t *payload) {
   return ESP_OK;
 }
 
-void payload_uart_update(uint8_t msgid, const uint8_t *payload_data_from_uart,
+void payload_uart_update(uint8_t msgid, const uint8_t *payload,
-                         size_t total_payload_len_from_uart,
+                         size_t payload_len, uint8_t *send_payload_buffer,
-                         uint8_t *send_payload_buffer,
                          size_t send_payload_buffer_size, uint8_t *send_buffer,
                          size_t send_buffer_size) {
+  // ESP_LOGI(TAG, "OTA Update Payload Uart Command");
 
-  const uint8_t *actual_firmware_data = payload_data_from_uart;
+  uint32_t write_len = MIN(UPDATE_PAYLOAD_SIZE, payload_len);
-
-  uint32_t write_len = total_payload_len_from_uart;
-
-  if (update_size == 0) {
-    ESP_LOGI(TAG, "First chunk received. write_len: %d", write_len);
-  }
-
   update_size += write_len;
 
-  esp_err_t err = write_ota_update(write_len, actual_firmware_data);
+  esp_err_t err = write_ota_update(write_len, payload);
 
   if (err != ESP_OK) {
     ESP_LOGE(TAG, "GOT ESP ERROR WRITE OTA %d", err);
@@ -427,13 +142,44 @@ void payload_uart_update(uint8_t msgid, const uint8_t *payload_data_from_uart,
     ESP_LOGE(TAG,
              "Error Building UART Message: payload_len, %d, sendbuffer_size: "
              "%d, mes_len(error): %d",
-             total_payload_len_from_uart, send_buffer_size, len);
+             payload_len, send_buffer_size, len);
     return;
   }
 
   uart_write_bytes(MASTER_UART, send_buffer, len);
 }
 
+esp_err_t end_ota_update() {
+  esp_err_t err =
+      esp_ota_write(update_handle, update_buffer, update_buffer_write_index);
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "GOT ESP ERROR WRITE OTA %d", err);
+  }
+
+  err = esp_ota_end(update_handle);
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "GOT ESP ERROR WRITE OTA %d", err);
+  }
+
+  ESP_LOGE(TAG, "UPDATE ENDE UPDATGE SIZE SIND %d BYTES", update_size);
+
+  // Hol dir die zuletzt geschriebene Partition
+  const esp_partition_t *partition = esp_ota_get_next_update_partition(NULL);
+  if (partition == NULL) {
+    ESP_LOGE(TAG, "Failed to get updated partition");
+    err = ESP_FAIL;
+  }
+
+  // Setze sie als Boot-Partition
+  ESP_LOGE(TAG, "Setzte nächste Partition auf %s", partition->label);
+  err = esp_ota_set_boot_partition(partition);
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "esp_ota_set_boot_partition failed: %s",
+             esp_err_to_name(err));
+  }
+  return err;
+}
+
 void end_uart_update(uint8_t msgid, const uint8_t *payload, size_t payload_len,
                      uint8_t *send_payload_buffer,
                      size_t send_payload_buffer_size, uint8_t *send_buffer,
@@ -442,6 +188,7 @@ void end_uart_update(uint8_t msgid, const uint8_t *payload, size_t payload_len,
 
   esp_err_t err = end_ota_update();
 
+  // message ret esp_err_t
   int send_payload_len = 1;
   send_payload_buffer[0] = err & 0xff;
   int len = build_message(UART_OTA_END, send_payload_buffer, send_payload_len,
@@ -459,202 +206,10 @@ void end_uart_update(uint8_t msgid, const uint8_t *payload, size_t payload_len,
   vTaskPrioritySet(NULL, 1);
 }
 
-void init_ota() {
+void write_ota_update_from_uart_task(void *param) {}
-  ota_task_queue = xQueueCreate(50, sizeof(ota_task_queue_message_t));
 
+void init_ota() {
   RegisterCallback(UART_OTA_START, start_uart_update);
   RegisterCallback(UART_OTA_PAYLOAD, payload_uart_update);
   RegisterCallback(UART_OTA_END, end_uart_update);
 }
-
-int prepare_ota_update() {
-  const esp_partition_t *running = esp_ota_get_running_partition();
-  ESP_LOGI(TAG, "Running Partition: %s", running->label);
-  const esp_partition_t *update_partition =
-      esp_ota_get_next_update_partition(NULL);
-  if (update_partition == NULL) {
-    ESP_LOGE(TAG, "Failed to find OTA partition.");
-    return -1;
-  }
-
-  ESP_LOGI(TAG, "Writing OTA Update to Partition: %s", update_partition->label);
-
-  esp_err_t err =
-      esp_ota_begin(update_partition, OTA_SIZE_UNKNOWN, &update_handle);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "esp_ota_begin failed (%s)", esp_err_to_name(err));
-    return -2;
-  }
-  return 0;
-}
-
-esp_err_t end_ota_update() {
-  if (update_buffer_write_index > 0) {
-    ESP_LOG_BUFFER_HEX(TAG, update_buffer, update_buffer_write_index);
-    esp_err_t err =
-        esp_ota_write(update_handle, update_buffer, update_buffer_write_index);
-    vTaskDelay(1);
-    if (err != ESP_OK) {
-      ESP_LOGE(TAG, "Error writing remaining data to partition: %s",
-               esp_err_to_name(err));
-      return err;
-    }
-  }
-
-  esp_err_t err = esp_ota_end(update_handle);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "esp_ota_end failed: %s", esp_err_to_name(err));
-    ESP_LOGI(TAG, "Total blocks written: %u, Last partial block size: %u",
-             sequenz_counter, update_buffer_write_index);
-    return err;
-  }
-
-  const esp_partition_t *update_partition =
-      esp_ota_get_next_update_partition(NULL);
-  err = esp_ota_set_boot_partition(update_partition);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "esp_ota_set_boot_partition failed: %s",
-             esp_err_to_name(err));
-  }
-  return err;
-}
-
-// Acknoledge that the slave should prepare for an update
-// Queues the Prepare Task beacuse it takes like 30 seconds
-void slave_Prep_Upgrade_Callback(const esp_now_recv_info_t *esp_now_info,
-                                 const uint8_t *data, int data_len) {
-  ESP_LOGE(TAG, "SLAVE PREPARE FOR UPDATE Callback");
-
-  update_size = 0;
-  update_buffer_write_index = 0;
-  sequenz_counter = 0;
-
-  const BaseMessage *message = (const BaseMessage *)data;
-  const OTA_PREPARE_FOR_UPDATE_Payload *payload =
-      &message->payload.ota_prepare_for_update_payload;
-  // total_update_size = payload->total_size;
-
-  // Queue Command for Task to call the prepare method
-  ota_task_queue_message_t msg = {.command = OTA_MASTER_SEND_PREAPRE_REQUEST};
-  memcpy(msg.mac_addr, esp_now_info->src_addr, ESP_NOW_ETH_ALEN);
-  if (xQueueSend(ota_task_queue, &msg, pdMS_TO_TICKS(10)) != pdTRUE) {
-    ESP_LOGE(TAG, "Failed to send prepare command to OTA task");
-  }
-  ESP_LOGE(TAG, "SLAVE PREPARE CALLBACK AFTER QUEUE SEND");
-
-  // Tell the master that the slave will preapre
-  OTA_PREPARE_ACKNOWLEDGED_Payload *reply_payload;
-  BaseMessage reply_message =
-      MessageBuilder(OTA_PREPARE_ACKNOWLEDGED, *(PayloadUnion *)&reply_payload,
-                     sizeof(OTA_PREPARE_ACKNOWLEDGED_Payload));
-  ESP_ERROR_CHECK(esp_now_send(esp_now_info->src_addr,
-                               (uint8_t *)&reply_message, sizeof(BaseMessage)));
-}
-
-void slave_Update_Chunk_Callback(const esp_now_recv_info_t *esp_now_info,
-                                 const uint8_t *data, int data_len) {
-  const BaseMessage *message = (const BaseMessage *)data;
-  const OTA_CHUNK_Payload *payload = &message->payload.ota_chunk_payload;
-
-  // copy data to update_buffer_chunk so that the write method can write it
-  // back later
-  memcpy(update_buffer_chunk, payload->data, payload->data_len);
-  update_buffer_chunk_len = payload->data_len;
-
-  ESP_LOGI(TAG, "slave_update_Chunk_Callback got %d bytes from Master",
-           payload->data_len);
-
-  // Queue Command for Task to call the ota_write_message method
-  ota_task_queue_message_t msg = {.command = OTA_MASTER_SEND_CHUNK};
-  memcpy(msg.mac_addr, esp_now_info->src_addr, ESP_NOW_ETH_ALEN);
-  if (xQueueSend(ota_task_queue, &msg, pdMS_TO_TICKS(10)) != pdTRUE) {
-    ESP_LOGE(TAG, "Failed to send prepare command to OTA task");
-  }
-}
-
-void slave_Update_Finished_Callback(const esp_now_recv_info_t *esp_now_info,
-                                    const uint8_t *data, int data_len) {
-  const BaseMessage *message = (const BaseMessage *)data;
-  const OTA_FINISH_UPDATE_Payload *payload =
-      &message->payload.ota_finish_update_payload;
-
-  ESP_LOGI(TAG, "slave_Update_Finished_Callback");
-
-  // Queue Command for Task to call the ota_write_message method
-  ota_task_queue_message_t msg = {.command = OTA_MASTER_SEND_FINISH};
-  memcpy(msg.mac_addr, esp_now_info->src_addr, ESP_NOW_ETH_ALEN);
-  if (xQueueSend(ota_task_queue, &msg, pdMS_TO_TICKS(10)) != pdTRUE) {
-    ESP_LOGE(TAG, "Failed to send prepare command to OTA task");
-  }
-}
-
-void start_ota_update_espnow(uint8_t msgid, const uint8_t *payload,
-                             size_t payload_len, uint8_t *send_payload_buffer,
-                             size_t send_payload_buffer_size,
-                             uint8_t *send_buffer, size_t send_buffer_size) {
-  ESP_LOGI(TAG, "Starting OTA update for all clients");
-
-  const esp_partition_t *ota_update_partition;
-
-  ota_update_partition = esp_ota_get_next_update_partition(NULL);
-  if (ota_update_partition == NULL) {
-    ESP_LOGE(TAG, "Failed to get update partition");
-    return;
-  }
-
-  update_size = get_app_size(ota_update_partition);
-
-  partition_to_read_update_from = *ota_update_partition;
-  partition_to_read_from_read_index = 0;
-
-  BaseMessage replyMessage = {};
-  OTA_PREPARE_FOR_UPDATE_Payload replyPayload = {};
-
-  replyMessage =
-      MessageBuilder(OTA_PREPARE_FOR_UPDATE, *(PayloadUnion *)&replyPayload,
-                     sizeof(replyPayload));
-
-  for (int i = 0; i < MAX_CLIENTS; i++) {
-    if (client_list->Clients[i].slotIsUsed) {
-      esp_now_send(client_list->Clients[i].macAddr, (uint8_t *)&replyMessage,
-                   sizeof(BaseMessage));
-      client_list->Clients[i].ota_status = OTA_READY;
-    }
-  }
-}
-
-void master_ota_prepare_acknowledge_callback(
-    const esp_now_recv_info_t *esp_now_info, const uint8_t *data,
-    int data_len) {
-  ESP_LOGI(TAG, "entering master_ota_prepare_acknowledge_callback");
-  // Queue Command for Task to call the ota_write_message method
-  ota_task_queue_message_t msg = {.command = OTA_SLAVE_WILL_PREPARE};
-  memcpy(msg.mac_addr, esp_now_info->src_addr, ESP_NOW_ETH_ALEN);
-  if (xQueueSend(ota_task_queue, &msg, pdMS_TO_TICKS(10)) != pdTRUE) {
-    ESP_LOGE(TAG, "Failed to send prepare command to OTA task");
-  }
-}
-
-void master_ota_ready_to_recieve_callback(
-    const esp_now_recv_info_t *esp_now_info, const uint8_t *data,
-    int data_len) {
-  ESP_LOGI(TAG, "entering master_ota_ready_to_recieve_callback");
-  // Queue Command for Task to call the ota_write_message method
-  ota_task_queue_message_t msg = {.command = OTA_SLAVE_IS_PREPARED};
-  memcpy(msg.mac_addr, esp_now_info->src_addr, ESP_NOW_ETH_ALEN);
-  if (xQueueSend(ota_task_queue, &msg, pdMS_TO_TICKS(10)) != pdTRUE) {
-    ESP_LOGE(TAG, "Failed to send prepare command to OTA task");
-  }
-}
-
-void master_ota_update_slave_acknowledge_callback(
-    const esp_now_recv_info_t *esp_now_info, const uint8_t *data,
-    int data_len) {
-  ESP_LOGI(TAG, "entering master_ota_update_slave_acknowledge_callback");
-  // Queue Command for Task to call the ota_write_message method
-  ota_task_queue_message_t msg = {.command = OTA_SLAVE_ACKED};
-  memcpy(msg.mac_addr, esp_now_info->src_addr, ESP_NOW_ETH_ALEN);
-  if (xQueueSend(ota_task_queue, &msg, pdMS_TO_TICKS(10)) != pdTRUE) {
-    ESP_LOGE(TAG, "Failed to send prepare command to OTA task");
-  }
-}

main/ota_update.h

@@ -1,81 +1,25 @@
 #ifndef OTA_UPDATE_H
 #define OTA_UPDATE_H
 
-#include "client_handler.h"
 #include "esp_err.h"
-#include "esp_now.h"
-#include "esp_partition.h"
-#include "message_structs.h"
 #include <stdint.h>
 #include <sys/types.h>
-
+#define UPDATE_BUFFER_SIZE 4000
-#define UPDATE_BUFFER_SIZE 4096
 #define UPDATE_PAYLOAD_SIZE 200
 #define UPDATE_MAX_SEQUENZES (UPDATE_BUFFER_SIZE / UPDATE_PAYLOAD_SIZE)
 
-typedef enum {
-  OTA_SEND_SLAVES_PREPARE_MESSAGE,
-  OTA_SLAVE_WILL_PREPARE,
-  OTA_SLAVE_IS_PREPARED,
-  OTA_SLAVE_ACKED,
-  OTA_SLAVE_ERROR,
-  OTA_MASTER_SEND_PREAPRE_REQUEST,
-  OTA_MASTER_SEND_CHUNK,
-  OTA_MASTER_SEND_FINISH,
-} ota_command_t;
-
-typedef struct {
-  ota_command_t command;
-  uint8_t mac_addr[ESP_NOW_ETH_ALEN];
-} ota_task_queue_message_t;
-
-typedef struct {
-  ClientList *client_list;
-} MasterOTA_TaskParams_t;
-
 void init_ota();
-void MasterOTATask(void *pvParameter);
-void slave_ota_task(void *pvParameter);
 
-u_int32_t get_app_size(const esp_partition_t *app_size_partition);
+enum OTA_UPDATE_STATES {
+  IDEL,
+  START_REQUESTED,
+  WAITING_FOR_PAYLOAD,
+  WRITING_OTA_TO_PARTITION,
+
+};
 
 int prepare_ota_update();
 esp_err_t write_ota_update(uint32_t write_len, const uint8_t *payload);
 esp_err_t end_ota_update();
 
-void slave_Prep_Upgrade_Callback(const esp_now_recv_info_t *esp_now_info,
-                                 const uint8_t *data, int data_len);
-void slave_Update_Chunk_Callback(const esp_now_recv_info_t *esp_now_info,
-                                 const uint8_t *data, int data_len);
-void slave_Update_Finished_Callback(const esp_now_recv_info_t *esp_now_info,
-                                    const uint8_t *data, int data_len);
-
-void master_ota_prepare_acknowledge_callback(
-    const esp_now_recv_info_t *esp_now_info, const uint8_t *data, int data_len);
-
-void master_ota_ready_to_recieve_callback(
-    const esp_now_recv_info_t *esp_now_info, const uint8_t *data, int data_len);
-
-void master_ota_update_slave_acknowledge_callback(
-    const esp_now_recv_info_t *esp_now_info, const uint8_t *data, int data_len);
-
-void start_uart_update(uint8_t msgid, const uint8_t *payload,
-                       size_t payload_len, uint8_t *send_payload_buffer,
-                       size_t send_payload_buffer_size, uint8_t *send_buffer,
-                       size_t send_buffer_size);
-void payload_uart_update(uint8_t msgid, const uint8_t *payload_data_from_uart,
-                         size_t total_payload_len_from_uart,
-                         uint8_t *send_payload_buffer,
-                         size_t send_payload_buffer_size, uint8_t *send_buffer,
-                         size_t send_buffer_size);
-void end_uart_update(uint8_t msgid, const uint8_t *payload, size_t payload_len,
-                     uint8_t *send_payload_buffer,
-                     size_t send_payload_buffer_size, uint8_t *send_buffer,
-                     size_t send_buffer_size);
-
-void start_ota_update_espnow(uint8_t msgid, const uint8_t *payload,
-                             size_t payload_len, uint8_t *send_payload_buffer,
-                             size_t send_payload_buffer_size,
-                             uint8_t *send_buffer, size_t send_buffer_size);
-
 #endif

main/uart_msg_ids.h

@@ -6,14 +6,12 @@ enum UART_MSG_IDS {
   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,
 };
 
 #endif