138 lines
3.6 KiB
C++
138 lines
3.6 KiB
C++
#include <array>
|
|
#include <cstdint>
|
|
#include <stdio.h>
|
|
|
|
#include "app_networking.hpp"
|
|
#include "app_serial.hpp"
|
|
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/queue.h"
|
|
#include "freertos/timers.h"
|
|
#include "nvs_flash.h"
|
|
#include "driver/uart.h"
|
|
#include "esp_log.h"
|
|
|
|
namespace
|
|
{
|
|
|
|
static const char* TAG = "App";
|
|
|
|
TaskHandle_t s_main_task = nullptr;
|
|
|
|
TimerHandle_t s_timer = nullptr;
|
|
|
|
QueueSetHandle_t s_queue_set = nullptr;
|
|
QueueHandle_t s_esp_now_queue = nullptr;
|
|
QueueHandle_t s_uart_queue = nullptr;
|
|
|
|
void s_sendUartData(const std::size_t len)
|
|
{
|
|
ESP_LOGD(TAG, "Sending %u bytes via UART.", len);
|
|
|
|
std::array<std::uint8_t, 128> tx_buffer;
|
|
uart_read_bytes(UART_NUM_0, tx_buffer.data(), len, 0);
|
|
|
|
Networking::sendData(tx_buffer, len);
|
|
}
|
|
|
|
std::size_t s_uartBytesWaiting()
|
|
{
|
|
std::size_t len = 0;
|
|
uart_get_buffered_data_len(UART_NUM_0, &len);
|
|
return std::min<std::size_t>(len, 128);
|
|
}
|
|
|
|
[[noreturn]] void s_mainTask(void*)
|
|
{
|
|
while (true)
|
|
{
|
|
QueueSetMemberHandle_t queue_select = xQueueSelectFromSet(s_queue_set, portMAX_DELAY);
|
|
|
|
ESP_LOGI(TAG, "Event: %s.", queue_select == s_esp_now_queue ? "ESP-NOW event" : "UART event");
|
|
|
|
if (queue_select == s_esp_now_queue)
|
|
{
|
|
Networking::EspNowEvent event;
|
|
xQueueReceive(queue_select, &event, 0);
|
|
|
|
ESP_LOGD(TAG, "ESP-NOW event: %u, rx-length: %ull.", event.type, event.rx_length);
|
|
|
|
if (event.type == Networking::EspNowEvent::MSG_RECEIVED)
|
|
{
|
|
std::size_t uart_free = 0;
|
|
uart_get_tx_buffer_free_size(UART_NUM_0, &uart_free);
|
|
if (uart_free >= event.rx_length)
|
|
{
|
|
ESP_LOGD(TAG, "ESP-NOW event: wrote %ull bytes to UART RX.", uart_free);
|
|
const auto& esp_rx_buffer = Networking::getRxBuffer();
|
|
uart_write_bytes(UART_NUM_0, esp_rx_buffer.data(), event.rx_length);
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGW(TAG, "ESP-NOW event: dropped RX data due to full UART RX buffer.");
|
|
}
|
|
}
|
|
else if (event.type == Networking::EspNowEvent::MSG_SEND_COMPLETE)
|
|
{
|
|
ESP_LOGD(TAG, "ESP-NOW event: TX completed. Checking to send data.");
|
|
|
|
const std::size_t bytes_waiting = s_uartBytesWaiting();
|
|
if (s_uartBytesWaiting() >= 128)
|
|
{
|
|
s_sendUartData(bytes_waiting);
|
|
xTimerStop(s_timer, 0);
|
|
}
|
|
}
|
|
}
|
|
else if (queue_select == s_uart_queue)
|
|
{
|
|
uart_event_t event;
|
|
xQueueReceive(s_uart_queue, &event, 0);
|
|
|
|
ESP_LOGD(TAG, "UART event: %d", event.type);
|
|
|
|
if (event.type == UART_DATA)
|
|
{
|
|
const std::size_t bytes_waiting = s_uartBytesWaiting();
|
|
if (s_uartBytesWaiting() >= 128)
|
|
s_sendUartData(bytes_waiting);
|
|
else
|
|
xTimerReset(s_timer, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void s_cbListenTimeout(TimerHandle_t)
|
|
{
|
|
const std::size_t bytes_waiting = s_uartBytesWaiting();
|
|
if (bytes_waiting > 0)
|
|
s_sendUartData(bytes_waiting);
|
|
}
|
|
|
|
}// namespace
|
|
|
|
extern "C" void app_main(void)
|
|
{
|
|
ESP_ERROR_CHECK(nvs_flash_init());
|
|
|
|
esp_log_level_set("*", ESP_LOG_INFO);
|
|
esp_log_level_set(TAG, ESP_LOG_DEBUG);
|
|
esp_log_level_set("Networking", ESP_LOG_DEBUG);
|
|
|
|
ESP_LOGD(TAG, "Starting main.");
|
|
|
|
Networking::setupWifi();
|
|
s_esp_now_queue = Networking::setupEspNow();
|
|
s_uart_queue = Serial::setupSerial();
|
|
|
|
s_timer = xTimerCreate("autosend_timer", pdMS_TO_TICKS(100), false, nullptr, s_cbListenTimeout);
|
|
|
|
s_queue_set = xQueueCreateSet(4 + 4);
|
|
xQueueAddToSet(s_esp_now_queue, s_queue_set);
|
|
xQueueAddToSet(s_uart_queue, s_queue_set);
|
|
|
|
ESP_LOGI(TAG, "Setup completed.");
|
|
xTaskCreate(s_mainTask, "main_task", 2048, nullptr, 4, &s_main_task);
|
|
}
|