diff options
Diffstat (limited to 'Marlin/src/lcd/extui/malyan_lcd.cpp')
| -rw-r--r-- | Marlin/src/lcd/extui/malyan_lcd.cpp | 543 |
1 files changed, 543 insertions, 0 deletions
diff --git a/Marlin/src/lcd/extui/malyan_lcd.cpp b/Marlin/src/lcd/extui/malyan_lcd.cpp new file mode 100644 index 0000000..6c55eea --- /dev/null +++ b/Marlin/src/lcd/extui/malyan_lcd.cpp @@ -0,0 +1,543 @@ +/** + * 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 <https://www.gnu.org/licenses/>. + * + */ + +/** + * malyan_lcd.cpp + * + * 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) + */ + +#include "../../inc/MarlinConfigPre.h" + +#if ENABLED(MALYAN_LCD) + +//#define DEBUG_MALYAN_LCD + +#include "ui_api.h" + +#include "../marlinui.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" + +#define DEBUG_OUT ENABLED(DEBUG_MALYAN_LCD) +#include "../../core/debug_out.h" + +// This is based on longest sys command + a filename, plus some buffer +// in case we encounter some data we don't recognize +// There is no evidence a line will ever be this long, but better safe than sorry +#define MAX_CURLY_COMMAND (32 + LONG_FILENAME_LENGTH) * 2 + +// Track incoming command bytes from the LCD +uint16_t inbound_count; + +// For sending print completion messages +bool last_printing_status = false; + +// Everything written needs the high bit set. +void write_to_lcd_P(PGM_P const message) { + char encoded_message[MAX_CURLY_COMMAND]; + uint8_t message_length = _MIN(strlen_P(message), sizeof(encoded_message)); + + LOOP_L_N(i, message_length) + encoded_message[i] = pgm_read_byte(&message[i]) | 0x80; + + LCD_SERIAL.Print::write(encoded_message, message_length); +} + +void write_to_lcd(const char * const message) { + char encoded_message[MAX_CURLY_COMMAND]; + const uint8_t message_length = _MIN(strlen(message), sizeof(encoded_message)); + + LOOP_L_N(i, message_length) + encoded_message[i] = message[i] | 0x80; + + LCD_SERIAL.Print::write(encoded_message, message_length); +} + +// {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("}")); +} + + +/** + * 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 + * + * {C:S09} set feedrate to 90 %. + * {C:S12} set feedrate to 120 %. + * + * the command portion begins after the : + */ +void process_lcd_c_command(const char* command) { + const int target_val = command[1] ? atoi(command + 1) : -1; + if (target_val < 0) { + DEBUG_ECHOLNPAIR("UNKNOWN C COMMAND ", command); + return; + } + switch (command[0]) { + case 'C': // Cope with both V1 early rev and later LCDs. + case 'S': + feedrate_percentage = target_val * 10; + LIMIT(feedrate_percentage, 10, 999); + break; + + 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; + + #if HAS_HEATED_BED + case 'P': ExtUI::setTargetTemp_celsius(target_val, ExtUI::heater_t::BED); break; + #endif + + default: DEBUG_ECHOLNPAIR("UNKNOWN C COMMAND ", command); + } +} + +/** + * 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]; + static uint8_t iteration = 0; + duration_t elapsed; + switch (command[0]) { + case '0': { + elapsed = print_job_timer.duration(); + sprintf_P(elapsed_buffer, PSTR("%02u%02u%02u"), uint16_t(elapsed.hour()), uint16_t(elapsed.minute()) % 60, uint16_t(elapsed.second()) % 60); + + char message_buffer[MAX_CURLY_COMMAND]; + 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 + + sprintf_P(message_buffer, + PSTR("{T0:%03i/%03i}{T1:000/000}{TP:%03i/%03i}{TQ:%03i}{TT:%s}"), + int(thermalManager.degHotend(0)), thermalManager.degTargetHotend(0), + #if HAS_HEATED_BED + int(thermalManager.degBed()), thermalManager.degTargetBed(), + #else + 0, 0, + #endif + #if ENABLED(SDSUPPORT) + done_pct, + #else + 0, + #endif + elapsed_buffer + ); + write_to_lcd(message_buffer); + } break; + + default: DEBUG_ECHOLNPAIR("UNKNOWN E/B COMMAND ", command); + } +} + +/** + * Process an LCD 'J' command. + * These are currently all movement commands. + * The command portion begins after the : + * Move X Axis + * + * {J:E}{J:X-200}{J:E} + * {J:E}{J:X+200}{J:E} + * X, Y, Z, A (extruder) + */ +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); +}; + +void process_lcd_j_command(const char* command) { + switch (command[0]) { + case 'E': break; + 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; + default: DEBUG_ECHOLNPAIR("UNKNOWN J COMMAND ", command); + } +} + +/** + * Process an LCD 'P' command, related to homing and printing. + * Cancel: + * {P:X} + * + * Home all axes: + * {P:H} + * + * 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]) { + case 'P': + ExtUI::pausePrint(); + write_to_lcd_P(PSTR("{SYS:PAUSED}")); + break; + case 'R': + ExtUI::resumePrint(); + write_to_lcd_P(PSTR("{SYS:RESUMED}")); + break; + case 'X': + write_to_lcd_P(PSTR("{SYS:CANCELING}")); + ExtUI::stopPrint(); + write_to_lcd_P(PSTR("{SYS:STARTED}")); + break; + case 'H': queue.enqueue_now_P(G28_STR); break; // Home all axes + default: { + #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. + card.selectFileByIndex(atoi(command)); + + // 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. + if (card.flag.filenameIsDir) { + card.cd(card.filename); + write_to_lcd_P(PSTR("{SYS:DIR}")); + } + else { + char message_buffer[MAX_CURLY_COMMAND]; + sprintf_P(message_buffer, PSTR("{PRINTFILE:%s}"), card.longest_filename()); + write_to_lcd(message_buffer); + write_to_lcd_P(PSTR("{SYS:BUILD}")); + card.openAndPrintFile(card.filename); + } + #endif + } break; // default + } // switch +} + +/** + * Handle an lcd 'S' command + * {S:I} - Temperature request + * {T0:999/000}{T1:000/000}{TP:004/000} + * + * {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]; + sprintf_P(message_buffer, PSTR("{T0:%03i/%03i}{T1:000/000}{TP:%03i/%03i}"), + int(thermalManager.degHotend(0)), thermalManager.degTargetHotend(0), + #if HAS_HEATED_BED + int(thermalManager.degBed()), thermalManager.degTargetBed() + #else + 0, 0 + #endif + ); + write_to_lcd(message_buffer); + } break; + + case 'L': { + #if ENABLED(SDSUPPORT) + if (!card.isMounted()) card.mount(); + + // 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++) { + card.selectFileByIndex(i); + sprintf_P(message_buffer, card.flag.filenameIsDir ? PSTR("{DIR:%s}") : PSTR("{FILE:%s}"), card.longest_filename()); + write_to_lcd(message_buffer); + } + + write_to_lcd_P(PSTR("{SYS:OK}")); + #endif + } break; + + default: DEBUG_ECHOLNPAIR("UNKNOWN S COMMAND ", command); + } +} + +/** + * 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++; + 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); + } + } + else + DEBUG_ECHOLNPAIR("UNKNOWN COMMAND FORMAT ", command); +} + +// +// Parse LCD commands mixed with G-Code +// +void parse_lcd_byte(const byte b) { + static char inbound_buffer[MAX_CURLY_COMMAND]; + + 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 + queue.enqueue_one_now(inbound_buffer); // Handle the G-code command + parsing = 0; // Unflag and... + } + else if (inbound_count < MAX_CURLY_COMMAND - 2) + inbound_buffer[inbound_count++] = is_lcd ? c : b; // Buffer while space remains + } + 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 + } +} + +/** + * UC means connected. + * UD means disconnected + * The stock firmware considers USB initialized as "connected." + */ +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. + if (last_usb_connected_status != MYSERIAL0.connected() || forceUpdate) { + last_usb_connected_status = MYSERIAL0.connected(); + write_to_lcd_P(last_usb_connected_status ? PSTR("{R:UC}\r\n") : PSTR("{R:UD}\r\n")); + } +} + +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 + * it and translate into ExtUI operations where possible. + */ + inbound_count = 0; + + #ifndef LCD_BAUDRATE + #define LCD_BAUDRATE 500000 + #endif + LCD_SERIAL.begin(LCD_BAUDRATE); + + // 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); + } + + 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... + while (LCD_SERIAL.available()) + parse_lcd_byte((byte)LCD_SERIAL.read()); + + #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. + const uint8_t percent_done = (ExtUI::isPrinting() || ExtUI::isPrintingFromMediaPaused()) ? ExtUI::getProgress_percent() : last_printing_status ? 100 : 0; + if (percent_done != last_percent_done) { + char message_buffer[16]; + sprintf_P(message_buffer, PSTR("{TQ:%03i}"), percent_done); + write_to_lcd(message_buffer); + last_percent_done = percent_done; + last_printing_status = ExtUI::isPrinting(); + } + #endif + } + + void onPrinterKilled(PGM_P const error, PGM_P const component) { + set_lcd_error_P(error, component); + } + + #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 + + void onPrintTimerStarted() { write_to_lcd_P(PSTR("{SYS:BUILD}")); } + void onPrintTimerPaused() {} + void onPrintTimerStopped() { write_to_lcd_P(PSTR("{TQ:100}")); } + + // Not needed for Malyan LCD + void onStatusChanged(const char * const) {} + void onMediaInserted() {} + void onMediaError() {} + void onMediaRemoved() {} + void onPlayTone(const uint16_t, const uint16_t) {} + void onFilamentRunout(const extruder_t extruder) {} + void onUserConfirmRequired(const char * const) {} + void onHomingStart() {} + void onHomingComplete() {} + void onPrintFinished() {} + void onFactoryReset() {} + void onStoreSettings(char*) {} + void onLoadSettings(const char*) {} + void onConfigurationStoreWritten(bool) {} + void onConfigurationStoreRead(bool) {} + + #if HAS_MESH + void onMeshLevelingStart() {} + 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 + + #if ENABLED(POWER_LOSS_RECOVERY) + void onPowerLossResume() {} + #endif + + void onSteppersDisabled() {} + void onSteppersEnabled() {} +} + +#endif // MALYAN_LCD |