Timer.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_TIMER_HPP
#define FREERTOS_TIMER_HPP
 
#include "FreeRTOS.h"
#include "timers.h"
 
void callTimerFunction(TimerHandle_t timer);
 
namespace FreeRTOS {
 
class TimerBase {
 public:
  friend class Timer;
  friend class StaticTimer;
 
  TimerBase(const TimerBase&) = delete;
  TimerBase& operator=(const TimerBase&) = delete;
 
  static void* operator new(size_t) = delete;
  static void* operator new[](size_t) = delete;
 
  static void* operator new(size_t, void* ptr) {
    return ptr;
  }
 
  static void* operator new[](size_t, void* ptr) {
    return ptr;
  }
 
  virtual inline void timerEntry() final {
    timerFunction();
  }
 
  inline bool isValid() const {
    return (handle != NULL);
  }
 
  inline bool isActive() const {
    return (xTimerIsTimerActive(handle) != pdFALSE);
  }
 
  inline bool start(const TickType_t blockTime = 0) const {
    return (xTimerStart(handle, blockTime) == pdPASS);
  }
 
  inline bool startFromISR(bool& higherPriorityTaskWoken) const {
    BaseType_t taskWoken = pdFALSE;
    const bool result = (xTimerStartFromISR(handle, &taskWoken) == pdPASS);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
    return result;
  }
 
  inline bool startFromISR() const {
    return (xTimerStartFromISR(handle, NULL) == pdPASS);
  }
 
  inline bool stop(const TickType_t blockTime = 0) const {
    return (xTimerStop(handle, blockTime) == pdPASS);
  }
 
  inline bool stopFromISR(bool& higherPriorityTaskWoken) const {
    BaseType_t taskWoken = pdFALSE;
    const bool result = (xTimerStopFromISR(handle, &taskWoken) == pdPASS);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
    return result;
  }
 
  inline bool stopFromISR() const {
    return (xTimerStopFromISR(handle, NULL) == pdPASS);
  }
 
  inline bool changePeriod(const TickType_t newPeriod,
                           const TickType_t blockTime = 0) const {
    return (xTimerChangePeriod(handle, newPeriod, blockTime) == pdPASS);
  }
 
  inline bool changePeriodFromISR(bool& higherPriorityTaskWoken,
                                  const TickType_t newPeriod) const {
    BaseType_t taskWoken = pdFALSE;
    const bool result =
        (xTimerChangePeriodFromISR(handle, newPeriod, &taskWoken) == pdPASS);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
    return result;
  }
 
  inline bool changePeriodFromISR(const TickType_t newPeriod) const {
    return (xTimerChangePeriodFromISR(handle, newPeriod, NULL) == pdPASS);
  }
 
  inline bool deleteTimer(const TickType_t blockTime = 0) {
    if (xTimerDelete(handle, blockTime) == pdPASS) {
      handle = NULL;
      return true;
    }
    return false;
  }
 
  inline bool reset(const TickType_t blockTime = 0) const {
    return (xTimerReset(handle, blockTime) == pdPASS);
  }
 
  inline bool resetFromISR(bool& higherPriorityTaskWoken) const {
    BaseType_t taskWoken = pdFALSE;
    const bool result = (xTimerResetFromISR(handle, &taskWoken) == pdPASS);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
    return result;
  }
 
  inline bool resetFromISR() const {
    return (xTimerResetFromISR(handle, NULL) == pdPASS);
  }
 
  inline void setReloadMode(const bool autoReload) const {
    vTimerSetReloadMode(handle, (autoReload ? pdTRUE : pdFALSE));
  }
 
  inline const char* getName() const {
    return pcTimerGetName(handle);
  }
 
  inline TickType_t getPeriod() const {
    return xTimerGetPeriod(handle);
  }
 
  inline TickType_t getExpiryTime() const {
    return xTimerGetExpiryTime(handle);
  }
 
  inline bool getReloadMode() const {
    return (uxTimerGetReloadMode(handle) == pdTRUE);
  }
 
  inline void setDeleteBlockTime(const TickType_t deleteBlockTime = 0) {
    this->deleteBlockTime = deleteBlockTime;
  }
 
  inline TickType_t getDeleteBlockTime() const {
    return deleteBlockTime;
  }
 
 protected:
  virtual void timerFunction() = 0;
 
 private:
  explicit TimerBase(const TickType_t deleteBlockTime = 0)
      : deleteBlockTime(deleteBlockTime) {}
 
  ~TimerBase() {
    if (isValid()) {
      deleteTimer(getDeleteBlockTime());
    }
  }
 
  TimerBase(TimerBase&&) noexcept = default;
  TimerBase& operator=(TimerBase&&) noexcept = default;
 
  TimerHandle_t handle = NULL;
  TickType_t deleteBlockTime;
};
 
#if (configSUPPORT_DYNAMIC_ALLOCATION == 1)
 
class Timer : public TimerBase {
 public:
  Timer(const Timer&) = delete;
  Timer& operator=(const Timer&) = delete;
 
 protected:
  explicit Timer(const TickType_t period, const bool autoReload = false,
                 const char* name = "", const TickType_t deleteBlockTime = 0)
      : TimerBase(deleteBlockTime) {
    this->handle = xTimerCreate(name, period, (autoReload ? pdTRUE : pdFALSE),
                                this, callTimerFunction);
  }
  ~Timer() = default;
 
  Timer(Timer&&) noexcept = default;
  Timer& operator=(Timer&&) noexcept = default;
};
 
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
 
#if (configSUPPORT_STATIC_ALLOCATION == 1)
 
class StaticTimer : public TimerBase {
 public:
  StaticTimer(const StaticTimer&) = delete;
  StaticTimer& operator=(const StaticTimer&) = delete;
 
 protected:
  explicit StaticTimer(const TickType_t period, const bool autoReload = false,
                       const char* name = "",
                       const TickType_t deleteBlockTime = 0)
      : TimerBase(deleteBlockTime) {
    this->handle =
        xTimerCreateStatic(name, period, (autoReload ? pdTRUE : pdFALSE), this,
                           callTimerFunction, &staticTimer);
  }
  ~StaticTimer() = default;
 
  StaticTimer(StaticTimer&&) noexcept = default;
  StaticTimer& operator=(StaticTimer&&) noexcept = default;
 
 private:
  StaticTimer_t staticTimer;
};
 
#endif /* configSUPPORT_STATIC_ALLOCATION */
 
}  // namespace FreeRTOS
 
inline void callTimerFunction(TimerHandle_t timer) {
  static_cast<FreeRTOS::TimerBase*>(pvTimerGetTimerID(timer))->timerEntry();
}
 
#endif  // FREERTOS_TIMER_HPP