Adding XON/XOFF and STATISTICS implementation

Marlin/Configuration.h

  *
  * 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
 

Marlin/MarlinSerial.cpp

     #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"
 
   #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);
 
     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
 
   #ifdef M_USARTx_RX_vect
     ISR(M_USARTx_RX_vect) {
-      const unsigned char c = M_UDRx;
-      store_char(c);
+      store_rxd_char();
     }
   #endif
 
 
   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;
     }
   }
 
   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) {
     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
     }
 
     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 (>
       return;
     }
 
+	
     void MarlinSerial::flushTX(void) {
       // TX
       // If we have never written a byte, no need to flush. This special
 
   #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;

Marlin/MarlinSerial.h

   #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
     #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:
       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);

Marlin/Marlin_main.cpp

           // 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 {