SpotMicroESP32-Leika/esp32/lib/ESP32-sveltekit/TaskManager.h

#pragma once

#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<const char *, task_t> _tasks;
    IdleTask _taskIdle0;
    IdleTask _taskIdle1;

    TaskHandle_t _hIdle0;
    TaskHandle_t _hIdle1;

  public:
    TaskManager()
    {
    }

    void begin()
    {
        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);
    }

    std::vector<task_t> getTasks()
    {
        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)
        {
            _tasks[task.first].priority = uxTaskPriorityGet(task.second.handle);
            _tasks[task.first].coreId = xTaskGetAffinity(task.second.handle);
        }
    }

    float getCpuUsage(int iCore = -1) const
    {
        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())
        {
            vTaskSuspend(_tasks[name].handle);
            _tasks[name].active = false;
        }
    }

    void resumeTask(const char * name)
    {
        if (_tasks.find(name) != _tasks.end())
        {
            vTaskResume(_tasks[name].handle);
            _tasks[name].active = true;
        }
    }

    void notifyTask(const char * name, uint32_t notificationValue, eNotifyAction action = eSetValueWithOverwrite)
    {
        if (_tasks.find(name) != _tasks.end())
            xTaskNotify(_tasks[name].handle, notificationValue, action);
    }

    void deleteTask(const char * name)
    {
        if (_tasks.find(name) != _tasks.end())
        {
            vTaskDelete(_tasks[name].handle);
            _tasks.erase(name);
        }
    }
};