feat: add lab-rv32i-freertos-event-group card

2026-07-21 19:13:55 +02:00
commit b72408da7f
67 changed files with 37880 additions and 0 deletions
@@ -0,0 +1,151 @@
+#ifndef FREERTOS_CPP_EVENT_GROUP_HPP
+#define FREERTOS_CPP_EVENT_GROUP_HPP
+
+#include <stdint.h>
+#include <type_traits>
+
+extern "C"
+{
+#include "FreeRTOS.h"
+#include "event_groups.h"
+}
+
+namespace freertos
+{
+
+enum class WaitMode : uint8_t
+{
+    any,
+    all
+};
+
+enum class ClearMode : uint8_t
+{
+    keep,
+    clear_on_exit
+};
+
+template< typename Bit >
+class EventMask final
+{
+    static_assert( std::is_enum< Bit >::value,
+                   "EventMask requires an enum bit type" );
+
+public:
+    constexpr EventMask() noexcept = default;
+    explicit constexpr EventMask( Bit bit ) noexcept
+        : value_ { static_cast< EventBits_t >( bit ) }
+    {
+    }
+
+    [[nodiscard]] static constexpr EventMask from_raw(
+        EventBits_t value ) noexcept
+    {
+        return EventMask { value, RawTag {} };
+    }
+
+    [[nodiscard]] constexpr EventBits_t raw() const noexcept { return value_; }
+    [[nodiscard]] constexpr bool contains( EventMask other ) const noexcept
+    {
+        return ( value_ & other.value_ ) == other.value_;
+    }
+
+    friend constexpr EventMask operator|( EventMask left,
+                                          EventMask right ) noexcept
+    {
+        return from_raw( left.value_ | right.value_ );
+    }
+
+private:
+    struct RawTag {};
+    constexpr EventMask( EventBits_t value, RawTag ) noexcept : value_ { value } {}
+    EventBits_t value_ {};
+};
+
+template< typename Bit >
+struct WaitResult final
+{
+    EventMask< Bit > observed {};
+
+    [[nodiscard]] constexpr bool satisfied( EventMask< Bit > wanted,
+                                            WaitMode mode ) const noexcept
+    {
+        const EventBits_t matched = observed.raw() & wanted.raw();
+        return mode == WaitMode::all ? matched == wanted.raw() : matched != 0U;
+    }
+};
+
+struct StaticEventGroupStorage final
+{
+    StaticEventGroup_t control {};
+};
+
+template< typename Bit >
+class EventGroup final
+{
+    static_assert( std::is_enum< Bit >::value,
+                   "EventGroup requires an enum bit type" );
+
+public:
+    explicit EventGroup( StaticEventGroupStorage & storage ) noexcept
+        : handle_ { xEventGroupCreateStatic( &storage.control ) }
+    {
+    }
+
+    ~EventGroup() noexcept
+    {
+        if( handle_ != nullptr ) vEventGroupDelete( handle_ );
+    }
+
+    EventGroup( const EventGroup & ) = delete;
+    EventGroup & operator=( const EventGroup & ) = delete;
+    EventGroup( EventGroup && ) = delete;
+    EventGroup & operator=( EventGroup && ) = delete;
+
+    [[nodiscard]] bool valid() const noexcept { return handle_ != nullptr; }
+
+    [[nodiscard]] EventMask< Bit > set( EventMask< Bit > bits ) noexcept
+    {
+        return EventMask< Bit >::from_raw(
+            xEventGroupSetBits( handle_, bits.raw() ) );
+    }
+
+    [[nodiscard]] EventMask< Bit > clear( EventMask< Bit > bits ) noexcept
+    {
+        return EventMask< Bit >::from_raw(
+            xEventGroupClearBits( handle_, bits.raw() ) );
+    }
+
+    [[nodiscard]] EventMask< Bit > bits() const noexcept
+    {
+        return EventMask< Bit >::from_raw( xEventGroupGetBits( handle_ ) );
+    }
+
+    [[nodiscard]] WaitResult< Bit > wait( EventMask< Bit > wanted,
+                                          WaitMode mode,
+                                          ClearMode clear,
+                                          TickType_t timeout ) noexcept
+    {
+        const EventBits_t result = xEventGroupWaitBits(
+            handle_, wanted.raw(),
+            clear == ClearMode::clear_on_exit ? pdTRUE : pdFALSE,
+            mode == WaitMode::all ? pdTRUE : pdFALSE,
+            timeout );
+        return { EventMask< Bit >::from_raw( result ) };
+    }
+
+    [[nodiscard]] EventGroupHandle_t native_handle() const noexcept
+    {
+        return handle_;
+    }
+
+private:
+    EventGroupHandle_t handle_ {};
+};
+
+static_assert( !std::is_copy_constructible<
+               EventGroup< WaitMode > >::value );
+
+} // namespace freertos
+
+#endif