RingBuf.h

Go to the documentation of this file.

#ifndef RingBuf_h
#define RingBuf_h
#include "Arduino.h"
#include "common/FmtNumber.h"
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
//  Teensy 3.5/3.6 has hard fault at 0x20000000 for unaligned memcpy.
#if defined(__MK64FX512__) || defined(__MK66FX1M0__)
inline bool is_aligned(const void *ptr, uintptr_t alignment)
{
    auto iptr = reinterpret_cast<uintptr_t>(ptr);
    return !(iptr % alignment);
}
inline void memcpyBuf(void *dst, const void *src, size_t len)
{
    const uint8_t *b = reinterpret_cast<const uint8_t *>(0X20000000UL);
    uint8_t *d = reinterpret_cast<uint8_t *>(dst);
    const uint8_t *s = reinterpret_cast<const uint8_t *>(src);
    if ((is_aligned(d, 4) && is_aligned(s, 4) && (len & 3) == 0) ||
        !((d < b && b <= (d + len)) || (s < b && b <= (s + len))))
    {
        memcpy(dst, src, len);
    }
    else
    {
        while (len--)
        {
            *d++ = *s++;
        }
    }
}
#else  // defined(__MK64FX512__) || defined(__MK66FX1M0__)
inline void memcpyBuf(void *dst, const void *src, size_t len)
{
    memcpy(dst, src, len);
}
#endif // defined(__MK64FX512__) || defined(__MK66FX1M0__)
#endif // DOXYGEN_SHOULD_SKIP_THIS
template <class F, size_t Size> class RingBuf : public Print
{
  public:
    RingBuf()
    {
    }

    void begin(F *file)
    {
        m_file = file;
        m_count = 0;
        m_head = 0;
        m_tail = 0;
        clearWriteError();
    }

    size_t bytesFree() const
    {
        size_t count;
        noInterrupts();
        count = m_count;
        interrupts();
        return Size - count;
    }

    size_t bytesFreeIsr() const
    {
        return Size - m_count;
    }

    size_t bytesUsed() const
    {
        size_t count;
        noInterrupts();
        count = m_count;
        interrupts();
        return count;
    }

    size_t bytesUsedIsr() const
    {
        return m_count;
    }

    size_t memcpyIn(const void *buf, size_t count)
    {
        const uint8_t *src = (const uint8_t *)buf;
        size_t n = Size - m_count;
        if (count > n)
        {
            count = n;
        }
        size_t nread = 0;
        while (nread != count)
        {
            n = minSize(Size - m_head, count - nread);
            memcpyBuf(m_buf + m_head, src + nread, n);
            m_head = advance(m_head, n);
            nread += n;
        }
        m_count += nread;
        return nread;
    }

    size_t memcpyOut(void *buf, size_t count)
    {
        uint8_t *dst = reinterpret_cast<uint8_t *>(buf);
        size_t nwrite = 0;
        size_t n = m_count;
        if (count > n)
        {
            count = n;
        }
        while (nwrite != count)
        {
            n = minSize(Size - m_tail, count - nwrite);
            memcpyBuf(dst + nwrite, m_buf + m_tail, n);
            m_tail = advance(m_tail, n);
            nwrite += n;
        }
        m_count -= nwrite;
        return nwrite;
    }

    size_t printField(double value, char term, uint8_t prec = 2)
    {
        char buf[24];
        char *str = buf + sizeof(buf);
        if (term)
        {
            *--str = term;
            if (term == '\n')
            {
                *--str = '\r';
            }
        }
        str = fmtDouble(str, value, prec, false);
        return write(str, buf + sizeof(buf) - str);
    }

    size_t printField(float value, char term, uint8_t prec = 2)
    {
        return printField(static_cast<double>(value), term, prec);
    }

    template <typename Type> size_t printField(Type value, char term)
    {
        char sign = 0;
        char buf[3 * sizeof(Type) + 3];
        char *str = buf + sizeof(buf);
 
        if (term)
        {
            *--str = term;
            if (term == '\n')
            {
                *--str = '\r';
            }
        }
        if (value < 0)
        {
            value = -value;
            sign = '-';
        }
        if (sizeof(Type) < 4)
        {
            str = fmtBase10(str, (uint16_t)value);
        }
        else
        {
            str = fmtBase10(str, (uint32_t)value);
        }
        if (sign)
        {
            *--str = sign;
        }
        return write((const uint8_t *)str, &buf[sizeof(buf)] - str);
    }

    size_t readIn(size_t count)
    {
        size_t nread = 0;
        size_t n = bytesFree(); // Protected from interrupts.
        if (count > n)
        {
            count = n;
        }
        while (nread != count)
        {
            n = minSize(Size - m_head, count - nread);
            if ((size_t)m_file->read(m_buf + m_head, n) != n)
            {
                return nread;
            }
            m_head = advance(m_head, n);
            nread += n;
        }
        noInterrupts();
        m_count += nread;
        interrupts();
        return nread;
    }

    bool sync()
    {
        size_t n = bytesUsed();
        return writeOut(n) == n;
    }

    size_t write(const void *buf, size_t count)
    {
        if (count > bytesFree())
        {
            setWriteError();
        }
        return memcpyIn(buf, count);
    }

    size_t write(const uint8_t *buf, size_t count) override
    {
        return write((const void *)buf, count);
    }

    size_t write(uint8_t data) override
    {
        return write(&data, 1);
    }

    size_t writeOut(size_t count)
    {
        size_t n = bytesUsed(); // Protected from interrupts;
        if (count > n)
        {
            count = n;
        }
        size_t nwrite = 0;
        while (nwrite != count)
        {
            n = minSize(Size - m_tail, count - nwrite);
            if (m_file->write(m_buf + m_tail, n) != n)
            {
                break;
            }
            m_tail = advance(m_tail, n);
            nwrite += n;
        }
        noInterrupts();
        m_count -= nwrite;
        interrupts();
        return nwrite;
    }
 
  private:
    uint8_t __attribute__((aligned(4))) m_buf[Size];
    F *m_file = nullptr;
    volatile size_t m_count;
    size_t m_head;
    size_t m_tail;
 
    size_t advance(size_t index, size_t n)
    {
        index += n;
        return index < Size ? index : index - Size;
    }
    // avoid macro MIN
    size_t minSize(size_t a, size_t b)
    {
        return a < b ? a : b;
    }
};
#endif // RingBuf_h