Multi-host support

Marlin/Configuration.h

 #define SERIAL_PORT 0
 
 /**
+ * Select a secondary serial port on the board to use for communication with the host.
+ * This allows the connection of wireless adapters (for instance) to non-default port pins.
+ * Serial port -1 is the USB emulated serial port, if avaialble.
+ *
+ * :[-1, 0, 1, 2, 3, 4, 5, 6, 7]
+ */
+#define SERIAL_PORT_2 -1
+
+/**
  * This setting determines the communication speed of the printer.
  *
  * 250000 works in most cases, but you might try a lower speed if

Marlin/src/HAL/HAL_AVR/HAL_AVR.cpp

 // Includes
 // --------------------------------------------------------------------------
 
-#include "../HAL.h"
-#include "../../core/macros.h"
+#include "../../inc/MarlinConfig.h"
 
 // --------------------------------------------------------------------------
 // Externals

Marlin/src/HAL/HAL_AVR/HAL_AVR.h

 #include "watchdog_AVR.h"
 #include "math_AVR.h"
 
+#ifdef USBCON
+  #include "HardwareSerial.h"
+#else
+  #include "MarlinSerial.h"
+#endif
+
 // --------------------------------------------------------------------------
 // Defines
 // --------------------------------------------------------------------------
 
 //extern uint8_t MCUSR;
 
+#define NUM_SERIAL 1
+
+#ifdef USBCON
+  #if ENABLED(BLUETOOTH)
+    #define MYSERIAL0 bluetoothSerial
+  #else
+    #define MYSERIAL0 Serial
+  #endif
+#else
+  #define MYSERIAL0 customizedSerial
+#endif
+
 // --------------------------------------------------------------------------
 // Public functions
 // --------------------------------------------------------------------------

Marlin/src/HAL/HAL_AVR/HAL_pinsDebug_AVR.h

       for (uint8_t y = 0; y < 28; y++) {                   // always print pin name
         temp_char = pgm_read_byte(name_mem_pointer + y);
         if (temp_char != 0)
-          MYSERIAL.write(temp_char);
+          SERIAL_CHAR(temp_char);
         else {
-          for (uint8_t i = 0; i < 28 - y; i++) MYSERIAL.write(' ');
+          for (uint8_t i = 0; i < 28 - y; i++) SERIAL_CHAR(' ');
           break;
         }
       }

Marlin/src/HAL/HAL_AVR/pinsDebug_AVR_8_bit.h

   for (uint8_t y = 0; y < MAX_NAME_LENGTH; y++) {
     char temp_char = pgm_read_byte(name_mem_pointer + y);
     if (temp_char != 0)
-      MYSERIAL.write(temp_char);
+      SERIAL_CHAR(temp_char);
     else {
-      for (uint8_t i = 0; i < MAX_NAME_LENGTH - y; i++) MYSERIAL.write(' ');
+      for (uint8_t i = 0; i < MAX_NAME_LENGTH - y; i++) SERIAL_CHAR(' ');
       break;
     }
   }

Marlin/src/HAL/HAL_DUE/EepromEmulation_Due.cpp

     char buffer[80];
 
     sprintf(buffer, "Page: %d (0x%04x)\n", page, page);
-    MYSERIAL.print(buffer);
+    SERIAL_PROTOCOL(buffer);
 
     char* p = &buffer[0];
     for (int i = 0; i< PageSize; ++i) {
       if ((i & 15) == 15) {
         *p++ = '\n';
         *p = 0;
-        MYSERIAL.print(buffer);
+        SERIAL_PROTOCOL(buffer);
         p = &buffer[0];
       }
     }
     SERIAL_ECHOLNPAIR("EEPROM PageWrite   ",page);
     SERIAL_ECHOLNPAIR(" in FLASH address ",(uint32_t)addrflash);
     SERIAL_ECHOLNPAIR(" base address     ",(uint32_t)getFlashStorage(0));
-    MYSERIAL.flush();
+    SERIAL_FLUSH();
   #endif
 
   // Get the page relative to the start of the EFC controller, and the EFC controller to use
     SERIAL_ECHOLNPAIR("EEPROM PageErase  ",page);
     SERIAL_ECHOLNPAIR(" in FLASH address ",(uint32_t)addrflash);
     SERIAL_ECHOLNPAIR(" base address     ",(uint32_t)getFlashStorage(0));
-    MYSERIAL.flush();
+    SERIAL_FLUSH();
   #endif
 
   // Get the page relative to the start of the EFC controller, and the EFC controller to use
   #ifdef EE_EMU_DEBUG
     SERIAL_ECHO_START();
     SERIAL_ECHOLNPAIR("EEPROM Current Group: ",curGroup);
-    MYSERIAL.flush();
+    SERIAL_FLUSH();
   #endif
 
   // Now, validate that all the other group pages are empty
           SERIAL_ECHO_START();
           SERIAL_ECHOPAIR("EEPROM Page ",page);
           SERIAL_ECHOLNPAIR(" not clean on group ",grp);
-          MYSERIAL.flush();
+          SERIAL_FLUSH();
         #endif
         ee_PageErase(grp * PagesPerGroup + page);
       }
   #ifdef EE_EMU_DEBUG
     SERIAL_ECHO_START();
     SERIAL_ECHOLNPAIR("EEPROM Active page: ",curPage);
-    MYSERIAL.flush();
+    SERIAL_FLUSH();
   #endif
 
   // Make sure the pages following the first clean one are also clean
         SERIAL_ECHO_START();
         SERIAL_ECHOPAIR("EEPROM Page ",page);
         SERIAL_ECHOLNPAIR(" not clean on active group ",curGroup);
-        MYSERIAL.flush();
+        SERIAL_FLUSH();
         ee_Dump(curGroup * PagesPerGroup + page, getFlashStorage(curGroup * PagesPerGroup + page));
       #endif
       ee_PageErase(curGroup * PagesPerGroup + page);

Marlin/src/HAL/HAL_DUE/HAL_Due.h

 //
 // Defines
 //
-#if SERIAL_PORT >= -1 && SERIAL_PORT <= 4
-  #define MYSERIAL customizedSerial
+#define NUM_SERIAL 1
+
+//#undef SERIAL_PORT
+//#define SERIAL_PORT -1
+
+#if SERIAL_PORT == -1
+  #define MYSERIAL0 SerialUSB
+#else
+  #define MYSERIAL0 customizedSerial
 #endif
 
 // We need the previous define before the include, or compilation bombs...
 void HAL_enable_AdcFreerun(void);
 //void HAL_disable_AdcFreerun(uint8_t chan);
 
+/**
+ * Pin Map
+ */
+
 #define GET_PIN_MAP_PIN(index) index
 #define GET_PIN_MAP_INDEX(pin) pin
 #define PARSED_PIN_INDEX(code, dval) parser.intval(code, dval)

Marlin/src/HAL/HAL_LPC1768/HAL.cpp

 
 HalSerial usb_serial;
 
-//u8glib required fucntions
+// U8glib required functions
 extern "C" void u8g_xMicroDelay(uint16_t val) {
   delayMicroseconds(val);
 }
   pin_t pin = analogInputToDigitalPin(ch);
 
   if (pin == -1) {
-    MYSERIAL.printf("%sINVALID ANALOG PORT:%d\n", errormagic, ch);
+    SERIAL_PRINTF("%sINVALID ANALOG PORT:%d\n", errormagic, ch);
     kill(MSG_KILLED);
   }
 
                               pin_port == 1                        ? 3 : 10;
 
   switch (pin_sel_register) {
-    case 1 :
+    case 1:
       LPC_PINCON->PINSEL1 &= ~(0x3 << pinsel_start_bit);
       LPC_PINCON->PINSEL1 |=  (0x1 << pinsel_start_bit);
       break;
-    case 3 :
+    case 3:
       LPC_PINCON->PINSEL3 &= ~(0x3 << pinsel_start_bit);
       LPC_PINCON->PINSEL3 |=  (0x3 << pinsel_start_bit);
       break;
-    case 0 :
+    case 0:
       LPC_PINCON->PINSEL0 &= ~(0x3 << pinsel_start_bit);
       LPC_PINCON->PINSEL0 |=  (0x2 << pinsel_start_bit);
       break;
 uint8_t active_adc = 0;
 void HAL_adc_start_conversion(const uint8_t ch) {
   if (analogInputToDigitalPin(ch) == -1) {
-    MYSERIAL.printf("HAL: HAL_adc_start_conversion: invalid channel %d\n", ch);
+    SERIAL_PRINTF("HAL: HAL_adc_start_conversion: invalid channel %d\n", ch);
     return;
   }
 

Marlin/src/HAL/HAL_LPC1768/HAL.h

 #define ST7920_DELAY_2 DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP
 #define ST7920_DELAY_3 DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP;DELAY_5_NOP
 
-//Serial override
 extern HalSerial usb_serial;
 
+#if !WITHIN(SERIAL_PORT, -1, 3)
+  #error "SERIAL_PORT must be from -1 to 3"
+#endif
+
 #if SERIAL_PORT == -1
-  #define MYSERIAL usb_serial
+  #define MYSERIAL0 usb_serial
 #elif SERIAL_PORT == 0
-  #define MYSERIAL Serial
+  #define MYSERIAL0 Serial
 #elif SERIAL_PORT == 1
-  #define MYSERIAL Serial1
+  #define MYSERIAL0 Serial1
 #elif SERIAL_PORT == 2
-  #define MYSERIAL Serial2
+  #define MYSERIAL0 Serial2
 #elif SERIAL_PORT == 3
-  #define MYSERIAL Serial3
+  #define MYSERIAL0 Serial3
+#endif
+
+#ifdef SERIAL_PORT_2
+  #if !WITHIN(SERIAL_PORT_2, -1, 3)
+    #error "SERIAL_PORT_2 must be from -1 to 3"
+  #elif SERIAL_PORT_2 == SERIAL_PORT
+    #error "SERIAL_PORT_2 must be different than SERIAL_PORT"
+  #endif
+  #define NUM_SERIAL 2
+  #if SERIAL_PORT_2 == -1
+    #define MYSERIAL1 usb_serial
+  #elif SERIAL_PORT_2 == 0
+    #define MYSERIAL1 Serial
+  #elif SERIAL_PORT_2 == 1
+    #define MYSERIAL1 Serial1
+  #elif SERIAL_PORT_2 == 2
+    #define MYSERIAL1 Serial2
+  #elif SERIAL_PORT_2 == 3
+    #define MYSERIAL1 Serial3
+  #endif
+#else
+  #define NUM_SERIAL 1
 #endif
 
 #define CRITICAL_SECTION_START  uint32_t primask = __get_PRIMASK(); __disable_irq();

Marlin/src/HAL/HAL_LPC1768/arduino.cpp

     if (LPC1768_PWM_attach_pin(pin, 1, LPC_PWM1->MR0, 0xFF))
       LPC1768_PWM_write(pin, map(value, 0, 255, 1, LPC_PWM1->MR0));  // map 1-254 onto PWM range
     else {                                                                 // out of PWM channels
-      if (!out_of_PWM_slots) MYSERIAL.printf(".\nWARNING - OUT OF PWM CHANNELS\n.\n");  //only warn once
+      if (!out_of_PWM_slots) SERIAL_ECHOPGM(".\nWARNING - OUT OF PWM CHANNELS\n.\n");  //only warn once
       out_of_PWM_slots = true;
       digitalWrite(pin, value);  // treat as a digital pin if out of channels
     }

Marlin/src/HAL/HAL_LPC1768/main.cpp

     #endif
   }
 
-  // Only initialize the debug framework if using the USB emulated serial port
-  if ((HalSerial*) &MYSERIAL == &usb_serial)
-    debug_frmwrk_init();
-
-  MYSERIAL.begin(BAUDRATE);
-  MYSERIAL.printf("\n\nLPC1768 (%dMhz) UART0 Initialised\n", SystemCoreClock / 1000000);
-  #if TX_BUFFER_SIZE > 0
-    MYSERIAL.flushTX();
+  #if NUM_SERIAL > 0
+    MYSERIAL0.begin(BAUDRATE);
+    #if NUM_SERIAL > 1
+      MYSERIAL1.begin(BAUDRATE);
+    #endif
+    SERIAL_PRINTF("\n\nLPC1768 (%dMhz) UART0 Initialised\n", SystemCoreClock / 1000000);
+    SERIAL_FLUSHTX();
   #endif
 
   HAL_timer_init();

Marlin/src/HAL/HAL_LPC1768/serial.h

  *
  */
 
-#ifndef HAL_SERIAL_H_
-#define HAL_SERIAL_H_
+#ifndef _HAL_SERIAL_H_
+#define _HAL_SERIAL_H_
 
 #include <stdarg.h>
 #include <stdio.h>
 #include <debug_frmwrk.h>
 }
 
-/*
+/**
  * Generic RingBuffer
  * T type of the buffer array
  * S size of the buffer (must be power of 2)
  */
 template <typename T, uint32_t S> class RingBuffer {
 public:
-  RingBuffer() {
-    index_read = 0;
-    index_write = 0;
-  }
+  RingBuffer() { index_read = index_write = 0; }
+  uint32_t available() volatile { return buffer_mask & (index_write - index_read); }
+  uint32_t free() volatile      { return buffer_size - available(); }
+  bool empty() volatile         { return (buffer_mask & index_read) == (buffer_mask & index_write); }
+  bool full() volatile          { return index_read == buffer_mask & (index_write + 1); }
+  void clear() volatile         { index_read = index_write = 0; }
   bool peek(T *value) volatile {
-    if(value == 0 || available() == 0)
+    if (value == 0 || available() == 0)
       return false;
     *value = buffer[buffer_mask & index_read];
     return true;
   }
-  uint32_t available() volatile {
-    return buffer_mask & (index_write - index_read);
-  }
-  uint32_t free() volatile {
-    return buffer_size - available();
-  }
-  T read() volatile {
-    if((buffer_mask & index_read) == (buffer_mask & index_write)) return T(-1);
+  int read() volatile {
+    if ((buffer_mask & index_read) == (buffer_mask & index_write)) return -1;
     T val = buffer[buffer_mask & index_read];
     ++index_read;
     return val;
   }
-  bool write( T value) volatile {
+  bool write(T value) volatile {
     uint32_t next_head = buffer_mask & (index_write + 1);
-    if(next_head != index_read) {
+    if (next_head != index_read) {
       buffer[buffer_mask & index_write] = value;
       index_write = next_head;
       return true;
     }
     return false;
   }
-  bool empty() volatile {
-    return (buffer_mask & index_read) == (buffer_mask & index_write);
-  }
-  bool full() volatile {
-    return index_read == buffer_mask & (index_write + 1);
-  }
-  void clear() volatile {
-    index_read = index_write = 0;
-  }
 
 private:
   static const uint32_t buffer_size = S;
 
 class HalSerial {
 public:
-  HalSerial() {
-    host_connected = false;
-  }
+  HalSerial() { host_connected = false; }
 
   void begin(int32_t baud) {
   }
 
-  char read() {
-    return (char)receive_buffer.read();
+  int peek() {
+    uint8_t value;
+    return receive_buffer.peek(&value) ? value : -1;
   }
 
-  void write(char c) {
-    _DBC(c); //Duplicate output over uart0
-    if(host_connected) transmit_buffer.write((uint8_t)c);
-  }
+  int read() { return receive_buffer.read(); }
 
-  operator bool() {
-    return host_connected;
-  }
+  size_t write(char c) { return host_connected ? transmit_buffer.write((uint8_t)c) : 0; }
+
+  operator bool() { return host_connected; }
 
   uint16_t available() {
     return (uint16_t)receive_buffer.available();
   }
 
-  void flush() {
-    receive_buffer.clear();
-  }
+  void flush() { receive_buffer.clear(); }
 
   uint8_t availableForWrite(void){
     return transmit_buffer.free() > 255 ? 255 : (uint8_t)transmit_buffer.free();
   }
 
   void flushTX(void){
-    if(host_connected) {
-      while(transmit_buffer.available());
-    }
+    if (host_connected)
+      while (transmit_buffer.available()) { /* nada */ }
   }
 
   void printf(const char *format, ...) {
     int length = vsnprintf((char *) buffer, 256, (char const *) format, vArgs);
     va_end(vArgs);
     if (length > 0 && length < 256) {
-      _DBG(buffer); //Duplicate output over uart0
       if (host_connected) {
         for (int i = 0; i < length;) {
           if (transmit_buffer.write(buffer[i])) {
   #define BIN 2
   #define BYTE 0
 
-
   void print_bin(uint32_t value, uint8_t num_digits) {
     uint32_t mask = 1 << (num_digits -1);
     for (uint8_t i = 0; i < num_digits; i++) {
-      if (!(i % 4) && i)    printf(" ");
-      if (!(i % 16)  && i)  printf(" ");
-      if (value & mask)     printf("1");
-      else                  printf("0");
+      if (!(i % 4) && i)    write(' ');
+      if (!(i % 16)  && i)  write(' ');
+      if (value & mask)     write('1');
+      else                  write('0');
       value <<= 1;
     }
   }
 
-  void print(const char value[]) {
-    printf("%s" , value);
-  }
+  void print(const char value[]) { printf("%s" , value); }
   void print(char value, int nbase = BYTE) {
-    if (nbase == BIN) print_bin(value,8);
+    if (nbase == BIN) print_bin(value, 8);
     else if (nbase == OCT) printf("%3o", value);
     else if (nbase == HEX) printf("%2X", value);
     else if (nbase == DEC ) printf("%d", value);
     else printf("%c" , value);
   }
   void print(unsigned char value, int nbase = BYTE) {
-    if (nbase == BIN) print_bin(value,8);
+    if (nbase == BIN) print_bin(value, 8);
     else if (nbase == OCT) printf("%3o", value);
     else if (nbase == HEX) printf("%2X", value);
     else printf("%u" , value);
   }
   void print(int value, int nbase = BYTE) {
-    if (nbase == BIN) print_bin(value,16);
+    if (nbase == BIN) print_bin(value, 16);
     else if (nbase == OCT) printf("%6o", value);
     else if (nbase == HEX) printf("%4X", value);
     else printf("%d", value);
   }
   void print(unsigned int value, int nbase = BYTE) {
-    if (nbase == BIN) print_bin(value,16);
+    if (nbase == BIN) print_bin(value, 16);
     else if (nbase == OCT) printf("%6o", value);
     else if (nbase == HEX) printf("%4X", value);
     else printf("%u" , value);
   }
   void print(long value, int nbase = BYTE) {
-    if (nbase == BIN) print_bin(value,32);
+    if (nbase == BIN) print_bin(value, 32);
     else if (nbase == OCT) printf("%11o", value);
     else if (nbase == HEX) printf("%8X", value);
     else printf("%ld" , value);
   }
   void print(unsigned long value, int nbase = BYTE) {
-    if (nbase == BIN) print_bin(value,32);
+    if (nbase == BIN) print_bin(value, 32);
     else if (nbase == OCT) printf("%11o", value);
     else if (nbase == HEX) printf("%8X", value);
     else printf("%lu" , value);
   }
-  void print(float value, int round = 6) {
-    printf("%f" , value);
-  }
-  void print(double value, int round = 6) {
-    printf("%f" , value );
-  }
+  void print(float value, int round = 6)  { printf("%f" , value); }
+  void print(double value, int round = 6) { printf("%f" , value); }
 
-
-
-  void println(const char value[]) {
-    printf("%s\n" , value);
-  }
-  void println(char value, int nbase = BYTE) {
-    print(value, nbase);
-    println();
-  }
-  void println(unsigned char value, int nbase = BYTE) {
-    print(value, nbase);
-    println();
-  }
-  void println(int value, int nbase = BYTE) {
-    print(value, nbase);
-    println();
-  }
-  void println(unsigned int value, int nbase = BYTE) {
-    print(value, nbase);
-    println();
-  }
-  void println(long value, int nbase = BYTE) {
-    print(value, nbase);
-    println();
-  }
-  void println(unsigned long value, int nbase = BYTE) {
-    print(value, nbase);
-    println();
-  }
-  void println(float value, int round = 6) {
-    printf("%f\n" , value );
-  }
-  void println(double value, int round = 6) {
-    printf("%f\n" , value );
-  }
-  void println(void) {
-    print('\n');
-  }
+  void println(const char value[]) { printf("%s\n" , value); }
+  void println(char value, int nbase = BYTE) { print(value, nbase); println(); }
+  void println(unsigned char value, int nbase = BYTE) { print(value, nbase); println(); }
+  void println(int value, int nbase = BYTE) { print(value, nbase); println(); }
+  void println(unsigned int value, int nbase = BYTE) { print(value, nbase); println(); }
+  void println(long value, int nbase = BYTE) { print(value, nbase); println(); }
+  void println(unsigned long value, int nbase = BYTE) { print(value, nbase); println(); }
+  void println(float value, int round = 6) { printf("%f\n" , value); }
+  void println(double value, int round = 6) { printf("%f\n" , value); }
+  void println(void) { print('\n'); }
 
   volatile RingBuffer<uint8_t, 128> receive_buffer;
   volatile RingBuffer<uint8_t, 128> transmit_buffer;
   volatile bool host_connected;
 };
 
-
-#endif /* MARLIN_SRC_HAL_HAL_SERIAL_H_ */
+#endif // _HAL_SERIAL_H_

Marlin/src/HAL/HAL_STM32F1/HAL_Stm32f1.h

 // Defines
 // --------------------------------------------------------------------------
 
+#if !WITHIN(SERIAL_PORT, -1, 3)
+  #error "SERIAL_PORT must be from -1 to 3"
+#endif
 #if SERIAL_PORT == -1
-  #define MYSERIAL SerialUSB
+  #define MYSERIAL0 SerialUSB
 #elif SERIAL_PORT == 0
-  #define MYSERIAL Serial
+  #define MYSERIAL0 Serial
 #elif SERIAL_PORT == 1
-  #define MYSERIAL Serial1
+  #define MYSERIAL0 Serial1
 #elif SERIAL_PORT == 2
-  #define MYSERIAL Serial2
+  #define MYSERIAL0 Serial2
 #elif SERIAL_PORT == 3
-  #define MYSERIAL Serial3
+  #define MYSERIAL0 Serial3
+#endif
+
+#ifdef SERIAL_PORT_2
+  #if !WITHIN(SERIAL_PORT_2, -1, 3)
+    #error "SERIAL_PORT_2 must be from -1 to 3"
+  #elif SERIAL_PORT_2 == SERIAL_PORT
+    #error "SERIAL_PORT_2 must be different than SERIAL_PORT"
+  #endif
+  #define NUM_SERIAL 2
+  #if SERIAL_PORT_2 == -1
+    #define MYSERIAL1 SerialUSB
+  #elif SERIAL_PORT_2 == 0
+    #define MYSERIAL1 Serial
+  #elif SERIAL_PORT_2 == 1
+    #define MYSERIAL1 Serial1
+  #elif SERIAL_PORT_2 == 2
+    #define MYSERIAL1 Serial2
+  #elif SERIAL_PORT_2 == 3
+    #define MYSERIAL1 Serial3
+  #endif
+#else
+  #define NUM_SERIAL 1
 #endif
 
 /**

Marlin/src/HAL/HAL_TEENSY35_36/HAL_Teensy.h

 #define IS_TEENSY35 defined(__MK64FX512__)
 #define IS_TEENSY36 defined(__MK66FX1M0__)
 
+#define NUM_SERIAL 1
+
 #if SERIAL_PORT == -1
-  #define MYSERIAL SerialUSB
+  #define MYSERIAL0 SerialUSB
 #elif SERIAL_PORT == 0
-  #define MYSERIAL Serial
+  #define MYSERIAL0 Serial
 #elif SERIAL_PORT == 1
-  #define MYSERIAL Serial1
+  #define MYSERIAL0 Serial1
 #elif SERIAL_PORT == 2
-  #define MYSERIAL Serial2
+  #define MYSERIAL0 Serial2
 #elif SERIAL_PORT == 3
-  #define MYSERIAL Serial3
+  #define MYSERIAL0 Serial3
 #endif
 
 #define HAL_SERVO_LIB libServo

Marlin/src/Marlin.cpp

     disableStepperDrivers();
   #endif
 
-  MYSERIAL.begin(BAUDRATE);
-  uint32_t serial_connect_timeout = millis() + 1000;
-  while(!MYSERIAL && PENDING(millis(), serial_connect_timeout));
+  #if NUM_SERIAL > 0
+    MYSERIAL0.begin(BAUDRATE);
+    #if NUM_SERIAL > 1
+      MYSERIAL1.begin(BAUDRATE);
+    #endif
+  #endif
+
+  #if NUM_SERIAL > 0
+    uint32_t serial_connect_timeout = millis() + 1000UL;
+    while(!MYSERIAL0 && PENDING(millis(), serial_connect_timeout)) { /*nada*/ }
+    #if NUM_SERIAL > 1
+      serial_connect_timeout = millis() + 1000UL;
+      while(!MYSERIAL1 && PENDING(millis(), serial_connect_timeout)) { /*nada*/ }
+    #endif
+  #endif
+
   SERIAL_PROTOCOLLNPGM("start");
   SERIAL_ECHO_START();
 

Marlin/src/core/serial.cpp

 const char errormagic[] PROGMEM = "Error:";
 const char echomagic[] PROGMEM = "echo:";
 
+#if NUM_SERIAL > 1
+  void serialprintPGM_P(const int8_t p, const char * str) {
+    while (char ch = pgm_read_byte(str++)) SERIAL_CHAR_P(p, ch);
+  }
+
+  void serial_echopair_PGM_P(const int8_t p, const char* s_P, const char *v)   { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
+  void serial_echopair_PGM_P(const int8_t p, const char* s_P, char v)          { serialprintPGM_P(p, s_P); SERIAL_CHAR_P(p, v); }
+  void serial_echopair_PGM_P(const int8_t p, const char* s_P, int v)           { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
+  void serial_echopair_PGM_P(const int8_t p, const char* s_P, long v)          { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
+  void serial_echopair_PGM_P(const int8_t p, const char* s_P, float v)         { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
+  void serial_echopair_PGM_P(const int8_t p, const char* s_P, double v)        { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
+  void serial_echopair_PGM_P(const int8_t p, const char* s_P, unsigned int v)  { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
+  void serial_echopair_PGM_P(const int8_t p, const char* s_P, unsigned long v) { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
+
+  void serial_spaces_P(const int8_t p, uint8_t count) { count *= (PROPORTIONAL_FONT_RATIO); while (count--) SERIAL_CHAR_P(p, ' '); }
+#endif
 
 void serialprintPGM(const char * str) {
-  #ifdef TARGET_LPC1768
-    MYSERIAL.print(str);
-  #else
-    while (char ch = pgm_read_byte(str++)) MYSERIAL.write(ch);
-  #endif
+  while (char ch = pgm_read_byte(str++)) SERIAL_CHAR(ch);
 }
 
-void serial_echopair_P(const char* s_P, const char *v)   { serialprintPGM(s_P); SERIAL_ECHO(v); }
-void serial_echopair_P(const char* s_P, char v)          { serialprintPGM(s_P); SERIAL_CHAR(v); }
-void serial_echopair_P(const char* s_P, int v)           { serialprintPGM(s_P); SERIAL_ECHO(v); }
-void serial_echopair_P(const char* s_P, long v)          { serialprintPGM(s_P); SERIAL_ECHO(v); }
-void serial_echopair_P(const char* s_P, float v)         { serialprintPGM(s_P); SERIAL_ECHO(v); }
-void serial_echopair_P(const char* s_P, double v)        { serialprintPGM(s_P); SERIAL_ECHO(v); }
-void serial_echopair_P(const char* s_P, unsigned int v)  { serialprintPGM(s_P); SERIAL_ECHO(v); }
-void serial_echopair_P(const char* s_P, unsigned long v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
+void serial_echopair_PGM(const char* s_P, const char *v)   { serialprintPGM(s_P); SERIAL_ECHO(v); }
+void serial_echopair_PGM(const char* s_P, char v)          { serialprintPGM(s_P); SERIAL_CHAR(v); }
+void serial_echopair_PGM(const char* s_P, int v)           { serialprintPGM(s_P); SERIAL_ECHO(v); }
+void serial_echopair_PGM(const char* s_P, long v)          { serialprintPGM(s_P); SERIAL_ECHO(v); }
+void serial_echopair_PGM(const char* s_P, float v)         { serialprintPGM(s_P); SERIAL_ECHO(v); }
+void serial_echopair_PGM(const char* s_P, double v)        { serialprintPGM(s_P); SERIAL_ECHO(v); }
+void serial_echopair_PGM(const char* s_P, unsigned int v)  { serialprintPGM(s_P); SERIAL_ECHO(v); }
+void serial_echopair_PGM(const char* s_P, unsigned long v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
 
-void serial_spaces(uint8_t count) { count *= (PROPORTIONAL_FONT_RATIO); while (count--) MYSERIAL.write(' '); }
+void serial_spaces(uint8_t count) { count *= (PROPORTIONAL_FONT_RATIO); while (count--) SERIAL_CHAR(' '); }
 
 #if ENABLED(DEBUG_LEVELING_FEATURE)
 

Marlin/src/core/serial.h

     #include "../HAL/HAL_AVR/MarlinSerial.h"
     #define MYSERIAL customizedSerial
   #endif
-#endif
-
-#ifdef ARDUINO_ARCH_SAM
+#elif defined(ARDUINO_ARCH_SAM)
   // To pull the Serial port definitions and overrides
   #include "../HAL/HAL_DUE/MarlinSerial_Due.h"
 #endif
 extern const char echomagic[] PROGMEM;
 extern const char errormagic[] PROGMEM;
 
-#define SERIAL_CHAR(x) ((void)MYSERIAL.write(x))
+#if TX_BUFFER_SIZE < 1
+  #define SERIAL_FLUSHTX_P(p)
+  #define SERIAL_FLUSHTX()
+#endif
+
+#if NUM_SERIAL > 1
+  #define SERIAL_CHAR_P(p,x)          (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.write(x) : MYSERIAL1.write(x)) : SERIAL_CHAR(x))
+  #define SERIAL_PROTOCOL_P(p,x)      (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.print(x) : MYSERIAL1.print(x)) : SERIAL_PROTOCOL(x))
+  #define SERIAL_PROTOCOL_F_P(p,x,y)  (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.print(x,y) : MYSERIAL1.print(x,y)) : SERIAL_PROTOCOL_F(x,y))
+  #define SERIAL_PROTOCOLLN_P(p,x)    (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.println(x) : MYSERIAL1.println(x)) : SERIAL_PROTOCOLLN(x))
+  #define SERIAL_PRINT_P(p,x,b)       (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.print(x,b) : MYSERIAL1.print(x,b)) : SERIAL_PRINT(x,b))
+  #define SERIAL_PRINTLN_P(p,x,b)     (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.println(x,b) : MYSERIAL1.println(x,b)) : SERIAL_PRINTLN(x,b))
+  #define SERIAL_PRINTF_P(p,args...)  (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.printf(args) : MYSERIAL1.printf(args)) : SERIAL_PRINTF(args))
+
+  #define SERIAL_CHAR(x)              (MYSERIAL0.write(x), MYSERIAL1.write(x))
+  #define SERIAL_PROTOCOL(x)          (MYSERIAL0.print(x), MYSERIAL1.print(x))
+  #define SERIAL_PROTOCOL_F(x,y)      (MYSERIAL0.print(x,y), MYSERIAL1.print(x,y))
+  #define SERIAL_PROTOCOLLN(x)        (MYSERIAL0.println(x), MYSERIAL1.println(x))
+  #define SERIAL_PRINT(x,b)           (MYSERIAL0.print(x,b), MYSERIAL1.print(x,b))
+  #define SERIAL_PRINTLN(x,b)         (MYSERIAL0.println(x,b), MYSERIAL1.println(x,b))
+  #define SERIAL_PRINTF(args...)      (MYSERIAL0.printf(args), MYSERIAL1.printf(args))
+
+  #define SERIAL_FLUSH_P(p)           (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.flush() : MYSERIAL1.flush()) : SERIAL_FLUSH())
+  #define SERIAL_FLUSH()              (MYSERIAL0.flush(), MYSERIAL1.flush())
+  #if TX_BUFFER_SIZE > 0
+    #define SERIAL_FLUSHTX_P(p)       (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.flushTX() : MYSERIAL1.flushTX()) : SERIAL_FLUSHTX())
+    #define SERIAL_FLUSHTX()          (MYSERIAL0.flushTX(), MYSERIAL1.flushTX())
+  #endif
+
+  #define SERIAL_EOL_P(p) SERIAL_CHAR_P(p,'\n')
+  
+  #define SERIAL_PROTOCOLCHAR_P(p,x)              SERIAL_CHAR_P(p,x)
+  #define SERIAL_PROTOCOLPGM_P(p,x)               (serialprintPGM_P(p,PSTR(x)))
+  #define SERIAL_PROTOCOLLNPGM_P(p,x)             (serialprintPGM_P(p,PSTR(x "\n")))
+  #define SERIAL_PROTOCOLPAIR_P(p, pre, value)    (serial_echopair_PGM_P(p,PSTR(pre),(value)))
+  #define SERIAL_PROTOCOLLNPAIR_P(p, pre, value)  do { SERIAL_PROTOCOLPAIR_P(p, pre, value); SERIAL_EOL_P(p); } while(0)
+  
+  #define SERIAL_ECHO_START_P(p)             (serialprintPGM_P(p,echomagic))
+  #define SERIAL_ECHO_P(p,x)                 SERIAL_PROTOCOL_P(p,x)
+  #define SERIAL_ECHOPGM_P(p,x)              SERIAL_PROTOCOLPGM_P(p,x)
+  #define SERIAL_ECHOLN_P(p,x)               SERIAL_PROTOCOLLN_P(p,x)
+  #define SERIAL_ECHOLNPGM_P(p,x)            SERIAL_PROTOCOLLNPGM_P(p,x)
+  #define SERIAL_ECHOPAIR_P(p,pre,value)     SERIAL_PROTOCOLPAIR_P(p, pre, value)
+  #define SERIAL_ECHOLNPAIR_P(p,pre, value)  SERIAL_PROTOCOLLNPAIR_P(p, pre, value)
+  #define SERIAL_ECHO_F_P(p,x,y)             SERIAL_PROTOCOL_F_P(p,x,y)
+  
+  #define SERIAL_ERROR_START_P(p)            (serialprintPGM_P(p,errormagic))
+  #define SERIAL_ERROR_P(p,x)                SERIAL_PROTOCOL_P(p,x)
+  #define SERIAL_ERRORPGM_P(p,x)             SERIAL_PROTOCOLPGM_P(p,x)
+  #define SERIAL_ERRORLN_P(p,x)              SERIAL_PROTOCOLLN_P(p,x)
+  #define SERIAL_ERRORLNPGM_P(p,x)           SERIAL_PROTOCOLLNPGM_P(p,x)
+  
+  // These macros compensate for float imprecision
+  #define SERIAL_PROTOCOLPAIR_F_P(p, pre, value)    SERIAL_PROTOCOLPAIR_P(p, pre, FIXFLOAT(value))
+  #define SERIAL_PROTOCOLLNPAIR_F_P(p, pre, value)  SERIAL_PROTOCOLLNPAIR_P(p, pre, FIXFLOAT(value))
+  #define SERIAL_ECHOPAIR_F_P(p,pre,value)          SERIAL_ECHOPAIR_P(p, pre, FIXFLOAT(value))
+  #define SERIAL_ECHOLNPAIR_F_P(p,pre, value)       SERIAL_ECHOLNPAIR_P(p, pre, FIXFLOAT(value))
+
+  void serial_echopair_PGM_P(const int8_t p, const char* s_P, const char *v);
+  void serial_echopair_PGM_P(const int8_t p, const char* s_P, char v);
+  void serial_echopair_PGM_P(const int8_t p, const char* s_P, int v);
+  void serial_echopair_PGM_P(const int8_t p, const char* s_P, long v);
+  void serial_echopair_PGM_P(const int8_t p, const char* s_P, float v);
+  void serial_echopair_PGM_P(const int8_t p, const char* s_P, double v);
+  void serial_echopair_PGM_P(const int8_t p, const char* s_P, unsigned int v);
+  void serial_echopair_PGM_P(const int8_t p, const char* s_P, unsigned long v);
+  FORCE_INLINE void serial_echopair_PGM_P(const int8_t p, const char* s_P, uint8_t v) { serial_echopair_PGM_P(p, s_P, (int)v); }
+  FORCE_INLINE void serial_echopair_PGM_P(const int8_t p, const char* s_P, bool v) { serial_echopair_PGM_P(p, s_P, (int)v); }
+  FORCE_INLINE void serial_echopair_PGM_P(const int8_t p, const char* s_P, void *v) { serial_echopair_PGM_P(p, s_P, (unsigned long)v); }
+
+  void serial_spaces_P(const int8_t p, uint8_t count);
+  #define SERIAL_ECHO_SP_P(p,C)     serial_spaces_P(p,C)
+  #define SERIAL_ERROR_SP_P(p,C)    serial_spaces_P(p,C)
+  #define SERIAL_PROTOCOL_SP_P(p,C) serial_spaces_P(p,C)
+
+  void serialprintPGM_P(const int8_t p, const char* str);
+#else
+  #define SERIAL_CHAR_P(p,x)          SERIAL_CHAR(x)
+  #define SERIAL_PROTOCOL_P(p,x)      SERIAL_PROTOCOL(x)
+  #define SERIAL_PROTOCOL_F_P(p,x,y)  SERIAL_PROTOCOL_F(x,y)
+  #define SERIAL_PROTOCOLLN_P(p,x)    SERIAL_PROTOCOLLN(x)
+  #define SERIAL_PRINT_P(p,x,b)       SERIAL_PRINT(x,b)
+  #define SERIAL_PRINTLN_P(p,x,b)     SERIAL_PRINTLN(x,b) 
+  #define SERIAL_PRINTF_P(p,args...)  SERIAL_PRINTF(args)
+
+  #define SERIAL_CHAR(x)              MYSERIAL0.write(x)
+  #define SERIAL_PROTOCOL(x)          MYSERIAL0.print(x)
+  #define SERIAL_PROTOCOL_F(x,y)      MYSERIAL0.print(x,y)
+  #define SERIAL_PROTOCOLLN(x)        MYSERIAL0.println(x)
+  #define SERIAL_PRINT(x,b)           MYSERIAL0.print(x,b)
+  #define SERIAL_PRINTLN(x,b)         MYSERIAL0.println(x,b)
+  #define SERIAL_PRINTF(args...)      MYSERIAL0.printf(args)
+
+  #define SERIAL_FLUSH_P(p)           SERIAL_FLUSH()
+  #define SERIAL_FLUSH()              MYSERIAL0.flush()
+  #if TX_BUFFER_SIZE > 0
+    #define SERIAL_FLUSHTX_P(p)       SERIAL_FLUSHTX()
+    #define SERIAL_FLUSHTX()          MYSERIAL0.flushTX()
+  #endif
+
+  #define SERIAL_EOL_P(p) SERIAL_EOL()
+  
+  #define SERIAL_PROTOCOLCHAR_P(p,x)              SERIAL_PROTOCOLCHAR(x)
+  #define SERIAL_PROTOCOLPGM_P(p,x)               SERIAL_PROTOCOLPGM(x)
+  #define SERIAL_PROTOCOLLNPGM_P(p,x)             SERIAL_PROTOCOLLNPGM(x)
+  #define SERIAL_PROTOCOLPAIR_P(p, pre, value)    SERIAL_PROTOCOLPAIR(pre, value)
+  #define SERIAL_PROTOCOLLNPAIR_P(p, pre, value)  SERIAL_PROTOCOLLNPAIR(pre, value)
+  
+  #define SERIAL_ECHO_START_P(p)             SERIAL_ECHO_START()
+  #define SERIAL_ECHO_P(p,x)                 SERIAL_ECHO(x)
+  #define SERIAL_ECHOPGM_P(p,x)              SERIAL_ECHOPGM(x)
+  #define SERIAL_ECHOLN_P(p,x)               SERIAL_ECHOLN(x)
+  #define SERIAL_ECHOLNPGM_P(p,x)            SERIAL_ECHOLNPGM(x)
+  #define SERIAL_ECHOPAIR_P(p,pre,value)     SERIAL_ECHOPAIR(pre, value)
+  #define SERIAL_ECHOLNPAIR_P(p,pre, value)  SERIAL_ECHOLNPAIR(pre, value)
+  #define SERIAL_ECHO_F_P(p,x,y)             SERIAL_ECHO_F(x,y)
+  
+  #define SERIAL_ERROR_START_P(p)            SERIAL_ERROR_START()
+  #define SERIAL_ERROR_P(p,x)                SERIAL_ERROR(x)
+  #define SERIAL_ERRORPGM_P(p,x)             SERIAL_ERRORPGM(x)
+  #define SERIAL_ERRORLN_P(p,x)              SERIAL_ERRORLN(x)
+  #define SERIAL_ERRORLNPGM_P(p,x)           SERIAL_ERRORLNPGM(x)
+  
+  // These macros compensate for float imprecision
+  #define SERIAL_PROTOCOLPAIR_F_P(p, pre, value)    SERIAL_PROTOCOLPAIR_F(pre, value)
+  #define SERIAL_PROTOCOLLNPAIR_F_P(p, pre, value)  SERIAL_PROTOCOLLNPAIR_F(pre, value)
+  #define SERIAL_ECHOPAIR_F_P(p,pre,value)          SERIAL_ECHOPAIR_F(pre, value)
+  #define SERIAL_ECHOLNPAIR_F_P(p,pre, value)       SERIAL_ECHOLNPAIR_F(pre, value)
+
+  #define serial_echopair_PGM_P(p,s_P,v)            serial_echopair_PGM(s_P, v)
+
+  #define serial_spaces_P(p,c)      serial_spaces(c)
+  #define SERIAL_ECHO_SP_P(p,C)     SERIAL_ECHO_SP(C)
+  #define SERIAL_ERROR_SP_P(p,C)    SERIAL_ERROR_SP(C)
+  #define SERIAL_PROTOCOL_SP_P(p,C) SERIAL_PROTOCOL_SP(C)
+
+  #define serialprintPGM_P(p,s)     serialprintPGM(s)
+#endif
+
 #define SERIAL_EOL() SERIAL_CHAR('\n')
 
 #define SERIAL_PROTOCOLCHAR(x)              SERIAL_CHAR(x)
-#define SERIAL_PROTOCOL(x)                  (MYSERIAL.print(x))
-#define SERIAL_PROTOCOL_F(x,y)              (MYSERIAL.print(x,y))
 #define SERIAL_PROTOCOLPGM(x)               (serialprintPGM(PSTR(x)))
-#define SERIAL_PROTOCOLLN(x)                do{ MYSERIAL.print(x); SERIAL_EOL(); }while(0)
 #define SERIAL_PROTOCOLLNPGM(x)             (serialprintPGM(PSTR(x "\n")))
-#define SERIAL_PROTOCOLPAIR(pre, value)     (serial_echopair_P(PSTR(pre),(value)))
-#define SERIAL_PROTOCOLLNPAIR(pre, value)   do{ SERIAL_PROTOCOLPAIR(pre, value); SERIAL_EOL(); }while(0)
+#define SERIAL_PROTOCOLPAIR(pre, value)     (serial_echopair_PGM(PSTR(pre), value))
+#define SERIAL_PROTOCOLLNPAIR(pre, value)   do { SERIAL_PROTOCOLPAIR(pre, value); SERIAL_EOL(); } while(0)
 
 #define SERIAL_ECHO_START()            (serialprintPGM(echomagic))
 #define SERIAL_ECHO(x)                 SERIAL_PROTOCOL(x)
 #define SERIAL_ECHOLNPGM(x)            SERIAL_PROTOCOLLNPGM(x)
 #define SERIAL_ECHOPAIR(pre,value)     SERIAL_PROTOCOLPAIR(pre, value)
 #define SERIAL_ECHOLNPAIR(pre, value)  SERIAL_PROTOCOLLNPAIR(pre, value)
-#define SERIAL_ECHO_F(x,y)             SERIAL_PROTOCOL_F(x,y)
+#define SERIAL_ECHO_F(x,y)             SERIAL_PROTOCOL_F(x, y)
 
 #define SERIAL_ERROR_START()           (serialprintPGM(errormagic))
 #define SERIAL_ERROR(x)                SERIAL_PROTOCOL(x)
 #define SERIAL_ECHOPAIR_F(pre,value)        SERIAL_ECHOPAIR(pre, FIXFLOAT(value))
 #define SERIAL_ECHOLNPAIR_F(pre, value)     SERIAL_ECHOLNPAIR(pre, FIXFLOAT(value))
 
-void serial_echopair_P(const char* s_P, const char *v);
-void serial_echopair_P(const char* s_P, char v);
-void serial_echopair_P(const char* s_P, int v);
-void serial_echopair_P(const char* s_P, long v);
-void serial_echopair_P(const char* s_P, float v);
-void serial_echopair_P(const char* s_P, double v);
-void serial_echopair_P(const char* s_P, unsigned int v);
-void serial_echopair_P(const char* s_P, unsigned long v);
-FORCE_INLINE void serial_echopair_P(const char* s_P, uint8_t v) { serial_echopair_P(s_P, (int)v); }
-FORCE_INLINE void serial_echopair_P(const char* s_P, bool v) { serial_echopair_P(s_P, (int)v); }
-FORCE_INLINE void serial_echopair_P(const char* s_P, void *v) { serial_echopair_P(s_P, (unsigned long)v); }
+void serial_echopair_PGM(const char* s_P, const char *v);
+void serial_echopair_PGM(const char* s_P, char v);
+void serial_echopair_PGM(const char* s_P, int v);
+void serial_echopair_PGM(const char* s_P, long v);
+void serial_echopair_PGM(const char* s_P, float v);
+void serial_echopair_PGM(const char* s_P, double v);
+void serial_echopair_PGM(const char* s_P, unsigned int v);
+void serial_echopair_PGM(const char* s_P, unsigned long v);
+FORCE_INLINE void serial_echopair_PGM(const char* s_P, uint8_t v) { serial_echopair_PGM(s_P, (int)v); }
+FORCE_INLINE void serial_echopair_PGM(const char* s_P, bool v) { serial_echopair_PGM(s_P, (int)v); }
+FORCE_INLINE void serial_echopair_PGM(const char* s_P, void *v) { serial_echopair_PGM(s_P, (unsigned long)v); }
 
 void serial_spaces(uint8_t count);
 #define SERIAL_ECHO_SP(C)     serial_spaces(C)
   #if HAS_ABL
     void print_xyz(const char* prefix, const char* suffix, const vector_3 &xyz);
   #endif
-  #define DEBUG_POS(SUFFIX,VAR) do { \
-    print_xyz(PSTR("  " STRINGIFY(VAR) "="), PSTR(" : " SUFFIX "\n"), VAR); }while(0)
+  #define DEBUG_POS(SUFFIX,VAR) do { print_xyz(PSTR("  " STRINGIFY(VAR) "="), PSTR(" : " SUFFIX "\n"), VAR); } while(0)
 #endif
 
 #endif // __SERIAL_H__

Marlin/src/feature/bedlevel/abl/abl.cpp

         c1 = z_values[x1][y1], c2 = z_values[x2][y2];
 
   // Treat far unprobed points as zero, near as equal to far
-  if (isnan(a2)) a2 = 0.0; if (isnan(a1)) a1 = a2;
-  if (isnan(b2)) b2 = 0.0; if (isnan(b1)) b1 = b2;
-  if (isnan(c2)) c2 = 0.0; if (isnan(c1)) c1 = c2;
+  if (isnan(a2)) a2 = 0.0;
+  if (isnan(a1)) a1 = a2;
+  if (isnan(b2)) b2 = 0.0;
+  if (isnan(b1)) b1 = b2;
+  if (isnan(c2)) c2 = 0.0;
+  if (isnan(c1)) c1 = c2;
 
   const float a = 2 * a1 - a2, b = 2 * b1 - b2, c = 2 * c1 - c2;
 

Marlin/src/feature/bedlevel/ubl/ubl.cpp

 
   uint8_t ubl_cnt = 0;
 
-  void unified_bed_leveling::echo_name() { SERIAL_PROTOCOLPGM("Unified Bed Leveling"); }
+  void unified_bed_leveling::echo_name(
+    #if NUM_SERIAL > 1
+      const int8_t port/*= -1*/
+    #endif
+  ) {
+    SERIAL_PROTOCOLPGM_P(port, "Unified Bed Leveling");
+  }
 
-  void unified_bed_leveling::report_state() {
-    echo_name();
-    SERIAL_PROTOCOLPGM(" System v" UBL_VERSION " ");
-    if (!planner.leveling_active) SERIAL_PROTOCOLPGM("in");
-    SERIAL_PROTOCOLLNPGM("active.");
+  void unified_bed_leveling::report_state(
+    #if NUM_SERIAL > 1
+      const int8_t port/*= -1*/
+    #endif
+  ) {
+    echo_name(
+      #if NUM_SERIAL > 1
+        port
+      #endif
+    );
+    SERIAL_PROTOCOLPGM_P(port, " System v" UBL_VERSION " ");
+    if (!planner.leveling_active) SERIAL_PROTOCOLPGM_P(port, "in");
+    SERIAL_PROTOCOLLNPGM_P(port, "active.");
     safe_delay(50);
   }
 
         }
         idle();
         if (map_type == 1 && i < GRID_MAX_POINTS_X - 1) SERIAL_CHAR(',');
-
-        #if TX_BUFFER_SIZE > 0
-          MYSERIAL.flushTX();
-        #endif
+        SERIAL_FLUSHTX();
         safe_delay(15);
         if (map_type == 0) {
           SERIAL_CHAR(is_current ? ']' : ' ');

Marlin/src/feature/bedlevel/ubl/ubl.h

 
   public:
 
-    static void echo_name();
-    static void report_state();
+    static void echo_name(
+      #if NUM_SERIAL > 1
+        const int8_t port = -1
+      #endif
+    );
+    static void report_state(
+      #if NUM_SERIAL > 1
+        const int8_t port = -1
+      #endif
+    );
     static void save_ubl_active_state_and_disable();
     static void restore_ubl_active_state_and_leave();
     static void display_map(const int);

Marlin/src/feature/tmc_util.cpp

       const uint32_t pwm_scale = get_pwm_scale(st);
       SERIAL_ECHO(axisID);
       SERIAL_ECHOPAIR(":", pwm_scale);
-      SERIAL_ECHO(" |0b"); MYSERIAL.print(get_status_response(st), BIN);
+      SERIAL_ECHO(" |0b"); SERIAL_PRINT(get_status_response(st), BIN);
       SERIAL_ECHO("| ");
       if (data.is_error) SERIAL_ECHO('E');
       else if (data.is_ot) SERIAL_ECHO('O');
       else if (data.is_otpw) SERIAL_ECHO('W');
-      else if (otpw_cnt>0) MYSERIAL.print(otpw_cnt, DEC);
+      else if (otpw_cnt>0) SERIAL_PRINT(otpw_cnt, DEC);
       else if (st.flag_otpw) SERIAL_ECHO('F');
       SERIAL_ECHO("\t");
     }

Marlin/src/gcode/eeprom/M500-M504.cpp

 #include "../../module/configuration_store.h"
 #include "../../inc/MarlinConfig.h"
 
+#if NUM_SERIAL > 1
+  #include "../../gcode/queue.h"
+#endif
+
 /**
  * M500: Store settings in EEPROM
  */
 void GcodeSuite::M500() {
-  (void)settings.save();
+  (void)settings.save(
+    #if ENABLED(EEPROM_CHITCHAT) && NUM_SERIAL > 1
+      command_queue_port[cmd_queue_index_r]
+    #endif
+  );
 }
 
 /**
  * M501: Read settings from EEPROM
  */
 void GcodeSuite::M501() {
-  (void)settings.load();
+  (void)settings.load(
+    #if ENABLED(EEPROM_SETTINGS) && ENABLED(EEPROM_CHITCHAT) && NUM_SERIAL > 1
+      command_queue_port[cmd_queue_index_r]
+    #endif
+  );
 }
 
 /**
  * M502: Revert to default settings
  */
 void GcodeSuite::M502() {
-  (void)settings.reset();
+  (void)settings.reset(
+    #if ENABLED(EEPROM_CHITCHAT) && NUM_SERIAL > 1
+      command_queue_port[cmd_queue_index_r]
+    #endif
+  );
 }
 
 #if DISABLED(DISABLE_M503)
    * M503: print settings currently in memory
    */
   void GcodeSuite::M503() {
-    (void)settings.report(parser.seen('S') && !parser.value_bool());
+    (void)settings.report(parser.seen('S') && !parser.value_bool()
+      #if NUM_SERIAL > 1
+        , command_queue_port[cmd_queue_index_r]
+      #endif
+    );
   }
 
 #endif // !DISABLE_M503

Marlin/src/gcode/feature/trinamic/M122.cpp

   SERIAL_ECHO(name);
   SERIAL_ECHOPGM(" = 0x");
   for(int B=24; B>=8; B-=8){
-    MYSERIAL.print((drv_status>>(B+4))&0xF, HEX);
-    MYSERIAL.print((drv_status>>B)&0xF, HEX);
-    MYSERIAL.print(':');
+    SERIAL_PRINT((drv_status>>(B+4))&0xF, HEX);
+    SERIAL_PRINT((drv_status>>B)&0xF, HEX);
+    SERIAL_CHAR(':');
   }
-  MYSERIAL.print((drv_status>>4)&0xF, HEX);
-  MYSERIAL.print((drv_status)&0xF, HEX);
+  SERIAL_PRINT((drv_status>>4)&0xF, HEX);
+  SERIAL_PRINT((drv_status)&0xF, HEX);
   SERIAL_EOL();
 }
 
 #if ENABLED(HAVE_TMC2130)
   static void tmc_status(TMC2130Stepper &st, const TMC_debug_enum i) {
     switch(i) {
-      case TMC_PWM_SCALE: MYSERIAL.print(st.PWM_SCALE(), DEC); break;
+      case TMC_PWM_SCALE: SERIAL_PRINT(st.PWM_SCALE(), DEC); break;
       case TMC_TSTEP: SERIAL_ECHO(st.TSTEP()); break;
-      case TMC_SGT: MYSERIAL.print(st.sgt(), DEC); break;
+      case TMC_SGT: SERIAL_PRINT(st.sgt(), DEC); break;
       case TMC_STEALTHCHOP: serialprintPGM(st.stealthChop() ? PSTR("true") : PSTR("false")); break;
       default: break;
     }
   static void tmc_parse_drv_status(TMC2130Stepper &st, const TMC_drv_status_enum i) {
     switch(i) {
       case TMC_STALLGUARD: if (st.stallguard()) SERIAL_ECHOPGM("X"); break;
-      case TMC_SG_RESULT:  MYSERIAL.print(st.sg_result(), DEC);      break;
+      case TMC_SG_RESULT:  SERIAL_PRINT(st.sg_result(), DEC);      break;
       case TMC_FSACTIVE:   if (st.fsactive())   SERIAL_ECHOPGM("X"); break;
       default: break;
     }
       case TMC_TSTEP: {
           uint32_t data = 0;
           st.TSTEP(&data);
-          MYSERIAL.print(data);
+          SERIAL_PROTOCOL(data);
           break;
         }
-      case TMC_PWM_SCALE: MYSERIAL.print(st.pwm_scale_sum(), DEC); break;
+      case TMC_PWM_SCALE: SERIAL_PRINT(st.pwm_scale_sum(), DEC); break;
       case TMC_STEALTHCHOP: serialprintPGM(st.stealth() ? PSTR("true") : PSTR("false")); break;
       case TMC_S2VSA: if (st.s2vsa()) SERIAL_ECHOPGM("X"); break;
       case TMC_S2VSB: if (st.s2vsb()) SERIAL_ECHOPGM("X"); break;
     case TMC_CODES: SERIAL_ECHO(extended_axis_codes[axis]); break;
     case TMC_ENABLED: serialprintPGM(st.isEnabled() ? PSTR("true") : PSTR("false")); break;
     case TMC_CURRENT: SERIAL_ECHO(st.getCurrent()); break;
-    case TMC_RMS_CURRENT: MYSERIAL.print(st.rms_current()); break;
-    case TMC_MAX_CURRENT: MYSERIAL.print((float)st.rms_current()*1.41, 0); break;
+    case TMC_RMS_CURRENT: SERIAL_PROTOCOL(st.rms_current()); break;
+    case TMC_MAX_CURRENT: SERIAL_PRINT((float)st.rms_current()*1.41, 0); break;
     case TMC_IRUN:
-      MYSERIAL.print(st.irun(), DEC);
+      SERIAL_PRINT(st.irun(), DEC);
       SERIAL_ECHOPGM("/31");
       break;
     case TMC_IHOLD:
-      MYSERIAL.print(st.ihold(), DEC);
+      SERIAL_PRINT(st.ihold(), DEC);
       SERIAL_ECHOPGM("/31");
       break;
     case TMC_CS_ACTUAL:
-      MYSERIAL.print(st.cs_actual(), DEC);
+      SERIAL_PRINT(st.cs_actual(), DEC);
       SERIAL_ECHOPGM("/31");
       break;
 
       break;
     case TMC_OTPW: serialprintPGM(st.otpw() ? PSTR("true") : PSTR("false")); break;
     case TMC_OTPW_TRIGGERED: serialprintPGM(st.getOTPW() ? PSTR("true") : PSTR("false")); break;
-    case TMC_TOFF: MYSERIAL.print(st.toff(), DEC); break;
-    case TMC_TBL: MYSERIAL.print(st.blank_time(), DEC); break;
-    case TMC_HEND: MYSERIAL.print(st.hysterisis_end(), DEC); break;
-    case TMC_HSTRT: MYSERIAL.print(st.hysterisis_start(), DEC); break;
+    case TMC_TOFF: SERIAL_PRINT(st.toff(), DEC); break;
+    case TMC_TBL: SERIAL_PRINT(st.blank_time(), DEC); break;
+    case TMC_HEND: SERIAL_PRINT(st.hysterisis_end(), DEC); break;
+    case TMC_HSTRT: SERIAL_PRINT(st.hysterisis_start(), DEC); break;
     default: tmc_status(st, i); break;
   }
 }
     case TMC_S2GA:          if (st.s2ga())         SERIAL_ECHOPGM("X"); break;
     case TMC_DRV_OTPW:      if (st.otpw())         SERIAL_ECHOPGM("X"); break;
     case TMC_OT:            if (st.ot())           SERIAL_ECHOPGM("X"); break;
-    case TMC_DRV_CS_ACTUAL: MYSERIAL.print(st.cs_actual(), DEC);        break;
+    case TMC_DRV_CS_ACTUAL: SERIAL_PRINT(st.cs_actual(), DEC);        break;
     case TMC_DRV_STATUS_HEX:drv_status_print_hex(extended_axis_codes[axis], st.DRV_STATUS()); break;
     default: tmc_parse_drv_status(st, i); break;
   }

Marlin/src/gcode/host/M115.cpp

 #include "../gcode.h"
 #include "../../inc/MarlinConfig.h"
 
+#if NUM_SERIAL > 1
+  #include "../../gcode/queue.h"
+#endif
+
 #if ENABLED(EXTENDED_CAPABILITIES_REPORT)
   static void cap_line(const char * const name, bool ena=false) {
     SERIAL_PROTOCOLPGM("Cap:");
  * M115: Capabilities string
  */
 void GcodeSuite::M115() {
-  SERIAL_PROTOCOLLNPGM(MSG_M115_REPORT);
+  #if NUM_SERIAL > 1
+    const int8_t port = command_queue_port[cmd_queue_index_r];
+    #define CAPLINE(STR,...) cap_line(PSTR(STR), port, __VA_ARGS__)
+  #else
+    #define CAPLINE(STR,...) cap_line(PSTR(STR), __VA_ARGS__)
+  #endif
+
+  SERIAL_PROTOCOLLNPGM_P(port, MSG_M115_REPORT);
 
   #if ENABLED(EXTENDED_CAPABILITIES_REPORT)
 

Marlin/src/gcode/parser.cpp

   #include "../libs/hex_print_routines.h"
 #endif
 
+#if NUM_SERIAL > 1
+  #include "queue.h"
+#endif
+
 // Must be declared for allocation and to satisfy the linker
 // Zero values need no initialization.
 
 #endif // CNC_COORDINATE_SYSTEMS
 
 void GCodeParser::unknown_command_error() {
-  SERIAL_ECHO_START();
-  SERIAL_ECHOPAIR(MSG_UNKNOWN_COMMAND, command_ptr);
-  SERIAL_CHAR('"');
-  SERIAL_EOL();
+  #if NUM_SERIAL > 1
+    const int16_t port = command_queue_port[cmd_queue_index_r];
+  #endif
+  SERIAL_ECHO_START_P(port);
+  SERIAL_ECHOPAIR_P(port, MSG_UNKNOWN_COMMAND, command_ptr);
+  SERIAL_CHAR_P(port, '"');
+  SERIAL_EOL_P(port);
 }
 
 #if ENABLED(DEBUG_GCODE_PARSER)

Marlin/src/gcode/queue.cpp

 
 char command_queue[BUFSIZE][MAX_CMD_SIZE];
 
+/*
+ * The port that the command was received on
+ */
+#if NUM_SERIAL > 1
+  int16_t command_queue_port[BUFSIZE];
+#endif
+
 /**
  * Serial command injection
  */
 
 // Number of characters read in the current line of serial input
-static int serial_count = 0;
+static int serial_count[NUM_SERIAL] = { 0 };
 
 bool send_ok[BUFSIZE];
 
 /**
  * Once a new command is in the ring buffer, call this to commit it
  */
-inline void _commit_command(bool say_ok) {
+inline void _commit_command(bool say_ok
+  #if NUM_SERIAL > 1
+    , int16_t port = -1
+  #endif
+) {
   send_ok[cmd_queue_index_w] = say_ok;
+  #if NUM_SERIAL > 1
+    command_queue_port[cmd_queue_index_w] = port;
+  #endif
   if (++cmd_queue_index_w >= BUFSIZE) cmd_queue_index_w = 0;
   commands_in_queue++;
 }
  * Return true if the command was successfully added.
  * Return false for a full buffer, or if the 'command' is a comment.
  */
-inline bool _enqueuecommand(const char* cmd, bool say_ok/*=false*/) {
+inline bool _enqueuecommand(const char* cmd, bool say_ok
+  #if NUM_SERIAL > 1
+    , int16_t port = -1
+  #endif
+) {
   if (*cmd == ';' || commands_in_queue >= BUFSIZE) return false;
   strcpy(command_queue[cmd_queue_index_w], cmd);
-  _commit_command(say_ok);
+  _commit_command(say_ok
+    #if NUM_SERIAL > 1
+      , port
+    #endif
+  );
   return true;
 }
 
  *   B<int>  Block queue space remaining
  */
 void ok_to_send() {
+  #if NUM_SERIAL > 1
+    const int16_t port = command_queue_port[cmd_queue_index_r];
+    if (port < 0) return;
+  #endif
   gcode.refresh_cmd_timeout();
   if (!send_ok[cmd_queue_index_r]) return;
-  SERIAL_PROTOCOLPGM(MSG_OK);
+  SERIAL_PROTOCOLPGM_P(port, MSG_OK);
   #if ENABLED(ADVANCED_OK)
     char* p = command_queue[cmd_queue_index_r];
     if (*p == 'N') {
-      SERIAL_PROTOCOL(' ');
-      SERIAL_ECHO(*p++);
+      SERIAL_PROTOCOL_P(port, ' ');
+      SERIAL_ECHO_P(port, *p++);
       while (NUMERIC_SIGNED(*p))
-        SERIAL_ECHO(*p++);
+        SERIAL_ECHO_P(port, *p++);
     }
-    SERIAL_PROTOCOLPGM(" P"); SERIAL_PROTOCOL(int(BLOCK_BUFFER_SIZE - planner.movesplanned() - 1));
-    SERIAL_PROTOCOLPGM(" B"); SERIAL_PROTOCOL(BUFSIZE - commands_in_queue);
+    SERIAL_PROTOCOLPGM_P(port, " P"); SERIAL_PROTOCOL_P(port, int(BLOCK_BUFFER_SIZE - planner.movesplanned() - 1));
+    SERIAL_PROTOCOLPGM_P(port, " B"); SERIAL_PROTOCOL_P(port, BUFSIZE - commands_in_queue);
   #endif
-  SERIAL_EOL();
+  SERIAL_EOL_P(port);
 }
 
 /**
  * indicate that a command needs to be re-sent.
  */
 void flush_and_request_resend() {
-  //char command_queue[cmd_queue_index_r][100]="Resend:";
-  MYSERIAL.flush();
-  SERIAL_PROTOCOLPGM(MSG_RESEND);
-  SERIAL_PROTOCOLLN(gcode_LastN + 1);
-  ok_to_send();
+  #if NUM_SERIAL > 1
+    const int16_t port = command_queue_port[cmd_queue_index_r];
+    if (port < 0) return;
+  #endif
+  SERIAL_FLUSH_P(port);
+  SERIAL_PROTOCOLPGM_P(port, MSG_RESEND);
+  SERIAL_PROTOCOLLN_P(port, gcode_LastN + 1);
 }
 
-void gcode_line_error(const char* err, bool doFlush = true) {
-  SERIAL_ERROR_START();
-  serialprintPGM(err);
-  SERIAL_ERRORLN(gcode_LastN);
-  //Serial.println(gcode_N);
-  if (doFlush) flush_and_request_resend();
-  serial_count = 0;
+void gcode_line_error(const char* err, uint8_t port) {
+  SERIAL_ERROR_START_P(port);
+  serialprintPGM_P(port, err);
+  SERIAL_ERRORLN_P(port, gcode_LastN);
+  flush_and_request_resend();
+  serial_count[port] = 0;
+}
+
+static bool serial_data_available() {
+  return (MYSERIAL0.available() ? true :
+    #if NUM_SERIAL > 1
+      MYSERIAL1.available() ? true :
+    #endif
+    false);
+}
+
+static int read_serial(const int index) {
+  switch (index) {
+    case 0: return MYSERIAL0.read();
+    #if NUM_SERIAL > 1 
+      case 1: return MYSERIAL1.read();
+    #endif
+    default: return -1;
+  }
 }
 
 /**
  * left on the serial port.
  */
 inline void get_serial_commands() {
-  static char serial_line_buffer[MAX_CMD_SIZE];
-  static bool serial_comment_mode = false;
+  static char serial_line_buffer[NUM_SERIAL][MAX_CMD_SIZE];
+  static bool serial_comment_mode[NUM_SERIAL] = { false };
 
   // If the command buffer is empty for too long,
   // send "wait" to indicate Marlin is still waiting.
   #if defined(NO_TIMEOUTS) && NO_TIMEOUTS > 0
     static millis_t last_command_time = 0;
     const millis_t ms = millis();
-    if (commands_in_queue == 0 && !MYSERIAL.available() && ELAPSED(ms, last_command_time + NO_TIMEOUTS)) {
+    if (commands_in_queue == 0 && !serial_data_available() && ELAPSED(ms, last_command_time + NO_TIMEOUTS)) {
       SERIAL_ECHOLNPGM(MSG_WAIT);
       last_command_time = ms;
     }
   /**
    * Loop while serial characters are incoming and the queue is not full
    */
-  int c;
-  while (commands_in_queue < BUFSIZE && (c = MYSERIAL.read()) >= 0) {
-    char serial_char = c;
+  while (commands_in_queue < BUFSIZE && serial_data_available()) {
+    for (uint8_t i = 0; i < NUM_SERIAL; ++i) {
+      int c;
+      if ((c = read_serial(i)) < 0) continue;
 
-    /**
-     * If the character ends the line
-     */
-    if (serial_char == '\n' || serial_char == '\r') {
+      char serial_char = c;
 
-      serial_comment_mode = false;                      // end of line == end of comment
+      /**
+       * If the character ends the line
+       */
+      if (serial_char == '\n' || serial_char == '\r') {
 
-      if (!serial_count) continue;                      // Skip empty lines
+        serial_comment_mode[i] = false;                   // end of line == end of comment
 
-      serial_line_buffer[serial_count] = 0;             // Terminate string
-      serial_count = 0;                                 // Reset buffer
+        if (!serial_count[i]) continue;                   // Skip empty lines
 
-      char* command = serial_line_buffer;
+        serial_line_buffer[i][serial_count[i]] = 0;       // Terminate string
+        serial_count[i] = 0;                              // Reset buffer
 
-      while (*command == ' ') command++;                // Skip leading spaces
-      char *npos = (*command == 'N') ? command : NULL;  // Require the N parameter to start the line
+        char* command = serial_line_buffer[i];
 
-      if (npos) {
+        while (*command == ' ') command++;                // Skip leading spaces
+        char *npos = (*command == 'N') ? command : NULL;  // Require the N parameter to start the line
 
-        bool M110 = strstr_P(command, PSTR("M110")) != NULL;
+        if (npos) {
 
-        if (M110) {
-          char* n2pos = strchr(command + 4, 'N');
-          if (n2pos) npos = n2pos;
-        }
+          bool M110 = strstr_P(command, PSTR("M110")) != NULL;
 
-        gcode_N = strtol(npos + 1, NULL, 10);
+          if (M110) {
+            char* n2pos = strchr(command + 4, 'N');
+            if (n2pos) npos = n2pos;
+          }
 
-        if (gcode_N != gcode_LastN + 1 && !M110) {
-          gcode_line_error(PSTR(MSG_ERR_LINE_NO));
-          return;
-        }
+          gcode_N = strtol(npos + 1, NULL, 10);
 
-        char *apos = strrchr(command, '*');
-        if (apos) {
-          uint8_t checksum = 0, count = uint8_t(apos - command);
-          while (count) checksum ^= command[--count];
-          if (strtol(apos + 1, NULL, 10) != checksum) {
-            gcode_line_error(PSTR(MSG_ERR_CHECKSUM_MISMATCH));
+          if (gcode_N != gcode_LastN + 1 && !M110) {
+            gcode_line_error(PSTR(MSG_ERR_LINE_NO), i);
             return;
           }
-        }
-        else {
-          gcode_line_error(PSTR(MSG_ERR_NO_CHECKSUM));
-          return;
-        }
-
-        gcode_LastN = gcode_N;
-      }
 
-      // Movement commands alert when stopped
-      if (IsStopped()) {
-        char* gpos = strchr(command, 'G');
-        if (gpos) {
-          const int codenum = strtol(gpos + 1, NULL, 10);
-          switch (codenum) {
-            case 0:
-            case 1:
-            case 2:
-            case 3:
-              SERIAL_ERRORLNPGM(MSG_ERR_STOPPED);
-              LCD_MESSAGEPGM(MSG_STOPPED);
-              break;
+          char *apos = strrchr(command, '*');
+          if (apos) {
+            uint8_t checksum = 0, count = uint8_t(apos - command);
+            while (count) checksum ^= command[--count];
+            if (strtol(apos + 1, NULL, 10) != checksum) {
+              gcode_line_error(PSTR(MSG_ERR_CHECKSUM_MISMATCH), i);
+              return;
+            }
+          }
+          else {
+            gcode_line_error(PSTR(MSG_ERR_NO_CHECKSUM), i);
+            return;
           }
-        }
-      }
 
-      #if DISABLED(EMERGENCY_PARSER)
-        // If command was e-stop process now
-        if (strcmp(command, "M108") == 0) {
-          wait_for_heatup = false;
-          #if ENABLED(ULTIPANEL)
-            wait_for_user = false;
-          #endif
+          gcode_LastN = gcode_N;
         }
-        if (strcmp(command, "M112") == 0) kill(PSTR(MSG_KILLED));
-        if (strcmp(command, "M410") == 0) { quickstop_stepper(); }
-      #endif
-
-      #if defined(NO_TIMEOUTS) && NO_TIMEOUTS > 0
-        last_command_time = ms;
-      #endif
 
-      // Add the command to the queue
-      _enqueuecommand(serial_line_buffer, true);
-    }
-    else if (serial_count >= MAX_CMD_SIZE - 1) {
-      // Keep fetching, but ignore normal characters beyond the max length
-      // The command will be injected when EOL is reached
-    }
-    else if (serial_char == '\\') {  // Handle escapes
-      // if we have one more character, copy it over
-      if ((c = MYSERIAL.read()) >= 0 && !serial_comment_mode)
-        serial_line_buffer[serial_count++] = serial_char;
-    }
-    else { // it's not a newline, carriage return or escape char
-      if (serial_char == ';') serial_comment_mode = true;
-      if (!serial_comment_mode) serial_line_buffer[serial_count++] = serial_char;
-    }
+        // Movement commands alert when stopped
+        if (IsStopped()) {
+          char* gpos = strchr(command, 'G');
+          if (gpos) {
+            const int codenum = strtol(gpos + 1, NULL, 10);
+            switch (codenum) {
+              case 0:
+              case 1:
+              case 2:
+              case 3:
+                SERIAL_ERRORLNPGM_P(i, MSG_ERR_STOPPED);
+                LCD_MESSAGEPGM(MSG_STOPPED);
+                break;
+            }
+          }
+        }
 
+        #if DISABLED(EMERGENCY_PARSER)
+          // If command was e-stop process now
+          if (strcmp(command, "M108") == 0) {
+            wait_for_heatup = false;
+            #if ENABLED(ULTIPANEL)
+              wait_for_user = false;
+            #endif
+          }
+          if (strcmp(command, "M112") == 0) kill(PSTR(MSG_KILLED));
+          if (strcmp(command, "M410") == 0) { quickstop_stepper(); }
+        #endif
+
+        #if defined(NO_TIMEOUTS) && NO_TIMEOUTS > 0
+          last_command_time = ms;
+        #endif
+
+        // Add the command to the queue
+        _enqueuecommand(serial_line_buffer[i], true
+          #if NUM_SERIAL > 1
+            , i
+          #endif
+        );
+      }
+      else if (serial_count[i] >= MAX_CMD_SIZE - 1) {
+        // Keep fetching, but ignore normal characters beyond the max length
+        // The command will be injected when EOL is reached
+      }
+      else if (serial_char == '\\') {  // Handle escapes
+        // if we have one more character, copy it over
+        if ((c = read_serial(i)) >= 0 && !serial_comment_mode[i])
+          serial_line_buffer[i][serial_count[i]++] = serial_char;
+      }
+      else { // it's not a newline, carriage return or escape char
+        if (serial_char == ';') serial_comment_mode[i] = true;
+        if (!serial_comment_mode[i]) serial_line_buffer[i][serial_count[i]++] = serial_char;
+      }
+    } // for NUM_SERIAL
   } // queue has space, serial has data
 }
 

Marlin/src/gcode/queue.h

 
 extern char command_queue[BUFSIZE][MAX_CMD_SIZE];
 
+/*
+ * The port that the command was received on
+ */
+#if NUM_SERIAL > 1
+  extern int16_t command_queue_port[BUFSIZE];
+#endif
+
 /**
  * Initialization of queue for setup()
  */

Marlin/src/gcode/sdcard/M20-M30_M32-M34_M928.cpp

   #include "../queue.h"
 #endif
 
+#if NUM_SERIAL > 1
+  #include "../../gcode/queue.h"
+#endif
+
 /**
  * M20: List SD card to serial output
  */
 void GcodeSuite::M20() {
-  SERIAL_PROTOCOLLNPGM(MSG_BEGIN_FILE_LIST);
-  card.ls();
-  SERIAL_PROTOCOLLNPGM(MSG_END_FILE_LIST);
+  #if NUM_SERIAL > 1
+    const int16_t port = command_queue_port[cmd_queue_index_r];
+  #endif
+
+  SERIAL_PROTOCOLLNPGM_P(port, MSG_BEGIN_FILE_LIST);
+  card.ls(
+    #if NUM_SERIAL > 1
+      port
+    #endif
+  );
+  SERIAL_PROTOCOLLNPGM_P(port, MSG_END_FILE_LIST);
 }
 
 /**
 /**
  * M27: Get SD Card status
  */
-void GcodeSuite::M27() { card.getStatus(); }
+void GcodeSuite::M27() { 
+  card.getStatus(
+    #if NUM_SERIAL > 1
+      command_queue_port[cmd_queue_index_r]
+    #endif
+  );
+}
 
 /**
  * M28: Start SD Write
    *   /Miscellaneous/Armchair/Armchair.gcode
    */
   void GcodeSuite::M33() {
-    card.printLongPath(parser.string_arg);
+    card.printLongPath(parser.string_arg
+      #if NUM_SERIAL > 1
+        , command_queue_port[cmd_queue_index_r]
+      #endif
+    );
   }
 
 #endif // LONG_FILENAME_HOST_SUPPORT

Marlin/src/gcode/stats/M31.cpp

 #include "../../libs/duration_t.h"
 #include "../../lcd/ultralcd.h"
 
+#if NUM_SERIAL > 1
+  #include "../../gcode/queue.h"
+#endif
+
 /**
  * M31: Get the time since the start of SD Print (or last M109)
  */
 void GcodeSuite::M31() {
+  #if NUM_SERIAL > 1
+    const int16_t port = command_queue_port[cmd_queue_index_r];
+  #endif
   char buffer[21];
   duration_t elapsed = print_job_timer.duration();
   elapsed.toString(buffer);
   lcd_setstatus(buffer);
 
-  SERIAL_ECHO_START();
-  SERIAL_ECHOLNPAIR("Print time: ", buffer);
+  SERIAL_ECHO_START_P(port);
+  SERIAL_ECHOLNPAIR_P(port, "Print time: ", buffer);
 }

Marlin/src/gcode/temperature/M105.cpp

 #include "../gcode.h"
 #include "../../module/temperature.h"
 
+#if NUM_SERIAL > 1
+  #include "../../gcode/queue.h"
+#endif
+
 /**
  * M105: Read hot end and bed temperature
  */
 void GcodeSuite::M105() {
   if (get_target_extruder_from_command()) return;
 
+  #if NUM_SERIAL > 1
+    const int16_t port = command_queue_port[cmd_queue_index_r];
+  #endif
+
   #if HAS_TEMP_HOTEND || HAS_TEMP_BED
-    SERIAL_PROTOCOLPGM(MSG_OK);
-    thermalManager.print_heaterstates();
+    SERIAL_PROTOCOLPGM_P(port, MSG_OK);
+    thermalManager.print_heaterstates(
+      #if NUM_SERIAL > 1
+        port
+      #endif
+    );
   #else // !HAS_TEMP_HOTEND && !HAS_TEMP_BED
-    SERIAL_ERROR_START();
-    SERIAL_ERRORLNPGM(MSG_ERR_NO_THERMISTORS);
+    SERIAL_ERROR_START_P(port);
+    SERIAL_ERRORLNPGM_P(port, MSG_ERR_NO_THERMISTORS);
   #endif
 
-  SERIAL_EOL();
+  SERIAL_EOL_P(port);
 }

Marlin/src/inc/Conditionals_LCD.h

 #define HAS_RESUME_CONTINUE (ENABLED(NEWPANEL) || ENABLED(EMERGENCY_PARSER))
 #define HAS_COLOR_LEDS (ENABLED(BLINKM) || ENABLED(RGB_LED) || ENABLED(RGBW_LED) || ENABLED(PCA9632) || ENABLED(NEOPIXEL_LED))
 
-// For Re-ARM boards, always use the USB Emulated Serial Port unless RE_ARM_FORCE_SERIAL_PORT is defined
-#if !defined(RE_ARM_FORCE_SERIAL_PORT) && (MB(RAMPS_14_RE_ARM_EFB) || MB(RAMPS_14_RE_ARM_EEB) || MB(RAMPS_14_RE_ARM_EFF) || MB(RAMPS_14_RE_ARM_EEF) || MB(RAMPS_14_RE_ARM_SF))
-  #undef SERIAL_PORT
-  #define SERIAL_PORT -1
-#endif
-
 #endif // CONDITIONALS_LCD_H

Marlin/src/module/configuration_store.h

 
 #include "../inc/MarlinConfig.h"
 
+#define ADD_PORT_ARG ENABLED(EEPROM_CHITCHAT) && NUM_SERIAL > 1
+
 class MarlinSettings {
   public:
     MarlinSettings() { }
 
     static uint16_t datasize();
 
-    static void reset();
-    static bool save();   // Return 'true' if data was saved
+    static void reset(
+      #if ADD_PORT_ARG
+        const int8_t port=-1
+      #endif
+    );
+    static bool save(
+      #if ADD_PORT_ARG
+        const int8_t port=-1
+      #endif
+    );   // Return 'true' if data was saved
 
     FORCE_INLINE static bool init_eeprom() {
       bool success = true;
     }
 
     #if ENABLED(EEPROM_SETTINGS)
-      static bool load();     // Return 'true' if data was loaded ok
-      static bool validate(); // Return 'true' if EEPROM data is ok
+      static bool load(
+        #if ADD_PORT_ARG
+          const int8_t port=-1
+        #endif
+      );     // Return 'true' if data was loaded ok
+      static bool validate(
+        #if ADD_PORT_ARG
+          const int8_t port=-1
+        #endif
+      ); // Return 'true' if EEPROM data is ok
 
       #if ENABLED(AUTO_BED_LEVELING_UBL) // Eventually make these available if any leveling system
                                          // That can store is enabled
     #endif
 
     #if DISABLED(DISABLE_M503)
-      static void report(const bool forReplay=false);
+      static void report(const bool forReplay=false
+        #if ADD_PORT_ARG
+          , const int8_t port=-1
+        #endif
+      );
     #else
       FORCE_INLINE
       static void report(const bool forReplay=false) { UNUSED(forReplay); }
 
       #endif
 
-      static bool _load();
-      static bool size_error(const uint16_t size);
+      static bool _load(
+        #if ADD_PORT_ARG
+          const int8_t port=-1
+        #endif
+      );
+      static bool size_error(const uint16_t size
+        #if ADD_PORT_ARG
+          const int8_t port=-1
+        #endif
+      );
     #endif
 };
 

Marlin/src/module/stepper.h

         }
         if (timer < 100) { // (20kHz - this should never happen)
           timer = 100;
-          MYSERIAL.print(MSG_STEPPER_TOO_HIGH);
-          MYSERIAL.println(step_rate);
+          SERIAL_ECHOPGM(MSG_STEPPER_TOO_HIGH);
+          SERIAL_ECHOLN(step_rate);
         }
       #endif
 

Marlin/src/module/temperature.cpp

 
   #include "../gcode/gcode.h"
 
-  void print_heater_state(const float &c, const float &t,
+  static void print_heater_state(const float &c, const float &t
     #if ENABLED(SHOW_TEMP_ADC_VALUES)
-      const float r,
+      , const float r
     #endif
-    const int8_t e=-2
+    #if NUM_SERIAL > 1
+      , const int8_t port=-1
+    #endif
+    , const int8_t e=-2
   ) {
     #if !(HAS_TEMP_BED && HAS_TEMP_HOTEND) && HOTENDS <= 1
       UNUSED(e);
     #endif
 
-    SERIAL_PROTOCOLCHAR(' ');
-    SERIAL_PROTOCOLCHAR(
+    SERIAL_PROTOCOLCHAR_P(port, ' ');
+    SERIAL_PROTOCOLCHAR_P(port,
       #if HAS_TEMP_BED && HAS_TEMP_HOTEND
         e == -1 ? 'B' : 'T'
       #elif HAS_TEMP_HOTEND
       #endif
     );
     #if HOTENDS > 1
-      if (e >= 0) SERIAL_PROTOCOLCHAR('0' + e);
+      if (e >= 0) SERIAL_PROTOCOLCHAR_P(port, '0' + e);
     #endif
-    SERIAL_PROTOCOLCHAR(':');
-    SERIAL_PROTOCOL(c);
-    SERIAL_PROTOCOLPAIR(" /" , t);
+    SERIAL_PROTOCOLCHAR_P(port, ':');
+    SERIAL_PROTOCOL_P(port, c);
+    SERIAL_PROTOCOLPAIR_P(port, " /" , t);
     #if ENABLED(SHOW_TEMP_ADC_VALUES)
-      SERIAL_PROTOCOLPAIR(" (", r / OVERSAMPLENR);
-      SERIAL_PROTOCOLCHAR(')');
+      SERIAL_PROTOCOLPAIR_P(port, " (", r / OVERSAMPLENR);
+      SERIAL_PROTOCOLCHAR_P(port, ')');
     #endif
   }
 
-  void Temperature::print_heaterstates() {
+  void Temperature::print_heaterstates(
+    #if NUM_SERIAL > 1
+      const int8_t port
+    #endif
+  ) {
     #if HAS_TEMP_HOTEND
       print_heater_state(degHotend(gcode.target_extruder), degTargetHotend(gcode.target_extruder)
         #if ENABLED(SHOW_TEMP_ADC_VALUES)
           , rawHotendTemp(gcode.target_extruder)
         #endif
+        #if NUM_SERIAL > 1
+          , port
+        #endif
       );
     #endif
     #if HAS_TEMP_BED
         #if ENABLED(SHOW_TEMP_ADC_VALUES)
           , rawBedTemp()
         #endif
+        #if NUM_SERIAL > 1
+          , port
+        #endif
         , -1 // BED
       );
     #endif
         #if ENABLED(SHOW_TEMP_ADC_VALUES)
           , rawHotendTemp(e)
         #endif
+        #if NUM_SERIAL > 1
+          , port
+        #endif
         , e
       );
     #endif
-    SERIAL_PROTOCOLPGM(" @:");
-    SERIAL_PROTOCOL(getHeaterPower(gcode.target_extruder));
+    SERIAL_PROTOCOLPGM_P(port, " @:");
+    SERIAL_PROTOCOL_P(port, getHeaterPower(gcode.target_extruder));
     #if HAS_TEMP_BED
-      SERIAL_PROTOCOLPGM(" B@:");
-      SERIAL_PROTOCOL(getHeaterPower(-1));
+      SERIAL_PROTOCOLPGM_P(port, " B@:");
+      SERIAL_PROTOCOL_P(port, getHeaterPower(-1));
     #endif
     #if HOTENDS > 1
       HOTEND_LOOP() {
-        SERIAL_PROTOCOLPAIR(" @", e);
-        SERIAL_PROTOCOLCHAR(':');
-        SERIAL_PROTOCOL(getHeaterPower(e));
+        SERIAL_PROTOCOLPAIR_P(port, " @", e);
+        SERIAL_PROTOCOLCHAR_P(port, ':');
+        SERIAL_PROTOCOL_P(port, getHeaterPower(e));
       }
     #endif
   }

Marlin/src/module/temperature.h

     #endif // HEATER_IDLE_HANDLER
 
     #if HAS_TEMP_HOTEND || HAS_TEMP_BED
-      static void print_heaterstates();
+      static void print_heaterstates(
+        #if NUM_SERIAL > 1
+          const int8_t port = -1
+        #endif
+      );
       #if ENABLED(AUTO_REPORT_TEMPERATURES)
         static uint8_t auto_report_temp_interval;
         static millis_t next_temp_report_ms;

Marlin/src/sd/SdBaseFile.cpp

         && DIR_IS_FILE_OR_SUBDIR(&dir)) break;
   }
   // indent for dir level
-  for (uint8_t i = 0; i < indent; i++) MYSERIAL.write(' ');
+  for (uint8_t i = 0; i < indent; i++) SERIAL_CHAR(' ');
 
   // print name
   for (uint8_t i = 0; i < 11; i++) {
     if (dir.name[i] == ' ')continue;
     if (i == 8) {
-      MYSERIAL.write('.');
+      SERIAL_CHAR('.');
       w++;
     }
-    MYSERIAL.write(dir.name[i]);
+    SERIAL_CHAR(dir.name[i]);
     w++;
   }
   if (DIR_IS_SUBDIR(&dir)) {
-    MYSERIAL.write('/');
+    SERIAL_CHAR('/');
     w++;
   }
   if (flags & (LS_DATE | LS_SIZE)) {
-    while (w++ < 14) MYSERIAL.write(' ');
+    while (w++ < 14) SERIAL_CHAR(' ');
   }
   // print modify date/time if requested
   if (flags & LS_DATE) {
-    MYSERIAL.write(' ');
+    SERIAL_CHAR(' ');
     printFatDate(dir.lastWriteDate);
-    MYSERIAL.write(' ');
+    SERIAL_CHAR(' ');
     printFatTime(dir.lastWriteTime);
   }
   // print size if requested
   if (!DIR_IS_SUBDIR(&dir) && (flags & LS_SIZE)) {
-    MYSERIAL.write(' ');
-    MYSERIAL.print(dir.fileSize);
+    SERIAL_CHAR(' ');
+    SERIAL_ECHO(dir.fileSize);
   }
-  MYSERIAL.println();
+  SERIAL_EOL();
   return DIR_IS_FILE(&dir) ? 1 : 2;
 }
 
   return c;
 }
 
-
 // print uint8_t with width 2
-static void print2u(uint8_t v) {
-  if (v < 10) MYSERIAL.write('0');
-  MYSERIAL.print(v, DEC);
+static void print2u(const uint8_t v) {
+  if (v < 10) SERIAL_CHAR('0');
+  SERIAL_ECHO_F(v, DEC);
 }
 
 /**
  * \param[in] fatDate The date field from a directory entry.
  */
 void SdBaseFile::printFatDate(uint16_t fatDate) {
-  MYSERIAL.print(FAT_YEAR(fatDate));
-  MYSERIAL.write('-');
+  SERIAL_ECHO(FAT_YEAR(fatDate));
+  SERIAL_CHAR('-');
   print2u(FAT_MONTH(fatDate));
-  MYSERIAL.write('-');
+  SERIAL_CHAR('-');
   print2u(FAT_DAY(fatDate));
 }
 
  */
 void SdBaseFile::printFatTime(uint16_t fatTime) {
   print2u(FAT_HOUR(fatTime));
-  MYSERIAL.write(':');
+  SERIAL_CHAR(':');
   print2u(FAT_MINUTE(fatTime));
-  MYSERIAL.write(':');
+  SERIAL_CHAR(':');
   print2u(FAT_SECOND(fatTime));
 }
 
 bool SdBaseFile::printName() {
   char name[FILENAME_LENGTH];
   if (!getFilename(name)) return false;
-  MYSERIAL.print(name);
+  SERIAL_ECHO(name);
   return true;
 }
 

Marlin/src/sd/SdFatUtil.cpp

  * \return The number of free bytes.
  */
 #ifdef __arm__
-extern "C" char* sbrk(int incr);
-int SdFatUtil::FreeRam() {
-  char top;
-  return &top - reinterpret_cast<char*>(sbrk(0));
-}
-#else  // __arm__
-extern char* __brkval;
-extern char __bss_end;
-/**
- * Amount of free RAM
- * \return The number of free bytes.
- */
-int SdFatUtil::FreeRam() {
-  char top;
-  return __brkval ? &top - __brkval : &top - &__bss_end;
-}
-#endif  // __arm
 
-/**
- * %Print a string in flash memory.
- *
- * \param[in] pr Print object for output.
- * \param[in] str Pointer to string stored in flash memory.
- */
-void SdFatUtil::print_P(PGM_P str) {
-  for (uint8_t c; (c = pgm_read_byte(str)); str++) MYSERIAL.write(c);
-}
+  extern "C" char* sbrk(int incr);
+  int SdFatUtil::FreeRam() {
+    char top;
+    return &top - reinterpret_cast<char*>(sbrk(0));
+  }
 
-/**
- * %Print a string in flash memory followed by a CR/LF.
- *
- * \param[in] pr Print object for output.
- * \param[in] str Pointer to string stored in flash memory.
- */
-void SdFatUtil::println_P(PGM_P str) { print_P(str); MYSERIAL.println(); }
+#else
 
-/**
- * %Print a string in flash memory to Serial.
- *
- * \param[in] str Pointer to string stored in flash memory.
- */
-void SdFatUtil::SerialPrint_P(PGM_P str) { print_P(str); }
+  extern char* __brkval;
+  extern char __bss_end;
+  int SdFatUtil::FreeRam() {
+    char top;
+    return __brkval ? &top - __brkval : &top - &__bss_end;
+  }
 
-/**
- * %Print a string in flash memory to Serial followed by a CR/LF.
- *
- * \param[in] str Pointer to string stored in flash memory.
- */
-void SdFatUtil::SerialPrintln_P(PGM_P str) { println_P(str); }
+#endif
 
 #endif // SDSUPPORT

Marlin/src/sd/SdFatUtil.h

  * \file
  * \brief Useful utility functions.
  */
-/** Store and print a string in flash memory.*/
-#define PgmPrint(x) SerialPrint_P(PSTR(x))
-/** Store and print a string in flash memory followed by a CR/LF.*/
-#define PgmPrintln(x) SerialPrintln_P(PSTR(x))
 
 namespace SdFatUtil {
   int FreeRam();
-  void print_P(PGM_P str);
-  void println_P(PGM_P str);
-  void SerialPrint_P(PGM_P str);
-  void SerialPrintln_P(PGM_P str);
 }
 
 using namespace SdFatUtil;  // NOLINT

Marlin/src/sd/cardreader.cpp

 
 uint16_t nrFile_index;
 
-void CardReader::lsDive(const char *prepend, SdFile parent, const char * const match/*=NULL*/) {
+void CardReader::lsDive(const char *prepend, SdFile parent, const char * const match/*=NULL*/
+  #if NUM_SERIAL > 1
+    , const int8_t port/*= -1*/
+  #endif
+) {
   dir_t p;
   uint8_t cnt = 0;
 
       SdFile dir;
       if (!dir.open(parent, lfilename, O_READ)) {
         if (lsAction == LS_SerialPrint) {
-          SERIAL_ECHO_START();
-          SERIAL_ECHOPGM(MSG_SD_CANT_OPEN_SUBDIR);
-          SERIAL_ECHOLN(lfilename);
+          SERIAL_ECHO_START_P(port);
+          SERIAL_ECHOPGM_P(port, MSG_SD_CANT_OPEN_SUBDIR);
+          SERIAL_ECHOLN_P(port, lfilename);
         }
       }
-      lsDive(path, dir);
+      lsDive(path, dir
+        #if NUM_SERIAL > 1
+          , NULL, port
+        #endif
+      );
       // close() is done automatically by destructor of SdFile
     }
     else {
 
         case LS_SerialPrint:
           createFilename(filename, p);
-          SERIAL_PROTOCOL(prepend);
-          SERIAL_PROTOCOL(filename);
-          SERIAL_PROTOCOLCHAR(' ');
-          SERIAL_PROTOCOLLN(p.fileSize);
+          SERIAL_PROTOCOL_P(port, prepend);
+          SERIAL_PROTOCOL_P(port, filename);
+          SERIAL_PROTOCOLCHAR_P(port, ' ');
+          SERIAL_PROTOCOLLN_P(port, p.fileSize);
           break;
 
         case LS_GetFilename:
   } // while readDir
 }
 
-void CardReader::ls() {
+void CardReader::ls(
+  #if NUM_SERIAL > 1
+    const int8_t port
+  #endif
+) {
   lsAction = LS_SerialPrint;
   root.rewind();
-  lsDive("", root);
+  lsDive("", root  
+    #if NUM_SERIAL > 1
+      , NULL, port
+    #endif
+  );
 }
 
 #if ENABLED(LONG_FILENAME_HOST_SUPPORT)
   /**
    * Get a long pretty path based on a DOS 8.3 path
    */
-  void CardReader::printLongPath(char *path) {
+  void CardReader::printLongPath(char *path
+    #if NUM_SERIAL > 1
+      , const int8_t port/*= -1*/
+    #endif
+  ) {
     lsAction = LS_GetFilename;
 
     int i, pathLen = strlen(path);
 
-    // SERIAL_ECHOPGM("Full Path: "); SERIAL_ECHOLN(path);
+    // SERIAL_ECHOPGM_P(port, "Full Path: "); SERIAL_ECHOLN_P(port, path);
 
     // Zero out slashes to make segments
     for (i = 0; i < pathLen; i++) if (path[i] == '/') path[i] = '\0';
       // Go to the next segment
       while (path[++i]) { }
 
-      // SERIAL_ECHOPGM("Looking for segment: "); SERIAL_ECHOLN(segment);
+      // SERIAL_ECHOPGM_P(port, "Looking for segment: "); SERIAL_ECHOLN_P(port, segment);
 
       // Find the item, setting the long filename
       diveDir.rewind();
-      lsDive("", diveDir, segment);
+      lsDive("", diveDir, segment
+        #if NUM_SERIAL > 1
+          , port
+        #endif
+      );
 
       // Print /LongNamePart to serial output
-      SERIAL_PROTOCOLCHAR('/');
-      SERIAL_PROTOCOL(longFilename[0] ? longFilename : "???");
+      SERIAL_PROTOCOLCHAR_P(port, '/');
+      SERIAL_PROTOCOL_P(port, longFilename[0] ? longFilename : "???");
 
       // If the filename was printed then that's it
       if (!filenameIsDir) break;
 
-      // SERIAL_ECHOPGM("Opening dir: "); SERIAL_ECHOLN(segment);
+      // SERIAL_ECHOPGM_P(port, "Opening dir: "); SERIAL_ECHOLN_P(port, segment);
 
       // Open the sub-item as the new dive parent
       SdFile dir;
       if (!dir.open(diveDir, segment, O_READ)) {
-        SERIAL_EOL();
-        SERIAL_ECHO_START();
-        SERIAL_ECHOPGM(MSG_SD_CANT_OPEN_SUBDIR);
-        SERIAL_ECHO(segment);
+        SERIAL_EOL_P(port);
+        SERIAL_ECHO_START_P(port);
+        SERIAL_ECHOPGM_P(port, MSG_SD_CANT_OPEN_SUBDIR);
+        SERIAL_ECHO_P(port, segment);
         break;
       }
 
 
     } // while i<pathLen
 
-    SERIAL_EOL();
+    SERIAL_EOL_P(port);
   }
 
 #endif // LONG_FILENAME_HOST_SUPPORT
   }
 }
 
-void CardReader::getStatus() {
+void CardReader::getStatus(
+  #if NUM_SERIAL > 1
+    const int8_t port/*= -1*/
+  #endif
+) {
   if (cardOK) {
-    SERIAL_PROTOCOLPGM(MSG_SD_PRINTING_BYTE);
-    SERIAL_PROTOCOL(sdpos);
-    SERIAL_PROTOCOLCHAR('/');
-    SERIAL_PROTOCOLLN(filesize);
+    SERIAL_PROTOCOLPGM_P(port, MSG_SD_PRINTING_BYTE);
+    SERIAL_PROTOCOL_P(port, sdpos);
+    SERIAL_PROTOCOLCHAR_P(port, '/');
+    SERIAL_PROTOCOLLN_P(port, filesize);
   }
   else
-    SERIAL_PROTOCOLLNPGM(MSG_SD_NOT_PRINTING);
+    SERIAL_PROTOCOLLNPGM_P(port, MSG_SD_NOT_PRINTING);
 }
 
 void CardReader::write_command(char *buf) {

Marlin/src/sd/cardreader.h

   void openAndPrintFile(const char *name);
   void startFileprint();
   void stopSDPrint();
-  void getStatus();
+  void getStatus(
+    #if NUM_SERIAL > 1
+      const int8_t port = -1
+    #endif
+  );
   void printingHasFinished();
 
   #if ENABLED(LONG_FILENAME_HOST_SUPPORT)
-    void printLongPath(char *path);
+    void printLongPath(char *path
+      #if NUM_SERIAL > 1
+        , const int8_t port = -1
+      #endif
+    );
   #endif
 
   void getfilename(uint16_t nr, const char* const match=NULL);
 
   void getAbsFilename(char *t);
 
-  void ls();
+  void ls(
+    #if NUM_SERIAL > 1
+      const int8_t port = -1
+    #endif
+  );
   void chdir(const char *relpath);
   int8_t updir();
   void setroot();
   LsAction lsAction; //stored for recursion.
   uint16_t nrFiles; //counter for the files in the current directory and recycled as position counter for getting the nrFiles'th name in the directory.
   char* diveDirName;
-  void lsDive(const char *prepend, SdFile parent, const char * const match=NULL);
+  void lsDive(const char *prepend, SdFile parent, const char * const match=NULL  
+    #if NUM_SERIAL > 1
+      , const int8_t port = -1
+    #endif
+  );
 
   #if ENABLED(SDCARD_SORT_ALPHA)
     void flush_presort();