Merge branch 'main' into ad/nanotracker

.github/workflows/code-quality.yml

@@ -16,7 +16,7 @@ jobs:
       - name: Run clang-format
         run: |
           apt update -y
-          apt install -y make clang-format
+          apt install -y make clang-format-18
           make clang-format
 
   cppcheck:

Makefile

@@ -1,6 +1,6 @@
 IMAGE2CODE = ./sdk/tools/image2code/image2code.py
-CPPCHECK = cppcheck
-CLANG_FORMAT = clang-format
+CPPCHECK ?= cppcheck
+CLANG_FORMAT ?= $(shell command -v clang-format-18 2>/dev/null || echo clang-format)
 
 help: ## Show this help
 	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-16s\033[0m %s\n", $$1, $$2}'
@@ -49,7 +49,7 @@ check-docker: ## Run all checks in docker
 	docker build -t lilka-check -f - . <<EOF
 		FROM ubuntu:24.04
 		RUN apt-get update -y && \
-		apt-get install -y clang-format cppcheck findutils grep make
+		apt-get install -y clang-format-18 cppcheck findutils grep make
 	EOF
 	docker run --rm -it -v $(PWD):/lilka -w /lilka lilka-check make check
 

firmware/keira/platformio.ini

@@ -6,10 +6,10 @@ boards_dir = ../../sdk/boards
 lib_dir = ../../sdk/lib
 
 [env:v1]
-platform = espressif32 @ 6.6.0
+platform = espressif32
 board = adafruit_qtpy_esp32c3
 framework = arduino
-lib_deps =
+lib_deps = 
 	lilka
 	mischief/lua @ ^0.1.1
 	https://github.com/moononournation/arduino-nofrendo.git
@@ -23,7 +23,7 @@ board_build.partitions = ./legacy/v1_partitions.csv
 platform = espressif32
 board = lilka_v2
 framework = arduino
-lib_deps =
+lib_deps = 
 	lilka
 	mischief/lua @ ^0.1.1
 	https://github.com/moononournation/arduino-nofrendo.git

firmware/keira/src/app.cpp

@@ -10,7 +10,7 @@ App::App(const char* name, uint16_t x, uint16_t y, uint16_t w, uint16_t h) :
     canvas(new lilka::Canvas(x, y, w, h)),
     backCanvas(new lilka::Canvas(x, y, w, h)),
     isDrawQueued(false),
-    backCanvasMutex(xSemaphoreCreateBinary()),
+    backCanvasMutex(xSemaphoreCreateMutex()),
     stackSize(8192),
     appCore(0) {
     // Clear buffers

firmware/keira/src/appmanager.cpp

@@ -4,7 +4,7 @@
 AppManager* AppManager::instance = NULL;
 
 AppManager::AppManager() :
-    mutex(xSemaphoreCreateBinary()), panel(NULL), toastMessage(""), toastStartTime(0), toastEndTime(0) {
+    mutex(xSemaphoreCreateMutex()), panel(NULL), toastMessage(""), toastStartTime(0), toastEndTime(0) {
     xSemaphoreGive(mutex);
 }
 

firmware/keira/src/apps/launcher.cpp

@@ -52,7 +52,6 @@ ITEM_LIST app_items = {
     ITEM_SUBMENU(
         "Демо",
         {
-            ITEM_APP("ЛілТрекер", LilTrackerApp),
             ITEM_APP("Лінії", DemoLines),
             ITEM_APP("Диск", DiskApp),
             ITEM_APP("Перетворення", TransformApp),
@@ -68,6 +67,7 @@ ITEM_LIST app_items = {
          ITEM_APP("I2C-сканер", ScanI2CApp),
          ITEM_APP("GPIO-мененджер", GPIOManagerApp)},
     ),
+    ITEM_APP("ЛілТрекер", LilTrackerApp),
     ITEM_APP("Летріс", LetrisApp),
     ITEM_APP("Тамагочі", TamagotchiApp),
     ITEM_APP("Погода", WeatherApp),

firmware/keira/src/servicemanager.cpp

@@ -19,8 +19,7 @@ ServiceManager* ServiceManager::getInstance() {
 }
 
 void ServiceManager::addService(Service* service) {
-    xSemaphoreTake(xMutex, portMAX_DELAY);
+    AcquireServiceManager acquire(xMutex);
     services.push_back(service);
     service->start();
-    xSemaphoreGive(xMutex);
 }

firmware/keira/src/servicemanager.h

@@ -2,23 +2,34 @@
 
 #include "service.h"
 
+class AcquireServiceManager {
+public:
+    explicit AcquireServiceManager(SemaphoreHandle_t xMutex) : xMutex(xMutex) {
+        xSemaphoreTake(xMutex, portMAX_DELAY);
+    }
+    ~AcquireServiceManager() {
+        xSemaphoreGive(xMutex);
+    }
+
+private:
+    SemaphoreHandle_t xMutex;
+};
+
 class ServiceManager {
 public:
     ~ServiceManager();
     void addService(Service* service);
 
     template <typename T>
     T* getService(const char* name) {
-        xSemaphoreTake(xMutex, portMAX_DELAY);
+        AcquireServiceManager acquire(xMutex);
         std::vector<Service*>::iterator it =
             std::find_if(services.begin(), services.end(), [name](const Service* service) {
                 return strcmp(service->name, name) == 0;
             });
         if (it != services.end()) {
-            xSemaphoreGive(xMutex);
             return static_cast<T*>(*it);
         }
-        xSemaphoreGive(xMutex);
         lilka::serial_err("getService(): service %s not found", name);
         return nullptr;
     }

firmware/keira/src/services/network.cpp

@@ -1,4 +1,5 @@
 // TODO: Add enable/disable methods instead of deallocating WiFi from apps like LilTracker
+// TODO: Use the mutex, Luke!
 
 #include <Preferences.h>
 #include <esp_wifi.h>
@@ -14,7 +15,7 @@ NetworkService::NetworkService() :
     state(NETWORK_STATE_OFFLINE),
     reason(0),
     signalStrength(0),
-    mutex(xSemaphoreCreateBinary()),
+    mutex(xSemaphoreCreateMutex()),
     lastPassword(""),
     ipAddr("") {
     // TODO: Use the mutex, Luke!
@@ -38,13 +39,13 @@ void NetworkService::run() {
     // Check if there is a known network to connect to
     prefs.begin("network", true);
     if (!prefs.isKey("last_ssid")) {
-        Serial.println("NetworkService: no last SSID found, skipping startup connection");
+        lilka::serial_log("NetworkService: no last SSID found, skipping startup connection");
     } else {
         String currentSSID = prefs.getString("last_ssid");
-        Serial.println("NetworkService: last SSID found: " + currentSSID);
+        lilka::serial_log("NetworkService: last SSID found: %s", currentSSID.c_str());
         lastPassword = getPassword(currentSSID);
         if (lastPassword == "") {
-            Serial.println("NetworkService: no password found for last SSID, skipping startup connection");
+            lilka::serial_log("NetworkService: no password found for last SSID, skipping startup connection");
         } else {
             connect(currentSSID, lastPassword);
         }
@@ -54,20 +55,20 @@ void NetworkService::run() {
     WiFi.onEvent([this](WiFiEvent_t event, WiFiEventInfo_t info) {
         switch (event) {
             case ARDUINO_EVENT_WIFI_STA_START: {
-                Serial.println("NetworkService: connecting to WiFi");
+                lilka::serial_log("NetworkService: connecting to WiFi");
                 setNetworkState(NETWORK_STATE_CONNECTING);
                 break;
             }
             case ARDUINO_EVENT_WIFI_STA_CONNECTED: {
-                Serial.println("NetworkService: connected to WiFi");
+                lilka::serial_log("NetworkService: connected to WiFi");
                 setNetworkState(NETWORK_STATE_ONLINE);
                 Preferences prefs;
                 String connectedSSID = String(info.wifi_sta_connected.ssid, info.wifi_sta_connected.ssid_len);
                 prefs.begin("network", false);
                 if (!prefs.isKey("last_ssid") || !String(prefs.getString("last_ssid")).equals(connectedSSID)) {
                     // Set current SSID as last connected
                     prefs.putString("last_ssid", String(connectedSSID));
-                    Serial.println("NetworkService: last SSID set to " + connectedSSID);
+                    lilka::serial_log("NetworkService: last SSID set to  %s", connectedSSID.c_str());
                 }
                 prefs.end();
                 String ssidHash = hash(connectedSSID);
@@ -76,36 +77,34 @@ void NetworkService::run() {
                 if (savedPassword != lastPassword) {
                     // Save password for the connected network
                     prefs.putString(String(ssidHash + "_pw").c_str(), lastPassword);
-                    Serial.println("NetworkService: password for " + connectedSSID + " saved");
+                    lilka::serial_log("NetworkService: password for %s saved", connectedSSID.c_str());
                 }
                 prefs.end();
                 break;
             }
             case ARDUINO_EVENT_WIFI_STA_DISCONNECTED: {
-                Serial.println(
-                    "NetworkService: disconnected from WiFi, reason " + String(info.wifi_sta_disconnected.reason)
+                lilka::serial_log(
+                    "NetworkService: disconnected from WiFi, reason: %d", info.wifi_sta_disconnected.reason
                 );
                 setNetworkState(NETWORK_STATE_OFFLINE);
                 reason = info.wifi_sta_disconnected.reason;
                 break;
             }
             case ARDUINO_EVENT_WIFI_STA_GOT_IP:
             case ARDUINO_EVENT_WIFI_STA_GOT_IP6: {
-                Serial.println("Got IP");
                 IPAddress ip = WiFi.localIP();
                 ipAddr = ip.toString();
-                Serial.println("NetworkService: got IP address: " + ipAddr);
+                lilka::serial_log("NetworkService: got IP address: %s", ipAddr.c_str());
                 setNetworkState(NETWORK_STATE_ONLINE);
                 break;
             }
             case ARDUINO_EVENT_WIFI_STA_LOST_IP: {
-                Serial.println("NetworkService: lost IP address");
+                lilka::serial_log("NetworkService: lost IP address");
                 ipAddr = "";
                 setNetworkState(NETWORK_STATE_OFFLINE);
                 break;
             }
             default:
-                Serial.println("Got unhandled WiFi event");
                 break;
         }
     });
@@ -116,10 +115,10 @@ void NetworkService::run() {
         if (esp_wifi_get_mode(&mode) == ESP_ERR_WIFI_NOT_INIT) {
             // WiFi was deallocated
             // TODO: This is a crutch to avoid using WiFi after deallocation by apps (e. g. LilTracker). /AD
-            // Serial.println("NetworkService: WiFi deallocated");
+            // lilka::serial_log("NetworkService: WiFi deallocated");
         } else if (WiFi.status() == WL_DISCONNECTED) {
             // WiFi is disconnected
-            // Serial.println("NetworkService: WiFi disconnected");
+            // lilka::serial_log("NetworkService: WiFi disconnected");
         } else {
             const int8_t rssi = WiFi.RSSI();
             if (rssi == 0) {
@@ -169,17 +168,17 @@ int NetworkService::getSignalStrength() {
 bool NetworkService::connect(String ssid) {
     String password = getPassword(ssid);
     if (password == "") {
-        Serial.println("NetworkService: no password found for SSID " + ssid);
+        lilka::serial_log("NetworkService: no password found for SSID %s", ssid.c_str());
         return false;
     }
-    Serial.println("NetworkService: found password for SSID " + ssid);
+    lilka::serial_log("NetworkService: found password for SSID ", ssid.c_str());
     connect(ssid, password);
     return true;
 }
 
 // Attempt to connect to a given network with a given password.
 void NetworkService::connect(String ssid, String password) {
-    Serial.println("NetworkService: connecting to " + ssid);
+    lilka::serial_log("NetworkService: connecting to %s", ssid.c_str());
     lastPassword = password;
     WiFi.disconnect();
     WiFi.begin(ssid.c_str(), password.c_str());
@@ -217,7 +216,6 @@ String NetworkService::getIpAddr() {
 }
 
 void NetworkService::setNetworkState(NetworkState state) {
-    // xSemaphoreTake(mutex, portMAX_DELAY);
     if (this->state != state) {
         this->state = state;
         if (state == NETWORK_STATE_OFFLINE) {
@@ -226,5 +224,4 @@ void NetworkService::setNetworkState(NetworkState state) {
             AppManager::getInstance()->startToast("Приєднано до WiFi", 2000);
         }
     }
-    // xSemaphoreGive(mutex);
 }

sdk/lib/lilka/src/lilka/buzzer.cpp

@@ -22,8 +22,6 @@ void Buzzer::begin() {
 #else
     _stop();
     pinMode(LILKA_BUZZER, OUTPUT);
-    // TODO: Should not be here. Треба кудись винести.
-    // const Tone helloTune[] = {{NOTE_C4, 8}, {NOTE_E4, 8}, {NOTE_E5, -4}, {NOTE_C6, 8}, {NOTE_C5, 8}};
     const Tone helloTune[] = {{NOTE_C3, 8}, {NOTE_C4, 8}, {NOTE_C5, 8}, {NOTE_C7, 4}, {0, 8}, {NOTE_C6, 4}};
     playMelody(helloTune, sizeof(helloTune) / sizeof(Tone), 160);
 #endif