🪇 Updates task manager to accurate task cpu usage

esp32/lib/ESP32-sveltekit/TaskManager.h

@@ -23,24 +23,25 @@ struct task_t {
 
 class IdleTask {
   private:
-    float _idleRatio = 0;
+    float idle_ratio = 0.0;
-    unsigned long _lastMeasurement;
+    unsigned long last_measurement;
-
     const int kMillisPerLoop = 1;
     const int kMillisPerCalc = 1000;
-
     unsigned long counter = 0;
 
   public:
+    IdleTask() : last_measurement(millis()) {}
+
     void ProcessIdleTime() {
-        _lastMeasurement = millis();
+        last_measurement = millis();
         counter = 0;
 
         for (;;) {
-            int delta = millis() - _lastMeasurement;
+            unsigned long current_time = millis();
+            unsigned long delta = current_time - last_measurement;
             if (delta >= kMillisPerCalc) {
-                _idleRatio = static_cast<float>(counter) / delta;
+                idle_ratio = static_cast<float>(counter) / delta;
-                _lastMeasurement = millis();
+                last_measurement = current_time;
                 counter = 0;
             } else {
                 esp_task_wdt_reset();
@@ -50,12 +51,10 @@ class IdleTask {
         }
     }
 
-    IdleTask() : _lastMeasurement(millis()) {}
-
     float GetCPUUsage() const {
-        if (millis() - _lastMeasurement > kMillisPerCalc) return 100.0f;
+        if (millis() - last_measurement > kMillisPerCalc) return 100.0f;
 
-        return 100.0f - 100 * _idleRatio;
+        return 100.0f - 100 * idle_ratio;
     }
 
     static void IdleTaskEntry(void *that) { static_cast<IdleTask *>(that)->ProcessIdleTime(); }
@@ -74,9 +73,9 @@ class TaskManager {
     TaskManager() {}
 
     void begin() {
-        createTask(IdleTask::IdleTaskEntry, "Idle Core 0", IDLE_STACK_SIZE, &_taskIdle0, tskIDLE_PRIORITY - 1, &_hIdle0,
+        createTask(IdleTask::IdleTaskEntry, "Idle Core 0", IDLE_STACK_SIZE, &_taskIdle0, tskIDLE_PRIORITY + 1, &_hIdle0,
                    0);
-        createTask(IdleTask::IdleTaskEntry, "Idle Core 1", IDLE_STACK_SIZE, &_taskIdle1, tskIDLE_PRIORITY - 1, &_hIdle1,
+        createTask(IdleTask::IdleTaskEntry, "Idle Core 1", IDLE_STACK_SIZE, &_taskIdle1, tskIDLE_PRIORITY + 1, &_hIdle1,
                    1);
         esp_task_wdt_delete(xTaskGetIdleTaskHandleForCPU(0));
         esp_task_wdt_delete(xTaskGetIdleTaskHandleForCPU(1));
@@ -110,12 +109,13 @@ class TaskManager {
     }
 
     BaseType_t createTask(void (*taskFunction)(void *), const char *name, uint32_t stackSize = 2048,
-                          void *params = nullptr, UBaseType_t priority = tskIDLE_PRIORITY + 1,
+                          void *params = nullptr, UBaseType_t priority = tskIDLE_PRIORITY + 2,
                           TaskHandle_t *handle = nullptr, BaseType_t coreId = -1) {
-        BaseType_t res =
+        BaseType_t res = coreId == -1
-            coreId == -1 ? xTaskCreate(taskFunction, name, stackSize, params, priority + 1, handle)
+                             ? xTaskCreate(taskFunction, name, stackSize, params, tskIDLE_PRIORITY + priority, handle)
-                         : xTaskCreatePinnedToCore(taskFunction, name, stackSize, params, priority + 1, handle, coreId);
+                             : xTaskCreatePinnedToCore(taskFunction, name, stackSize, params,
-        task_t task = {name, handle, stackSize, priority + 1, coreId, coreId != -1, true};
+                                                       tskIDLE_PRIORITY + priority, handle, coreId);
+        task_t task = {name, handle, stackSize, priority, coreId, coreId != -1, true};
         if (res == pdPASS) _tasks[name] = task;
         return res;
     }
@@ -145,3 +145,30 @@ class TaskManager {
         }
     }
 };
+
+class CPUBurnerTask {
+  private:
+    float burn_ratio;
+    const int kMillisPerCalc = 1000;
+
+  public:
+    CPUBurnerTask(float ratio) : burn_ratio(ratio) {}
+
+    void BurnCPUTask() {
+        unsigned long burn_time = burn_ratio * kMillisPerCalc;
+        unsigned long idle_time = kMillisPerCalc - burn_time;
+
+        while (true) {
+            unsigned long start_time = millis();
+            while ((millis() - start_time) < burn_time) {
+                esp_task_wdt_reset();
+            }
+
+            delay(idle_time);
+        }
+    }
+
+    static void CPUBurnerTaskEntry(void *instance) { static_cast<CPUBurnerTask *>(instance)->BurnCPUTask(); }
+
+    void StartTask() { xTaskCreate(CPUBurnerTaskEntry, "CPUBurnerTask", 2048, this, tskIDLE_PRIORITY + 2, nullptr); }
+};