From 0283ed22a4cd4847ddb3d5c70b6653143d9551ea Mon Sep 17 00:00:00 2001 From: jneilliii Date: Sun, 7 Jan 2024 14:54:00 -0500 Subject: [PATCH] 0.0.1 --- .editorconfig | 18 + .gitignore | 10 + MANIFEST.in | 4 + README.md | 17 + babel.cfg | 8 + octoprint_bambu_printer/__init__.py | 135 +++ .../ftpsclient/__init__.py | 2 + octoprint_bambu_printer/ftpsclient/_client.py | 159 +++ .../ftpsclient/_version.py | 3 + .../static/js/bambu_printer.js | 29 + .../templates/bambu_printer_settings.jinja2 | 40 + octoprint_bambu_printer/virtual.py | 970 ++++++++++++++++++ requirements.txt | 9 + screenshot.png | Bin 0 -> 130584 bytes setup.cfg | 2 + setup.py | 102 ++ translations/README.txt | 28 + 17 files changed, 1536 insertions(+) create mode 100644 .editorconfig create mode 100644 .gitignore create mode 100644 MANIFEST.in create mode 100644 README.md create mode 100644 babel.cfg create mode 100644 octoprint_bambu_printer/__init__.py create mode 100644 octoprint_bambu_printer/ftpsclient/__init__.py create mode 100644 octoprint_bambu_printer/ftpsclient/_client.py create mode 100644 octoprint_bambu_printer/ftpsclient/_version.py create mode 100644 octoprint_bambu_printer/static/js/bambu_printer.js create mode 100644 octoprint_bambu_printer/templates/bambu_printer_settings.jinja2 create mode 100644 octoprint_bambu_printer/virtual.py create mode 100644 requirements.txt create mode 100644 screenshot.png create mode 100644 setup.cfg create mode 100644 setup.py create mode 100644 translations/README.txt diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..df59181 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,18 @@ +# This file is for unifying the coding style for different editors and IDEs +# editorconfig.org + +root = true + +[*] +end_of_line = lf +charset = utf-8 +insert_final_newline = true +trim_trailing_whitespace = true + +[**.py] +indent_style = space +indent_size = 4 + +[**.js] +indent_style = space +indent_size = 4 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..56b0eec --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +*.pyc +*.swp +.idea +*.iml +build +dist +*.egg* +.DS_Store +*.zip +extras diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 0000000..a34974d --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,4 @@ +include README.md +recursive-include octoprint_bambu_printer/templates * +recursive-include octoprint_bambu_printer/translations * +recursive-include octoprint_bambu_printer/static * diff --git a/README.md b/README.md new file mode 100644 index 0000000..86f47b4 --- /dev/null +++ b/README.md @@ -0,0 +1,17 @@ +# OctoPrint-BambuPrinter + +**TODO:** Describe what your plugin does. + +## Setup + +Install via the bundled [Plugin Manager](https://docs.octoprint.org/en/master/bundledplugins/pluginmanager.html) +or manually using this URL: + + https://github.com/jneilliii/OctoPrint-BambuPrinter/archive/master.zip + +**TODO:** Describe how to install your plugin, if more needs to be done than just installing it via pip or through +the plugin manager. + +## Configuration + +**TODO:** Describe your plugin's configuration options (if any). diff --git a/babel.cfg b/babel.cfg new file mode 100644 index 0000000..202a4ee --- /dev/null +++ b/babel.cfg @@ -0,0 +1,8 @@ +[python: */**.py] + +[jinja2: */**.jinja2] +silent=false +extensions=jinja2.ext.do, octoprint.util.jinja.trycatch + +[javascript: */**.js] +extract_messages = gettext, ngettext diff --git a/octoprint_bambu_printer/__init__.py b/octoprint_bambu_printer/__init__.py new file mode 100644 index 0000000..36a65c1 --- /dev/null +++ b/octoprint_bambu_printer/__init__.py @@ -0,0 +1,135 @@ +# coding=utf-8 +from __future__ import absolute_import + +import threading +import time + +import octoprint.plugin + +from .ftpsclient import IoTFTPSClient + + +class BambuPrintPlugin( + octoprint.plugin.SettingsPlugin, octoprint.plugin.TemplatePlugin +): + + def get_template_configs(self): + return [{"type": "settings", "custom_bindings": False}] + + def get_settings_defaults(self): + return {"device_type": "X1C", + "serial": "", + "host": "", + "access_code": "", + "username": "bblp", + "timelapse": False, + "bed_leveling": True, + "flow_cali": False, + "vibration_cali": True, + "layer_inspect": True, + "use_ams": False} + + def support_3mf_files(self): + return {'machinecode': {'3mf': ["3mf"]}} + + def upload_to_sd(self, printer, filename, path, sd_upload_started, sd_upload_succeeded, sd_upload_failed, *args, **kwargs): + self._logger.debug(f"Starting upload from {filename} to {filename}") + sd_upload_started(filename, filename) + def process(): + host = self._settings.get(["host"]) + access_code = self._settings.get(["access_code"]) + elapsed = time.monotonic() + + try: + ftp = IoTFTPSClient(f"{host}", 990, "bblp", f"{access_code}", ssl_implicit=True) + if ftp.upload_file(path, f"{filename}"): + elapsed = time.monotonic() - elapsed + sd_upload_succeeded(filename, filename, elapsed) + # remove local file after successful upload to Bambu + self._file_manager.remove_file("local", filename) + else: + raise Exception("upload failed") + except Exception as e: + elapsed = time.monotonic() - elapsed + sd_upload_failed(filename, filename, elapsed) + self._logger.debug(f"Error uploading file {filename}") + + thread = threading.Thread(target=process) + thread.daemon = True + thread.start() + + return filename + + def virtual_printer_factory(self, comm_instance, port, baudrate, read_timeout): + if not port == "BAMBU": + return None + + if self._settings.get(["serial"]) == "" or self._settings.get(["host"]) == "" or self._settings.get(["access_code"]) == "": + return None + + import logging.handlers + + from octoprint.logging.handlers import CleaningTimedRotatingFileHandler + + seriallog_handler = CleaningTimedRotatingFileHandler( + self._settings.get_plugin_logfile_path(postfix="serial"), + when="D", + backupCount=3, + ) + seriallog_handler.setFormatter(logging.Formatter("%(asctime)s %(message)s")) + seriallog_handler.setLevel(logging.DEBUG) + + from . import virtual + + serial_obj = virtual.BambuPrinter( + self._settings, + self._printer_profile_manager, + data_folder=self.get_plugin_data_folder(), + seriallog_handler=seriallog_handler, + read_timeout=float(read_timeout), + faked_baudrate=baudrate, + ) + return serial_obj + + def get_additional_port_names(self, *args, **kwargs): + if self._settings.get(["serial"]) != "" and self._settings.get(["host"]) != "" and self._settings.get(["access_code"]) != "": + return ["BAMBU"] + else: + return [] + + def get_update_information(self): + return {'bambu_printer': {'displayName': "Bambu Printer", + 'displayVersion': self._plugin_version, + 'type': "github_release", + 'user': "jneilliii", + 'repo': "OctoPrint-BambuPrinter", + 'current': self._plugin_version, + 'stable_branch': {'name': "Stable", + 'branch': "master", + 'comittish': ["master"]}, + 'prerelease_branches': [ + {'name': "Release Candidate", + 'branch': "rc", + 'comittish': ["rc", "master"]} + ], + 'pip': "https://github.com/jneilliii/OctoPrint-BambuPrinter/archive/{target_version}.zip"}} + + +__plugin_name__ = "Bambu Printer" +__plugin_pythoncompat__ = ">=3.7,<4" + + +def __plugin_load__(): + plugin = BambuPrintPlugin() + + global __plugin_implementation__ + __plugin_implementation__ = plugin + + global __plugin_hooks__ + __plugin_hooks__ = { + "octoprint.comm.transport.serial.factory": __plugin_implementation__.virtual_printer_factory, + "octoprint.comm.transport.serial.additional_port_names": __plugin_implementation__.get_additional_port_names, + "octoprint.filemanager.extension_tree": __plugin_implementation__.support_3mf_files, + "octoprint.printer.sdcardupload": __plugin_implementation__.upload_to_sd, + "octoprint.plugin.softwareupdate.check_config": __plugin_implementation__.get_update_information, + } diff --git a/octoprint_bambu_printer/ftpsclient/__init__.py b/octoprint_bambu_printer/ftpsclient/__init__.py new file mode 100644 index 0000000..e3684a7 --- /dev/null +++ b/octoprint_bambu_printer/ftpsclient/__init__.py @@ -0,0 +1,2 @@ +from ._client import IoTFTPSClient +from ._version import __version__ diff --git a/octoprint_bambu_printer/ftpsclient/_client.py b/octoprint_bambu_printer/ftpsclient/_client.py new file mode 100644 index 0000000..ab11261 --- /dev/null +++ b/octoprint_bambu_printer/ftpsclient/_client.py @@ -0,0 +1,159 @@ +"""wrapper for FTPS server interactions""" + +import ftplib +import ssl +from typing import List, Optional, Union + + +class ImplicitTLS(ftplib.FTP_TLS): + """ftplib.FTP_TLS sub-class to support implicit SSL FTPS""" + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self._sock = None + + @property + def sock(self): + """return socket""" + return self._sock + + @sock.setter + def sock(self, value): + """wrap and set SSL socket""" + if value is not None and not isinstance(value, ssl.SSLSocket): + value = self.context.wrap_socket(value) + self._sock = value + + def ntransfercmd(self, cmd, rest=None): + conn, size = ftplib.FTP.ntransfercmd(self, cmd, rest) + if self._prot_p: + conn = self.context.wrap_socket(conn, + server_hostname=self.host, + session=self.sock.session) # this is the fix + return conn, size + + +class IoTFTPSClient: + """iot ftps ftpsclient""" + + ftps_host: str + ftps_port: int + ftps_user: str + ftps_pass: str + ssl_implicit: bool + ftps_session: Union[ftplib.FTP, ImplicitTLS] + + def __init__( + self, + ftps_host: str, + ftps_port: Optional[int] = 21, + ftps_user: Optional[str] = "", + ftps_pass: Optional[str] = "", + ssl_implicit: Optional[bool] = False, + ) -> None: + self.ftps_host = ftps_host + self.ftps_port = ftps_port + self.ftps_user = ftps_user + self.ftps_pass = ftps_pass + self.ssl_implicit = ssl_implicit + self.instantiate_ftps_session() + + def __repr__(self) -> str: + return ( + "IoT FTPS Client\n" + "--------------------\n" + f"host: {self.ftps_host}\n" + f"port: {self.ftps_port}\n" + f"user: {self.ftps_user}\n" + f"ssl: {self.ssl_implicit}" + ) + + def instantiate_ftps_session(self) -> None: + """init ftps_session based on input params""" + try: + if self.ssl_implicit: + self.ftps_session = ImplicitTLS() + else: + self.ftps_session = ftplib.FTP() + + self.ftps_session.connect(host=self.ftps_host, port=self.ftps_port) + + if self.ftps_user != "" and self.ftps_pass != "": + self.ftps_session.login(user=self.ftps_user, passwd=self.ftps_pass) + else: + self.ftps_session.login() + + if self.ssl_implicit: + self.ftps_session.prot_p() + + except Exception as ex: + print(f"unexpected exception occurred: {ex}") + pass + return + + def disconnect(self) -> None: + """disconnect the current session from the ftps server""" + try: + self.ftps_session.close() + except Exception as ex: + print(f"unexpected exception occurred: {ex}") + pass + return + + def download_file(self, source: str, dest: str) -> bool: + """download a file to a path on the local filesystem""" + try: + with open(dest, "wb") as file: + self.ftps_session.retrbinary(f"RETR {source}", file.write) + return True + except Exception as ex: + print(f"unexpected exception occurred: {ex}") + pass + return False + + def upload_file(self, source: str, dest: str) -> bool: + """upload a file to a path inside the FTPS server""" + try: + with open(source, "rb") as file: + self.ftps_session.storbinary(f"STOR {dest}", file) + return True + except Exception as ex: + print(f"unexpected exception occurred: {ex}") + pass + return False + + def delete_file(self, path: str) -> bool: + """delete a file from under a path inside the FTPS server""" + try: + self.ftps_session.delete(path) + return True + except Exception as ex: + print(f"unexpected exception occurred: {ex}") + pass + return False + + def move_file(self, source: str, dest: str) -> bool: + """move a file inside the FTPS server to another path inside the FTPS server""" + try: + self.ftps_session.rename(source, dest) + return True + except Exception as ex: + print(f"unexpected exception occurred: {ex}") + pass + return False + + def list_files( + self, path: str, file_pattern: Optional[str] = None + ) -> Union[List[str], None]: + """list files under a path inside the FTPS server""" + try: + files = self.ftps_session.nlst(path) + if not files: + return + if file_pattern: + return [f for f in files if file_pattern in f] + return files + except Exception as ex: + print(f"unexpected exception occurred: {ex}") + pass + return diff --git a/octoprint_bambu_printer/ftpsclient/_version.py b/octoprint_bambu_printer/ftpsclient/_version.py new file mode 100644 index 0000000..6ba758b --- /dev/null +++ b/octoprint_bambu_printer/ftpsclient/_version.py @@ -0,0 +1,3 @@ +VERSION = "1.1.1" + +__version__ = VERSION diff --git a/octoprint_bambu_printer/static/js/bambu_printer.js b/octoprint_bambu_printer/static/js/bambu_printer.js new file mode 100644 index 0000000..81e28b6 --- /dev/null +++ b/octoprint_bambu_printer/static/js/bambu_printer.js @@ -0,0 +1,29 @@ +/* + * View model for OctoPrint-BambuPrinter + * + * Author: jneilliii + * License: AGPLv3 + */ +$(function() { + function Bambu_printerViewModel(parameters) { + var self = this; + + // assign the injected parameters, e.g.: + // self.loginStateViewModel = parameters[0]; + // self.settingsViewModel = parameters[1]; + + // TODO: Implement your plugin's view model here. + } + + /* view model class, parameters for constructor, container to bind to + * Please see http://docs.octoprint.org/en/master/plugins/viewmodels.html#registering-custom-viewmodels for more details + * and a full list of the available options. + */ + OCTOPRINT_VIEWMODELS.push({ + construct: Bambu_printerViewModel, + // ViewModels your plugin depends on, e.g. loginStateViewModel, settingsViewModel, ... + dependencies: [ /* "loginStateViewModel", "settingsViewModel" */ ], + // Elements to bind to, e.g. #settings_plugin_bambu_printer, #tab_plugin_bambu_printer, ... + elements: [ /* ... */ ] + }); +}); diff --git a/octoprint_bambu_printer/templates/bambu_printer_settings.jinja2 b/octoprint_bambu_printer/templates/bambu_printer_settings.jinja2 new file mode 100644 index 0000000..7e4845a --- /dev/null +++ b/octoprint_bambu_printer/templates/bambu_printer_settings.jinja2 @@ -0,0 +1,40 @@ +

Virtual Printer

+ +
+
+ +
+ +
+
+
+ +
+ +
+
+
+ +
+ +
+
+
+ +
+ +
+
+
+ +
+ + + + + + +
+
+
diff --git a/octoprint_bambu_printer/virtual.py b/octoprint_bambu_printer/virtual.py new file mode 100644 index 0000000..185e372 --- /dev/null +++ b/octoprint_bambu_printer/virtual.py @@ -0,0 +1,970 @@ +__author__ = "Gina Häußge " +__license__ = "GNU Affero General Public License http://www.gnu.org/licenses/agpl.html" + + +import collections +import os +import queue +import re +import threading +import time +from typing import Any, Dict, List, Optional +import asyncio +from pybambu import BambuClient, commands + +from serial import SerialTimeoutException +from octoprint.util import RepeatedTimer, to_bytes, to_unicode, get_dos_filename + +from .ftpsclient import IoTFTPSClient + + +# noinspection PyBroadException +class BambuPrinter: + command_regex = re.compile(r"^([GM])(\d+)") + + def __init__( + self, + settings, + printer_profile_manager, + data_folder, + seriallog_handler=None, + read_timeout=5.0, + write_timeout=10.0, + faked_baudrate=115200, + ): + self._busyInterval = 2.0 + self.tick_rate = 2.0 + self._errors = { + "checksum_mismatch": "Checksum mismatch", + "checksum_missing": "Missing checksum", + "lineno_mismatch": "expected line {} got {}", + "lineno_missing": "No Line Number with checksum, Last Line: {}", + "maxtemp": "MAXTEMP triggered!", + "mintemp": "MINTEMP triggered!", + "command_unknown": "Unknown command {}", + } + self._sendBusy = False + self._ambient_temperature = 21.3 + self.temp = [self._ambient_temperature ] + self.targetTemp = [0.0] + self.bedTemp = self._ambient_temperature + self.bedTargetTemp = 0.0 + self.chamberTemp = self._ambient_temperature + self.chamberTargetTemp = 0.0 + self.lastTempAt = time.monotonic() + self._firmwareName = "Bambu" + self._m115FormatString = "FIRMWARE_NAME:{firmware_name} PROTOCOL_VERSION:1.0" + self._received_lines = 0 + self.extruderCount = 1 + self._waitInterval = 5.0 + self._killed = False + self._heatingUp = False + self.current_line = 0 + self._writingToSd = False + + self._sdCardReady = True + self._sdPrinter = None + self._sdPrinting = False + self._sdPrintingSemaphore = threading.Event() + self._sdPrintingPausedSemaphore = threading.Event() + self._selectedSdFile = None + self._selectedSdFileSize = 0 + self._selectedSdFilePos = 0 + + self._busy = None + self._busy_loop = None + + + import logging + + self._logger = logging.getLogger( + "octoprint.plugins.bambu_printer.BambuPrinter" + ) + + self._settings = settings + self._printer_profile_manager = printer_profile_manager + self._faked_baudrate = faked_baudrate + self._plugin_data_folder = data_folder + + self._seriallog = logging.getLogger( + "octoprint.plugins.bambu_printer.BambuPrinter.serial" + ) + self._seriallog.setLevel(logging.CRITICAL) + self._seriallog.propagate = False + + if seriallog_handler is not None: + import logging.handlers + + self._seriallog.addHandler(seriallog_handler) + self._seriallog.setLevel(logging.INFO) + + self._seriallog.debug("-" * 78) + + self._read_timeout = read_timeout + self._write_timeout = write_timeout + + self._rx_buffer_size = 64 + self._incoming_lock = threading.RLock() + + self.incoming = CharCountingQueue(self._rx_buffer_size, name="RxBuffer") + self.outgoing = queue.Queue() + self.buffered = queue.Queue(maxsize=4) + + self._last_hms_errors = None + + self.bambu = None + + readThread = threading.Thread( + target=self._processIncoming, + name="octoprint.plugins.bambu_printer.wait_thread", + daemon=True + ) + readThread.start() + + # bufferThread = threading.Thread( + # target=self._processBuffer, + # name="octoprint.plugins.bambu_printer.buffer_thread", + # daemon=True + # ) + # bufferThread.start() + + connectionThread = threading.Thread( + target=self._create_connection, + name="octoprint.plugins.bambu_printer.connection_thread", + daemon=True + ) + connectionThread.start() + + def new_update(self, event_type): + if event_type == "event_hms_errors": + bambu_printer = self.bambu.get_device() + if bambu_printer.hms.errors != self._last_hms_errors and bambu_printer.hms.errors["Count"] > 0: + self._logger.debug(f"HMS Error: {bambu_printer.hms.errors}") + for n in range(1, bambu_printer.hms.errors["Count"]+1): + error = bambu_printer.hms.errors[f"{n}-Error"].strip() + self._send(f"// action:notification {error}") + self._last_hms_errors = bambu_printer.hms.errors + elif event_type == "event_printer_data_update": + device_data = self.bambu.get_device() + ams = device_data.ams.__dict__ + info = device_data.info.__dict__ + temperatures = device_data.temperature.__dict__ + lights = device_data.lights.__dict__ + fans = device_data.fans.__dict__ + speed = device_data.speed.__dict__ + + self.temp[0] = temperatures.get("nozzle_temp", 0.0) + self.targetTemp[0] = temperatures.get("target_nozzle_temp", 0.0) + self.bedTemp = temperatures.get("bed_temp", 0.0) + self.bedTargetTemp = temperatures.get("target_bed_temp", 0.0) + self.chamberTemp = temperatures.get("chamber_temp", 0.0) + + if info.get("gcode_state") == "RUNNING": + if not self._sdPrintingSemaphore.is_set(): + self._sdPrintingSemaphore.set() + if self._sdPrintingPausedSemaphore.is_set(): + self._sdPrintingPausedSemaphore.clear() + if not self._sdPrinting: + filename = info.get("subtask_name") + self._selectSdFile(filename) + self._startSdPrint(from_printer=True) + + # fuzzy math here to get print percentage to match BambuStudio + self._selectedSdFilePos = int(self._selectedSdFileSize * ((info.get("print_percentage") + 1)/100)) + + if info.get("gcode_state") == "PAUSE": + if not self._sdPrintingPausedSemaphore.is_set(): + self._sdPrintingPausedSemaphore.set() + if self._sdPrintingSemaphore.is_set(): + self._sdPrintingSemaphore.clear() + self._send("// action:paused") + self._sendPaused() + + if info.get("gcode_state") == "FINISH" and self._sdPrintingSemaphore.is_set(): + self._selectedSdFilePos = self._selectedSdFileSize + self._finishSdPrint() + def _create_connection(self): + if (self._settings.get(["device_type"]) != "" and + self._settings.get(["serial"]) != "" and + self._settings.get(["serial"]) != "" and + self._settings.get(["username"]) != "" and + self._settings.get(["access_code"]) != "" + ): + asyncio.run(self._create_connection_async()) + + async def _create_connection_async(self): + self.bambu = BambuClient(device_type=self._settings.get(["device_type"]), + serial=self._settings.get(["serial"]), + host=self._settings.get(["host"]), + username=self._settings.get(["username"]), + access_code=self._settings.get(["access_code"]) + ) + + await self.bambu.connect(callback=self.new_update) + self._logger.info(f"bambu connection status: {self.bambu.connected}") + self._sendOk() + # while True: + # await asyncio.sleep(self.tick_rate) + # self._processTemperatureQuery() + + def __str__(self): + return "BAMBU(read_timeout={read_timeout},write_timeout={write_timeout},options={options})".format( + read_timeout=self._read_timeout, + write_timeout=self._write_timeout, + options={"device_type": self._settings.get(["device_type"]), "host": self._settings.get(["host"])}, + ) + + def _calculate_resend_every_n(self, resend_ratio): + self._resend_every_n = (100 // resend_ratio) if resend_ratio else 0 + + def _reset(self): + with self._incoming_lock: + self._relative = True + self._lastX = 0.0 + self._lastY = 0.0 + self._lastZ = 0.0 + self._lastE = [0.0] * self.extruderCount + self._lastF = 200 + + self._unitModifier = 1 + self._feedrate_multiplier = 100 + self._flowrate_multiplier = 100 + + self._sdCardReady = True + self._sdPrinting = False + if self._sdPrinter: + self._sdPrinting = False + self._sdPrintingSemaphore.clear() + self._sdPrintingPausedSemaphore.clear() + self._sdPrinter = None + self._selectedSdFile = None + self._selectedSdFileSize = None + self._selectedSdFilePos = None + + if self._writingToSdHandle: + try: + self._writingToSdHandle.close() + except Exception: + pass + self._writingToSd = False + self._writingToSdHandle = None + self._writingToSdFile = None + self._newSdFilePos = None + + self._heatingUp = False + + self.current_line = 0 + self.lastN = 0 + + self._debug_awol = False + self._debug_sleep = 0 + # self._sleepAfterNext.clear() + # self._sleepAfter.clear() + + self._dont_answer = False + self._broken_klipper_connection = False + + self._debug_drop_connection = False + + self._killed = False + + if self._sdstatus_reporter is not None: + self._sdstatus_reporter.cancel() + self._sdstatus_reporter = None + + self._clearQueue(self.incoming) + self._clearQueue(self.outgoing) + # self._clearQueue(self.buffered) + + if self._settings.get_boolean(["simulateReset"]): + for item in self._settings.get(["resetLines"]): + self._send(item + "\n") + + self._locked = self._settings.get_boolean(["locked"]) + + @property + def timeout(self): + return self._read_timeout + + @timeout.setter + def timeout(self, value): + self._logger.debug(f"Setting read timeout to {value}s") + self._read_timeout = value + + @property + def write_timeout(self): + return self._write_timeout + + @write_timeout.setter + def write_timeout(self, value): + self._logger.debug(f"Setting write timeout to {value}s") + self._write_timeout = value + + @property + def port(self): + return "BAMBU" + + @property + def baudrate(self): + return self._faked_baudrate + + # noinspection PyMethodMayBeStatic + def _clearQueue(self, q): + try: + while q.get(block=False): + q.task_done() + continue + except queue.Empty: + pass + + def _processIncoming(self): + linenumber = 0 + next_wait_timeout = 0 + + def recalculate_next_wait_timeout(): + nonlocal next_wait_timeout + next_wait_timeout = time.monotonic() + self._waitInterval + + recalculate_next_wait_timeout() + + data = None + + buf = b"" + while self.incoming is not None and not self._killed: + try: + data = self.incoming.get(timeout=0.01) + data = to_bytes(data, encoding="ascii", errors="replace") + self.incoming.task_done() + except queue.Empty: + continue + except Exception: + if self.incoming is None: + # just got closed + break + + if data is not None: + buf += data + nl = buf.find(b"\n") + 1 + if nl > 0: + data = buf[:nl] + buf = buf[nl:] + else: + continue + + recalculate_next_wait_timeout() + + if data is None: + continue + + self._received_lines += 1 + + # strip checksum + if b"*" in data: + checksum = int(data[data.rfind(b"*") + 1 :]) + data = data[: data.rfind(b"*")] + if not checksum == self._calculate_checksum(data): + self._triggerResend(expected=self.current_line + 1) + continue + + self.current_line += 1 + elif self._settings.get_boolean(["forceChecksum"]): + self._send(self._error("checksum_missing")) + continue + + # track N = N + 1 + if data.startswith(b"N") and b"M110" in data: + linenumber = int(re.search(b"N([0-9]+)", data).group(1)) + self.lastN = linenumber + self.current_line = linenumber + self._sendOk() + continue + + elif data.startswith(b"N"): + linenumber = int(re.search(b"N([0-9]+)", data).group(1)) + expected = self.lastN + 1 + if linenumber != expected: + self._triggerResend(actual=linenumber) + continue + else: + self.lastN = linenumber + + data = data.split(None, 1)[1].strip() + + data += b"\n" + + data = to_unicode(data, encoding="ascii", errors="replace").strip() + + # actual command handling + command_match = BambuPrinter.command_regex.match(data) + if command_match is not None: + command = command_match.group(0) + letter = command_match.group(1) + + try: + # if we have a method _gcode_G, _gcode_M or _gcode_T, execute that first + letter_handler = f"_gcode_{letter}" + if hasattr(self, letter_handler): + code = command_match.group(2) + handled = getattr(self, letter_handler)(code, data) + if handled: + self._sendOk() + continue + + # then look for a method _gcode_ and execute that if it exists + command_handler = f"_gcode_{command}" + if hasattr(self, command_handler): + handled = getattr(self, command_handler)(data) + if handled: + self._sendOk() + continue + else: + self._sendOk() + + finally: + self._logger.debug(f"{data}") + + self._logger.debug("Closing down read loop") + + ##~~ command implementations + + # noinspection PyUnusedLocal + def _gcode_M20(self, data: str) -> bool: + if self._sdCardReady: + self._listSd(incl_long="L" in data, incl_timestamp="T" in data) + return True + + # noinspection PyUnusedLocal + def _gcode_M21(self, data: str) -> bool: + self._sdCardReady = True + self._send("SD card ok") + return True + + # noinspection PyUnusedLocal + def _gcode_M22(self, data: str) -> bool: + self._logger.debug("ignoring M22 command.") + self._send("M22 disabled for Bambu") + return True + + def _gcode_M23(self, data: str) -> bool: + if self._sdCardReady: + filename = data.split(None, 1)[1].strip() + self._selectSdFile(filename) + return True + + # noinspection PyUnusedLocal + def _gcode_M24(self, data: str) -> bool: + if self._sdCardReady: + self._startSdPrint() + return True + + # noinspection PyUnusedLocal + def _gcode_M25(self, data: str) -> bool: + if self._sdCardReady: + self._pauseSdPrint() + return True + + def _gcode_M26(self, data: str) -> bool: + self._logger.debug("ignoring M26 command.") + self._send("M26 disabled for Bambu") + return True + + def _gcode_M27(self, data: str) -> bool: + def report(): + if self._sdCardReady: + self._reportSdStatus() + + matchS = re.search(r"S([0-9]+)", data) + if matchS: + interval = int(matchS.group(1)) + if self._sdstatus_reporter is not None: + self._sdstatus_reporter.cancel() + + if interval > 0: + self._sdstatus_reporter = RepeatedTimer(interval, report) + self._sdstatus_reporter.start() + else: + self._sdstatus_reporter = None + + report() + return True + + def _gcode_M28(self, data: str) -> bool: + self._logger.debug("ignoring M28 command.") + self._send("M28 disabled for Bambu") + return True + + # noinspection PyUnusedLocal + def _gcode_M29(self, data: str) -> bool: + self._logger.debug("ignoring M28 command.") + self._send("M28 disabled for Bambu") + return True + + def _gcode_M30(self, data: str) -> bool: + if self._sdCardReady: + filename = data.split(None, 1)[1].strip() + self._deleteSdFile(filename) + return True + + def _gcode_M33(self, data: str) -> bool: + self._logger.debug("ignoring M33 command.") + self._send("M33 disabled for Bambu") + return True + + # noinspection PyUnusedLocal + def _gcode_M105(self, data: str) -> bool: + self._processTemperatureQuery() + return True + + # noinspection PyUnusedLocal + def _gcode_M115(self, data: str) -> bool: + self._send("Bambu Printer Integration") + self._send("Cap:EXTENDED_M20:1") + self._send("Cap:LFN_WRITE:1") + self._send("Cap:LFN_WRITE:1") + return True + + def _gcode_M117(self, data: str) -> bool: + # we'll just use this to echo a message, to allow playing around with pause triggers + result = re.search(r"M117\s+(.*)", data).group(1) + self._send(f"echo:{result}") + return False + + def _gcode_M118(self, data: str) -> bool: + match = re.search(r"M118 (?:(?PA1|E1|Pn[012])\s)?(?P.*)", data) + if not match: + self._send("Unrecognized command parameters for M118") + else: + result = match.groupdict() + text = result["text"] + parameter = result["parameter"] + + if parameter == "A1": + self._send(f"//{text}") + elif parameter == "E1": + self._send(f"echo:{text}") + else: + self._send(text) + return True + + # noinspection PyUnusedLocal + def _gcode_M400(self, data: str) -> bool: + return True + + @staticmethod + def _check_param_letters(letters, data): + # Checks if any of the params (letters) are included in data + # Purely for saving typing :) + for param in list(letters): + if param in data: + return True + + ##~~ further helpers + + # noinspection PyMethodMayBeStatic + def _calculate_checksum(self, line: bytes) -> int: + checksum = 0 + for c in bytearray(line): + checksum ^= c + return checksum + + def _kill(self): + self._killed = True + if self.bambu.connected: + self.bambu.disconnect() + self._send("echo:EMERGENCY SHUTDOWN DETECTED. KILLED.") + + def _triggerResend( + self, expected: int = None, actual: int = None, checksum: int = None + ) -> None: + with self._incoming_lock: + if expected is None: + expected = self.lastN + 1 + else: + self.lastN = expected - 1 + + if actual is None: + if checksum: + self._send(self._error("checksum_mismatch")) + else: + self._send(self._error("checksum_missing")) + else: + self._send(self._error("lineno_mismatch", expected, actual)) + + def request_resend(): + self._send("Resend:%d" % expected) + # if not self._brokenResend: + self._sendOk() + + request_resend() + + def _listSd(self, incl_long=False, incl_timestamp=False): + line = "{name} {size} \"{name}\"" + + self._send("Begin file list") + for item in map(lambda x: line.format(**x), self._getSdFiles()): + self._send(item) + self._send("End file list") + + def _mappedSdList(self) -> Dict[str, Dict[str, Any]]: + result = {} + host = self._settings.get(["host"]) + access_code = self._settings.get(["access_code"]) + + ftp = IoTFTPSClient(f"{host}", 990, "bblp", f"{access_code}", ssl_implicit=True) + filelist = ftp.list_files("", ".3mf") + + for entry in filelist: + if entry.startswith("/"): + filename = entry[1:] + else: + filename = entry + filesize = ftp.ftps_session.size(entry) + dosname = get_dos_filename(filename, existing_filenames=list(result.keys())).lower() + data = { + "dosname": dosname, + "name": filename, + "path": filename, + "size": filesize, + } + result[filename.lower()] = data + # result[dosname.lower()] = filename.lower() + + return result + + def _getSdFileData(self, filename: str) -> Optional[Dict[str, Any]]: + files = self._mappedSdList() + data = files.get(filename.lower()) + if isinstance(data, str): + data = files.get(data.lower()) + return data + + def _getSdFiles(self) -> List[Dict[str, Any]]: + files = self._mappedSdList() + return [x for x in files.values() if isinstance(x, dict)] + + def _selectSdFile(self, filename: str, check_already_open: bool = False) -> None: + if filename.startswith("/"): + filename = filename[1:] + + file = self._getSdFileData(filename) + if file is None: + self._send(f"{filename} open failed") + return + + if self._selectedSdFile == file["path"] and check_already_open: + return + + self._selectedSdFile = file["path"] + self._selectedSdFileSize = file["size"] + self._send(f"File opened: {file['name']} Size: {self._selectedSdFileSize}") + self._send("File selected") + + def _startSdPrint(self, from_printer: bool = False) -> None: + if self._selectedSdFile is not None: + if self._sdPrinter is None: + self._sdPrinting = True + self._sdPrinter = threading.Thread(target=self._sdPrintingWorker, kwargs={"from_printer": from_printer}) + self._sdPrinter.start() + # self._sdPrintingSemaphore.set() + if self._sdPrinter is not None: + if self.bambu.connected: + if self.bambu.publish(commands.RESUME): + self._logger.info("print resumed") + # if not self._sdPrintingSemaphore.is_set(): + # self._sdPrintingSemaphore.set() + else: + self._logger.info("print resume failed") + + def _pauseSdPrint(self): + if self.bambu.connected: + if self.bambu.publish(commands.PAUSE): + self._logger.info("print paused") + else: + self._logger.info("print pause failed") + + def _setSdPos(self, pos): + self._newSdFilePos = pos + + def _reportSdStatus(self): + if self._sdPrinter is not None and (self._sdPrintingSemaphore.is_set() or self._sdPrintingPausedSemaphore.is_set()): + self._send(f"SD printing byte {self._selectedSdFilePos}/{self._selectedSdFileSize}") + else: + self._send("Not SD printing") + + def _generateTemperatureOutput(self) -> str: + template = "{heater}:{actual:.2f}/ {target:.2f}" + temps = collections.OrderedDict() + heater = "T" + temps[heater] = (self.temp[0], self.targetTemp[0]) + temps["B"] = (self.bedTemp, self.bedTargetTemp) + temps["C"] = (self.chamberTemp, self.chamberTargetTemp) + + output = " ".join( + map( + lambda x: template.format(heater=x[0], actual=x[1][0], target=x[1][1]), + temps.items(), + ) + ) + output += " @:64\n" + return output + + def _processTemperatureQuery(self): + # includeOk = not self._okBeforeCommandOutput + output = self._generateTemperatureOutput() + self._send(output) + + def _writeSdFile(self, filename: str) -> None: + self._send(f"Writing to file: {filename}") + + def _finishSdFile(self): + try: + self._writingToSdHandle.close() + except Exception: + pass + finally: + self._writingToSdHandle = None + self._writingToSd = False + self._selectedSdFile = None + # Most printers don't have RTC and set some ancient date + # by default. Emulate that using 2000-01-01 01:00:00 + # (taken from prusa firmware behaviour) + st = os.stat(self._writingToSdFile) + os.utime(self._writingToSdFile, (st.st_atime, 946684800)) + self._writingToSdFile = None + self._send("Done saving file") + + def _sdPrintingWorker(self, from_printer: bool = False): + self._selectedSdFilePos = 0 + try: + if not from_printer and self.bambu.connected: + print_command = {"print": {"sequence_id": 0, + "command": "project_file", + "param": "Metadata/plate_1.gcode", + "subtask_name": f"{self._selectedSdFile}", + "url": f"file:///mnt/sdcard/{self._selectedSdFile}", + "timelapse": self._settings.get_boolean(["timelapse"]), + "bed_leveling": self._settings.get_boolean(["bed_leveling"]), + "flow_cali": self._settings.get_boolean(["flow_cali"]), + "vibration_cali": self._settings.get_boolean(["vibration_cali"]), + "layer_inspect": self._settings.get_boolean(["layer_inspect"]), + "use_ams": self._settings.get_boolean(["use_ams"]) + } + } + self.bambu.publish(print_command) + + while self._selectedSdFilePos < self._selectedSdFileSize: + if self._killed or not self._sdPrinting: + break + + # if we are paused, wait for resuming + self._sdPrintingSemaphore.wait() + self._reportSdStatus() + time.sleep(3) + self._logger.debug(f"SD File Print: {self._selectedSdFile}") + except AttributeError: + if self.outgoing is not None: + raise + + self._finishSdPrint() + + def _finishSdPrint(self): + if not self._killed: + self._sdPrintingSemaphore.clear() + self._sdPrintingPausedSemaphore.clear() + self._send("Done printing file") + self._selectedSdFilePos = 0 + self._selectedSdFileSize = 0 + self._sdPrinting = False + self._sdPrinter = None + + def _deleteSdFile(self, filename: str) -> None: + host = self._settings.get(["host"]) + access_code = self._settings.get(["access_code"]) + + if filename.startswith("/"): + filename = filename[1:] + file = self._getSdFileData(filename) + if file is not None: + ftp = IoTFTPSClient(f"{host}", 990, "bblp", f"{access_code}", ssl_implicit=True) + try: + if ftp.delete_file(filename): + self._logger.debug(f"{filename} deleted") + else: + raise Exception("delete failed") + except Exception as e: + self._logger.debug(f"Error deleting file {filename}") + + def _setBusy(self, reason="processing"): + if not self._sendBusy: + return + + def loop(): + while self._busy: + self._send(f"echo:busy {self._busy}") + time.sleep(self._busyInterval) + self._sendOk() + + self._busy = reason + self._busy_loop = threading.Thread(target=loop) + self._busy_loop.daemon = True + self._busy_loop.start() + + def _setUnbusy(self): + self._busy = None + + # def _processBuffer(self): + # while self.buffered is not None: + # try: + # line = self.buffered.get(timeout=0.5) + # except queue.Empty: + # continue + # + # if line is None: + # continue + # + # self.buffered.task_done() + # + # self._logger.debug("Closing down buffer loop") + + def _showPrompt(self, text, choices): + self._hidePrompt() + self._send(f"//action:prompt_begin {text}") + for choice in choices: + self._send(f"//action:prompt_button {choice}") + self._send("//action:prompt_show") + + def _hidePrompt(self): + self._send("//action:prompt_end") + + def write(self, data: bytes) -> int: + data = to_bytes(data, errors="replace") + u_data = to_unicode(data, errors="replace") + + with self._incoming_lock: + if self.incoming is None or self.outgoing is None: + return 0 + + if b"M112" in data: + self._seriallog.debug(f"<<< {u_data}") + self._kill() + return len(data) + + try: + written = self.incoming.put(data, timeout=self._write_timeout, partial=True) + self._seriallog.debug(f"<<< {u_data}") + return written + except queue.Full: + self._logger.info( + "Incoming queue is full, raising SerialTimeoutException" + ) + raise SerialTimeoutException() + + def readline(self) -> bytes: + timeout = self._read_timeout + + try: + # fetch a line from the queue, wait no longer than timeout + line = to_unicode(self.outgoing.get(timeout=timeout), errors="replace") + self._seriallog.debug(f">>> {line.strip()}") + self.outgoing.task_done() + return to_bytes(line) + except queue.Empty: + # queue empty? return empty line + return b"" + + def close(self): + if self.bambu.connected: + self.bambu.disconnect() + self._killed = True + self.incoming = None + self.outgoing = None + self.buffered = None + + def _sendOk(self): + if self.outgoing is None: + return + ok = self._ok() + if ok: + self._send(ok) + + def _isPaused(self): + return self._sdPrintingPausedSemaphore.is_set() + def _sendPaused(self): + paused_timer = RepeatedTimer(interval=3.0, function=self._send, args=[f"SD printing byte {self._selectedSdFilePos}/{self._selectedSdFileSize}"], + daemon=True, run_first=True, condition=self._isPaused) + paused_timer.start() + + def _send(self, line: str) -> None: + if self.outgoing is not None: + self.outgoing.put(line) + + def _ok(self): + return "ok" + + def _error(self, error: str, *args, **kwargs) -> str: + return f"Error: {self._errors.get(error).format(*args, **kwargs)}" + +# noinspection PyUnresolvedReferences +class CharCountingQueue(queue.Queue): + def __init__(self, maxsize, name=None): + queue.Queue.__init__(self, maxsize=maxsize) + self._size = 0 + self._name = name + + def clear(self): + with self.mutex: + self.queue.clear() + + def put(self, item, block=True, timeout=None, partial=False) -> int: + self.not_full.acquire() + + try: + if not self._will_it_fit(item) and partial: + space_left = self.maxsize - self._qsize() + if space_left: + item = item[:space_left] + + if not block: + if not self._will_it_fit(item): + raise queue.Full + elif timeout is None: + while not self._will_it_fit(item): + self.not_full.wait() + elif timeout < 0: + raise ValueError("'timeout' must be a positive number") + else: + endtime = time.monotonic() + timeout + while not self._will_it_fit(item): + remaining = endtime - time.monotonic() + if remaining <= 0: + raise queue.Full + self.not_full.wait(remaining) + + self._put(item) + self.unfinished_tasks += 1 + self.not_empty.notify() + + return self._len(item) + finally: + self.not_full.release() + + # noinspection PyMethodMayBeStatic + def _len(self, item): + return len(item) + + def _qsize(self, l=len): # noqa: E741 + return self._size + + # Put a new item in the queue + def _put(self, item): + self.queue.append(item) + self._size += self._len(item) + + # Get an item from the queue + def _get(self): + item = self.queue.popleft() + self._size -= self._len(item) + return item + + def _will_it_fit(self, item): + return self.maxsize - self._qsize() >= self._len(item) diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..a1dc463 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,9 @@ +### +# This file is only here to make sure that something like +# +# pip install -e . +# +# works as expected. Requirements can be found in setup.py. +### + +. diff --git a/screenshot.png b/screenshot.png new file mode 100644 index 0000000000000000000000000000000000000000..24b175a2c9f5f7fb0d011798e9e6cc82899c8243 GIT binary patch literal 130584 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

4`oI;;me4LRrfwJ1 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 Q1n|<)(!W=7*Ealr0OqYFYybcN literal 0 HcmV?d00001 diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 0000000..2a9acf1 --- /dev/null +++ b/setup.cfg @@ -0,0 +1,2 @@ +[bdist_wheel] +universal = 1 diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..bff221d --- /dev/null +++ b/setup.py @@ -0,0 +1,102 @@ +# coding=utf-8 + +######################################################################################################################## +### Do not forget to adjust the following variables to your own plugin. + +# The plugin's identifier, has to be unique +plugin_identifier = "bambu_printer" + +# The plugin's python package, should be "octoprint_", has to be unique +plugin_package = "octoprint_bambu_printer" + +# The plugin's human readable name. Can be overwritten within OctoPrint's internal data via __plugin_name__ in the +# plugin module +plugin_name = "OctoPrint-BambuPrinter" + +# The plugin's version. Can be overwritten within OctoPrint's internal data via __plugin_version__ in the plugin module +plugin_version = "0.0.1" + +# The plugin's description. Can be overwritten within OctoPrint's internal data via __plugin_description__ in the plugin +# module +plugin_description = """Connects OctoPrint to BambuLabs printers.""" + +# The plugin's author. Can be overwritten within OctoPrint's internal data via __plugin_author__ in the plugin module +plugin_author = "jneilliii" + +# The plugin's author's mail address. +plugin_author_email = "jneilliii+github@gmail.com" + +# The plugin's homepage URL. Can be overwritten within OctoPrint's internal data via __plugin_url__ in the plugin module +plugin_url = "https://github.com/jneilliii/OctoPrint-BambuPrinter" + +# The plugin's license. Can be overwritten within OctoPrint's internal data via __plugin_license__ in the plugin module +plugin_license = "AGPLv3" + +# Any additional requirements besides OctoPrint should be listed here +plugin_requires = ["paho-mqtt", "pybambu>=1.0.0"] + +### -------------------------------------------------------------------------------------------------------------------- +### More advanced options that you usually shouldn't have to touch follow after this point +### -------------------------------------------------------------------------------------------------------------------- + +# Additional package data to install for this plugin. The subfolders "templates", "static" and "translations" will +# already be installed automatically if they exist. Note that if you add something here you'll also need to update +# MANIFEST.in to match to ensure that python setup.py sdist produces a source distribution that contains all your +# files. This is sadly due to how python's setup.py works, see also http://stackoverflow.com/a/14159430/2028598 +plugin_additional_data = [] + +# Any additional python packages you need to install with your plugin that are not contained in .* +plugin_additional_packages = [] + +# Any python packages within .* you do NOT want to install with your plugin +plugin_ignored_packages = [] + +# Additional parameters for the call to setuptools.setup. If your plugin wants to register additional entry points, +# define dependency links or other things like that, this is the place to go. Will be merged recursively with the +# default setup parameters as provided by octoprint_setuptools.create_plugin_setup_parameters using +# octoprint.util.dict_merge. +# +# Example: +# plugin_requires = ["someDependency==dev"] +# additional_setup_parameters = {"dependency_links": ["https://github.com/someUser/someRepo/archive/master.zip#egg=someDependency-dev"]} +# "python_requires": ">=3,<4" blocks installation on Python 2 systems, to prevent confused users and provide a helpful error. +# Remove it if you would like to support Python 2 as well as 3 (not recommended). +additional_setup_parameters = {"python_requires": ">=3,<4"} + +######################################################################################################################## + +from setuptools import setup + +try: + import octoprint_setuptools +except: + print( + "Could not import OctoPrint's setuptools, are you sure you are running that under " + "the same python installation that OctoPrint is installed under?" + ) + import sys + + sys.exit(-1) + +setup_parameters = octoprint_setuptools.create_plugin_setup_parameters( + identifier=plugin_identifier, + package=plugin_package, + name=plugin_name, + version=plugin_version, + description=plugin_description, + author=plugin_author, + mail=plugin_author_email, + url=plugin_url, + license=plugin_license, + requires=plugin_requires, + additional_packages=plugin_additional_packages, + ignored_packages=plugin_ignored_packages, + additional_data=plugin_additional_data, +) + +if len(additional_setup_parameters): + from octoprint.util import dict_merge + + setup_parameters = dict_merge(setup_parameters, additional_setup_parameters) + +setup(**setup_parameters) diff --git a/translations/README.txt b/translations/README.txt new file mode 100644 index 0000000..077f131 --- /dev/null +++ b/translations/README.txt @@ -0,0 +1,28 @@ +Your plugin's translations will reside here. The provided setup.py supports a +couple of additional commands to make managing your translations easier: + +babel_extract + Extracts any translateable messages (marked with Jinja's `_("...")` or + JavaScript's `gettext("...")`) and creates the initial `messages.pot` file. +babel_refresh + Reruns extraction and updates the `messages.pot` file. +babel_new --locale= + Creates a new translation folder for locale ``. +babel_compile + Compiles the translations into `mo` files, ready to be used within + OctoPrint. +babel_pack --locale= [ --author= ] + Packs the translation for locale `` up as an installable + language pack that can be manually installed by your plugin's users. This is + interesting for languages you can not guarantee to keep up to date yourself + with each new release of your plugin and have to depend on contributors for. + +If you want to bundle translations with your plugin, create a new folder +`octoprint_bambu_printer/translations`. When that folder exists, +an additional command becomes available: + +babel_bundle --locale= + Moves the translation for locale `` to octoprint_bambu_printer/translations, + effectively bundling it with your plugin. This is interesting for languages + you can guarantee to keep up to date yourself with each new release of your + plugin.