SW-1242 release v0.10.4 (mrbeam#1472)

Author: JFSolution

octoprint_mrbeam/__init__.py

@@ -243,10 +243,10 @@ def initialize(self):
         self.led_event_listener.set_fps(self._settings.get(["leds", "fps"]))
         # start iobeam socket only once other handlers are already initialized so that we can handle info message
         self.iobeam = ioBeamHandler(self)
-        self.temperature_manager = temperatureManager(self)
         self.dust_manager = dustManager(self)
         self.hw_malfunction_handler = hwMalfunctionHandler(self)
         self.laserhead_handler = laserheadHandler(self)
+        self.temperature_manager = temperatureManager(self)
         self.compressor_handler = compressor_handler(self)
         self.wizard_config = WizardConfig(self)
         self.job_time_estimation = JobTimeEstimation(self)

octoprint_mrbeam/__version.py

@@ -1 +1 @@
-__version__ = "0.10.3"
+__version__ = "0.10.4"

octoprint_mrbeam/analytics/timer_handler.py

@@ -1,4 +1,5 @@
 # coding=utf-8
+import re
 
 import netifaces
 import requests
@@ -215,7 +216,7 @@ def _software_versions(self):
         it made sens when we did a filesystem checksum calculation... _software_versions_and_checksums()
         """
         sw_versions = self._get_software_versions()
-        self._logger.debug("_software_versions: %s", sw_versions)
+        self._logger.debug("Software Version info: \n{}".format(sw_versions))
         self._plugin.analytics_handler.add_software_versions(sw_versions)
 
     def _software_versions_and_checksums(self):
@@ -279,31 +280,38 @@ def _software_versions_and_checksums(self):
 
     def _get_software_versions(self):
         result = dict()
-        configured_checks = None
+        software_info = None
+
         try:
-            pluginInfo = self._plugin._plugin_manager.get_plugin_info("softwareupdate")
-            if pluginInfo is not None:
-                impl = pluginInfo.implementation
-                configured_checks = impl._configured_checks
-            else:
-                self._logger.error(
-                    "_get_software_versions() Can't get pluginInfo.implementation"
-                )
+            plugin_info = self._plugin._plugin_manager.get_plugin_info("softwareupdate")
+            impl = plugin_info.implementation
+            # using the method get_current_versions() is OK as it is threadsafe
+            software_info, _, _ = impl.get_current_versions()
+            self._logger.debug("Software_info: \n {}".format(software_info))
         except Exception as e:
             self._logger.exception(
-                "Exception while reading configured_checks from softwareupdate plugin. "
+                "Exception while reading software_info from softwareupdate plugin. Error:{} ".format(e)
             )
+            return result
 
-        if configured_checks is None:
+        if isinstance(software_info, dict) is False:
             self._logger.warn(
-                "_get_software_versions() Can't read software version from softwareupdate plugin."
+                "get_current_versions() Can't read software version from softwareupdate plugin."
+            )
+            return result
+
+        # Reaching this section means we are OK so far
+        for name, info in software_info.iteritems():
+            commit_hash = info["information"]["local"].get("name", None)
+            if commit_hash is not None:
+                # regex: "Commit 89nhfbffnf7f8fbfgfndhf" --> "89nhfbffnf7f8fbfgfndhf"
+                regex_match = re.match(r"Commit (\S+)", commit_hash)
+                if regex_match is not None:
+                    commit_hash = regex_match.group(1)
+            result[name] = dict(
+                version=info.get("displayVersion", None),
+                commit_hash=commit_hash,
             )
-        else:
-            for name, config in configured_checks.iteritems():
-                result[name] = dict(
-                    version=config.get("displayVersion", None),
-                    commit_hash=config.get("current", None),
-                )
         return result
 
     def _num_files(self):

octoprint_mrbeam/iobeam/iobeam_handler.py

@@ -62,6 +62,7 @@ class IoBeamValueEvents(object):
     FAN_FACTOR_RESPONSE = "iobeam.fan.factor.response"
     COMPRESSOR_STATIC = "iobeam.compressor.static"
     COMPRESSOR_DYNAMIC = "iobeam.compressor.dynamic"
+    LASERHEAD_CHANGED = "iobeam.laserhead.changed"
 
 
 class IoBeamHandler(object):

octoprint_mrbeam/iobeam/laserhead_handler.py

@@ -3,6 +3,9 @@
 import re
 from octoprint_mrbeam.mrb_logger import mrb_logger
 from octoprint_mrbeam.mrbeam_events import MrBeamEvents
+from octoprint_mrbeam.iobeam.iobeam_handler import IoBeamValueEvents
+
+LASERHEAD_MAX_TEMP_FALLBACK = 55.0
 
 # singleton
 _instance = None
@@ -30,6 +33,7 @@ def __init__(self, plugin):
         self._settings = plugin._settings
         self._event_bus = plugin._event_bus
         self._plugin_version = plugin.get_plugin_version()
+        self._iobeam = None
 
         self._lh_cache = {}
         self._last_used_lh_serial = None
@@ -74,6 +78,7 @@ def _on_mrbeam_plugin_initialized(self, event, payload):
         _ = event
         _ = payload
         self._analytics_handler = self._plugin.analytics_handler
+        self._iobeam = self._plugin.iobeam
 
     def _get_lh_model(self, lh_data):
         try:
@@ -92,19 +97,25 @@ def _get_lh_model(self, lh_data):
             )
 
     def set_current_used_lh_data(self, lh_data):
+        laser_head_model_changed = False
+
         try:
             if self._valid_lh_data(lh_data):
                 self._current_used_lh_serial = lh_data["main"]["serial"]
                 self._current_used_lh_model_id = self._get_lh_model(lh_data)
                 self._current_used_lh_model = self._LASERHEAD_MODEL_STRING_MAP[str(self._current_used_lh_model_id)]
                 # fmt: off
+                if(self._current_used_lh_model_id != self._last_used_lh_model_id) \
+                        and self._current_used_lh_model_id is not None:
+                    laser_head_model_changed = True
+
                 if (self._current_used_lh_serial != self._last_used_lh_serial) and self._last_used_lh_model_id is not None:
                     # fmt: on
                     if self._current_used_lh_model_id == 1:
                         self._settings.set_boolean(["laserheadChanged"], True)
                         self._settings.save()
                     self._logger.info(
-                        "Laserhead changed: s/n:%s model:%s -> s/n:%s model:%s",
+                        "laserhead_handler: Laserhead changed: s/n:%s model:%s -> s/n:%s model:%s",
                         self._last_used_lh_serial,
                         self._last_used_lh_model_id,
                         self._current_used_lh_serial,
@@ -124,6 +135,21 @@ def set_current_used_lh_data(self, lh_data):
                     ),
                 )
 
+                if laser_head_model_changed:
+                    # Now all the information about the new laser head should be present Thus we can fire this event
+                    self._logger.info(
+                        "laserhead_handler: Laserhead Model changed: s/n:%s model:%s -> s/n:%s model:%s",
+                        self._last_used_lh_serial,
+                        self._last_used_lh_model_id,
+                        self._current_used_lh_serial,
+                        self._current_used_lh_model_id,
+                    )
+                    # Fire the event
+                    self._iobeam._call_callback(
+                        IoBeamValueEvents.LASERHEAD_CHANGED,
+                        "Laserhead Model changed",
+                    )
+
             # BACKWARD_COMPATIBILITY: This is for detecting mrb_hw_info v0.0.20
             # This part of the code should never by reached, if reached then this means an update for mrb_hw_info did
             # fail TODO Remove this part of the code later
@@ -407,3 +433,79 @@ def _write_laser_heads_file(self, laser_heads_file=None):
                 self._logger.info("Writing to file: {} ..is successful!".format(laser_heads_file))
         except IOError as e:
             self._logger.error("Can't open file: {} , Due to error: {}: ".format(laser_heads_file, e))
+
+    @property
+    def current_laserhead_max_temperature(self):
+        """
+        Return the current laser head max temperature
+
+        Returns:
+            float: Laser head max temp
+
+        """
+        current_laserhead_properties = self._load_current_laserhead_properties()
+
+        # Handle the exceptions
+        if((isinstance(current_laserhead_properties, dict) is False) or
+                ("max_temperature" not in current_laserhead_properties) or
+                (isinstance(current_laserhead_properties["max_temperature"], float) is False)):
+            # Apply fallback
+            self._logger.debug("Current laserhead properties: {}".format(current_laserhead_properties))
+            self._logger.exception(
+                "Current Laserhead Max temp couldn't be retrieved, fallback to the temperature value of: {}".format(
+                    self.default_laserhead_max_temperature))
+            return self.default_laserhead_max_temperature
+        # Reaching here means, everything looks good
+        self._logger.debug("Current Laserhead Max temp:{}".format(current_laserhead_properties["max_temperature"]))
+        return current_laserhead_properties["max_temperature"]
+
+    @property
+    def default_laserhead_max_temperature(self):
+        """
+        Default max temperature for laser head. to be used by other modules at init time
+
+        Returns:
+            float: Laser head default max temp
+        """
+
+        return LASERHEAD_MAX_TEMP_FALLBACK
+
+    def _load_current_laserhead_properties(self):
+        """
+        Loads the current detected laser head related properties and return them
+
+        Returns:
+            dict: current laser head properties, None: otherwise
+
+        """
+        # 1. get the ID of the current laser head
+        laserhead_id = self.get_current_used_lh_model_id()
+
+        # 2. Load the corresponding yaml file and return it's content
+        lh_properties_file_path = os.path.join(self._plugin._basefolder,
+                                               "profiles", "laserhead", "laserhead_id_{}.yaml".format(laserhead_id))
+        if not os.path.isfile(lh_properties_file_path):
+            self._logger.exception(
+                "properties file for current laser head ID: {} doesn't exist or path is invalid. Path: {}".format(
+                    laserhead_id, lh_properties_file_path))
+            return None
+
+        self._logger.debug(
+            "properties file for current laser head ID: {} exists. Path:{}".format(
+                laserhead_id, lh_properties_file_path) )
+        try:
+            with open(lh_properties_file_path) as lh_properties_yaml_file:
+                self._logger.debug(
+                    "properties file for current laser head ID: {} opened successfully".format(
+                        laserhead_id))
+                return yaml.safe_load(lh_properties_yaml_file)
+        except (IOError, yaml.YAMLError) as e:
+            self._logger.exception(
+                "Exception: {} while Opening or loading the properties file for current laser head. Path: {}".format(
+                    e, lh_properties_file_path))
+            return None
+
+
+
+
+

octoprint_mrbeam/iobeam/temperature_manager.py

@@ -28,11 +28,7 @@ def __init__(self, plugin):
         self._event_bus = plugin._event_bus
         self.temperature = None
         self.temperature_ts = 0
-        self.temperature_max = (
-            plugin.laserCutterProfileManager.get_current_or_default()["laser"][
-                "max_temperature"
-            ]
-        )
+        self.temperature_max = plugin.laserhead_handler.current_laserhead_max_temperature
         self.hysteresis_temperature = (
             plugin.laserCutterProfileManager.get_current_or_default()["laser"][
                 "hysteresis_temperature"
@@ -55,7 +51,7 @@ def __init__(self, plugin):
 
         self.dev_mode = plugin._settings.get_boolean(["dev", "iobeam_disable_warnings"])
 
-        msg = "TemperatureManager initialized. temperature_max: {max}, {key}: {value}".format(
+        msg = "TemperatureManager: initialized. temperature_max: {max}, {key}: {value}".format(
             max=self.temperature_max,
             key="cooling_duration"
             if self.mode_time_based
@@ -74,14 +70,16 @@ def _on_mrbeam_plugin_initialized(self, event, payload):
         self._iobeam = self._plugin.iobeam
         self._analytics_handler = self._plugin.analytics_handler
         self._one_button_handler = self._plugin.onebutton_handler
-
+        self._subscribe()
         self._start_temp_timer()
 
-        self._subscribe()
+
 
     def _subscribe(self):
         self._iobeam.subscribe(IoBeamValueEvents.LASER_TEMP, self.handle_temp)
 
+        self._iobeam.subscribe(IoBeamValueEvents.LASERHEAD_CHANGED, self.reset)
+
         self._event_bus.subscribe(OctoPrintEvents.PRINT_DONE, self.onEvent)
         self._event_bus.subscribe(OctoPrintEvents.PRINT_FAILED, self.onEvent)
         self._event_bus.subscribe(OctoPrintEvents.PRINT_CANCELLED, self.onEvent)
@@ -90,12 +88,9 @@ def _subscribe(self):
     def shutdown(self):
         self._shutting_down = True
 
-    def reset(self):
-        self.temperature_max = (
-            self._plugin.laserCutterProfileManager.get_current_or_default()["laser"][
-                "max_temperature"
-            ]
-        )
+    def reset(self, kwargs):
+        self._logger.info("TemperatureManager: Reset trigger Received : {}".format(kwargs.get("event", None)))
+        self.temperature_max = self._plugin.laserhead_handler.current_laserhead_max_temperature
         self.hysteresis_temperature = (
             self._plugin.laserCutterProfileManager.get_current_or_default()["laser"][
                 "hysteresis_temperature"
@@ -109,15 +104,28 @@ def reset(self):
         self.mode_time_based = self.cooling_duration > 0
         self.is_cooling_since = 0
 
+        msg = "TemperatureManager: Reset Done. temperature_max: {max}, {key}: {value}".format(
+            max=self.temperature_max,
+            key="cooling_duration"
+            if self.mode_time_based
+            else "hysteresis_temperature",
+            value=self.cooling_duration
+            if self.mode_time_based
+            else self.hysteresis_temperature,
+        )
+        self._logger.info(msg)
+
     def onEvent(self, event, payload):
+        self._logger.debug("TemperatureManager: Event received: {}".format(event))
         if event == IoBeamValueEvents.LASER_TEMP:
             self.handle_temp(payload)
         elif event in (
             OctoPrintEvents.PRINT_DONE,
             OctoPrintEvents.PRINT_FAILED,
             OctoPrintEvents.PRINT_CANCELLED,
         ):
-            self.reset()
+
+            self.reset({"event": event})
         elif event == OctoPrintEvents.SHUTDOWN:
             self.shutdown()
 

octoprint_mrbeam/printing/profiles/default.py

@@ -18,7 +18,7 @@
     # if set to onebutton, MR Beam 2 One Button to start laser is activated.
     start_method="onebutton",
     laser=dict(
-        max_temperature=55.0,
+        max_temperature=55.0,   # deprecated, moved to iobeam.laserhead_handler in SW-1077
         hysteresis_temperature=48.0,
         cooling_duration=25,  # if set to positive values: enables time based cooling resuming rather that per hysteresis_temperature
         intensity_factor=13,  # to get from 100% intesity to GCODE-intensity of 1300

octoprint_mrbeam/profiles/laserhead/laserhead_id_0.yaml

@@ -0,0 +1 @@
+max_temperature: 55.0

octoprint_mrbeam/profiles/laserhead/laserhead_id_1.yaml

@@ -0,0 +1 @@
+max_temperature: 59.0