USBPrinterOutputDevice.py 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435
  1. # Copyright (c) 2020 Ultimaker B.V.
  2. # Cura is released under the terms of the LGPLv3 or higher.
  3. import os
  4. from UM.i18n import i18nCatalog
  5. from UM.Logger import Logger
  6. from UM.Mesh.MeshWriter import MeshWriter #To get the g-code output.
  7. from UM.Message import Message #Show an error when already printing.
  8. from UM.PluginRegistry import PluginRegistry #To get the g-code output.
  9. from UM.Qt.Duration import DurationFormat
  10. from cura.CuraApplication import CuraApplication
  11. from cura.PrinterOutput.PrinterOutputDevice import PrinterOutputDevice, ConnectionState, ConnectionType
  12. from cura.PrinterOutput.Models.PrinterOutputModel import PrinterOutputModel
  13. from cura.PrinterOutput.Models.PrintJobOutputModel import PrintJobOutputModel
  14. from cura.PrinterOutput.GenericOutputController import GenericOutputController
  15. from .AutoDetectBaudJob import AutoDetectBaudJob
  16. from .AvrFirmwareUpdater import AvrFirmwareUpdater
  17. from io import StringIO #To write the g-code output.
  18. from queue import Queue
  19. from serial import Serial, SerialException, SerialTimeoutException
  20. from threading import Thread, Event
  21. from time import time
  22. from typing import Union, Optional, List, cast, TYPE_CHECKING
  23. import re
  24. import functools # Used for reduce
  25. if TYPE_CHECKING:
  26. from UM.FileHandler.FileHandler import FileHandler
  27. from UM.Scene.SceneNode import SceneNode
  28. catalog = i18nCatalog("cura")
  29. class USBPrinterOutputDevice(PrinterOutputDevice):
  30. def __init__(self, serial_port: str, baud_rate: Optional[int] = None) -> None:
  31. super().__init__(serial_port, connection_type = ConnectionType.UsbConnection)
  32. self.setName(catalog.i18nc("@item:inmenu", "USB printing"))
  33. self.setShortDescription(catalog.i18nc("@action:button Preceded by 'Ready to'.", "Print via USB"))
  34. self.setDescription(catalog.i18nc("@info:tooltip", "Print via USB"))
  35. self.setIconName("print")
  36. self._serial = None # type: Optional[Serial]
  37. self._serial_port = serial_port
  38. self._address = serial_port
  39. self._timeout = 3
  40. # List of gcode lines to be printed
  41. self._gcode = [] # type: List[str]
  42. self._gcode_position = 0
  43. self._use_auto_detect = True
  44. self._baud_rate = baud_rate
  45. self._all_baud_rates = [115200, 250000, 500000, 230400, 76800, 57600, 38400, 19200, 9600]
  46. # Instead of using a timer, we really need the update to be as a thread, as reading from serial can block.
  47. self._update_thread = Thread(target = self._update, daemon = True, name = "USBPrinterUpdate")
  48. self._last_temperature_request = None # type: Optional[int]
  49. self._firmware_idle_count = 0
  50. self._is_printing = False # A print is being sent.
  51. ## Set when print is started in order to check running time.
  52. self._print_start_time = None # type: Optional[float]
  53. self._print_estimated_time = None # type: Optional[int]
  54. self._accepts_commands = True
  55. self._paused = False
  56. self._printer_busy = False # When printer is preheating and waiting (M190/M109), or when waiting for action on the printer
  57. self.setConnectionText(catalog.i18nc("@info:status", "Connected via USB"))
  58. # Queue for commands that need to be sent.
  59. self._command_queue = Queue() # type: Queue
  60. # Event to indicate that an "ok" was received from the printer after sending a command.
  61. self._command_received = Event()
  62. self._command_received.set()
  63. self._firmware_name_requested = False
  64. self._firmware_updater = AvrFirmwareUpdater(self)
  65. plugin_path = PluginRegistry.getInstance().getPluginPath("USBPrinting")
  66. if plugin_path:
  67. self._monitor_view_qml_path = os.path.join(plugin_path, "MonitorItem.qml")
  68. else:
  69. Logger.log("e", "Cannot create Monitor QML view: cannot find plugin path for plugin [USBPrinting]")
  70. self._monitor_view_qml_path = ""
  71. CuraApplication.getInstance().getOnExitCallbackManager().addCallback(self._checkActivePrintingUponAppExit)
  72. # This is a callback function that checks if there is any printing in progress via USB when the application tries
  73. # to exit. If so, it will show a confirmation before
  74. def _checkActivePrintingUponAppExit(self) -> None:
  75. application = CuraApplication.getInstance()
  76. if not self._is_printing:
  77. # This USB printer is not printing, so we have nothing to do. Call the next callback if exists.
  78. application.triggerNextExitCheck()
  79. return
  80. application.setConfirmExitDialogCallback(self._onConfirmExitDialogResult)
  81. application.showConfirmExitDialog.emit(catalog.i18nc("@label", "A USB print is in progress, closing Cura will stop this print. Are you sure?"))
  82. def _onConfirmExitDialogResult(self, result: bool) -> None:
  83. if result:
  84. application = CuraApplication.getInstance()
  85. application.triggerNextExitCheck()
  86. def resetDeviceSettings(self) -> None:
  87. """Reset USB device settings"""
  88. self._firmware_name = None
  89. def requestWrite(self, nodes: List["SceneNode"], file_name: Optional[str] = None, limit_mimetypes: bool = False,
  90. file_handler: Optional["FileHandler"] = None, filter_by_machine: bool = False, **kwargs) -> None:
  91. """Request the current scene to be sent to a USB-connected printer.
  92. :param nodes: A collection of scene nodes to send. This is ignored.
  93. :param file_name: A suggestion for a file name to write.
  94. :param filter_by_machine: Whether to filter MIME types by machine. This
  95. is ignored.
  96. :param kwargs: Keyword arguments.
  97. """
  98. if self._is_printing:
  99. message = Message(text = catalog.i18nc("@message",
  100. "A print is still in progress. Cura cannot start another print via USB until the previous print has completed."),
  101. title = catalog.i18nc("@message", "Print in Progress"),
  102. message_type = Message.MessageType.ERROR)
  103. message.show()
  104. return # Already printing
  105. self.writeStarted.emit(self)
  106. # cancel any ongoing preheat timer before starting a print
  107. controller = cast(GenericOutputController, self._printers[0].getController())
  108. controller.stopPreheatTimers()
  109. CuraApplication.getInstance().getController().setActiveStage("MonitorStage")
  110. #Find the g-code to print.
  111. gcode_textio = StringIO()
  112. gcode_writer = cast(MeshWriter, PluginRegistry.getInstance().getPluginObject("GCodeWriter"))
  113. success = gcode_writer.write(gcode_textio, None)
  114. if not success:
  115. return
  116. self._printGCode(gcode_textio.getvalue())
  117. def _printGCode(self, gcode: str):
  118. """Start a print based on a g-code.
  119. :param gcode: The g-code to print.
  120. """
  121. self._gcode.clear()
  122. self._paused = False
  123. self._gcode.extend(gcode.split("\n"))
  124. # Reset line number. If this is not done, first line is sometimes ignored
  125. self._gcode.insert(0, "M110")
  126. self._gcode_position = 0
  127. self._print_start_time = time()
  128. self._print_estimated_time = int(CuraApplication.getInstance().getPrintInformation().currentPrintTime.getDisplayString(DurationFormat.Format.Seconds))
  129. for i in range(0, 4): # Push first 4 entries before accepting other inputs
  130. self._sendNextGcodeLine()
  131. self._is_printing = True
  132. self.writeFinished.emit(self)
  133. def _autoDetectFinished(self, job: AutoDetectBaudJob):
  134. result = job.getResult()
  135. if result is not None:
  136. self.setBaudRate(result)
  137. self.connect() # Try to connect (actually create serial, etc)
  138. def setBaudRate(self, baud_rate: int):
  139. if baud_rate not in self._all_baud_rates:
  140. Logger.log("w", "Not updating baudrate to {baud_rate} as it's an unknown baudrate".format(baud_rate=baud_rate))
  141. return
  142. self._baud_rate = baud_rate
  143. def connect(self):
  144. self._firmware_name = None # after each connection ensure that the firmware name is removed
  145. if self._baud_rate is None:
  146. if self._use_auto_detect:
  147. auto_detect_job = AutoDetectBaudJob(self._serial_port)
  148. auto_detect_job.start()
  149. auto_detect_job.finished.connect(self._autoDetectFinished)
  150. return
  151. if self._serial is None:
  152. try:
  153. self._serial = Serial(str(self._serial_port), self._baud_rate, timeout=self._timeout, writeTimeout=self._timeout)
  154. except SerialException:
  155. Logger.warning("An exception occurred while trying to create serial connection.")
  156. return
  157. except OSError as e:
  158. Logger.warning("The serial device is suddenly unavailable while trying to create a serial connection: {err}".format(err = str(e)))
  159. return
  160. CuraApplication.getInstance().globalContainerStackChanged.connect(self._onGlobalContainerStackChanged)
  161. self._onGlobalContainerStackChanged()
  162. self.setConnectionState(ConnectionState.Connected)
  163. self._update_thread.start()
  164. def _onGlobalContainerStackChanged(self):
  165. container_stack = CuraApplication.getInstance().getGlobalContainerStack()
  166. if container_stack is None:
  167. return
  168. num_extruders = container_stack.getProperty("machine_extruder_count", "value")
  169. # Ensure that a printer is created.
  170. controller = GenericOutputController(self)
  171. controller.setCanUpdateFirmware(True)
  172. self._printers = [PrinterOutputModel(output_controller = controller, number_of_extruders = num_extruders)]
  173. self._printers[0].updateName(container_stack.getName())
  174. def close(self):
  175. super().close()
  176. if self._serial is not None:
  177. self._serial.close()
  178. # Re-create the thread so it can be started again later.
  179. self._update_thread = Thread(target=self._update, daemon=True, name = "USBPrinterUpdate")
  180. self._serial = None
  181. def sendCommand(self, command: Union[str, bytes]):
  182. """Send a command to printer."""
  183. if not self._command_received.is_set():
  184. self._command_queue.put(command)
  185. else:
  186. self._sendCommand(command)
  187. def _sendCommand(self, command: Union[str, bytes]):
  188. if self._serial is None or self._connection_state != ConnectionState.Connected:
  189. return
  190. new_command = cast(bytes, command) if type(command) is bytes else cast(str, command).encode() # type: bytes
  191. if not new_command.endswith(b"\n"):
  192. new_command += b"\n"
  193. try:
  194. self._command_received.clear()
  195. self._serial.write(new_command)
  196. except SerialTimeoutException:
  197. Logger.log("w", "Timeout when sending command to printer via USB.")
  198. self._command_received.set()
  199. except SerialException:
  200. Logger.logException("w", "An unexpected exception occurred while writing to the serial.")
  201. self.setConnectionState(ConnectionState.Error)
  202. def _update(self):
  203. while self._connection_state == ConnectionState.Connected and self._serial is not None:
  204. try:
  205. line = self._serial.readline()
  206. except:
  207. continue
  208. if not self._firmware_name_requested:
  209. self._firmware_name_requested = True
  210. self.sendCommand("M115")
  211. if b"FIRMWARE_NAME:" in line:
  212. self._setFirmwareName(line)
  213. if self._last_temperature_request is None or time() > self._last_temperature_request + self._timeout:
  214. # Timeout, or no request has been sent at all.
  215. if not self._printer_busy: # Don't flood the printer with temperature requests while it is busy
  216. self.sendCommand("M105")
  217. self._last_temperature_request = time()
  218. if re.search(b"[B|T\d*]: ?\d+\.?\d*", line): # Temperature message. 'T:' for extruder and 'B:' for bed
  219. extruder_temperature_matches = re.findall(b"T(\d*): ?(\d+\.?\d*)\s*\/?(\d+\.?\d*)?", line)
  220. # Update all temperature values
  221. matched_extruder_nrs = []
  222. for match in extruder_temperature_matches:
  223. extruder_nr = 0
  224. if match[0] != b"":
  225. extruder_nr = int(match[0])
  226. if extruder_nr in matched_extruder_nrs:
  227. continue
  228. matched_extruder_nrs.append(extruder_nr)
  229. if extruder_nr >= len(self._printers[0].extruders):
  230. Logger.log("w", "Printer reports more temperatures than the number of configured extruders")
  231. continue
  232. extruder = self._printers[0].extruders[extruder_nr]
  233. if match[1]:
  234. extruder.updateHotendTemperature(float(match[1]))
  235. if match[2]:
  236. extruder.updateTargetHotendTemperature(float(match[2]))
  237. bed_temperature_matches = re.findall(b"B: ?(\d+\.?\d*)\s*\/?(\d+\.?\d*)?", line)
  238. if bed_temperature_matches:
  239. match = bed_temperature_matches[0]
  240. if match[0]:
  241. self._printers[0].updateBedTemperature(float(match[0]))
  242. if match[1]:
  243. self._printers[0].updateTargetBedTemperature(float(match[1]))
  244. if line == b"":
  245. # An empty line means that the firmware is idle
  246. # Multiple empty lines probably means that the firmware and Cura are waiting
  247. # for each other due to a missed "ok", so we keep track of empty lines
  248. self._firmware_idle_count += 1
  249. else:
  250. self._firmware_idle_count = 0
  251. if line.startswith(b"ok") or self._firmware_idle_count > 1:
  252. self._printer_busy = False
  253. self._command_received.set()
  254. if not self._command_queue.empty():
  255. self._sendCommand(self._command_queue.get())
  256. elif self._is_printing:
  257. if self._paused:
  258. pass # Nothing to do!
  259. else:
  260. self._sendNextGcodeLine()
  261. if line.startswith(b"echo:busy:"):
  262. self._printer_busy = True
  263. if self._is_printing:
  264. if line.startswith(b'!!'):
  265. Logger.log('e', "Printer signals fatal error. Cancelling print. {}".format(line))
  266. self.cancelPrint()
  267. elif line.lower().startswith(b"resend") or line.startswith(b"rs"):
  268. # A resend can be requested either by Resend, resend or rs.
  269. try:
  270. self._gcode_position = int(line.replace(b"N:", b" ").replace(b"N", b" ").replace(b":", b" ").split()[-1])
  271. except:
  272. if line.startswith(b"rs"):
  273. # In some cases of the RS command it needs to be handled differently.
  274. self._gcode_position = int(line.split()[1])
  275. def _setFirmwareName(self, name):
  276. new_name = re.findall(r"FIRMWARE_NAME:(.*);", str(name))
  277. if new_name:
  278. self._firmware_name = new_name[0]
  279. Logger.log("i", "USB output device Firmware name: %s", self._firmware_name)
  280. else:
  281. self._firmware_name = "Unknown"
  282. Logger.log("i", "Unknown USB output device Firmware name: %s", str(name))
  283. def getFirmwareName(self):
  284. return self._firmware_name
  285. def pausePrint(self):
  286. self._paused = True
  287. def resumePrint(self):
  288. self._paused = False
  289. self._sendNextGcodeLine() #Send one line of g-code next so that we'll trigger an "ok" response loop even if we're not polling temperatures.
  290. def cancelPrint(self):
  291. self._gcode_position = 0
  292. self._gcode.clear()
  293. self._printers[0].updateActivePrintJob(None)
  294. self._is_printing = False
  295. self._paused = False
  296. # Turn off temperatures, fan and steppers
  297. self._sendCommand("M140 S0")
  298. self._sendCommand("M104 S0")
  299. self._sendCommand("M107")
  300. # Home XY to prevent nozzle resting on aborted print
  301. # Don't home bed because it may crash the printhead into the print on printers that home on the bottom
  302. self.printers[0].homeHead()
  303. self._sendCommand("M84")
  304. def _sendNextGcodeLine(self):
  305. """
  306. Send the next line of g-code, at the current `_gcode_position`, via a
  307. serial port to the printer.
  308. If the print is done, this sets `_is_printing` to `False` as well.
  309. """
  310. try:
  311. line = self._gcode[self._gcode_position]
  312. except IndexError: # End of print, or print got cancelled.
  313. self._printers[0].updateActivePrintJob(None)
  314. self._is_printing = False
  315. return
  316. if ";" in line:
  317. line = line[:line.find(";")]
  318. line = line.strip()
  319. # Don't send empty lines. But we do have to send something, so send M105 instead.
  320. # Don't send the M0 or M1 to the machine, as M0 and M1 are handled as an LCD menu pause.
  321. if line == "" or line == "M0" or line == "M1":
  322. line = "M105"
  323. checksum = functools.reduce(lambda x, y: x ^ y, map(ord, "N%d%s" % (self._gcode_position, line)))
  324. self._sendCommand("N%d%s*%d" % (self._gcode_position, line, checksum))
  325. print_job = self._printers[0].activePrintJob
  326. try:
  327. progress = self._gcode_position / len(self._gcode)
  328. except ZeroDivisionError:
  329. # There is nothing to send!
  330. if print_job is not None:
  331. print_job.updateState("error")
  332. return
  333. elapsed_time = int(time() - self._print_start_time)
  334. if print_job is None:
  335. controller = GenericOutputController(self)
  336. controller.setCanUpdateFirmware(True)
  337. print_job = PrintJobOutputModel(output_controller = controller, name = CuraApplication.getInstance().getPrintInformation().jobName)
  338. print_job.updateState("printing")
  339. self._printers[0].updateActivePrintJob(print_job)
  340. print_job.updateTimeElapsed(elapsed_time)
  341. estimated_time = self._print_estimated_time
  342. if progress > .1:
  343. estimated_time = self._print_estimated_time * (1 - progress) + elapsed_time
  344. print_job.updateTimeTotal(estimated_time)
  345. self._gcode_position += 1