BufferedInput.h

Go to the documentation of this file.

#ifndef BufferedInput_h
#define BufferedInput_h
#ifdef __cplusplus
 
 
#include <Print.h>
#include <Printable.h>
 
#include "SafeString.h" // for SSTRING_DEBUG and SafeString::Output and stream support
 
// handle namespace arduino
#include "SafeStringNameSpaceStart.h"
 
#define createBufferedInput(name, size) uint8_t name ## _INPUT_BUFFER[(size)]; BufferedInput name(sizeof(name ## _INPUT_BUFFER),name ## _INPUT_BUFFER);
 
 
class BufferedInput : public Stream {
  public:
    BufferedInput(size_t _bufferSize, uint8_t *_buf);
 
    void connect(Stream& _stream);
 
    void nextByteIn();
    virtual size_t write(uint8_t);
    virtual size_t write(const uint8_t *buf, size_t size);
    virtual int available();
    virtual int read();
    virtual int peek();
    virtual void flush();
    virtual int availableForWrite();
    size_t getSize(); // returns buffer size
 
    // These two are HIGH WATER MARKS, not drop counts.  BufferedInput does not count dropped chars;
    // nextByteIn() only ever moves as many bytes as currently fit, it never discards any.
    // Each value is reset to zero by the call that reads it, so each reading covers the interval
    // since the previous call.
    int maxStreamAvailable(); // the largest available() seen on the connected Stream, ie how close the
    // hardware RX buffer came to overflowing.  If this approaches the RX buffer size, call nextByteIn() more often
    int maxBufferUsed();      // the largest fill level seen in this buffer.  If this reaches the buffer
    // size then chars ARE being lost at the Stream, increase the size passed to createBufferedInput( )
 
  private:
    Stream* streamPtr;
    int maxAvail;
    int bufUsed;
    uint8_t defaultBuffer[8]; // if buffer passed in too small or NULL
 
    // ringBuffer methods
    void rb_init(uint8_t* _buf, size_t _size);
    // from Stream
    inline int rb_available() {
      return rb_buffer_count;
    }
    int rb_peek();
    int rb_read();
    size_t rb_write(uint8_t b); // does not block, drops bytes if buffer full
    size_t rb_write(const uint8_t *buffer, size_t size); // does not block, drops bytes if buffer full
    int rb_availableForWrite(); // {   return (bufSize - buffer_count); }
    size_t rb_getSize(); // size of ring buffer
    void rb_clear();
    void rb_dump(Stream* streamPtr);
    uint8_t* rb_buf;
    uint16_t rb_bufSize;
    uint16_t rb_buffer_head;
    uint16_t rb_buffer_tail;
    uint16_t rb_buffer_count;
    uint16_t rb_wrapBufferIdx(uint16_t idx);
    void rb_internalWrite(uint8_t b);
};
 
#include "SafeStringNameSpaceEnd.h"
 
#endif  // __cplusplus
#endif // BufferedInput_h