Update for RRF3.6.0-rc1

Author: AndyEveritt

examples/send_simple_code.py

@@ -14,6 +14,7 @@ def send_simple_code():
     command_connection.connect()
 
     try:
+        # res = command_connection.set_plugin_data("ExecOnMcode", "test", "1")
         # Perform a simple command and wait for its output
         res = command_connection.perform_simple_code("M115")
         print("M115 is telling us:", res)

examples/subscribe_object_model.py

@@ -22,7 +22,10 @@ def subscribe():
         # subset of the object model will be updated
         for _ in range(0, 3):
             update = subscribe_connection.get_object_model_patch()
+            object_model.update_from_json(update)
             print(update)
+    except Exception as e:
+        print(f"An error occurred: {e}")
     finally:
         subscribe_connection.close()
 

src/dsf/object_model/job/gcode_fileinfo.py

@@ -11,6 +11,7 @@ class GCodeFileInfo(ModelObject):
 
     def __init__(self):
         super().__init__()
+        self._custom_info = {}
         self._filament = []
         self._file_name = ""
         self._generated_by = ""
@@ -23,6 +24,11 @@ def __init__(self):
         self._size = 0
         self._thumbnails = ModelCollection(ThumbnailInfo)
 
+    @property
+    def custom_info(self) -> dict:
+        """Custom information extracted from the G-code file"""
+        return self._custom_info
+
     @property
     def filament(self) -> List[float]:
         """Filament consumption per extruder drive (in mm)"""

src/dsf/object_model/model_collection.py

@@ -1,25 +1,27 @@
+from typing import Generic, TypeVar, Type, List, Dict, Any, Union, Optional
 from .utils import is_model_object
 
+T = TypeVar('T')
 
-class ModelCollection(list):
+
+class ModelCollection(Generic[T], list):
     """
     Class for storing model object items in a list
     Useful for updating model object items from JSON data (patches)
     """
 
-    def __init__(self, item_constructor, value=None):
+    def __init__(self, item_constructor: Type[T], value: Optional[List[T]] = None) -> None:
         """
-
         :param item_constructor: Item constructor type that items must derive from
         :param value: Value used to initialize the list from
         """
         super().__init__()
-        self._item_constructor = item_constructor
+        self._item_constructor: Type[T] = item_constructor
 
         if value is not None:
             self[:] = value
 
-    def update_from_json(self, json_element):
+    def update_from_json(self, json_element: List[Any]) -> 'ModelCollection[T]':
         """
         Update this instance from the given data
         :param json_element: JSON data to upgrade this instance from

src/dsf/object_model/move/axis.py

@@ -86,6 +86,8 @@ def __init__(self):
         self._percent_current = 100
         # Percentage applied to the motor current during standstill (0..100 or None if not supported)
         self._percent_stst_current = None
+        # Motor jerk during the current print only (in mm/s)
+        self._printing_jerk = None
         # Reduced accelerations used by Z probing and stall homing moves (in mm/s^2)
         self._reduced_acceleration = 0
         # Maximum speed (in mm/min)
@@ -242,6 +244,15 @@ def percent_stst_current(self) -> Union[int, None]:
     def percent_stst_current(self, value):
         self._percent_stst_current = int(value) if value is not None else None
 
+    @property
+    def printing_jerk(self) -> Union[float, None]:
+        """Motor jerk during the current print only (in mm/s)"""
+        return self._printing_jerk
+
+    @printing_jerk.setter
+    def printing_jerk(self, value):
+        self._printing_jerk = float(value) if value is not None else None
+
     @property
     def reduced_acceleration(self) -> float:
         """Reduced accelerations used by Z probing and stall homing moves (in mm/s^2)"""

src/dsf/object_model/move/extruder.py

@@ -41,6 +41,8 @@ def __init__(self):
         self._position = 0
         # Pressure advance
         self._pressure_advance = 0
+        # Motor jerk during the current print only (in mm/s)
+        self._printing_jerk = None
         # Raw extruder position as commanded by the slicer without extrusion factor applied (in mm)
         self._raw_position = 0
         # Maximum speed (in mm/s)
@@ -148,6 +150,15 @@ def pressure_advance(self) -> float:
     def pressure_advance(self, value):
         self._pressure_advance = float(value)
 
+    @property
+    def printing_jerk(self) -> Union[float, None]:
+        """Motor jerk during the current print only (in mm/s)"""
+        return self._printing_jerk
+
+    @printing_jerk.setter
+    def printing_jerk(self, value):
+        self._printing_jerk = float(value) if value is not None else None
+
     @property
     def raw_position(self) -> float:
         """Raw extruder position as commanded by the slicer without extrusion factor applied (in mm)"""

src/dsf/object_model/move/input_shaping.py

@@ -40,13 +40,10 @@ def __init__(self):
         self._amplitudes = []
         # Damping factor
         self._damping = 0.1
-        # Input shaper durations (in s)
-        self._durations = []
+        # Input shaper delays (in s)
+        self._delays = []
         # Frequency (in Hz)
         self._frequency = 40
-        # Minimum fraction of the original acceleration or feed rate to which the acceleration or
-        # feed rate may be reduced in order to apply input shaping
-        self._reduction_limit = 0.25
         # Configured input shaping type
         self._type = InputShapingType.none
 
@@ -65,9 +62,9 @@ def damping(self, value):
         self._damping = float(value)
 
     @property
-    def durations(self) -> List[float]:
-        """Input shaper durations (in s)"""
-        return self._durations
+    def delays(self) -> List[float]:
+        """Input shaper delays (in s)"""
+        return self._delays
 
     @property
     def frequency(self) -> float:
@@ -78,16 +75,6 @@ def frequency(self) -> float:
     def frequency(self, value):
         self._frequency = float(value)
 
-    @property
-    def reduction_limit(self) -> float:
-        """Minimum fraction of the original acceleration or feed rate to which the acceleration or
-        feed rate may be reduced in order to apply input shaping"""
-        return self._reduction_limit
-
-    @reduction_limit.setter
-    def reduction_limit(self, value):
-        self._reduction_limit = float(value)
-
     @property
     def type(self) -> InputShapingType:
         """Configured input shaping type"""

src/dsf/object_model/network/network_interface.py

@@ -4,6 +4,7 @@
 from .network_protocol import NetworkProtocol
 from .network_state import NetworkState
 from ..model_object import ModelObject
+from ...utils import deprecated
 
 
 class NetworkInterface(ModelObject):
@@ -27,6 +28,8 @@ def __init__(self):
         self._mac = ""
         # Number of reconnect attempts or null if unknown
         self._num_reconnects = None
+        # Received signal strength indicator of the WiFi adapter (only WiFi, in dBm, or null if unknown)
+        self._rssi = None
         # Signal of the Wi-Fi adapter (only Wi-Fi, in dBm, or null if unknown)
         self._signal = None
         # Speed of the network interface (in MBit, null if unknown, 0 if not connected)
@@ -112,10 +115,20 @@ def num_reconnects(self, value):
         self._num_reconnects = int(value) if value is not None else None
 
     @property
+    def rssi(self) -> Union[int, None]:
+        """Received signal strength indicator of the WiFi adapter (only WiFi, in dBm, or None if unknown)"""
+        return self._rssi
+
+    @rssi.setter
+    def rssi(self, value):
+        self._rssi = int(value) if value is not None else None
+
+    @property
+    @deprecated(f"Use '{__name__}.rssi' instead.")
     def signal(self) -> Union[int, None]:
         """Signal of the Wi-Fi adapter (only Wi-Fi, in dBm, or null if unknown)"""
         return self._signal
-    
+
     @signal.setter
     def signal(self, value):
         self._signal = int(value) if value is not None else None

src/dsf/object_model/sensors/analog_sensor.py

@@ -12,7 +12,9 @@ def __init__(self):
         super(AnalogSensor, self).__init__()
         self._beta = None
         self._c = None
+        self._high_reading = None
         self._last_reading = None
+        self._low_reading = None
         self._name = None
         self._offset_adj = 0.0
         self._port = None
@@ -40,6 +42,15 @@ def c(self) -> Union[float, None]:
     def c(self, value):
         self._c = float(value) if value is not None else None
 
+    @property
+    def high_reading(self) -> Union[float, None]:
+        """High sensor reading (only linear analog sensors, otherwise null)"""
+        return self._high_reading
+
+    @high_reading.setter
+    def high_reading(self, value):
+        self._high_reading = float(value) if value is not None else None
+
     @property
     def last_reading(self) -> Union[float, None]:
         """Last sensor reading (in C) or null if invalid"""
@@ -48,6 +59,15 @@ def last_reading(self) -> Union[float, None]:
     @last_reading.setter
     def last_reading(self, value):
         self._last_reading = float(value) if value is not None else None
+
+    @property
+    def low_reading(self) -> Union[float, None]:
+        """Low sensor reading (only linear analog sensors, otherwise null)"""
+        return self._low_reading
+
+    @low_reading.setter
+    def low_reading(self, value):
+        self._low_reading = float(value) if value is not None else None
 
     @property
     def name(self) -> Union[str, None]:

src/dsf/object_model/sensors/filament_monitors/Duet3DFilamentMonitor.py

@@ -17,6 +17,8 @@ def __init__(self, type_: FilamentMonitorType = FilamentMonitorType.Unknown):
         self._max_percentage = None
         # Minimum ratio of measured vs. commanded movement
         self._min_percentage = None
+        # Position of the sensor (in mm)
+        self._position = 0
         # Total extrusion commanded (in mm)
         self._total_extrusion = 0
 
@@ -55,6 +57,15 @@ def min_percentage(self) -> Union[int, None]:
     @min_percentage.setter
     def min_percentage(self, value):
         self._min_percentage = None if value is None else int(value)
+
+    @property
+    def position(self) -> float:
+        """Position of the sensor (in mm)"""
+        return self._position
+
+    @position.setter
+    def position(self, value):
+        self._position = float(value)
 
     @property
     def total_extrusion(self) -> float: