C++ in Embedded - Classes & RAII

// C++: type-safe GPIO pin abstraction with zero overhead
#include 

// Enum class: scoped, strongly-typed (not convertible to int)
enum class PinMode : uint8_t { Input = 0u, Output = 1u };
enum class PinState : uint8_t { Low = 0u, High = 1u };

class GpioPin {
public:
    // Constructor: configures pin at object creation
    GpioPin(uint8_t port, uint8_t pin, PinMode mode) noexcept
        : m_port(port), m_pin(pin)
    {
        configure(mode);
    }

    // Deleted copy constructor: pins are not copyable
    GpioPin(const GpioPin&) = delete;
    GpioPin& operator=(const GpioPin&) = delete;

    void set(PinState state) const noexcept {
        if (state == PinState::High) {
            PORT(m_port)->OMR = (1u << m_pin);          // atomic set
        } else {
            PORT(m_port)->OMR = (1u << (m_pin + 16u));  // atomic clear
        }
    }

    PinState get() const noexcept {
        return (PORT(m_port)->IN >> m_pin) & 1u ? PinState::High : PinState::Low;
    }

    void toggle() const noexcept {
        PORT(m_port)->OMR = (1u << m_pin) | (1u << (m_pin + 16u));
    }

private:
    uint8_t m_port;
    uint8_t m_pin;
    void configure(PinMode mode) noexcept;
};

// Usage: zero runtime overhead vs C version
static const GpioPin g_led{2u, 4u, PinMode::Output};
static const GpioPin g_btn{0u, 3u, PinMode::Input};
g_led.set(PinState::High);

#include "FreeRTOS.h"
#include "semphr.h"

// RAII Lock Guard: automatically releases mutex when leaving scope
class MutexGuard {
public:
    explicit MutexGuard(SemaphoreHandle_t &mutex, TickType_t timeout = portMAX_DELAY) noexcept
        : m_mutex(mutex), m_locked(false)
    {
        m_locked = (xSemaphoreTake(m_mutex, timeout) == pdTRUE);
    }

    ~MutexGuard() noexcept {
        if (m_locked) { xSemaphoreGive(m_mutex); }
    }

    bool isLocked() const noexcept { return m_locked; }

    // Non-copyable, non-movable
    MutexGuard(const MutexGuard&) = delete;
    MutexGuard& operator=(const MutexGuard&) = delete;

private:
    SemaphoreHandle_t &m_mutex;
    bool m_locked;
};

// Usage: no manual unlock needed — destructor handles it on any exit path
Std_ReturnType Spi_Transfer(const uint8_t *tx, uint8_t *rx, uint8_t len)
{
    MutexGuard lock{g_spi_mutex, pdMS_TO_TICKS(50u)};
    if (!lock.isLocked()) { return E_NOT_OK; }

    return Spi_DoTransfer(tx, rx, len);
    // ~MutexGuard() called here: mutex released automatically
    // Even if Spi_DoTransfer throws (it shouldn't — noexcept!) or returns early
}