skruecken/esp_alox
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Compare commits

base: skruecken:672267b99174744b26c10eda68450a54700547a3
Branches Tags
skruecken:master
skruecken:ai_slop
..
compare: skruecken:b29512d92213f0d26add711dfead913ecd59fd86
Branches Tags
skruecken:ai_slop
skruecken:master

No commits in common. "672267b99174744b26c10eda68450a54700547a3" and "b29512d92213f0d26add711dfead913ecd59fd86" have entirely different histories.
672267b991 ... b29512d922

3 changed files with 23 additions and 133 deletions
Show Stats Expand all files Collapse all files

117
main/communication_handler.c
View File

@ -8,18 +8,15 @@
#include <stdbool.h> #include <stdbool.h>
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h>
#include <sys/types.h> #include <sys/types.h>
static const char *TAG = "ALOX - COM"; static const char *TAG = "ALOX - COM";
static struct ESP_MessageBroker mr; static struct ESP_MessageBroker mr;
static QueueHandle_t ESP_recieved_message_queue;
void ESP_InitMessageBroker(QueueHandle_t msg_queue_handle) { void ESP_InitMessageBroker() {
mr.num_direct_callbacks = 0; mr.num_direct_callbacks = 0;
mr.num_task_callbacks = 0; mr.num_task_callbacks = 0;
ESP_recieved_message_queue = msg_queue_handle;
return; return;
} }
@ -38,12 +35,15 @@ void ESP_RegisterTask(CommandPages command, ESP_RegisterTaskCallback callback) {
} }
void ESP_MessageBrokerTask(void *param) { void ESP_MessageBrokerTask(void *param) {
ESPNOW_MessageInfo received_msg; ParsedMessage_t received_msg;
ESP_MessageBrokerTaskParams_t *task_params = MessageBrokerTaskParams_t *task_params = (MessageBrokerTaskParams_t *)param;
(ESP_MessageBrokerTaskParams_t *)param;
// Extrahiere die einzelnen Parameter // Extrahiere die einzelnen Parameter
QueueHandle_t msg_queue = task_params->message_queue; QueueHandle_t msg_queue = task_params->message_queue;
uint8_t *send_message_buffer = task_params->send_buffer;
size_t send_message_buffer_size = task_params->send_buffer_size;
uint8_t *send_payload_buffer = task_params->payload_buffer;
size_t send_payload_buffer_size = task_params->payload_buffer_size;
if (msg_queue == NULL) { if (msg_queue == NULL) {
ESP_LOGE(TAG, "Message queue not initialized. Terminating task."); ESP_LOGE(TAG, "Message queue not initialized. Terminating task.");
@ -54,25 +54,23 @@ void ESP_MessageBrokerTask(void *param) {
while (1) { while (1) {
if (xQueueReceive(msg_queue, &received_msg, portMAX_DELAY)) { if (xQueueReceive(msg_queue, &received_msg, portMAX_DELAY)) {
//ESP_LOGI(TAG, "Received message from queue: MSGID=0x%02X, Length=%u",
// received_msg.msgid, received_msg.payload_len);
ESP_LOGI(TAG, "Broker got message trying to relay it now");
const BaseMessage *message = (const BaseMessage *)received_msg.data;
ESP_LOGI(TAG, "Broker searching for command page %d",
message->commandPage);
for (int i = 0; i < mr.num_direct_callbacks; i++) { for (int i = 0; i < mr.num_direct_callbacks; i++) {
if (mr.FunctionList[i].MSGID == message->commandPage) { if (mr.FunctionList[i].MSGID == received_msg) {
mr.FunctionList[i].callback(&received_msg.esp_now_info, mr.FunctionList[i].callback(
received_msg.data, received_msg.data_len); received_msg.msgid, received_msg.data, received_msg.payload_len,
ESP_LOGI(TAG, "Broker found matching msgid %d", send_payload_buffer, send_payload_buffer_size,
mr.FunctionList[i].MSGID); send_message_buffer, send_message_buffer_size);
} }
} }
for (int i = 0; i < mr.num_direct_callbacks; i++) { for (int i = 0; i < mr.num_direct_callbacks; i++) {
// if (mr.FunctionList[i].MSGID == received_msg.msgid) { if (mr.FunctionList[i].MSGID == received_msg.msgid) {
// TODO: Not yet implemented // TODO: Not yet implemented
// Only send data to task, task should be created beforhead and wait // Only send data to task, task should be created beforhead and wait
// for new data in the queue. // for new data in the queue.
//} }
} }
} }
} }
@ -197,93 +195,10 @@ 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 " MACSTR, MAC2STR(esp_now_info->src_addr));
ESP_LOGI(TAG,
"Status Message Received: status: %d, runningPartition: %d, uptime: "
"%d, version: %d",
message->payload.status_payload.status,
message->payload.status_payload.runningPartition,
message->payload.status_payload.uptime,
message->payload.status_payload.version);
}
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):
ESP_LOGI(TAG, "CLIENT WIRD IN DIE LISTE AUFGENOMMEN");
add_peer(esp_now_info->src_addr);
ESP_LOGI(TAG, "FRAGE CLIENT STATUS AN");
GetStatusPayload payload = {};
replyMessage = MessageBuilder(GetStatusPage, *(PayloadUnion *)&payload,
sizeof(payload));
ESP_ERROR_CHECK(esp_now_send(
esp_now_info->src_addr, (uint8_t *)&replyMessage, sizeof(BaseMessage)));
break;
default:
ESP_LOGI(TAG, "Unknown Message %i", checkPeer);
}
}
void ESPNOW_RegisterMasterCallbacks() {
ESP_RegisterFunction(StatusPage, master_StatusCallback);
ESP_RegisterFunction(RegisterPage, master_RegisterCallback);
}
void master_receive_callback(const esp_now_recv_info_t *esp_now_info, void master_receive_callback(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 GOT MESSAGE"); 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;
memcpy(&msg_info.esp_now_info, esp_now_info, sizeof(esp_now_recv_info_t));
msg_info.data = copied_data;
msg_info.data_len = data_len;
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;
// TODO: just testing if callback queue logic works here
BaseMessage replyMessage = {}; BaseMessage replyMessage = {};
const BaseMessage *message = (const BaseMessage *)data; const BaseMessage *message = (const BaseMessage *)data;
int id; int id;

16
main/communication_handler.h
View File

@ -138,24 +138,10 @@ struct ESP_MessageBroker {
uint8_t num_task_callbacks; uint8_t num_task_callbacks;
}; };
typedef struct { void ESP_InitMessageBroker();
QueueHandle_t message_queue;
} ESP_MessageBrokerTaskParams_t;
typedef struct {
esp_now_recv_info_t esp_now_info;
const uint8_t *data;
int data_len;
} ESPNOW_MessageInfo;
void ESP_InitMessageBroker(QueueHandle_t msg_queue_handle);
void ESP_RegisterFunction(CommandPages command, void ESP_RegisterFunction(CommandPages command,
ESP_RegisterFunctionCallback callback); ESP_RegisterFunctionCallback callback);
void ESP_RegisterTask(CommandPages command, ESP_RegisterTaskCallback callback); void ESP_RegisterTask(CommandPages command, ESP_RegisterTaskCallback callback);
void ESP_MessageBrokerTask(void *param);
void ESPNOW_RegisterMasterCallbacks();
int init_com(ClientList *clients, uint8_t wifi_channel); int init_com(ClientList *clients, uint8_t wifi_channel);
int getNextFreeClientId(); int getNextFreeClientId();

11
main/main.c
View File

@ -36,7 +36,6 @@ static uint8_t send_message_buffer[1024];
static uint8_t send_message_payload_buffer[512]; static uint8_t send_message_payload_buffer[512];
static MessageBrokerTaskParams_t broker_task_params; static MessageBrokerTaskParams_t broker_task_params;
static ESP_MessageBrokerTaskParams_t esp_broker_task_params;
ClientList clientList = {.Clients = {{0}}, .ClientCount = 0}; ClientList clientList = {.Clients = {{0}}, .ClientCount = 0};
@ -258,19 +257,9 @@ void app_main(void) {
} }
nvs_close(nt); nvs_close(nt);
QueueHandle_t espnow_message_queue =
xQueueCreate(10, sizeof(ESPNOW_MessageInfo));
ESP_InitMessageBroker(espnow_message_queue);
esp_broker_task_params.message_queue = espnow_message_queue;
xTaskCreate(ESP_MessageBrokerTask, "espnow_message_broker_task", 4096,
(void *)&esp_broker_task_params, 4, NULL);
// Tasks starten basierend auf Master/Client // Tasks starten basierend auf Master/Client
if (isMaster) { if (isMaster) {
ESP_LOGI(TAG, "Started in Mastermode"); ESP_LOGI(TAG, "Started in Mastermode");
ESPNOW_RegisterMasterCallbacks();
add_peer(broadcast_address); add_peer(broadcast_address);
xTaskCreate(master_broadcast_task, "MasterBroadcast", 4096, NULL, 1, NULL); xTaskCreate(master_broadcast_task, "MasterBroadcast", 4096, NULL, 1, NULL);
// xTaskCreate(master_ping_task, "MasterPing", 4096, NULL, 1, NULL); // xTaskCreate(master_ping_task, "MasterPing", 4096, NULL, 1, NULL);