ccf.hpp

Go to the documentation of this file.

 
 
#pragma once
 
#include "circular_buffer.hpp"
#include "cbor.hpp"
#include "cobs.hpp"
#include "fnv1a.hpp"
 
#if defined(DEBUG_CCF)
#include DEBUG_CCF
#else
#include "ndebug.hpp"
#endif
 
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
 
#include <algorithm>
#include <iterator>
#include <optional>
#include <span>
 
struct CcfConfig
{
    size_t rxBufSize;
    size_t txBufSize;
    size_t maxPktSize;
};
 
enum class Channels : uint8_t
{
    Rpc = 0,
    Log = 1,
    Trace = 2,
};
 
enum class LogLevel : uint8_t
{
    Debug,
    Info,
    Warn,
    Error,
 
};
 
template<CcfConfig Config>
class Ccf
{
    using RxFrame = CircularBuffer<uint8_t, Config.rxBufSize, Config.maxPktSize>::Frame;
public:
    using TxFrame = CircularBuffer<uint8_t, Config.txBufSize, Config.maxPktSize>::Frame;

    bool receiveCharacter(uint8_t byte)
    {
        // Do get before feed, and always do feed to e.g. reset on \0
        const uint8_t value = decoder.get(byte);
        const bool do_output = decoder.feed(byte);
        // Not storing null byte because packet length is indicated in
        // a different way
        if (byte == 0)
        {
            if (!rxBuf.dropping())
            {
                rxBuf.notify();
            }
            else
            {
                rxBuf.reset_dropped();
            }
            return true;
        }
        else if (do_output)
        {
            rxBuf.push_back(value);
        }
        else
        {
            // This is expected for the header byte and continuation bytes
            // (frames >255 bytes without any null terminators)
            debugf(DEBUG "dropping %02X as !=0 and !do_output" END LOGLEVEL_ARGS, byte);
        }
        return false;
    }

    bool charactersToSend(std::optional<TxFrame> & frame)
    {
        return txBuf.get_frame(frame);
    }

    template<typename Rpc>
    bool poll(const Rpc & rpc)
    {
        bool output = false;
        std::optional<RxFrame> frame;
        while (rxBuf.get_frame(frame))
        {
            size_t len = 0;
            // Copy to a local buffer to make sure it is contiguous
            for (auto c : *frame)
            {
                pktBuf[len++] = c;
            }
            std::span span{pktBuf, len};
 
            if (len < 6)
            {
                debugf(WARN "Bad RPC! (len=%zu)" END LOGLEVEL_ARGS, len);
                std::ranges::copy("Bad RPC!\n", std::back_inserter(txBuf));
                txBuf.push_back(static_cast<uint8_t>(0));
                txBuf.notify();
                output = true;
                continue;
            }
 
            uint8_t channel = span[0];
            (void)channel;
 
            if (!Fnv1a::checkAtEnd(span))
            {
                debugf(WARN "Corrupted request (chan=%u)" END LOGLEVEL_ARGS, channel);
                std::ranges::copy("Corrupted request\n", std::back_inserter(txBuf));
                txBuf.push_back(static_cast<uint8_t>(0));
                txBuf.notify();
                output = true;
                continue;
            }
            // Remove channel + checksum
            span = span.subspan(
                sizeof(channel),
                span.size() - Fnv1a::size - sizeof(channel));
 
            uint8_t seqNo = span[0];
            uint8_t function = span[1];
            span = span.subspan(sizeof(seqNo) + sizeof(function));
            // Reuse the pktBuf buffer for return (leaving space for
            // channel, function, and checksum)
            auto header = sizeof(channel) + sizeof(seqNo) + sizeof(function);
            auto ret = std::span<uint8_t>(
                pktBuf + header, sizeof(pktBuf) - header - Fnv1a::size);
            if (!rpc.call(function, span, ret))
            {
                debugf(WARN "RPC failed (function=%u)" END LOGLEVEL_ARGS, function);
                std::ranges::copy("RPC failed\n", std::back_inserter(txBuf));
                txBuf.push_back(static_cast<uint8_t>(0));
                txBuf.notify();
                output = true;
                continue;
            }
            pktBuf[0] = channel;
            pktBuf[1] = seqNo + 1;
            pktBuf[2] = function;
            auto respLen = static_cast<size_t>(ret.data() - pktBuf);
            std::span resp{pktBuf + sizeof(channel), respLen - sizeof(channel)};
            output = output || send(Channels::Rpc, resp);
        }
        return output;
    }

    bool send(Channels channel, std::span<uint8_t> & data)
    {
        const size_t toSend = data.size() + sizeof(channel) + Fnv1a::size;
        if (toSend > sizeof(pktBuf))
        {
            debugf("Data for send too large\n");
            return false;
        }
        std::span resp{pktBuf, toSend};
        // Note: memmove caters for overlapping pktBuf/data (though no
        // need to move if it is already in place)
        if (&data[0] != &resp[1])
        {
            memmove(&resp[1], data.data(), data.size_bytes());
        }
        uint8_t chan = static_cast<uint8_t>(channel);
        resp[0] = chan;
        Fnv1a::putAtEnd(resp);
        for (auto c : Cobs::Encoder(resp))
        {
            txBuf.push_back(c);
        }
        txBuf.push_back(static_cast<uint8_t>(0));
        if (txBuf.dropping())
        {
            txBuf.reset_dropped();
            return false;
        }
        else
        {
            txBuf.notify();
            return true;
        }
    }

#if defined(DEFERRED_FORMATTING)
    template <typename... Args>
    std::optional<size_t> logToBuffer(
        std::span<uint8_t> & span,
        LogLevel level,
        uint8_t module,
        std::string_view fmt,
        Args && ... args)
#else
    std::optional<size_t> logToBuffer(
        std::span<uint8_t> & span,
        LogLevel level,
        uint8_t module,
        const char * fmt,
        ...)
    {
        va_list args;
        va_start(args, fmt);
        const auto ret = vLogToBuffer(span, level, module, fmt, args);
        va_end(args);
        return ret;
    }

    std::optional<size_t> vLogToBuffer(
        std::span<uint8_t> & span,
        LogLevel level,
        uint8_t module,
        const char * fmt,
        va_list args)
#endif
    {
        if (module > (1 << 5) - 1)
        {
            return {};
        }
        uint8_t initialByte = (static_cast<uint8_t>(level) << 5) | module;
        span[0] = initialByte;
        // Space for length
        const auto start = span.begin() + 2;
#if defined(DEFERRED_FORMATTING)
        const auto written = std::distance(start, std::ranges::copy(fmt, start).out);
        auto rest = span.subspan(2 + written);
        bool ok = (Cbor::Cbor<Args>::encode(std::forward<Args>(args), rest) && ...);
        const auto end = rest.begin();
#else
        int written = vsnprintf(
            reinterpret_cast<char *>(&*start),
            std::distance(start, span.end()),
            fmt,
            args
        );
        bool ok = 0 < written && static_cast<size_t>(written) < span.size();
        const auto end = start + written;
#endif
        span[1] = written;
        if (!ok)
        {
            return {};
        }
        size_t total = std::distance(span.begin(), end);
        span = span.subspan(total);
        return {total};
    }

#if defined(DEFERRED_FORMATTING)
    template <typename... Args>
    std::optional<size_t> log(
        LogLevel level,
        uint8_t module,
        std::string_view fmt,
        Args && ... args)
#else
    std::optional<size_t> log(
        LogLevel level,
        uint8_t module,
        const char * fmt,
        ...)
#endif
    {
        std::span<uint8_t> span{pktBuf};
#if defined(DEFERRED_FORMATTING)
        const auto formatted = logToBuffer(span, level, module, fmt, std::forward<Args>(args)...);
#else
        va_list args;
        va_start(args, fmt);
        const auto formatted = vLogToBuffer(span, level, module, fmt, args);
        va_end(args);
#endif
        if (formatted)
        {
            std::span<uint8_t> toSend{pktBuf, *formatted};
            if (send(Channels::Log, toSend))
            {
                return formatted;
            }
        }
        return {};
    }
 
 
private:
    CircularBuffer<uint8_t, Config.txBufSize, Config.maxPktSize> txBuf;
    CircularBuffer<uint8_t, Config.rxBufSize, Config.maxPktSize> rxBuf;
    Cobs::Decoder decoder{};
    uint8_t pktBuf[Config.maxPktSize];
};
 
// This is a header, undefine the debugf macro
#include "debug_end.hpp"