# Cura PostProcessingPlugin # Author: Mathias Lyngklip Kjeldgaard, Alexander Gee, Kimmo Toivanen # Date: July 31, 2019 # Modified: Okt 22, 2020 # Description: This plugin displays progress on the LCD. It can output the estimated time remaining and the completion percentage. from ..Script import Script import re import datetime class DisplayProgressOnLCD(Script): def __init__(self): super().__init__() def getSettingDataString(self): return """{ "name": "Display Progress On LCD", "key": "DisplayProgressOnLCD", "metadata": {}, "version": 2, "settings": { "time_remaining": { "label": "Time Remaining", "description": "Select to write remaining time to the display.Select to write remaining time on the display using M117 status line message (almost all printers) or using M73 command (Prusa and Marlin 2 if enabled).", "type": "bool", "default_value": false }, "time_remaining_method": { "label": "Time Reporting Method", "description": "How should remaining time be shown on the display? It could use a generic message command (M117, almost all printers), or a specialised time remaining command (M73, Prusa and Marlin 2).", "type": "enum", "options": { "m117":"M117 - All printers", "m73":"M73 - Prusa, Marlin 2" }, "enabled": "time_remaining", "default_value": "m117" }, "update_frequency": { "label": "Update frequency", "description": "Update remaining time for every layer or periodically every minute or faster.", "type": "enum", "options": {"0":"Every layer","15":"Every 15 seconds","30":"Every 30 seconds","60":"Every minute"}, "default_value": "0", "enabled": "time_remaining" }, "percentage": { "label": "Percentage", "description": "When enabled, set the completion bar percentage on the LCD using Marlin's M73 command.", "type": "bool", "default_value": false } } }""" # Get the time value from a line as a float. # Example line ;TIME_ELAPSED:1234.6789 or ;TIME:1337 def getTimeValue(self, line): list_split = re.split(":", line) # Split at ":" so we can get the numerical value return float(list_split[1]) # Convert the numerical portion to a float def outputTime(self, lines, line_index, time_left, mode): # Do some math to get the time left in seconds into the right format. (HH,MM,SS) time_left = max(time_left, 0) m, s = divmod(time_left, 60) h, m = divmod(m, 60) # Create the string if mode == "m117": current_time_string = "{:d}h{:02d}m{:02d}s".format(int(h), int(m), int(s)) # And now insert that into the GCODE lines.insert(line_index, "M117 Time Left {}".format(current_time_string)) else: # Must be m73. mins = int(60 * h + m + s / 30) lines.insert(line_index, "M73 R{}".format(mins)) def execute(self, data): output_time = self.getSettingValueByKey("time_remaining") output_time_method = self.getSettingValueByKey("time_remaining_method") output_frequency = int(self.getSettingValueByKey("update_frequency")) output_percentage = self.getSettingValueByKey("percentage") line_set = {} if output_percentage or output_time: total_time = -1 previous_layer_end_percentage = 0 previous_layer_end_time = 0 for layer in data: layer_index = data.index(layer) lines = layer.split("\n") for line in lines: if (line.startswith(";TIME:") or line.startswith(";PRINT.TIME:")) and total_time == -1: # This line represents the total time required to print the gcode total_time = self.getTimeValue(line) line_index = lines.index(line) # In the beginning we may have 2 M73 lines, but it makes logic less complicated if output_time: self.outputTime(lines, line_index, total_time, output_time_method) if output_percentage: # Emit 0 percent to sure Marlin knows we are overriding the completion percentage lines.insert(line_index, "M73 P0") elif line.startswith(";TIME_ELAPSED:"): # We've found one of the time elapsed values which are added at the end of layers # If we have seen this line before then skip processing it. We can see lines multiple times because we are adding # intermediate percentages before the line being processed. This can cause the current line to shift back and be # encountered more than once if line in line_set: continue line_set[line] = True # If total_time was not already found then noop if total_time == -1: continue current_time = self.getTimeValue(line) line_index = lines.index(line) if output_time: if output_frequency == 0: # Here we calculate remaining time self.outputTime(lines, line_index, total_time - current_time, output_time_method) else: # Here we calculate remaining time and how many outputs are expected for the layer layer_time_delta = int(current_time - previous_layer_end_time) layer_step_delta = int((current_time - previous_layer_end_time) / output_frequency) # If this layer represents less than 1 step then we don't need to emit anything, continue to the next layer if layer_step_delta != 0: # Grab the index of the current line and figure out how many lines represent one second step = line_index / layer_time_delta # Move new lines further as we add new lines above it lines_added = 1 # Run through layer in seconds for seconds in range(1, layer_time_delta + 1): # Time from start to decide when to update line_time = int(previous_layer_end_time + seconds) # Output every X seconds and after last layer if line_time % output_frequency == 0 or line_time == total_time: # Line to add the output time_line_index = int((seconds * step) + lines_added) # Insert remaining time into the GCODE self.outputTime(lines, time_line_index, total_time - line_time, output_time_method) # Next line will be again lower lines_added = lines_added + 1 previous_layer_end_time = int(current_time) if output_percentage: # Calculate percentage value this layer ends at layer_end_percentage = int((current_time / total_time) * 100) # Figure out how many percent of the total time is spent in this layer layer_percentage_delta = layer_end_percentage - previous_layer_end_percentage # If this layer represents less than 1 percent then we don't need to emit anything, continue to the next layer if layer_percentage_delta != 0: # Grab the index of the current line and figure out how many lines represent one percent step = line_index / layer_percentage_delta for percentage in range(1, layer_percentage_delta + 1): # We add the percentage value here as while processing prior lines we will have inserted # percentage lines before the current one. Failing to do this will upset the spacing percentage_line_index = int((percentage * step) + percentage) # Due to integer truncation of the total time value in the gcode the percentage we # calculate may slightly exceed 100, as that is not valid we cap the value here output = min(percentage + previous_layer_end_percentage, 100) # Now insert the sanitized percentage into the GCODE lines.insert(percentage_line_index, "M73 P{}".format(output)) previous_layer_end_percentage = layer_end_percentage # Join up the lines for this layer again and store them in the data array data[layer_index] = "\n".join(lines) return data