task.hpp

Go to the documentation of this file.

// Copyright (C) 2025 Vincent Hamp
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

 
#include <esp_task.h>
#include <array>
 
#pragma once
 
#define CONCAT_DETAIL(A, B) A##B
#define CONCAT(A, B) CONCAT_DETAIL(A, B)

#define COMMON_TASK_MEMBERS(NAME, PRIORITY, CORE_ID, TIMEOUT)                  \
  static constexpr char const* name{NAME};                                     \
  static constexpr UBaseType_t priority{PRIORITY};                             \
  static constexpr BaseType_t core_id{CORE_ID};                                \
  static constexpr TickType_t timeout{TIMEOUT};                                \
  static inline StaticTask_t tcb{};                                            \
  static inline TaskFunction_t function{NULL};                                 \
  static inline TaskHandle_t handle{NULL};                                     \
  static void create(TaskFunction_t f = function) {                            \
    handle = xTaskCreateStaticPinnedToCore(function = f,                       \
                                           name,                               \
                                           size(stack),                        \
                                           NULL,                               \
                                           priority,                           \
                                           data(stack),                        \
                                           &tcb,                               \
                                           core_id);                           \
  }                                                                            \
  static void destroy() {                                                      \
    vTaskDelete(handle);                                                       \
    handle = NULL;                                                             \
  }                                                                            \
  static void resume() { vTaskResume(handle); }                                \
  static void suspend() { vTaskSuspend(handle); }

#define TASK(OBJECT, NAME, STACK_SIZE, PRIORITY, CORE_ID, TIMEOUT)             \
  struct CONCAT(Task, __LINE__) {                                              \
    static inline std::array<StackType_t, STACK_SIZE> stack{};                 \
    COMMON_TASK_MEMBERS(NAME, PRIORITY, CORE_ID, TIMEOUT)                      \
  } OBJECT

#define SHARED_TASK(OBJECT, NAME, PRIORITY, CORE_ID, TIMEOUT)                  \
  struct CONCAT(SharedTask, __LINE__) {                                        \
    COMMON_TASK_MEMBERS(NAME, PRIORITY, CORE_ID, TIMEOUT)                      \
  } OBJECT