From 4abad60bf199bacd4d43795de54cfcdc77610028 Mon Sep 17 00:00:00 2001
From: JBA <44487003+hub-jba@users.noreply.github.com>
Date: Fri, 17 Jul 2020 16:07:09 +1000
Subject: [PATCH] ExtUI for Anycubic I3 Mega (#18655)
---
Marlin/src/gcode/feature/pause/M125.cpp | 2 +-
.../extui/lib/anycubic/anycubic_serial.cpp | 294 +++++
.../lcd/extui/lib/anycubic/anycubic_serial.h | 143 +++
.../lcd/extui/lib/anycubic/anycubic_tft.cpp | 1066 +++++++++++++++++
.../src/lcd/extui/lib/anycubic/anycubic_tft.h | 114 ++
Marlin/src/lcd/extui_anycubic_tft.cpp | 104 ++
Marlin/src/pins/ramps/pins_TRIGORILLA_14.h | 34 +-
7 files changed, 1753 insertions(+), 4 deletions(-)
create mode 100644 Marlin/src/lcd/extui/lib/anycubic/anycubic_serial.cpp
create mode 100644 Marlin/src/lcd/extui/lib/anycubic/anycubic_serial.h
create mode 100644 Marlin/src/lcd/extui/lib/anycubic/anycubic_tft.cpp
create mode 100644 Marlin/src/lcd/extui/lib/anycubic/anycubic_tft.h
create mode 100644 Marlin/src/lcd/extui_anycubic_tft.cpp
diff --git a/Marlin/src/gcode/feature/pause/M125.cpp b/Marlin/src/gcode/feature/pause/M125.cpp
index 12b0892d581..cb59985278f 100644
--- a/Marlin/src/gcode/feature/pause/M125.cpp
+++ b/Marlin/src/gcode/feature/pause/M125.cpp
@@ -79,7 +79,7 @@ void GcodeSuite::M125() {
if (pause_print(retract, park_point, 0, show_lcd)) {
TERN_(POWER_LOSS_RECOVERY, if (recovery.enabled) recovery.save(true));
- if (!sd_printing || show_lcd) {
+ if (ENABLED(EXTENSIBLE_UI) || !sd_printing || show_lcd) {
wait_for_confirmation(false, 0);
resume_print(0, 0, -retract, 0);
}
diff --git a/Marlin/src/lcd/extui/lib/anycubic/anycubic_serial.cpp b/Marlin/src/lcd/extui/lib/anycubic/anycubic_serial.cpp
new file mode 100644
index 00000000000..3fad103bb41
--- /dev/null
+++ b/Marlin/src/lcd/extui/lib/anycubic/anycubic_serial.cpp
@@ -0,0 +1,294 @@
+/*
+ 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 HardwareSerial.cpp,
+// so I can 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;
+};
+
+#ifdef UBRR3H
+ ring_buffer rx_buffer_ajg = { { 0 }, 0, 0 };
+ ring_buffer tx_buffer_ajg = { { 0 }, 0, 0 };
+#endif
+
+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 //////////////////////////////////////////////////////
+
+#ifdef UBRR3H
+ AnycubicSerialClass AnycubicSerial(&rx_buffer_ajg, &tx_buffer_ajg, &UBRR3H, &UBRR3L, &UCSR3A, &UCSR3B, &UCSR3C, &UDR3, RXEN3, TXEN3, RXCIE3, UDRIE3, U2X3);
+#endif
+
+#endif // UBRR3H
+#endif // ANYCUBIC_TFT_MODEL
diff --git a/Marlin/src/lcd/extui/lib/anycubic/anycubic_serial.h b/Marlin/src/lcd/extui/lib/anycubic/anycubic_serial.h
new file mode 100644
index 00000000000..e7494d38ada
--- /dev/null
+++ b/Marlin/src/lcd/extui/lib/anycubic/anycubic_serial.h
@@ -0,0 +1,143 @@
+/*
+ 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)
+
+FORCE_INLINE void AnycubicSerialprintPGM(const char *str) {
+ char ch=pgm_read_byte(str);
+ while (ch) {
+ AnycubicSerial.write(ch);
+ ch=pgm_read_byte(++str);
+ }
+}
+
+#ifdef UBRR3H
+ extern AnycubicSerialClass AnycubicSerial;
+#endif
diff --git a/Marlin/src/lcd/extui/lib/anycubic/anycubic_tft.cpp b/Marlin/src/lcd/extui/lib/anycubic/anycubic_tft.cpp
new file mode 100644
index 00000000000..718b47fee9b
--- /dev/null
+++ b/Marlin/src/lcd/extui/lib/anycubic/anycubic_tft.cpp
@@ -0,0 +1,1066 @@
+/**
+ * anycubic_tft.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
+ *
+ * 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
+ */
+
+#include "../../../../inc/MarlinConfigPre.h"
+
+#if ENABLED(ANYCUBIC_TFT_MODEL)
+
+#include "anycubic_tft.h"
+#include "anycubic_serial.h"
+
+#include "../../../../inc/MarlinConfig.h"
+#include "../../ui_api.h"
+#include "../../../../MarlinCore.h" // for quickstop_stepper and disable_steppers
+
+AnycubicTFTClass AnycubicTFT;
+
+char _conv[8];
+
+char *itostr2(const uint8_t &x) {
+ // sprintf(conv,"%5.1f",x);
+ int xx = x;
+ _conv[0] = (xx / 10) % 10 + '0';
+ _conv[1] = (xx) % 10 + '0';
+ _conv[2] = 0;
+ return _conv;
+}
+
+#ifndef ULTRA_LCD
+ #define DIGIT(n) ('0' + (n))
+ #define DIGIMOD(n, f) DIGIT((n) / (f) % 10)
+ #define RJDIGIT(n, f) ((n) >= (f) ? DIGIMOD(n, f) : ' ')
+ #define MINUSOR(n, alt) (n >= 0 ? (alt) : (n = -n, '-'))
+
+ char* itostr3(const int x) {
+ int xx = x;
+ _conv[4] = MINUSOR(xx, RJDIGIT(xx, 100));
+ _conv[5] = RJDIGIT(xx, 10);
+ _conv[6] = DIGIMOD(xx, 1);
+ return &_conv[4];
+ }
+
+// Convert signed float to fixed-length string with 023.45 / -23.45 format
+ char *ftostr32(const float &x) {
+ long xx = x * 100;
+ _conv[1] = MINUSOR(xx, DIGIMOD(xx, 10000));
+ _conv[2] = DIGIMOD(xx, 1000);
+ _conv[3] = DIGIMOD(xx, 100);
+ _conv[4] = '.';
+ _conv[5] = DIGIMOD(xx, 10);
+ _conv[6] = DIGIMOD(xx, 1);
+ return &_conv[1];
+ }
+
+#endif
+
+AnycubicTFTClass::AnycubicTFTClass() {}
+
+void AnycubicTFTClass::OnSetup() {
+ AnycubicSerial.begin(115200);
+ ANYCUBIC_SENDCOMMAND_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
+ #if ENABLED(SDSUPPORT) && PIN_EXISTS(SD_DETECT)
+ pinMode(SD_DETECT_PIN, INPUT);
+ WRITE(SD_DETECT_PIN, HIGH);
+ #endif
+ #if ENABLED(FILAMENT_RUNOUT_SENSOR)
+ pinMode(FIL_RUNOUT_PIN, INPUT);
+ WRITE(FIL_RUNOUT_PIN, HIGH);
+ #endif
+
+ mediaPrintingState = AMPRINTSTATE_NOT_PRINTING;
+ mediaPauseState = AMPAUSESTATE_NOT_PAUSED;
+
+ // DoSDCardStateCheck();
+ ANYCUBIC_SENDCOMMAND_DBG_PGM("J12", "TFT Serial Debug: Ready... J12"); // J12 Ready
+ ExtUI::delay_ms(10);
+
+ DoFilamentRunoutCheck();
+ SelectedFile[0] = 0;
+
+ #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)
+ SERIAL_ECHOLNPGM("TFT Serial Debug: Finished startup");
+ #endif
+}
+
+void AnycubicTFTClass::OnCommandScan() {
+ static millis_t nextStopCheck = 0; // used to slow the stopped print check down to reasonable times
+ const millis_t ms = millis();
+ if (ELAPSED(ms, nextStopCheck)) {
+ nextStopCheck = ms + 1000UL;
+ if (mediaPrintingState == AMPRINTSTATE_STOP_REQUESTED && IsNozzleHomed()) {
+ #if ENABLED(ANYCUBIC_TFT_DEBUG)
+ SERIAL_ECHOLNPGM("TFT Serial Debug: Finished stopping print, releasing motors ...");
+ #endif
+ mediaPrintingState = AMPRINTSTATE_NOT_PRINTING;
+ mediaPauseState = AMPAUSESTATE_NOT_PAUSED;
+ 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");
+ }
+ }
+
+ if (TFTbuflen < (TFTBUFSIZE - 1))
+ GetCommandFromTFT();
+
+ if (TFTbuflen) {
+ TFTbuflen = (TFTbuflen - 1);
+ TFTbufindr = (TFTbufindr + 1) % TFTBUFSIZE;
+ }
+}
+
+void AnycubicTFTClass::OnKillTFT() {
+ ANYCUBIC_SENDCOMMAND_DBG_PGM("J11", "TFT Serial Debug: Kill command... J11");
+}
+
+void AnycubicTFTClass::OnSDCardStateChange(bool isInserted) {
+ #if ENABLED(ANYCUBIC_TFT_DEBUG)
+ SERIAL_ECHOPGM("TFT Serial Debug: OnSDCardStateChange event triggered...");
+ SERIAL_ECHO(itostr2(isInserted));
+ SERIAL_EOL();
+ #endif
+ DoSDCardStateCheck();
+}
+
+void AnycubicTFTClass::OnSDCardError() {
+ #if ENABLED(ANYCUBIC_TFT_DEBUG)
+ SERIAL_ECHOLNPGM("TFT Serial Debug: OnSDCardError event triggered...");
+ #endif
+ ANYCUBIC_SENDCOMMAND_DBG_PGM("J21", "TFT Serial Debug: On SD Card Error ... J21");
+}
+
+void AnycubicTFTClass::OnFilamentRunout() {
+ #if ENABLED(ANYCUBIC_TFT_DEBUG)
+ SERIAL_ECHOLNPGM("TFT Serial Debug: FilamentRunout triggered...");
+ #endif
+ DoFilamentRunoutCheck();
+}
+
+void AnycubicTFTClass::OnUserConfirmRequired(const char * const msg) {
+ #if ENABLED(ANYCUBIC_TFT_DEBUG)
+ SERIAL_ECHOPGM("TFT Serial Debug: OnUserConfirmRequired triggered... ");
+ SERIAL_ECHOLN(msg);
+ #endif
+
+ #if ENABLED(SDSUPPORT)
+ /**
+ * Need to handle the process of following states
+ * "Nozzle Parked"
+ * "Load Filament"
+ * "Filament Purging..."
+ * "HeaterTimeout"
+ * "Reheat finished."
+ *
+ * NOTE: The only way to handle these states is strcmp_P with the msg unfortunately (very expensive)
+ */
+ if (strcmp_P(msg, PSTR("Nozzle Parked")) == 0) {
+ mediaPrintingState = AMPRINTSTATE_PAUSED;
+ mediaPauseState = AMPAUSESTATE_PARKED;
+ // enable continue button
+ ANYCUBIC_SENDCOMMAND_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");
+ }
+ 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
+
+ // enable continue button
+ ANYCUBIC_SENDCOMMAND_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");
+ }
+ 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");
+ }
+ #endif
+}
+
+float AnycubicTFTClass::CodeValue() {
+ return (strtod(&TFTcmdbuffer[TFTbufindr][TFTstrchr_pointer - TFTcmdbuffer[TFTbufindr] + 1], NULL));
+}
+
+bool AnycubicTFTClass::CodeSeen(char code) {
+ TFTstrchr_pointer = strchr(TFTcmdbuffer[TFTbufindr], code);
+ return (TFTstrchr_pointer != NULL); // Return True if a character was found
+}
+
+bool AnycubicTFTClass::IsNozzleHomed() {
+ const float xPosition = ExtUI::getAxisPosition_mm((ExtUI::axis_t) ExtUI::X);
+ const float yPosition = ExtUI::getAxisPosition_mm((ExtUI::axis_t) ExtUI::Y);
+ return WITHIN(xPosition, X_MIN_POS - 0.1, X_MIN_POS + 0.1) &&
+ WITHIN(yPosition, Y_MIN_POS - 0.1, Y_MIN_POS + 0.1);
+}
+
+void AnycubicTFTClass::HandleSpecialMenu() {
+ /**
+ * NOTE: that the file selection command actual lowercases the entire selected file/foldername, so charracter comparisons need to be lowercase.
+ */
+ if (SelectedDirectory[0] == '<') {
+ switch (SelectedDirectory[1]) {
+ case 'e': // "<exit>"
+ SpecialMenu = false;
+ return;
+ break;
+
+ #if ENABLED(PROBE_MANUALLY)
+ case '0':
+ switch (SelectedDirectory[2]) {
+ case '1': // "<01ZUp0.1>"
+ SERIAL_ECHOLNPGM("Special Menu: Z Up 0.1");
+ ExtUI::injectCommands_P(PSTR("G91\nG1 Z+0.1\nG90"));
+ break;
+
+ case '2': // "<02ZUp0.02>"
+ SERIAL_ECHOLNPGM("Special Menu: Z Up 0.02");
+ ExtUI::injectCommands_P(PSTR("G91\nG1 Z+0.02\nG90"));
+ break;
+
+ case '3': // "<03ZDn0.02>"
+ SERIAL_ECHOLNPGM("Special Menu: Z Down 0.02");
+ ExtUI::injectCommands_P(PSTR("G91\nG1 Z-0.02\nG90"));
+ break;
+
+ case '4': // "<04ZDn0.1>"
+ SERIAL_ECHOLNPGM("Special Menu: Z Down 0.1");
+ ExtUI::injectCommands_P(PSTR("G91\nG1 Z-0.1\nG90"));
+ break;
+
+ case '5': // "<05PrehtBed>"
+ SERIAL_ECHOLNPGM("Special Menu: Preheat Bed");
+ ExtUI::injectCommands_P(PSTR("M140 S65"));
+ break;
+
+ case '6': // "<06SMeshLvl>"
+ SERIAL_ECHOLNPGM("Special Menu: Start Mesh Leveling");
+ ExtUI::injectCommands_P(PSTR("G29 S1"));
+ break;
+
+ case '7': // "<07MeshNPnt>"
+ SERIAL_ECHOLNPGM("Special Menu: Next Mesh Point");
+ ExtUI::injectCommands_P(PSTR("G29 S2"));
+ break;
+
+ case '8': // "<08HtEndPID>"
+ SERIAL_ECHOLNPGM("Special Menu: Auto Tune Hotend PID");
+ // need to dwell for half a second to give the fan a chance to start before the pid tuning starts
+ ExtUI::injectCommands_P(PSTR("M106 S204\nG4 P500\nM303 E0 S215 C15 U1"));
+ break;
+
+ case '9': // "<09HtBedPID>"
+ SERIAL_ECHOLNPGM("Special Menu: Auto Tune Hotbed Pid");
+ ExtUI::injectCommands_P(PSTR("M303 E-1 S65 C6 U1"));
+ break;
+
+ default:
+ break;
+ }
+ break;
+
+ case '1':
+ switch (SelectedDirectory[2]) {
+ case '0': // "<10FWDeflts>"
+ SERIAL_ECHOLNPGM("Special Menu: Load FW Defaults");
+ ExtUI::injectCommands_P(PSTR("M502\nM300 P105 S1661\nM300 P210 S1108"));
+ break;
+
+ case '1': // "<11SvEEPROM>"
+ SERIAL_ECHOLNPGM("Special Menu: Save EEPROM");
+ ExtUI::injectCommands_P(PSTR("M500\nM300 P105 S1108\nM300 P210 S1661"));
+ break;
+
+ default:
+ break;
+ }
+ break;
+ #else // if ENABLED(PROBE_MANUALLY)
+ case '0':
+ switch (SelectedDirectory[2]) {
+ case '1': // "<01PrehtBed>"
+ SERIAL_ECHOLNPGM("Special Menu: Preheat Bed");
+ ExtUI::injectCommands_P(PSTR("M140 S65"));
+ break;
+
+ case '2': // "<02ABL>"
+ SERIAL_ECHOLNPGM("Special Menu: Auto Bed Leveling");
+ ExtUI::injectCommands_P(PSTR("G28\nG29"));
+ break;
+
+ case '3': // "<03HtendPID>"
+ SERIAL_ECHOLNPGM("Special Menu: Auto Tune Hotend PID");
+ // need to dwell for half a second to give the fan a chance to start before the pid tuning starts
+ ExtUI::injectCommands_P(PSTR("M106 S204\nG4 P500\nM303 E0 S215 C15 U1"));
+ break;
+
+ case '4': // "<04HtbedPID>"
+ SERIAL_ECHOLNPGM("Special Menu: Auto Tune Hotbed Pid");
+ ExtUI::injectCommands_P(PSTR("M303 E-1 S65 C6 U1"));
+ break;
+
+ case '5': // "<05FWDeflts>"
+ SERIAL_ECHOLNPGM("Special Menu: Load FW Defaults");
+ ExtUI::injectCommands_P(PSTR("M502\nM300 P105 S1661\nM300 P210 S1108"));
+ break;
+
+ case '6': // "<06SvEEPROM>"
+ SERIAL_ECHOLNPGM("Special Menu: Save EEPROM");
+ ExtUI::injectCommands_P(PSTR("M500\nM300 P105 S1108\nM300 P210 S1661"));
+ break;
+
+ case '7': // <07SendM108>
+ SERIAL_ECHOLNPGM("Special Menu: Send User Confirmation");
+ ExtUI::injectCommands_P(PSTR("M108"));
+ break;
+
+ default:
+ break;
+ }
+ break;
+ #endif // PROBE_MANUALLY
+
+ default:
+ break;
+ }
+ #if ENABLED(ANYCUBIC_TFT_DEBUG)
+ }
+ else {
+ SERIAL_ECHOPGM("TFT Serial Debug: Attempted to HandleSpecialMenu on non-special menu... ");
+ SERIAL_ECHOLN(SelectedDirectory);
+ #endif
+ }
+}
+
+void AnycubicTFTClass::RenderCurrentFileList() {
+ #if ENABLED(SDSUPPORT)
+ uint16_t selectedNumber = 0;
+ SelectedDirectory[0] = 0;
+ SelectedFile[0] = 0;
+
+ ANYCUBIC_SERIAL_PROTOCOLPGM("FN "); // Filelist start
+ ANYCUBIC_SERIAL_ENTER();
+
+ if (!ExtUI::isMediaInserted() && !SpecialMenu) {
+ ANYCUBIC_SENDCOMMAND_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>");
+ }
+ else {
+ if (CodeSeen('S'))
+ selectedNumber = CodeValue();
+
+ if (SpecialMenu)
+ RenderSpecialMenu(selectedNumber);
+ else
+ RenderCurrentFolder(selectedNumber);
+ }
+ ANYCUBIC_SERIAL_PROTOCOLPGM("END"); // Filelist stop
+ ANYCUBIC_SERIAL_ENTER();
+ #endif // SDSUPPORT
+}
+
+void AnycubicTFTClass::RenderSpecialMenu(uint16_t selectedNumber) {
+ 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>");
+ 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>");
+ 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>");
+ 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>");
+ 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>");
+ break;
+
+ #endif // PROBE_MANUALLY
+
+ default:
+ break;
+ }
+}
+
+void AnycubicTFTClass::RenderCurrentFolder(uint16_t selectedNumber) {
+ ExtUI::FileList currentFileList;
+ uint16_t cnt = selectedNumber;
+ uint16_t max_files;
+ uint16_t dir_files = currentFileList.count();
+
+ if ((dir_files - selectedNumber) < 4)
+ max_files = dir_files;
+ else
+ max_files = selectedNumber + 3;
+
+ for (cnt = selectedNumber; cnt <= max_files; cnt++) {
+ if (cnt == 0) { // Special Entry
+ if (currentFileList.isAtRootDir()) {
+ ANYCUBIC_SERIAL_PROTOCOLLNPGM("<specialmnu>");
+ ANYCUBIC_SERIAL_PROTOCOLLNPGM("<Special Menu>");
+ }
+ else {
+ ANYCUBIC_SERIAL_PROTOCOLLNPGM("/..");
+ ANYCUBIC_SERIAL_PROTOCOLLNPGM("/..");
+ }
+ }
+ else {
+ currentFileList.seek(cnt - 1, false);
+
+ #if ENABLED(ANYCUBIC_TFT_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());
+
+ }
+ else {
+ ANYCUBIC_SERIAL_PROTOCOLLN(currentFileList.shortFilename());
+ ANYCUBIC_SERIAL_PROTOCOLLN(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
+
+ #endif
+}
+
+void AnycubicTFTClass::OnPrintTimerPaused() {
+ #if ENABLED(SDSUPPORT)
+ if (ExtUI::isPrintingFromMedia()) {
+ mediaPrintingState = AMPRINTSTATE_PAUSED;
+ mediaPauseState = AMPAUSESTATE_PARKING;
+ }
+ #endif
+}
+
+void AnycubicTFTClass::OnPrintTimerStopped() {
+ #if ENABLED(SDSUPPORT)
+ if (mediaPrintingState == AMPRINTSTATE_PRINTING) {
+ mediaPrintingState = AMPRINTSTATE_NOT_PRINTING;
+ mediaPauseState = AMPAUSESTATE_NOT_PAUSED;
+ ANYCUBIC_SENDCOMMAND_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();
+ if (serial3_char == '\n' ||
+ serial3_char == '\r' ||
+ serial3_char == ':' ||
+ serial3_count >= (TFT_MAX_CMD_SIZE - 1)
+ ) {
+
+ if (!serial3_count) return; // if empty line
+
+ TFTcmdbuffer[TFTbufindw][serial3_count] = 0; // terminate string
+
+ if ((strchr(TFTcmdbuffer[TFTbufindw], 'A') != NULL)) {
+ int16_t a_command;
+ TFTstrchr_pointer = strchr(TFTcmdbuffer[TFTbufindw], 'A');
+ a_command = ((int)((strtod(&TFTcmdbuffer[TFTbufindw][TFTstrchr_pointer - TFTcmdbuffer[TFTbufindw] + 1], NULL))));
+
+ #if ENABLED(ANYCUBIC_TFT_DEBUG)
+ if ((a_command > 7) && (a_command != 20)) { // No debugging of status polls, please!
+ SERIAL_ECHOPGM("TFT Serial Command: ");
+ SERIAL_ECHOLN(TFTcmdbuffer[TFTbufindw]);
+ }
+ #endif
+
+ 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));
+ }
+ 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));
+ }
+ 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));
+ }
+ 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));
+ }
+ break;
+
+ case 4: // A4 GET FAN SPEED
+ {
+ float fanPercent = ExtUI::getActualFan_percent(ExtUI::FAN0);
+ fanPercent = constrain(fanPercent, 0, 100);
+ ANYCUBIC_SENDCOMMANDPGM_VAL("A4V ", int(fanPercent));
+ }
+ break;
+
+ case 5: // A5 GET CURRENT COORDINATE
+ {
+ 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();
+ }
+ break;
+
+ case 6: // A6 GET SD CARD PRINTING STATUS
+ #if ENABLED(SDSUPPORT)
+ if (ExtUI::isPrintingFromMedia()) {
+ ANYCUBIC_SERIAL_PROTOCOLPGM("A6V ");
+ if (ExtUI::isMediaInserted()) {
+ ANYCUBIC_SERIAL_PROTOCOL(itostr3(int(ExtUI::getProgress_percent())));
+ ANYCUBIC_SERIAL_ENTER();
+ }
+ else {
+ ANYCUBIC_SENDCOMMAND_DBG_PGM("J02", "TFT Serial Debug: No SD Card mounted to return printing status... J02");
+ }
+ }
+ else {
+ ANYCUBIC_SERIAL_PROTOCOLPGM("A6V ---");
+ ANYCUBIC_SERIAL_ENTER();
+ }
+ #endif
+ break;
+
+ case 7: { // A7 GET PRINTING TIME
+ uint32_t elapsedSeconds = ExtUI::getProgress_seconds_elapsed();
+ ANYCUBIC_SERIAL_PROTOCOLPGM("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");
+ }
+ else {
+ ANYCUBIC_SERIAL_SPACE();
+ ANYCUBIC_SERIAL_PROTOCOLPGM("999:999");
+ }
+ ANYCUBIC_SERIAL_ENTER();
+ }
+ break;
+
+ case 8: // A8 GET SD LIST
+ #if ENABLED(SDSUPPORT)
+ SelectedFile[0] = 0;
+ RenderCurrentFileList();
+ #endif
+ break;
+
+ case 9: // A9 pause sd print
+ #if ENABLED(SDSUPPORT)
+ if (ExtUI::isPrintingFromMedia())
+ PausePrint();
+
+ #endif
+ break;
+
+ case 10: // A10 resume sd print
+ #if ENABLED(SDSUPPORT)
+ if (ExtUI::isPrintingFromMediaPaused())
+ ResumePrint();
+
+ #endif
+ break;
+
+ case 11: // A11 STOP SD PRINT
+ #if ENABLED(SDSUPPORT)
+ StopPrint();
+ #endif
+ break;
+
+ case 12: // A12 kill
+ kill(PSTR(STR_ERR_KILLED));
+ break;
+
+ case 13: // A13 SELECTION FILE
+ #if ENABLED(SDSUPPORT)
+ if (ExtUI::isMediaInserted()) {
+ starpos = (strchr(TFTstrchr_pointer + 4, '*'));
+ 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();
+ }
+ 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();
+ }
+ else {
+ SelectedDirectory[0] = 0;
+
+ if (starpos != NULL)
+ *(starpos - 1) = '\0';
+
+ strcpy(SelectedFile, TFTstrchr_pointer + 4);
+ ANYCUBIC_SENDCOMMAND_DBG_PGM_VAL("J20", "TFT Serial Debug: File Selected... J20 ", SelectedFile); // J20 File Selected
+ }
+ }
+ #endif
+ break;
+
+ case 14: // A14 START PRINTING
+ #if ENABLED(SDSUPPORT)
+ if (!ExtUI::isPrinting() && strlen(SelectedFile) > 0)
+ StartPrint();
+
+ #endif
+ break;
+
+ case 15: // A15 RESUMING FROM OUTAGE
+ // TODO: JBA implement resume form outage
+ break;
+
+ case 16: { // A16 set hotend temp
+ unsigned int tempvalue;
+ if (CodeSeen('S')) {
+ tempvalue = constrain(CodeValue(), 0, 275);
+ ExtUI::setTargetTemp_celsius(tempvalue, (ExtUI::extruder_t) ExtUI::E0);
+ }
+ else if (CodeSeen('C') && !ExtUI::isPrinting()) {
+ if (ExtUI::getAxisPosition_mm(ExtUI::Z) < 10)
+ ExtUI::injectCommands_P(PSTR("G1 Z10")); // RASE Z AXIS
+ tempvalue = constrain(CodeValue(), 0, 275);
+ ExtUI::setTargetTemp_celsius(tempvalue, (ExtUI::extruder_t) ExtUI::E0);
+ }
+ }
+ break;
+
+ case 17:// A17 set heated bed temp
+ {
+ unsigned int tempbed;
+ if (CodeSeen('S')) {
+ tempbed = constrain(CodeValue(), 0, 100);
+ ExtUI::setTargetTemp_celsius(tempbed, (ExtUI::heater_t)ExtUI::BED);
+ }
+ }
+ break;
+
+ case 18:// A18 set fan speed
+ {
+ float fanPercent;
+ if (CodeSeen('S')) {
+ fanPercent = CodeValue();
+ fanPercent = constrain(fanPercent, 0, 100);
+ ExtUI::setTargetFan_percent(fanPercent, ExtUI::FAN0);
+ }
+ else {
+ fanPercent = 100;
+ }
+ ExtUI::setTargetFan_percent(fanPercent, ExtUI::FAN0);
+
+ ANYCUBIC_SERIAL_ENTER();
+ }
+ break;
+
+ case 19: // A19 stop stepper drivers - sent on stop extrude command and on turn motors off command
+ if (!ExtUI::isPrinting()) {
+ quickstop_stepper();
+ disable_all_steppers();
+ }
+
+ ANYCUBIC_SERIAL_ENTER();
+ break;
+
+ case 20: { // A20 read printing speed
+ int16_t feedrate_percentage = 100;
+
+ if (CodeSeen('S'))
+ feedrate_percentage = constrain(CodeValue(), 40, 999);
+ else
+ ANYCUBIC_SENDCOMMANDPGM_VAL("A20V ", feedrate_percentage);
+ }
+ break;
+
+ case 21: // A21 all home
+ if (!ExtUI::isPrinting() && !ExtUI::isPrintingFromMediaPaused()) {
+ if (CodeSeen('X') || CodeSeen('Y') || CodeSeen('Z')) {
+ if (CodeSeen('X'))
+ ExtUI::injectCommands_P(PSTR("G28 X"));
+ if (CodeSeen('Y'))
+ ExtUI::injectCommands_P(PSTR("G28 Y"));
+ if (CodeSeen('Z'))
+ ExtUI::injectCommands_P(PSTR("G28 Z"));
+ }
+ else if (CodeSeen('C')) {
+ ExtUI::injectCommands_P(PSTR("G28"));
+ }
+ }
+ break;
+
+ case 22: // A22 move X/Y/Z or extrude
+ if (!ExtUI::isPrinting()) {
+ float coorvalue;
+ unsigned int movespeed = 0;
+ char commandStr[30];
+ char fullCommandStr[38];
+
+ commandStr[0] = 0; // empty string
+ if (CodeSeen('F')) // Set feedrate
+ movespeed = CodeValue();
+
+ if (CodeSeen('X')) { // Move in X direction
+ coorvalue = CodeValue();
+ if ((coorvalue <= 0.2) && coorvalue > 0)
+ sprintf_P(commandStr, PSTR("G1 X0.1F%i"), movespeed);
+ else if ((coorvalue <= -0.1) && coorvalue > -1)
+ sprintf_P(commandStr, PSTR("G1 X-0.1F%i"), movespeed);
+ else
+ sprintf_P(commandStr, PSTR("G1 X%iF%i"), int(coorvalue), movespeed);
+ }
+ else if (CodeSeen('Y')) { // Move in Y direction
+ coorvalue = CodeValue();
+ if ((coorvalue <= 0.2) && coorvalue > 0)
+ sprintf_P(commandStr, PSTR("G1 Y0.1F%i"), movespeed);
+ else if ((coorvalue <= -0.1) && coorvalue > -1)
+ sprintf_P(commandStr, PSTR("G1 Y-0.1F%i"), movespeed);
+ else
+ sprintf_P(commandStr, PSTR("G1 Y%iF%i"), int(coorvalue), movespeed);
+ }
+ else if (CodeSeen('Z')) { // Move in Z direction
+ coorvalue = CodeValue();
+ if ((coorvalue <= 0.2) && coorvalue > 0)
+ sprintf_P(commandStr, PSTR("G1 Z0.1F%i"), movespeed);
+ else if ((coorvalue <= -0.1) && coorvalue > -1)
+ sprintf_P(commandStr, PSTR("G1 Z-0.1F%i"), movespeed);
+ else
+ sprintf_P(commandStr, PSTR("G1 Z%iF%i"), int(coorvalue), movespeed);
+ }
+ else if (CodeSeen('E')) { // Extrude
+ coorvalue = CodeValue();
+ if ((coorvalue <= 0.2) && coorvalue > 0)
+ sprintf_P(commandStr, PSTR("G1 E0.1F%i"), movespeed);
+ else if ((coorvalue <= -0.1) && coorvalue > -1)
+ sprintf_P(commandStr, PSTR("G1 E-0.1F%i"), movespeed);
+ else
+ sprintf_P(commandStr, PSTR("G1 E%iF500"), int(coorvalue));
+ }
+
+ if (strlen(commandStr) > 0) {
+ sprintf_P(fullCommandStr, PSTR("G91\n%s\nG90"), commandStr);
+ #if ENABLED(ANYCUBIC_TFT_DEBUG)
+ SERIAL_ECHOPGM("TFT Serial Debug: A22 Move final request with gcode... ");
+ SERIAL_ECHOLN(fullCommandStr);
+ #endif
+ ExtUI::injectCommands(fullCommandStr);
+ }
+ }
+ ANYCUBIC_SERIAL_ENTER();
+ break;
+
+ case 23: // A23 preheat pla
+ if (!ExtUI::isPrinting()) {
+ if (ExtUI::getAxisPosition_mm(ExtUI::Z) < 10)
+ ExtUI::injectCommands_P(PSTR("G1 Z10")); // RASE Z AXIS
+
+ 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();
+ }
+ break;
+
+ case 24:// A24 preheat abs
+ if (!ExtUI::isPrinting()) {
+ if (ExtUI::getAxisPosition_mm(ExtUI::Z) < 10)
+ ExtUI::injectCommands_P(PSTR("G1 Z10")); // RASE Z AXIS
+
+ 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();
+ }
+ break;
+
+ case 25: // A25 cool down
+ if (!ExtUI::isPrinting()) {
+ 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
+ }
+ break;
+
+ case 26: // A26 refresh SD
+ #if ENABLED(SDSUPPORT)
+ if (ExtUI::isMediaInserted()) {
+ if (strlen(SelectedDirectory) > 0) {
+ ExtUI::FileList currentFileList;
+ if ((SelectedDirectory[0] == '.') && (SelectedDirectory[1] == '.')) {
+ currentFileList.upDir();
+ }
+ else {
+ if (SelectedDirectory[0] == '<')
+ HandleSpecialMenu();
+ else
+ currentFileList.changeDir(SelectedDirectory);
+ }
+ }
+ }
+ else {
+ ANYCUBIC_SENDCOMMAND_DBG_PGM("J02", "TFT Serial Debug: No SD Card mounted to refresh SD A26... J02");
+ }
+
+ SelectedDirectory[0] = 0;
+ #endif
+ break;
+
+ #if ENABLED(SERVO_ENDSTOPS)
+ case 27: break; // A27 servos angles adjust
+ #endif
+
+ case 28: // A28 filament test
+ if (CodeSeen('O'))
+ NOOP;
+ else if (CodeSeen('C'))
+ NOOP;
+ ANYCUBIC_SERIAL_ENTER();
+ break;
+
+ case 33: // A33 get version info
+ ANYCUBIC_SERIAL_PROTOCOLPGM("J33 ");
+ ANYCUBIC_SERIAL_PROTOCOLPGM(DETAILED_BUILD_VERSION);
+ ANYCUBIC_SERIAL_ENTER();
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ TFTbufindw = (TFTbufindw + 1) % TFTBUFSIZE;
+ TFTbuflen += 1;
+ serial3_count = 0; // clear buffer
+ }
+ else {
+ TFTcmdbuffer[TFTbufindw][serial3_count++] = serial3_char;
+ }
+ }
+}
+
+void AnycubicTFTClass::DoSDCardStateCheck() {
+ #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");
+ else
+ ANYCUBIC_SENDCOMMAND_DBG_PGM("J01", "TFT Serial Debug: SD card state changed... !isInserted");
+
+ #endif
+}
+
+void AnycubicTFTClass::DoFilamentRunoutCheck() {
+ #if ENABLED(FILAMENT_RUNOUT_SENSOR)
+ // NOTE: ExtUI::getFilamentRunoutState() only returns the runout state if the job is printing
+ // we want to actually check the status of the pin here, regardless of printstate
+ if (READ(FIL_RUNOUT_PIN)) {
+ if (mediaPrintingState == AMPRINTSTATE_PRINTING || mediaPrintingState == AMPRINTSTATE_PAUSED || mediaPrintingState == AMPRINTSTATE_PAUSE_REQUESTED) {
+ // play tone to indicate filament is out
+ 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");
+ }
+ else {
+ ANYCUBIC_SENDCOMMAND_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)
+ SERIAL_ECHOPGM("TFT Serial Debug: About to print file ... ");
+ SERIAL_ECHO(ExtUI::isPrinting());
+ SERIAL_ECHOPGM(" ");
+ SERIAL_ECHOLN(SelectedFile);
+ #endif
+ mediaPrintingState = AMPRINTSTATE_PRINTING;
+ mediaPauseState = AMPAUSESTATE_NOT_PAUSED;
+ ExtUI::printFile(SelectedFile);
+ }
+ #endif // SDUPPORT
+}
+
+void AnycubicTFTClass::PausePrint() {
+ #if ENABLED(SDSUPPORT)
+ 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
+
+ // 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"));
+ ExtUI::pausePrint();
+ }
+ #endif
+}
+
+void AnycubicTFTClass::ResumePrint() {
+ #if ENABLED(SDSUPPORT)
+ #if ENABLED(FILAMENT_RUNOUT_SENSOR)
+ if (READ(FIL_RUNOUT_PIN)) {
+ #if ENABLED(ANYCUBIC_TFT_DEBUG)
+ SERIAL_ECHOLNPGM("TFT Serial Debug: Resume Print with filament sensor still tripped... ");
+ #endif
+
+ // trigger the user message box
+ DoFilamentRunoutCheck();
+
+ // re-enable the continue button
+ ANYCUBIC_SENDCOMMAND_DBG_PGM("J18", "TFT Serial Debug: Resume Print with filament sensor still tripped... J18");
+ return;
+ }
+ #endif
+
+ if (mediaPauseState == AMPAUSESTATE_HEATER_TIMEOUT) {
+ 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
+
+ // reheat the nozzle
+ ExtUI::setUserConfirmed();
+ }
+ else {
+ 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
+ ExtUI::resumePrint();
+ }
+ #endif
+}
+
+void AnycubicTFTClass::StopPrint() {
+ #if ENABLED(SDSUPPORT)
+ mediaPrintingState = AMPRINTSTATE_STOP_REQUESTED;
+ mediaPauseState = AMPAUSESTATE_NOT_PAUSED;
+ ANYCUBIC_SENDCOMMAND_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"));
+ ExtUI::stopPrint();
+ #endif
+}
+
+#endif // ANYCUBIC_TFT_MODEL
diff --git a/Marlin/src/lcd/extui/lib/anycubic/anycubic_tft.h b/Marlin/src/lcd/extui/lib/anycubic/anycubic_tft.h
new file mode 100644
index 00000000000..324dfd213f4
--- /dev/null
+++ b/Marlin/src/lcd/extui/lib/anycubic/anycubic_tft.h
@@ -0,0 +1,114 @@
+/**
+ * anycubic_tft.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
+ *
+ * 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
+ */
+#pragma once
+
+#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);
+ char *ftostr32(const float &);
+#endif
+
+#define TFTBUFSIZE 4
+#define TFT_MAX_CMD_SIZE 96
+
+enum AnycubicMediaPrintState {
+ AMPRINTSTATE_NOT_PRINTING,
+ AMPRINTSTATE_PRINTING,
+ AMPRINTSTATE_PAUSE_REQUESTED,
+ AMPRINTSTATE_PAUSED,
+ AMPRINTSTATE_STOP_REQUESTED
+};
+
+enum AnycubicMediaPauseState {
+ AMPAUSESTATE_NOT_PAUSED,
+ AMPAUSESTATE_PARKING,
+ AMPAUSESTATE_PARKED,
+ AMPAUSESTATE_FILAMENT_OUT,
+ AMPAUSESTATE_FIAMENT_PRUGING,
+ AMPAUSESTATE_HEATER_TIMEOUT,
+ AMPAUSESTATE_REHEATING,
+ AMPAUSESTATE_REHEAT_FINISHED
+};
+
+class AnycubicTFTClass {
+public:
+ AnycubicTFTClass();
+ void OnSetup();
+ void OnCommandScan();
+ void OnKillTFT();
+ void OnSDCardStateChange(bool);
+ void OnSDCardError();
+ void OnFilamentRunout();
+ void OnUserConfirmRequired(const char *);
+ void OnPrintTimerStarted();
+ void OnPrintTimerPaused();
+ void OnPrintTimerStopped();
+
+private:
+ char TFTcmdbuffer[TFTBUFSIZE][TFT_MAX_CMD_SIZE];
+ int TFTbuflen=0;
+ int TFTbufindr = 0;
+ int TFTbufindw = 0;
+ char serial3_char;
+ int serial3_count = 0;
+ char *TFTstrchr_pointer;
+ uint8_t SpecialMenu = false;
+ AnycubicMediaPrintState mediaPrintingState = AMPRINTSTATE_NOT_PRINTING;
+ AnycubicMediaPauseState mediaPauseState = AMPAUSESTATE_NOT_PAUSED;
+
+ float CodeValue();
+ bool CodeSeen(char);
+ bool IsNozzleHomed();
+ void RenderCurrentFileList();
+ void RenderSpecialMenu(uint16_t);
+ void RenderCurrentFolder(uint16_t);
+ void GetCommandFromTFT();
+ void CheckSDCardChange();
+ void CheckPauseState();
+ void CheckPrintCompletion();
+ void HandleSpecialMenu();
+ void DoSDCardStateCheck();
+ void DoFilamentRunoutCheck();
+ void StartPrint();
+ void PausePrint();
+ void ResumePrint();
+ void StopPrint();
+
+ char SelectedDirectory[30];
+ char SelectedFile[FILENAME_LENGTH];
+};
+
+extern AnycubicTFTClass AnycubicTFT;
diff --git a/Marlin/src/lcd/extui_anycubic_tft.cpp b/Marlin/src/lcd/extui_anycubic_tft.cpp
new file mode 100644
index 00000000000..6782f8d9d6a
--- /dev/null
+++ b/Marlin/src/lcd/extui_anycubic_tft.cpp
@@ -0,0 +1,104 @@
+/**
+ * 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_tft.cpp
+ */
+
+#include "../inc/MarlinConfigPre.h"
+
+#if BOTH(ANYCUBIC_TFT_MODEL, EXTENSIBLE_UI)
+
+#include "extui/lib/anycubic/anycubic_tft.h"
+#include "extui/ui_api.h"
+
+#include <Arduino.h> // for the ::tone() call
+
+namespace ExtUI {
+
+ void onStartup() { AnycubicTFT.OnSetup(); }
+ void onIdle() { AnycubicTFT.OnCommandScan(); }
+ void onPrinterKilled(PGM_P const error, PGM_P const component) { AnycubicTFT.OnKillTFT(); }
+ void onMediaInserted() { AnycubicTFT.OnSDCardStateChange(true); }
+ void onMediaError() { AnycubicTFT.OnSDCardError(); }
+ void onMediaRemoved() { AnycubicTFT.OnSDCardStateChange(false); }
+ void onPlayTone(const uint16_t frequency, const uint16_t duration) {
+ #if ENABLED(SPEAKER)
+ ::tone(BEEPER_PIN, frequency, duration);
+ #endif
+ }
+ void onPrintTimerStarted() { AnycubicTFT.OnPrintTimerStarted(); }
+ void onPrintTimerPaused() { AnycubicTFT.OnPrintTimerPaused(); }
+ void onPrintTimerStopped() { AnycubicTFT.OnPrintTimerStopped(); }
+ void onFilamentRunout(const extruder_t extruder) { AnycubicTFT.OnFilamentRunout(); }
+ void onUserConfirmRequired(const char * const msg) { AnycubicTFT.OnUserConfirmRequired(msg); }
+ void onStatusChanged(const char * const msg) {}
+ void onFactoryReset() {}
+
+ void onStoreSettings(char *buff) {
+ // Called when saving to EEPROM (i.e. M500). If the ExtUI needs
+ // permanent data to be stored, it can write up to eeprom_data_size bytes
+ // into buff.
+
+ // Example:
+ // static_assert(sizeof(myDataStruct) <= ExtUI::eeprom_data_size);
+ // memcpy(buff, &myDataStruct, sizeof(myDataStruct));
+ }
+
+ void onLoadSettings(const char *buff) {
+ // Called while loading settings from EEPROM. If the ExtUI
+ // needs to retrieve data, it should copy up to eeprom_data_size bytes
+ // from buff
+
+ // Example:
+ // static_assert(sizeof(myDataStruct) <= ExtUI::eeprom_data_size);
+ // memcpy(&myDataStruct, buff, sizeof(myDataStruct));
+ }
+
+ void onConfigurationStoreWritten(bool success) {
+ // Called after the entire EEPROM has been written,
+ // whether successful or not.
+ }
+
+ void onConfigurationStoreRead(bool success) {
+ // Called after the entire EEPROM has been read,
+ // whether successful or not.
+ }
+
+ void onMeshUpdate(const int8_t xpos, const int8_t ypos, const float zval) {
+ // Called when any mesh points are updated
+ }
+
+ #if ENABLED(POWER_LOSS_RECOVERY)
+ void onPowerLossResume() {
+ // Called on resume from power-loss
+ }
+ #endif
+
+ #if HAS_PID_HEATING
+ void onPidTuning(const result_t rst) {
+ // Called for temperature PID tuning result
+ }
+ #endif
+}
+
+#endif // ANYCUBIC_TFT_MODEL && EXTENSIBLE_UI
diff --git a/Marlin/src/pins/ramps/pins_TRIGORILLA_14.h b/Marlin/src/pins/ramps/pins_TRIGORILLA_14.h
index a512aa8353f..ce3160ffe93 100644
--- a/Marlin/src/pins/ramps/pins_TRIGORILLA_14.h
+++ b/Marlin/src/pins/ramps/pins_TRIGORILLA_14.h
@@ -38,15 +38,38 @@
#endif
//
-// Custom Limit Switches
+// 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
- #define Y_MIN_PIN 19
+#else
+ #define X_MAX_PIN 43
#endif
-// 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
@@ -55,6 +78,11 @@
#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
+
// Remap MOSFET pins to common usages:
#define RAMPS_D10_PIN TG_HEATER_0_PIN // HEATER_0_PIN is always RAMPS_D10_PIN in pins_RAMPS.h