Adds taskManager cpu usage

esp32/lib/ESP32-sveltekit/TaskManager.h

@@ -3,77 +3,179 @@
 #include <esp_task_wdt.h>
 #include <map>
 #include <string>
+#include <vector>
 
 #define IDLE_STACK_SIZE 2048
 #define DEFAULT_STACK_SIZE 2048+512
 
 #define DELETE_TASK(handle) if (handle != nullptr) vTaskDelete(handle)
 
+struct task_t
+{
+    String name;
+    TaskHandle_t handle;
+    uint32_t stackSize;
+    UBaseType_t priority;
+    BaseType_t coreId;
+    bool pinned;
+    bool active; // blocked ('B'), ready ('R'), deleted ('D') or suspended ('S').
+};
+
+class IdleTask
+{
+  private:
+    float _idleRatio = 0;
+    unsigned long _lastMeasurement;
+
+    const int kMillisPerLoop = 1;
+    const int kMillisPerCalc = 1000;
+
+    unsigned long counter = 0;
+
+  public:
+    void ProcessIdleTime()
+    {
+        _lastMeasurement = millis();
+        counter = 0;
+
+        for(;;)
+        {
+            int delta = millis() - _lastMeasurement;
+            if (delta >= kMillisPerCalc)
+            {
+                _idleRatio = static_cast<float>(counter) / delta;
+                _lastMeasurement = millis();
+                counter = 0;
+            }
+            else
+            {
+                esp_task_wdt_reset();
+                delayMicroseconds(kMillisPerLoop * 1000);
+                counter += kMillisPerLoop;
+            }
+        }
+    }
+
+    IdleTask() : _lastMeasurement(millis())
+    {
+    }
+
+    float GetCPUUsage() const
+    {
+        if (millis() - _lastMeasurement > kMillisPerCalc)
+            return 100.0f;
+
+        return 100.0f - 100 * _idleRatio;
+    }
+
+    static void IdleTaskEntry(void *that)
+    {
+        static_cast<IdleTask *>(that)->ProcessIdleTime();
+    }
+};
+
 class TaskManager
 {
   private:
-    std::map<std::string, TaskHandle_t> tasks;
+    std::map<const char *, task_t> _tasks;
+    IdleTask _taskIdle0;
+    IdleTask _taskIdle1;
 
-    static void idleTask(void *pvParameters)
-    {
-        while (true)
-        {
-            vTaskDelay(pdMS_TO_TICKS(1000)); // Delay to simulate workload
-        }
-    }
+    TaskHandle_t _hIdle0;
+    TaskHandle_t _hIdle1;
 
   public:
     TaskManager()
     {
-        xTaskCreatePinnedToCore(idleTask, "IdleTaskCore0", 1024, nullptr, 0, nullptr, 0);
-        xTaskCreatePinnedToCore(idleTask, "IdleTaskCore1", 1024, nullptr, 0, nullptr, 1);
     }
 
-    void createTask(const std::string &name, void (*taskFunction)(void *), void *params = nullptr,
-                    uint32_t stackSize = 2048, UBaseType_t priority = 1)
+    void begin()
     {
-        TaskHandle_t handle;
-        xTaskCreate(taskFunction, name.c_str(), stackSize, params, priority + 1, &handle);
-        tasks[name] = handle;
+        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, 1);
+        esp_task_wdt_delete(xTaskGetIdleTaskHandleForCPU(0));
+        esp_task_wdt_delete(xTaskGetIdleTaskHandleForCPU(1));
+        esp_task_wdt_add(_hIdle0);
+        esp_task_wdt_add(_hIdle1);
     }
 
-    void suspendTask(const std::string &name)
+    std::vector<task_t> getTasks()
     {
-        if (tasks.find(name) != tasks.end())
+        std::vector<task_t> tasks;
+        for (auto const &task : _tasks)
+            tasks.push_back(task.second);
+        return tasks;
+    }
+
+    int getTaskCount() const
+    {
+        return _tasks.size();
+    }
+
+    int getKernelTaskCount() const
+    {
+        return uxTaskGetNumberOfTasks();
+    }
+
+    void update()
+    {
+        for (auto const &task : _tasks)
         {
-            vTaskSuspend(tasks[name]);
+            _tasks[task.first].priority = uxTaskPriorityGet(task.second.handle);
+            _tasks[task.first].coreId = xTaskGetAffinity(task.second.handle);
         }
     }
 
-    void resumeTask(const std::string &name)
+    float getCpuUsage(int iCore = -1) const
     {
-        if (tasks.find(name) != tasks.end())
+        if (iCore == 0) return _taskIdle0.GetCPUUsage();
+        else if (iCore == 1) return _taskIdle1.GetCPUUsage();
+        return (_taskIdle0.GetCPUUsage() + _taskIdle1.GetCPUUsage()) / 2;
+    }
+
+    BaseType_t createTask(void (*taskFunction)(void *), const char * name, uint32_t stackSize = 2048,
+                          void *params = nullptr, UBaseType_t priority = tskIDLE_PRIORITY + 1, TaskHandle_t* handle = nullptr,
+                          BaseType_t coreId = -1)
+    {
+        BaseType_t res = coreId == -1 
+            ? xTaskCreate(taskFunction, name, stackSize, params, priority + 1, handle)
+            : xTaskCreatePinnedToCore(taskFunction, name, stackSize, params, priority + 1, handle, coreId);
+        task_t task = {name, handle, stackSize, priority + 1, coreId, coreId != -1, true};
+        if (res == pdPASS)
+            _tasks[name] = task;
+        return res;
+    }
+
+    void suspendTask(const char * name)
+    {
+        if (_tasks.find(name) != _tasks.end())
         {
-            vTaskResume(tasks[name]);
+            vTaskSuspend(_tasks[name].handle);
+            _tasks[name].active = false;
         }
     }
 
-    void notifyTask(const std::string &name, uint32_t notificationValue, eNotifyAction action = eSetValueWithOverwrite)
+    void resumeTask(const char * name)
     {
-        if (tasks.find(name) != tasks.end())
+        if (_tasks.find(name) != _tasks.end())
         {
-            xTaskNotify(tasks[name], notificationValue, action);
+            vTaskResume(_tasks[name].handle);
+            _tasks[name].active = true;
         }
     }
 
-    void deleteTask(const std::string &name)
+    void notifyTask(const char * name, uint32_t notificationValue, eNotifyAction action = eSetValueWithOverwrite)
     {
-        if (tasks.find(name) != tasks.end())
-        {
-            vTaskDelete(tasks[name]);
-            tasks.erase(name);
-        }
+        if (_tasks.find(name) != _tasks.end())
+            xTaskNotify(_tasks[name].handle, notificationValue, action);
     }
 
-    float getCpuUsage(uint8_t coreId)
+    void deleteTask(const char * name)
     {
-        if (coreId > 1)
-            return 0.0; // ESP32 has only core 0 and 1
-        return uxTaskGetSystemState(nullptr, 0, nullptr) * 100.0 / configTICK_RATE_HZ;
+        if (_tasks.find(name) != _tasks.end())
+        {
+            vTaskDelete(_tasks[name].handle);
+            _tasks.erase(name);
+        }
     }
 };