EventGroups.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_EVENTGROUPS_HPP
#define FREERTOS_EVENTGROUPS_HPP
 
#include <bitset>
 
#include "FreeRTOS.h"
#include "event_groups.h"
 
#if (configUSE_EVENT_GROUPS == 1)
 
namespace FreeRTOS {
 
class EventGroupBase {
 public:
  friend class EventGroup;
  friend class StaticEventGroup;
 
  EventGroupBase(const EventGroupBase&) = delete;
  EventGroupBase& operator=(const EventGroupBase&) = 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;
  }
 
#if (configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_16_BITS)
  using EventBits = std::bitset<8>;  // NOLINT
#elif (configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_32_BITS)
  using EventBits = std::bitset<24>;  // NOLINT
#elif (configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_64_BITS)
  using EventBits = std::bitset<56>;  // NOLINT
#endif
 
  inline bool isValid() const {
    return (handle != NULL);
  }
 
  inline EventBits wait(const EventBits& bitsToWaitFor = 0,
                        const bool clearOnExit = false,
                        const bool waitForAllBits = false,
                        const TickType_t ticksToWait = portMAX_DELAY) const {
    return EventBits(xEventGroupWaitBits(
        handle, bitsToWaitFor.to_ulong(), (clearOnExit ? pdTRUE : pdFALSE),
        (waitForAllBits ? pdTRUE : pdFALSE), ticksToWait));
  }
 
  inline EventBits set(const EventBits& bitsToSet) const {
    return EventBits(xEventGroupSetBits(handle, bitsToSet.to_ulong()));
  }
 
  inline bool setFromISR(bool& higherPriorityTaskWoken,
                         const EventBits& bitsToSet) const {
    BaseType_t taskWoken = pdFALSE;
    const bool result = (xEventGroupSetBitsFromISR(handle, bitsToSet.to_ulong(),
                                                   &taskWoken) == pdPASS);
    if (taskWoken == pdTRUE) {
      higherPriorityTaskWoken = true;
    }
    return result;
  }
 
  inline bool setFromISR(const EventBits& bitsToSet) const {
    return (xEventGroupSetBitsFromISR(handle, bitsToSet.to_ulong(), NULL) ==
            pdPASS);
  }
 
  inline EventBits clear(const EventBits& bitsToClear) const {
    return EventBits(xEventGroupClearBits(handle, bitsToClear.to_ulong()));
  }
 
  inline bool clearFromISR(const EventBits& bitsToClear) const {
    return (xEventGroupClearBitsFromISR(handle, bitsToClear.to_ulong()) ==
            pdPASS);
  }
 
  inline EventBits get() const {
    return EventBits(xEventGroupGetBits(handle));
  }
 
  inline EventBits getFromISR() const {
    return EventBits(xEventGroupGetBitsFromISR(handle));
  }
 
  inline EventBits sync(const EventBits& bitsToSet = 0,
                        const EventBits& bitsToWaitFor = 0,
                        const TickType_t ticksToWait = portMAX_DELAY) const {
    return EventBits(xEventGroupSync(handle, bitsToSet.to_ulong(),
                                     bitsToWaitFor.to_ulong(), ticksToWait));
  }
 
 private:
  EventGroupBase() = default;
 
  ~EventGroupBase() {
    vEventGroupDelete(this->handle);
  };
 
  EventGroupBase(EventGroupBase&&) noexcept = default;
  EventGroupBase& operator=(EventGroupBase&&) noexcept = default;
 
  EventGroupHandle_t handle = NULL;
};
 
#if (configSUPPORT_DYNAMIC_ALLOCATION == 1)
 
class EventGroup : public EventGroupBase {
 public:
  EventGroup() {
    this->handle = xEventGroupCreate();
  }
  ~EventGroup() = default;
 
  EventGroup(const EventGroup&) = delete;
  EventGroup& operator=(const EventGroup&) = delete;
 
  EventGroup(EventGroup&&) noexcept = default;
  EventGroup& operator=(EventGroup&&) noexcept = default;
};
 
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
 
#if (configSUPPORT_STATIC_ALLOCATION == 1)
 
class StaticEventGroup : public EventGroupBase {
 public:
  StaticEventGroup() {
    this->handle = xEventGroupCreateStatic(&staticEventGroup);
  }
  ~StaticEventGroup() = default;
 
  StaticEventGroup(const StaticEventGroup&) = delete;
  StaticEventGroup& operator=(const StaticEventGroup&) = delete;
 
  StaticEventGroup(StaticEventGroup&&) noexcept = default;
  StaticEventGroup& operator=(StaticEventGroup&&) noexcept = default;
 
 private:
  StaticEventGroup_t staticEventGroup;
};
 
#endif /* configSUPPORT_STATIC_ALLOCATION */
 
}  // namespace FreeRTOS
 
#endif /* configUSE_EVENT_GROUPS */
 
#endif  // FREERTOS_EVENTGROUPS_HPP