BinaryStream Class Reference

#include <binary_protocol.h>

Collaboration diagram for BinaryStream:

Classes
struct	Packet

Public Types
enum	Protocol : uint8_t { Protocol::CONTROL, Protocol::FILE_TRANSFER }
enum	ProtocolControl : uint8_t { ProtocolControl::SYNC = 1, ProtocolControl::CLOSE }
enum	StreamState : uint8_t {   StreamState::PACKET_RESET, StreamState::PACKET_WAIT, StreamState::PACKET_HEADER, StreamState::PACKET_DATA,   StreamState::PACKET_FOOTER, StreamState::PACKET_PROCESS, StreamState::PACKET_RESEND, StreamState::PACKET_TIMEOUT,   StreamState::PACKET_ERROR }

Public Member Functions
void	reset ()
uint32_t	checksum (uint32_t cs, uint8_t value)
bool	stream_read (uint8_t &data)
template<const size_t buffer_size>
void	receive (char(&buffer)[buffer_size])
void	dispatch ()
void	idle ()

Public Attributes
struct BinaryStream::Packet	packet
uint8_t	packet_retries
uint8_t	sync
uint16_t	buffer_next_index
uint32_t	bytes_received
StreamState	stream_state = StreamState::PACKET_RESET

Static Public Attributes
static const uint16_t	PACKET_MAX_WAIT = 500
static const uint16_t	RX_TIMESLICE = 20
static const uint16_t	MAX_RETRIES = 0
static const uint16_t	VERSION_MAJOR = 0
static const uint16_t	VERSION_MINOR = 1
static const uint16_t	VERSION_PATCH = 0

Member Enumeration Documentation

Protocol

enum BinaryStream::Protocol : uint8_t

strong

Enumerator
CONTROL
FILE_TRANSFER

: uint8_t { CONTROL, FILE_TRANSFER };

ProtocolControl

enum BinaryStream::ProtocolControl : uint8_t

strong

Enumerator
SYNC
CLOSE

: uint8_t { SYNC = 1, CLOSE };

StreamState

enum BinaryStream::StreamState : uint8_t

strong

Enumerator
PACKET_RESET
PACKET_WAIT
PACKET_HEADER
PACKET_DATA
PACKET_FOOTER
PACKET_PROCESS
PACKET_RESEND
PACKET_TIMEOUT
PACKET_ERROR

                         : uint8_t { PACKET_RESET, PACKET_WAIT, PACKET_HEADER, PACKET_DATA, PACKET_FOOTER,
                                     PACKET_PROCESS, PACKET_RESEND, PACKET_TIMEOUT, PACKET_ERROR };

Member Function Documentation

reset()

void BinaryStream::reset

(

)

               {
    sync = 0;
    packet_retries = 0;
    buffer_next_index = 0;
  }

Here is the caller graph for this function:

checksum()

uint32_t BinaryStream::checksum	(	uint32_t	cs,
		uint8_t	value
	)

                                                {
    uint16_t cs_low = (((cs & 0xFF) + value) % 255);
    return ((((cs >> 8) + cs_low) % 255) << 8)  | cs_low;
  }

Here is the caller graph for this function:

stream_read()

bool BinaryStream::stream_read

(

uint8_t &

data

)

                                  {
    if (stream_state != StreamState::PACKET_WAIT && ELAPSED(millis(), packet.timeout)) {
      stream_state = StreamState::PACKET_TIMEOUT;
      return false;
    }
    if (!bs_serial_data_available(card.transfer_port_index)) return false;
    data = bs_read_serial(card.transfer_port_index);
    packet.timeout = millis() + PACKET_MAX_WAIT;
    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

receive()

template<const size_t buffer_size>

void BinaryStream::receive

(

char(&)

buffer[buffer_size]

)

Data stream packet handling

                                            {
    uint8_t data = 0;
    millis_t transfer_window = millis() + RX_TIMESLICE;
 
    #if ENABLED(SDSUPPORT)
      PORT_REDIRECT(card.transfer_port_index);
    #endif
 
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Warray-bounds"
 
    while (PENDING(millis(), transfer_window)) {
      switch (stream_state) {
         /**
          * Data stream packet handling
          */
        case StreamState::PACKET_RESET:
          packet.reset();
          stream_state = StreamState::PACKET_WAIT;
        case StreamState::PACKET_WAIT:
          if (!stream_read(data)) { idle(); return; }  // no active packet so don't wait
          packet.header.data[1] = data;
          if (packet.header.token == packet.header.HEADER_TOKEN) {
            packet.bytes_received = 2;
            stream_state = StreamState::PACKET_HEADER;
          }
          else {
            // stream corruption drop data
            packet.header.data[0] = data;
          }
          break;
        case StreamState::PACKET_HEADER:
          if (!stream_read(data)) break;
 
          packet.header.data[packet.bytes_received++] = data;
          packet.checksum = checksum(packet.checksum, data);
 
          // header checksum calculation can't contain the checksum
          if (packet.bytes_received == sizeof(Packet::header) - 2)
            packet.header_checksum = packet.checksum;
 
          if (packet.bytes_received == sizeof(Packet::header)) {
            if (packet.header.checksum == packet.header_checksum) {
              // The SYNC control packet is a special case in that it doesn't require the stream sync to be correct
              if (static_cast<Protocol>(packet.header.protocol()) == Protocol::CONTROL && static_cast<ProtocolControl>(packet.header.type()) == ProtocolControl::SYNC) {
                  SERIAL_ECHOLNPAIR("ss", sync, ",", buffer_size, ",", VERSION_MAJOR, ".", VERSION_MINOR, ".", VERSION_PATCH);
                  stream_state = StreamState::PACKET_RESET;
                  break;
              }
              if (packet.header.sync == sync) {
                buffer_next_index = 0;
                packet.bytes_received = 0;
                if (packet.header.size) {
                  stream_state = StreamState::PACKET_DATA;
                  packet.buffer = static_cast<char *>(&buffer[0]); // multipacket buffering not implemented, always allocate whole buffer to packet
                }
                else
                  stream_state = StreamState::PACKET_PROCESS;
              }
              else if (packet.header.sync == sync - 1) {           // ok response must have been lost
                SERIAL_ECHOLNPAIR("ok", packet.header.sync);  // transmit valid packet received and drop the payload
                stream_state = StreamState::PACKET_RESET;
              }
              else if (packet_retries) {
                stream_state = StreamState::PACKET_RESET; // could be packets already buffered on flow controlled connections, drop them without ack
              }
              else {
                SERIAL_ECHO_MSG("Datastream packet out of order");
                stream_state = StreamState::PACKET_RESEND;
              }
            }
            else {
              SERIAL_ECHO_START();
              SERIAL_ECHOLNPAIR("Packet header(", packet.header.sync, "?) corrupt");
              stream_state = StreamState::PACKET_RESEND;
            }
          }
          break;
        case StreamState::PACKET_DATA:
          if (!stream_read(data)) break;
 
          if (buffer_next_index < buffer_size)
            packet.buffer[buffer_next_index] = data;
          else {
            SERIAL_ECHO_MSG("Datastream packet data buffer overrun");
            stream_state = StreamState::PACKET_ERROR;
            break;
          }
 
          packet.checksum = checksum(packet.checksum, data);
          packet.bytes_received++;
          buffer_next_index++;
 
          if (packet.bytes_received == packet.header.size) {
            stream_state = StreamState::PACKET_FOOTER;
            packet.bytes_received = 0;
          }
          break;
        case StreamState::PACKET_FOOTER:
          if (!stream_read(data)) break;
 
          packet.footer.data[packet.bytes_received++] = data;
          if (packet.bytes_received == sizeof(Packet::footer)) {
            if (packet.footer.checksum == packet.checksum) {
              stream_state = StreamState::PACKET_PROCESS;
            }
            else {
              SERIAL_ECHO_START();
              SERIAL_ECHOLNPAIR("Packet(", packet.header.sync, ") payload corrupt");
              stream_state = StreamState::PACKET_RESEND;
            }
          }
          break;
        case StreamState::PACKET_PROCESS:
          sync++;
          packet_retries = 0;
          bytes_received += packet.header.size;
 
          SERIAL_ECHOLNPAIR("ok", packet.header.sync); // transmit valid packet received
          dispatch();
          stream_state = StreamState::PACKET_RESET;
          break;
        case StreamState::PACKET_RESEND:
          if (packet_retries < MAX_RETRIES || MAX_RETRIES == 0) {
            packet_retries++;
            stream_state = StreamState::PACKET_RESET;
            SERIAL_ECHO_START();
            SERIAL_ECHOLNPAIR("Resend request ", int(packet_retries));
            SERIAL_ECHOLNPAIR("rs", sync);
          }
          else
            stream_state = StreamState::PACKET_ERROR;
          break;
        case StreamState::PACKET_TIMEOUT:
          SERIAL_ECHO_MSG("Datastream timeout");
          stream_state = StreamState::PACKET_RESEND;
          break;
        case StreamState::PACKET_ERROR:
          SERIAL_ECHOLNPAIR("fe", packet.header.sync);
          reset(); // reset everything, resync required
          stream_state = StreamState::PACKET_RESET;
          break;
      }
    }
 
    #pragma GCC diagnostic pop
  }

Here is the call graph for this function:

dispatch()

void BinaryStream::dispatch

(

)

                  {
    switch(static_cast<Protocol>(packet.header.protocol())) {
      case Protocol::CONTROL:
        switch(static_cast<ProtocolControl>(packet.header.type())) {
          case ProtocolControl::CLOSE: // revert back to ASCII mode
            card.flag.binary_mode = false;
            break;
          default:
            SERIAL_ECHO_MSG("Unknown BinaryProtocolControl Packet");
        }
        break;
      case Protocol::FILE_TRANSFER:
        SDFileTransferProtocol::process(packet.header.type(), packet.buffer, packet.header.size); // send user data to be processed
      break;
      default:
        SERIAL_ECHO_MSG("Unsupported Binary Protocol");
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

idle()

void BinaryStream::idle

(

)

              {
    // Some Protocols may need periodic updates without new data
    SDFileTransferProtocol::idle();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

packet

struct BinaryStream::Packet BinaryStream::packet

PACKET_MAX_WAIT

const uint16_t BinaryStream::PACKET_MAX_WAIT = 500

static

RX_TIMESLICE

const uint16_t BinaryStream::RX_TIMESLICE = 20

static

MAX_RETRIES

const uint16_t BinaryStream::MAX_RETRIES = 0

static

VERSION_MAJOR

const uint16_t BinaryStream::VERSION_MAJOR = 0

static

VERSION_MINOR

const uint16_t BinaryStream::VERSION_MINOR = 1

static

VERSION_PATCH

const uint16_t BinaryStream::VERSION_PATCH = 0

static

packet_retries

uint8_t BinaryStream::packet_retries

sync

uint8_t BinaryStream::sync

buffer_next_index

uint16_t BinaryStream::buffer_next_index

bytes_received

uint32_t BinaryStream::bytes_received

stream_state

StreamState BinaryStream::stream_state = StreamState::PACKET_RESET