Merge pull request #11238 from xC0000005/MalyanLCDUpdate

[2.0.x] Malyan LCD Feedrate + Better Temp Handling

Marlin/src/lcd/malyanlcd.cpp

 // Track incoming command bytes from the LCD
 int inbound_count;
 
+// For sending print completion messages
+bool last_printing_status = false;
+
 // Everything written needs the high bit set.
 void write_to_lcd_P(const char * const message) {
   char encoded_message[MAX_CURLY_COMMAND];
  * {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) {
   switch (command[0]) {
+    case 'C': {
+      int raw_feedrate = atoi(command + 1);
+      feedrate_percentage = raw_feedrate * 10;
+      feedrate_percentage = constrain(feedrate_percentage, 10, 999);
+    } break;
     case 'T': {
-      // M104 S<temperature>
-      char cmd[20];
-      sprintf_P(cmd, PSTR("M104 S%s"), command + 1);
-      enqueue_and_echo_command_now(cmd);
+      thermalManager.setTargetHotend(atoi(command + 1), 0);
     } break;
-
     case 'P': {
-      // M140 S<temperature>
-      char cmd[20];
-      sprintf_P(cmd, PSTR("M140 S%s"), command + 1);
-      enqueue_and_echo_command_now(cmd);
+      thermalManager.setTargetBed(atoi(command + 1));
     } break;
 
     default:
       #if ENABLED(SDSUPPORT)
         // cancel print
         write_to_lcd_P(PSTR("{SYS:CANCELING}"));
+        last_printing_status = false;
         card.stopSDPrint(
           #if SD_RESORT
             true
         }
         else {
           char message_buffer[MAX_CURLY_COMMAND];
-          sprintf_P(message_buffer, PSTR("{PRINTFILE:%s}"), card.filename);
+          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);
 
     case 'H':
       // Home all axis
-      enqueue_and_echo_command("G28");
+      enqueue_and_echo_command("G28", false);
       break;
 
     case 'L': {
         uint16_t file_count = card.get_num_Files();
         for (uint16_t i = 0; i < file_count; i++) {
           card.getfilename(i);
-          sprintf_P(message_buffer, card.filenameIsDir ? PSTR("{DIR:%s}") : PSTR("{FILE:%s}"), card.filename);
+          sprintf_P(message_buffer, card.filenameIsDir ? PSTR("{DIR:%s}") : PSTR("{FILE:%s}"), card.longest_filename());
           write_to_lcd(message_buffer);
         }
 
 /**
  * UC means connected.
  * UD means disconnected
- * The stock firmware considers USB initialied as "connected."
+ * The stock firmware considers USB initialized as "connected."
  */
 void update_usb_status(const bool forceUpdate) {
   static bool last_usb_connected_status = false;
   }
 
   #if ENABLED(SDSUPPORT)
-    // If there's a print in progress, we need to emit the status as
-    // {TQ:<PERCENT>}
-    if (card.sdprinting) {
-      // We also need to send: T:-2538.0 E:0
-      // I have no idea what this means.
+    // 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 = card.sdprinting ? card.percentDone() : last_printing_status ? 100 : 0;
+    if (percent_done != last_percent_done) {
       char message_buffer[10];
-      sprintf_P(message_buffer, PSTR("{TQ:%03i}"), card.percentDone());
+      sprintf_P(message_buffer, PSTR("{TQ:%03i}"), percent_done);
       write_to_lcd(message_buffer);
+      last_percent_done = percent_done;
+      last_printing_status = card.sdprinting;
     }
   #endif
 }

Marlin/src/lcd/ultralcd.cpp

 
   #if ENABLED(SDSUPPORT)
     void lcd_sdcard_menu();
-    void menu_action_sdfile(const char* filename, char* longFilename);
-    void menu_action_sddirectory(const char* filename, char* longFilename);
+    void menu_action_sdfile(CardReader &theCard);
+    void menu_action_sddirectory(CardReader &theCard);
   #endif
 
   ////////////////////////////////////////////
     msg = paused;
   #if ENABLED(SDSUPPORT)
     else if (card.sdprinting)
-      return lcd_setstatus(card.longFilename[0] ? card.longFilename : card.filename, true);
+      return lcd_setstatus(card.longest_filename(), true);
   #endif
   else if (print_job_timer.isRunning())
     msg = printing;
       bar_percent = constrain(bar_percent, 0, 100);
       encoderPosition = 0;
       lcd_implementation_drawmenu_static(0, PSTR(MSG_PROGRESS_BAR_TEST), true, true);
-      lcd.setCursor((LCD_WIDTH) / 2 - 2, LCD_HEIGHT - 2);
-      lcd.print(itostr3(bar_percent)); lcd.write('%');
-      lcd.setCursor(0, LCD_HEIGHT - 1); lcd_draw_progress_bar(bar_percent);
+      lcd_moveto((LCD_WIDTH) / 2 - 2, LCD_HEIGHT - 2);
+      lcd_put_u8str(int(bar_percent)); lcd_put_wchar('%');
+      lcd_moveto(0, LCD_HEIGHT - 1); lcd_draw_progress_bar(bar_percent);
     }
 
     void _progress_bar_test() {
         destination[manual_move_axis] += manual_move_offset;
 
         // Reset for the next move
-        manual_move_offset = 0.0;
+        manual_move_offset = 0;
         manual_move_axis = (int8_t)NO_AXIS;
 
         // DELTA and SCARA machines use segmented moves, which could fill the planner during the call to
           #endif
 
           if (card.filenameIsDir)
-            MENU_ITEM(sddirectory, MSG_CARD_MENU, card.filename, card.longFilename);
+            MENU_ITEM(sddirectory, MSG_CARD_MENU, card);
           else
-            MENU_ITEM(sdfile, MSG_CARD_MENU, card.filename, card.longFilename);
+            MENU_ITEM(sdfile, MSG_CARD_MENU, card);
         }
         else {
           MENU_ITEM_DUMMY();
 
   #if ENABLED(SDSUPPORT)
 
-    void menu_action_sdfile(const char* filename, char* longFilename) {
+    void menu_action_sdfile(CardReader &theCard) {
       #if ENABLED(SD_REPRINT_LAST_SELECTED_FILE)
         last_sdfile_encoderPosition = encoderPosition;  // Save which file was selected for later use
       #endif
-      UNUSED(longFilename);
-      card.openAndPrintFile(filename);
+      card.openAndPrintFile(theCard.filename);
       lcd_return_to_status();
       lcd_reset_status();
     }
 
-    void menu_action_sddirectory(const char* filename, char* longFilename) {
-      UNUSED(longFilename);
-      card.chdir(filename);
+    void menu_action_sddirectory(CardReader &theCard) {
+      card.chdir(theCard.filename);
       encoderTopLine = 0;
       encoderPosition = 2 * ENCODER_STEPS_PER_MENU_ITEM;
       screen_changed = true;

Marlin/src/lcd/ultralcd_impl_DOGM.h

 
   #if ENABLED(SDSUPPORT)
 
-    static void _drawmenu_sd(const bool isSelected, const uint8_t row, const char* const pstr, const char* filename, char* const longFilename, const bool isDir) {
+    static void _drawmenu_sd(const bool isSelected, const uint8_t row, const char* const pstr, CardReader &theCard, const bool isDir) {
       UNUSED(pstr);
 
       lcd_implementation_mark_as_selected(row, isSelected);
       if (!PAGE_CONTAINS(row_y1, row_y2)) return;
 
       constexpr uint8_t maxlen = LCD_WIDTH - (START_COL) - 1;
-      const char *outstr = longFilename[0] ? longFilename : filename;
-      if (longFilename[0]) {
+      const char *outstr = theCard.longest_filename();
+      if (theCard.longFilename[0]) {
         #if ENABLED(SCROLL_LONG_FILENAMES)
           if (isSelected) {
             uint8_t name_hash = row;
             for (uint8_t l = FILENAME_LENGTH; l--;)
-              name_hash = ((name_hash << 1) | (name_hash >> 7)) ^ filename[l];  // rotate, xor
+              name_hash = ((name_hash << 1) | (name_hash >> 7)) ^ theCard.filename[l];  // rotate, xor
             if (filename_scroll_hash != name_hash) {                            // If the hash changed...
               filename_scroll_hash = name_hash;                                 // Save the new hash
-              filename_scroll_max = MAX(0, utf8_strlen(longFilename) - maxlen); // Update the scroll limit
+              filename_scroll_max = MAX(0, utf8_strlen(theCard.longFilename) - maxlen); // Update the scroll limit
               filename_scroll_pos = 0;                                          // Reset scroll to the start
               lcd_status_update_delay = 8;                                      // Don't scroll right away
             }
             outstr += filename_scroll_pos;
           }
         #else
-          longFilename[maxlen] = '\0'; // cutoff at screen edge
+          theCard.longFilename[maxlen] = '\0'; // cutoff at screen edge
         #endif
       }
 
       while (n - DOG_CHAR_WIDTH > 0) { n -= lcd_put_wchar(' '); }
     }
 
-    #define lcd_implementation_drawmenu_sdfile(sel, row, pstr, filename, longFilename) _drawmenu_sd(sel, row, pstr, filename, longFilename, false)
-    #define lcd_implementation_drawmenu_sddirectory(sel, row, pstr, filename, longFilename) _drawmenu_sd(sel, row, pstr, filename, longFilename, true)
+    #define lcd_implementation_drawmenu_sdfile(sel, row, pstr, theCard) _drawmenu_sd(sel, row, pstr, theCard, false)
+    #define lcd_implementation_drawmenu_sddirectory(sel, row, pstr, theCard) _drawmenu_sd(sel, row, pstr, theCard, true)
 
   #endif // SDSUPPORT
 

Marlin/src/lcd/ultralcd_impl_HD44780.h

 
   #if ENABLED(SDSUPPORT)
 
-    static void lcd_implementation_drawmenu_sd(const bool sel, const uint8_t row, const char* const pstr, const char* filename, char* const longFilename, const uint8_t concat, const char post_char) {
+    static void lcd_implementation_drawmenu_sd(const bool sel, const uint8_t row, const char* const pstr, CardReader &theCard, const uint8_t concat, const char post_char) {
       UNUSED(pstr);
       lcd_moveto(0, row);
       lcd_put_wchar(sel ? '>' : ' ');
 
       uint8_t n = LCD_WIDTH - concat;
-      const char *outstr = longFilename[0] ? longFilename : filename;
-      if (longFilename[0]) {
+      const char *outstr = theCard.longest_filename();
+      if (theCard.longFilename[0]) {
         #if ENABLED(SCROLL_LONG_FILENAMES)
           if (sel) {
             uint8_t name_hash = row;
             for (uint8_t l = FILENAME_LENGTH; l--;)
-              name_hash = ((name_hash << 1) | (name_hash >> 7)) ^ filename[l];  // rotate, xor
+              name_hash = ((name_hash << 1) | (name_hash >> 7)) ^ theCard.filename[l];  // rotate, xor
             if (filename_scroll_hash != name_hash) {                            // If the hash changed...
               filename_scroll_hash = name_hash;                                 // Save the new hash
-              filename_scroll_max = MAX(0, utf8_strlen(longFilename) - n);  // Update the scroll limit
+              filename_scroll_max = MAX(0, utf8_strlen(theCard.longFilename) - n);  // Update the scroll limit
               filename_scroll_pos = 0;                                          // Reset scroll to the start
               lcd_status_update_delay = 8;                                      // Don't scroll right away
             }
             outstr += filename_scroll_pos;
           }
         #else
-          longFilename[n] = '\0'; // cutoff at screen edge
+          theCard.longFilename[n] = '\0'; // cutoff at screen edge
         #endif
       }
 
       lcd_put_wchar(post_char);
     }
 
-    static void lcd_implementation_drawmenu_sdfile(const bool sel, const uint8_t row, const char* pstr, const char* filename, char* const longFilename) {
-      lcd_implementation_drawmenu_sd(sel, row, pstr, filename, longFilename, 2, ' ');
+    static void lcd_implementation_drawmenu_sdfile(const bool sel, const uint8_t row, const char* pstr, CardReader &theCard) {
+      lcd_implementation_drawmenu_sd(sel, row, pstr, theCard, 2, ' ');
     }
 
-    static void lcd_implementation_drawmenu_sddirectory(const bool sel, const uint8_t row, const char* pstr, const char* filename, char* const longFilename) {
-      lcd_implementation_drawmenu_sd(sel, row, pstr, filename, longFilename, 2, LCD_STR_FOLDER[0]);
+    static void lcd_implementation_drawmenu_sddirectory(const bool sel, const uint8_t row, const char* pstr, CardReader &theCard) {
+      lcd_implementation_drawmenu_sd(sel, row, pstr, theCard, 2, LCD_STR_FOLDER[0]);
     }
 
   #endif // SDSUPPORT

Marlin/src/sd/cardreader.cpp

 
 #include <ctype.h>
 
-#define LONGEST_FILENAME (longFilename[0] ? longFilename : filename)
-
 CardReader::CardReader() {
   #if ENABLED(SDCARD_SORT_ALPHA)
     sort_count = 0;
             getfilename(i);
             #if ENABLED(SDSORT_DYNAMIC_RAM)
               // Use dynamic method to copy long filename
-              sortnames[i] = strdup(LONGEST_FILENAME);
+              sortnames[i] = strdup(longest_filename());
               #if ENABLED(SDSORT_CACHE_NAMES)
                 // When caching also store the short name, since
                 // we're replacing the getfilename() behavior.
             #else
               // Copy filenames into the static array
               #if SORTED_LONGNAME_MAXLEN != LONG_FILENAME_LENGTH
-                strncpy(sortnames[i], LONGEST_FILENAME, SORTED_LONGNAME_MAXLEN);
+                strncpy(sortnames[i], longest_filename(), SORTED_LONGNAME_MAXLEN);
                 sortnames[i][SORTED_LONGNAME_MAXLEN - 1] = '\0';
               #else
-                strncpy(sortnames[i], LONGEST_FILENAME, SORTED_LONGNAME_MAXLEN);
+                strncpy(sortnames[i], longest_filename(), SORTED_LONGNAME_MAXLEN);
               #endif
               #if ENABLED(SDSORT_CACHE_NAMES)
                 strcpy(sortshort[i], filename);
             // throughout the loop. Slow if there are many.
             #if DISABLED(SDSORT_USES_RAM)
               getfilename(o1);
-              strcpy(name1, LONGEST_FILENAME); // save (or getfilename below will trounce it)
+              strcpy(name1, longest_filename()); // save (or getfilename below will trounce it)
               #if HAS_FOLDER_SORTING
                 bool dir1 = filenameIsDir;
               #endif
               getfilename(o2);
-              char *name2 = LONGEST_FILENAME; // use the string in-place
+              char *name2 = longest_filename(); // use the string in-place
             #endif // !SDSORT_USES_RAM
 
             // Sort the current pair according to settings.
           getfilename(0);
           #if ENABLED(SDSORT_DYNAMIC_RAM)
             sortnames = new char*[1];
-            sortnames[0] = strdup(LONGEST_FILENAME); // malloc
+            sortnames[0] = strdup(longest_filename()); // malloc
             #if ENABLED(SDSORT_CACHE_NAMES)
               sortshort = new char*[1];
               sortshort[0] = strdup(filename);       // malloc
             isDir = new uint8_t[1];
           #else
             #if SORTED_LONGNAME_MAXLEN != LONG_FILENAME_LENGTH
-              strncpy(sortnames[0], LONGEST_FILENAME, SORTED_LONGNAME_MAXLEN);
+              strncpy(sortnames[0], longest_filename(), SORTED_LONGNAME_MAXLEN);
               sortnames[0][SORTED_LONGNAME_MAXLEN - 1] = '\0';
             #else
-              strncpy(sortnames[0], LONGEST_FILENAME, SORTED_LONGNAME_MAXLEN);
+              strncpy(sortnames[0], longest_filename(), SORTED_LONGNAME_MAXLEN);
             #endif
             #if ENABLED(SDSORT_CACHE_NAMES)
               strcpy(sortshort[0], filename);

Marlin/src/sd/cardreader.h

     }
   #endif
 
+  FORCE_INLINE char* longest_filename() { return longFilename[0] ? longFilename : filename; }
+
 public:
   bool saving, logging, sdprinting, cardOK, filenameIsDir;
   char filename[FILENAME_LENGTH], longFilename[LONG_FILENAME_LENGTH];