From 508d764d63c26376683eb1de7ef9c0f8f1d19abf Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Mon, 2 Oct 2017 02:47:30 -0500 Subject: [PATCH] Add serial XON/XOFF handshaking From @ejtagle, originally #7459 --- Marlin/Configuration.h | 3 +- Marlin/Configuration_adv.h | 24 ++- Marlin/src/HAL/HAL_AVR/MarlinSerial.cpp | 256 ++++++++++++++++++------ Marlin/src/HAL/HAL_AVR/MarlinSerial.h | 75 +++---- Marlin/src/core/macros.h | 1 + Marlin/src/gcode/queue.cpp | 24 ++- 6 files changed, 279 insertions(+), 104 deletions(-) diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h index c933b6887c..25a2571549 100644 --- a/Marlin/Configuration.h +++ b/Marlin/Configuration.h @@ -108,8 +108,9 @@ * * 250000 works in most cases, but you might try a lower speed if * you commonly experience drop-outs during host printing. + * You may try up to 1000000 to speed up SD file transfer. * - * :[2400, 9600, 19200, 38400, 57600, 115200, 250000] + * :[2400, 9600, 19200, 38400, 57600, 115200, 250000, 500000, 1000000] */ #define BAUDRATE 250000 diff --git a/Marlin/Configuration_adv.h b/Marlin/Configuration_adv.h index fbab9b8191..402c5b18cf 100644 --- a/Marlin/Configuration_adv.h +++ b/Marlin/Configuration_adv.h @@ -751,7 +751,7 @@ #define MAX_CMD_SIZE 96 #define BUFSIZE 4 -// Transfer Buffer Size +// Transmission to Host Buffer Size // To save 386 bytes of PROGMEM (and TX_BUFFER_SIZE+3 bytes of RAM) set to 0. // To buffer a simple "ok" you need 4 bytes. // For ADVANCED_OK (M105) you need 32 bytes. @@ -760,6 +760,28 @@ // :[0, 2, 4, 8, 16, 32, 64, 128, 256] #define TX_BUFFER_SIZE 0 +// Host Receive Buffer Size +// Without XON/XOFF flow control (see SERIAL_XON_XOFF below) 32 bytes should be enough. +// To use flow control, set this buffer size to at least 1024 bytes. +// :[0, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048] +//#define RX_BUFFER_SIZE 1024 + +#if RX_BUFFER_SIZE >= 1024 + // Enable to have the controller send XON/XOFF control characters to + // the host to signal the RX buffer is becoming full. + //#define SERIAL_XON_XOFF +#endif + +#if ENABLED(SDSUPPORT) + // Enable this option to collect and display the maximum + // RX queue usage after transferring a file to SD. + //#define SERIAL_STATS_MAX_RX_QUEUED + + // Enable this option to collect and display the number + // of dropped bytes after a file transfer to SD. + //#define SERIAL_STATS_DROPPED_RX +#endif + // Enable an emergency-command parser to intercept certain commands as they // enter the serial receive buffer, so they cannot be blocked. // Currently handles M108, M112, M410 diff --git a/Marlin/src/HAL/HAL_AVR/MarlinSerial.cpp b/Marlin/src/HAL/HAL_AVR/MarlinSerial.cpp index 6e6430f77a..ca83f24c02 100644 --- a/Marlin/src/HAL/HAL_AVR/MarlinSerial.cpp +++ b/Marlin/src/HAL/HAL_AVR/MarlinSerial.cpp @@ -27,16 +27,31 @@ * Modified 23 November 2006 by David A. Mellis * Modified 28 September 2010 by Mark Sproul * Modified 14 February 2016 by Andreas Hardtung (added tx buffer) + * Modified 01 October 2017 by Eduardo José Tagle (added XON/XOFF) */ #ifdef __AVR__ -#include "MarlinSerial.h" -#include "../../Marlin.h" - // Disable HardwareSerial.cpp to support chips without a UART (Attiny, etc.) +#include "../../inc/MarlinConfig.h" + #if !defined(USBCON) && (defined(UBRRH) || defined(UBRR0H) || defined(UBRR1H) || defined(UBRR2H) || defined(UBRR3H)) + #include "MarlinSerial.h" + #include "../../Marlin.h" + + struct ring_buffer_r { + unsigned char buffer[RX_BUFFER_SIZE]; + volatile ring_buffer_pos_t head, tail; + }; + + #if TX_BUFFER_SIZE > 0 + struct ring_buffer_t { + unsigned char buffer[TX_BUFFER_SIZE]; + volatile uint8_t head, tail; + }; + #endif + #if UART_PRESENT(SERIAL_PORT) ring_buffer_r rx_buffer = { { 0 }, 0, 0 }; #if TX_BUFFER_SIZE > 0 @@ -45,6 +60,23 @@ #endif #endif + #if ENABLED(SERIAL_XON_XOFF) + uint8_t xon_xoff_state = XON_XOFF_CHAR_SENT | XON_CHAR; + constexpr uint8_t XON_XOFF_CHAR_SENT = 0x80; // XON / XOFF Character was sent + constexpr uint8_t XON_XOFF_CHAR_MASK = 0x1F; // XON / XOFF character to send + // XON / XOFF character definitions + constexpr uint8_t XON_CHAR = 17; + constexpr uint8_t XOFF_CHAR = 19; + #endif + + #if ENABLED(SERIAL_STATS_DROPPED_RX) + uint8_t rx_dropped_bytes = 0; + #endif + + #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED) + ring_buffer_pos_t rx_max_enqueued = 0; + #endif + #if ENABLED(EMERGENCY_PARSER) #include "../../module/stepper.h" @@ -136,20 +168,78 @@ #endif // EMERGENCY_PARSER - FORCE_INLINE void store_char(unsigned char c) { - CRITICAL_SECTION_START; - const uint8_t h = rx_buffer.head, - i = (uint8_t)(h + 1) & (RX_BUFFER_SIZE - 1); + FORCE_INLINE void store_rxd_char() { + const ring_buffer_pos_t h = rx_buffer.head, + i = (ring_buffer_pos_t)(h + 1) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1); - // if we should be storing the received character into the location - // just before the tail (meaning that the head would advance to the - // current location of the tail), we're about to overflow the buffer - // and so we don't write the character or advance the head. - if (i != rx_buffer.tail) { - rx_buffer.buffer[h] = c; - rx_buffer.head = i; + // If the character is to be stored at the index just before the tail + // (such that the head would advance to the current tail), the buffer is + // critical, so don't write the character or advance the head. + if (i != rx_buffer.tail) { + rx_buffer.buffer[h] = M_UDRx; + rx_buffer.head = i; + } + else { + (void)M_UDRx; + #if ENABLED(SERIAL_STATS_DROPPED_RX) + if (!++rx_dropped_bytes) ++rx_dropped_bytes; + #endif + } + + #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED) + // calculate count of bytes stored into the RX buffer + ring_buffer_pos_t rx_count = (ring_buffer_pos_t)(rx_buffer.head - rx_buffer.tail) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1); + // Keep track of the maximum count of enqueued bytes + NOLESS(rx_max_enqueued, rx_count); + #endif + + #if ENABLED(SERIAL_XON_XOFF) + + // for high speed transfers, we can use XON/XOFF protocol to do + // software handshake and avoid overruns. + if ((xon_xoff_state & XON_XOFF_CHAR_MASK) == XON_CHAR) { + + // calculate count of bytes stored into the RX buffer + ring_buffer_pos_t rx_count = (ring_buffer_pos_t)(rx_buffer.head - rx_buffer.tail) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1); + + // if we are above 12.5% of RX buffer capacity, send XOFF before + // we run out of RX buffer space .. We need 325 bytes @ 250kbits/s to + // let the host react and stop sending bytes. This translates to 13mS + // propagation time. + if (rx_count >= (RX_BUFFER_SIZE) / 8) { + // If TX interrupts are disabled and data register is empty, + // just write the byte to the data register and be done. This + // shortcut helps significantly improve the effective datarate + // at high (>500kbit/s) bitrates, where interrupt overhead + // becomes a slowdown. + if (!TEST(M_UCSRxB, M_UDRIEx) && TEST(M_UCSRxA, M_UDREx)) { + // Send an XOFF character + M_UDRx = XOFF_CHAR; + // clear the TXC bit -- "can be cleared by writing a one to its bit + // location". This makes sure flush() won't return until the bytes + // actually got written + SBI(M_UCSRxA, M_TXCx); + // And remember it was sent + xon_xoff_state = XOFF_CHAR | XON_XOFF_CHAR_SENT; + } + else { + // TX interrupts disabled, but buffer still not empty ... or + // TX interrupts enabled. Reenable TX ints and schedule XOFF + // character to be sent + #if TX_BUFFER_SIZE > 0 + SBI(M_UCSRxB, M_UDRIEx); + xon_xoff_state = XOFF_CHAR; + #else + // We are not using TX interrupts, we will have to send this manually + while (!TEST(M_UCSRxA, M_UDREx)) { /* nada */ }; + M_UDRx = XOFF_CHAR; + // And remember we already sent it + xon_xoff_state = XOFF_CHAR | XON_XOFF_CHAR_SENT; + #endif + } + } } - CRITICAL_SECTION_END; + #endif // SERIAL_XON_XOFF #if ENABLED(EMERGENCY_PARSER) emergency_parser(c); @@ -160,37 +250,41 @@ FORCE_INLINE void _tx_udr_empty_irq(void) { // If interrupts are enabled, there must be more data in the output - // buffer. Send the next byte - const uint8_t t = tx_buffer.tail, - c = tx_buffer.buffer[t]; - tx_buffer.tail = (t + 1) & (TX_BUFFER_SIZE - 1); + // buffer. - M_UDRx = c; + #if ENABLED(SERIAL_XON_XOFF) + // Do a priority insertion of an XON/XOFF char, if needed. + const uint8_t state = xon_xoff_state; + if (!(state & XON_XOFF_CHAR_SENT)) { + M_UDRx = state & XON_XOFF_CHAR_MASK; + xon_xoff_state = state | XON_XOFF_CHAR_SENT; + } + else + #endif + { // Send the next byte + const uint8_t t = tx_buffer.tail, c = tx_buffer.buffer[t]; + tx_buffer.tail = (t + 1) & (TX_BUFFER_SIZE - 1); + M_UDRx = c; + } // clear the TXC bit -- "can be cleared by writing a one to its bit // location". This makes sure flush() won't return until the bytes // actually got written SBI(M_UCSRxA, M_TXCx); - if (tx_buffer.head == tx_buffer.tail) { - // Buffer empty, so disable interrupts + // Disable interrupts if the buffer is empty + if (tx_buffer.head == tx_buffer.tail) CBI(M_UCSRxB, M_UDRIEx); - } } #ifdef M_USARTx_UDRE_vect - ISR(M_USARTx_UDRE_vect) { - _tx_udr_empty_irq(); - } + ISR(M_USARTx_UDRE_vect) { _tx_udr_empty_irq(); } #endif #endif // TX_BUFFER_SIZE #ifdef M_USARTx_RX_vect - ISR(M_USARTx_RX_vect) { - const unsigned char c = M_UDRx; - store_char(c); - } + ISR(M_USARTx_RX_vect) { store_rxd_char(); } #endif // Public Methods @@ -200,9 +294,9 @@ bool useU2X = true; #if F_CPU == 16000000UL && SERIAL_PORT == 0 - // hard-coded exception for compatibility with the bootloader shipped - // with the Duemilanove and previous boards and the firmware on the 8U2 - // on the Uno and Mega 2560. + // Hard-coded exception for compatibility with the bootloader shipped + // with the Duemilanove and previous boards, and the firmware on the + // 8U2 on the Uno and Mega 2560. if (baud == 57600) useU2X = false; #endif @@ -237,8 +331,9 @@ void MarlinSerial::checkRx(void) { if (TEST(M_UCSRxA, M_RXCx)) { - const uint8_t c = M_UDRx; - store_char(c); + CRITICAL_SECTION_START; + store_rxd_char(); + CRITICAL_SECTION_END; } } @@ -252,47 +347,76 @@ int MarlinSerial::read(void) { int v; CRITICAL_SECTION_START; - const uint8_t t = rx_buffer.tail; + const ring_buffer_pos_t t = rx_buffer.tail; if (rx_buffer.head == t) v = -1; else { v = rx_buffer.buffer[t]; - rx_buffer.tail = (uint8_t)(t + 1) & (RX_BUFFER_SIZE - 1); + rx_buffer.tail = (ring_buffer_pos_t)(t + 1) & (RX_BUFFER_SIZE - 1); + + #if ENABLED(SERIAL_XON_XOFF) + if ((xon_xoff_state & XON_XOFF_CHAR_MASK) == XOFF_CHAR) { + // Get count of bytes in the RX buffer + ring_buffer_pos_t rx_count = (ring_buffer_pos_t)(rx_buffer.head - rx_buffer.tail) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1); + // When below 10% of RX buffer capacity, send XON before + // running out of RX buffer bytes + if (rx_count < (RX_BUFFER_SIZE) / 10) { + xon_xoff_state = XON_CHAR | XON_XOFF_CHAR_SENT; + CRITICAL_SECTION_END; // End critical section before returning! + writeNoHandshake(XON_CHAR); + return v; + } + } + #endif } CRITICAL_SECTION_END; return v; } - uint8_t MarlinSerial::available(void) { + ring_buffer_pos_t MarlinSerial::available(void) { CRITICAL_SECTION_START; - const uint8_t h = rx_buffer.head, - t = rx_buffer.tail; + const ring_buffer_pos_t h = rx_buffer.head, t = rx_buffer.tail; CRITICAL_SECTION_END; - return (uint8_t)(RX_BUFFER_SIZE + h - t) & (RX_BUFFER_SIZE - 1); + return (ring_buffer_pos_t)(RX_BUFFER_SIZE + h - t) & (RX_BUFFER_SIZE - 1); } void MarlinSerial::flush(void) { - // RX - // don't reverse this or there may be problems if the RX interrupt - // occurs after reading the value of rx_buffer_head but before writing - // the value to rx_buffer_tail; the previous value of rx_buffer_head - // may be written to rx_buffer_tail, making it appear as if the buffer - // were full, not empty. + // Don't change this order of operations. If the RX interrupt occurs between + // reading rx_buffer_head and updating rx_buffer_tail, the previous rx_buffer_head + // may be written to rx_buffer_tail, making the buffer appear full rather than empty. CRITICAL_SECTION_START; rx_buffer.head = rx_buffer.tail; CRITICAL_SECTION_END; + + #if ENABLED(SERIAL_XON_XOFF) + if ((xon_xoff_state & XON_XOFF_CHAR_MASK) == XOFF_CHAR) { + xon_xoff_state = XON_CHAR | XON_XOFF_CHAR_SENT; + writeNoHandshake(XON_CHAR); + } + #endif } #if TX_BUFFER_SIZE > 0 uint8_t MarlinSerial::availableForWrite(void) { CRITICAL_SECTION_START; - const uint8_t h = tx_buffer.head, - t = tx_buffer.tail; + const uint8_t h = tx_buffer.head, t = tx_buffer.tail; CRITICAL_SECTION_END; return (uint8_t)(TX_BUFFER_SIZE + h - t) & (TX_BUFFER_SIZE - 1); } void MarlinSerial::write(const uint8_t c) { + #if ENABLED(SERIAL_XON_XOFF) + const uint8_t state = xon_xoff_state; + if (!(state & XON_XOFF_CHAR_SENT)) { + // Send 2 chars: XON/XOFF, then a user-specified char + writeNoHandshake(state & XON_XOFF_CHAR_MASK); + xon_xoff_state = state | XON_XOFF_CHAR_SENT; + } + #endif + writeNoHandshake(c); + } + + void MarlinSerial::writeNoHandshake(const uint8_t c) { _written = true; CRITICAL_SECTION_START; bool emty = (tx_buffer.head == tx_buffer.tail); @@ -353,20 +477,34 @@ } // If we get here, nothing is queued anymore (DRIE is disabled) and // the hardware finished tranmission (TXC is set). - } + } - #else - void MarlinSerial::write(uint8_t c) { - while (!TEST(M_UCSRxA, M_UDREx)) - ; + #else // TX_BUFFER_SIZE == 0 + + void MarlinSerial::write(const uint8_t c) { + while (!TEST(M_UCSRxA, M_UDREx)) { /* nada */ } + M_UDRx = c; + #if ENABLED(SERIAL_XON_XOFF) + // Do a priority insertion of an XON/XOFF char, if needed. + const uint8_t state = xon_xoff_state; + if (!(state & XON_XOFF_CHAR_SENT)) { + writeNoHandshake(state & XON_XOFF_CHAR_MASK); + xon_xoff_state = state | XON_XOFF_CHAR_SENT; + } + #endif + writeNoHandshake(c); + } + + void MarlinSerial::writeNoHandshake(const uint8_t c) { + while (!TEST(M_UCSRxA, M_UDREx)) ; M_UDRx = c; } - #endif - // end NEW - - /// imports from print.h + #endif // TX_BUFFER_SIZE == 0 + /** + * Imports from print.h + */ void MarlinSerial::print(char c, int base) { print((long)c, base); @@ -516,4 +654,4 @@ HardwareSerial bluetoothSerial; #endif -#endif +#endif // __AVR__ diff --git a/Marlin/src/HAL/HAL_AVR/MarlinSerial.h b/Marlin/src/HAL/HAL_AVR/MarlinSerial.h index 0448e5502c..ef4f165e0c 100644 --- a/Marlin/src/HAL/HAL_AVR/MarlinSerial.h +++ b/Marlin/src/HAL/HAL_AVR/MarlinSerial.h @@ -21,13 +21,13 @@ */ /** - MarlinSerial.h - Hardware serial library for Wiring - Copyright (c) 2006 Nicholas Zambetti. All right reserved. - - Modified 28 September 2010 by Mark Sproul - Modified 14 February 2016 by Andreas Hardtung (added tx buffer) - -*/ + * MarlinSerial.h - Hardware serial library for Wiring + * Copyright (c) 2006 Nicholas Zambetti. All right reserved. + * + * Modified 28 September 2010 by Mark Sproul + * Modified 14 February 2016 by Andreas Hardtung (added tx buffer) + * Modified 01 October 2017 by Eduardo José Tagle (added XON/XOFF) + */ #ifndef MARLINSERIAL_H #define MARLINSERIAL_H @@ -89,34 +89,33 @@ #ifndef TX_BUFFER_SIZE #define TX_BUFFER_SIZE 32 #endif - #if !((RX_BUFFER_SIZE == 256) ||(RX_BUFFER_SIZE == 128) ||(RX_BUFFER_SIZE == 64) ||(RX_BUFFER_SIZE == 32) ||(RX_BUFFER_SIZE == 16) ||(RX_BUFFER_SIZE == 8) ||(RX_BUFFER_SIZE == 4) ||(RX_BUFFER_SIZE == 2)) - #error "RX_BUFFER_SIZE has to be a power of 2 and >= 2" - #endif - #if !((TX_BUFFER_SIZE == 256) ||(TX_BUFFER_SIZE == 128) ||(TX_BUFFER_SIZE == 64) ||(TX_BUFFER_SIZE == 32) ||(TX_BUFFER_SIZE == 16) ||(TX_BUFFER_SIZE == 8) ||(TX_BUFFER_SIZE == 4) ||(TX_BUFFER_SIZE == 2) ||(TX_BUFFER_SIZE == 0)) - #error TX_BUFFER_SIZE has to be a power of 2 or 0 + + #if ENABLED(SERIAL_XON_XOFF) && RX_BUFFER_SIZE < 1024 + #error "XON/XOFF requires RX_BUFFER_SIZE >= 1024 for reliable transfers without drops." #endif - struct ring_buffer_r { - unsigned char buffer[RX_BUFFER_SIZE]; - volatile uint8_t head; - volatile uint8_t tail; - }; - - #if TX_BUFFER_SIZE > 0 - struct ring_buffer_t { - unsigned char buffer[TX_BUFFER_SIZE]; - volatile uint8_t head; - volatile uint8_t tail; - }; + #if !IS_POWER_OF_2(RX_BUFFER_SIZE) || RX_BUFFER_SIZE < 2 + #error "RX_BUFFER_SIZE must be a power of 2 greater than 1." #endif - #if UART_PRESENT(SERIAL_PORT) - extern ring_buffer_r rx_buffer; - #if TX_BUFFER_SIZE > 0 - extern ring_buffer_t tx_buffer; - #endif + #if TX_BUFFER_SIZE && (TX_BUFFER_SIZE < 2 || TX_BUFFER_SIZE > 256 || !IS_POWER_OF_2(TX_BUFFER_SIZE)) + #error "TX_BUFFER_SIZE must be 0 or a power of 2 greater than 1." #endif + #if RX_BUFFER_SIZE > 256 + typedef uint16_t ring_buffer_pos_t; + #else + typedef uint8_t ring_buffer_pos_t; + #endif + + #if ENABLED(SERIAL_STATS_DROPPED_RX) + extern uint8_t rx_dropped_bytes; + #endif + + #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED) + extern ring_buffer_pos_t rx_max_enqueued; + #endif + class MarlinSerial { //: public Stream public: @@ -126,19 +125,23 @@ static int peek(void); static int read(void); static void flush(void); - static uint8_t available(void); + static ring_buffer_pos_t available(void); static void checkRx(void); static void write(const uint8_t c); #if TX_BUFFER_SIZE > 0 static uint8_t availableForWrite(void); static void flushTX(void); #endif + static void writeNoHandshake(const uint8_t c); - private: - static void printNumber(unsigned long, const uint8_t); - static void printFloat(double, uint8_t); + #if ENABLED(SERIAL_STATS_DROPPED_RX) + FORCE_INLINE static uint32_t dropped() { return rx_dropped_bytes; } + #endif + + #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED) + FORCE_INLINE static ring_buffer_pos_t rxMaxEnqueued() { return rx_max_enqueued; } + #endif - public: static FORCE_INLINE void write(const char* str) { while (*str) write(*str++); } static FORCE_INLINE void write(const uint8_t* buffer, size_t size) { while (size--) write(*buffer++); } static FORCE_INLINE void print(const String& s) { for (int i = 0; i < (int)s.length(); i++) write(s[i]); } @@ -163,6 +166,10 @@ static void println(double, int = 2); static void println(void); operator bool() { return true; } + + private: + static void printNumber(unsigned long, const uint8_t); + static void printFloat(double, uint8_t); }; extern MarlinSerial customizedSerial; diff --git a/Marlin/src/core/macros.h b/Marlin/src/core/macros.h index e2f25eed4b..a89b6dafce 100644 --- a/Marlin/src/core/macros.h +++ b/Marlin/src/core/macros.h @@ -106,6 +106,7 @@ #define CIRCLE_CIRC(R) (2.0 * M_PI * (R)) #define SIGN(a) ((a>0)-(a<0)) +#define IS_POWER_OF_2(x) ((x) && !((x) & ((x) - 1))) // Macros to contrain values #define NOLESS(v,n) do{ if (v < n) v = n; }while(0) diff --git a/Marlin/src/gcode/queue.cpp b/Marlin/src/gcode/queue.cpp index 09c49933a6..fd28d20cfe 100644 --- a/Marlin/src/gcode/queue.cpp +++ b/Marlin/src/gcode/queue.cpp @@ -221,9 +221,9 @@ inline void get_serial_commands() { /** * Loop while serial characters are incoming and the queue is not full */ - while (commands_in_queue < BUFSIZE && MYSERIAL.available() > 0) { - - char serial_char = MYSERIAL.read(); + int c; + while (commands_in_queue < BUFSIZE && (c = MYSERIAL.read()) >= 0) { + char serial_char = c; /** * If the character ends the line @@ -323,12 +323,9 @@ inline void get_serial_commands() { // The command will be injected when EOL is reached } else if (serial_char == '\\') { // Handle escapes - if (MYSERIAL.available() > 0) { - // if we have one more character, copy it over - serial_char = MYSERIAL.read(); - if (!serial_comment_mode) serial_line_buffer[serial_count++] = serial_char; - } - // otherwise do nothing + // if we have one more character, copy it over + if ((c = MYSERIAL.read()) >= 0 && !serial_comment_mode) + serial_line_buffer[serial_count++] = serial_char; } else { // it's not a newline, carriage return or escape char if (serial_char == ';') serial_comment_mode = true; @@ -448,6 +445,15 @@ void advance_command_queue() { // M29 closes the file card.closefile(); SERIAL_PROTOCOLLNPGM(MSG_FILE_SAVED); + + #if ENABLED(SERIAL_STATS_DROPPED_RX) + SERIAL_ECHOLNPAIR("Dropped bytes: ", customizedSerial.dropped()); + #endif + + #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED) + SERIAL_ECHOLNPAIR("Max RX Queue Size: ", customizedSerial.rxMaxEnqueued()); + #endif + ok_to_send(); } else {