Add LED for user feedback

.gitignore

@@ -2,6 +2,8 @@ build/
 sdkconfig
 sdkconfig.old
 
+managed_components/
+
 .vscode/
 
 cmake-build-*/

main/CMakeLists.txt

@@ -2,4 +2,5 @@ idf_component_register(SRCS "esp_tunnel.cpp"
                             "app_networking.cpp"
                             "app_serial.cpp"
                             "app_config.cpp"
+                            "app_led.cpp"
                     INCLUDE_DIRS ".")

main/Kconfig.projbuild

@@ -25,6 +25,13 @@ menu "EspTunnel Configuration"
         help
             The UART interface to use for RX and TX.
 
+    config ESPTNL_BUFFER_SIZE
+        int "Buffer size"
+        default 128
+        range 40 218
+        help
+            The maximum size of the buffer to transmit via ESPNOW.
+
     choice ESPTNL_LOG_LEVEL
         prompt "Log level"
         default ESPTNL_LOG_DEBUG

main/app_led.cpp

@@ -0,0 +1,64 @@
+//
+// Created by erki on 26/06/23.
+//
+
+#include "app_led.hpp"
+
+#include "led_strip.h"
+
+namespace
+{
+
+led_strip_handle_t s_strip;
+bool s_tx_on = false;
+bool s_rx_on = false;
+
+void s_updateStrip()
+{
+  const int red = s_tx_on ? 10 : 0;
+  const int blue = s_rx_on ? 10 : 0;
+
+  led_strip_set_pixel(s_strip, 0, red, 10, blue);
+  led_strip_refresh(s_strip);
+}
+
+}
+
+namespace Led
+{
+
+void setupLed(const gpio_num_t gpio)
+{
+  led_strip_config_t config = {
+    .strip_gpio_num = gpio,
+    .max_leds = 1,
+    .led_pixel_format = LED_PIXEL_FORMAT_GRB,
+    .led_model = LED_MODEL_WS2812,
+    .flags = { 0 }
+  };
+
+  led_strip_rmt_config_t rmt_config = {
+    .clk_src = RMT_CLK_SRC_DEFAULT,
+    .resolution_hz = 10 * 1000 * 1000,
+    .mem_block_symbols = 0,
+    .flags = { 0 }
+  };
+
+  ESP_ERROR_CHECK(led_strip_new_rmt_device(&config, &rmt_config, &s_strip));
+  led_strip_clear(s_strip);
+  s_updateStrip();
+}
+
+void flashRx()
+{
+  s_rx_on = !s_rx_on;
+  s_updateStrip();
+}
+
+void flashTx()
+{
+  s_tx_on = !s_tx_on;
+  s_updateStrip();
+}
+
+}

main/app_led.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <driver/gpio.h>
+
+namespace Led
+{
+
+void setupLed(const gpio_num_t gpio);
+void flashRx();
+void flashTx();
+
+} // namespace Led
+

main/app_networking.cpp

@@ -22,7 +22,7 @@ static_assert(std::is_standard_layout_v<EspNowEvent> && std::is_trivial_v<EspNow
         "EspNowEvent is not compatible with a FreeRTOS queue.");
 
 QueueHandle_t s_esp_now_queue = nullptr;
-std::array<std::uint8_t, 128> s_rx_buffer;
+std::array<std::uint8_t, CONFIG_ESPTNL_BUFFER_SIZE> s_rx_buffer;
 std::variant<MacAddress, std::monostate> s_peer;
 
 bool s_isBroadcastAddress(const std::uint8_t* mac)
@@ -123,12 +123,12 @@ void sendHello()
   ESP_ERROR_CHECK(esp_now_send(broadcast_mac.data(), (uint8_t*)buffer, length));
 }
 
-const std::array<std::uint8_t, 128>& getRxBuffer()
+const std::array<std::uint8_t, CONFIG_ESPTNL_BUFFER_SIZE>& getRxBuffer()
 {
   return s_rx_buffer;
 }
 
-void sendData(const std::array<std::uint8_t, 128>& buffer, const std::size_t length)
+void sendData(const std::array<std::uint8_t, CONFIG_ESPTNL_BUFFER_SIZE>& buffer, const std::size_t length)
 {
   if (const MacAddress* peer_mac = std::get_if<MacAddress>(&s_peer);
       peer_mac != nullptr)

main/app_networking.hpp

@@ -28,7 +28,7 @@ void setupWifi();
 [[nodiscard]] QueueHandle_t setupEspNow();
 void sendHello();
 
-void sendData(const std::array<std::uint8_t, 128>& buffer, const std::size_t length);
-const std::array<std::uint8_t, 128>& getRxBuffer();
+void sendData(const std::array<std::uint8_t, CONFIG_ESPTNL_BUFFER_SIZE>& buffer, const std::size_t length);
+const std::array<std::uint8_t, CONFIG_ESPTNL_BUFFER_SIZE>& getRxBuffer();
 
 }// namespace App

main/app_serial.cpp

@@ -28,7 +28,7 @@ QueueHandle_t setupSerial(const uart_port_t uart)
     .source_clk = UART_SCLK_DEFAULT,
   };
 
-  ESP_ERROR_CHECK(uart_driver_install(uart, 128 * 2, 128 * 2, 4, &s_uart_queue, 0));
+  ESP_ERROR_CHECK(uart_driver_install(uart, CONFIG_ESPTNL_BUFFER_SIZE * 2, CONFIG_ESPTNL_BUFFER_SIZE * 2, 4, &s_uart_queue, 0));
   ESP_ERROR_CHECK(uart_param_config(uart, &config));
   ESP_ERROR_CHECK(uart_set_pin(uart, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE));
 

main/esp_tunnel.cpp

@@ -6,6 +6,7 @@
 #include "app_networking.hpp"
 #include "app_serial.hpp"
 #include "app_config.hpp"
+#include "app_led.hpp"
 
 #include "freertos/FreeRTOS.h"
 #include "freertos/queue.h"
@@ -29,13 +30,15 @@ QueueHandle_t s_uart_queue = nullptr;
 
 void s_sendUartData(std::size_t len)
 {
-  len = std::clamp<std::size_t>(len, 1, 128);
+  len = std::clamp<std::size_t>(len, 1, CONFIG_ESPTNL_BUFFER_SIZE);
   ESP_LOGD(LOG_TAG, "Sending %u bytes via UART.", len);
 
-  std::array<std::uint8_t, 128> tx_buffer;
+  std::array<std::uint8_t, CONFIG_ESPTNL_BUFFER_SIZE> tx_buffer;
   uart_read_bytes(CONFIG_ESPTNL_UART, tx_buffer.data(), len, 0);
 
   xTimerStop(s_timer, 0);
+  Led::flashTx();
+
   Networking::sendData(tx_buffer, len);
 }
 
@@ -43,7 +46,7 @@ std::size_t s_uartBytesWaiting()
 {
   std::size_t len = 0;
   uart_get_buffered_data_len(CONFIG_ESPTNL_UART, &len);
-  return std::min<std::size_t>(len, 128);
+  return std::min<std::size_t>(len, CONFIG_ESPTNL_BUFFER_SIZE);
 }
 
 [[noreturn]] void s_mainTask(void*)
@@ -65,9 +68,13 @@ std::size_t s_uartBytesWaiting()
       {
         std::size_t uart_free = 0;
         uart_get_tx_buffer_free_size(CONFIG_ESPTNL_UART, &uart_free);
+
         if (uart_free >= event.rx_length)
         {
           ESP_LOGD(LOG_TAG, "ESP-NOW event: wrote %ull bytes to UART RX.", uart_free);
+
+          Led::flashRx();
+
           const auto& esp_rx_buffer = Networking::getRxBuffer();
           uart_write_bytes(CONFIG_ESPTNL_UART, esp_rx_buffer.data(), event.rx_length);
         }
@@ -81,7 +88,7 @@ std::size_t s_uartBytesWaiting()
         ESP_LOGD(LOG_TAG, "ESP-NOW event: TX completed. Checking to send data.");
 
         const std::size_t bytes_waiting = s_uartBytesWaiting();
-        if (s_uartBytesWaiting() >= 128)
+        if (s_uartBytesWaiting() >= CONFIG_ESPTNL_BUFFER_SIZE)
         {
           s_sendUartData(bytes_waiting);
         }
@@ -97,7 +104,7 @@ std::size_t s_uartBytesWaiting()
       if (event.type == UART_DATA)
       {
         const std::size_t recv_size = s_uartBytesWaiting();
-        if (recv_size >= 128)
+        if (recv_size >= CONFIG_ESPTNL_BUFFER_SIZE)
           s_sendUartData(recv_size);
         else
           xTimerReset(s_timer, 0);
@@ -151,6 +158,8 @@ extern "C" void app_main(void)
   xQueueAddToSet(s_esp_now_queue, s_queue_set);
   xQueueAddToSet(s_uart_queue, s_queue_set);
 
+  Led::setupLed(GPIO_NUM_8);
+
   ESP_LOGI(LOG_TAG, "Setup completed. Sending hello.");
 
   Networking::sendHello();

main/idf_component.yml

@@ -0,0 +1,2 @@
+dependencies:
+  espressif/led_strip: "^2.0.0"