From b4c53af07db1b248c1cc308d153c975060de536e Mon Sep 17 00:00:00 2001 From: etagle Date: Tue, 8 Aug 2017 02:09:50 -0300 Subject: [PATCH 1/8] Adding a new macro to be able to determine if a given integer value is a power of 2 --- Marlin/macros.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Marlin/macros.h b/Marlin/macros.h index 3b79ba9b8..9c45ba38e 100644 --- a/Marlin/macros.h +++ b/Marlin/macros.h @@ -99,6 +99,9 @@ #define CBI(n,b) (n &= ~_BV(b)) #define SET_BIT(n,b,value) (n) ^= ((-value)^(n)) & (_BV(b)) +// Macro to check that a number if a power if 2 +#define IS_POWEROF2(x) ((x) && !((x) & ((x) - 1))) + // Macros for maths shortcuts #ifndef M_PI #define M_PI 3.14159265358979323846 From 8ab2e420f61f1db6d44b024e23296130e6515c8e Mon Sep 17 00:00:00 2001 From: etagle Date: Tue, 8 Aug 2017 02:18:42 -0300 Subject: [PATCH 2/8] Adding separate RX_BUFFER_SIZE configuration setting and proper documentation on its usage --- Marlin/Configuration_adv.h | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/Marlin/Configuration_adv.h b/Marlin/Configuration_adv.h index 43be4998e..4b431f954 100644 --- a/Marlin/Configuration_adv.h +++ b/Marlin/Configuration_adv.h @@ -731,7 +731,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. @@ -740,6 +740,13 @@ // :[0, 2, 4, 8, 16, 32, 64, 128, 256] #define TX_BUFFER_SIZE 0 +// Reception from Host Buffer Size +// This is the size of the Reception buffer. If XON/XOFF software flow control +// is not enabled, then 32 bytes should be enough. But if you plan to use XON/XOFF +// you need 1024 bytes at least. +// :[0, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048] +#define RX_BUFFER_SIZE 1024 + // 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 From 9e147e9ac417a016c4e8a5f0178de641146b6ff5 Mon Sep 17 00:00:00 2001 From: etagle Date: Tue, 8 Aug 2017 02:22:33 -0300 Subject: [PATCH 3/8] Adding XON/XOFF and STATISTICS configuration settings and proper documentation on their usage for serial port --- Marlin/Configuration_adv.h | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/Marlin/Configuration_adv.h b/Marlin/Configuration_adv.h index 4b431f954..1a627a0dd 100644 --- a/Marlin/Configuration_adv.h +++ b/Marlin/Configuration_adv.h @@ -747,6 +747,18 @@ // :[0, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048] #define RX_BUFFER_SIZE 1024 +// This setting determines if the printer will send the XON/XOFF +// control characters to the host to signal RX buffer is becoming full +#define SERIAL_XON_XOFF 1 + +// This setting determines if you want to display and collect +// maximum RX queue usage after transferring a file to the SD +//#define SERIAL_STATS_MAX_RX_QUEUED 1 + +// This setting determines if you want to display and collect +// the number of dropped bytes after a file transfer to the SD +#define SERIAL_STATS_DROPPED_RX 1 + // 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 From 3e5485de924b8e9f21c851e037d156a7cef9d2e0 Mon Sep 17 00:00:00 2001 From: etagle Date: Tue, 8 Aug 2017 02:30:04 -0300 Subject: [PATCH 4/8] Enforcing requirements so XON/XOFF software handshake works and no drops of data are experienced while transferring data to an SD Card. I tested this with a CH340 USB to serial adapter (quite typical) at baudrates as high as 1000000 on a Atmega2560 running at 16Mhz, with no problems at all. We need a 1024 byte RX buffer. Less than that and we will have drops, higher than that is not needed --- Marlin/MarlinSerial.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Marlin/MarlinSerial.h b/Marlin/MarlinSerial.h index 8456a7237..1be94d656 100644 --- a/Marlin/MarlinSerial.h +++ b/Marlin/MarlinSerial.h @@ -84,6 +84,9 @@ #ifndef RX_BUFFER_SIZE #define RX_BUFFER_SIZE 128 #endif + #if ENABLED(SERIAL_XON_XOFF) && RX_BUFFER_SIZE < 1024 + #error "XON/XOFF requires a 1024 or greater RX_BUFFER_SIZE for allowing reliable transfers without drops" + #endif #ifndef TX_BUFFER_SIZE #define TX_BUFFER_SIZE 32 #endif From 534bbb81ff2ad9d2347c3648f92d4769bbac0f76 Mon Sep 17 00:00:00 2001 From: etagle Date: Tue, 8 Aug 2017 02:46:37 -0300 Subject: [PATCH 5/8] Adding XON/XOFF and STATISTICS implementation --- Marlin/Configuration.h | 3 +- Marlin/MarlinSerial.cpp | 210 +++++++++++++++++++++++++++++++++++++--- Marlin/MarlinSerial.h | 43 ++++++-- Marlin/Marlin_main.cpp | 6 ++ 4 files changed, 239 insertions(+), 23 deletions(-) diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h index 12d394fc3..3f3a83648 100644 --- a/Marlin/Configuration.h +++ b/Marlin/Configuration.h @@ -107,8 +107,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 file transfer to the SD card * - * :[2400, 9600, 19200, 38400, 57600, 115200, 250000] + * :[2400, 9600, 19200, 38400, 57600, 115200, 250000, 500000, 1000000] */ #define BAUDRATE 250000 diff --git a/Marlin/MarlinSerial.cpp b/Marlin/MarlinSerial.cpp index 235e01809..8a881db22 100644 --- a/Marlin/MarlinSerial.cpp +++ b/Marlin/MarlinSerial.cpp @@ -44,6 +44,17 @@ #endif #endif + #if ENABLED(SERIAL_XON_XOFF) + uint8_t xon_xoff_state = XON_XOFF_CHAR_SENT | XON_CHAR; + #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 "stepper.h" @@ -136,20 +147,94 @@ #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.buffer[h] = M_UDRx; rx_buffer.head = i; } - CRITICAL_SECTION_END; + 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 + if (rx_max_enqueued < rx_count) + 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 we already sent it + 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)) + ; + M_UDRx = XOFF_CHAR; + + // And remember we already sent it + xon_xoff_state = XOFF_CHAR | XON_XOFF_CHAR_SENT; + + #endif + } + + } + } + #endif #if ENABLED(EMERGENCY_PARSER) emergency_parser(c); @@ -160,13 +245,31 @@ 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 + // buffer. + + #if ENABLED(SERIAL_XON_XOFF) + + // If we must do a priority insertion of an XON/XOFF char, + // do it now + 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; + #if ENABLED(SERIAL_XON_XOFF) + } + #endif + // 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 @@ -188,8 +291,7 @@ #ifdef M_USARTx_RX_vect ISR(M_USARTx_RX_vect) { - const unsigned char c = M_UDRx; - store_char(c); + store_rxd_char(); } #endif @@ -237,8 +339,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,23 +355,52 @@ 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) + + // 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) == XOFF_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 below 10% of RX buffer capacity, send XON before + // we run out of RX buffer bytes + if (rx_count < (RX_BUFFER_SIZE/10)) { + + // Send an XON character + xon_xoff_state = XON_CHAR | XON_XOFF_CHAR_SENT; + + // End critical section + CRITICAL_SECTION_END; + + // Transmit the XON character + writeNoHandshake(XON_CHAR); + + // Done + 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, + 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) { @@ -281,6 +413,20 @@ CRITICAL_SECTION_START; rx_buffer.head = rx_buffer.tail; CRITICAL_SECTION_END; + + #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) == XOFF_CHAR) { + + // Send an XON character + xon_xoff_state = XON_CHAR | XON_XOFF_CHAR_SENT; + + // Transmit the XON character + writeNoHandshake(XON_CHAR); + } + #endif } #if TX_BUFFER_SIZE > 0 @@ -293,10 +439,26 @@ } void MarlinSerial::write(const uint8_t c) { + + #if ENABLED(SERIAL_XON_XOFF) + uint8_t state = xon_xoff_state; + if (!(state & XON_XOFF_CHAR_SENT)) { + // 2 characters to send: The XON/XOFF character and the user + // specified char. + writeNoHandshake(state & XON_XOFF_CHAR_MASK); + xon_xoff_state = state | XON_XOFF_CHAR_SENT; + } + #endif + writeNoHandshake(c); + } + + void MarlinSerial::writeNoHandshake(uint8_t c) { + _written = true; CRITICAL_SECTION_START; bool emty = (tx_buffer.head == tx_buffer.tail); CRITICAL_SECTION_END; + // If the buffer and the 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 (> @@ -335,6 +497,7 @@ return; } + void MarlinSerial::flushTX(void) { // TX // If we have never written a byte, no need to flush. This special @@ -357,6 +520,21 @@ #else void MarlinSerial::write(uint8_t c) { + + #if ENABLED(SERIAL_XON_XOFF) + // If we must do a priority insertion of an XON/XOFF char, do it now + 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(uint8_t c) { while (!TEST(M_UCSRxA, M_UDREx)) ; M_UDRx = c; diff --git a/Marlin/MarlinSerial.h b/Marlin/MarlinSerial.h index 1be94d656..b0de0bb87 100644 --- a/Marlin/MarlinSerial.h +++ b/Marlin/MarlinSerial.h @@ -90,17 +90,22 @@ #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)) + #if !IS_POWEROF2(RX_BUFFER_SIZE) || (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 TX_BUFFER_SIZE != 0 && (TX_BUFFER_SIZE < 2 || TX_BUFFER_SIZE > 256 || !IS_POWEROF2(TX_BUFFER_SIZE)) + #error "TX_BUFFER_SIZE has to be a power of 2 or 0" + #endif + #if RX_BUFFER_SIZE > 256 + typedef uint16_t ring_buffer_pos_t; + #else + typedef uint8_t ring_buffer_pos_t; #endif struct ring_buffer_r { unsigned char buffer[RX_BUFFER_SIZE]; - volatile uint8_t head; - volatile uint8_t tail; + volatile ring_buffer_pos_t head; + volatile ring_buffer_pos_t tail; }; #if TX_BUFFER_SIZE > 0 @@ -118,6 +123,24 @@ #endif #endif + #if ENABLED(SERIAL_XON_XOFF) + #define XON_XOFF_CHAR_SENT (uint8_t)0x80 /* XON / XOFF Character was sent */ + #define XON_XOFF_CHAR_MASK (uint8_t)0x1F /* XON / XOFF character to send */ + + extern uint8_t xon_xoff_state; + + // XON / XOFF character definitions + #define XON_CHAR (uint8_t)17 + #define XOFF_CHAR (uint8_t)19 + #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: @@ -127,13 +150,21 @@ 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(uint8_t c); + + #if ENABLED(SERIAL_STATS_DROPPED_RX) + static uint32_t dropped() { return rx_dropped_bytes; } + #endif + #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED) + static ring_buffer_pos_t rxMaxEnqueued() { return rx_max_enqueued; } + #endif private: static void printNumber(unsigned long, const uint8_t); diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index 185dfb413..af16c9500 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -13329,6 +13329,12 @@ void loop() { // M29 closes the file card.closefile(); SERIAL_PROTOCOLLNPGM(MSG_FILE_SAVED); + #if ENABLED(SERIAL_STATS_DROPPED_RX) + SERIAL_ECHOLNPAIR("Dropped bytes: ", MarlinSerial::dropped()); + #endif + #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED) + SERIAL_ECHOLNPAIR("Max RX Queue Size: ", MarlinSerial::rxMaxEnqueued()); + #endif ok_to_send(); } else { From 2864ef8c7f6e06240a648b4ab827d67c1cd26443 Mon Sep 17 00:00:00 2001 From: etagle Date: Tue, 8 Aug 2017 02:57:55 -0300 Subject: [PATCH 6/8] Slight improvement to the line parsing logic, saving 8 cycles per character --- Marlin/Marlin_main.cpp | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index af16c9500..9d5963054 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -1094,9 +1094,10 @@ 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) { + int c; + while (commands_in_queue < BUFSIZE && (c = MYSERIAL.read()) >= 0) { - char serial_char = MYSERIAL.read(); + char serial_char = c; /** * If the character ends the line @@ -1196,9 +1197,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 ((c = MYSERIAL.read()) >= 0) { // if we have one more character, copy it over - serial_char = MYSERIAL.read(); + serial_char = c; if (!serial_comment_mode) serial_line_buffer[serial_count++] = serial_char; } // otherwise do nothing From 94caabf89ac8b5717251899efb3df521f18539f1 Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Mon, 2 Oct 2017 01:59:59 -0500 Subject: [PATCH 7/8] Add XON/XOFF options to example configs --- .../AlephObjects/TAZ4/Configuration.h | 3 ++- .../AlephObjects/TAZ4/Configuration_adv.h | 22 +++++++++++++++++++ .../AliExpress/CL-260/Configuration.h | 3 ++- .../Anet/A6/Configuration.h | 3 ++- .../Anet/A6/Configuration_adv.h | 22 +++++++++++++++++++ .../Anet/A8/Configuration.h | 3 ++- .../Anet/A8/Configuration_adv.h | 22 +++++++++++++++++++ .../BQ/Hephestos/Configuration.h | 3 ++- .../BQ/Hephestos/Configuration_adv.h | 22 +++++++++++++++++++ .../BQ/Hephestos_2/Configuration.h | 3 ++- .../BQ/Hephestos_2/Configuration_adv.h | 22 +++++++++++++++++++ .../BQ/WITBOX/Configuration.h | 3 ++- .../BQ/WITBOX/Configuration_adv.h | 22 +++++++++++++++++++ .../Cartesio/Configuration.h | 3 ++- .../Cartesio/Configuration_adv.h | 22 +++++++++++++++++++ .../Creality/CR-10/Configuration.h | 3 ++- .../Felix/Configuration.h | 3 ++- .../Felix/Configuration_adv.h | 22 +++++++++++++++++++ .../Felix/DUAL/Configuration.h | 3 ++- .../Folger Tech/i3-2020/Configuration.h | 3 ++- .../Folger Tech/i3-2020/Configuration_adv.h | 22 +++++++++++++++++++ .../Geeetech/GT2560/Configuration.h | 3 ++- .../Geeetech/I3_Pro_X-GT2560/Configuration.h | 3 ++- .../Infitary/i3-M508/Configuration.h | 3 ++- .../Infitary/i3-M508/Configuration_adv.h | 22 +++++++++++++++++++ .../Malyan/M150/Configuration.h | 3 ++- .../Malyan/M150/Configuration_adv.h | 22 +++++++++++++++++++ .../RepRapWorld/Megatronics/Configuration.h | 3 ++- .../RigidBot/Configuration.h | 3 ++- .../RigidBot/Configuration_adv.h | 22 +++++++++++++++++++ .../SCARA/Configuration.h | 3 ++- .../SCARA/Configuration_adv.h | 22 +++++++++++++++++++ .../TinyBoy2/Configuration.h | 3 ++- .../TinyBoy2/Configuration_adv.h | 22 +++++++++++++++++++ .../Velleman/K8200/Configuration.h | 3 ++- .../Velleman/K8200/Configuration_adv.h | 22 +++++++++++++++++++ .../Velleman/K8400/Configuration.h | 3 ++- .../Velleman/K8400/Configuration_adv.h | 22 +++++++++++++++++++ .../Velleman/K8400/Dual-head/Configuration.h | 3 ++- .../adafruit/ST7565/Configuration.h | 3 ++- .../FLSUN/auto_calibrate/Configuration.h | 3 ++- .../FLSUN/auto_calibrate/Configuration_adv.h | 22 +++++++++++++++++++ .../delta/FLSUN/kossel_mini/Configuration.h | 3 ++- .../FLSUN/kossel_mini/Configuration_adv.h | 22 +++++++++++++++++++ .../delta/generic/Configuration.h | 3 ++- .../delta/generic/Configuration_adv.h | 22 +++++++++++++++++++ .../delta/kossel_mini/Configuration.h | 3 ++- .../delta/kossel_mini/Configuration_adv.h | 22 +++++++++++++++++++ .../delta/kossel_pro/Configuration.h | 3 ++- .../delta/kossel_pro/Configuration_adv.h | 22 +++++++++++++++++++ .../delta/kossel_xl/Configuration.h | 3 ++- .../delta/kossel_xl/Configuration_adv.h | 22 +++++++++++++++++++ .../gCreate/gMax1.5+/Configuration.h | 3 ++- .../gCreate/gMax1.5+/Configuration_adv.h | 22 +++++++++++++++++++ .../makibox/Configuration.h | 3 ++- .../makibox/Configuration_adv.h | 22 +++++++++++++++++++ .../tvrrug/Round2/Configuration.h | 3 ++- .../tvrrug/Round2/Configuration_adv.h | 22 +++++++++++++++++++ .../wt150/Configuration.h | 3 ++- .../wt150/Configuration_adv.h | 22 +++++++++++++++++++ 60 files changed, 640 insertions(+), 34 deletions(-) diff --git a/Marlin/example_configurations/AlephObjects/TAZ4/Configuration.h b/Marlin/example_configurations/AlephObjects/TAZ4/Configuration.h index ce9250eb9..5e519dc49 100644 --- a/Marlin/example_configurations/AlephObjects/TAZ4/Configuration.h +++ b/Marlin/example_configurations/AlephObjects/TAZ4/Configuration.h @@ -107,8 +107,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/example_configurations/AlephObjects/TAZ4/Configuration_adv.h b/Marlin/example_configurations/AlephObjects/TAZ4/Configuration_adv.h index 5511b1187..0ae41fc8d 100644 --- a/Marlin/example_configurations/AlephObjects/TAZ4/Configuration_adv.h +++ b/Marlin/example_configurations/AlephObjects/TAZ4/Configuration_adv.h @@ -740,6 +740,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/example_configurations/AliExpress/CL-260/Configuration.h b/Marlin/example_configurations/AliExpress/CL-260/Configuration.h index 5cbd95adf..12f63bef1 100644 --- a/Marlin/example_configurations/AliExpress/CL-260/Configuration.h +++ b/Marlin/example_configurations/AliExpress/CL-260/Configuration.h @@ -107,8 +107,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/example_configurations/Anet/A6/Configuration.h b/Marlin/example_configurations/Anet/A6/Configuration.h index 319826393..8fa8104d2 100644 --- a/Marlin/example_configurations/Anet/A6/Configuration.h +++ b/Marlin/example_configurations/Anet/A6/Configuration.h @@ -107,8 +107,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 115200 diff --git a/Marlin/example_configurations/Anet/A6/Configuration_adv.h b/Marlin/example_configurations/Anet/A6/Configuration_adv.h index 265f54429..7f9c94a6b 100644 --- a/Marlin/example_configurations/Anet/A6/Configuration_adv.h +++ b/Marlin/example_configurations/Anet/A6/Configuration_adv.h @@ -740,6 +740,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/example_configurations/Anet/A8/Configuration.h b/Marlin/example_configurations/Anet/A8/Configuration.h index 537a90468..8fb99ba89 100644 --- a/Marlin/example_configurations/Anet/A8/Configuration.h +++ b/Marlin/example_configurations/Anet/A8/Configuration.h @@ -107,8 +107,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 115200 diff --git a/Marlin/example_configurations/Anet/A8/Configuration_adv.h b/Marlin/example_configurations/Anet/A8/Configuration_adv.h index ee2229416..19fc54c5d 100644 --- a/Marlin/example_configurations/Anet/A8/Configuration_adv.h +++ b/Marlin/example_configurations/Anet/A8/Configuration_adv.h @@ -740,6 +740,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/example_configurations/BQ/Hephestos/Configuration.h b/Marlin/example_configurations/BQ/Hephestos/Configuration.h index fd956dcdf..29eb64465 100644 --- a/Marlin/example_configurations/BQ/Hephestos/Configuration.h +++ b/Marlin/example_configurations/BQ/Hephestos/Configuration.h @@ -107,8 +107,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 115200 diff --git a/Marlin/example_configurations/BQ/Hephestos/Configuration_adv.h b/Marlin/example_configurations/BQ/Hephestos/Configuration_adv.h index 611336851..3561a15f0 100644 --- a/Marlin/example_configurations/BQ/Hephestos/Configuration_adv.h +++ b/Marlin/example_configurations/BQ/Hephestos/Configuration_adv.h @@ -740,6 +740,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/example_configurations/BQ/Hephestos_2/Configuration.h b/Marlin/example_configurations/BQ/Hephestos_2/Configuration.h index fdba13b24..1eabee6b7 100644 --- a/Marlin/example_configurations/BQ/Hephestos_2/Configuration.h +++ b/Marlin/example_configurations/BQ/Hephestos_2/Configuration.h @@ -106,8 +106,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 115200 diff --git a/Marlin/example_configurations/BQ/Hephestos_2/Configuration_adv.h b/Marlin/example_configurations/BQ/Hephestos_2/Configuration_adv.h index adde1b841..74f211220 100644 --- a/Marlin/example_configurations/BQ/Hephestos_2/Configuration_adv.h +++ b/Marlin/example_configurations/BQ/Hephestos_2/Configuration_adv.h @@ -740,6 +740,28 @@ // :[0, 2, 4, 8, 16, 32, 64, 128, 256] #define TX_BUFFER_SIZE 32 +// 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/example_configurations/BQ/WITBOX/Configuration.h b/Marlin/example_configurations/BQ/WITBOX/Configuration.h index b8fbc1266..cd7aa4b57 100644 --- a/Marlin/example_configurations/BQ/WITBOX/Configuration.h +++ b/Marlin/example_configurations/BQ/WITBOX/Configuration.h @@ -107,8 +107,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 115200 diff --git a/Marlin/example_configurations/BQ/WITBOX/Configuration_adv.h b/Marlin/example_configurations/BQ/WITBOX/Configuration_adv.h index 611336851..3561a15f0 100644 --- a/Marlin/example_configurations/BQ/WITBOX/Configuration_adv.h +++ b/Marlin/example_configurations/BQ/WITBOX/Configuration_adv.h @@ -740,6 +740,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/example_configurations/Cartesio/Configuration.h b/Marlin/example_configurations/Cartesio/Configuration.h index 9360232d6..ea9b2df8f 100644 --- a/Marlin/example_configurations/Cartesio/Configuration.h +++ b/Marlin/example_configurations/Cartesio/Configuration.h @@ -107,8 +107,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 115200 diff --git a/Marlin/example_configurations/Cartesio/Configuration_adv.h b/Marlin/example_configurations/Cartesio/Configuration_adv.h index f8d170dca..e0f008510 100644 --- a/Marlin/example_configurations/Cartesio/Configuration_adv.h +++ b/Marlin/example_configurations/Cartesio/Configuration_adv.h @@ -740,6 +740,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/example_configurations/Creality/CR-10/Configuration.h b/Marlin/example_configurations/Creality/CR-10/Configuration.h index b4817e4ae..6d1228046 100644 --- a/Marlin/example_configurations/Creality/CR-10/Configuration.h +++ b/Marlin/example_configurations/Creality/CR-10/Configuration.h @@ -107,8 +107,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 115200 diff --git a/Marlin/example_configurations/Felix/Configuration.h b/Marlin/example_configurations/Felix/Configuration.h index 5b99d6dba..24b062f31 100644 --- a/Marlin/example_configurations/Felix/Configuration.h +++ b/Marlin/example_configurations/Felix/Configuration.h @@ -107,8 +107,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/example_configurations/Felix/Configuration_adv.h b/Marlin/example_configurations/Felix/Configuration_adv.h index b954f1ddb..d97235319 100644 --- a/Marlin/example_configurations/Felix/Configuration_adv.h +++ b/Marlin/example_configurations/Felix/Configuration_adv.h @@ -740,6 +740,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/example_configurations/Felix/DUAL/Configuration.h b/Marlin/example_configurations/Felix/DUAL/Configuration.h index eeaaf0e7f..e77fd4968 100644 --- a/Marlin/example_configurations/Felix/DUAL/Configuration.h +++ b/Marlin/example_configurations/Felix/DUAL/Configuration.h @@ -107,8 +107,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/example_configurations/Folger Tech/i3-2020/Configuration.h b/Marlin/example_configurations/Folger Tech/i3-2020/Configuration.h index b0a875840..e931714e6 100644 --- a/Marlin/example_configurations/Folger Tech/i3-2020/Configuration.h +++ b/Marlin/example_configurations/Folger Tech/i3-2020/Configuration.h @@ -107,8 +107,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/example_configurations/Folger Tech/i3-2020/Configuration_adv.h b/Marlin/example_configurations/Folger Tech/i3-2020/Configuration_adv.h index 2bd673901..4900c734c 100644 --- a/Marlin/example_configurations/Folger Tech/i3-2020/Configuration_adv.h +++ b/Marlin/example_configurations/Folger Tech/i3-2020/Configuration_adv.h @@ -740,6 +740,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/example_configurations/Geeetech/GT2560/Configuration.h b/Marlin/example_configurations/Geeetech/GT2560/Configuration.h index 6cbc46bc0..d30ff17a0 100644 --- a/Marlin/example_configurations/Geeetech/GT2560/Configuration.h +++ b/Marlin/example_configurations/Geeetech/GT2560/Configuration.h @@ -107,8 +107,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/example_configurations/Geeetech/I3_Pro_X-GT2560/Configuration.h b/Marlin/example_configurations/Geeetech/I3_Pro_X-GT2560/Configuration.h index d7e024dce..e15e74074 100644 --- a/Marlin/example_configurations/Geeetech/I3_Pro_X-GT2560/Configuration.h +++ b/Marlin/example_configurations/Geeetech/I3_Pro_X-GT2560/Configuration.h @@ -107,8 +107,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/example_configurations/Infitary/i3-M508/Configuration.h b/Marlin/example_configurations/Infitary/i3-M508/Configuration.h index 872870a76..d84acc0a4 100644 --- a/Marlin/example_configurations/Infitary/i3-M508/Configuration.h +++ b/Marlin/example_configurations/Infitary/i3-M508/Configuration.h @@ -107,8 +107,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/example_configurations/Infitary/i3-M508/Configuration_adv.h b/Marlin/example_configurations/Infitary/i3-M508/Configuration_adv.h index eb7127285..a5753a022 100644 --- a/Marlin/example_configurations/Infitary/i3-M508/Configuration_adv.h +++ b/Marlin/example_configurations/Infitary/i3-M508/Configuration_adv.h @@ -740,6 +740,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/example_configurations/Malyan/M150/Configuration.h b/Marlin/example_configurations/Malyan/M150/Configuration.h index 501738266..416843fc9 100644 --- a/Marlin/example_configurations/Malyan/M150/Configuration.h +++ b/Marlin/example_configurations/Malyan/M150/Configuration.h @@ -112,8 +112,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 115200 diff --git a/Marlin/example_configurations/Malyan/M150/Configuration_adv.h b/Marlin/example_configurations/Malyan/M150/Configuration_adv.h index 11403a7fb..ea988ee62 100644 --- a/Marlin/example_configurations/Malyan/M150/Configuration_adv.h +++ b/Marlin/example_configurations/Malyan/M150/Configuration_adv.h @@ -740,6 +740,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/example_configurations/RepRapWorld/Megatronics/Configuration.h b/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h index 0f575a8fc..6fc961edb 100644 --- a/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h +++ b/Marlin/example_configurations/RepRapWorld/Megatronics/Configuration.h @@ -107,8 +107,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/example_configurations/RigidBot/Configuration.h b/Marlin/example_configurations/RigidBot/Configuration.h index ea744e8e8..40cd0b802 100644 --- a/Marlin/example_configurations/RigidBot/Configuration.h +++ b/Marlin/example_configurations/RigidBot/Configuration.h @@ -107,8 +107,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 115200 diff --git a/Marlin/example_configurations/RigidBot/Configuration_adv.h b/Marlin/example_configurations/RigidBot/Configuration_adv.h index 565ac51bf..6fd68174b 100644 --- a/Marlin/example_configurations/RigidBot/Configuration_adv.h +++ b/Marlin/example_configurations/RigidBot/Configuration_adv.h @@ -740,6 +740,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/example_configurations/SCARA/Configuration.h b/Marlin/example_configurations/SCARA/Configuration.h index aa5dcdac6..57618d78d 100644 --- a/Marlin/example_configurations/SCARA/Configuration.h +++ b/Marlin/example_configurations/SCARA/Configuration.h @@ -137,8 +137,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/example_configurations/SCARA/Configuration_adv.h b/Marlin/example_configurations/SCARA/Configuration_adv.h index 09771987b..c4df15ce9 100644 --- a/Marlin/example_configurations/SCARA/Configuration_adv.h +++ b/Marlin/example_configurations/SCARA/Configuration_adv.h @@ -740,6 +740,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/example_configurations/TinyBoy2/Configuration.h b/Marlin/example_configurations/TinyBoy2/Configuration.h index 480ba0a7a..bf4a1ef42 100644 --- a/Marlin/example_configurations/TinyBoy2/Configuration.h +++ b/Marlin/example_configurations/TinyBoy2/Configuration.h @@ -123,8 +123,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 115200 diff --git a/Marlin/example_configurations/TinyBoy2/Configuration_adv.h b/Marlin/example_configurations/TinyBoy2/Configuration_adv.h index f590111ee..72a1409e2 100644 --- a/Marlin/example_configurations/TinyBoy2/Configuration_adv.h +++ b/Marlin/example_configurations/TinyBoy2/Configuration_adv.h @@ -740,6 +740,28 @@ // :[0, 2, 4, 8, 16, 32, 64, 128, 256] #define TX_BUFFER_SIZE 64 +// 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/example_configurations/Velleman/K8200/Configuration.h b/Marlin/example_configurations/Velleman/K8200/Configuration.h index 959713d3d..00c572ff5 100644 --- a/Marlin/example_configurations/Velleman/K8200/Configuration.h +++ b/Marlin/example_configurations/Velleman/K8200/Configuration.h @@ -123,8 +123,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/example_configurations/Velleman/K8200/Configuration_adv.h b/Marlin/example_configurations/Velleman/K8200/Configuration_adv.h index 94f87feed..d69282e7e 100644 --- a/Marlin/example_configurations/Velleman/K8200/Configuration_adv.h +++ b/Marlin/example_configurations/Velleman/K8200/Configuration_adv.h @@ -753,6 +753,28 @@ // :[0, 2, 4, 8, 16, 32, 64, 128, 256] #define TX_BUFFER_SIZE 128 +// 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/example_configurations/Velleman/K8400/Configuration.h b/Marlin/example_configurations/Velleman/K8400/Configuration.h index 48ed7f53f..3aa5121ab 100644 --- a/Marlin/example_configurations/Velleman/K8400/Configuration.h +++ b/Marlin/example_configurations/Velleman/K8400/Configuration.h @@ -107,8 +107,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/example_configurations/Velleman/K8400/Configuration_adv.h b/Marlin/example_configurations/Velleman/K8400/Configuration_adv.h index d910ab8ea..fe0c1c365 100644 --- a/Marlin/example_configurations/Velleman/K8400/Configuration_adv.h +++ b/Marlin/example_configurations/Velleman/K8400/Configuration_adv.h @@ -740,6 +740,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/example_configurations/Velleman/K8400/Dual-head/Configuration.h b/Marlin/example_configurations/Velleman/K8400/Dual-head/Configuration.h index 1c24b7217..4672eb8f6 100644 --- a/Marlin/example_configurations/Velleman/K8400/Dual-head/Configuration.h +++ b/Marlin/example_configurations/Velleman/K8400/Dual-head/Configuration.h @@ -107,8 +107,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/example_configurations/adafruit/ST7565/Configuration.h b/Marlin/example_configurations/adafruit/ST7565/Configuration.h index 4c99ee2f1..d8c72a98e 100644 --- a/Marlin/example_configurations/adafruit/ST7565/Configuration.h +++ b/Marlin/example_configurations/adafruit/ST7565/Configuration.h @@ -107,8 +107,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/example_configurations/delta/FLSUN/auto_calibrate/Configuration.h b/Marlin/example_configurations/delta/FLSUN/auto_calibrate/Configuration.h index 643d2e2ee..9e1746376 100644 --- a/Marlin/example_configurations/delta/FLSUN/auto_calibrate/Configuration.h +++ b/Marlin/example_configurations/delta/FLSUN/auto_calibrate/Configuration.h @@ -107,8 +107,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/example_configurations/delta/FLSUN/auto_calibrate/Configuration_adv.h b/Marlin/example_configurations/delta/FLSUN/auto_calibrate/Configuration_adv.h index 9f2bba659..003528ba5 100644 --- a/Marlin/example_configurations/delta/FLSUN/auto_calibrate/Configuration_adv.h +++ b/Marlin/example_configurations/delta/FLSUN/auto_calibrate/Configuration_adv.h @@ -742,6 +742,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/example_configurations/delta/FLSUN/kossel_mini/Configuration.h b/Marlin/example_configurations/delta/FLSUN/kossel_mini/Configuration.h index 82de18e31..fdcecb96f 100644 --- a/Marlin/example_configurations/delta/FLSUN/kossel_mini/Configuration.h +++ b/Marlin/example_configurations/delta/FLSUN/kossel_mini/Configuration.h @@ -107,8 +107,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/example_configurations/delta/FLSUN/kossel_mini/Configuration_adv.h b/Marlin/example_configurations/delta/FLSUN/kossel_mini/Configuration_adv.h index fdc226633..85fa5e2a9 100644 --- a/Marlin/example_configurations/delta/FLSUN/kossel_mini/Configuration_adv.h +++ b/Marlin/example_configurations/delta/FLSUN/kossel_mini/Configuration_adv.h @@ -742,6 +742,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/example_configurations/delta/generic/Configuration.h b/Marlin/example_configurations/delta/generic/Configuration.h index ce2b8ceec..2ff7f1232 100644 --- a/Marlin/example_configurations/delta/generic/Configuration.h +++ b/Marlin/example_configurations/delta/generic/Configuration.h @@ -107,8 +107,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/example_configurations/delta/generic/Configuration_adv.h b/Marlin/example_configurations/delta/generic/Configuration_adv.h index fdc226633..85fa5e2a9 100644 --- a/Marlin/example_configurations/delta/generic/Configuration_adv.h +++ b/Marlin/example_configurations/delta/generic/Configuration_adv.h @@ -742,6 +742,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/example_configurations/delta/kossel_mini/Configuration.h b/Marlin/example_configurations/delta/kossel_mini/Configuration.h index 75c03f697..3103a7db8 100644 --- a/Marlin/example_configurations/delta/kossel_mini/Configuration.h +++ b/Marlin/example_configurations/delta/kossel_mini/Configuration.h @@ -107,8 +107,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/example_configurations/delta/kossel_mini/Configuration_adv.h b/Marlin/example_configurations/delta/kossel_mini/Configuration_adv.h index fdc226633..85fa5e2a9 100644 --- a/Marlin/example_configurations/delta/kossel_mini/Configuration_adv.h +++ b/Marlin/example_configurations/delta/kossel_mini/Configuration_adv.h @@ -742,6 +742,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/example_configurations/delta/kossel_pro/Configuration.h b/Marlin/example_configurations/delta/kossel_pro/Configuration.h index 259c923d0..d0927c9f2 100644 --- a/Marlin/example_configurations/delta/kossel_pro/Configuration.h +++ b/Marlin/example_configurations/delta/kossel_pro/Configuration.h @@ -111,8 +111,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 115200 diff --git a/Marlin/example_configurations/delta/kossel_pro/Configuration_adv.h b/Marlin/example_configurations/delta/kossel_pro/Configuration_adv.h index c01524728..400fad527 100644 --- a/Marlin/example_configurations/delta/kossel_pro/Configuration_adv.h +++ b/Marlin/example_configurations/delta/kossel_pro/Configuration_adv.h @@ -747,6 +747,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/example_configurations/delta/kossel_xl/Configuration.h b/Marlin/example_configurations/delta/kossel_xl/Configuration.h index 4231be068..af3845f45 100644 --- a/Marlin/example_configurations/delta/kossel_xl/Configuration.h +++ b/Marlin/example_configurations/delta/kossel_xl/Configuration.h @@ -107,8 +107,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/example_configurations/delta/kossel_xl/Configuration_adv.h b/Marlin/example_configurations/delta/kossel_xl/Configuration_adv.h index a41212a88..87aeef112 100644 --- a/Marlin/example_configurations/delta/kossel_xl/Configuration_adv.h +++ b/Marlin/example_configurations/delta/kossel_xl/Configuration_adv.h @@ -742,6 +742,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/example_configurations/gCreate/gMax1.5+/Configuration.h b/Marlin/example_configurations/gCreate/gMax1.5+/Configuration.h index a870e8da8..b7f58a33e 100644 --- a/Marlin/example_configurations/gCreate/gMax1.5+/Configuration.h +++ b/Marlin/example_configurations/gCreate/gMax1.5+/Configuration.h @@ -107,8 +107,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/example_configurations/gCreate/gMax1.5+/Configuration_adv.h b/Marlin/example_configurations/gCreate/gMax1.5+/Configuration_adv.h index f32a9354d..126cecb65 100644 --- a/Marlin/example_configurations/gCreate/gMax1.5+/Configuration_adv.h +++ b/Marlin/example_configurations/gCreate/gMax1.5+/Configuration_adv.h @@ -740,6 +740,28 @@ // :[0, 2, 4, 8, 16, 32, 64, 128, 256] #define TX_BUFFER_SIZE 32 +// 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/example_configurations/makibox/Configuration.h b/Marlin/example_configurations/makibox/Configuration.h index 02f33df03..ed30cb8af 100644 --- a/Marlin/example_configurations/makibox/Configuration.h +++ b/Marlin/example_configurations/makibox/Configuration.h @@ -107,8 +107,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/example_configurations/makibox/Configuration_adv.h b/Marlin/example_configurations/makibox/Configuration_adv.h index 8a568f2f8..b7e442ad0 100644 --- a/Marlin/example_configurations/makibox/Configuration_adv.h +++ b/Marlin/example_configurations/makibox/Configuration_adv.h @@ -740,6 +740,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/example_configurations/tvrrug/Round2/Configuration.h b/Marlin/example_configurations/tvrrug/Round2/Configuration.h index 8212beb07..55e40fa49 100644 --- a/Marlin/example_configurations/tvrrug/Round2/Configuration.h +++ b/Marlin/example_configurations/tvrrug/Round2/Configuration.h @@ -107,8 +107,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/example_configurations/tvrrug/Round2/Configuration_adv.h b/Marlin/example_configurations/tvrrug/Round2/Configuration_adv.h index 0f75b95c7..1e0e279dc 100644 --- a/Marlin/example_configurations/tvrrug/Round2/Configuration_adv.h +++ b/Marlin/example_configurations/tvrrug/Round2/Configuration_adv.h @@ -740,6 +740,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/example_configurations/wt150/Configuration.h b/Marlin/example_configurations/wt150/Configuration.h index 2c468a942..651b7cf65 100644 --- a/Marlin/example_configurations/wt150/Configuration.h +++ b/Marlin/example_configurations/wt150/Configuration.h @@ -107,8 +107,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 115200 diff --git a/Marlin/example_configurations/wt150/Configuration_adv.h b/Marlin/example_configurations/wt150/Configuration_adv.h index 3501c7157..4a39effc3 100644 --- a/Marlin/example_configurations/wt150/Configuration_adv.h +++ b/Marlin/example_configurations/wt150/Configuration_adv.h @@ -740,6 +740,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 From 4e19ff75b6d211961454f2df00443b1fa260d07a Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Mon, 2 Oct 2017 00:26:56 -0500 Subject: [PATCH 8/8] XON/XOFF corrections, tweaks, formatting, etc. --- Marlin/Configuration.h | 2 +- Marlin/Configuration_adv.h | 31 +-- Marlin/MarlinSerial.cpp | 395 +++++++++++++++++-------------------- Marlin/MarlinSerial.h | 72 +++---- Marlin/Marlin_main.cpp | 17 +- Marlin/macros.h | 2 +- 6 files changed, 228 insertions(+), 291 deletions(-) diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h index 3f3a83648..d4075fedc 100644 --- a/Marlin/Configuration.h +++ b/Marlin/Configuration.h @@ -107,7 +107,7 @@ * * 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 file transfer to the SD card + * You may try up to 1000000 to speed up SD file transfer. * * :[2400, 9600, 19200, 38400, 57600, 115200, 250000, 500000, 1000000] */ diff --git a/Marlin/Configuration_adv.h b/Marlin/Configuration_adv.h index 1a627a0dd..33a9ca48f 100644 --- a/Marlin/Configuration_adv.h +++ b/Marlin/Configuration_adv.h @@ -740,24 +740,27 @@ // :[0, 2, 4, 8, 16, 32, 64, 128, 256] #define TX_BUFFER_SIZE 0 -// Reception from Host Buffer Size -// This is the size of the Reception buffer. If XON/XOFF software flow control -// is not enabled, then 32 bytes should be enough. But if you plan to use XON/XOFF -// you need 1024 bytes at least. +// 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 +//#define RX_BUFFER_SIZE 1024 -// This setting determines if the printer will send the XON/XOFF -// control characters to the host to signal RX buffer is becoming full -#define SERIAL_XON_XOFF 1 +#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 -// This setting determines if you want to display and collect -// maximum RX queue usage after transferring a file to the SD -//#define SERIAL_STATS_MAX_RX_QUEUED 1 +#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 -// This setting determines if you want to display and collect -// the number of dropped bytes after a file transfer to the SD -#define SERIAL_STATS_DROPPED_RX 1 + // 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. diff --git a/Marlin/MarlinSerial.cpp b/Marlin/MarlinSerial.cpp index 8a881db22..778125818 100644 --- a/Marlin/MarlinSerial.cpp +++ b/Marlin/MarlinSerial.cpp @@ -27,15 +27,30 @@ * 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) */ -#include "MarlinSerial.h" -#include "Marlin.h" - // Disable HardwareSerial.cpp to support chips without a UART (Attiny, etc.) +#include "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,15 +60,21 @@ #endif #if ENABLED(SERIAL_XON_XOFF) - uint8_t xon_xoff_state = XON_XOFF_CHAR_SENT | XON_CHAR; + 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; + uint8_t rx_dropped_bytes = 0; #endif + #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED) - ring_buffer_pos_t rx_max_enqueued = 0; - #endif + ring_buffer_pos_t rx_max_enqueued = 0; + #endif #if ENABLED(EMERGENCY_PARSER) @@ -149,92 +170,76 @@ 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); + 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) { + // 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; + 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 + } + } } - 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 - if (rx_max_enqueued < rx_count) - 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 we already sent it - 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)) - ; - M_UDRx = XOFF_CHAR; - - // And remember we already sent it - xon_xoff_state = XOFF_CHAR | XON_XOFF_CHAR_SENT; - - #endif - } - - } - } - #endif + #endif // SERIAL_XON_XOFF #if ENABLED(EMERGENCY_PARSER) emergency_parser(c); @@ -247,52 +252,39 @@ // If interrupts are enabled, there must be more data in the output // buffer. - #if ENABLED(SERIAL_XON_XOFF) - - // If we must do a priority insertion of an XON/XOFF char, - // do it now - 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; + #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; + } - #if ENABLED(SERIAL_XON_XOFF) - } - #endif - // 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) { - store_rxd_char(); - } + ISR(M_USARTx_RX_vect) { store_rxd_char(); } #endif // Public Methods @@ -302,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 @@ -339,9 +331,9 @@ void MarlinSerial::checkRx(void) { if (TEST(M_UCSRxA, M_RXCx)) { - CRITICAL_SECTION_START; + CRITICAL_SECTION_START; store_rxd_char(); - CRITICAL_SECTION_END; + CRITICAL_SECTION_END; } } @@ -361,35 +353,21 @@ else { v = rx_buffer.buffer[t]; rx_buffer.tail = (ring_buffer_pos_t)(t + 1) & (RX_BUFFER_SIZE - 1); - - #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) == XOFF_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 below 10% of RX buffer capacity, send XON before - // we run out of RX buffer bytes - if (rx_count < (RX_BUFFER_SIZE/10)) { - - // Send an XON character - xon_xoff_state = XON_CHAR | XON_XOFF_CHAR_SENT; - - // End critical section - CRITICAL_SECTION_END; - - // Transmit the XON character - writeNoHandshake(XON_CHAR); - - // Done - return v; - } - } - #endif - + + #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; @@ -397,68 +375,53 @@ ring_buffer_pos_t MarlinSerial::available(void) { CRITICAL_SECTION_START; - const ring_buffer_pos_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 (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) - - // 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) == XOFF_CHAR) { - - // Send an XON character - xon_xoff_state = XON_CHAR | XON_XOFF_CHAR_SENT; - - // Transmit the XON character - writeNoHandshake(XON_CHAR); - } - #endif + + #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) - uint8_t state = xon_xoff_state; - if (!(state & XON_XOFF_CHAR_SENT)) { - // 2 characters to send: The XON/XOFF character and the user - // specified char. - writeNoHandshake(state & XON_XOFF_CHAR_MASK); - xon_xoff_state = state | XON_XOFF_CHAR_SENT; - } - #endif - writeNoHandshake(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(uint8_t c) { - + + void MarlinSerial::writeNoHandshake(const uint8_t c) { _written = true; CRITICAL_SECTION_START; bool emty = (tx_buffer.head == tx_buffer.tail); CRITICAL_SECTION_END; - + // If the buffer and the 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 (> @@ -497,7 +460,6 @@ return; } - void MarlinSerial::flushTX(void) { // TX // If we have never written a byte, no need to flush. This special @@ -516,35 +478,32 @@ } // 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) { - - #if ENABLED(SERIAL_XON_XOFF) - // If we must do a priority insertion of an XON/XOFF char, do it now - 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); + #else // TX_BUFFER_SIZE == 0 + + void MarlinSerial::write(const uint8_t 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(uint8_t c) { - while (!TEST(M_UCSRxA, M_UDREx)) - ; + while (!TEST(M_UCSRxA, M_UDREx)) {/* nada */} 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); diff --git a/Marlin/MarlinSerial.h b/Marlin/MarlinSerial.h index b0de0bb87..a6c4728ce 100644 --- a/Marlin/MarlinSerial.h +++ b/Marlin/MarlinSerial.h @@ -84,61 +84,32 @@ #ifndef RX_BUFFER_SIZE #define RX_BUFFER_SIZE 128 #endif - #if ENABLED(SERIAL_XON_XOFF) && RX_BUFFER_SIZE < 1024 - #error "XON/XOFF requires a 1024 or greater RX_BUFFER_SIZE for allowing reliable transfers without drops" - #endif #ifndef TX_BUFFER_SIZE #define TX_BUFFER_SIZE 32 #endif - #if !IS_POWEROF2(RX_BUFFER_SIZE) || (RX_BUFFER_SIZE < 2) - #error "RX_BUFFER_SIZE has to be a power of 2 and >= 2" - #endif - #if TX_BUFFER_SIZE != 0 && (TX_BUFFER_SIZE < 2 || TX_BUFFER_SIZE > 256 || !IS_POWEROF2(TX_BUFFER_SIZE)) - #error "TX_BUFFER_SIZE has to be a power of 2 or 0" - #endif - #if RX_BUFFER_SIZE > 256 - typedef uint16_t ring_buffer_pos_t; - #else - typedef uint8_t ring_buffer_pos_t; - #endif - - struct ring_buffer_r { - unsigned char buffer[RX_BUFFER_SIZE]; - volatile ring_buffer_pos_t head; - volatile ring_buffer_pos_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 ENABLED(SERIAL_XON_XOFF) && RX_BUFFER_SIZE < 1024 + #error "XON/XOFF requires RX_BUFFER_SIZE >= 1024 for reliable transfers without drops." #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 !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 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 ENABLED(SERIAL_XON_XOFF) - #define XON_XOFF_CHAR_SENT (uint8_t)0x80 /* XON / XOFF Character was sent */ - #define XON_XOFF_CHAR_MASK (uint8_t)0x1F /* XON / XOFF character to send */ - - extern uint8_t xon_xoff_state; - - // XON / XOFF character definitions - #define XON_CHAR (uint8_t)17 - #define XOFF_CHAR (uint8_t)19 + #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; + extern uint8_t rx_dropped_bytes; #endif + #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED) - extern ring_buffer_pos_t rx_max_enqueued; + extern ring_buffer_pos_t rx_max_enqueued; #endif class MarlinSerial { //: public Stream @@ -157,14 +128,15 @@ static uint8_t availableForWrite(void); static void flushTX(void); #endif - static void writeNoHandshake(uint8_t c); + static void writeNoHandshake(const uint8_t c); - #if ENABLED(SERIAL_STATS_DROPPED_RX) - static uint32_t dropped() { return rx_dropped_bytes; } - #endif - #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED) - static ring_buffer_pos_t rxMaxEnqueued() { return rx_max_enqueued; } - #endif + #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 private: static void printNumber(unsigned long, const uint8_t); diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp index 9d5963054..043480aa7 100644 --- a/Marlin/Marlin_main.cpp +++ b/Marlin/Marlin_main.cpp @@ -1097,7 +1097,7 @@ inline void get_serial_commands() { int c; while (commands_in_queue < BUFSIZE && (c = MYSERIAL.read()) >= 0) { - char serial_char = c; + char serial_char = c; /** * If the character ends the line @@ -13330,12 +13330,15 @@ void loop() { // M29 closes the file card.closefile(); SERIAL_PROTOCOLLNPGM(MSG_FILE_SAVED); - #if ENABLED(SERIAL_STATS_DROPPED_RX) - SERIAL_ECHOLNPAIR("Dropped bytes: ", MarlinSerial::dropped()); - #endif - #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED) - SERIAL_ECHOLNPAIR("Max RX Queue Size: ", MarlinSerial::rxMaxEnqueued()); - #endif + + #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 { diff --git a/Marlin/macros.h b/Marlin/macros.h index 9c45ba38e..05433597f 100644 --- a/Marlin/macros.h +++ b/Marlin/macros.h @@ -100,7 +100,7 @@ #define SET_BIT(n,b,value) (n) ^= ((-value)^(n)) & (_BV(b)) // Macro to check that a number if a power if 2 -#define IS_POWEROF2(x) ((x) && !((x) & ((x) - 1))) +#define IS_POWER_OF_2(x) ((x) && !((x) & ((x) - 1))) // Macros for maths shortcuts #ifndef M_PI