From c387e27748e3aab809eb93cdf4e9c72f9fcf5fb8 Mon Sep 17 00:00:00 2001 From: Nanokloon Date: Mon, 28 Sep 2026 11:39:34 +0200 Subject: [PATCH] Functional prototype! --- main/CMakeLists.txt | 15 +- main/mcu-code.cpp | 63 ++++++- main/oled_display/oled_display.cpp | 5 + main/oled_display/oled_display.h | 13 ++ main/peripherals/lp_uart_serial.cpp | 5 + main/peripherals/lp_uart_serial.h | 26 +++ main/peripherals/uart_serial.cpp | 64 +++++++ main/peripherals/uart_serial.h | 52 +++++ main/peripherals/usb_serial.cpp | 1 - main/peripherals/usb_serial.h | 10 +- main/peripherals/wireless_comms.cpp | 283 ++++++++++++++++++++++++++++ main/peripherals/wireless_comms.h | 137 ++++++++++++++ sdkconfig | 94 ++++----- 13 files changed, 713 insertions(+), 55 deletions(-) create mode 100644 main/oled_display/oled_display.cpp create mode 100644 main/oled_display/oled_display.h create mode 100644 main/peripherals/lp_uart_serial.cpp create mode 100644 main/peripherals/lp_uart_serial.h create mode 100644 main/peripherals/uart_serial.cpp create mode 100644 main/peripherals/uart_serial.h create mode 100644 main/peripherals/wireless_comms.cpp create mode 100644 main/peripherals/wireless_comms.h diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt index b39485a..12518b2 100644 --- a/main/CMakeLists.txt +++ b/main/CMakeLists.txt @@ -1,2 +1,13 @@ -idf_component_register(SRCS mcu-code.cpp peripherals/usb_serial.cpp peripherals/usb_serial.h - INCLUDE_DIRS ".") +idf_component_register(SRCS + mcu-code.cpp + peripherals/usb_serial.cpp + peripherals/usb_serial.h + peripherals/uart_serial.cpp + peripherals/uart_serial.h + peripherals/wireless_comms.cpp + peripherals/wireless_comms.h + peripherals/lp_uart_serial.cpp + peripherals/lp_uart_serial.h + oled_display/oled_display.cpp + oled_display/oled_display.h + INCLUDE_DIRS ".") diff --git a/main/mcu-code.cpp b/main/mcu-code.cpp index 6c074a0..04847db 100644 --- a/main/mcu-code.cpp +++ b/main/mcu-code.cpp @@ -1,6 +1,8 @@ #include +#include "peripherals/uart_serial.h" #include "peripherals/usb_serial.h" +#include "peripherals/wireless_comms.h" /// /// So i lost all the code from the previous version of this due to messing with git. @@ -10,11 +12,62 @@ /// Nicholas - 23/08/2026 @ 21:36 /// -const char* test = "amai zeg"; +const char *test = "amai zeg\n"; + +#define NODE_NUMBER 1 +#define TOTAL_NUMBER_OF_NODES 4 -extern "C" void app_main(void) -{ - usb_serial::init(); - usb_serial::write(test,strlen(test)); +uint8_t node_mac[ESP_NOW_ETH_ALEN] = {0xDE, 0xD5, 0xEC, 0x00, 0x00, 0x02}; + +uint8_t peer_mac[ESP_NOW_ETH_ALEN] = {0xDE, 0xD5, 0xEC, 0x00, 0x00, 0x01}; + +uint8_t peer_list[TOTAL_NUMBER_OF_NODES][ESP_NOW_ETH_ALEN]; + +typedef struct communications { + uart_serial uart; + wireless_comms *wireless; +} communications; + + +void main_task(void *pvParameter) { + auto comms = reinterpret_cast(pvParameter); + uart_serial uart = comms->uart; + char data; + while (true) { + if (usb_serial::read_byte(&data)) { + wireless_comms::send_byte(data); + uart.write_byte(&data); + } + if (uart.read_byte(&data)) { + ESP_LOGI("uart", "received data"); + wireless_comms::send_byte(data); + usb_serial::write_byte(&data); + } + } +} + +extern "C" void app_main(void) { + esp_log_level_set("*", ESP_LOG_NONE); + usb_serial::init(); + uart_serial uart(UART_NUM_0, GPIO_NUM_18, GPIO_NUM_19, 9600); + wireless_comms wireless; + + //usb_serial::write(test,strlen(test)); + communications comms = {.uart = uart, .wireless = &wireless}; + /* + uint8_t peer_gen[ESP_NOW_ETH_ALEN] = {0xDE, 0xD5, 0xEC, 0x00, 0x00, 0x00}; + for(int i=2;i size) { + uart_read_bytes(uart_num,data,size,100); + return size; + } + uart_read_bytes(uart_num,data,length,100); + return length; +} + +/*int uart_serial::read_byte(char* data) { + int length = 0; + ESP_LOGI("sanity check","uart num: %d",uart_num); + ESP_ERROR_CHECK(uart_get_buffered_data_len(uart_num,(size_t *) &length)); + if (length) { + uart_read_bytes(uart_num,data,1,100); + return 1; + } + return 0; +}*/ + +int uart_serial::read_byte(char* data) { + size_t length = 0; + esp_err_t err = uart_get_buffered_data_len(this->uart_num, &length); + if (err != ESP_OK) { + ESP_LOGE("uart_serial", "get_buffered_data_len failed on port %d: %s", + uart_num, esp_err_to_name(err)); + return 0; + } + if (length > 0) { + int n = uart_read_bytes(uart_num, data, 1, pdMS_TO_TICKS(100)); + return (n == 1) ? 1 : 0; + } + return 0; +} \ No newline at end of file diff --git a/main/peripherals/uart_serial.h b/main/peripherals/uart_serial.h new file mode 100644 index 0000000..5f58535 --- /dev/null +++ b/main/peripherals/uart_serial.h @@ -0,0 +1,52 @@ +// +// Created by nano on 8/23/26. +// + +#ifndef MCU_CODE_UART_SERIAL_H +#define MCU_CODE_UART_SERIAL_H +#include "driver/uart.h" +#include "freertos/queue.h" +#include "hal/uart_types.h" +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "driver/uart.h" +#include "driver/gpio.h" +#include "sdkconfig.h" +#include "esp_log.h" + +class uart_serial { +public: + explicit uart_serial(uart_port_t uart_port_num = UART_NUM_0, const gpio_num_t tx = GPIO_NUM_NC, + const gpio_num_t rx = GPIO_NUM_NC, int baudrate = 9600) : uart_num(uart_port_num), tx_pin_num(tx), + rx_pin_num(rx) { + uart_config.baud_rate = baudrate; + uart_config.data_bits = UART_DATA_8_BITS; + uart_config.parity = UART_PARITY_DISABLE; + uart_config.stop_bits = UART_STOP_BITS_1; + uart_config.flow_ctrl = UART_HW_FLOWCTRL_DISABLE; + + init(); + }; + + void uart_serial_dtor() const { + uart_driver_delete(uart_num); + } + void write(const char* data, int len); + void write_byte(const char* data); + + int read(char* data,int len); + int read_byte(char* data); + +private: + void init(); + + QueueHandle_t uart_queue = {}; + const uart_port_t uart_num; + uart_config_t uart_config = {}; + const gpio_num_t tx_pin_num; + const gpio_num_t rx_pin_num; + constexpr static int buffer_size = (1024); +}; + + +#endif //MCU_CODE_UART_SERIAL_H diff --git a/main/peripherals/usb_serial.cpp b/main/peripherals/usb_serial.cpp index 7fec531..0b6470f 100644 --- a/main/peripherals/usb_serial.cpp +++ b/main/peripherals/usb_serial.cpp @@ -16,7 +16,6 @@ void usb_serial::init() { }; ESP_ERROR_CHECK(usb_serial_jtag_driver_install(&usb_serial_jtag_config)); ESP_LOGI("usb_serial", "USB_SERIAL_JTAG init done"); - } void usb_serial::write(const char* byte, int len) { diff --git a/main/peripherals/usb_serial.h b/main/peripherals/usb_serial.h index ca9376a..7efaf70 100644 --- a/main/peripherals/usb_serial.h +++ b/main/peripherals/usb_serial.h @@ -9,12 +9,12 @@ #include namespace usb_serial { - static void write(const char* byte, int len); - static int read(char* byte,int len); + void write(const char* byte, int len); + int read(char* byte,int len); - static void write_byte(char* byte); - static int read_byte(char* byte); - static void init(); + void write_byte(char* byte); + int read_byte(char* byte); + void init(); }; diff --git a/main/peripherals/wireless_comms.cpp b/main/peripherals/wireless_comms.cpp new file mode 100644 index 0000000..3895a97 --- /dev/null +++ b/main/peripherals/wireless_comms.cpp @@ -0,0 +1,283 @@ +// +// Created by nano on 8/23/26. +// + +#include "wireless_comms.h" + +#include "esp_err.h" +#include "esp_log.h" +#include "esp_netif.h" +#include "esp_now.h" +#include "esp_wifi.h" +#include "esp_crc.h" +#include "esp_mac.h" +#include "esp_random.h" +#include "usb_serial.h" + +const char *TAG = "wireless_comms"; + +#define ESPNOW_MAXDELAY 512 + +static QueueHandle_t espnow_send_queue = NULL; + +static uint8_t s_broadcast_mac[ESP_NOW_ETH_ALEN] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; +extern uint8_t node_mac[ESP_NOW_ETH_ALEN]; + +void wireless_comms::wifi_init(int channel) { + 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)); + ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM)); + ESP_ERROR_CHECK(esp_wifi_set_mode(ESPNOW_WIFI_MODE)); + ESP_ERROR_CHECK(esp_wifi_set_mac(ESPNOW_WIFI_IF,node_mac)); + ESP_ERROR_CHECK(esp_wifi_start()); + ESP_ERROR_CHECK(esp_wifi_set_channel(channel, WIFI_SECOND_CHAN_NONE)); + + +#ifdef CONFIG_ESPNOW_ENABLE_LONG_RANGE + ESP_ERROR_CHECK( + esp_wifi_set_protocol(ESPNOW_WIFI_IF, WIFI_PROTOCOL_11B|WIFI_PROTOCOL_11G|WIFI_PROTOCOL_11N|WIFI_PROTOCOL_LR)); +#endif +} + +void wireless_comms::espnow_send_callback(const esp_now_send_info_t *tx_info, esp_now_send_status_t status) { + espnow_event_t evt; + espnow_event_send_cb_t *send_cb = &evt.info.send_cb; + + if (tx_info == NULL) { + ESP_LOGE(TAG, "Send cb arg error"); + return; + } + + evt.id = ESPNOW_SEND_CB; + memcpy(send_cb->mac_addr, tx_info->des_addr, ESP_NOW_ETH_ALEN); + send_cb->status = status; + if (xQueueSend(espnow_send_queue, &evt, ESPNOW_MAXDELAY) != pdTRUE) { + ESP_LOGW(TAG, "Send send queue fail"); + } +} + +void wireless_comms::espnow_recv_callback(const esp_now_recv_info_t *recv_info, const uint8_t *data, int len) { + espnow_event_t evt; + espnow_event_recv_cb_t *recv_cb = &evt.info.recv_cb; + uint8_t *mac_addr = recv_info->src_addr; + + if (mac_addr == NULL || data == NULL || len <= 0) { + ESP_LOGE(TAG, "Receive cb arg error"); + return; + } + + evt.id = ESPNOW_RECV_CB; + memcpy(recv_cb->mac_addr, mac_addr, ESP_NOW_ETH_ALEN); + recv_cb->data = (uint8_t *) malloc(len); + if (recv_cb->data == NULL) { + ESP_LOGE(TAG, "Malloc receive data fail"); + return; + } + memcpy(recv_cb->data, data, len); + recv_cb->data_len = len; + if (xQueueSend(espnow_send_queue, &evt, ESPNOW_MAXDELAY) != pdTRUE) { + ESP_LOGW(TAG, "Send receive queue fail"); + free(recv_cb->data); + } +} + +/* Parse received ESPNOW data. */ +int wireless_comms::espnow_data_parse(uint8_t *data, uint16_t data_len) { + auto *buf = (espnow_data_t *) data; + uint16_t crc, crc_cal = 0; + + if (data_len < sizeof(espnow_data_t)) { + ESP_LOGE(TAG, "Receive ESPNOW data too short, len:%d", data_len); + return -1; + } + + crc = buf->crc; + buf->crc = 0; + crc_cal = esp_crc16_le(UINT16_MAX, (uint8_t const *) buf, data_len); + + if (crc_cal == crc) { + return 1; + } + + return -1; +} + +/* Prepare ESPNOW data to be sent. */ +void wireless_comms::espnow_send_data_prepare(espnow_send_param_t *send_param) { + espnow_data_t *buf = (espnow_data_t *) send_param->buffer; + assert(send_param->len >= sizeof(espnow_data_t)); + buf->crc = 0; + buf->crc = esp_crc16_le(UINT16_MAX, (uint8_t const *) buf, send_param->len); + ESP_LOGI("espnow send_data_prepare", "%d %s", send_param->len - sizeof(espnow_data_t), buf->payload); +} + +esp_err_t wireless_comms::espnow_init(int wifi_channel) { + // Create send queue + espnow_send_queue = xQueueCreate(ESPNOW_QUEUE_SIZE, sizeof(espnow_event_t)); + if (espnow_send_queue == NULL) { + ESP_LOGE(TAG, "Create queue fail"); + return ESP_FAIL; + } + + /* Initialize ESPNOW and register sending and receiving callback function. */ + ESP_ERROR_CHECK(esp_now_init()); + ESP_ERROR_CHECK(esp_now_register_send_cb(espnow_send_callback)); + ESP_ERROR_CHECK(esp_now_register_recv_cb(espnow_recv_callback)); +#if CONFIG_ESPNOW_ENABLE_POWER_SAVE + ESP_ERROR_CHECK(esp_now_set_wake_window(CONFIG_ESPNOW_WAKE_WINDOW)); + ESP_ERROR_CHECK(esp_wifi_connectionless_module_set_wake_interval(CONFIG_ESPNOW_WAKE_INTERVAL)); +#endif + /* Set primary master key. */ + ESP_ERROR_CHECK(esp_now_set_pmk((uint8_t *)ESPNOW_PMK)); + + /* Add broadcast peer information to peer list. */ + auto *peer = static_cast(malloc(sizeof(esp_now_peer_info_t))); + if (peer == NULL) { + ESP_LOGE(TAG, "Malloc peer information fail"); + vQueueDelete(espnow_send_queue); + espnow_send_queue = NULL; + esp_now_deinit(); + return ESP_FAIL; + } + memset(peer, 0, sizeof(esp_now_peer_info_t)); + peer->channel = wifi_channel; + peer->ifidx = ESPNOW_WIFI_IF; + peer->encrypt = false; + memcpy(peer->peer_addr, s_broadcast_mac, ESP_NOW_ETH_ALEN); + ESP_ERROR_CHECK(esp_now_add_peer(peer)); + free(peer); + + /* Initialize sending parameters. */ + send_param = (espnow_send_param_t *) malloc(sizeof(espnow_send_param_t)); + if (send_param == NULL) { + ESP_LOGE(TAG, "Malloc send parameter fail"); + vQueueDelete(espnow_send_queue); + espnow_send_queue = NULL; + esp_now_deinit(); + return ESP_FAIL; + } + memset(send_param, 0, sizeof(espnow_send_param_t)); + send_param->buffer = (uint8_t *) malloc(ESPNOW_SEND_LEN); + send_param->len = ESPNOW_SEND_LEN; + if (send_param->buffer == NULL) { + ESP_LOGE(TAG, "Malloc send buffer fail"); + free(send_param); + vQueueDelete(espnow_send_queue); + espnow_send_queue = NULL; + esp_now_deinit(); + return ESP_FAIL; + } + memcpy(send_param->dest_mac, s_broadcast_mac, ESP_NOW_ETH_ALEN); + espnow_send_data_prepare(send_param); + + return ESP_OK; +} + +void wireless_comms::espnow_deinit(espnow_send_param_t *send_param) { + free(send_param->buffer); + free(send_param); + vQueueDelete(espnow_send_queue); + espnow_send_queue = NULL; + esp_now_deinit(); +} + +void wireless_comms::espnow_task(void *pvParameter) { + espnow_event_t evt; + int ret; + auto task_params = (espnow_task_params_t *) pvParameter; + espnow_send_param_t send_param = *task_params->send_param; + uart_serial uart = task_params->uart; + vTaskDelay(5000 / portTICK_PERIOD_MS); + + while (xQueueReceive(espnow_send_queue, &evt, portMAX_DELAY) == pdPASS) { + switch (evt.id) { + case ESPNOW_SEND_CB: { + espnow_event_send_cb_t *send_cb = &evt.info.send_cb; + /* Delay a while before sending the next data. */ + ESP_LOGI(TAG, "send data to " MACSTR "", MAC2STR(send_cb->mac_addr)); + break; + } + case ESPNOW_RECV_CB: { + espnow_event_recv_cb_t *recv_cb = &evt.info.recv_cb; + + ret = espnow_data_parse(recv_cb->data, recv_cb->data_len); + if (ret == 1) { + auto *rx = (espnow_data_t *) recv_cb->data; + ESP_LOGI(TAG, "Receive data from: " MACSTR ", len: %d, byte0: 0x%02x", + MAC2STR(recv_cb->mac_addr), recv_cb->data_len, rx->payload[0]); + usb_serial::write(reinterpret_cast(&rx->payload), PAYLOAD_SIZE); + uart.write(reinterpret_cast(&rx->payload), PAYLOAD_SIZE); + } else { + ESP_LOGI(TAG, "Receive error (bad CRC) from: " MACSTR "", MAC2STR(recv_cb->mac_addr)); + } + free(recv_cb->data); + break; + } + default: + ESP_LOGE(TAG, "Callback type error: %d", evt.id); + break; + } + } + ESP_LOGI(TAG,"ENDED TASK WIRELESS"); +} + +void wireless_comms::set_dest_mac(const uint8_t dest_mac[ESP_NOW_ETH_ALEN]) { + ESP_ERROR_CHECK(add_peer(dest_mac)); + memcpy(send_param->dest_mac, dest_mac, ESP_NOW_ETH_ALEN); + espnow_send_data_prepare(send_param); +} + +esp_err_t wireless_comms::add_peer(const uint8_t dest_mac[ESP_NOW_ETH_ALEN]) { + auto *peer = static_cast(malloc(sizeof(esp_now_peer_info_t))); + if (peer == NULL) { + ESP_LOGE(TAG, "Malloc peer information fail"); + vQueueDelete(espnow_send_queue); + espnow_send_queue = NULL; + esp_now_deinit(); + return ESP_FAIL; + } + memset(peer, 0, sizeof(esp_now_peer_info_t)); + peer->channel = ESPNOW_CHANNEL; + peer->ifidx = ESPNOW_WIFI_IF; + peer->encrypt = false; + memcpy(peer->peer_addr, dest_mac, ESP_NOW_ETH_ALEN); + ESP_ERROR_CHECK(esp_now_add_peer(peer)); + free(peer); + ESP_LOGI(TAG, "Peer " MACSTR " added", MAC2STR(dest_mac)); + return ESP_OK; +} + +void wireless_comms::delete_peer(const uint8_t dest_mac[ESP_NOW_ETH_ALEN]) { + ESP_ERROR_CHECK(esp_now_del_peer(dest_mac)); +} + +esp_err_t wireless_comms::send_byte(uint8_t data) { + auto send_parameters = (espnow_send_param_t *) malloc(sizeof(espnow_send_param_t)); + memset(send_parameters, 0, sizeof(espnow_send_param_t)); + send_parameters->len = sizeof(espnow_data_t); + send_parameters->buffer = (uint8_t *) malloc(sizeof(espnow_data_t)); + if (send_parameters->buffer == NULL) { + ESP_LOGE(TAG, "Malloc send buffer fail"); + free(send_parameters); + vQueueDelete(espnow_send_queue); + espnow_send_queue = NULL; + esp_now_deinit(); + return ESP_FAIL; + } + ((espnow_data_t *) (send_parameters->buffer))->payload[0] = data; // i am disgusted at myself + memset(((espnow_data_t *) (send_parameters->buffer))->payload + 1, 0,PAYLOAD_SIZE - 1); + // fill the rest of the payload with zeroes + + memcpy(send_parameters->dest_mac, s_broadcast_mac, ESP_NOW_ETH_ALEN); // TODO: THIS IS IGNORED FOR NOW + espnow_send_data_prepare(send_parameters); + if (esp_now_send(NULL, send_parameters->buffer, send_parameters->len) != ESP_OK) { + // send to all peers + ESP_LOGE(TAG, "Send error"); + espnow_deinit(send_parameters); + } + free(send_parameters); + ESP_LOGI(TAG, "SENT DATA"); + return ESP_OK; +} diff --git a/main/peripherals/wireless_comms.h b/main/peripherals/wireless_comms.h new file mode 100644 index 0000000..ab0e84b --- /dev/null +++ b/main/peripherals/wireless_comms.h @@ -0,0 +1,137 @@ +// +// Created by nano on 8/23/26. +// + +#ifndef MCU_CODE_WIRELESS_COMMS_H +#define MCU_CODE_WIRELESS_COMMS_H +#include "esp_now.h" +#include "nvs_flash.h" +#include "uart_serial.h" +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" + +#define PAYLOAD_SIZE 1 + +#define ESPNOW_PMK "pmk1234567890123" // ESPNOW primary master for the example to use. The length of ESPNOW primary master must be 16 bytes. +#define ESPNOW_LMK "lmk1234567890123" // ESPNOW local master for the example to use. The length of ESPNOW local master must be 16 bytes. +#define ESPNOW_SEND_COUNT 1 // range 1-65535; Total count of unicast ESPNOW data to be sent. +#define ESPNOW_SEND_DELAY 0 // range 0-65535; default 1000; Delay between sending two ESPNOW data, unit: ms. +#define ESPNOW_SEND_LEN (2 + PAYLOAD_SIZE) // range 10-1470; Length of ESPNOW data to be sent, unit: byte. + +#define ESPNOW_CHANNEL 11 +#define ESPNOW_QUEUE_SIZE 512 + +#define CONFIG_ESPNOW_ENABLE_LONG_RANGE +#define CONFIG_ESPNOW_WIFI_MODE_STATION +// #define CONFIG_ESPNOW_ENABLE_POWER_SAVE + +#ifdef CONFIG_ESPNOW_WIFI_MODE_STATION +#define ESPNOW_WIFI_MODE WIFI_MODE_STA +#define ESPNOW_WIFI_IF WIFI_IF_STA +#else +#define ESPNOW_WIFI_MODE WIFI_MODE_AP +#define ESPNOW_WIFI_IF WIFI_IF_AP +#endif + + +#define IS_BROADCAST_ADDR(addr) (memcmp(addr, s_broadcast_mac, ESP_NOW_ETH_ALEN) == 0) + +enum { + ESPNOW_DATA_BROADCAST, + ESPNOW_DATA_UNICAST, + ESPNOW_DATA_MAX, +}; + +typedef enum { + ESPNOW_SEND_CB, + ESPNOW_RECV_CB, +} espnow_event_id_t; + +typedef struct { + uint8_t mac_addr[ESP_NOW_ETH_ALEN]; + esp_now_send_status_t status; +} espnow_event_send_cb_t; + +typedef struct { + uint8_t mac_addr[ESP_NOW_ETH_ALEN]; + uint8_t *data; + int data_len; +} espnow_event_recv_cb_t; + +typedef union { + espnow_event_send_cb_t send_cb; + espnow_event_recv_cb_t recv_cb; +} espnow_event_info_t; + +/* When ESPNOW sending or receiving callback function is called, post event to ESPNOW task. */ +typedef struct { + espnow_event_id_t id; + espnow_event_info_t info; +} espnow_event_t; + +/* User defined field of ESPNOW data in this example. */ +typedef struct { + uint16_t crc; //CRC16 value of ESPNOW data. + uint8_t payload[PAYLOAD_SIZE]; //Real payload of ESPNOW data. +} __attribute__((packed)) espnow_data_t; + +/* Parameters of sending ESPNOW data. */ +typedef struct { + int len; //Length of ESPNOW data to be sent, unit: byte. + uint8_t *buffer; //Buffer pointing to ESPNOW data. + uint8_t dest_mac[ESP_NOW_ETH_ALEN]; //MAC address of destination device. +} espnow_send_param_t; + +typedef struct espnow_task_params_t { + espnow_send_param_t *send_param; + uart_serial uart; + +} espnow_task_params_t; + +class wireless_comms { +public: + wireless_comms(int wifi_channel = ESPNOW_CHANNEL) { + // Initialize NVS + 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 ); + + wifi_init(wifi_channel); + espnow_init(wifi_channel); + } + void set_dest_mac(const uint8_t dest_mac[ESP_NOW_ETH_ALEN]); + void create_rtos_task(const uart_serial &uart) const { + auto *task_params = new espnow_task_params_t{.send_param = send_param, .uart = uart}; // heap, outlives this call + xTaskCreate(espnow_task, "espnow_task", 2048, task_params, 4, NULL); + // note: task_params is intentionally leaked for the task's lifetime; + // free it inside espnow_task if the task can ever exit + } + + static esp_err_t add_peer(const uint8_t dest_mac[ESP_NOW_ETH_ALEN]); + static void delete_peer(const uint8_t dest_mac[ESP_NOW_ETH_ALEN]); + + static esp_err_t send_byte(uint8_t data) ; +private: + + espnow_send_param_t * send_param = nullptr; + static void wifi_init(int channel); + + static void espnow_send_callback(const esp_now_send_info_t *tx_info, esp_now_send_status_t status); + + static void espnow_recv_callback(const esp_now_recv_info_t *recv_info, const uint8_t *data, int len); + + static int espnow_data_parse(uint8_t *data, uint16_t data_len); + + static void espnow_send_data_prepare(espnow_send_param_t *send_param); + + esp_err_t espnow_init(int wifi_channel); + + static void espnow_deinit(espnow_send_param_t *send_param); + static void espnow_task(void *pvParameter); +}; + + +#endif //MCU_CODE_WIRELESS_COMMS_H diff --git a/sdkconfig b/sdkconfig index 021390f..83346a3 100644 --- a/sdkconfig +++ b/sdkconfig @@ -792,20 +792,14 @@ CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE=y CONFIG_BOOTLOADER_LOG_VERSION_1=y # default: CONFIG_BOOTLOADER_LOG_VERSION=1 -# default: -# CONFIG_BOOTLOADER_LOG_LEVEL_NONE is not set -# default: +CONFIG_BOOTLOADER_LOG_LEVEL_NONE=y # CONFIG_BOOTLOADER_LOG_LEVEL_ERROR is not set -# default: # CONFIG_BOOTLOADER_LOG_LEVEL_WARN is not set -# default: -CONFIG_BOOTLOADER_LOG_LEVEL_INFO=y -# default: +# CONFIG_BOOTLOADER_LOG_LEVEL_INFO is not set # CONFIG_BOOTLOADER_LOG_LEVEL_DEBUG is not set -# default: # CONFIG_BOOTLOADER_LOG_LEVEL_VERBOSE is not set # default: -CONFIG_BOOTLOADER_LOG_LEVEL=3 +CONFIG_BOOTLOADER_LOG_LEVEL=0 # # Format @@ -1008,24 +1002,16 @@ CONFIG_ESPTOOLPY_FLASHFREQ_80M=y # CONFIG_ESPTOOLPY_FLASHFREQ_20M is not set # default: CONFIG_ESPTOOLPY_FLASHFREQ="80m" -# default: # CONFIG_ESPTOOLPY_FLASHSIZE_1MB is not set -# default: -CONFIG_ESPTOOLPY_FLASHSIZE_2MB=y -# default: -# CONFIG_ESPTOOLPY_FLASHSIZE_4MB is not set -# default: +# CONFIG_ESPTOOLPY_FLASHSIZE_2MB is not set +CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y # CONFIG_ESPTOOLPY_FLASHSIZE_8MB is not set -# default: # CONFIG_ESPTOOLPY_FLASHSIZE_16MB is not set -# default: # CONFIG_ESPTOOLPY_FLASHSIZE_32MB is not set -# default: # CONFIG_ESPTOOLPY_FLASHSIZE_64MB is not set -# default: # CONFIG_ESPTOOLPY_FLASHSIZE_128MB is not set # default: -CONFIG_ESPTOOLPY_FLASHSIZE="2MB" +CONFIG_ESPTOOLPY_FLASHSIZE="4MB" # default: # CONFIG_ESPTOOLPY_HEADER_FLASHSIZE_UPDATE is not set # default: @@ -1047,20 +1033,15 @@ CONFIG_ESPTOOLPY_MONITOR_BAUD=115200 # # Partition Table # -# default: -CONFIG_PARTITION_TABLE_SINGLE_APP=y -# default: -# CONFIG_PARTITION_TABLE_SINGLE_APP_LARGE is not set -# default: +# CONFIG_PARTITION_TABLE_SINGLE_APP is not set +CONFIG_PARTITION_TABLE_SINGLE_APP_LARGE=y # CONFIG_PARTITION_TABLE_TWO_OTA is not set -# default: # CONFIG_PARTITION_TABLE_TWO_OTA_LARGE is not set -# default: # CONFIG_PARTITION_TABLE_CUSTOM is not set # default: CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" # default: -CONFIG_PARTITION_TABLE_FILENAME="partitions_singleapp.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions_singleapp_large_coredump.csv" # default: CONFIG_PARTITION_TABLE_OFFSET=0x8000 # default: @@ -2261,12 +2242,25 @@ CONFIG_ESP_WIFI_ENTERPRISE_SUPPORT=y # # Core dump # -# default: -# CONFIG_ESP_COREDUMP_ENABLE_TO_FLASH is not set -# default: +CONFIG_ESP_COREDUMP_ENABLE_TO_FLASH=y # CONFIG_ESP_COREDUMP_ENABLE_TO_UART is not set +# CONFIG_ESP_COREDUMP_ENABLE_TO_NONE is not set # default: -CONFIG_ESP_COREDUMP_ENABLE_TO_NONE=y +# CONFIG_ESP_COREDUMP_CAPTURE_DRAM is not set +# default: +CONFIG_ESP_COREDUMP_CHECK_BOOT=y +# default: +CONFIG_ESP_COREDUMP_ENABLE=y +# default: +CONFIG_ESP_COREDUMP_LOGS=y +# default: +CONFIG_ESP_COREDUMP_MAX_TASKS_NUM=64 +# default: +# CONFIG_ESP_COREDUMP_FLASH_NO_OVERWRITE is not set +# default: +CONFIG_ESP_COREDUMP_STACK_SIZE=0 +# default: +CONFIG_ESP_COREDUMP_SUMMARY_STACKDUMP_SIZE=1024 # end of Core dump # @@ -2448,7 +2442,7 @@ CONFIG_FREERTOS_TLSP_DELETION_CALLBACKS=y # default: CONFIG_FREERTOS_CHECK_MUTEX_GIVEN_BY_OWNER=y # default: -CONFIG_FREERTOS_ISR_STACKSIZE=1536 +CONFIG_FREERTOS_ISR_STACKSIZE=2096 # default: CONFIG_FREERTOS_INTERRUPT_BACKTRACE=y # default: @@ -3409,11 +3403,11 @@ CONFIG_SD_ENABLE_SDIO_SUPPORT=y # MMU Config # # default: -CONFIG_MMU_PAGE_SIZE_32KB=y +CONFIG_MMU_PAGE_SIZE_64KB=y # default: -CONFIG_MMU_PAGE_MODE="32KB" +CONFIG_MMU_PAGE_MODE="64KB" # default: -CONFIG_MMU_PAGE_SIZE=0x8000 +CONFIG_MMU_PAGE_SIZE=0x10000 # end of MMU Config # @@ -3581,12 +3575,25 @@ CONFIG_WS_BUFFER_SIZE=1024 # # Ultra Low Power (ULP) Co-processor # +CONFIG_ULP_COPROC_ENABLED=y # default: -# CONFIG_ULP_COPROC_ENABLED is not set +CONFIG_ULP_COPROC_TYPE_LP_CORE=y +# default: +CONFIG_ULP_COPROC_RESERVE_MEM=4096 +# default: +CONFIG_ULP_SHARED_MEM=0x10 +# default: +CONFIG_ULP_TRAP_WAKEUP=y # # ULP Debugging Options # +# default: +# CONFIG_ULP_PANIC_OUTPUT_ENABLE is not set +# default: +# CONFIG_ULP_HP_UART_CONSOLE_PRINT is not set +# default: +CONFIG_ULP_NORESET_UNDER_DEBUG=y # end of ULP Debugging Options # end of Ultra Low Power (ULP) Co-processor @@ -3660,13 +3667,13 @@ CONFIG_WL_SECTOR_SIZE=4096 # CONFIG_NO_BLOBS is not set # CONFIG_APP_ROLLBACK_ENABLE is not set # CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_NONE is not set -# CONFIG_LOG_BOOTLOADER_LEVEL_NONE is not set +CONFIG_LOG_BOOTLOADER_LEVEL_NONE=y # CONFIG_LOG_BOOTLOADER_LEVEL_ERROR is not set # CONFIG_LOG_BOOTLOADER_LEVEL_WARN is not set -CONFIG_LOG_BOOTLOADER_LEVEL_INFO=y +# CONFIG_LOG_BOOTLOADER_LEVEL_INFO is not set # CONFIG_LOG_BOOTLOADER_LEVEL_DEBUG is not set # CONFIG_LOG_BOOTLOADER_LEVEL_VERBOSE is not set -CONFIG_LOG_BOOTLOADER_LEVEL=3 +CONFIG_LOG_BOOTLOADER_LEVEL=0 # CONFIG_FLASH_ENCRYPTION_ENABLED is not set # CONFIG_FLASHMODE_QIO is not set # CONFIG_FLASHMODE_QOUT is not set @@ -3784,9 +3791,12 @@ CONFIG_WPA_MBEDTLS_TLS_CLIENT=y # CONFIG_WPA_WPS_SOFTAP_REGISTRAR is not set # CONFIG_WPA_WPS_STRICT is not set # CONFIG_WPA_DEBUG_PRINT is not set -# CONFIG_ESP32_ENABLE_COREDUMP_TO_FLASH is not set +CONFIG_ESP32_ENABLE_COREDUMP_TO_FLASH=y # CONFIG_ESP32_ENABLE_COREDUMP_TO_UART is not set -CONFIG_ESP32_ENABLE_COREDUMP_TO_NONE=y +# CONFIG_ESP32_ENABLE_COREDUMP_TO_NONE is not set +CONFIG_ESP32_ENABLE_COREDUMP=y +CONFIG_ESP32_CORE_DUMP_MAX_TASKS_NUM=64 +CONFIG_ESP32_CORE_DUMP_STACK_SIZE=0 CONFIG_TIMER_TASK_PRIORITY=1 CONFIG_TIMER_TASK_STACK_DEPTH=2048 CONFIG_TIMER_QUEUE_LENGTH=10