Task.hpp

/*
 * FreeRTOS-Cpp
 * Copyright (C) 2021 Jon Enz. All Rights Reserved.
 *
 * SPDX-License-Identifier: MIT
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * https://github.com/jonenz/FreeRTOS-Cpp
 */
 
#ifndef FREERTOS_TASK_HPP
#define FREERTOS_TASK_HPP
 
#include <FreeRTOS/Kernel.hpp>
#include <bitset>
#include <utility>
 
#include "FreeRTOS.h"
#include "task.h"
 
void callTaskFunction(void* task);
 
namespace FreeRTOS {
 
class TaskBase {
 public:
  friend class Task;
  template <UBaseType_t>
  friend class StaticTask;
 
  TaskBase(const TaskBase&) = delete;
  TaskBase& operator=(const TaskBase&) = delete;
 
  static void* operator new(size_t, void* ptr) { return ptr; }
  static void* operator new[](size_t, void* ptr) { return ptr; }
  static void* operator new(size_t) = delete;
  static void* operator new[](size_t) = delete;
 
  enum class State {
    Running = eRunning,
    Ready = eReady,
    Blocked = eBlocked,
    Suspended = eSuspended,
    Deleted = eDeleted,
    Invalid = eInvalid,
  };
 
  enum class NotifyAction {
    NoAction = eNoAction,
    SetBits = eSetBits,
    Increment = eIncrement,
    SetValueWithOverwrite = eSetValueWithOverwrite,
    SetValueWithoutOverwrite = eSetValueWithoutOverwrite,
  };
 
  // NOLINTNEXTLINE
  using NotificationBits = std::bitset<32>;
 
  virtual inline void taskEntry() final {
    previousWakeTime = FreeRTOS::Kernel::getTickCount();
    taskFunction();
  };
 
#if (INCLUDE_uxTaskPriorityGet == 1)
  inline UBaseType_t getPriority() const { return uxTaskPriorityGet(handle); }
#endif /* INCLUDE_uxTaskPriorityGet */
 
#if (INCLUDE_vTaskPrioritySet == 1)
  inline void setPriority(const UBaseType_t newPriority) const {
    vTaskPrioritySet(handle, newPriority);
  }
#endif /* INCLUDE_vTaskPrioritySet */
 
#if (INCLUDE_vTaskSuspend == 1)
  inline void suspend() const { vTaskSuspend(handle); }
 
  inline void resume() const { vTaskResume(handle); }
 
#if (INCLUDE_xTaskResumeFromISR == 1)
  inline bool resumeFromISR() const {
    return (xTaskResumeFromISR(handle) == pdTRUE);
  }
#endif /* INCLUDE_xTaskResumeFromISR */
#endif /* INCLUDE_vTaskSuspend */
 
#if (INCLUDE_xTaskAbortDelay == 1)
  inline bool abortDelay() const { return (xTaskAbortDelay(handle) == pdPASS); }
#endif /* INCLUDE_xTaskAbortDelay */
 
#if (INCLUDE_xTaskGetIdleTaskHandle == 1)
  inline static TaskHandle_t getIdleHandle() {
    return xTaskGetIdleTaskHandle();
  }
#endif /* INCLUDE_xTaskGetIdleTaskHandle */
 
#if (INCLUDE_uxTaskGetStackHighWaterMark == 1)
  inline UBaseType_t getStackHighWaterMark() const {
    return uxTaskGetStackHighWaterMark(handle);
  }
 
  inline configSTACK_DEPTH_TYPE getStackHighWaterMark2() const {
    return uxTaskGetStackHighWaterMark2(handle);
  }
#endif /* INCLUDE_uxTaskGetStackHighWaterMark */
 
#if (INCLUDE_eTaskGetState == 1)
  inline State getState() const {
    return static_cast<State>(eTaskGetState(handle));
  }
#endif /* INCLUDE_eTaskGetState */
 
  inline const char* getName() const { return pcTaskGetName(handle); }
 
#if (INCLUDE_xTaskGetHandle == 1)
  inline static TaskHandle_t getHandle(const char* name) {
    return xTaskGetHandle(name);
  }
#endif /* INCLUDE_xTaskGetHandle */
 
#if (configUSE_TASK_NOTIFICATIONS == 1)
  inline void notifyGive(const UBaseType_t index = 0) const {
    xTaskNotifyGiveIndexed(handle, index);
  }
 
  inline void notifyGiveFromISR(bool& higherPriorityTaskWoken,
                                const UBaseType_t index = 0) const {
    BaseType_t taskWoken = pdFALSE;
    vTaskNotifyGiveIndexedFromISR(handle, index, &taskWoken);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
  }
 
  inline void notifyGiveFromISR(const UBaseType_t index = 0) const {
    vTaskNotifyGiveIndexedFromISR(handle, index, NULL);
  }
 
  inline bool notify(const NotifyAction action,
                     const NotificationBits value = 0,
                     const UBaseType_t index = 0) const {
    return (xTaskNotifyIndexed(handle, index, value.to_ulong(),
                               static_cast<eNotifyAction>(action)) == pdPASS);
  }
 
  inline std::pair<bool, NotificationBits> notifyAndQuery(
      const NotifyAction action, const NotificationBits value = 0,
      const UBaseType_t index = 0) const {
    uint32_t pulNotificationValue;
    bool result =
        (xTaskNotifyAndQueryIndexed(handle, index, value.to_ulong(),
                                    static_cast<eNotifyAction>(action),
                                    &pulNotificationValue) == pdPASS);
 
    return std::make_pair(result, NotificationBits(pulNotificationValue));
  }
 
  inline std::pair<bool, NotificationBits> notifyAndQueryFromISR(
      bool& higherPriorityTaskWoken, const NotifyAction action,
      const NotificationBits value = 0, const UBaseType_t index = 0) const {
    BaseType_t taskWoken = pdFALSE;
    uint32_t pulNotificationValue;
    bool result = (xTaskNotifyAndQueryIndexedFromISR(
                       handle, index, value.to_ulong(),
                       static_cast<eNotifyAction>(action),
                       &pulNotificationValue, &taskWoken) == pdPASS);
 
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
 
    return std::make_pair(result, NotificationBits(pulNotificationValue));
  }
 
  inline std::pair<bool, NotificationBits> notifyAndQueryFromISR(
      const NotifyAction action, const NotificationBits value = 0,
      const UBaseType_t index = 0) const {
    uint32_t pulNotificationValue;
    bool result = (xTaskNotifyAndQueryIndexedFromISR(
                       handle, index, value.to_ulong(),
                       static_cast<eNotifyAction>(action),
                       &pulNotificationValue, NULL) == pdPASS);
 
    return std::make_pair(result, NotificationBits(pulNotificationValue));
  }
 
  inline bool notifyFromISR(bool& higherPriorityTaskWoken,
                            const NotifyAction action,
                            const NotificationBits value = 0,
                            const UBaseType_t index = 0) const {
    BaseType_t taskWoken = pdFALSE;
    bool result = (xTaskNotifyIndexedFromISR(handle, index, value.to_ulong(),
                                             static_cast<eNotifyAction>(action),
                                             &taskWoken) == pdPASS);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
    return result;
  }
 
  inline bool notifyFromISR(const NotifyAction action,
                            const NotificationBits value = 0,
                            const UBaseType_t index = 0) const {
    return (xTaskNotifyIndexedFromISR(handle, index, value.to_ulong(),
                                      static_cast<eNotifyAction>(action),
                                      NULL) == pdPASS);
  }
 
  inline static std::pair<bool, NotificationBits> notifyWait(
      const TickType_t ticksToWait = portMAX_DELAY,
      const NotificationBits bitsToClearOnEntry = 0,
      const NotificationBits bitsToClearOnExit = 0,
      const UBaseType_t index = 0) {
    uint32_t pulNotificationValue;
    bool result =
        (xTaskNotifyWaitIndexed(index, bitsToClearOnEntry.to_ulong(),
                                bitsToClearOnExit.to_ulong(),
                                &pulNotificationValue, ticksToWait) == pdTRUE);
    return std::make_pair(result, NotificationBits(pulNotificationValue));
  }
 
  inline bool notifyStateClear(const UBaseType_t index = 0) const {
    return (xTaskNotifyStateClearIndexed(handle, index) == pdTRUE);
  }
 
  inline NotificationBits notifyValueClear(
      const NotificationBits bitsToClear = 0,
      const UBaseType_t index = 0) const {
    return NotificationBits(
        ulTaskNotifyValueClearIndexed(handle, index, bitsToClear.to_ulong()));
  }
#endif /* configUSE_TASK_NOTIFICATIONS */
 
 protected:
  virtual void taskFunction() = 0;
 
#if (INCLUDE_vTaskDelay == 1)
  inline static void delay(const TickType_t ticksToDelay = 0) {
    vTaskDelay(ticksToDelay);
  }
#endif /* INCLUDE_vTaskDelay */
 
#if (INCLUDE_xTaskDelayUntil == 1)
  inline bool delayUntil(const TickType_t timeIncrement = 0) {
    return (xTaskDelayUntil(&previousWakeTime, timeIncrement) == pdTRUE);
  }
#endif /* INCLUDE_xTaskDelayUntil */
 
  inline static NotificationBits notifyTake(
      const TickType_t ticksToWait = portMAX_DELAY,
      const bool clearCountOnExit = true, const UBaseType_t index = 0) {
    return NotificationBits(
        ulTaskNotifyTakeIndexed(index, clearCountOnExit, ticksToWait));
  }
 
 private:
  TaskBase() = default;
 
  TaskBase(TaskBase&&) noexcept = default;
  TaskBase& operator=(TaskBase&&) noexcept = default;
 
  ~TaskBase() {
#if (INCLUDE_vTaskDelete == 1)
 
    if (handle != NULL) {
      vTaskDelete(handle);
    }
 
#endif /* INCLUDE_vTaskDelete */
  }
 
  TaskHandle_t handle = NULL;
 
  TickType_t previousWakeTime = 0;
};
 
#if (configSUPPORT_DYNAMIC_ALLOCATION == 1)
 
class Task : public TaskBase {
 public:
  Task(const Task&) = delete;
  Task& operator=(const Task&) = delete;
 
  bool isValid() const { return taskCreatedSuccessfully; }
 
 protected:
  explicit Task(
      const UBaseType_t priority = tskIDLE_PRIORITY,
      const configSTACK_DEPTH_TYPE stackDepth = configMINIMAL_STACK_SIZE,
      const char* name = "") {
    taskCreatedSuccessfully = (xTaskCreate(callTaskFunction, name, stackDepth,
                                           this, priority, &handle) == pdPASS);
  }
 
  ~Task() = default;
 
  Task(Task&&) noexcept = default;
  Task& operator=(Task&&) noexcept = default;
 
 private:
  bool taskCreatedSuccessfully = false;
};
 
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
 
#if (configSUPPORT_STATIC_ALLOCATION == 1)
 
template <UBaseType_t N = configMINIMAL_STACK_SIZE>
class StaticTask : public TaskBase {
 public:
  StaticTask(const StaticTask&) = delete;
  StaticTask& operator=(const StaticTask&) = delete;
 
 protected:
  explicit StaticTask(const UBaseType_t priority = tskIDLE_PRIORITY,
                      const char* name = "") {
    handle = xTaskCreateStatic(callTaskFunction, name, N, this, priority, stack,
                               &taskBuffer);
  }
  ~StaticTask() = default;
 
  StaticTask(StaticTask&&) noexcept = default;
  StaticTask& operator=(StaticTask&&) noexcept = default;
 
 private:
  StaticTask_t taskBuffer;
  StackType_t stack[N];
};
 
#endif /* configSUPPORT_STATIC_ALLOCATION */
 
}  // namespace FreeRTOS
 
inline void callTaskFunction(void* task) {
  static_cast<FreeRTOS::TaskBase*>(task)->taskEntry();
}
 
#endif  // FREERTOS_TASK_HPP