feat: task manager

src/TaskManager.cpp

@@ -0,0 +1,162 @@
+#include "TaskManager.h"
+#include <Arduino.h>
+#include <TaskScheduler.h>
+
+TaskManager::TaskManager(NodeContext& ctx) : ctx(ctx) {}
+
+TaskManager::~TaskManager() {
+    // Clean up tasks
+    for (auto task : tasks) {
+        delete task;
+    }
+    tasks.clear();
+}
+
+void TaskManager::registerTask(const std::string& name, unsigned long interval, TaskCallback callback, bool enabled, bool autoStart) {
+    TaskDefinition taskDef(name, interval, callback, enabled, autoStart);
+    registerTask(taskDef);
+}
+
+void TaskManager::registerTask(const TaskDefinition& taskDef) {
+    taskDefinitions.push_back(taskDef);
+}
+
+void TaskManager::initialize() {
+    // Initialize the scheduler
+    ctx.scheduler->init();
+    
+    // Create all registered tasks
+    for (const auto& taskDef : taskDefinitions) {
+        createTask(taskDef);
+    }
+    
+    // Enable tasks that should auto-start
+    for (const auto& taskDef : taskDefinitions) {
+        if (taskDef.autoStart && taskDef.enabled) {
+            enableTask(taskDef.name);
+        }
+    }
+}
+
+void TaskManager::createTask(const TaskDefinition& taskDef) {
+    // Create new task
+    Task* task = new Task(0, TASK_FOREVER, taskDef.callback);
+    task->setInterval(taskDef.interval);
+    
+    // Add to scheduler
+    ctx.scheduler->addTask(*task);
+    
+    // Store task pointer
+    tasks.push_back(task);
+    
+    Serial.printf("[TaskManager] Created task: %s (interval: %lu ms)\n", 
+                  taskDef.name.c_str(), taskDef.interval);
+}
+
+void TaskManager::enableTask(const std::string& name) {
+    Task* task = findTask(name);
+    if (task) {
+        task->enable();
+        Serial.printf("[TaskManager] Enabled task: %s\n", name.c_str());
+    } else {
+        Serial.printf("[TaskManager] Warning: Task not found: %s\n", name.c_str());
+    }
+}
+
+void TaskManager::disableTask(const std::string& name) {
+    Task* task = findTask(name);
+    if (task) {
+        task->disable();
+        Serial.printf("[TaskManager] Disabled task: %s\n", name.c_str());
+    } else {
+        Serial.printf("[TaskManager] Warning: Task not found: %s\n", name.c_str());
+    }
+}
+
+void TaskManager::setTaskInterval(const std::string& name, unsigned long interval) {
+    Task* task = findTask(name);
+    if (task) {
+        task->setInterval(interval);
+        Serial.printf("[TaskManager] Set interval for task %s: %lu ms\n", name.c_str(), interval);
+    } else {
+        Serial.printf("[TaskManager] Warning: Task not found: %s\n", name.c_str());
+    }
+}
+
+void TaskManager::startTask(const std::string& name) {
+    Task* task = findTask(name);
+    if (task) {
+        task->enable();
+        Serial.printf("[TaskManager] Started task: %s\n", name.c_str());
+    } else {
+        Serial.printf("[TaskManager] Warning: Task not found: %s\n", name.c_str());
+    }
+}
+
+void TaskManager::stopTask(const std::string& name) {
+    Task* task = findTask(name);
+    if (task) {
+        task->disable();
+        Serial.printf("[TaskManager] Stopped task: %s\n", name.c_str());
+    } else {
+        Serial.printf("[TaskManager] Warning: Task not found: %s\n", name.c_str());
+    }
+}
+
+bool TaskManager::isTaskEnabled(const std::string& name) const {
+    Task* task = findTask(name);
+    return task ? task->isEnabled() : false;
+}
+
+bool TaskManager::isTaskRunning(const std::string& name) const {
+    Task* task = findTask(name);
+    return task ? task->isEnabled() : false;
+}
+
+unsigned long TaskManager::getTaskInterval(const std::string& name) const {
+    Task* task = findTask(name);
+    return task ? task->getInterval() : 0;
+}
+
+void TaskManager::enableAllTasks() {
+    for (auto task : tasks) {
+        task->enable();
+    }
+    Serial.println("[TaskManager] Enabled all tasks");
+}
+
+void TaskManager::disableAllTasks() {
+    for (auto task : tasks) {
+        task->disable();
+    }
+    Serial.println("[TaskManager] Disabled all tasks");
+}
+
+void TaskManager::printTaskStatus() const {
+    Serial.println("\n[TaskManager] Task Status:");
+    Serial.println("==========================");
+    
+    for (size_t i = 0; i < tasks.size() && i < taskDefinitions.size(); ++i) {
+        const auto& taskDef = taskDefinitions[i];
+        const auto& task = tasks[i];
+        
+        Serial.printf("  %s: %s (interval: %lu ms)\n", 
+                      taskDef.name.c_str(),
+                      task->isEnabled() ? "ENABLED" : "DISABLED",
+                      task->getInterval());
+    }
+    Serial.println("==========================\n");
+}
+
+void TaskManager::execute() {
+    ctx.scheduler->execute();
+}
+
+Task* TaskManager::findTask(const std::string& name) const {
+    for (size_t i = 0; i < tasks.size() && i < taskDefinitions.size(); ++i) {
+        if (taskDefinitions[i].name == name) {
+            return tasks[i];
+        }
+    }
+    return nullptr;
+}