DmaUartAdapter.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <span>
 
#include "corium/EventSink.hpp"
#include "corium/policies/QueuePolicies.hpp"
 
namespace corium::embedded {
 
template <std::size_t BufferSize = 512>
class DmaUartRxBuffer {
    static_assert((BufferSize & (BufferSize - 1)) == 0, "BufferSize must be a power of two.");
 
public:
    constexpr DmaUartRxBuffer() = default;
 
    [[nodiscard]] uint8_t* dmaBuffer() noexcept {
        return _buffer.data();
    }
 
    [[nodiscard]] const uint8_t* dmaBuffer() const noexcept {
        return _buffer.data();
    }
 
    [[nodiscard]] static constexpr std::size_t capacity() noexcept {
        return BufferSize;
    }
 
    template <typename Callback>
    void processAvailableBytes(std::size_t currentDmaWriteIndex, Callback&& onPacket) {
        currentDmaWriteIndex = currentDmaWriteIndex & (BufferSize - 1);
 
        if (currentDmaWriteIndex == _tail) {
            return; // No new bytes received
        }
 
        if (currentDmaWriteIndex > _tail) {
            // Contiguous slice
            std::size_t len = currentDmaWriteIndex - _tail;
            onPacket(std::span<const uint8_t>(_buffer.data() + _tail, len));
            _tail = currentDmaWriteIndex;
        } else {
            // Wrapped around circular buffer
            std::size_t firstPart = BufferSize - _tail;
            if (firstPart > 0) {
                onPacket(std::span<const uint8_t>(_buffer.data() + _tail, firstPart));
            }
            if (currentDmaWriteIndex > 0) {
                onPacket(std::span<const uint8_t>(_buffer.data(), currentDmaWriteIndex));
            }
            _tail = currentDmaWriteIndex;
        }
    }
 
    void reset() noexcept {
        _tail = 0;
    }
 
    [[nodiscard]] std::size_t tail() const noexcept {
        return _tail;
    }
 
private:
    alignas(4) std::array<uint8_t, BufferSize> _buffer{};
    std::size_t _tail{0};
};
 
template <typename EventVariant, std::size_t BufferSize = 512>
class DmaUartAdapter {
public:
    explicit DmaUartAdapter(EventSinkT<EventVariant> sink) noexcept
        : _sink(sink)
    {}
 
    [[nodiscard]] DmaUartRxBuffer<BufferSize>& rxBuffer() noexcept {
        return _rxBuffer;
    }
 
    [[nodiscard]] const DmaUartRxBuffer<BufferSize>& rxBuffer() const noexcept {
        return _rxBuffer;
    }
 
    template <typename TargetEvent>
    void processFromIsr(std::size_t currentDmaWriteIndex, EventPriority priority = EventPriority::Normal) {
        _rxBuffer.processAvailableBytes(currentDmaWriteIndex, [this, priority](std::span<const uint8_t> data) {
            _sink.post(EventVariant{TargetEvent{data}}, priority);
        });
    }
 
private:
    EventSinkT<EventVariant> _sink;
    DmaUartRxBuffer<BufferSize> _rxBuffer{};
};
 
} // namespace corium::embedded