SDFileTransferProtocol Class Reference

#include <binary_protocol.h>

Collaboration diagram for SDFileTransferProtocol:

Static Public Member Functions
static void	idle ()
static void	process (uint8_t packet_type, char *buffer, const uint16_t length)

Static Public Attributes
static const uint16_t	VERSION_MAJOR = 0
static const uint16_t	VERSION_MINOR = 1
static const uint16_t	VERSION_PATCH = 0
static const uint16_t	TIMEOUT = 10000
static const uint16_t	IDLE_PERIOD = 1000

Member Function Documentation

idle()

static void SDFileTransferProtocol::idle ( )

static

                     {
    // If a transfer is interrupted and a file is left open, abort it after TIMEOUT ms
    const millis_t ms = millis();
    if (transfer_active && ELAPSED(ms, idle_timeout)) {
      idle_timeout = ms + IDLE_PERIOD;
      if (ELAPSED(ms, transfer_timeout)) transfer_abort();
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

process()

static void SDFileTransferProtocol::process ( uint8_t  packet_type, char *  buffer, const uint16_t  length  )

static

                                                                                {
    transfer_timeout = millis() + TIMEOUT;
    switch (static_cast<FileTransfer>(packet_type)) {
      case FileTransfer::QUERY:
        SERIAL_ECHOPAIR("PFT:version:", VERSION_MAJOR, ".", VERSION_MINOR, ".", VERSION_PATCH);
        #if ENABLED(BINARY_STREAM_COMPRESSION)
          SERIAL_ECHOLNPAIR(":compresion:heatshrink,", HEATSHRINK_STATIC_WINDOW_BITS, ",", HEATSHRINK_STATIC_LOOKAHEAD_BITS);
        #else
          SERIAL_ECHOLNPGM(":compresion:none");
        #endif
        break;
      case FileTransfer::OPEN:
        if (transfer_active)
          SERIAL_ECHOLNPGM("PFT:busy");
        else {
          if (Packet::Open::validate(buffer, length)) {
            auto packet = Packet::Open::decode(buffer);
            compression = packet.compression_enabled();
            dummy_transfer = packet.dummy_transfer();
            if (file_open(packet.filename())) {
              SERIAL_ECHOLNPGM("PFT:success");
              break;
            }
          }
          SERIAL_ECHOLNPGM("PFT:fail");
        }
        break;
      case FileTransfer::CLOSE:
        if (transfer_active) {
          if (file_close())
            SERIAL_ECHOLNPGM("PFT:success");
          else
            SERIAL_ECHOLNPGM("PFT:ioerror");
        }
        else SERIAL_ECHOLNPGM("PFT:invalid");
        break;
      case FileTransfer::WRITE:
        if (!transfer_active)
          SERIAL_ECHOLNPGM("PFT:invalid");
        else if (!file_write(buffer, length))
          SERIAL_ECHOLNPGM("PFT:ioerror");
        break;
      case FileTransfer::ABORT:
        transfer_abort();
        SERIAL_ECHOLNPGM("PFT:success");
        break;
      default:
        SERIAL_ECHOLNPGM("PTF:invalid");
        break;
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

VERSION_MAJOR

const uint16_t SDFileTransferProtocol::VERSION_MAJOR = 0

static

VERSION_MINOR

const uint16_t SDFileTransferProtocol::VERSION_MINOR = 1

static

VERSION_PATCH

const uint16_t SDFileTransferProtocol::VERSION_PATCH = 0

static

TIMEOUT

const uint16_t SDFileTransferProtocol::TIMEOUT = 10000

static

IDLE_PERIOD

const uint16_t SDFileTransferProtocol::IDLE_PERIOD = 1000

static