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 +#include +#include +#include +#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 +#include + +#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': // "" + 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(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + } + 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(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM("<02ZUp0.02>"); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM("<03ZDn0.02>"); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM("<04ZDn0.1>"); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + break; + + case 4: // Second Page + ANYCUBIC_SERIAL_PROTOCOLLNPGM("<05PrehtBed>"); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM("<06SMeshLvl>"); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM("<07MeshNPnt>"); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM("<08HtEndPID>"); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + break; + + case 8: // Third Page + ANYCUBIC_SERIAL_PROTOCOLLNPGM("<09HtBedPID>"); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM("<10FWDeflts>"); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM("<11SvEEPROM>"); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + break; + #else + case 0: // First Page + ANYCUBIC_SERIAL_PROTOCOLLNPGM("<01PrehtBed>"); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM("<02ABL>"); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM("<03HtEndPID>"); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM("<04HtBedPID>"); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + break; + + case 4: // Second Page + ANYCUBIC_SERIAL_PROTOCOLLNPGM("<05FWDeflts>"); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM("<06SvEEPROM>"); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM("<07SendM108>"); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + 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(""); + ANYCUBIC_SERIAL_PROTOCOLLNPGM(""); + } + 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 . + * + */ + +/** + * 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 // 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