BufferedOutput.h

Go to the documentation of this file.

#ifndef BufferedOutput_h
#define BufferedOutput_h
#ifdef __cplusplus
 
 
#include <Print.h>
#include <Printable.h>
#include "SafeString.h"  // for Output and #define SSTRING_DEBUG and stream support
 
// handle namespace arduino
#include "SafeStringNameSpaceStart.h"
 
#define createBufferedOutput(name, size, ...) uint8_t name ## _OUTPUT_BUFFER[(size)+4]; BufferedOutput name(sizeof(name ## _OUTPUT_BUFFER),name ## _OUTPUT_BUFFER,  __VA_ARGS__ ); // add 4 for dropMark
 
typedef enum {BLOCK_IF_FULL, DROP_UNTIL_EMPTY, DROP_IF_FULL } BufferedOutputMode;
 
class BufferedOutput : public Stream {
  public:
 
    BufferedOutput(size_t _bufferSize, uint8_t *_buf, BufferedOutputMode mode, bool allOrNothing = true);
 
    void connect(HardwareSerial& _serial); 
    
    
    void connect(Stream& _stream, const uint32_t baudRate=0);
    
    void nextByteOut();
    
    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();
 
    int clearSpace(size_t len); 
    
    void protect(); 
    void clear(); // clears outgoing (write) buffer, even if protected.
    
    
    size_t terminateLastLine(); // adds a newline if one not already there
 
  private:
    int internalAvailableForWrite();
    int internalStreamAvailableForWrite(); // returns 0 if no availableForWrite else connection.availableForWrite()-1 to allow for ESP blocking on 1
    void writeDropMark();
    size_t bytesToBeSent(); // bytes in this buffer to be sent, // this ignores any data in the HardwareSerial buffer
    BufferedOutputMode mode; // = 0;
    bool allOrNothing; // = true current setting reset to allOrNothingSetting after each write(buf,size)
    bool allOrNothingSetting; // = true as passed in to constructor
    uint8_t defaultBuffer[8]; // if buffer passed in too small or NULL
    unsigned long us_perByte; // == 1000000 / (baudRate/10) == 10000000 / baudRate
    Stream* streamPtr;
    HardwareSerial* serialPtr; // non-null if HardwareSerial and availableForWrite returns non zero
    uint32_t baudRate;
    unsigned long sendTimerStart;
    bool waitForEmpty;
    Print* debugOut; // only used if #define DEBUG uncomment in BufferedOutput.cpp
    int txBufferSize; // serial tx buffer, if any OR set to zero to only use ringBuffer
    bool dropMarkWritten;
    uint8_t lastCharWritten; // check for \n
    volatile bool inNextByteOut; // per-instance lock to prevent recursive calls to nextByteOut()
 
    // ringBuffer methods
    void rb_init(uint8_t* _buf, size_t _size);
    void rb_clear();
    bool rb_clearSpace(size_t len); //returns true if some output dropped, clears space in outgoing (write) buffer, by removing last bytes written
    // 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
    bool rb_lastBufferedByteProtect();
    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 // BufferedOutput_h