|
|
|
|
@ -258,14 +258,15 @@ void gcode_line_error(PGM_P err, uint8_t port) {
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static bool serial_data_available() {
|
|
|
|
|
return (MYSERIAL0.available() ? true :
|
|
|
|
|
return false
|
|
|
|
|
|| MYSERIAL0.available()
|
|
|
|
|
#if NUM_SERIAL > 1
|
|
|
|
|
MYSERIAL1.available() ? true :
|
|
|
|
|
|| MYSERIAL1.available()
|
|
|
|
|
#endif
|
|
|
|
|
false);
|
|
|
|
|
;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int read_serial(const int index) {
|
|
|
|
|
static int read_serial(const uint8_t index) {
|
|
|
|
|
switch (index) {
|
|
|
|
|
case 0: return MYSERIAL0.read();
|
|
|
|
|
#if NUM_SERIAL > 1
|
|
|
|
|
@ -275,6 +276,263 @@ static int read_serial(const int index) {
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if ENABLED(FAST_FILE_TRANSFER)
|
|
|
|
|
|
|
|
|
|
#if ENABLED(SDSUPPORT)
|
|
|
|
|
#define CARD_CHAR_P(C) SERIAL_CHAR_P(card.transfer_port, C)
|
|
|
|
|
#define CARD_ECHO_P(V) SERIAL_ECHO_P(card.transfer_port, V)
|
|
|
|
|
#define CARD_ECHOLN_P(V) SERIAL_ECHOLN_P(card.transfer_port, V)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
static bool serial_data_available(const uint8_t index) {
|
|
|
|
|
switch (index) {
|
|
|
|
|
case 0: return MYSERIAL0.available();
|
|
|
|
|
#if NUM_SERIAL > 1
|
|
|
|
|
case 1: return MYSERIAL1.available();
|
|
|
|
|
#endif
|
|
|
|
|
default: return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
class BinaryStream {
|
|
|
|
|
public:
|
|
|
|
|
enum class StreamState : uint8_t {
|
|
|
|
|
STREAM_RESET,
|
|
|
|
|
PACKET_RESET,
|
|
|
|
|
STREAM_HEADER,
|
|
|
|
|
PACKET_HEADER,
|
|
|
|
|
PACKET_DATA,
|
|
|
|
|
PACKET_VALIDATE,
|
|
|
|
|
PACKET_RESEND,
|
|
|
|
|
PACKET_FLUSHRX,
|
|
|
|
|
PACKET_TIMEOUT,
|
|
|
|
|
STREAM_COMPLETE,
|
|
|
|
|
STREAM_FAILED,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#pragma pack(push, 1)
|
|
|
|
|
|
|
|
|
|
struct StreamHeader {
|
|
|
|
|
uint16_t token;
|
|
|
|
|
uint32_t filesize;
|
|
|
|
|
};
|
|
|
|
|
union {
|
|
|
|
|
uint8_t stream_header_bytes[sizeof(StreamHeader)];
|
|
|
|
|
StreamHeader stream_header;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct Packet {
|
|
|
|
|
struct Header {
|
|
|
|
|
uint32_t id;
|
|
|
|
|
uint16_t size, checksum;
|
|
|
|
|
};
|
|
|
|
|
union {
|
|
|
|
|
uint8_t header_bytes[sizeof(Header)];
|
|
|
|
|
Header header;
|
|
|
|
|
};
|
|
|
|
|
uint32_t bytes_received;
|
|
|
|
|
uint16_t checksum;
|
|
|
|
|
millis_t timeout;
|
|
|
|
|
} packet{};
|
|
|
|
|
|
|
|
|
|
#pragma pack(pop)
|
|
|
|
|
|
|
|
|
|
void packet_reset() {
|
|
|
|
|
packet.header.id = 0;
|
|
|
|
|
packet.header.size = 0;
|
|
|
|
|
packet.header.checksum = 0;
|
|
|
|
|
packet.bytes_received = 0;
|
|
|
|
|
packet.checksum = 0x53A2;
|
|
|
|
|
packet.timeout = millis() + STREAM_MAX_WAIT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void stream_reset() {
|
|
|
|
|
packets_received = 0;
|
|
|
|
|
bytes_received = 0;
|
|
|
|
|
packet_retries = 0;
|
|
|
|
|
buffer_next_index = 0;
|
|
|
|
|
stream_header.token = 0;
|
|
|
|
|
stream_header.filesize = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint32_t checksum(uint32_t seed, uint8_t value) {
|
|
|
|
|
return ((seed ^ value) ^ (seed << 8)) & 0xFFFF;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// read the next byte from the data stream keeping track of
|
|
|
|
|
// whether the stream times out from data starvation
|
|
|
|
|
// takes the data variable by reference in order to return status
|
|
|
|
|
bool stream_read(uint8_t& data) {
|
|
|
|
|
if (ELAPSED(millis(), packet.timeout)) {
|
|
|
|
|
stream_state = StreamState::PACKET_TIMEOUT;
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
if (!serial_data_available(card.transfer_port)) return false;
|
|
|
|
|
data = read_serial(card.transfer_port);
|
|
|
|
|
packet.timeout = millis() + STREAM_MAX_WAIT;
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<const size_t buffer_size>
|
|
|
|
|
void receive(char (&buffer)[buffer_size]) {
|
|
|
|
|
uint8_t data = 0;
|
|
|
|
|
millis_t tranfer_timeout = millis() + RX_TIMESLICE;
|
|
|
|
|
while (PENDING(millis(), tranfer_timeout)) {
|
|
|
|
|
switch (stream_state) {
|
|
|
|
|
case StreamState::STREAM_RESET:
|
|
|
|
|
stream_reset();
|
|
|
|
|
case StreamState::PACKET_RESET:
|
|
|
|
|
packet_reset();
|
|
|
|
|
stream_state = StreamState::PACKET_HEADER;
|
|
|
|
|
break;
|
|
|
|
|
case StreamState::STREAM_HEADER: // we could also transfer the filename in this packet, rather than handling it in the gcode
|
|
|
|
|
for (size_t i = 0; i < sizeof(stream_header); ++i) {
|
|
|
|
|
stream_header_bytes[i] = buffer[i];
|
|
|
|
|
}
|
|
|
|
|
if (stream_header.token == 0x1234) {
|
|
|
|
|
stream_state = StreamState::PACKET_RESET;
|
|
|
|
|
bytes_received = 0;
|
|
|
|
|
time_stream_start = millis();
|
|
|
|
|
CARD_ECHO_P("echo: Datastream initialized (");
|
|
|
|
|
CARD_ECHO_P(stream_header.filesize);
|
|
|
|
|
CARD_ECHOLN_P("Bytes expected)");
|
|
|
|
|
CARD_ECHO_P("so"); // confirm active stream and the maximum block size supported
|
|
|
|
|
CARD_CHAR_P(static_cast<uint8_t>(buffer_size & 0xFF));
|
|
|
|
|
CARD_CHAR_P(static_cast<uint8_t>((buffer_size >> 8) & 0xFF));
|
|
|
|
|
CARD_CHAR_P('\n');
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
CARD_ECHOLN_P("echo: Datastream initialization error (invalid token)");
|
|
|
|
|
stream_state = StreamState::STREAM_FAILED;
|
|
|
|
|
}
|
|
|
|
|
buffer_next_index = 0;
|
|
|
|
|
break;
|
|
|
|
|
case StreamState::PACKET_HEADER:
|
|
|
|
|
if (!stream_read(data)) break;
|
|
|
|
|
|
|
|
|
|
packet.header_bytes[packet.bytes_received++] = data;
|
|
|
|
|
if (packet.bytes_received == sizeof(Packet::Header)) {
|
|
|
|
|
if (packet.header.id == packets_received) {
|
|
|
|
|
buffer_next_index = 0;
|
|
|
|
|
packet.bytes_received = 0;
|
|
|
|
|
stream_state = StreamState::PACKET_DATA;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
CARD_ECHO_P("echo: Datastream packet out of order");
|
|
|
|
|
stream_state = StreamState::PACKET_FLUSHRX;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case StreamState::PACKET_DATA:
|
|
|
|
|
if (!stream_read(data)) break;
|
|
|
|
|
|
|
|
|
|
if (buffer_next_index < buffer_size) {
|
|
|
|
|
buffer[buffer_next_index] = data;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
CARD_ECHO_P("echo: Datastream packet data buffer overrun");
|
|
|
|
|
stream_state = StreamState::STREAM_FAILED;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
packet.checksum = checksum(packet.checksum, data);
|
|
|
|
|
packet.bytes_received ++;
|
|
|
|
|
buffer_next_index ++;
|
|
|
|
|
|
|
|
|
|
if (packet.bytes_received == packet.header.size) {
|
|
|
|
|
stream_state = StreamState::PACKET_VALIDATE;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case StreamState::PACKET_VALIDATE:
|
|
|
|
|
if (packet.header.checksum == packet.checksum) {
|
|
|
|
|
packet_retries = 0;
|
|
|
|
|
packets_received ++;
|
|
|
|
|
bytes_received += packet.header.size;
|
|
|
|
|
|
|
|
|
|
if (packet.header.id == 0) { // id 0 is always the stream descriptor
|
|
|
|
|
stream_state = StreamState::STREAM_HEADER; // defer packet confirmation to STREAM_HEADER state
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
if (bytes_received < stream_header.filesize) {
|
|
|
|
|
stream_state = StreamState::PACKET_RESET; // reset and receive next packet
|
|
|
|
|
CARD_ECHOLN_P("ok"); // transmit confirm packet received and valid token
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
stream_state = StreamState::STREAM_COMPLETE; // no more data required
|
|
|
|
|
}
|
|
|
|
|
if (card.write(buffer, buffer_next_index) < 0) {
|
|
|
|
|
stream_state = StreamState::STREAM_FAILED;
|
|
|
|
|
CARD_ECHO_P("echo: IO ERROR");
|
|
|
|
|
break;
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
CARD_ECHO_P("echo: Block(");
|
|
|
|
|
CARD_ECHO_P(packet.header.id);
|
|
|
|
|
CARD_ECHOLN_P(") Corrupt");
|
|
|
|
|
stream_state = StreamState::PACKET_FLUSHRX;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case StreamState::PACKET_RESEND:
|
|
|
|
|
if (packet_retries < MAX_RETRIES) {
|
|
|
|
|
packet_retries ++;
|
|
|
|
|
stream_state = StreamState::PACKET_RESET;
|
|
|
|
|
CARD_ECHO_P("echo: Resend request ");
|
|
|
|
|
CARD_ECHOLN_P(packet_retries);
|
|
|
|
|
CARD_ECHOLN_P("rs"); // transmit resend packet token
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
stream_state = StreamState::STREAM_FAILED;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case StreamState::PACKET_FLUSHRX:
|
|
|
|
|
if (ELAPSED(millis(), packet.timeout)) {
|
|
|
|
|
stream_state = StreamState::PACKET_RESEND;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (!serial_data_available(card.transfer_port)) break;
|
|
|
|
|
read_serial(card.transfer_port); // throw away data
|
|
|
|
|
packet.timeout = millis() + STREAM_MAX_WAIT;
|
|
|
|
|
break;
|
|
|
|
|
case StreamState::PACKET_TIMEOUT:
|
|
|
|
|
CARD_ECHOLN_P("echo: Datastream timeout");
|
|
|
|
|
stream_state = StreamState::PACKET_RESEND;
|
|
|
|
|
break;
|
|
|
|
|
case StreamState::STREAM_COMPLETE:
|
|
|
|
|
stream_state = StreamState::STREAM_RESET;
|
|
|
|
|
card.binary_mode = false;
|
|
|
|
|
card.closefile();
|
|
|
|
|
CARD_ECHO_P("echo: ");
|
|
|
|
|
CARD_ECHO_P(card.filename);
|
|
|
|
|
CARD_ECHO_P(" transfer completed @ ");
|
|
|
|
|
CARD_ECHO_P(((bytes_received / (millis() - time_stream_start) * 1000) / 1024 ));
|
|
|
|
|
CARD_ECHOLN_P("KiB/s");
|
|
|
|
|
CARD_ECHOLN_P("sc"); // transmit stream complete token
|
|
|
|
|
return;
|
|
|
|
|
case StreamState::STREAM_FAILED:
|
|
|
|
|
stream_state = StreamState::STREAM_RESET;
|
|
|
|
|
card.binary_mode = false;
|
|
|
|
|
card.closefile();
|
|
|
|
|
card.removeFile(card.filename);
|
|
|
|
|
CARD_ECHOLN_P("echo: File transfer failed");
|
|
|
|
|
CARD_ECHOLN_P("sf"); // transmit stream failed token
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const uint16_t STREAM_MAX_WAIT = 500, RX_TIMESLICE = 20, MAX_RETRIES = 3;
|
|
|
|
|
uint8_t packet_retries;
|
|
|
|
|
uint16_t buffer_next_index;
|
|
|
|
|
uint32_t packets_received, bytes_received;
|
|
|
|
|
millis_t time_stream_start;
|
|
|
|
|
StreamState stream_state = StreamState::STREAM_RESET;
|
|
|
|
|
|
|
|
|
|
} binaryStream{};
|
|
|
|
|
|
|
|
|
|
#endif // FAST_FILE_TRANSFER
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Get all commands waiting on the serial port and queue them.
|
|
|
|
|
* Exit when the buffer is full or when no more characters are
|
|
|
|
|
@ -288,6 +546,18 @@ inline void get_serial_commands() {
|
|
|
|
|
#endif
|
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
#if ENABLED(FAST_FILE_TRANSFER)
|
|
|
|
|
if (card.saving && card.binary_mode) {
|
|
|
|
|
/**
|
|
|
|
|
* For binary stream file transfer, use serial_line_buffer as the working
|
|
|
|
|
* receive buffer (which limits the packet size to MAX_CMD_SIZE).
|
|
|
|
|
* The receive buffer also limits the packet size for reliable transmission.
|
|
|
|
|
*/
|
|
|
|
|
binaryStream.receive(serial_line_buffer[card.transfer_port]);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
// If the command buffer is empty for too long,
|
|
|
|
|
// send "wait" to indicate Marlin is still waiting.
|
|
|
|
|
#if NO_TIMEOUTS > 0
|
|
|
|
|
|
Chris Pepper
6 years ago
committed by