226 lines
7.7 KiB
C
226 lines
7.7 KiB
C
#include "client_handler.h"
|
|
#include "driver/gpio.h"
|
|
#include "driver/uart.h"
|
|
#include "esp_log.h"
|
|
#include "esp_phy_init.h"
|
|
#include "esp_rom_gpio.h"
|
|
#include "esp_timer.h"
|
|
#include "esp_wifi.h"
|
|
#include "freertos/idf_additions.h"
|
|
#include "hal/uart_types.h"
|
|
#include "message_handler.h"
|
|
#include "message_parser.h"
|
|
#include "nvs_flash.h"
|
|
|
|
#include "communication_handler.h"
|
|
#include "main.h"
|
|
#include "uart_handler.h"
|
|
#include <stdbool.h>
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
|
|
#include "message_builder.h"
|
|
|
|
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 - 4];
|
|
|
|
static MessageBrokerTaskParams_t broker_task_params;
|
|
|
|
ClientList clientList = {.Clients = {{0}}, .ClientCount = 0};
|
|
|
|
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) {
|
|
ESP_LOGI(TAG, "Echo command 0x01...");
|
|
int len =
|
|
build_message(0x01, payload, payload_len, 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 versionCallback(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, "Version command 0x02...");
|
|
size_t git_build_hash_len = strlen(BUILD_GIT_HASH);
|
|
size_t needed_buffer_size = 2 + git_build_hash_len;
|
|
|
|
if (send_payload_buffer_size < needed_buffer_size) {
|
|
ESP_LOGE(TAG, "send_payload_buffer to small size %d need %d",
|
|
send_payload_buffer_size, needed_buffer_size);
|
|
return;
|
|
}
|
|
|
|
send_payload_buffer[0] = (uint8_t)(version & 0xFF);
|
|
send_payload_buffer[1] = (uint8_t)((version >> 8) & 0xFF);
|
|
memcpy(&send_payload_buffer[2], &BUILD_GIT_HASH, git_build_hash_len);
|
|
|
|
int len = build_message(0x02, send_payload_buffer, needed_buffer_size,
|
|
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 clientInfoCallback(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, "Client Info Command 0x03...");
|
|
static uint8_t entryLength = 17;
|
|
uint8_t needed_buffer_size = 1 + entryLength * clientList.ClientCount;
|
|
|
|
if (send_payload_buffer_size < needed_buffer_size) {
|
|
ESP_LOGE(TAG, "send_payload_buffer to small size %d need %d",
|
|
send_payload_buffer_size, needed_buffer_size);
|
|
return;
|
|
}
|
|
|
|
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;
|
|
memcpy(&send_payload_buffer[offset + 3], clientList.Clients[i].macAddr,
|
|
MAC_LENGTH);
|
|
memcpy(&send_payload_buffer[offset + 9], &clientList.Clients[i].lastPing,
|
|
4);
|
|
memcpy(&send_payload_buffer[offset + 13],
|
|
&clientList.Clients[i].lastSuccessfullPing, 4);
|
|
}
|
|
}
|
|
|
|
int len = build_message(0x04, send_payload_buffer, needed_buffer_size,
|
|
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",
|
|
needed_buffer_size, send_buffer_size, len);
|
|
return;
|
|
}
|
|
uart_write_bytes(MASTER_UART, send_buffer, len);
|
|
}
|
|
|
|
void app_main(void) {
|
|
ESP_LOGI(TAG, "Starting Alox Powerpod Version %d Build: %s", version,
|
|
BUILD_GIT_HASH);
|
|
|
|
esp_err_t ret = nvs_flash_init();
|
|
if (ret == ESP_ERR_NVS_NO_FREE_PAGES ||
|
|
ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
|
|
ESP_ERROR_CHECK(nvs_flash_erase());
|
|
ret = nvs_flash_init();
|
|
}
|
|
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();
|
|
ESP_ERROR_CHECK(esp_wifi_init(&cfg));
|
|
wifi_config_t wifi_config = {
|
|
.sta =
|
|
{
|
|
.channel = 1, // Kanal 1, stelle sicher, dass alle Geräte
|
|
// denselben Kanal verwenden
|
|
},
|
|
};
|
|
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
|
|
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
|
|
ESP_ERROR_CHECK(esp_wifi_start());
|
|
ESP_ERROR_CHECK(esp_now_init());
|
|
|
|
if (isMaster) {
|
|
ESP_ERROR_CHECK(esp_now_register_recv_cb(master_receive_callback));
|
|
} else {
|
|
ESP_ERROR_CHECK(esp_now_register_recv_cb(client_receive_callback));
|
|
}
|
|
|
|
init_com(&clientList);
|
|
|
|
// Tasks starten basierend auf Master/Client
|
|
if (isMaster) {
|
|
ESP_LOGI(TAG, "Started in Mastermode");
|
|
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);
|
|
broker_task_params.payload_buffer = send_message_payload_buffer;
|
|
broker_task_params.payload_buffer_size =
|
|
sizeof(send_message_payload_buffer);
|
|
|
|
xTaskCreate(MessageBrokerTask, "message_handler_task", 4096,
|
|
(void *)&broker_task_params, 5, NULL);
|
|
|
|
RegisterCallback(0x01, echoCallback);
|
|
RegisterCallback(0x02, versionCallback);
|
|
RegisterCallback(0x03, clientInfoCallback);
|
|
|
|
// xTaskCreate(uart_status_task, "MasterUartStatusTask", 4096, NULL, 1,
|
|
// NULL); xTaskCreate(SendClientInfoTask, "SendCientInfo", 4096, NULL, 1,
|
|
// NULL);
|
|
} else {
|
|
ESP_LOGI(TAG, "Started in Slavemode");
|
|
xTaskCreate(client_data_sending_task, "ClientDataSending", 4096, NULL, 1,
|
|
NULL);
|
|
}
|
|
}
|