Task.h

Go to the documentation of this file.

#pragma once
 
#ifdef ESP32
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#elif defined(__linux__)
#else
#include "FreeRTOS.h"
#include "task.h"
#endif
#include <functional>
#include "AudioTools/Concurrency/ITask.h"
#include "AudioLogger.h"
 
namespace audio_tools {

class Task : public ITask {
 public:
  Task(const char* name, int stackSizeWords, int priority = 1, int core = -1)
      : task_name(name),
        task_stack_size(stackSizeWords),
        task_priority(priority),
        task_core(core) {}
 
  Task() = default;
  ~Task() { remove(); }

  bool create(const char* name, int stackSizeWords, int priority = 1,
              int core = -1) {
    if (xHandle != 0) return false;
    // configMAX_PRIORITIES varies a lot between platforms (e.g.
    // RP2040/arduino-pico only goes up to 7); clamp to avoid undefined
    // behavior when a caller-supplied priority is out of range
    if (priority >= configMAX_PRIORITIES) {
       priority = configMAX_PRIORITIES - 1;
       LOGW("clamped task priority to %d ", priority);
    }
    BaseType_t rc;
#ifdef ESP32
    if (core >= 0)
      rc = xTaskCreatePinnedToCore(task_loop, name, stackSizeWords, this,
                                   priority, &xHandle, core);
    else
      rc = xTaskCreate(task_loop, name, stackSizeWords, this, priority,
                       &xHandle);
    // without a valid handle suspend() would suspend the calling task
    if (rc != pdPASS || xHandle == nullptr) {
      LOGE("could not create task %s", name);
      xHandle = nullptr;
      return false;
    }
    suspend();
#else
    rc = xTaskCreate(task_loop, name, stackSizeWords, this, priority,
                     &xHandle);
    if (rc != pdPASS || xHandle == nullptr) {
      LOGE("could not create task %s", name);
      xHandle = nullptr;
      return false;
    }
    suspend();
#if defined(configUSE_CORE_AFFINITY) && (configUSE_CORE_AFFINITY == 1) && \
    (configNUMBER_OF_CORES > 1)
    // e.g. RP2040 (Earle Philhower core): pin the task to a core after
    // creation via the FreeRTOS SMP core-affinity API
    if (core >= 0) vTaskCoreAffinitySet(xHandle, (1 << core));
#endif
#endif
    return true;
  }

  void remove() {
    if (xHandle != nullptr) {
      suspend();
      vTaskDelete(xHandle);
      xHandle = nullptr;
      task_suspended = false;
    }
  }
 
  bool begin(std::function<void()> process) {
    LOGI("starting task");
    if (xHandle == nullptr && task_name != nullptr) {
      if (!create(task_name, task_stack_size, task_priority, task_core))
        return false;
    }
    if (xHandle == nullptr) {
      LOGE("task not created: call create() or use the named constructor");
      return false;
    }
    loop_code = process;
    resume();
    return true;
  }

  void end() { suspend(); }

  void suspend() {
    if (xHandle == nullptr) return;
    vTaskSuspend(xHandle);
    task_suspended = true;
  }
 
  void resume() {
    if (xHandle == nullptr) return;
    vTaskResume(xHandle);
    task_suspended = false;
  }

  bool isSuspended() { return xHandle != nullptr && task_suspended; }

  bool isEnded() { return xHandle == nullptr; }

  bool isRunning() { return xHandle != nullptr && !task_suspended; }
 
  TaskHandle_t &getTaskHandle() {
    return xHandle;
  }
 
  void setReference(void *r){
    ref = r;
  }
 
  void *getReference(){
    return ref;
  }
 
#ifdef ESP32
  int getCoreID() {
    return xPortGetCoreID();
  }
#endif
 
 protected:
  TaskHandle_t xHandle = nullptr;
  std::function<void()> loop_code = nop;
  void *ref = nullptr;
  const char* task_name = nullptr;
  int task_stack_size = 0;
  int task_priority = 1;
  int task_core = -1;
  bool task_suspended = false;
 
  static void nop() { delay(100); }
 
  static void task_loop(void* arg) {
    Task* self = (Task*)arg;
    while (true) {
      self->loop_code();
    }
  }
};
 
}  // namespace audio_tools