Refactored Communication Handling

main/CMakeLists.txt

@@ -1,3 +1,3 @@
-idf_component_register(SRCS "main.c"
+idf_component_register(SRCS "main.c" "uart_handler.c" "communication_handler.c"
                        INCLUDE_DIRS ".")
 

main/communication_handler.c

@@ -0,0 +1,299 @@
+#include "esp_log.h"
+#include "esp_timer.h"
+
+#include "communication_handler.h"
+
+static const char *TAG = "ALOX - COM";
+
+QueueHandle_t messageQueue = NULL; // Warteschlange für empfangene Nachrichten
+ClientInfo clients[MAX_CLIENTS] = {
+    0}; // Clients statisch initialisieren, alle auf 0 gesetzt
+size_t numClients = 0;
+size_t activeClients = 0;
+bool hasMaster = false;
+
+void init_com() {
+  // Initialisiere die Kommunikations-Warteschlange
+  messageQueue = xQueueCreate(MESSAGE_QUEUE_SIZE, sizeof(BaseMessage));
+  if (messageQueue == NULL) {
+    ESP_LOGE(TAG, "Message queue creation failed");
+  }
+
+  // Weitere Initialisierungen, falls nötig
+  numClients = 0;
+  activeClients = 0;
+  hasMaster = false;
+}
+
+// return any inactive client field for new usage
+int getNextFreeClientId() {
+  for (int i = 0; i < numClients; i++) {
+    if (!clients[i].isAvailable) {
+      return i;
+    }
+  }
+  return 0;
+}
+
+void add_peer(uint8_t *macAddr) {
+  esp_now_peer_info_t peerInfo = {
+      .channel =
+          0, // Standardkanal, sollte uit den anderen Geräten übereinstimmen
+      .ifidx = ESP_IF_WIFI_STA,
+      .encrypt = false, // Keine Verschlüsselung (kann geändert werden)
+  };
+  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: %02X:%02X:%02X:%02X:%02X:%02X", macAddr[0],
+             macAddr[1], macAddr[2], macAddr[3], macAddr[4], macAddr[5]);
+
+    if (!IS_BROADCAST_ADDR(macAddr)) {
+
+      if (numClients >= MAX_CLIENTS) {
+        ESP_LOGW(TAG, "Cannot add more clients, maximum reached.");
+        return;
+      }
+
+      ClientInfo newClient = {};
+      memcpy(newClient.macAddr, macAddr, ESP_NOW_ETH_ALEN);
+      newClient.isAvailable = true;
+      newClient.lastSuccessfullPing = xTaskGetTickCount();
+      clients[getNextFreeClientId()] = newClient;
+      ESP_LOGI(TAG, "New client added.");
+    }
+  } else if (result == ESP_ERR_ESPNOW_EXIST) {
+    ESP_LOGW(TAG, "Peer already exists.");
+    // Überprüfen, ob der Client bereits existiert
+    for (int i = 0; i < numClients; i++) {
+      if (memcmp(clients[i].macAddr, macAddr, ESP_NOW_ETH_ALEN) == 0) {
+        ESP_LOGI(TAG, "Client found again, welcome back!");
+        clients[i].isAvailable = true; // Reaktiviere den Client
+        break;
+      }
+    }
+  } else {
+    ESP_LOGE(TAG, "Failed to add peer: %s", esp_err_to_name(result));
+  }
+}
+
+// UNSAFE ACCROSS THREADS BUT EZ TO USE
+const char *MACtoString(uint8_t *macAddr) {
+  static char output[18]; // 17 Zeichen + 1 für Nullterminierung
+  sprintf(output, "%02X:%02X:%02X:%02X:%02X:%02X", macAddr[0], macAddr[1],
+          macAddr[2], macAddr[3], macAddr[4], macAddr[5]);
+  return output;
+}
+
+BaseMessage MessageBuilder(CommandPages commandPage, PayloadUnion payload,
+                           size_t payload_size) {
+  BaseMessage message;
+
+  // Initialisierung der BaseMessage
+  message.commandPage = commandPage;
+  message.version = 1;
+  message.length = (uint16_t)payload_size;
+
+  // Kopieren des Payloads in die Union
+  memset(&message.payload, 0, sizeof(message.payload)); // Sicherheitsmaßnahme
+  memcpy(&message.payload, &payload, payload_size);
+
+  return message;
+}
+
+void master_broadcast_task(void *param) {
+  while (1) {
+    BroadCastPayload payload = {};
+
+    BaseMessage message = MessageBuilder(
+        BroadCastPage, *(PayloadUnion *)&payload, sizeof(payload));
+
+    ESP_ERROR_CHECK(esp_now_send(broadcast_address, (uint8_t *)&message,
+                                 sizeof(BaseMessage)));
+    ESP_LOGI(TAG, "Broadcast Message sent");
+    vTaskDelay(pdMS_TO_TICKS(5000));
+  }
+}
+
+void master_ping_task(void *param) {
+  while (1) {
+    for (size_t i = 0; i < MAX_CLIENTS; ++i) {
+      if (clients[i].isAvailable) {
+        PingPayload payload = {};
+        payload.timestamp = esp_timer_get_time();
+        BaseMessage message = MessageBuilder(
+            PingPage, *(PayloadUnion *)&payload, sizeof(payload));
+        esp_now_send(clients[i].macAddr, (uint8_t *)&message,
+                     sizeof(BaseMessage));
+        ESP_LOGI(TAG, "SENDING PING!!!!");
+      }
+    }
+    vTaskDelay(pdMS_TO_TICKS(1000));
+  }
+}
+
+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");
+  ESP_LOGI(TAG, "Message: %.*s", data_len, data);
+
+  const BaseMessage *message = (const BaseMessage *)data;
+  switch (message->commandPage) {
+  case StatusPage:
+    ESP_LOGI(TAG, "GOT STATUS MESSAGE");
+    break;
+  case PingPage:
+    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
+
+    for (int i = 0; i < MAX_CLIENTS; i++) {
+      // Überprüfen, ob der Client existiert und die MAC-Adresse übereinstimmt
+      if (clients[i].isAvailable &&
+          memcmp(clients[i].macAddr, esp_now_info->src_addr,
+                 ESP_NOW_ETH_ALEN) == 0) {
+        clients[i].lastSuccessfullPing = xTaskGetTickCount();
+        ESP_LOGI(TAG, "Updated client %d last ping time to %lu", i,
+                 clients[i].lastSuccessfullPing);
+        break;
+      }
+    }
+    break;
+  case BroadCastPage:
+    ESP_LOGI(TAG, "MASTER SHOULD NOT GET BROADCAST MESSAGE, is there another "
+                  "master calling?");
+    break;
+  case RegisterPage:
+    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");
+      for (int i = 0; i < MAX_CLIENTS; i++) {
+        // client in liste wiederfinden
+        if (!clients[i].isAvailable &&
+            memcmp(clients[i].macAddr, esp_now_info->src_addr,
+                   ESP_NOW_ETH_ALEN) == 0) {
+          clients[i].isAvailable = true;
+          clients[i].lastSuccessfullPing = xTaskGetTickCount();
+          ESP_LOGI(TAG, "Updated client %d last ping time to %lu", i,
+                   clients[i].lastSuccessfullPing);
+          break;
+        }
+      }
+      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):
+      ESP_LOGI(TAG, "CLIENT WIRD IN DIE LISTE AUFGENOMMEN");
+      add_peer(esp_now_info->src_addr);
+      break;
+    default:
+      ESP_LOGI(TAG, "Unknown Message %i", checkPeer);
+    }
+
+    break;
+  default:
+    break;
+  }
+}
+
+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: %02X:%02X:%02X:%02X:%02X:%02X",
+           esp_now_info->src_addr[0], esp_now_info->src_addr[1],
+           esp_now_info->src_addr[2], esp_now_info->src_addr[3],
+           esp_now_info->src_addr[4], esp_now_info->src_addr[5]);
+  ESP_LOGI(TAG, "Message: %.*s", data_len, data);
+
+  BaseMessage replyMessage = {};
+
+  const BaseMessage *message = (const BaseMessage *)data;
+  switch (message->commandPage) {
+  case StatusPage:
+    ESP_LOGI(TAG, "GOT STATUS MESSAGE");
+    break;
+  case PingPage:
+    ESP_LOGI(TAG, "GOT PING MESSAGE");
+    replyMessage = MessageBuilder(PingPage, *(PayloadUnion *)&message->payload,
+                                  sizeof(message->payload));
+    ESP_ERROR_CHECK(esp_now_send(
+        esp_now_info->src_addr, (uint8_t *)&replyMessage, sizeof(BaseMessage)));
+    break;
+  case BroadCastPage:
+    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);
+        replyMessage =
+            MessageBuilder(RegisterPage, *(PayloadUnion *)&message->payload,
+                           sizeof(message->payload));
+        ESP_ERROR_CHECK(esp_now_send(esp_now_info->src_addr,
+                                     (uint8_t *)&replyMessage,
+                                     sizeof(BaseMessage)));
+        hasMaster = true;
+      }
+    }
+    break;
+  case RegisterPage:
+    break;
+  default:
+    ESP_LOGI(TAG, "GOT UNKONW MESSAGE");
+    break;
+  }
+}
+
+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)); // Sende Daten an Master
+    vTaskDelay(pdMS_TO_TICKS(5000));
+  }
+}
+
+void client_monitor_task(void *pvParameters) {
+  TickType_t timeout_ticks =
+      pdMS_TO_TICKS(CLIENT_TIMEOUT_MS); // Timeout in Ticks
+  TickType_t interval_ticks =
+      pdMS_TO_TICKS(CHECK_INTERVAL_MS); // Prüfintervall in Ticks
+
+  while (1) {
+    TickType_t now = xTaskGetTickCount(); // Aktuelle Zeit in Ticks
+
+    for (int i = 0; i < MAX_CLIENTS; i++) {
+      if (clients[i].isAvailable) {
+        TickType_t time_diff = now - clients[i].lastSuccessfullPing;
+
+        // Prüfen, ob der Client als "nicht verfügbar" markiert werden soll
+        if (time_diff > timeout_ticks) {
+          clients[i].isAvailable = false;
+          ESP_LOGW(
+              TAG,
+              "Client %d (MAC: %02X:%02X:%02X:%02X:%02X:%02X) is unavailable",
+              i, clients[i].macAddr[0], clients[i].macAddr[1],
+              clients[i].macAddr[2], clients[i].macAddr[3],
+              clients[i].macAddr[4], clients[i].macAddr[5]);
+        }
+      }
+    }
+
+    // Task für das Prüfintervall anhalten
+    vTaskDelay(interval_ticks);
+  }
+}

main/communication_handler.h

@@ -0,0 +1,90 @@
+#ifndef COMMUNICATION_HANDLER_H
+#define COMMUNICATION_HANDLER_H
+
+#include <esp_now.h>
+#include <esp_wifi.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/queue.h>
+#include <freertos/task.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.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)
+
+#define MAX_CLIENTS 19
+#define MESSAGE_QUEUE_SIZE 10
+
+typedef enum {
+  BroadCastPage,
+  StatusPage,
+  PingPage,
+  RegisterPage,
+} CommandPages;
+
+typedef struct {
+  uint32_t uptime;
+  uint8_t status;
+} StatusPayload;
+
+typedef struct {
+  uint32_t timestamp;
+} PingPayload;
+
+typedef struct {
+} BroadCastPayload;
+
+typedef struct {
+  bool familierClient;
+} RegisterPayload;
+
+typedef union {
+  StatusPayload status_payload;
+  PingPayload ping_payload;
+  BroadCastPayload broadcast_payload;
+  RegisterPayload register_payload;
+} PayloadUnion;
+
+typedef struct {
+  uint16_t version;
+  CommandPages commandPage;
+  uint16_t length;
+  PayloadUnion payload;
+} BaseMessage;
+
+static_assert(sizeof(BaseMessage) <= 255,
+              "BaseMessage darf nicht größer als 255 sein");
+
+typedef struct {
+  uint8_t macAddr[ESP_NOW_ETH_ALEN];
+  int rssi;
+  bool isAvailable;
+  TickType_t lastSuccessfullPing;
+} ClientInfo;
+
+void init_com();
+int getNextFreeClientId();
+void add_peer(uint8_t *macAddr);
+const char *MACtoString(uint8_t *macAddr);
+BaseMessage MessageBuilder(CommandPages commandPage, PayloadUnion payload,
+                           size_t payload_size);
+
+void master_broadcast_task(void *param);
+void master_ping_task(void *param);
+void master_receive_callback(const esp_now_recv_info_t *esp_now_info,
+                             const uint8_t *data, int data_len);
+
+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_monitor_task(void *pvParameters);
+
+#endif

main/main.c

@@ -9,307 +9,10 @@
 #include "nvs_flash.h"
 
 #include "main.h"
-// return any inactive client field for new usage
+#include "uart_handler.h"
-int getNextFreeClientId() {
+#include "communication_handler.h"
-  for (int i = 0; i < numClients; i++) {
-    if (!clients[i].isAvailable) {
-      return i;
-    }
-  }
-  return 0;
-}
 
-void add_peer(uint8_t *macAddr) {
+static const char *TAG = "ALOX - MAIN";
-  esp_now_peer_info_t peerInfo = {
-      .channel =
-          0, // Standardkanal, sollte mit den anderen Geräten übereinstimmen
-      .ifidx = ESP_IF_WIFI_STA,
-      .encrypt = false, // Keine Verschlüsselung (kann geändert werden)
-  };
-  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: %02X:%02X:%02X:%02X:%02X:%02X", macAddr[0],
-             macAddr[1], macAddr[2], macAddr[3], macAddr[4], macAddr[5]);
-
-    if (!IS_BROADCAST_ADDR(macAddr)) {
-
-      if (numClients >= MAX_CLIENTS) {
-        ESP_LOGW(TAG, "Cannot add more clients, maximum reached.");
-        return;
-      }
-
-      ClientInfo newClient = {};
-      memcpy(newClient.macAddr, macAddr, ESP_NOW_ETH_ALEN);
-      newClient.isAvailable = true;
-      newClient.lastSuccessfullPing = xTaskGetTickCount();
-      clients[getNextFreeClientId()] = newClient;
-      ESP_LOGI(TAG, "New client added.");
-    }
-  } else if (result == ESP_ERR_ESPNOW_EXIST) {
-    ESP_LOGW(TAG, "Peer already exists.");
-    // Überprüfen, ob der Client bereits existiert
-    for (int i = 0; i < numClients; i++) {
-      if (memcmp(clients[i].macAddr, macAddr, ESP_NOW_ETH_ALEN) == 0) {
-        ESP_LOGI(TAG, "Client found again, welcome back!");
-        clients[i].isAvailable = true; // Reaktiviere den Client
-        break;
-      }
-    }
-  } else {
-    ESP_LOGE(TAG, "Failed to add peer: %s", esp_err_to_name(result));
-  }
-}
-
-// UNSAFE ACCROSS THREADS BUT EZ TO USE
-const char *MACtoString(uint8_t *macAddr) {
-  static char output[18]; // 17 Zeichen + 1 für Nullterminierung
-  sprintf(output, "%02X:%02X:%02X:%02X:%02X:%02X", macAddr[0], macAddr[1],
-          macAddr[2], macAddr[3], macAddr[4], macAddr[5]);
-  return output;
-}
-
-BaseMessage MessageBuilder(CommandPages commandPage, PayloadUnion payload,
-                           size_t payload_size) {
-  BaseMessage message;
-
-  // Initialisierung der BaseMessage
-  message.commandPage = commandPage;
-  message.version = 1;
-  message.length = (uint16_t)payload_size;
-
-  // Kopieren des Payloads in die Union
-  memset(&message.payload, 0, sizeof(message.payload)); // Sicherheitsmaßnahme
-  memcpy(&message.payload, &payload, payload_size);
-
-  return message;
-}
-
-void master_broadcast_task(void *param) {
-  while (1) {
-    BroadCastPayload payload = {};
-
-    BaseMessage message = MessageBuilder(
-        BroadCastPage, *(PayloadUnion *)&payload, sizeof(payload));
-
-    ESP_ERROR_CHECK(esp_now_send(broadcast_address, (uint8_t *)&message,
-                                 sizeof(BaseMessage)));
-    ESP_LOGI(TAG, "Broadcast Message sent");
-    vTaskDelay(pdMS_TO_TICKS(5000));
-  }
-}
-
-void master_ping_task(void *param) {
-  while (1) {
-    for (size_t i = 0; i < MAX_CLIENTS; ++i) {
-      if (clients[i].isAvailable) {
-        PingPayload payload = {};
-        payload.timestamp = esp_timer_get_time();
-        BaseMessage message = MessageBuilder(
-            PingPage, *(PayloadUnion *)&payload, sizeof(payload));
-        esp_now_send(clients[i].macAddr, (uint8_t *)&message,
-                     sizeof(BaseMessage));
-        ESP_LOGI(TAG, "SENDING PING!!!!");
-      }
-    }
-    vTaskDelay(pdMS_TO_TICKS(1000));
-  }
-}
-
-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");
-  ESP_LOGI(TAG, "Message: %.*s", data_len, data);
-
-  const BaseMessage *message = (const BaseMessage *)data;
-  switch (message->commandPage) {
-  case StatusPage:
-    ESP_LOGI(TAG, "GOT STATUS MESSAGE");
-    break;
-  case PingPage:
-    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
-
-    for (int i = 0; i < MAX_CLIENTS; i++) {
-      // Überprüfen, ob der Client existiert und die MAC-Adresse übereinstimmt
-      if (clients[i].isAvailable &&
-          memcmp(clients[i].macAddr, esp_now_info->src_addr,
-                 ESP_NOW_ETH_ALEN) == 0) {
-        clients[i].lastSuccessfullPing = xTaskGetTickCount();
-        ESP_LOGI(TAG, "Updated client %d last ping time to %lu", i,
-                 clients[i].lastSuccessfullPing);
-        break;
-      }
-    }
-    break;
-  case BroadCastPage:
-    ESP_LOGI(TAG, "MASTER SHOULD NOT GET BROADCAST MESSAGE, is there another "
-                  "master calling?");
-    break;
-  case RegisterPage:
-    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");
-      for (int i = 0; i < MAX_CLIENTS; i++) {
-            // client in liste wiederfinden
-        if (!clients[i].isAvailable &&
-            memcmp(clients[i].macAddr, esp_now_info->src_addr,
-                   ESP_NOW_ETH_ALEN) == 0) {
-          clients[i].isAvailable = true;
-          clients[i].lastSuccessfullPing = xTaskGetTickCount();
-          ESP_LOGI(TAG, "Updated client %d last ping time to %lu", i,
-                   clients[i].lastSuccessfullPing);
-          break;
-        }
-      }
-      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):
-      ESP_LOGI(TAG, "CLIENT WIRD IN DIE LISTE AUFGENOMMEN");
-      add_peer(esp_now_info->src_addr);
-      break;
-    default:
-      ESP_LOGI(TAG, "Unknown Message %i", checkPeer);
-    }
-
-    break;
-  default:
-    break;
-  }
-}
-
-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: %02X:%02X:%02X:%02X:%02X:%02X",
-           esp_now_info->src_addr[0], esp_now_info->src_addr[1],
-           esp_now_info->src_addr[2], esp_now_info->src_addr[3],
-           esp_now_info->src_addr[4], esp_now_info->src_addr[5]);
-  ESP_LOGI(TAG, "Message: %.*s", data_len, data);
-
-  BaseMessage replyMessage = {};
-
-  const BaseMessage *message = (const BaseMessage *)data;
-  switch (message->commandPage) {
-  case StatusPage:
-    ESP_LOGI(TAG, "GOT STATUS MESSAGE");
-    break;
-  case PingPage:
-    ESP_LOGI(TAG, "GOT PING MESSAGE");
-    replyMessage = MessageBuilder(PingPage, *(PayloadUnion *)&message->payload,
-                                  sizeof(message->payload));
-    ESP_ERROR_CHECK(esp_now_send(
-        esp_now_info->src_addr, (uint8_t *)&replyMessage, sizeof(BaseMessage)));
-    break;
-  case BroadCastPage:
-    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);
-        replyMessage =
-            MessageBuilder(RegisterPage, *(PayloadUnion *)&message->payload,
-                           sizeof(message->payload));
-        ESP_ERROR_CHECK(esp_now_send(esp_now_info->src_addr,
-                                     (uint8_t *)&replyMessage,
-                                     sizeof(BaseMessage)));
-        hasMaster = true;
-      }
-    }
-    break;
-  case RegisterPage:
-    break;
-  default:
-    ESP_LOGI(TAG, "GOT UNKONW MESSAGE");
-    break;
-  }
-}
-
-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)); // Sende Daten an Master
-    vTaskDelay(pdMS_TO_TICKS(5000));
-  }
-}
-
-void client_monitor_task(void *pvParameters) {
-  TickType_t timeout_ticks =
-      pdMS_TO_TICKS(CLIENT_TIMEOUT_MS); // Timeout in Ticks
-  TickType_t interval_ticks =
-      pdMS_TO_TICKS(CHECK_INTERVAL_MS); // Prüfintervall in Ticks
-
-  while (1) {
-    TickType_t now = xTaskGetTickCount(); // Aktuelle Zeit in Ticks
-
-    for (int i = 0; i < MAX_CLIENTS; i++) {
-      if (clients[i].isAvailable) {
-        TickType_t time_diff = now - clients[i].lastSuccessfullPing;
-
-        // Prüfen, ob der Client als "nicht verfügbar" markiert werden soll
-        if (time_diff > timeout_ticks) {
-          clients[i].isAvailable = false;
-          ESP_LOGW(
-              TAG,
-              "Client %d (MAC: %02X:%02X:%02X:%02X:%02X:%02X) is unavailable",
-              i, clients[i].macAddr[0], clients[i].macAddr[1],
-              clients[i].macAddr[2], clients[i].macAddr[3],
-              clients[i].macAddr[4], clients[i].macAddr[5]);
-        }
-      }
-    }
-
-    // Task für das Prüfintervall anhalten
-    vTaskDelay(interval_ticks);
-  }
-}
-
-void uart_read_task(void *param) {
-  uint8_t *data = (uint8_t *)malloc(BUF_SIZE);
-  int len = 0;
-  while (1) {
-    len = 0;
-    len =
-        uart_read_bytes(MASTER_UART, data, BUF_SIZE, (20 / portTICK_PERIOD_MS));
-    if (len > 0) {
-      data[len] = '\0';
-      ESP_LOGI(TAG, "GOT UART DATA %s", data);
-      uart_write_bytes(MASTER_UART, data, len);
-    }
-  }
-}
-
-void init_uart() {
-  uart_config_t uart_config = {.baud_rate = 115200,
-                               .data_bits = UART_DATA_8_BITS,
-                               .parity = UART_PARITY_DISABLE,
-                               .stop_bits = UART_STOP_BITS_1,
-                               .flow_ctrl = UART_HW_FLOWCTRL_DISABLE};
-
-  uart_driver_install(MASTER_UART, BUF_SIZE * 2, 0, 0, NULL, 0);
-  uart_param_config(MASTER_UART, &uart_config);
-  uart_set_pin(MASTER_UART, TXD_PIN, RXD_PIN, UART_PIN_NO_CHANGE,
-               UART_PIN_NO_CHANGE);
-  xTaskCreate(uart_read_task, "Read Uart", 4096, NULL, 1, NULL);
-}
 
 void app_main(void) {
   esp_err_t ret = nvs_flash_init();
@@ -348,8 +51,7 @@ void app_main(void) {
     ESP_ERROR_CHECK(esp_now_register_recv_cb(client_receive_callback));
   }
 
-  // Nachrichtenschlange initialisieren
+  init_com();
-  messageQueue = xQueueCreate(10, sizeof(char *));
 
   // Tasks starten basierend auf Master/Client
   if (isMaster) {

main/main.h

@@ -15,75 +15,5 @@
 #include <string.h>
 
 #define MASTER_MODE_PIN GPIO_NUM_23 // Jumper-Erkennungspin
-#define MASTER_UART UART_NUM_2
-#define BROADCAST_INTERVAL_MS 500
-
-#define BUF_SIZE (1024)
-#define TXD_PIN (GPIO_NUM_17)
-#define RXD_PIN (GPIO_NUM_16)
-
-#define CLIENT_TIMEOUT_MS 5000 // 5 Sekunden Timeout
-#define CHECK_INTERVAL_MS 1000 // Jede Sekunde überprüfen
-
-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)
-
-typedef enum {
-  BroadCastPage,
-  StatusPage,
-  PingPage,
-  RegisterPage,
-} CommandPages;
-
-typedef struct {
-  uint32_t uptime;
-  uint8_t status;
-} StatusPayload;
-
-typedef struct {
-  uint32_t timestamp;
-} PingPayload;
-
-typedef struct {
-} BroadCastPayload;
-
-typedef struct {
-  bool familierClient;
-} RegisterPayload;
-
-typedef union {
-  StatusPayload status_payload;
-  PingPayload ping_payload;
-  BroadCastPayload broadcast_payload;
-  RegisterPayload register_payload;
-} PayloadUnion;
-
-typedef struct {
-  uint16_t version;
-  CommandPages commandPage;
-  uint16_t length;
-  PayloadUnion payload;
-} BaseMessage;
-
-static_assert(sizeof(BaseMessage) <= 255,
-              "BaseMessage darf nicht größer als 255 sein");
-
-QueueHandle_t messageQueue; // Warteschlange für empfangene Nachrichten
-const char *TAG = "ALOX";
-
-typedef struct {
-  uint8_t macAddr[ESP_NOW_ETH_ALEN];
-  int rssi;
-  bool isAvailable;
-  TickType_t lastSuccessfullPing;
-} ClientInfo;
-
-#define MAX_CLIENTS 19
-ClientInfo clients[MAX_CLIENTS];
-size_t numClients = 0;
-size_t activeClients = 0;
-bool hasMaster = false;
 
 #endif

main/uart_handler.c

@@ -0,0 +1,38 @@
+#include "driver/uart.h"
+#include "driver/gpio.h"
+#include "esp_log.h"
+#include "hal/uart_types.h"
+#include "nvs_flash.h"
+
+#include "uart_handler.h"
+
+static const char *TAG = "ALOX - UART";
+
+void init_uart() {
+  uart_config_t uart_config = {.baud_rate = 115200,
+                               .data_bits = UART_DATA_8_BITS,
+                               .parity = UART_PARITY_DISABLE,
+                               .stop_bits = UART_STOP_BITS_1,
+                               .flow_ctrl = UART_HW_FLOWCTRL_DISABLE};
+
+  uart_driver_install(MASTER_UART, BUF_SIZE * 2, 0, 0, NULL, 0);
+  uart_param_config(MASTER_UART, &uart_config);
+  uart_set_pin(MASTER_UART, TXD_PIN, RXD_PIN, UART_PIN_NO_CHANGE,
+               UART_PIN_NO_CHANGE);
+  xTaskCreate(uart_read_task, "Read Uart", 4096, NULL, 1, NULL);
+}
+
+void uart_read_task(void *param) {
+  uint8_t *data = (uint8_t *)malloc(BUF_SIZE);
+  int len = 0;
+  while (1) {
+    len = 0;
+    len =
+        uart_read_bytes(MASTER_UART, data, BUF_SIZE, (20 / portTICK_PERIOD_MS));
+    if (len > 0) {
+      data[len] = '\0';
+      ESP_LOGI(TAG, "GOT UART DATA %s", data);
+      uart_write_bytes(MASTER_UART, data, len);
+    }
+  }
+}

main/uart_handler.h

@@ -0,0 +1,13 @@
+#ifndef UART_HANDLER_H
+#define UART_HANDLER_H
+
+#define MASTER_UART UART_NUM_2
+#define TXD_PIN (GPIO_NUM_17)
+#define RXD_PIN (GPIO_NUM_16)
+
+#define BUF_SIZE (1024)
+
+void init_uart();
+void uart_read_task(void *param);
+
+#endif