More Anycubic + Trigorilla mappings, ExtUI (#18903)

Marlin/Configuration.h

 //#define TOUCH_UI_FTDI_EVE
 
 //
+// Touch-screen LCD for Anycubic printers
+//
+//#define ANYCUBIC_LCD_I3MEGA
+//#define ANYCUBIC_LCD_CHIRON
+#if EITHER(ANYCUBIC_LCD_I3MEGA, ANYCUBIC_LCD_CHIRON)
+  #define ANYCUBIC_LCD_SERIAL_PORT 3
+  //#define ANYCUBIC_LCD_DEBUG
+#endif
+
+//
 // Third-party or vendor-customized controller interfaces.
 // Sources should be installed in 'src/lcd/extensible_ui'.
 //
 //#define TFT_LVGL_UI_FSMC  // Robin nano v1.2 uses FSMC
 //#define TFT_LVGL_UI_SPI   // Robin nano v2.0 uses SPI
 
-//
-// Anycubic Mega TFT (AI3M)
-//
-//#define ANYCUBIC_TFT_MODEL
-//#define ANYCUBIC_TFT_DEBUG
-
 //=============================================================================
 //============================  Other Controllers  ============================
 //=============================================================================

Marlin/src/HAL/AVR/HAL.h

   #define DGUS_SERIAL_GET_TX_BUFFER_FREE DGUS_SERIAL.get_tx_buffer_free
 #endif
 
+#ifdef ANYCUBIC_LCD_SERIAL_PORT
+  #if !WITHIN(ANYCUBIC_LCD_SERIAL_PORT, -1, 3)
+    #error "ANYCUBIC_LCD_SERIAL_PORT must be from -1 to 3. Please update your configuration."
+  #elif ANYCUBIC_LCD_SERIAL_PORT == SERIAL_PORT
+    #error "ANYCUBIC_LCD_SERIAL_PORT must be different than SERIAL_PORT. Please update your configuration."
+  #elif defined(SERIAL_PORT_2) && ANYCUBIC_LCD_SERIAL_PORT == SERIAL_PORT_2
+    #error "ANYCUBIC_LCD_SERIAL_PORT must be different than SERIAL_PORT_2. Please update your configuration."
+  #endif
+  #define ANYCUBIC_LCD_SERIAL anycubicLcdSerial
+#endif
+
 // ------------------------
 // Public functions
 // ------------------------

Marlin/src/HAL/AVR/MarlinSerial.cpp

 
 #endif
 
+#ifdef ANYCUBIC_LCD_SERIAL_PORT
+
+  ISR(SERIAL_REGNAME(USART,ANYCUBIC_LCD_SERIAL_PORT,_RX_vect)) {
+    MarlinSerial<AnycubicLcdSerialCfg<ANYCUBIC_LCD_SERIAL_PORT>>::store_rxd_char();
+  }
+
+  ISR(SERIAL_REGNAME(USART,ANYCUBIC_LCD_SERIAL_PORT,_UDRE_vect)) {
+    MarlinSerial<AnycubicLcdSerialCfg<ANYCUBIC_LCD_SERIAL_PORT>>::_tx_udr_empty_irq();
+  }
+
+  // Preinstantiate
+  template class MarlinSerial<AnycubicLcdSerialCfg<ANYCUBIC_LCD_SERIAL_PORT>>;
+
+  // Instantiate
+  MarlinSerial<AnycubicLcdSerialCfg<ANYCUBIC_LCD_SERIAL_PORT>> anycubicLcdSerial;
+
+#endif
+
 // For AT90USB targets use the UART for BT interfacing
 #if defined(USBCON) && ENABLED(BLUETOOTH)
   HardwareSerial bluetoothSerial;

Marlin/src/HAL/AVR/MarlinSerial.h

   extern MarlinSerial<MarlinInternalSerialCfg<DGUS_SERIAL_PORT>> internalDgusSerial;
 #endif
 
+#ifdef ANYCUBIC_LCD_SERIAL_PORT
+  template <uint8_t serial>
+  struct AnycubicLcdSerialCfg {
+    static constexpr int PORT               = serial;
+    static constexpr unsigned int RX_SIZE   = 64;
+    static constexpr unsigned int TX_SIZE   = 128;
+    static constexpr bool XONOFF            = false;
+    static constexpr bool EMERGENCYPARSER   = false;
+    static constexpr bool DROPPED_RX        = false;
+    static constexpr bool RX_OVERRUNS       = false;
+    static constexpr bool RX_FRAMING_ERRORS = false;
+    static constexpr bool MAX_RX_QUEUED     = false;
+  };
+
+  extern MarlinSerial<AnycubicLcdSerialCfg<ANYCUBIC_LCD_SERIAL_PORT>> anycubicLcdSerial;
+#endif
+
 // Use the UART for Bluetooth in AT90USB configurations
 #if defined(USBCON) && ENABLED(BLUETOOTH)
   extern HardwareSerial bluetoothSerial;

Marlin/src/inc/Conditionals_LCD.h

 #endif
 
 // Extensible UI serial touch screens. (See src/lcd/extui)
-#if ANY(HAS_DGUS_LCD, MALYAN_LCD, TOUCH_UI_FTDI_EVE)
+#if ANY(HAS_DGUS_LCD, MALYAN_LCD, TOUCH_UI_FTDI_EVE, ANYCUBIC_LCD_I3MEGA, ANYCUBIC_LCD_CHIRON)
   #define IS_EXTUI
   #define EXTENSIBLE_UI
 #endif

Marlin/src/inc/SanityCheck.h

   #error "DIGIPOT_I2C is now DIGIPOT_MCP4451 (or DIGIPOT_MCP4018). Please update Configuration_adv.h."
 #elif defined(TOUCH_BUTTONS)
   #error "TOUCH_BUTTONS is now TOUCH_SCREEN. Please update your Configuration.h."
+#elif defined(ANYCUBIC_TFT_MODEL)
+  #error "ANYCUBIC_TFT_MODEL is now ANYCUBIC_LCD_I3MEGA. Please update your Configuration.h."
 #endif
 
 #ifdef FIL_RUNOUT_INVERTING
   + ENABLED(TFT_320x240_SPI) \
   + ENABLED(FSMC_GRAPHICAL_TFT) \
   + ENABLED(TFT_LVGL_UI_FSMC) \
-  + ENABLED(TFT_LVGL_UI_SPI)
+  + ENABLED(TFT_LVGL_UI_SPI) \
+  + ENABLED(ANYCUBIC_LCD_I3MEGA) \
+  + ENABLED(ANYCUBIC_LCD_CHIRON)
   #error "Please select no more than one LCD controller option."
 #endif
 

Marlin/src/lcd/extui/lib/anycubic/anycubic_serial.cpp

-/*
-  anycubic_serial.cpp  --- Support for Anycubic i3 Mega TFT serial connection
-  Created by Christian Hopp on 09.12.17.
-
-  Original file:
-  HardwareSerial.cpp - Hardware serial library for Wiring
-  Copyright (c) 2006 Nicholas Zambetti.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public
-  License along with this library; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-  Modified 23 November 2006 by David A. Mellis
-  Modified 28 September 2010 by Mark Sproul
-  Modified 14 August 2012 by Alarus
-*/
-
-#include "../../../../inc/MarlinConfig.h"
-
-#if ENABLED(ANYCUBIC_TFT_MODEL)
-
-#include <Arduino.h>
-
-// This next line disables the entire anycubic_serial.cpp,
-// to support AtTiny series and other chips without a UART
-#ifdef UBRR3H
-
-#include "anycubic_serial.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <inttypes.h>
-#include "wiring_private.h"
-
-// Define constants and variables for buffering incoming serial data.  We're
-// using a ring buffer (I think), in which head is the index of the location
-// to which to write the next incoming character and tail is the index of the
-// location from which to read.
-#if (RAMEND < 1000)
-  #define SERIAL_BUFFER_SIZE 64
-#else
-  #define SERIAL_BUFFER_SIZE 128
-#endif
-
-struct ring_buffer {
-  unsigned char buffer[SERIAL_BUFFER_SIZE];
-  volatile unsigned int head;
-  volatile unsigned int tail;
-};
-
-ring_buffer rx_buffer_ajg  =  { { 0 }, 0, 0 };
-ring_buffer tx_buffer_ajg  =  { { 0 }, 0, 0 };
-
-inline void store_char(unsigned char c, ring_buffer *buffer) {
-  int i = (unsigned int)(buffer->head + 1) % SERIAL_BUFFER_SIZE;
-
-  // 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 != buffer->tail) {
-    buffer->buffer[buffer->head] = c;
-    buffer->head = i;
-  }
-}
-
-#if defined(USART3_RX_vect) && defined(UDR3)
-  void serialEvent3() __attribute__((weak));
-  void serialEvent3() {}
-  #define serialEvent3_implemented
-  ISR(USART3_RX_vect) {
-    if (bit_is_clear(UCSR3A, UPE3)) {
-      unsigned char c = UDR3;
-      store_char(c, &rx_buffer_ajg);
-    }
-    else {
-      unsigned char c = UDR3;
-    }
-  }
-#endif
-
-#ifdef USART3_UDRE_vect
-
-  ISR(USART3_UDRE_vect) {
-    if (tx_buffer_ajg.head == tx_buffer_ajg.tail) {
-  	// Buffer empty, so disable interrupts
-      cbi(UCSR3B, UDRIE3);
-    }
-    else {
-      // There is more data in the output buffer. Send the next byte
-      unsigned char c = tx_buffer_ajg.buffer[tx_buffer_ajg.tail];
-      tx_buffer_ajg.tail = (tx_buffer_ajg.tail + 1) % SERIAL_BUFFER_SIZE;
-
-      UDR3 = c;
-    }
-  }
-
-#endif
-
-// Constructors ////////////////////////////////////////////////////////////////
-
-AnycubicSerialClass::AnycubicSerialClass(ring_buffer *rx_buffer, ring_buffer *tx_buffer,
-  volatile uint8_t *ubrrh, volatile uint8_t *ubrrl,
-  volatile uint8_t *ucsra, volatile uint8_t *ucsrb,
-  volatile uint8_t *ucsrc, volatile uint8_t *udr,
-  uint8_t rxen, uint8_t txen, uint8_t rxcie, uint8_t udrie, uint8_t u2x
-) {
-  _rx_buffer = rx_buffer;
-  _tx_buffer = tx_buffer;
-  _ubrrh = ubrrh;
-  _ubrrl = ubrrl;
-  _ucsra = ucsra;
-  _ucsrb = ucsrb;
-  _ucsrc = ucsrc;
-  _udr = udr;
-  _rxen = rxen;
-  _txen = txen;
-  _rxcie = rxcie;
-  _udrie = udrie;
-  _u2x = u2x;
-}
-
-// Public Methods //////////////////////////////////////////////////////////////
-
-void AnycubicSerialClass::begin(unsigned long baud) {
-  uint16_t baud_setting;
-  bool use_u2x = true;
-
-  #if F_CPU == 16000000UL
-    // hardcoded 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) use_u2x = false;
-  #endif
-
-try_again:
-
-  if (use_u2x) {
-    *_ucsra = 1 << _u2x;
-    baud_setting = (F_CPU / 4 / baud - 1) / 2;
-  } else {
-    *_ucsra = 0;
-    baud_setting = (F_CPU / 8 / baud - 1) / 2;
-  }
-
-  if ((baud_setting > 4095) && use_u2x) {
-    use_u2x = false;
-    goto try_again;
-  }
-
-  // assign the baud_setting, a.k.a. ubbr (USART Baud Rate Register)
-  *_ubrrh = baud_setting >> 8;
-  *_ubrrl = baud_setting;
-
-  transmitting = false;
-
-  sbi(*_ucsrb, _rxen);
-  sbi(*_ucsrb, _txen);
-  sbi(*_ucsrb, _rxcie);
-  cbi(*_ucsrb, _udrie);
-}
-
-void AnycubicSerialClass::begin(unsigned long baud, byte config) {
-  uint16_t baud_setting;
-  uint8_t current_config;
-  bool use_u2x = true;
-
-  #if F_CPU == 16000000UL
-    // hardcoded 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) use_u2x = false;
-  #endif
-
-try_again:
-
-  if (use_u2x) {
-    *_ucsra = 1 << _u2x;
-    baud_setting = (F_CPU / 4 / baud - 1) / 2;
-  }
-  else {
-    *_ucsra = 0;
-    baud_setting = (F_CPU / 8 / baud - 1) / 2;
-  }
-
-  if ((baud_setting > 4095) && use_u2x) {
-    use_u2x = false;
-    goto try_again;
-  }
-
-  // assign the baud_setting, a.k.a. ubbr (USART Baud Rate Register)
-  *_ubrrh = baud_setting >> 8;
-  *_ubrrl = baud_setting;
-
-  //set the data bits, parity, and stop bits
-  #ifdef __AVR_ATmega8__
-    config |= 0x80; // select UCSRC register (shared with UBRRH)
-  #endif
-  *_ucsrc = config;
-
-  sbi(*_ucsrb, _rxen);
-  sbi(*_ucsrb, _txen);
-  sbi(*_ucsrb, _rxcie);
-  cbi(*_ucsrb, _udrie);
-}
-
-void AnycubicSerialClass::end() {
-  // wait for transmission of outgoing data
-  while (_tx_buffer->head != _tx_buffer->tail)
-    ;
-
-  cbi(*_ucsrb, _rxen);
-  cbi(*_ucsrb, _txen);
-  cbi(*_ucsrb, _rxcie);
-  cbi(*_ucsrb, _udrie);
-
-  // clear any received data
-  _rx_buffer->head = _rx_buffer->tail;
-}
-
-int AnycubicSerialClass::available(void) {
-  return (int)(SERIAL_BUFFER_SIZE + _rx_buffer->head - _rx_buffer->tail) % SERIAL_BUFFER_SIZE;
-}
-
-int AnycubicSerialClass::peek(void) {
-  if (_rx_buffer->head == _rx_buffer->tail) {
-    return -1;
-  } else {
-    return _rx_buffer->buffer[_rx_buffer->tail];
-  }
-}
-
-int AnycubicSerialClass::read(void) {
-  // if the head isn't ahead of the tail, we don't have any characters
-  if (_rx_buffer->head == _rx_buffer->tail) {
-    return -1;
-  } else {
-    unsigned char c = _rx_buffer->buffer[_rx_buffer->tail];
-    _rx_buffer->tail = (unsigned int)(_rx_buffer->tail + 1) % SERIAL_BUFFER_SIZE;
-    return c;
-  }
-}
-
-void AnycubicSerialClass::flush() {
-  // UDR is kept full while the buffer is not empty, so TXC triggers when EMPTY && SENT
-  while (transmitting && ! (*_ucsra & _BV(TXC0)));
-  transmitting = false;
-}
-
-size_t AnycubicSerialClass::write(uint8_t c) {
-  int i = (_tx_buffer->head + 1) % SERIAL_BUFFER_SIZE;
-
-  // If the output buffer is full, there's nothing for it other than to
-  // wait for the interrupt handler to empty it a bit
-  // ???: return 0 here instead?
-  while (i == _tx_buffer->tail)
-    ;
-
-  _tx_buffer->buffer[_tx_buffer->head] = c;
-  _tx_buffer->head = i;
-
-  sbi(*_ucsrb, _udrie);
-  // clear the TXC bit -- "can be cleared by writing a one to its bit location"
-  transmitting = true;
-  sbi(*_ucsra, TXC0);
-
-  return 1;
-}
-
-AnycubicSerialClass::operator bool() {
-	return true;
-}
-
-// Preinstantiate Objects //////////////////////////////////////////////////////
-
-AnycubicSerialClass AnycubicSerial(&rx_buffer_ajg, &tx_buffer_ajg, &UBRR3H, &UBRR3L, &UCSR3A, &UCSR3B, &UCSR3C, &UDR3, RXEN3, TXEN3, RXCIE3, UDRIE3, U2X3);
-
-#endif // UBRR3H
-#endif // ANYCUBIC_TFT_MODEL

Marlin/src/lcd/extui/lib/anycubic/anycubic_serial.h

-/*
-  anycubic_serial.h  --- Support for Anycubic i3 Mega TFT serial connection
-  Created by Christian Hopp on 09.12.17.
-
-  Original file:
-
-  HardwareSerial.h - Hardware serial library for Wiring
-  Copyright (c) 2006 Nicholas Zambetti.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public
-  License along with this library; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-  Modified 28 September 2010 by Mark Sproul
-  Modified 14 August 2012 by Alarus
-*/
-#pragma once
-
-#include <inttypes.h>
-#include <avr/pgmspace.h>
-
-#include "Stream.h"
-
-#define FORCE_INLINE __attribute__((always_inline)) inline
-
-struct ring_buffer;
-
-class AnycubicSerialClass : public Stream {
-  private:
-    ring_buffer *_rx_buffer;
-    ring_buffer *_tx_buffer;
-    volatile uint8_t *_ubrrh;
-    volatile uint8_t *_ubrrl;
-    volatile uint8_t *_ucsra;
-    volatile uint8_t *_ucsrb;
-    volatile uint8_t *_ucsrc;
-    volatile uint8_t *_udr;
-    uint8_t _rxen;
-    uint8_t _txen;
-    uint8_t _rxcie;
-    uint8_t _udrie;
-    uint8_t _u2x;
-    bool transmitting;
-  public:
-    AnycubicSerialClass(ring_buffer *rx_buffer, ring_buffer *tx_buffer,
-      volatile uint8_t *ubrrh, volatile uint8_t *ubrrl,
-      volatile uint8_t *ucsra, volatile uint8_t *ucsrb,
-      volatile uint8_t *ucsrc, volatile uint8_t *udr,
-      uint8_t rxen, uint8_t txen, uint8_t rxcie, uint8_t udrie, uint8_t u2x
-    );
-    void begin(unsigned long);
-    void begin(unsigned long, uint8_t);
-    void end();
-    virtual int available(void);
-    virtual int peek(void);
-    virtual int read(void);
-    virtual void flush(void);
-    virtual size_t write(uint8_t);
-    inline size_t write(unsigned long n) { return write((uint8_t)n); }
-    inline size_t write(long n) { return write((uint8_t)n); }
-    inline size_t write(unsigned int n) { return write((uint8_t)n); }
-    inline size_t write(int n) { return write((uint8_t)n); }
-    using Print::write; // pull in write(str) and write(buf, size) from Print
-    operator bool();
-};
-
-// Define config for Serial.begin(baud, config);
-#define SERIAL_5N1 0x00
-#define SERIAL_6N1 0x02
-#define SERIAL_7N1 0x04
-#define SERIAL_8N1 0x06
-#define SERIAL_5N2 0x08
-#define SERIAL_6N2 0x0A
-#define SERIAL_7N2 0x0C
-#define SERIAL_8N2 0x0E
-#define SERIAL_5E1 0x20
-#define SERIAL_6E1 0x22
-#define SERIAL_7E1 0x24
-#define SERIAL_8E1 0x26
-#define SERIAL_5E2 0x28
-#define SERIAL_6E2 0x2A
-#define SERIAL_7E2 0x2C
-#define SERIAL_8E2 0x2E
-#define SERIAL_5O1 0x30
-#define SERIAL_6O1 0x32
-#define SERIAL_7O1 0x34
-#define SERIAL_8O1 0x36
-#define SERIAL_5O2 0x38
-#define SERIAL_6O2 0x3A
-#define SERIAL_7O2 0x3C
-#define SERIAL_8O2 0x3E
-
-extern void serialEventRun(void) __attribute__((weak));
-
-#define ANYCUBIC_SERIAL_PROTOCOL(x) (AnycubicSerial.print(x))
-#define ANYCUBIC_SERIAL_PROTOCOL_F(x,y) (AnycubicSerial.print(x, y))
-#define ANYCUBIC_SERIAL_PROTOCOLPGM(x) (AnycubicSerialprintPGM(PSTR(x)))
-#define ANYCUBIC_SERIAL_(x) (AnycubicSerial.print(x), AnycubicSerial.write('\n'))
-#define ANYCUBIC_SERIAL_PROTOCOLLN(x) (AnycubicSerial.print(x), AnycubicSerial.write('\r'), AnycubicSerial.write('\n'))
-#define ANYCUBIC_SERIAL_PROTOCOLLNPGM(x) (AnycubicSerialprintPGM(PSTR(x)), AnycubicSerial.write('\r'), AnycubicSerial.write('\n'))
-
-#define ANYCUBIC_SERIAL_START() (AnycubicSerial.write('\r'), AnycubicSerial.write('\n'))
-#define ANYCUBIC_SERIAL_CMD_SEND(x) (AnycubicSerialprintPGM(PSTR(x)), AnycubicSerial.write('\r'), AnycubicSerial.write('\n'))
-#define ANYCUBIC_SERIAL_ENTER() (AnycubicSerial.write('\r'), AnycubicSerial.write('\n'))
-#define ANYCUBIC_SERIAL_SPACE() (AnycubicSerial.write(' '))
-
-const char newErr[] PROGMEM = "ERR ";
-const char newSucc[] PROGMEM = "OK";
-
-#define ANYCUBIC_SERIAL_ERROR_START (AnycubicSerialprintPGM(newErr))
-#define ANYCUBIC_SERIAL_ERROR(x) ANYCUBIC_SERIAL_PROTOCOL(x)
-#define ANYCUBIC_SERIAL_ERRORPGM(x) ANYCUBIC_SERIAL_PROTOCOLPGM(x)
-#define ANYCUBIC_SERIAL_ERRORLN(x) ANYCUBIC_SERIAL_PROTOCOLLN(x)
-#define ANYCUBIC_SERIAL_ERRORLNPGM(x) ANYCUBIC_SERIAL_PROTOCOLLNPGM(x)
-
-//##define ANYCUBIC_SERIAL_ECHO_START (AnycubicSerialprintPGM(newSucc))
-#define ANYCUBIC_SERIAL_ECHOLN(x) ANYCUBIC_SERIAL_PROTOCOLLN(x)
-#define ANYCUBIC_SERIAL_SUCC_START (AnycubicSerialprintPGM(newSucc))
-#define ANYCUBIC_SERIAL_ECHOPAIR(name,value) (serial_echopair_P(PSTR(name),(value)))
-#define ANYCUBIC_SERIAL_ECHOPGM(x) ANYCUBIC_SERIAL_PROTOCOLPGM(x)
-#define ANYCUBIC_SERIAL_ECHO(x) ANYCUBIC_SERIAL_PROTOCOL(x)
-
-#ifdef UBRR3H
-
-  extern AnycubicSerialClass AnycubicSerial;
-
-  FORCE_INLINE void AnycubicSerialprintPGM(const char *str) {
-    char ch = pgm_read_byte(str);
-    while (ch) {
-      AnycubicSerial.write(ch);
-      ch = pgm_read_byte(++str);
-    }
-  }
-
-#endif

Marlin/src/lcd/extui/lib/anycubic/anycubic_tft.cpp → Marlin/src/lcd/extui/lib/anycubic_i3mega/anycubic_i3mega_lcd.cpp

 /**
- * anycubic_tft.cpp  --- Support for Anycubic i3 Mega TFT
+ * anycubic_i3mega_lcd.cpp  --- Support for Anycubic i3 Mega TFT
  * Created by Christian Hopp on 09.12.17.
  * Improved by David Ramiro
  * Converted to ext_iu by John BouAntoun 21 June 2020
 
 #include "../../../../inc/MarlinConfigPre.h"
 
-#if ENABLED(ANYCUBIC_TFT_MODEL)
+#if ENABLED(ANYCUBIC_LCD_I3MEGA)
 
-#include "anycubic_tft.h"
-#include "anycubic_serial.h"
+#include "anycubic_i3mega_lcd.h"
 
 #include "../../../../inc/MarlinConfig.h"
 #include "../../ui_api.h"
 #include "../../../../MarlinCore.h" // for quickstop_stepper and disable_steppers
 
+// command sending macro's with debugging capability
+#define SEND_PGM(x)                                 send_P(PSTR(x))
+#define SENDLINE_PGM(x)                             sendLine_P(PSTR(x))
+#define SEND_PGM_VAL(x,y)                           (send_P(PSTR(x)), sendLine(itostr3(y)))
+#define SEND(x)                                     send(x)
+#define SENDLINE(x)                                 sendLine(x)
+#if ENABLED(ANYCUBIC_LCD_DEBUG)
+  #define SENDLINE_DBG_PGM(x,y)                     (sendLine_P(PSTR(x)), SERIAL_ECHOLNPGM(y))
+  #define SENDLINE_DBG_PGM_VAL(x,y,z)               (sendLine_P(PSTR(x)), SERIAL_ECHOPGM(y), SERIAL_ECHOLN(z))
+#else
+  #define SENDLINE_DBG_PGM(x,y)                     sendLine_P(PSTR(x))
+  #define SENDLINE_DBG_PGM_VAL(x,y,z)               sendLine_P(PSTR(x))
+#endif
+
+
 AnycubicTFTClass AnycubicTFT;
 
 char _conv[8];
   return _conv;
 }
 
+static void sendNewLine(void) {
+  ANYCUBIC_LCD_SERIAL.write('\r');
+  ANYCUBIC_LCD_SERIAL.write('\n');
+}
+
+static void send(const char *str) {
+  ANYCUBIC_LCD_SERIAL.print(str);
+}
+
+static void sendLine(const char *str) {
+  send(str);
+  sendNewLine();
+}
+
+static void send_P(PGM_P str) {
+  while (const char c = pgm_read_byte(str++))
+    ANYCUBIC_LCD_SERIAL.write(c);
+}
+
+static void sendLine_P(PGM_P str) {
+  send_P(str);
+  sendNewLine();
+}
+
 #ifndef ULTRA_LCD
   #define DIGIT(n) ('0' + (n))
   #define DIGIMOD(n, f) DIGIT((n) / (f) % 10)
 AnycubicTFTClass::AnycubicTFTClass() {}
 
 void AnycubicTFTClass::OnSetup() {
-  AnycubicSerial.begin(115200);
-  ANYCUBIC_SENDCOMMAND_DBG_PGM("J17", "TFT Serial Debug: Main board reset... J17"); // J17 Main board reset
+  ANYCUBIC_LCD_SERIAL.begin(115200);
+  SENDLINE_DBG_PGM("J17", "TFT Serial Debug: Main board reset... J17"); // J17 Main board reset
   ExtUI::delay_ms(10);
 
   // initialise the state of the key pins running on the tft
   mediaPauseState = AMPAUSESTATE_NOT_PAUSED;
 
   // DoSDCardStateCheck();
-  ANYCUBIC_SENDCOMMAND_DBG_PGM("J12", "TFT Serial Debug: Ready... J12"); // J12 Ready
+  SENDLINE_DBG_PGM("J12", "TFT Serial Debug: Ready... J12"); // J12 Ready
   ExtUI::delay_ms(10);
 
   DoFilamentRunoutCheck();
   #if ENABLED(STARTUP_CHIME)
     ExtUI::injectCommands_P(PSTR("M300 P250 S554\nM300 P250 S554\nM300 P250 S740\nM300 P250 S554\nM300 P250 S740\nM300 P250 S554\nM300 P500 S831"));
   #endif
-  #if ENABLED(ANYCUBIC_TFT_DEBUG)
+  #if ENABLED(ANYCUBIC_LCD_DEBUG)
     SERIAL_ECHOLNPGM("TFT Serial Debug: Finished startup");
   #endif
 }
   if (ELAPSED(ms, nextStopCheck)) {
     nextStopCheck = ms + 1000UL;
     if (mediaPrintingState == AMPRINTSTATE_STOP_REQUESTED && IsNozzleHomed()) {
-      #if ENABLED(ANYCUBIC_TFT_DEBUG)
+      #if ENABLED(ANYCUBIC_LCD_DEBUG)
         SERIAL_ECHOLNPGM("TFT Serial Debug: Finished stopping print, releasing motors ...");
       #endif
       mediaPrintingState = AMPRINTSTATE_NOT_PRINTING;
       ExtUI::injectCommands_P(PSTR("M84\nM27")); // disable stepper motors and force report of SD status
       ExtUI::delay_ms(200);
       // tell printer to release resources of print to indicate it is done
-      ANYCUBIC_SENDCOMMAND_DBG_PGM("J14", "TFT Serial Debug: SD Print Stopped... J14");
+      SENDLINE_DBG_PGM("J14", "TFT Serial Debug: SD Print Stopped... J14");
     }
   }
 
 }
 
 void AnycubicTFTClass::OnKillTFT() {
-  ANYCUBIC_SENDCOMMAND_DBG_PGM("J11", "TFT Serial Debug: Kill command... J11");
+  SENDLINE_DBG_PGM("J11", "TFT Serial Debug: Kill command... J11");
 }
 
 void AnycubicTFTClass::OnSDCardStateChange(bool isInserted) {
-  #if ENABLED(ANYCUBIC_TFT_DEBUG)
+  #if ENABLED(ANYCUBIC_LCD_DEBUG)
     SERIAL_ECHOPGM("TFT Serial Debug: OnSDCardStateChange event triggered...");
     SERIAL_ECHO(itostr2(isInserted));
     SERIAL_EOL();
 }
 
 void AnycubicTFTClass::OnSDCardError() {
-  #if ENABLED(ANYCUBIC_TFT_DEBUG)
+  #if ENABLED(ANYCUBIC_LCD_DEBUG)
     SERIAL_ECHOLNPGM("TFT Serial Debug: OnSDCardError event triggered...");
   #endif
-  ANYCUBIC_SENDCOMMAND_DBG_PGM("J21", "TFT Serial Debug: On SD Card Error ... J21");
+  SENDLINE_DBG_PGM("J21", "TFT Serial Debug: On SD Card Error ... J21");
 }
 
 void AnycubicTFTClass::OnFilamentRunout() {
-  #if ENABLED(ANYCUBIC_TFT_DEBUG)
+  #if ENABLED(ANYCUBIC_LCD_DEBUG)
     SERIAL_ECHOLNPGM("TFT Serial Debug: FilamentRunout triggered...");
   #endif
   DoFilamentRunoutCheck();
 }
 
 void AnycubicTFTClass::OnUserConfirmRequired(const char * const msg) {
-  #if ENABLED(ANYCUBIC_TFT_DEBUG)
+  #if ENABLED(ANYCUBIC_LCD_DEBUG)
     SERIAL_ECHOPGM("TFT Serial Debug: OnUserConfirmRequired triggered... ");
     SERIAL_ECHOLN(msg);
   #endif
       mediaPrintingState = AMPRINTSTATE_PAUSED;
       mediaPauseState    = AMPAUSESTATE_PARKED;
       // enable continue button
-      ANYCUBIC_SENDCOMMAND_DBG_PGM("J18", "TFT Serial Debug: UserConfirm SD print paused done... J18");
+      SENDLINE_DBG_PGM("J18", "TFT Serial Debug: UserConfirm SD print paused done... J18");
     }
     else if (strcmp_P(msg, PSTR("Load Filament")) == 0) {
       mediaPrintingState = AMPRINTSTATE_PAUSED;
       mediaPauseState    = AMPAUSESTATE_FILAMENT_OUT;
       // enable continue button
-      ANYCUBIC_SENDCOMMAND_DBG_PGM("J18", "TFT Serial Debug: UserConfirm Filament is out... J18");
-      ANYCUBIC_SENDCOMMAND_DBG_PGM("J23", "TFT Serial Debug: UserConfirm Blocking filament prompt... J23");
+      SENDLINE_DBG_PGM("J18", "TFT Serial Debug: UserConfirm Filament is out... J18");
+      SENDLINE_DBG_PGM("J23", "TFT Serial Debug: UserConfirm Blocking filament prompt... J23");
     }
     else if (strcmp_P(msg, PSTR("Filament Purging...")) == 0) {
       mediaPrintingState = AMPRINTSTATE_PAUSED;
       mediaPauseState    = AMPAUSESTATE_PARKING;
       // TODO: JBA I don't think J05 just disables the continue button, i think it injects a rogue M25. So taking this out
       // disable continue button
-      // ANYCUBIC_SENDCOMMAND_DBG_PGM("J05", "TFT Serial Debug: UserConfirm SD Filament Purging... J05"); // J05 printing pause
+      // SENDLINE_DBG_PGM("J05", "TFT Serial Debug: UserConfirm SD Filament Purging... J05"); // J05 printing pause
 
       // enable continue button
-      ANYCUBIC_SENDCOMMAND_DBG_PGM("J18", "TFT Serial Debug: UserConfirm Filament is purging... J18");
+      SENDLINE_DBG_PGM("J18", "TFT Serial Debug: UserConfirm Filament is purging... J18");
     }
     else if (strcmp_P(msg, PSTR("HeaterTimeout")) == 0) {
       mediaPrintingState = AMPRINTSTATE_PAUSED;
       mediaPauseState    = AMPAUSESTATE_HEATER_TIMEOUT;
       // enable continue button
-      ANYCUBIC_SENDCOMMAND_DBG_PGM("J18", "TFT Serial Debug: UserConfirm SD Heater timeout... J18");
+      SENDLINE_DBG_PGM("J18", "TFT Serial Debug: UserConfirm SD Heater timeout... J18");
     }
     else if (strcmp_P(msg, PSTR("Reheat finished.")) == 0) {
       mediaPrintingState = AMPRINTSTATE_PAUSED;
       mediaPauseState    = AMPAUSESTATE_REHEAT_FINISHED;
       // enable continue button
-      ANYCUBIC_SENDCOMMAND_DBG_PGM("J18", "TFT Serial Debug: UserConfirm SD Reheat done... J18");
+      SENDLINE_DBG_PGM("J18", "TFT Serial Debug: UserConfirm SD Reheat done... J18");
     }
   #endif
 }
           default:
             break;
     }
-    #if ENABLED(ANYCUBIC_TFT_DEBUG)
+    #if ENABLED(ANYCUBIC_LCD_DEBUG)
   }
   else {
     SERIAL_ECHOPGM("TFT Serial Debug: Attempted to HandleSpecialMenu on non-special menu... ");
     SelectedDirectory[0] = 0;
     SelectedFile[0] = 0;
 
-    ANYCUBIC_SERIAL_PROTOCOLPGM("FN "); // Filelist start
-    ANYCUBIC_SERIAL_ENTER();
+    SENDLINE_PGM("FN "); // Filelist start
 
     if (!ExtUI::isMediaInserted() && !SpecialMenu) {
-      ANYCUBIC_SENDCOMMAND_DBG_PGM("J02", "TFT Serial Debug: No SD Card mounted to render Current File List... J02");
+      SENDLINE_DBG_PGM("J02", "TFT Serial Debug: No SD Card mounted to render Current File List... J02");
 
-      ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Special_Menu>");
-      ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Special_Menu>");
+      SENDLINE_PGM("<Special_Menu>");
+      SENDLINE_PGM("<Special_Menu>");
     }
     else {
       if (CodeSeen('S'))
       else
         RenderCurrentFolder(selectedNumber);
     }
-    ANYCUBIC_SERIAL_PROTOCOLPGM("END"); // Filelist stop
-    ANYCUBIC_SERIAL_ENTER();
+    SENDLINE_PGM("END"); // Filelist stop
   #endif // SDSUPPORT
 }
 
   switch (selectedNumber) {
     #if ENABLED(PROBE_MANUALLY)
       case 0: // First Page
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<01ZUp0.1>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Z Up 0.1>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<02ZUp0.02>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Z Up 0.02>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<03ZDn0.02>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Z Down 0.02>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<04ZDn0.1>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Z Down 0.1>");
+        SENDLINE_PGM("<01ZUp0.1>");
+        SENDLINE_PGM("<Z Up 0.1>");
+        SENDLINE_PGM("<02ZUp0.02>");
+        SENDLINE_PGM("<Z Up 0.02>");
+        SENDLINE_PGM("<03ZDn0.02>");
+        SENDLINE_PGM("<Z Down 0.02>");
+        SENDLINE_PGM("<04ZDn0.1>");
+        SENDLINE_PGM("<Z Down 0.1>");
         break;
 
       case 4: // Second Page
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<05PrehtBed>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Preheat bed>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<06SMeshLvl>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Start Mesh Leveling>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<07MeshNPnt>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Next Mesh Point>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<08HtEndPID>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Auto Tune Hotend PID>");
+        SENDLINE_PGM("<05PrehtBed>");
+        SENDLINE_PGM("<Preheat bed>");
+        SENDLINE_PGM("<06SMeshLvl>");
+        SENDLINE_PGM("<Start Mesh Leveling>");
+        SENDLINE_PGM("<07MeshNPnt>");
+        SENDLINE_PGM("<Next Mesh Point>");
+        SENDLINE_PGM("<08HtEndPID>");
+        SENDLINE_PGM("<Auto Tune Hotend PID>");
         break;
 
       case 8: // Third Page
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<09HtBedPID>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Auto Tune Hotbed PID>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<10FWDeflts>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Load FW Defaults>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<11SvEEPROM>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Save EEPROM>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Exit>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Exit>");
+        SENDLINE_PGM("<09HtBedPID>");
+        SENDLINE_PGM("<Auto Tune Hotbed PID>");
+        SENDLINE_PGM("<10FWDeflts>");
+        SENDLINE_PGM("<Load FW Defaults>");
+        SENDLINE_PGM("<11SvEEPROM>");
+        SENDLINE_PGM("<Save EEPROM>");
+        SENDLINE_PGM("<Exit>");
+        SENDLINE_PGM("<Exit>");
         break;
     #else
       case 0: // First Page
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<01PrehtBed>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Preheat bed>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<02ABL>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Auto Bed Leveling>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<03HtEndPID>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Auto Tune Hotend PID>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<04HtBedPID>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Auto Tune Hotbed PID>");
+        SENDLINE_PGM("<01PrehtBed>");
+        SENDLINE_PGM("<Preheat bed>");
+        SENDLINE_PGM("<02ABL>");
+        SENDLINE_PGM("<Auto Bed Leveling>");
+        SENDLINE_PGM("<03HtEndPID>");
+        SENDLINE_PGM("<Auto Tune Hotend PID>");
+        SENDLINE_PGM("<04HtBedPID>");
+        SENDLINE_PGM("<Auto Tune Hotbed PID>");
         break;
 
       case 4: // Second Page
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<05FWDeflts>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Load FW Defaults>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<06SvEEPROM>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Save EEPROM>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<07SendM108>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Send User Confirmation>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Exit>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Exit>");
+        SENDLINE_PGM("<05FWDeflts>");
+        SENDLINE_PGM("<Load FW Defaults>");
+        SENDLINE_PGM("<06SvEEPROM>");
+        SENDLINE_PGM("<Save EEPROM>");
+        SENDLINE_PGM("<07SendM108>");
+        SENDLINE_PGM("<Send User Confirmation>");
+        SENDLINE_PGM("<Exit>");
+        SENDLINE_PGM("<Exit>");
         break;
 
         #endif // PROBE_MANUALLY
   for (cnt = selectedNumber; cnt <= max_files; cnt++) {
     if (cnt == 0) { // Special Entry
       if (currentFileList.isAtRootDir()) {
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<specialmnu>");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Special Menu>");
+        SENDLINE_PGM("<specialmnu>");
+        SENDLINE_PGM("<Special Menu>");
       }
       else {
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("/..");
-        ANYCUBIC_SERIAL_PROTOCOLLNPGM("/..");
+        SENDLINE_PGM("/..");
+        SENDLINE_PGM("/..");
       }
     }
     else {
       currentFileList.seek(cnt - 1, false);
 
-      #if ENABLED(ANYCUBIC_TFT_DEBUG)
+      #if ENABLED(ANYCUBIC_LCD_DEBUG)
         SERIAL_ECHOLN(currentFileList.filename());
       #endif
       if (currentFileList.isDir()) {
-        ANYCUBIC_SERIAL_PROTOCOLPGM("/");
-        ANYCUBIC_SERIAL_PROTOCOLLN(currentFileList.shortFilename());
-        ANYCUBIC_SERIAL_PROTOCOLPGM("/");
-        ANYCUBIC_SERIAL_PROTOCOLLN(currentFileList.longFilename());
+        SEND_PGM("/");
+        SENDLINE(currentFileList.shortFilename());
+        SEND_PGM("/");
+        SENDLINE(currentFileList.longFilename());
 
       }
       else {
-        ANYCUBIC_SERIAL_PROTOCOLLN(currentFileList.shortFilename());
-        ANYCUBIC_SERIAL_PROTOCOLLN(currentFileList.longFilename());
+        SENDLINE(currentFileList.shortFilename());
+        SENDLINE(currentFileList.longFilename());
       }
     }
   }
 void AnycubicTFTClass::OnPrintTimerStarted() {
   #if ENABLED(SDSUPPORT)
     if (mediaPrintingState == AMPRINTSTATE_PRINTING)
-      ANYCUBIC_SENDCOMMAND_DBG_PGM("J04", "TFT Serial Debug: Starting SD Print... J04"); // J04 Starting Print
+      SENDLINE_DBG_PGM("J04", "TFT Serial Debug: Starting SD Print... J04"); // J04 Starting Print
 
   #endif
 }
     if (mediaPrintingState == AMPRINTSTATE_PRINTING) {
       mediaPrintingState = AMPRINTSTATE_NOT_PRINTING;
       mediaPauseState    = AMPAUSESTATE_NOT_PAUSED;
-      ANYCUBIC_SENDCOMMAND_DBG_PGM("J14", "TFT Serial Debug: SD Print Completed... J14");
+      SENDLINE_DBG_PGM("J14", "TFT Serial Debug: SD Print Completed... J14");
     }
     // otherwise it was stopped by the printer so don't send print completed signal to TFT
   #endif
 
 void AnycubicTFTClass::GetCommandFromTFT() {
   char *starpos = NULL;
-  while (AnycubicSerial.available() > 0  && TFTbuflen < TFTBUFSIZE) {
-    serial3_char = AnycubicSerial.read();
+  while (ANYCUBIC_LCD_SERIAL.available() > 0  && TFTbuflen < TFTBUFSIZE) {
+    serial3_char = ANYCUBIC_LCD_SERIAL.read();
     if (serial3_char == '\n' ||
         serial3_char == '\r' ||
         serial3_char == ':'  ||
         TFTstrchr_pointer = strchr(TFTcmdbuffer[TFTbufindw], 'A');
         a_command = ((int)((strtod(&TFTcmdbuffer[TFTbufindw][TFTstrchr_pointer - TFTcmdbuffer[TFTbufindw] + 1], NULL))));
 
-        #if ENABLED(ANYCUBIC_TFT_DEBUG)
+        #if ENABLED(ANYCUBIC_LCD_DEBUG)
           if ((a_command > 7) && (a_command != 20)) { // No debugging of status polls, please!
             SERIAL_ECHOPGM("TFT Serial Command: ");
             SERIAL_ECHOLN(TFTcmdbuffer[TFTbufindw]);
         switch (a_command) {
           case 0: { // A0 GET HOTEND TEMP
             float hotendActualTemp = ExtUI::getActualTemp_celsius((ExtUI::extruder_t) (ExtUI::extruder_t) ExtUI::E0);
-            ANYCUBIC_SENDCOMMANDPGM_VAL("A0V ", int(hotendActualTemp + 0.5));
+            SEND_PGM_VAL("A0V ", int(hotendActualTemp + 0.5));
           }
           break;
 
           case 1: { // A1  GET HOTEND TARGET TEMP
             float hotendTargetTemp = ExtUI::getTargetTemp_celsius((ExtUI::extruder_t) (ExtUI::extruder_t) ExtUI::E0);
-            ANYCUBIC_SENDCOMMANDPGM_VAL("A1V ", int(hotendTargetTemp + 0.5));
+            SEND_PGM_VAL("A1V ", int(hotendTargetTemp + 0.5));
           }
           break;
 
           case 2: { // A2 GET HOTBED TEMP
             float heatedBedActualTemp = ExtUI::getActualTemp_celsius((ExtUI::heater_t) ExtUI::BED);
-            ANYCUBIC_SENDCOMMANDPGM_VAL("A2V ", int(heatedBedActualTemp + 0.5));
+            SEND_PGM_VAL("A2V ", int(heatedBedActualTemp + 0.5));
           }
           break;
 
           case 3: { // A3 GET HOTBED TARGET TEMP
             float heatedBedTargetTemp = ExtUI::getTargetTemp_celsius((ExtUI::heater_t) ExtUI::BED);
-            ANYCUBIC_SENDCOMMANDPGM_VAL("A3V ", int(heatedBedTargetTemp + 0.5));
+            SEND_PGM_VAL("A3V ", int(heatedBedTargetTemp + 0.5));
           }
           break;
 
           {
             float fanPercent = ExtUI::getActualFan_percent(ExtUI::FAN0);
             fanPercent = constrain(fanPercent, 0, 100);
-            ANYCUBIC_SENDCOMMANDPGM_VAL("A4V ", int(fanPercent));
+            SEND_PGM_VAL("A4V ", int(fanPercent));
           }
           break;
 
             float xPostition = ExtUI::getAxisPosition_mm(ExtUI::X);
             float yPostition = ExtUI::getAxisPosition_mm(ExtUI::Y);
             float zPostition = ExtUI::getAxisPosition_mm(ExtUI::Z);
-            ANYCUBIC_SERIAL_PROTOCOLPGM("A5V");
-            ANYCUBIC_SERIAL_SPACE();
-            ANYCUBIC_SERIAL_PROTOCOLPGM("X: ");
-            ANYCUBIC_SERIAL_PROTOCOL(xPostition);
-            ANYCUBIC_SERIAL_SPACE();
-            ANYCUBIC_SERIAL_PROTOCOLPGM("Y: ");
-            ANYCUBIC_SERIAL_PROTOCOL(yPostition);
-            ANYCUBIC_SERIAL_SPACE();
-            ANYCUBIC_SERIAL_PROTOCOLPGM("Z: ");
-            ANYCUBIC_SERIAL_PROTOCOL(zPostition);
-            ANYCUBIC_SERIAL_SPACE();
-            ANYCUBIC_SERIAL_ENTER();
+            SEND_PGM("A5V X: ");
+            ANYCUBIC_LCD_SERIAL.print(xPostition);
+            SEND_PGM(" Y: ");
+            ANYCUBIC_LCD_SERIAL.print(yPostition);
+            SEND_PGM(" Z: ");
+            ANYCUBIC_LCD_SERIAL.print(zPostition);
+            SENDLINE_PGM("");
           }
           break;
 
           case 6: // A6 GET SD CARD PRINTING STATUS
             #if ENABLED(SDSUPPORT)
               if (ExtUI::isPrintingFromMedia()) {
-                ANYCUBIC_SERIAL_PROTOCOLPGM("A6V ");
+                SEND_PGM("A6V ");
                 if (ExtUI::isMediaInserted()) {
-                  ANYCUBIC_SERIAL_PROTOCOL(itostr3(int(ExtUI::getProgress_percent())));
-                  ANYCUBIC_SERIAL_ENTER();
+                  SENDLINE(itostr3(int(ExtUI::getProgress_percent())));
                 }
                 else {
-                  ANYCUBIC_SENDCOMMAND_DBG_PGM("J02", "TFT Serial Debug: No SD Card mounted to return printing status... J02");
+                  SENDLINE_DBG_PGM("J02", "TFT Serial Debug: No SD Card mounted to return printing status... J02");
                 }
               }
               else {
-                ANYCUBIC_SERIAL_PROTOCOLPGM("A6V ---");
-                ANYCUBIC_SERIAL_ENTER();
+                SENDLINE_PGM("A6V ---");
               }
             #endif
             break;
 
           case 7: { // A7 GET PRINTING TIME
             uint32_t elapsedSeconds = ExtUI::getProgress_seconds_elapsed();
-            ANYCUBIC_SERIAL_PROTOCOLPGM("A7V ");
+            SEND_PGM("A7V ");
             if (elapsedSeconds != 0) {  // print time
               uint32_t elapsedMinutes = elapsedSeconds / 60;
-              ANYCUBIC_SERIAL_PROTOCOL(itostr2(elapsedMinutes / 60));
-              ANYCUBIC_SERIAL_SPACE();
-              ANYCUBIC_SERIAL_PROTOCOLPGM("H");
-              ANYCUBIC_SERIAL_SPACE();
-              ANYCUBIC_SERIAL_PROTOCOL(itostr2(elapsedMinutes % 60));
-              ANYCUBIC_SERIAL_SPACE();
-              ANYCUBIC_SERIAL_PROTOCOLPGM("M");
+              SEND(itostr2(elapsedMinutes / 60));
+              SEND_PGM(" H ");
+              SEND(itostr2(elapsedMinutes % 60));
+              SENDLINE_PGM(" M");
             }
             else {
-              ANYCUBIC_SERIAL_SPACE();
-              ANYCUBIC_SERIAL_PROTOCOLPGM("999:999");
+              SENDLINE_PGM(" 999:999");
             }
-            ANYCUBIC_SERIAL_ENTER();
           }
           break;
 
                 if (TFTstrchr_pointer[4] == '/') {
                   strcpy(SelectedDirectory, TFTstrchr_pointer + 5);
                   SelectedFile[0] = 0;
-                  ANYCUBIC_SENDCOMMAND_DBG_PGM("J21", "TFT Serial Debug: Clear file selection... J21 "); // J21 Not File Selected
-                  ANYCUBIC_SERIAL_ENTER();
+                  SENDLINE_DBG_PGM("J21", "TFT Serial Debug: Clear file selection... J21 "); // J21 Not File Selected
+                  SENDLINE_PGM("");
                 }
                 else if (TFTstrchr_pointer[4] == '<') {
                   strcpy(SelectedDirectory, TFTstrchr_pointer + 4);
                   SpecialMenu = true;
                   SelectedFile[0] = 0;
-                  ANYCUBIC_SENDCOMMAND_DBG_PGM("J21", "TFT Serial Debug: Clear file selection... J21 "); // J21 Not File Selected
-                  ANYCUBIC_SERIAL_ENTER();
+                  SENDLINE_DBG_PGM("J21", "TFT Serial Debug: Clear file selection... J21 "); // J21 Not File Selected
+                  SENDLINE_PGM("");
                 }
                 else {
                   SelectedDirectory[0] = 0;
                     *(starpos - 1) = '\0';
 
                   strcpy(SelectedFile, TFTstrchr_pointer + 4);
-                  ANYCUBIC_SENDCOMMAND_DBG_PGM_VAL("J20", "TFT Serial Debug: File Selected... J20 ", SelectedFile); // J20 File Selected
+                  SENDLINE_DBG_PGM_VAL("J20", "TFT Serial Debug: File Selected... J20 ", SelectedFile); // J20 File Selected
                 }
               }
             #endif
             }
             ExtUI::setTargetFan_percent(fanPercent, ExtUI::FAN0);
 
-            ANYCUBIC_SERIAL_ENTER();
+            SENDLINE_PGM("");
           }
           break;
 
               disable_all_steppers();
             }
 
-            ANYCUBIC_SERIAL_ENTER();
+            SENDLINE_PGM("");
             break;
 
           case 20: { // A20 read printing speed
             if (CodeSeen('S'))
               feedrate_percentage = constrain(CodeValue(), 40, 999);
             else
-              ANYCUBIC_SENDCOMMANDPGM_VAL("A20V ", feedrate_percentage);
+              SEND_PGM_VAL("A20V ", feedrate_percentage);
           }
             break;
 
 
               if (strlen(commandStr) > 0) {
                 sprintf_P(fullCommandStr, PSTR("G91\n%s\nG90"), commandStr);
-                #if ENABLED(ANYCUBIC_TFT_DEBUG)
+                #if ENABLED(ANYCUBIC_LCD_DEBUG)
                   SERIAL_ECHOPGM("TFT Serial Debug: A22 Move final request with gcode... ");
                   SERIAL_ECHOLN(fullCommandStr);
                 #endif
                 ExtUI::injectCommands(fullCommandStr);
               }
             }
-            ANYCUBIC_SERIAL_ENTER();
+            SENDLINE_PGM("");
             break;
 
           case 23: // A23 preheat pla
 
               ExtUI::setTargetTemp_celsius(PREHEAT_1_TEMP_BED, (ExtUI::heater_t) ExtUI::BED);
               ExtUI::setTargetTemp_celsius(PREHEAT_1_TEMP_HOTEND, (ExtUI::extruder_t) ExtUI::E0);
-              ANYCUBIC_SERIAL_SUCC_START;
-              ANYCUBIC_SERIAL_ENTER();
+              SENDLINE_PGM("OK");
             }
             break;
 
 
               ExtUI::setTargetTemp_celsius(PREHEAT_2_TEMP_BED, (ExtUI::heater_t) ExtUI::BED);
               ExtUI::setTargetTemp_celsius(PREHEAT_2_TEMP_HOTEND, (ExtUI::extruder_t) ExtUI::E0);
-              ANYCUBIC_SERIAL_SUCC_START;
-              ANYCUBIC_SERIAL_ENTER();
+              SENDLINE_PGM("OK");
             }
             break;
 
               ExtUI::setTargetTemp_celsius(0, (ExtUI::heater_t) ExtUI::BED);
               ExtUI::setTargetTemp_celsius(0, (ExtUI::extruder_t) ExtUI::E0);
 
-              ANYCUBIC_SENDCOMMAND_DBG_PGM("J12", "TFT Serial Debug: Cooling down... J12"); // J12 cool down
+              SENDLINE_DBG_PGM("J12", "TFT Serial Debug: Cooling down... J12"); // J12 cool down
             }
             break;
 
                 }
               }
               else {
-                ANYCUBIC_SENDCOMMAND_DBG_PGM("J02", "TFT Serial Debug: No SD Card mounted to refresh SD A26... J02");
+                SENDLINE_DBG_PGM("J02", "TFT Serial Debug: No SD Card mounted to refresh SD A26... J02");
               }
 
               SelectedDirectory[0] = 0;
               NOOP;
             else if (CodeSeen('C'))
               NOOP;
-            ANYCUBIC_SERIAL_ENTER();
+            SENDLINE_PGM("");
             break;
 
           case 33: // A33 get version info
-            ANYCUBIC_SERIAL_PROTOCOLPGM("J33 ");
-            ANYCUBIC_SERIAL_PROTOCOLPGM(DETAILED_BUILD_VERSION);
-            ANYCUBIC_SERIAL_ENTER();
+            SEND_PGM("J33 ");
+            SENDLINE_PGM(DETAILED_BUILD_VERSION);
             break;
 
           default:
   #if ENABLED(SDSUPPORT) && PIN_EXISTS(SD_DETECT)
     bool isInserted = ExtUI::isMediaInserted();
     if (isInserted)
-      ANYCUBIC_SENDCOMMAND_DBG_PGM("J00", "TFT Serial Debug: SD card state changed... isInserted");
+      SENDLINE_DBG_PGM("J00", "TFT Serial Debug: SD card state changed... isInserted");
     else
-      ANYCUBIC_SENDCOMMAND_DBG_PGM("J01", "TFT Serial Debug: SD card state changed... !isInserted");
+      SENDLINE_DBG_PGM("J01", "TFT Serial Debug: SD card state changed... !isInserted");
 
   #endif
 }
         ExtUI::injectCommands_P(PSTR("\nM300 P200 S1567\nM300 P200 S1174\nM300 P200 S1567\nM300 P200 S1174\nM300 P2000 S1567"));
 
         // tell the user that the filament has run out and wait
-        ANYCUBIC_SENDCOMMAND_DBG_PGM("J23", "TFT Serial Debug: Blocking filament prompt... J23");
+        SENDLINE_DBG_PGM("J23", "TFT Serial Debug: Blocking filament prompt... J23");
       }
       else {
-        ANYCUBIC_SENDCOMMAND_DBG_PGM("J15", "TFT Serial Debug: Non blocking filament runout... J15");
+        SENDLINE_DBG_PGM("J15", "TFT Serial Debug: Non blocking filament runout... J15");
       }
     }
   #endif // FILAMENT_RUNOUT_SENSOR
 void AnycubicTFTClass::StartPrint() {
   #if ENABLED(SDSUPPORT)
     if (!ExtUI::isPrinting() && strlen(SelectedFile) > 0) {
-      #if ENABLED(ANYCUBIC_TFT_DEBUG)
+      #if ENABLED(ANYCUBIC_LCD_DEBUG)
         SERIAL_ECHOPGM("TFT Serial Debug: About to print file ... ");
         SERIAL_ECHO(ExtUI::isPrinting());
         SERIAL_ECHOPGM(" ");
     if (ExtUI::isPrintingFromMedia() && mediaPrintingState != AMPRINTSTATE_STOP_REQUESTED && mediaPauseState == AMPAUSESTATE_NOT_PAUSED) {
       mediaPrintingState = AMPRINTSTATE_PAUSE_REQUESTED;
       mediaPauseState    = AMPAUSESTATE_NOT_PAUSED; // need the userconfirm method to update pause state
-      ANYCUBIC_SENDCOMMAND_DBG_PGM("J05", "TFT Serial Debug: SD print pause started... J05"); // J05 printing pause
+      SENDLINE_DBG_PGM("J05", "TFT Serial Debug: SD print pause started... J05"); // J05 printing pause
 
       // for some reason pausing the print doesn't retract the extruder so force a manual one here
       ExtUI::injectCommands_P(PSTR("G91\nG1 E-2 F1800\nG90"));
   #if ENABLED(SDSUPPORT)
     #if ENABLED(FILAMENT_RUNOUT_SENSOR)
       if (READ(FIL_RUNOUT_PIN)) {
-        #if ENABLED(ANYCUBIC_TFT_DEBUG)
+        #if ENABLED(ANYCUBIC_LCD_DEBUG)
           SERIAL_ECHOLNPGM("TFT Serial Debug: Resume Print with filament sensor still tripped... ");
         #endif
 
         DoFilamentRunoutCheck();
 
         // re-enable the continue button
-        ANYCUBIC_SENDCOMMAND_DBG_PGM("J18", "TFT Serial Debug: Resume Print with filament sensor still tripped... J18");
+        SENDLINE_DBG_PGM("J18", "TFT Serial Debug: Resume Print with filament sensor still tripped... J18");
         return;
       }
     #endif
       mediaPauseState = AMPAUSESTATE_REHEATING;
       // TODO: JBA I don't think J05 just disables the continue button, i think it injects a rogue M25. So taking this out
       // // disable the continue button
-      // ANYCUBIC_SENDCOMMAND_DBG_PGM("J05", "TFT Serial Debug: Resume called with heater timeout... J05"); // J05 printing pause
+      // SENDLINE_DBG_PGM("J05", "TFT Serial Debug: Resume called with heater timeout... J05"); // J05 printing pause
 
       // reheat the nozzle
       ExtUI::setUserConfirmed();
       mediaPrintingState = AMPRINTSTATE_PRINTING;
       mediaPauseState    = AMPAUSESTATE_NOT_PAUSED;
 
-      ANYCUBIC_SENDCOMMAND_DBG_PGM("J04", "TFT Serial Debug: SD print resumed... J04"); // J04 printing form sd card now
+      SENDLINE_DBG_PGM("J04", "TFT Serial Debug: SD print resumed... J04"); // J04 printing form sd card now
       ExtUI::resumePrint();
     }
   #endif
   #if ENABLED(SDSUPPORT)
     mediaPrintingState = AMPRINTSTATE_STOP_REQUESTED;
     mediaPauseState    = AMPAUSESTATE_NOT_PAUSED;
-    ANYCUBIC_SENDCOMMAND_DBG_PGM("J16", "TFT Serial Debug: SD print stop called... J16");
+    SENDLINE_DBG_PGM("J16", "TFT Serial Debug: SD print stop called... J16");
 
     // for some reason stopping the print doesn't retract the extruder so force a manual one here
     ExtUI::injectCommands_P(PSTR("G91\nG1 E-2 F1800\nG90"));
   #endif
 }
 
-#endif // ANYCUBIC_TFT_MODEL
+#endif // ANYCUBIC_LCD_I3MEGA

Marlin/src/lcd/extui/lib/anycubic/anycubic_tft.h → Marlin/src/lcd/extui/lib/anycubic_i3mega/anycubic_i3mega_lcd.h

 /**
- * anycubic_tft.h  --- Support for Anycubic i3 Mega TFT
+ * anycubic_i3mega_lcd.h  --- Support for Anycubic i3 Mega TFT
  * Created by Christian Hopp on 09.12.17.
  * Improved by David Ramiro
  * Converted to ext_iu by John BouAntoun 21 June 2020
 #include "../../../../inc/MarlinConfigPre.h"
 #include "../../../../sd/SdFatConfig.h"   // for the FILENAME_LENGTH macro
 
-// command sending macro's with debugging capability
-#define ANYCUBIC_SENDCOMMANDPGM(x)                  ANYCUBIC_SERIAL_PROTOCOLLNPGM(x)
-#define ANYCUBIC_SENDCOMMANDPGM_VAL(x,y)            (ANYCUBIC_SERIAL_PROTOCOLPGM(x), ANYCUBIC_SERIAL_PROTOCOLLN(itostr3(y)))
-#define ANYCUBIC_SENDCOMMAND(x)                     ANYCUBIC_SERIAL_PROTOCOLLN(x)
-#if ENABLED(ANYCUBIC_TFT_DEBUG)
-  #define ANYCUBIC_SENDCOMMAND_DBG_PGM(x,y)         (ANYCUBIC_SERIAL_PROTOCOLLNPGM(x), SERIAL_ECHOLNPGM(y))
-  #define ANYCUBIC_SENDCOMMAND_DBG_PGM_VAL(x,y,z)   (ANYCUBIC_SERIAL_PROTOCOLLNPGM(x), SERIAL_ECHOPGM(y), SERIAL_ECHOLN(z))
-#else
-  #define ANYCUBIC_SENDCOMMAND_DBG_PGM(x,y)         (ANYCUBIC_SERIAL_PROTOCOLLNPGM(x))
-  #define ANYCUBIC_SENDCOMMAND_DBG_PGM_VAL(x,y,z)   (ANYCUBIC_SERIAL_PROTOCOLLNPGM(x))
-#endif
-
 char *itostr2(const uint8_t &x);
 #ifndef ULTRA_LCD
   char *itostr3(const int);

Marlin/src/lcd/extui/ui_api.cpp

     return epos;
   }
 
-  void setAxisPosition_mm(const float position, const axis_t axis) {
+  void setAxisPosition_mm(const float position, const axis_t axis, const feedRate_t feedrate/*=0*/) {
     // Start with no limits to movement
     float min = current_position[axis] - 1000,
           max = current_position[axis] + 1000;
     #endif
 
     current_position[axis] = constrain(position, min, max);
-    line_to_current_position(manual_feedrate_mm_s[axis]);
+    line_to_current_position(feedrate ?: manual_feedrate_mm_s[axis]);
   }
 
-  void setAxisPosition_mm(const float position, const extruder_t extruder) {
+  void setAxisPosition_mm(const float position, const extruder_t extruder, const feedRate_t feedrate/*=0*/) {
     setActiveTool(extruder, true);
 
     current_position.e = position;
-    line_to_current_position(manual_feedrate_mm_s.e);
+    line_to_current_position(feedrate ?: manual_feedrate_mm_s.e);
   }
 
   void setActiveTool(const extruder_t extruder, bool no_move) {

Marlin/src/lcd/extui/ui_api.h

   void setTargetTemp_celsius(const float, const heater_t);
   void setTargetTemp_celsius(const float, const extruder_t);
   void setTargetFan_percent(const float, const fan_t);
-  void setAxisPosition_mm(const float, const axis_t);
-  void setAxisPosition_mm(const float, const extruder_t);
+  void setAxisPosition_mm(const float, const axis_t, const feedRate_t=0);
+  void setAxisPosition_mm(const float, const extruder_t, const feedRate_t=0);
   void setAxisSteps_per_mm(const float, const axis_t);
   void setAxisSteps_per_mm(const float, const extruder_t);
   void setAxisMaxFeedrate_mm_s(const feedRate_t, const axis_t);

Marlin/src/lcd/extui_anycubic_chiron_lcd.cpp

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * extui_anycubic_chiron_lcd.cpp
+ *
+ * Anycubic Chiron TFT support for Marlin
+ */
+
+#include "../inc/MarlinConfigPre.h"
+
+#if ENABLED(ANYCUBIC_LCD_CHIRON)
+
+#include "extui/ui_api.h"
+
+#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
+  #if GRID_MAX_POINTS_X != 5 || GRID_MAX_POINTS_Y != 5
+    #error ANYCUBIC CHIRON LCD requires a 5x5 bed leveling grid (GRID_MAX_POINTS_X and GRID_MAX_POINTS_Y)
+  #endif
+#else
+  #error ANYCUBIC CHIRON LCD requires AUTO_BED_LEVELING_BILINEAR enabled
+#endif
+
+#if DISABLED(FILAMENT_RUNOUT_SENSOR)
+  #error ANYCUBIC CHIRON LCD requires FILAMENT_RUNOUT_SENSOR enabled
+#endif
+
+#if ENABLED(POWER_LOSS_RECOVERY)
+  #error ANYCUBIC CHIRON LCD does not currently support POWER_LOSS_RECOVERY
+#endif
+
+static bool is_auto_leveling = false;
+static bool is_printing_from_sd = false;
+static bool is_out_of_filament = false;
+
+static void sendNewLine(void) {
+  ANYCUBIC_LCD_SERIAL.write('\r');
+  ANYCUBIC_LCD_SERIAL.write('\n');
+}
+
+static void send(const char *str) {
+  ANYCUBIC_LCD_SERIAL.print(str);
+}
+
+static void sendLine(const char *str) {
+  send(str);
+  sendNewLine();
+}
+
+static void send_P(PGM_P str) {
+  while (const char c = pgm_read_byte(str++))
+    ANYCUBIC_LCD_SERIAL.write(c);
+}
+
+static void sendLine_P(PGM_P str) {
+  send_P(str);
+  sendNewLine();
+}
+
+static void sendValue_P(PGM_P prefix, int value) {
+  send_P(prefix);
+  ANYCUBIC_LCD_SERIAL.print(value);
+}
+
+static void sendValue_P(PGM_P prefix, float value) {
+  send_P(prefix);
+  ANYCUBIC_LCD_SERIAL.print(value);
+}
+
+static void sendValueLine_P(PGM_P prefix, int value) {
+  send_P(prefix);
+  ANYCUBIC_LCD_SERIAL.print(value);
+  sendNewLine();
+}
+
+static void sendValueLine_P(PGM_P prefix, float value) {
+  send_P(prefix);
+  ANYCUBIC_LCD_SERIAL.print(value);
+  sendNewLine();
+}
+
+static int parseIntArgument(const char *buffer, char letterId) {
+  char *p = strchr(buffer, letterId);
+  if (!p)
+    return -1;
+  return atoi(p+1);
+}
+
+static float parseFloatArgument(const char *buffer, char letterId) {
+  char *p = strchr(buffer, letterId);
+  if (!p)
+    return NAN;
+  return strtof(p+1, nullptr);
+}
+
+static int mmToHundredths(float x) {
+  // Round
+  if (x >= 0)
+    x += 0.005f;
+  else
+    x -= 0.005f;
+  return (int)(x * 100.0f);
+}
+
+static float hundredthsToMm(int x) {
+  return x / 100.0f;
+}
+
+#define SEND_PGM(str)                           send_P(PSTR(str))
+#define SENDLINE_PGM(str)                       sendLine_P(PSTR(str))
+#define SENDVALUE_PGM(prefix, value)            sendValue_P(PSTR(prefix), value)
+#define SENDVALUELINE_PGM(prefix, value)        sendValueLine_P(PSTR(prefix), value)
+
+namespace ExtUI {
+
+  static void moveAxis(float delta, feedRate_t feedrate, axis_t axis) {
+    float pos = getAxisPosition_mm(axis);
+    pos += delta;
+    setAxisPosition_mm(pos, axis, feedrate);
+  }
+
+  static void handleCmd(const char *rx) {
+    static FileList fileList;
+    static char selectedFileShortName[8+1+3+1];
+
+    if (rx[0] != 'A') {
+      SERIAL_ECHOPGM("Unexpected RX: ");
+      SERIAL_ECHOLN(rx);
+    
+      return;
+    }
+
+    const int cmd = atoi(&rx[1]);
+
+    // Uncomment for debugging RX
+    //if (cmd > 7 && cmd != 20) {
+    //  SERIAL_ECHOPGM("RX: ");
+    //  SERIAL_ECHOLN(rx);
+    //}
+
+    switch (cmd) {
+      case 0: // Get Hotend Actual Temperature
+        SENDVALUELINE_PGM("A0V ", (int)getActualTemp_celsius(E0));
+        break;
+      case 1: // Get Hotend Target Temperature
+        SENDVALUELINE_PGM("A1V ", (int)getTargetTemp_celsius(E0));
+        break;
+      case 2: // Get Bed Actual Temperature
+        SENDVALUELINE_PGM("A2V ", (int)getActualTemp_celsius(BED));
+        break;
+      case 3: // Get Bed Target Temperature
+        SENDVALUELINE_PGM("A3V ", (int)getTargetTemp_celsius(BED));
+        break;
+      case 4: // Get Fan Speed
+        SENDVALUELINE_PGM("A4V ", (int)getTargetFan_percent(FAN0));
+        break;
+      case 5: // Get Current Coordinates
+        SENDVALUE_PGM("A5V X: ", getAxisPosition_mm(X));
+        SENDVALUE_PGM(" Y: ", getAxisPosition_mm(Y));
+        SENDVALUE_PGM(" Z: ", getAxisPosition_mm(Z));
+        sendNewLine();
+        break;
+      case 6: // Get SD Card Print Status
+        if (isPrintingFromMedia())
+          SENDVALUELINE_PGM("A6V ", (int)getProgress_percent());
+        else
+          SENDLINE_PGM("A6V ---");
+        break;
+      case 7: // Get Printing Time
+        if (isPrinting()) {
+          const int totalMinutes = getProgress_seconds_elapsed() / 60;
+          SENDVALUE_PGM("A7V ", (int)(totalMinutes/60));
+          SENDVALUE_PGM(" H ", (int)(totalMinutes%60));
+          SENDLINE_PGM(" M");
+        } else {
+          SENDLINE_PGM("A7V 999:999");
+        }
+        break;
+      case 8: // Get SD Card File List
+        if (isMediaInserted()) {
+          const int startIndex = parseIntArgument(rx, 'S');
+          SENDLINE_PGM("FN ");
+          for (int i = 0, fileIndex = 0, numFiles = 0; i < (int)fileList.count() && numFiles < 4; i++) {
+            fileList.seek(i);
+            if (!fileList.isDir()) {
+              if (fileIndex >= startIndex) {
+                sendLine(fileList.shortFilename());
+                sendLine(fileList.longFilename());
+                numFiles++;
+              }
+              fileIndex++;
+            }
+          }
+          SENDLINE_PGM("END");
+        } else {
+          SENDLINE_PGM("J02");
+        }
+        break;
+      case 9: // Pause SD Card Print
+        if (isPrintingFromMedia()) {
+          pausePrint();
+          is_printing_from_sd = false;
+          SENDLINE_PGM("J05");
+        } else {
+          SENDLINE_PGM("J16"); // Print stopped
+        }
+        break;
+      case 10: // Resume SD Card Print
+        if (is_out_of_filament) {
+          is_out_of_filament = false;
+          // Filament change did eject the old filament automatically,
+          // now continue and load the new one
+          setUserConfirmed();
+          SENDLINE_PGM("J04"); // Printing from SD card
+        } else if (isPrintingFromMediaPaused()) {
+          resumePrint();
+          SENDLINE_PGM("J04"); // Printing from SD card
+        }
+        break;
+      case 11: // Stop SD Card Print
+        if (isPrintingFromMedia()) {
+          stopPrint();
+          is_printing_from_sd = false;
+          SENDLINE_PGM("J16"); // Print stopped
+        }
+        break;
+      //case 12: // Kill
+      //  break;
+      case 13: // Select File
+        if (!isPrinting()) {
+          // Store selected file name
+          char *p = strchr(rx, ' ');
+          if (p != nullptr && strlen(p+1) < sizeof(selectedFileShortName)) {
+            strcpy(selectedFileShortName, p+1);
+            SENDLINE_PGM("J20"); // Open succeeded
+          }
+          else
+            SENDLINE_PGM("J21"); // Open failed
+        }
+        break;
+      case 14: // Start Print
+        if (!isPrinting() && strcmp(selectedFileShortName, "") != 0) {
+          printFile(selectedFileShortName);
+          is_printing_from_sd = true;
+          SENDLINE_PGM("J04"); // Printing from SD card
+        }
+        break;
+      case 15: // Resume from power outage
+        // This is not supported, just report print as completed
+        SENDLINE_PGM("J16"); // Print stopped
+        break;
+      case 16: // Set Hotend Target Temperature
+        {
+          int temp = parseIntArgument(rx, 'S');
+          if (temp >= 0)
+            setTargetTemp_celsius(temp, E0);
+        }
+        break;
+      case 17: // Set Bed Target Temperature
+        {
+          int temp = parseIntArgument(rx, 'S');
+          if (temp >= 0)
+            setTargetTemp_celsius(temp, BED);
+        }
+        break;
+      case 18: // Set Fan Speed
+        {
+          int temp = parseIntArgument(rx, 'S');
+          if (temp >= 0)
+            setTargetFan_percent(temp, FAN0);
+        }
+        break;
+      case 19: // Disable Motors
+        injectCommands_P(PSTR("M84"));
+        break;
+      case 20: // Get/Set Printing Speed
+        {
+          int newPerc = parseIntArgument(rx, 'S');
+          if (newPerc >= 0)
+            setFeedrate_percent(newPerc);
+          else
+            SENDVALUELINE_PGM("A20V ", (int)getFeedrate_percent());
+        }
+        break;
+      case 21: // Home axes
+        if (!isPrinting()) {
+          const bool hasX = strchr(rx, 'X') != nullptr,
+                     hasY = strchr(rx, 'Y') != nullptr,
+                     hasZ = strchr(rx, 'Z') != nullptr,
+                     hasC = strchr(rx, 'C') != nullptr;
+          if (hasX || hasY || hasZ) {
+            if (hasX) injectCommands_P(PSTR("G28 X"));
+            if (hasY) injectCommands_P(PSTR("G28 Y"));
+            if (hasZ) injectCommands_P(PSTR("G28 Z"));
+          } else if (hasC) {
+            injectCommands_P(PSTR("G28"));
+          }
+        }
+        break;
+      case 22: // Move axes
+        if (!isPrinting()) {
+          const int feedrate = parseIntArgument(rx, 'F') / 60;
+          float delta;
+          if (!isnan(delta = parseFloatArgument(rx, 'X')))
+            moveAxis(delta, feedrate, X);
+          else if (!isnan(delta = parseFloatArgument(rx, 'Y')))
+            moveAxis(delta, feedrate, Y);
+          else if (!isnan(delta = parseFloatArgument(rx, 'Z')))
+            moveAxis(delta, feedrate, Z);
+        }
+        break;
+      case 23: // Preheat PLA
+        setTargetTemp_celsius(PREHEAT_1_TEMP_HOTEND, E0);
+        setTargetTemp_celsius(PREHEAT_1_TEMP_BED, BED);
+        SENDLINE_PGM("OK");
+        break;
+      case 24: // Preheat ABS
+        setTargetTemp_celsius(PREHEAT_2_TEMP_HOTEND, E0);
+        setTargetTemp_celsius(PREHEAT_2_TEMP_BED, BED);
+        SENDLINE_PGM("OK");
+        break;
+      case 25: // Cool down
+        setTargetTemp_celsius(0, E0);
+        setTargetTemp_celsius(0, BED);
+        SENDLINE_PGM("J12");
+        break;
+      case 26: // Refresh SD Card
+        fileList.refresh();
+        break;
+      //case 27: // Adjust Servo Angles
+      //  break;
+      //case 28: // Filament Test
+      //  break;
+      case 29: // Get Bed Autolevel Grid
+        {
+          int x = parseIntArgument(rx, 'X'),
+              y = parseIntArgument(rx, 'Y');
+          if (x != -1 && y != -1) {
+            xy_uint8_t coord;
+            coord.set(x, y);
+            const int value = mmToHundredths(getMeshPoint(coord));
+            SENDVALUELINE_PGM("A29V ", value);
+          }
+        }
+        break;
+      case 30: // Autolevel
+        if (strchr(rx, 'S')) { // Autoleveling started by clicking "PROBE" and then "OK"
+          // Note:
+          //  We check for completion by monitoring the command queue.
+          //  Since it will become empty *while* processing the last injected command,
+          //  we enqueue an extra 10ms delay so we can the determine when all the others
+          //  have completed.
+          if (isMachineHomed())
+            injectCommands_P(PSTR("G29\nG4 P10"));
+          else
+            injectCommands_P(PSTR("G28\nG29\nG4 P10"));
+          is_auto_leveling = true;
+        } else { // Entering Autoleveling screen
+          if (isPrinting())
+            SENDLINE_PGM("J24"); // Disallow autoleveling
+          else
+            SENDLINE_PGM("J26"); // Allow autoleveling
+        }
+        break;
+      case 31: // Set Bed Autolevel Z offset
+        if (strchr(rx, 'G')) { // Get
+          SENDVALUELINE_PGM("A31V ", getZOffset_mm());
+        } else if (strchr(rx, 'S')) { // Set
+          float delta = parseFloatArgument(rx, 'S');
+          delta = constrain(delta, -1.0, 1.0);
+          setZOffset_mm(getZOffset_mm() + delta);
+
+          SENDVALUELINE_PGM("A31V ", getZOffset_mm());
+        } else if (strchr(rx, 'D')) { // Save
+          injectCommands_P(PSTR("M500"));
+        }
+        break;
+      //case 32: // ?
+      //  break;
+      case 33: // Get Version Info
+        SENDLINE_PGM("J33 " SHORT_BUILD_VERSION);
+        break;
+      case 34: // Set Bed Autolevel Grid
+        {
+          int x = parseIntArgument(rx, 'X'),
+              y = parseIntArgument(rx, 'Y'),
+              v = parseIntArgument(rx, 'V');
+          if (x != -1 && y != -1 && v != -1) { // Set new value
+            float value = hundredthsToMm(v);
+            value = constrain(value, -10, 10);
+
+            xy_uint8_t coord;
+            coord.set(x, y);
+            setMeshPoint(coord, value);
+          } else if (strchr(rx, 'S')) { // Save (apply new values)
+            injectCommands_P(PSTR("M500"));
+          } else if (strchr(rx, 'C')) { // Cancel (discard new values)
+            injectCommands_P(PSTR("M501"));
+          }
+        }
+        break;
+    }
+  }
+
+  #define RX_LEN_MAX 63
+  static void parseSerialRx() {
+    static char rxBuffer[RX_LEN_MAX+1];
+    static uint8_t rxLen = 0;
+
+    while (ANYCUBIC_LCD_SERIAL.available()) {
+      const char c = ANYCUBIC_LCD_SERIAL.read();
+      switch (c) {
+        case '\r': case '\n':
+          if (rxLen > 0 && rxLen <= RX_LEN_MAX) {
+            rxBuffer[rxLen] = '\0'; // Terminate string
+            handleCmd(rxBuffer);
+          }
+          rxLen = 0;
+          break;
+        default:
+          if (rxLen < RX_LEN_MAX)
+            rxBuffer[rxLen++] = c;
+          else {
+            rxLen = 0xFF; // Overrun
+            SERIAL_ECHOPGM("Warning: dropping long received line");
+          }
+          break;
+      }
+    }
+  }
+
+  static void detectPrintFromSdCompletion() {
+    // Note: printFile() queues some commands that actually start the print, so isPrintingFromMedia()
+    //       initially returns false
+    if (is_printing_from_sd && !commandsInQueue() && !isPrintingFromMedia()) {
+      is_printing_from_sd = false;
+      SENDLINE_PGM("J14"); // Print done
+    }
+  }
+
+  static void detectAutolevelingCompletion() {
+    if (is_auto_leveling && !commandsInQueue()) {
+      is_auto_leveling = false;
+      injectCommands_P(PSTR("M500"));
+      SENDLINE_PGM("J25"); // Autoleveling done
+    }
+  }
+
+  void onStartup() {
+    ANYCUBIC_LCD_SERIAL.begin(115200);
+    sendNewLine();
+    SENDLINE_PGM("J17"); // Reset
+    delay_ms(10);
+    SENDLINE_PGM("J12"); // Ready
+  }
+
+  void onIdle() {
+    parseSerialRx();
+    detectAutolevelingCompletion();
+    detectPrintFromSdCompletion();
+  }
+
+  void onPrinterKilled(PGM_P const error, PGM_P const component) { }
+
+  void onMediaInserted() {
+    SENDLINE_PGM("J00"); // SD Inserted
+  }
+
+  void onMediaError() { }
+
+  void onMediaRemoved() {
+    SENDLINE_PGM("J01"); // SD Removed
+  }
+  
+  void onPlayTone(const uint16_t frequency, const uint16_t duration) {
+    tone(BEEPER_PIN, frequency, duration);
+  }
+
+  void onPrintTimerStarted() { }
+
+  void onPrintTimerPaused() { }
+
+  void onPrintTimerStopped() { }
+
+  void onFilamentRunout(const extruder_t extruder) {
+    is_out_of_filament = true;
+    SENDLINE_PGM("J23"); // Filament runout
+    SENDLINE_PGM("J18"); // Print paused
+    // Note: printer will unload filament automatically
+  }
+
+  void onUserConfirmRequired(const char * const msg) { }
+
+  void onStatusChanged(const char * const msg) { }
+
+  void onFactoryReset() { }
+
+  void onStoreSettings(char *buff) { }
+
+  void onLoadSettings(const char *buff) { }
+
+  void onConfigurationStoreWritten(bool success) { }
+
+  void onConfigurationStoreRead(bool success) { }
+
+  void onMeshUpdate(const int8_t xpos, const int8_t ypos, const float zval) { }
+
+  #if ENABLED(POWER_LOSS_RECOVERY)
+    void onPowerLossResume() { }
+  #endif
+
+  #if HAS_PID_HEATING
+    void onPidTuning(const result_t rst) { }
+  #endif
+}
+
+#endif // ANYCUBIC_LCD_CHIRON

Marlin/src/lcd/extui_anycubic_tft.cpp → Marlin/src/lcd/extui_anycubic_i3mega_lcd.cpp

  */
 
 /**
- * extui_anycubic_tft.cpp
+ * extui_anycubic_i3mega_lcd.cpp
  */
 
 #include "../inc/MarlinConfigPre.h"
 
-#if BOTH(ANYCUBIC_TFT_MODEL, EXTENSIBLE_UI)
+#if ENABLED(ANYCUBIC_LCD_I3MEGA)
 
-#include "extui/lib/anycubic/anycubic_tft.h"
+#include "extui/lib/anycubic_i3mega/anycubic_i3mega_lcd.h"
 #include "extui/ui_api.h"
 
 #include <Arduino.h>    // for the ::tone() call
   #endif
 }
 
-#endif // ANYCUBIC_TFT_MODEL && EXTENSIBLE_UI
+#endif // ANYCUBIC_LCD_I3MEGA

Marlin/src/pins/ramps/pins_TRIGORILLA_14.h

 
 #define BOARD_INFO_NAME "Anycubic RAMPS 1.4"
 
-//
-// Servos
-//
-#if MB(TRIGORILLA_14_11)
-  #define SERVO0_PIN                           5
-  #define SERVO1_PIN                           4
-  #define SERVO2_PIN                          11
-  #define SERVO3_PIN                           6
-#endif
-
-//
-// Limit Switches
-//
-//#define ANYCUBIC_4_MAX_PRO_ENDSTOPS
-
-#define X_MIN_PIN                              3
-
-#if ENABLED(ANYCUBIC_4_MAX_PRO_ENDSTOPS)
-  #define X_MAX_PIN                           43
-#else
-  #define X_MAX_PIN                           43
-#endif
+// Board labeled pins:
 
-#if ENABLED(ANYCUBIC_4_MAX_PRO_ENDSTOPS)
-  #define Y_STOP_PIN                          19
-#else
-  #define Y_STOP_PIN                          42
-#endif
-
-#define Z_STOP_PIN                            18
-
-//
-// Z Probe (when not Z_MIN_PIN)
-//
-#define Z_MIN_PROBE_PIN                        2
-
-#ifndef FIL_RUNOUT_PIN
-  #define FIL_RUNOUT_PIN                      19
-#endif
-
-//
-// Heaters / Fans
-//
 #define TG_HEATER_BED_PIN                      8
 #define TG_HEATER_0_PIN                       10
 #define TG_HEATER_1_PIN                       45  // Anycubic Kossel: Unused
 #define TG_FAN1_PIN                            7  // Anycubic Kossel: Unused
 #define TG_FAN2_PIN                           44  // Anycubic Kossel: Hotend fan
 
-#define CONTROLLER_FAN_PIN           TG_FAN1_PIN
-
-#define BEEPER_PIN                            31
-#define SD_DETECT_PIN                         49
+//
+// Servos
+//
+#if MB(TRIGORILLA_14_11)
+  #define SERVO0_PIN                           5
+  #define SERVO1_PIN                           4
+  #define SERVO2_PIN                          11
+  #define SERVO3_PIN                           6
+#endif
 
 // Remap MOSFET pins to common usages:
 
 #elif TEMP_SENSOR_BED
   // EFB (Anycubic Kossel default)
   #define RAMPS_D9_PIN               TG_FAN0_PIN
-  #define RAMPS_D8_PIN         TG_HEATER_BED_PIN
+  #if ENABLED(ANYCUBIC_CHIRON)
+    #define RAMPS_D8_PIN         TG_HEATER_1_PIN  // Heated bed is connected to HEATER1 output
+  #else
+    #define RAMPS_D8_PIN       TG_HEATER_BED_PIN
+  #endif
 #else
   // EFF
   #define RAMPS_D9_PIN               TG_FAN1_PIN
   #define E0_AUTO_FAN_PIN            TG_FAN2_PIN  // Used in Anycubic Kossel example config
 #endif
 
+#if ENABLED(ANYCUBIC_I3MEGA)
+  #define CONTROLLER_FAN_PIN         TG_FAN1_PIN
+#endif
+
+//
+// AnyCubic standard pin mappings
+//
+//  On most printers, endstops are NOT all wired to the appropriate pins on the Trigorilla board.
+//  For instance, on a Chiron, Y axis goes to an aux connector.
+//  There are also other things that have been wired in creative ways.
+//  To enable PIN definitions for a specific printer model, #define the appropriate symbol after
+//  MOTHERBOARD in Configuration.h
+
+//
+// Limit Switches
+//
+//#define ANYCUBIC_4_MAX_PRO_ENDSTOPS
+
+#if ENABLED(ANYCUBIC_4_MAX_PRO_ENDSTOPS)
+  #define X_MAX_PIN                           43
+  #define Y_STOP_PIN                          19
+#elif EITHER(ANYCUBIC_CHIRON, ANYCUBIC_I3MEGA)
+  #define Y_STOP_PIN                          42
+  #define Z2_MIN_PIN                          43
+  #ifndef Z_MIN_PROBE_PIN
+    #define Z_MIN_PROBE_PIN                    2
+  #endif
+  #ifndef FIL_RUNOUT_PIN
+    #if ENABLED(ANYCUBIC_CHIRON)
+      #define FIL_RUNOUT_PIN                  33
+    #else
+      #define FIL_RUNOUT_PIN                  19
+    #endif
+  #endif
+  #define BEEPER_PIN                          31
+  #define SD_DETECT_PIN                       49
+#endif
+
 #include "pins_RAMPS.h"
 
 //

platformio.ini

 HAS_LCD_MENU            = src_filter=+<src/lcd/menu>
 HAS_DGUS_LCD            = src_filter=+<src/lcd/extui/lib/dgus>
 TOUCH_UI_FTDI_EVE       = src_filter=+<src/lcd/extui/lib/ftdi_eve_touch_ui>
-ANYCUBIC_TFT_MODEL      = src_filter=+<src/lcd/extui/lib/anycubic>
+ANYCUBIC_LCD_I3MEGA     = src_filter=+<src/lcd/extui/lib/anycubic_i3mega>
 USB_FLASH_DRIVE_SUPPORT = src_filter=+<src/sd/usb_flashdrive>
 AUTO_BED_LEVELING_(3POINT|(BI)?LINEAR) = src_filter=+<src/feature/bedlevel/abl> +<src/gcode/bedlevel/abl>
 MESH_BED_LEVELING       = src_filter=+<src/feature/bedlevel/mbl> +<src/gcode/bedlevel/mbl>