2018-02-04 06:39:01 +00:00
|
|
|
/**
|
|
|
|
* Marlin 3D Printer Firmware
|
2020-02-03 14:00:57 +00:00
|
|
|
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
2018-02-04 06:39:01 +00:00
|
|
|
*
|
|
|
|
* Based on Sprinter and grbl.
|
2019-06-28 04:57:50 +00:00
|
|
|
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
|
2018-02-04 06:39:01 +00:00
|
|
|
*
|
|
|
|
* 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
|
2020-07-23 03:20:14 +00:00
|
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
2018-02-04 06:39:01 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
2020-08-20 06:38:22 +00:00
|
|
|
* malyan_lcd.cpp
|
2018-02-04 06:39:01 +00:00
|
|
|
*
|
|
|
|
* LCD implementation for Malyan's LCD, a separate ESP8266 MCU running
|
|
|
|
* on Serial1 for the M200 board. This module outputs a pseudo-gcode
|
|
|
|
* wrapped in curly braces which the LCD implementation translates into
|
|
|
|
* actual G-code commands.
|
|
|
|
*
|
|
|
|
* Added to Marlin for Mini/Malyan M200
|
|
|
|
* Unknown commands as of Jan 2018: {H:}
|
|
|
|
* Not currently implemented:
|
|
|
|
* {E:} when sent by LCD. Meaning unknown.
|
|
|
|
*
|
|
|
|
* Notes for connecting to boards that are not Malyan:
|
|
|
|
* The LCD is 3.3v, so if powering from a RAMPS 1.4 board or
|
|
|
|
* other 5v/12v board, use a buck converter to power the LCD and
|
|
|
|
* the 3.3v side of a logic level shifter. Aux1 on the RAMPS board
|
|
|
|
* has Serial1 and 12v, making it perfect for this.
|
|
|
|
* Copyright (c) 2017 Jason Nelson (xC0000005)
|
|
|
|
*/
|
|
|
|
|
2020-08-20 06:38:22 +00:00
|
|
|
#include "../../inc/MarlinConfigPre.h"
|
2018-02-09 03:59:53 +00:00
|
|
|
|
|
|
|
#if ENABLED(MALYAN_LCD)
|
|
|
|
|
2020-09-24 00:45:33 +00:00
|
|
|
//#define DEBUG_MALYAN_LCD
|
2019-08-17 01:02:35 +00:00
|
|
|
|
2020-08-20 06:38:22 +00:00
|
|
|
#include "ui_api.h"
|
2019-05-04 04:53:15 +00:00
|
|
|
|
2020-08-20 06:38:22 +00:00
|
|
|
#include "../ultralcd.h"
|
|
|
|
#include "../../sd/cardreader.h"
|
|
|
|
#include "../../module/temperature.h"
|
|
|
|
#include "../../module/stepper.h"
|
|
|
|
#include "../../module/motion.h"
|
|
|
|
#include "../../libs/duration_t.h"
|
|
|
|
#include "../../module/printcounter.h"
|
|
|
|
#include "../../gcode/queue.h"
|
2018-02-04 06:39:01 +00:00
|
|
|
|
2019-08-17 01:02:35 +00:00
|
|
|
#define DEBUG_OUT ENABLED(DEBUG_MALYAN_LCD)
|
2020-08-20 06:38:22 +00:00
|
|
|
#include "../../core/debug_out.h"
|
2019-08-17 01:02:35 +00:00
|
|
|
|
2018-02-04 06:39:01 +00:00
|
|
|
// This is based on longest sys command + a filename, plus some buffer
|
|
|
|
// in case we encounter some data we don't recognize
|
2018-02-20 11:37:38 +00:00
|
|
|
// There is no evidence a line will ever be this long, but better safe than sorry
|
2018-02-04 06:39:01 +00:00
|
|
|
#define MAX_CURLY_COMMAND (32 + LONG_FILENAME_LENGTH) * 2
|
|
|
|
|
|
|
|
// Track incoming command bytes from the LCD
|
2020-04-23 03:02:31 +00:00
|
|
|
uint16_t inbound_count;
|
2018-02-04 06:39:01 +00:00
|
|
|
|
2018-07-10 17:55:29 +00:00
|
|
|
// For sending print completion messages
|
|
|
|
bool last_printing_status = false;
|
|
|
|
|
2018-02-04 06:39:01 +00:00
|
|
|
// Everything written needs the high bit set.
|
2018-10-01 04:44:33 +00:00
|
|
|
void write_to_lcd_P(PGM_P const message) {
|
2018-02-04 06:39:01 +00:00
|
|
|
char encoded_message[MAX_CURLY_COMMAND];
|
2019-07-05 23:01:21 +00:00
|
|
|
uint8_t message_length = _MIN(strlen_P(message), sizeof(encoded_message));
|
2018-02-04 06:39:01 +00:00
|
|
|
|
2020-03-14 04:18:16 +00:00
|
|
|
LOOP_L_N(i, message_length)
|
2018-02-20 11:37:38 +00:00
|
|
|
encoded_message[i] = pgm_read_byte(&message[i]) | 0x80;
|
2018-02-04 06:39:01 +00:00
|
|
|
|
|
|
|
LCD_SERIAL.Print::write(encoded_message, message_length);
|
|
|
|
}
|
|
|
|
|
|
|
|
void write_to_lcd(const char * const message) {
|
|
|
|
char encoded_message[MAX_CURLY_COMMAND];
|
2019-07-05 23:01:21 +00:00
|
|
|
const uint8_t message_length = _MIN(strlen(message), sizeof(encoded_message));
|
2018-02-04 06:39:01 +00:00
|
|
|
|
2020-03-14 04:18:16 +00:00
|
|
|
LOOP_L_N(i, message_length)
|
2018-02-04 06:39:01 +00:00
|
|
|
encoded_message[i] = message[i] | 0x80;
|
|
|
|
|
|
|
|
LCD_SERIAL.Print::write(encoded_message, message_length);
|
|
|
|
}
|
|
|
|
|
2020-05-04 19:37:43 +00:00
|
|
|
// {E:<msg>} is for error states.
|
|
|
|
void set_lcd_error_P(PGM_P const error, PGM_P const component=nullptr) {
|
|
|
|
write_to_lcd_P(PSTR("{E:"));
|
|
|
|
write_to_lcd_P(error);
|
|
|
|
if (component) {
|
|
|
|
write_to_lcd_P(PSTR(" "));
|
|
|
|
write_to_lcd_P(component);
|
|
|
|
}
|
|
|
|
write_to_lcd_P(PSTR("}"));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-04 06:39:01 +00:00
|
|
|
/**
|
|
|
|
* Process an LCD 'C' command.
|
|
|
|
* These are currently all temperature commands
|
|
|
|
* {C:T0190}
|
|
|
|
* Set temp for hotend to 190
|
|
|
|
* {C:P050}
|
|
|
|
* Set temp for bed to 50
|
2018-02-11 01:25:34 +00:00
|
|
|
*
|
2018-07-10 17:55:29 +00:00
|
|
|
* {C:S09} set feedrate to 90 %.
|
|
|
|
* {C:S12} set feedrate to 120 %.
|
|
|
|
*
|
2018-02-04 06:39:01 +00:00
|
|
|
* the command portion begins after the :
|
|
|
|
*/
|
|
|
|
void process_lcd_c_command(const char* command) {
|
2019-10-06 03:37:22 +00:00
|
|
|
const int target_val = command[1] ? atoi(command + 1) : -1;
|
|
|
|
if (target_val < 0) {
|
|
|
|
DEBUG_ECHOLNPAIR("UNKNOWN C COMMAND ", command);
|
|
|
|
return;
|
|
|
|
}
|
2018-02-04 06:39:01 +00:00
|
|
|
switch (command[0]) {
|
2019-06-26 08:35:52 +00:00
|
|
|
case 'C': // Cope with both V1 early rev and later LCDs.
|
2019-07-28 03:44:05 +00:00
|
|
|
case 'S':
|
2019-10-06 03:37:22 +00:00
|
|
|
feedrate_percentage = target_val * 10;
|
2019-07-10 08:33:28 +00:00
|
|
|
LIMIT(feedrate_percentage, 10, 999);
|
2019-07-28 03:44:05 +00:00
|
|
|
break;
|
2018-02-04 06:39:01 +00:00
|
|
|
|
2019-10-06 03:37:22 +00:00
|
|
|
case 'T':
|
|
|
|
// Sometimes the LCD will send commands to turn off both extruder and bed, though
|
|
|
|
// this should not happen since the printing screen is up. Better safe than sorry.
|
|
|
|
if (!print_job_timer.isRunning() || target_val > 0)
|
|
|
|
ExtUI::setTargetTemp_celsius(target_val, ExtUI::extruder_t::E0);
|
|
|
|
break;
|
2019-07-28 03:44:05 +00:00
|
|
|
|
|
|
|
#if HAS_HEATED_BED
|
2019-10-06 03:37:22 +00:00
|
|
|
case 'P': ExtUI::setTargetTemp_celsius(target_val, ExtUI::heater_t::BED); break;
|
2019-07-28 03:44:05 +00:00
|
|
|
#endif
|
|
|
|
|
2019-08-17 01:02:35 +00:00
|
|
|
default: DEBUG_ECHOLNPAIR("UNKNOWN C COMMAND ", command);
|
2018-02-04 06:39:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Process an LCD 'B' command.
|
|
|
|
* {B:0} results in: {T0:008/195}{T1:000/000}{TP:000/000}{TQ:000C}{TT:000000}
|
|
|
|
* T0/T1 are hot end temperatures, TP is bed, TQ is percent, and TT is probably
|
|
|
|
* time remaining (HH:MM:SS). The UI can't handle displaying a second hotend,
|
|
|
|
* but the stock firmware always sends it, and it's always zero.
|
|
|
|
*/
|
|
|
|
void process_lcd_eb_command(const char* command) {
|
|
|
|
char elapsed_buffer[10];
|
2019-10-06 03:37:22 +00:00
|
|
|
static uint8_t iteration = 0;
|
2018-02-04 06:39:01 +00:00
|
|
|
duration_t elapsed;
|
|
|
|
switch (command[0]) {
|
|
|
|
case '0': {
|
|
|
|
elapsed = print_job_timer.duration();
|
2019-07-02 09:29:07 +00:00
|
|
|
sprintf_P(elapsed_buffer, PSTR("%02u%02u%02u"), uint16_t(elapsed.hour()), uint16_t(elapsed.minute()) % 60, uint16_t(elapsed.second()) % 60);
|
2018-02-04 06:39:01 +00:00
|
|
|
|
|
|
|
char message_buffer[MAX_CURLY_COMMAND];
|
2019-10-06 03:37:22 +00:00
|
|
|
uint8_t done_pct = print_job_timer.isRunning() ? (iteration * 10) : 100;
|
|
|
|
iteration = (iteration + 1) % 10; // Provide progress animation
|
|
|
|
#if ENABLED(SDSUPPORT)
|
|
|
|
if (ExtUI::isPrintingFromMedia() || ExtUI::isPrintingFromMediaPaused())
|
|
|
|
done_pct = card.percentDone();
|
|
|
|
#endif
|
|
|
|
|
2018-02-04 06:39:01 +00:00
|
|
|
sprintf_P(message_buffer,
|
2019-08-08 06:51:37 +00:00
|
|
|
PSTR("{T0:%03i/%03i}{T1:000/000}{TP:%03i/%03i}{TQ:%03i}{TT:%s}"),
|
|
|
|
int(thermalManager.degHotend(0)), thermalManager.degTargetHotend(0),
|
2019-07-28 03:44:05 +00:00
|
|
|
#if HAS_HEATED_BED
|
2019-08-08 06:51:37 +00:00
|
|
|
int(thermalManager.degBed()), thermalManager.degTargetBed(),
|
2019-07-28 03:44:05 +00:00
|
|
|
#else
|
|
|
|
0, 0,
|
|
|
|
#endif
|
|
|
|
#if ENABLED(SDSUPPORT)
|
2019-10-06 03:37:22 +00:00
|
|
|
done_pct,
|
2019-07-28 03:44:05 +00:00
|
|
|
#else
|
|
|
|
0,
|
|
|
|
#endif
|
|
|
|
elapsed_buffer
|
|
|
|
);
|
2018-02-04 06:39:01 +00:00
|
|
|
write_to_lcd(message_buffer);
|
|
|
|
} break;
|
|
|
|
|
2019-08-17 01:02:35 +00:00
|
|
|
default: DEBUG_ECHOLNPAIR("UNKNOWN E/B COMMAND ", command);
|
2018-02-04 06:39:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Process an LCD 'J' command.
|
|
|
|
* These are currently all movement commands.
|
|
|
|
* The command portion begins after the :
|
|
|
|
* Move X Axis
|
2018-02-11 01:25:34 +00:00
|
|
|
*
|
2018-02-04 06:39:01 +00:00
|
|
|
* {J:E}{J:X-200}{J:E}
|
|
|
|
* {J:E}{J:X+200}{J:E}
|
|
|
|
* X, Y, Z, A (extruder)
|
|
|
|
*/
|
2020-05-04 22:44:01 +00:00
|
|
|
template<typename T>
|
|
|
|
void j_move_axis(const char* command, const T axis) {
|
|
|
|
const float dist = atof(command + 1) / 10.0;
|
|
|
|
ExtUI::setAxisPosition_mm(ExtUI::getAxisPosition_mm(axis) + dist, axis);
|
|
|
|
};
|
2019-08-17 01:02:35 +00:00
|
|
|
|
2020-05-04 22:44:01 +00:00
|
|
|
void process_lcd_j_command(const char* command) {
|
2019-08-17 01:02:35 +00:00
|
|
|
switch (command[0]) {
|
|
|
|
case 'E': break;
|
2020-05-04 22:44:01 +00:00
|
|
|
case 'A': j_move_axis<ExtUI::extruder_t>(command, ExtUI::extruder_t::E0); break;
|
|
|
|
case 'Y': j_move_axis<ExtUI::axis_t>(command, ExtUI::axis_t::Y); break;
|
|
|
|
case 'Z': j_move_axis<ExtUI::axis_t>(command, ExtUI::axis_t::Z); break;
|
|
|
|
case 'X': j_move_axis<ExtUI::axis_t>(command, ExtUI::axis_t::X); break;
|
2019-08-17 01:02:35 +00:00
|
|
|
default: DEBUG_ECHOLNPAIR("UNKNOWN J COMMAND ", command);
|
2018-02-04 06:39:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Process an LCD 'P' command, related to homing and printing.
|
|
|
|
* Cancel:
|
|
|
|
* {P:X}
|
2018-02-11 01:25:34 +00:00
|
|
|
*
|
2018-02-04 06:39:01 +00:00
|
|
|
* Home all axes:
|
|
|
|
* {P:H}
|
2018-02-11 01:25:34 +00:00
|
|
|
*
|
2018-02-04 06:39:01 +00:00
|
|
|
* Print a file:
|
|
|
|
* {P:000}
|
|
|
|
* The File number is specified as a three digit value.
|
|
|
|
* Printer responds with:
|
|
|
|
* {PRINTFILE:Mini_SNES_Bottom.gcode}
|
|
|
|
* {SYS:BUILD}echo:Now fresh file: Mini_SNES_Bottom.gcode
|
|
|
|
* File opened: Mini_SNES_Bottom.gcode Size: 5805813
|
|
|
|
* File selected
|
|
|
|
* {SYS:BUILD}
|
|
|
|
* T:-2526.8 E:0
|
|
|
|
* T:-2533.0 E:0
|
|
|
|
* T:-2537.4 E:0
|
|
|
|
* Note only the curly brace stuff matters.
|
|
|
|
*/
|
|
|
|
void process_lcd_p_command(const char* command) {
|
|
|
|
|
|
|
|
switch (command[0]) {
|
2019-08-17 01:02:35 +00:00
|
|
|
case 'P':
|
|
|
|
ExtUI::pausePrint();
|
|
|
|
write_to_lcd_P(PSTR("{SYS:PAUSED}"));
|
|
|
|
break;
|
|
|
|
case 'R':
|
|
|
|
ExtUI::resumePrint();
|
|
|
|
write_to_lcd_P(PSTR("{SYS:RESUMED}"));
|
|
|
|
break;
|
2018-02-04 06:39:01 +00:00
|
|
|
case 'X':
|
2018-05-24 09:39:34 +00:00
|
|
|
write_to_lcd_P(PSTR("{SYS:CANCELING}"));
|
2019-08-17 01:02:35 +00:00
|
|
|
ExtUI::stopPrint();
|
2018-05-24 09:39:34 +00:00
|
|
|
write_to_lcd_P(PSTR("{SYS:STARTED}"));
|
2019-08-17 01:02:35 +00:00
|
|
|
break;
|
2019-11-02 04:51:25 +00:00
|
|
|
case 'H': queue.enqueue_now_P(G28_STR); break; // Home all axes
|
2018-02-04 06:39:01 +00:00
|
|
|
default: {
|
2018-05-24 09:39:34 +00:00
|
|
|
#if ENABLED(SDSUPPORT)
|
|
|
|
// Print file 000 - a three digit number indicating which
|
|
|
|
// file to print in the SD card. If it's a directory,
|
|
|
|
// then switch to the directory.
|
|
|
|
|
|
|
|
// Find the name of the file to print.
|
|
|
|
// It's needed to echo the PRINTFILE option.
|
|
|
|
// The {S:L} command should've ensured the SD card was mounted.
|
2019-09-28 20:28:05 +00:00
|
|
|
card.selectFileByIndex(atoi(command));
|
2018-05-24 09:39:34 +00:00
|
|
|
|
|
|
|
// There may be a difference in how V1 and V2 LCDs handle subdirectory
|
|
|
|
// prints. Investigate more. This matches the V1 motion controller actions
|
|
|
|
// but the V2 LCD switches to "print" mode on {SYS:DIR} response.
|
2018-11-17 04:39:16 +00:00
|
|
|
if (card.flag.filenameIsDir) {
|
2019-09-28 20:28:05 +00:00
|
|
|
card.cd(card.filename);
|
2018-05-24 09:39:34 +00:00
|
|
|
write_to_lcd_P(PSTR("{SYS:DIR}"));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
char message_buffer[MAX_CURLY_COMMAND];
|
2018-07-10 17:55:29 +00:00
|
|
|
sprintf_P(message_buffer, PSTR("{PRINTFILE:%s}"), card.longest_filename());
|
2018-05-24 09:39:34 +00:00
|
|
|
write_to_lcd(message_buffer);
|
|
|
|
write_to_lcd_P(PSTR("{SYS:BUILD}"));
|
|
|
|
card.openAndPrintFile(card.filename);
|
|
|
|
}
|
|
|
|
#endif
|
2018-02-04 06:39:01 +00:00
|
|
|
} break; // default
|
|
|
|
} // switch
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Handle an lcd 'S' command
|
|
|
|
* {S:I} - Temperature request
|
|
|
|
* {T0:999/000}{T1:000/000}{TP:004/000}
|
2018-02-11 01:25:34 +00:00
|
|
|
*
|
2018-02-04 06:39:01 +00:00
|
|
|
* {S:L} - File Listing request
|
|
|
|
* Printer Response:
|
|
|
|
* {FILE:buttons.gcode}
|
|
|
|
* {FILE:update.bin}
|
|
|
|
* {FILE:nupdate.bin}
|
|
|
|
* {FILE:fcupdate.flg}
|
|
|
|
* {SYS:OK}
|
|
|
|
*/
|
|
|
|
void process_lcd_s_command(const char* command) {
|
|
|
|
switch (command[0]) {
|
|
|
|
case 'I': {
|
|
|
|
// temperature information
|
|
|
|
char message_buffer[MAX_CURLY_COMMAND];
|
2019-08-08 06:51:37 +00:00
|
|
|
sprintf_P(message_buffer, PSTR("{T0:%03i/%03i}{T1:000/000}{TP:%03i/%03i}"),
|
|
|
|
int(thermalManager.degHotend(0)), thermalManager.degTargetHotend(0),
|
2018-05-24 09:39:34 +00:00
|
|
|
#if HAS_HEATED_BED
|
2019-08-08 06:51:37 +00:00
|
|
|
int(thermalManager.degBed()), thermalManager.degTargetBed()
|
2018-05-24 09:39:34 +00:00
|
|
|
#else
|
|
|
|
0, 0
|
|
|
|
#endif
|
2018-02-04 06:39:01 +00:00
|
|
|
);
|
|
|
|
write_to_lcd(message_buffer);
|
|
|
|
} break;
|
|
|
|
|
|
|
|
case 'L': {
|
2018-05-24 09:39:34 +00:00
|
|
|
#if ENABLED(SDSUPPORT)
|
2019-09-15 08:10:59 +00:00
|
|
|
if (!card.isMounted()) card.mount();
|
2018-05-24 09:39:34 +00:00
|
|
|
|
|
|
|
// A more efficient way to do this would be to
|
|
|
|
// implement a callback in the ls_SerialPrint code, but
|
|
|
|
// that requires changes to the core cardreader class that
|
|
|
|
// would not benefit the majority of users. Since one can't
|
|
|
|
// select a file for printing during a print, there's
|
|
|
|
// little reason not to do it this way.
|
|
|
|
char message_buffer[MAX_CURLY_COMMAND];
|
|
|
|
uint16_t file_count = card.get_num_Files();
|
|
|
|
for (uint16_t i = 0; i < file_count; i++) {
|
2019-09-28 20:28:05 +00:00
|
|
|
card.selectFileByIndex(i);
|
2018-11-17 04:39:16 +00:00
|
|
|
sprintf_P(message_buffer, card.flag.filenameIsDir ? PSTR("{DIR:%s}") : PSTR("{FILE:%s}"), card.longest_filename());
|
2018-05-24 09:39:34 +00:00
|
|
|
write_to_lcd(message_buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
write_to_lcd_P(PSTR("{SYS:OK}"));
|
|
|
|
#endif
|
2018-02-04 06:39:01 +00:00
|
|
|
} break;
|
|
|
|
|
2019-08-17 01:02:35 +00:00
|
|
|
default: DEBUG_ECHOLNPAIR("UNKNOWN S COMMAND ", command);
|
2018-02-04 06:39:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Receive a curly brace command and translate to G-code.
|
|
|
|
* Currently {E:0} is not handled. Its function is unknown,
|
|
|
|
* but it occurs during the temp window after a sys build.
|
|
|
|
*/
|
|
|
|
void process_lcd_command(const char* command) {
|
|
|
|
const char *current = command;
|
|
|
|
|
|
|
|
byte command_code = *current++;
|
2019-08-17 01:02:35 +00:00
|
|
|
if (*current == ':') {
|
|
|
|
|
|
|
|
current++; // skip the :
|
|
|
|
|
|
|
|
switch (command_code) {
|
|
|
|
case 'S': process_lcd_s_command(current); break;
|
|
|
|
case 'J': process_lcd_j_command(current); break;
|
|
|
|
case 'P': process_lcd_p_command(current); break;
|
|
|
|
case 'C': process_lcd_c_command(current); break;
|
|
|
|
case 'B':
|
|
|
|
case 'E': process_lcd_eb_command(current); break;
|
|
|
|
default: DEBUG_ECHOLNPAIR("UNKNOWN COMMAND ", command);
|
|
|
|
}
|
2018-02-04 06:39:01 +00:00
|
|
|
}
|
2019-08-17 01:02:35 +00:00
|
|
|
else
|
|
|
|
DEBUG_ECHOLNPAIR("UNKNOWN COMMAND FORMAT ", command);
|
2018-02-04 06:39:01 +00:00
|
|
|
}
|
|
|
|
|
2020-04-23 03:02:31 +00:00
|
|
|
//
|
2019-10-06 03:37:22 +00:00
|
|
|
// Parse LCD commands mixed with G-Code
|
2020-04-23 03:02:31 +00:00
|
|
|
//
|
|
|
|
void parse_lcd_byte(const byte b) {
|
2019-10-06 03:37:22 +00:00
|
|
|
static char inbound_buffer[MAX_CURLY_COMMAND];
|
|
|
|
|
2020-04-23 03:02:31 +00:00
|
|
|
static uint8_t parsing = 0; // Parsing state
|
|
|
|
static bool prevcr = false; // Was the last c a CR?
|
|
|
|
|
|
|
|
const char c = b & 0x7F;
|
|
|
|
|
|
|
|
if (parsing) {
|
|
|
|
const bool is_lcd = parsing == 1; // 1 for LCD
|
|
|
|
if ( ( is_lcd && c == '}') // Closing brace on LCD command
|
|
|
|
|| (!is_lcd && c == '\n') // LF on a G-code command
|
|
|
|
) {
|
|
|
|
inbound_buffer[inbound_count] = '\0'; // Reset before processing
|
|
|
|
inbound_count = 0; // Reset buffer index
|
|
|
|
if (parsing == 1)
|
|
|
|
process_lcd_command(inbound_buffer); // Handle the LCD command
|
|
|
|
else
|
2019-10-06 03:37:22 +00:00
|
|
|
queue.enqueue_one_now(inbound_buffer); // Handle the G-code command
|
2020-05-04 19:03:01 +00:00
|
|
|
parsing = 0; // Unflag and...
|
2019-10-06 03:37:22 +00:00
|
|
|
}
|
2020-04-23 03:02:31 +00:00
|
|
|
else if (inbound_count < MAX_CURLY_COMMAND - 2)
|
|
|
|
inbound_buffer[inbound_count++] = is_lcd ? c : b; // Buffer while space remains
|
2019-10-06 03:37:22 +00:00
|
|
|
}
|
2020-04-23 03:02:31 +00:00
|
|
|
else {
|
|
|
|
if (c == '{') parsing = 1; // Brace opens an LCD command
|
|
|
|
else if (prevcr && c == '\n') parsing = 2; // CRLF indicates G-code
|
|
|
|
prevcr = (c == '\r'); // Remember if it was a CR
|
2019-10-06 03:37:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-04 06:39:01 +00:00
|
|
|
/**
|
|
|
|
* UC means connected.
|
|
|
|
* UD means disconnected
|
2018-07-10 17:55:29 +00:00
|
|
|
* The stock firmware considers USB initialized as "connected."
|
2018-02-04 06:39:01 +00:00
|
|
|
*/
|
|
|
|
void update_usb_status(const bool forceUpdate) {
|
|
|
|
static bool last_usb_connected_status = false;
|
|
|
|
// This is mildly different than stock, which
|
|
|
|
// appears to use the usb discovery status.
|
|
|
|
// This is more logical.
|
2019-12-20 01:53:06 +00:00
|
|
|
if (last_usb_connected_status != MYSERIAL0 || forceUpdate) {
|
|
|
|
last_usb_connected_status = MYSERIAL0;
|
2018-02-04 06:39:01 +00:00
|
|
|
write_to_lcd_P(last_usb_connected_status ? PSTR("{R:UC}\r\n") : PSTR("{R:UD}\r\n"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-04 04:53:15 +00:00
|
|
|
namespace ExtUI {
|
|
|
|
void onStartup() {
|
|
|
|
/**
|
|
|
|
* The Malyan LCD actually runs as a separate MCU on Serial 1.
|
|
|
|
* This code's job is to siphon the weird curly-brace commands from
|
2019-08-17 01:02:35 +00:00
|
|
|
* it and translate into ExtUI operations where possible.
|
2019-05-04 04:53:15 +00:00
|
|
|
*/
|
|
|
|
inbound_count = 0;
|
|
|
|
LCD_SERIAL.begin(500000);
|
|
|
|
|
|
|
|
// Signal init
|
|
|
|
write_to_lcd_P(PSTR("{SYS:STARTED}\r\n"));
|
|
|
|
|
|
|
|
// send a version that says "unsupported"
|
|
|
|
write_to_lcd_P(PSTR("{VER:99}\r\n"));
|
|
|
|
|
|
|
|
// No idea why it does this twice.
|
|
|
|
write_to_lcd_P(PSTR("{SYS:STARTED}\r\n"));
|
|
|
|
update_usb_status(true);
|
2018-02-04 06:39:01 +00:00
|
|
|
}
|
|
|
|
|
2019-05-04 04:53:15 +00:00
|
|
|
void onIdle() {
|
|
|
|
/**
|
|
|
|
* - from printer on startup:
|
|
|
|
* {SYS:STARTED}{VER:29}{SYS:STARTED}{R:UD}
|
|
|
|
*/
|
|
|
|
|
|
|
|
// First report USB status.
|
|
|
|
update_usb_status(false);
|
|
|
|
|
|
|
|
// now drain commands...
|
2020-04-23 03:02:31 +00:00
|
|
|
while (LCD_SERIAL.available())
|
|
|
|
parse_lcd_byte((byte)LCD_SERIAL.read());
|
2018-02-04 06:39:01 +00:00
|
|
|
|
2019-05-04 04:53:15 +00:00
|
|
|
#if ENABLED(SDSUPPORT)
|
|
|
|
// The way last printing status works is simple:
|
|
|
|
// The UI needs to see at least one TQ which is not 100%
|
|
|
|
// and then when the print is complete, one which is.
|
|
|
|
static uint8_t last_percent_done = 100;
|
|
|
|
|
|
|
|
// If there was a print in progress, we need to emit the final
|
|
|
|
// print status as {TQ:100}. Reset last percent done so a new print will
|
|
|
|
// issue a percent of 0.
|
2019-08-17 01:02:35 +00:00
|
|
|
const uint8_t percent_done = (ExtUI::isPrinting() || ExtUI::isPrintingFromMediaPaused()) ? ExtUI::getProgress_percent() : last_printing_status ? 100 : 0;
|
2019-05-04 04:53:15 +00:00
|
|
|
if (percent_done != last_percent_done) {
|
2019-07-02 09:29:07 +00:00
|
|
|
char message_buffer[16];
|
2019-05-04 04:53:15 +00:00
|
|
|
sprintf_P(message_buffer, PSTR("{TQ:%03i}"), percent_done);
|
|
|
|
write_to_lcd(message_buffer);
|
|
|
|
last_percent_done = percent_done;
|
2019-08-17 01:02:35 +00:00
|
|
|
last_printing_status = ExtUI::isPrinting();
|
2019-05-04 04:53:15 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
2018-02-04 06:39:01 +00:00
|
|
|
|
2020-05-04 19:37:43 +00:00
|
|
|
void onPrinterKilled(PGM_P const error, PGM_P const component) {
|
|
|
|
set_lcd_error_P(error, component);
|
2019-05-08 01:32:50 +00:00
|
|
|
}
|
|
|
|
|
2020-05-04 19:37:43 +00:00
|
|
|
#if HAS_PID_HEATING
|
|
|
|
|
|
|
|
void onPidTuning(const result_t rst) {
|
|
|
|
// Called for temperature PID tuning result
|
|
|
|
//SERIAL_ECHOLNPAIR("OnPidTuning:", rst);
|
|
|
|
switch (rst) {
|
|
|
|
case PID_BAD_EXTRUDER_NUM:
|
|
|
|
set_lcd_error_P(GET_TEXT(MSG_PID_BAD_EXTRUDER_NUM));
|
|
|
|
break;
|
|
|
|
case PID_TEMP_TOO_HIGH:
|
|
|
|
set_lcd_error_P(GET_TEXT(MSG_PID_TEMP_TOO_HIGH));
|
|
|
|
break;
|
|
|
|
case PID_TUNING_TIMEOUT:
|
|
|
|
set_lcd_error_P(GET_TEXT(MSG_PID_TIMEOUT));
|
|
|
|
break;
|
|
|
|
case PID_DONE:
|
|
|
|
set_lcd_error_P(GET_TEXT(MSG_PID_AUTOTUNE_DONE));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2019-10-06 03:37:22 +00:00
|
|
|
void onPrintTimerStarted() { write_to_lcd_P(PSTR("{SYS:BUILD}")); }
|
|
|
|
void onPrintTimerPaused() {}
|
|
|
|
void onPrintTimerStopped() { write_to_lcd_P(PSTR("{TQ:100}")); }
|
|
|
|
|
2019-05-08 01:32:50 +00:00
|
|
|
// Not needed for Malyan LCD
|
2019-10-06 03:37:22 +00:00
|
|
|
void onStatusChanged(const char * const) {}
|
2019-05-04 04:53:15 +00:00
|
|
|
void onMediaInserted() {};
|
|
|
|
void onMediaError() {};
|
|
|
|
void onMediaRemoved() {};
|
2019-10-06 03:37:22 +00:00
|
|
|
void onPlayTone(const uint16_t, const uint16_t) {}
|
2019-09-18 04:41:34 +00:00
|
|
|
void onFilamentRunout(const extruder_t extruder) {}
|
2019-10-06 03:37:22 +00:00
|
|
|
void onUserConfirmRequired(const char * const) {}
|
2019-05-04 04:53:15 +00:00
|
|
|
void onFactoryReset() {}
|
2019-10-06 03:37:22 +00:00
|
|
|
void onStoreSettings(char*) {}
|
|
|
|
void onLoadSettings(const char*) {}
|
|
|
|
void onConfigurationStoreWritten(bool) {}
|
|
|
|
void onConfigurationStoreRead(bool) {}
|
2020-05-02 21:13:14 +00:00
|
|
|
|
|
|
|
#if HAS_MESH
|
|
|
|
void onMeshUpdate(const int8_t xpos, const int8_t ypos, const float zval) {}
|
|
|
|
void onMeshUpdate(const int8_t xpos, const int8_t ypos, const ExtUI::probe_state_t state) {}
|
|
|
|
#endif
|
2020-05-01 05:52:37 +00:00
|
|
|
|
|
|
|
#if ENABLED(POWER_LOSS_RECOVERY)
|
|
|
|
void onPowerLossResume() {}
|
|
|
|
#endif
|
2018-02-04 06:39:01 +00:00
|
|
|
}
|
|
|
|
|
2018-03-07 07:42:11 +00:00
|
|
|
#endif // MALYAN_LCD
|