325 lines
11 KiB
C
325 lines
11 KiB
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();
|
|
newClient.lastPing = 0;
|
|
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++) {
|
|
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(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();
|
|
clients[i].lastPing = (diff/1000);
|
|
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);
|
|
}
|
|
}
|
|
|
|
ClientInfo *get_client_info(int entry) {
|
|
return &clients[entry];
|
|
}
|