esp_alox/main/communication_handler.c

#include "esp_log.h"
#include "esp_timer.h"
#include "freertos/idf_additions.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 < MAX_CLIENTS; i++) {
    if (!clients[i].isAvailable) {
      return i;
    }
  }
  return -1;
}

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",
             peerInfo.peer_addr[0], peerInfo.peer_addr[1],
             peerInfo.peer_addr[2], peerInfo.peer_addr[3],
             peerInfo.peer_addr[4], peerInfo.peer_addr[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_broadcast_ping(void *param) {
  while (1) {
    // BroadCastPayload payload = {};
    PingPayload payload = {};
    payload.timestamp = esp_timer_get_time();
    BaseMessage message =
        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));
  }
}



void master_ping_task(void *param) {
  while (1) {
    for (size_t i = 0; i < MAX_CLIENTS; i++) {
      // ESP_LOGI(TAG, "WANT TO SEND PING TO CLIENT %zu isAvailiable %d", i,
      //          clients[i].isAvailable);
      if (clients[i].isAvailable) {
        ESP_LOGI(TAG, "SEND PING TO %zu: %s", i,
                 MACtoString(clients[i].macAddr));
        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(5));
      }
    }
    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");

  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: %s last ping time to %lu", i,
                 MACtoString(clients[i].macAddr),
                 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:
    ESP_LOGI(TAG, "Unknown CommandPage %i", message->commandPage);
    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);
  }
}