fit the memory usage for esp32c3

main/boards/common/board.cc

@@ -1,5 +1,6 @@
 #include "board.h"
 #include "system_info.h"
+#include "display/no_display.h"
 
 #include <esp_log.h>
 #include <esp_ota_ops.h>
@@ -11,6 +12,12 @@ bool Board::GetBatteryLevel(int &level, bool& charging) {
     return false;
 }
 
+Display* Board::GetDisplay() {
+    static NoDisplay display;
+    return &display;
+}
+
+
 std::string Board::GetJson() {
     /* 
         {
@@ -101,4 +108,4 @@ std::string Board::GetJson() {
     // Close the JSON object
     json += "}";
     return json;
-}
+}

main/boards/common/board.h

@@ -35,7 +35,7 @@ public:
     virtual ~Board() = default;
     virtual Led* GetBuiltinLed() = 0;
     virtual AudioCodec* GetAudioCodec() = 0;
-    virtual Display* GetDisplay() = 0;
+    virtual Display* GetDisplay();
     virtual Http* CreateHttp() = 0;
     virtual WebSocket* CreateWebSocket() = 0;
     virtual Mqtt* CreateMqtt() = 0;

main/boards/common/led.cc

@@ -7,10 +7,6 @@
 #define TAG "Led"
 
 Led::Led(gpio_num_t gpio) {
-    mutex_ = xSemaphoreCreateMutex();
-    blink_event_group_ = xEventGroupCreate();
-    xEventGroupSetBits(blink_event_group_, BLINK_TASK_STOPPED_BIT);
-
     if (gpio == GPIO_NUM_NC) {
         ESP_LOGI(TAG, "Builtin LED not connected");
         return;
@@ -29,19 +25,25 @@ Led::Led(gpio_num_t gpio) {
     led_strip_clear(led_strip_);
 
     SetGrey();
+
+    esp_timer_create_args_t blink_timer_args = {
+        .callback = [](void *arg) {
+            auto led = static_cast<Led*>(arg);
+            led->OnBlinkTimer();
+        },
+        .arg = this,
+        .dispatch_method = ESP_TIMER_TASK,
+        .name = "Blink Timer",
+        .skip_unhandled_events = false,
+    };
+    ESP_ERROR_CHECK(esp_timer_create(&blink_timer_args, &blink_timer_));
 }
 
 Led::~Led() {
-    StopBlinkInternal();
+    esp_timer_stop(blink_timer_);
     if (led_strip_ != nullptr) {
         led_strip_del(led_strip_);
     }
-    if (mutex_ != nullptr) {
-        vSemaphoreDelete(mutex_);
-    }
-    if (blink_event_group_ != nullptr) {
-        vEventGroupDelete(blink_event_group_);
-    }
 }
 
 void Led::SetColor(uint8_t r, uint8_t g, uint8_t b) {
@@ -54,21 +56,21 @@ void Led::TurnOn() {
     if (led_strip_ == nullptr) {
         return;
     }
-    StopBlinkInternal();
-    xSemaphoreTake(mutex_, portMAX_DELAY);
+    
+    std::lock_guard<std::mutex> lock(mutex_);
+    esp_timer_stop(blink_timer_);
     led_strip_set_pixel(led_strip_, 0, r_, g_, b_);
     led_strip_refresh(led_strip_);
-    xSemaphoreGive(mutex_);
 }
 
 void Led::TurnOff() {
     if (led_strip_ == nullptr) {
         return;
     }
-    StopBlinkInternal();
-    xSemaphoreTake(mutex_, portMAX_DELAY);
+
+    std::lock_guard<std::mutex> lock(mutex_);
+    esp_timer_stop(blink_timer_);
     led_strip_clear(led_strip_);
-    xSemaphoreGive(mutex_);
 }
 
 void Led::BlinkOnce() {
@@ -87,45 +89,27 @@ void Led::StartBlinkTask(int times, int interval_ms) {
     if (led_strip_ == nullptr) {
         return;
     }
-    StopBlinkInternal();
-    xSemaphoreTake(mutex_, portMAX_DELAY);
+
+    std::lock_guard<std::mutex> lock(mutex_);
+    esp_timer_stop(blink_timer_);
     
-    blink_times_ = times;
+    led_strip_clear(led_strip_);
+    blink_counter_ = times * 2;
     blink_interval_ms_ = interval_ms;
-    should_blink_ = true;
+    esp_timer_start_periodic(blink_timer_, interval_ms * 1000);
+}
 
-    xEventGroupClearBits(blink_event_group_, BLINK_TASK_STOPPED_BIT);
-    xEventGroupSetBits(blink_event_group_, BLINK_TASK_RUNNING_BIT);
+void Led::OnBlinkTimer() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    blink_counter_--;
+    if (blink_counter_ & 1) {
+        led_strip_set_pixel(led_strip_, 0, r_, g_, b_);
+        led_strip_refresh(led_strip_);
+    } else {
+        led_strip_clear(led_strip_);
 
-    xTaskCreate([](void* obj) {
-        auto this_ = static_cast<Led*>(obj);
-        int count = 0;
-        while (this_->should_blink_ && (this_->blink_times_ == BLINK_INFINITE || count < this_->blink_times_)) {
-            xSemaphoreTake(this_->mutex_, portMAX_DELAY);
-            led_strip_set_pixel(this_->led_strip_, 0, this_->r_, this_->g_, this_->b_);
-            led_strip_refresh(this_->led_strip_);
-            xSemaphoreGive(this_->mutex_);
-
-            vTaskDelay(this_->blink_interval_ms_ / portTICK_PERIOD_MS);
-            if (!this_->should_blink_) break;
-
-            xSemaphoreTake(this_->mutex_, portMAX_DELAY);
-            led_strip_clear(this_->led_strip_);
-            xSemaphoreGive(this_->mutex_);
-
-            vTaskDelay(this_->blink_interval_ms_ / portTICK_PERIOD_MS);
-            if (this_->blink_times_ != BLINK_INFINITE) count++;
+        if (blink_counter_ == 0) {
+            esp_timer_stop(blink_timer_);
         }
-        this_->blink_task_ = nullptr;
-        xEventGroupClearBits(this_->blink_event_group_, BLINK_TASK_RUNNING_BIT);
-        xEventGroupSetBits(this_->blink_event_group_, BLINK_TASK_STOPPED_BIT);
-        vTaskDelete(NULL);
-    }, "blink", 2048, this, tskIDLE_PRIORITY, &blink_task_);
-
-    xSemaphoreGive(mutex_);
-}
-
-void Led::StopBlinkInternal() {
-    should_blink_ = false;
-    xEventGroupWaitBits(blink_event_group_, BLINK_TASK_STOPPED_BIT, pdFALSE, pdTRUE, portMAX_DELAY);
+    }
 }

main/boards/common/led.h

@@ -2,10 +2,9 @@
 #define _LED_H_
 
 #include <led_strip.h>
-#include <freertos/semphr.h>
-#include <freertos/task.h>
-#include <freertos/event_groups.h>
+#include <esp_timer.h>
 #include <atomic>
+#include <mutex>
 
 #define BLINK_INFINITE -1
 #define BLINK_TASK_STOPPED_BIT BIT0
@@ -33,17 +32,16 @@ public:
     void SetBlue(uint8_t brightness = DEFAULT_BRIGHTNESS) { SetColor(0, 0, brightness); }
 
 private:
-    SemaphoreHandle_t mutex_;
-    EventGroupHandle_t blink_event_group_;
+    std::mutex mutex_;
     TaskHandle_t blink_task_ = nullptr;
     led_strip_handle_t led_strip_ = nullptr;
     uint8_t r_ = 0, g_ = 0, b_ = 0;
-    int blink_times_ = 0;
+    int blink_counter_ = 0;
     int blink_interval_ms_ = 0;
-    std::atomic<bool> should_blink_{false};
+    esp_timer_handle_t blink_timer_ = nullptr;
 
     void StartBlinkTask(int times, int interval_ms);
-    void StopBlinkInternal();
+    void OnBlinkTimer();
 };
 
 #endif // _LED_H_

main/boards/common/wifi_board.cc

@@ -62,7 +62,10 @@ void WifiBoard::StartNetwork() {
         
         // Wait forever until reset after configuration
         while (true) {
-            vTaskDelay(pdMS_TO_TICKS(1000));
+            int free_sram = heap_caps_get_free_size(MALLOC_CAP_INTERNAL);
+            int min_free_sram = heap_caps_get_minimum_free_size(MALLOC_CAP_INTERNAL);
+            ESP_LOGI(TAG, "Free internal: %u minimal internal: %u", free_sram, min_free_sram);
+            vTaskDelay(pdMS_TO_TICKS(10000));
         }
     }
 }