I2cAdapter.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <span>
#include <type_traits>
 
#include "corium/EventSink.hpp"
#include "corium/policies/QueuePolicies.hpp"
 
namespace corium::embedded {
 
enum class I2cOpType : uint8_t {
    Read = 0,
    Write = 1,
    WriteRead = 2
};
 
template <size_t MaxPayload = 32>
struct I2cFrame {
    uint16_t deviceAddress{0};     
    uint8_t registerAddress{0};    
    I2cOpType opType{I2cOpType::Read}; 
    uint8_t status{0};             
    uint8_t length{0};             
    std::array<uint8_t, MaxPayload> data{}; 
 
    [[nodiscard]] std::span<const uint8_t> payload() const noexcept {
        return {data.data(), static_cast<size_t>(length > MaxPayload ? MaxPayload : length)};
    }
};
 
template <typename EventVariant>
class I2cIsrAdapter {
public:
    explicit I2cIsrAdapter(EventSinkT<EventVariant> sink) noexcept
        : m_sink(sink)
    {}
 
    template <typename TargetEvent = I2cFrame<32>, size_t MaxPayload = 32>
    void postFromIsr(const I2cFrame<MaxPayload>& frame, EventPriority priority = EventPriority::Normal) noexcept {
        if constexpr (std::is_same_v<TargetEvent, I2cFrame<MaxPayload>>) {
            m_sink.post(EventVariant{frame}, priority);
        } else {
            m_sink.post(EventVariant{TargetEvent{frame}}, priority);
        }
    }
 
    template <typename TargetEvent = I2cFrame<32>>
    void postReadFromIsr(
        uint16_t devAddr,
        uint8_t regAddr,
        std::span<const uint8_t> readBytes,
        uint8_t status = 0,
        EventPriority priority = EventPriority::Normal
    ) noexcept {
        I2cFrame<32> frame{};
        frame.deviceAddress = devAddr;
        frame.registerAddress = regAddr;
        frame.opType = I2cOpType::Read;
        frame.status = status;
        frame.length = static_cast<uint8_t>(readBytes.size() > 32 ? 32 : readBytes.size());
        std::memcpy(frame.data.data(), readBytes.data(), frame.length);
 
        if constexpr (std::is_same_v<TargetEvent, I2cFrame<32>>) {
            m_sink.post(EventVariant{frame}, priority);
        } else {
            m_sink.post(EventVariant{TargetEvent{frame}}, priority);
        }
    }
 
private:
    EventSinkT<EventVariant> m_sink;
};
 
} // namespace corium::embedded