default compilation target -> xdp

CHANGELOG.md

@@ -1,19 +1,3 @@
-# `2.12.0`
-_17.11.2025_
-
-## General
-- [#847](https://github.com/qitechgmbh/control/pull/847) Improved discovery and initialization 
-- [#859](https://github.com/qitechgmbh/control/pull/859) Improved update speed
-- [#897](https://github.com/qitechgmbh/control/pull/897), [#899](https://github.com/qitechgmbh/control/pull/899), [#852](https://github.com/qitechgmbh/control/pull/852)  Improved system stability
-- [#817](https://github.com/qitechgmbh/control/pull/817) Added an update bar
-
-## Laser
-- [#857](https://github.com/qitechgmbh/control/pull/857) Fixed potential issues with 2 Axis Laser
-
-## Extruder V2
-- [#881](https://github.com/qitechgmbh/control/pull/881) Extended Temperature PID Configuration
-
-
 # `2.11.0`
 _21.10.2025_
 

Cargo.toml

@@ -4,11 +4,8 @@ members = [
     "ethercat-hal",
     "ethercat-hal-derive",
     "control-core",
-    "machines",
-    #"ethercat-eeprom-dump",
+    "ethercat-eeprom-dump",
     "control-core-derive",
-    "units",
-    "utils",
 ]
 exclude = []
 resolver = "2"

cargo_run_linux.sh

@@ -15,7 +15,7 @@ if [[ "$1" == "release" ]]; then
     cargo build --release
 else
     echo "Building Debug Code"
-    cargo build $FEATURE --features development-build
+    cargo build $FEATURE
 fi
 
 # Only setcap if not building with mock-machine

control-core/Cargo.toml

@@ -12,15 +12,17 @@ anyhow = "1.0.100"
 axum = "0.8.6"
 
 ethercat_hal = { path = "../ethercat-hal" }
-units = { path = "../units" }
-ethercrab = "0.6"
+ethercrab = { git = "https://github.com/ethercrab-rs/ethercrab", branch = "main", features = ["xdp"] }
 interfaces = "0.0.9"
 serde = "1.0.219"
+serde_json = "1.0.143"
 serialport = "4.7.3"
 smol = "2.0.2"
 socketioxide = "0.17.2"
+uom = { version = "0.36.0", default-features = false, features = ["f64"] }
 bitvec = { version = "1.0.1", features = ["alloc"] }
 crc = "3.3.0"
+serial = "0.4.0"
 tracing = "0.1.41"
 erased-serde = "0.4.8"
 core_affinity = "0.8.3"

control-core/src/controllers/first_degree_motion/angular_acceleration_speed_controller.rs

@@ -1,6 +1,6 @@
 use std::time::Instant;
 
-use units::{
+use uom::si::{
     angular_acceleration::radian_per_second_squared,
     angular_velocity::radian_per_second,
     f64::{AngularAcceleration, AngularVelocity},

control-core/src/controllers/first_degree_motion/linear_acceleration_speed_controller.rs

@@ -1,6 +1,6 @@
 use std::time::Instant;
 
-use units::{
+use uom::si::{
     acceleration::meter_per_second_squared,
     f64::{Acceleration, Velocity},
     velocity::meter_per_second,

control-core/src/controllers/second_degree_motion/angular_acceleration_position_controller.rs

@@ -1,6 +1,6 @@
 use std::time::Instant;
 
-use units::{
+use uom::si::{
     angle::radian,
     angular_acceleration::radian_per_second_squared,
     angular_velocity::radian_per_second,
@@ -199,8 +199,8 @@ impl AngularAccelerationPositionController {
     /// # Example
     /// ```ignore
     /// use control_core::controllers::second_degree_motion::angular_acceleration_position_controller::AngularAccelerationPositionController;
-    /// use units::f64::Angle;
-    /// use units::angle::degree;
+    /// use uom::si::f64::Angle;
+    /// use uom::si::angle::degree;
     ///
     /// let mut controller = AngularAccelerationPositionController::new_simple(
     ///     Some(Angle::new::<degree>(180.0)),

control-core/src/controllers/second_degree_motion/angular_jerk_speed_controller.rs

@@ -1,6 +1,6 @@
 use std::time::Instant;
 
-use units::{
+use uom::si::{
     angular_acceleration::radian_per_second_squared,
     angular_jerk::radian_per_second_cubed,
     angular_velocity::radian_per_second,
@@ -23,7 +23,7 @@ use super::jerk_speed_controller::JerkSpeedController;
 ///
 /// # Example
 /// ```ignore
-/// use units::{
+/// use uom::si::{
 ///     angular_velocity::revolution_per_minute,
 ///     angular_acceleration::revolution_per_minute_per_second,
 ///     angular_jerk::revolution_per_minute_per_second_squared,
@@ -65,7 +65,7 @@ impl AngularJerkSpeedController {
     ///
     /// # Example
     /// ```ignore
-    /// use units::{
+    /// use uom::si::{
     ///     angular_velocity::revolution_per_minute,
     ///     angular_acceleration::revolution_per_minute_per_second,
     ///     angular_jerk::revolution_per_minute_per_second_squared,
@@ -127,7 +127,7 @@ impl AngularJerkSpeedController {
     ///
     /// # Example
     /// ```ignore
-    /// use units::{
+    /// use uom::si::{
     ///     angular_velocity::revolution_per_minute,
     ///     angular_acceleration::revolution_per_minute_per_second,
     ///     angular_jerk::revolution_per_minute_per_second_squared,
@@ -185,7 +185,7 @@ impl AngularJerkSpeedController {
     /// # Example
     /// ```ignore
     /// use std::time::Instant;
-    /// use units::{angular_velocity::revolution_per_minute, f64::AngularVelocity};
+    /// use uom::si::{angular_velocity::revolution_per_minute, f64::AngularVelocity};
     ///
     /// let mut controller = AngularJerkSpeedController::new_simple(/* ... */);
     /// let target = AngularVelocity::new::<revolution_per_minute>(1500.0);

control-core/src/controllers/second_degree_motion/linear_acceleration_position_controller.rs

@@ -1,6 +1,6 @@
 use std::time::Instant;
 
-use units::{
+use uom::si::{
     acceleration::meter_per_second_squared,
     f64::{Acceleration, Length, Velocity},
     length::meter,
@@ -22,8 +22,8 @@ use super::acceleration_position_controller::{
 ///
 /// # Example
 /// ```ignore
-/// use units::{length::meter, velocity::meter_per_second, acceleration::meter_per_second_squared};
-/// use units::f64::{Length, Velocity, Acceleration};
+/// use uom::si::{length::meter, velocity::meter_per_second, acceleration::meter_per_second_squared};
+/// use uom::si::f64::{Length, Velocity, Acceleration};
 ///
 /// let position_limit = Length::new::<meter>(10.0);
 /// let max_speed = Velocity::new::<meter_per_second>(2.0);
@@ -101,8 +101,8 @@ impl LinearAccelerationPositionController {
     ///
     /// # Example
     /// ```ignore
-    /// use units::{length::meter, velocity::meter_per_second, acceleration::meter_per_second_squared};
-    /// use units::f64::{Length, Velocity, Acceleration};
+    /// use uom::si::{length::meter, velocity::meter_per_second, acceleration::meter_per_second_squared};
+    /// use uom::si::f64::{Length, Velocity, Acceleration};
     ///
     /// let position_limit = Length::new::<meter>(5.0);  // Creates [-5.0, +5.0] meter range
     /// let max_speed = Velocity::new::<meter_per_second>(1.0);  // Creates [-1.0, +1.0] m/s range
@@ -150,7 +150,7 @@ impl LinearAccelerationPositionController {
     /// # Example
     /// ```ignore
     /// use std::time::Instant;
-    /// use units::{length::meter, f64::Length};
+    /// use uom::si::{length::meter, f64::Length};
     ///
     /// let mut controller = LinearAccelerationPositionController::new_simple(
     ///     Some(Length::new::<meter>(10.0)),
@@ -375,7 +375,7 @@ impl LinearAccelerationPositionController {
     ///
     /// # Example
     /// ```ignore
-    /// use units::{length::meter, velocity::meter_per_second, f64::{Length, Velocity}};
+    /// use uom::si::{length::meter, velocity::meter_per_second, f64::{Length, Velocity}};
     ///
     /// let new_position = Length::new::<meter>(0.0);
     ///

control-core/src/controllers/second_degree_motion/linear_jerk_speed_controller.rs

@@ -1,6 +1,6 @@
 use std::time::Instant;
 
-use units::{
+use uom::si::{
     acceleration::meter_per_second_squared,
     f64::{Acceleration, Jerk, Velocity},
     jerk::meter_per_second_cubed,
@@ -23,7 +23,7 @@ use super::jerk_speed_controller::JerkSpeedController;
 ///
 /// # Example
 /// ```ignore
-/// use units::{
+/// use uom::si::{
 ///     velocity::meter_per_second,
 ///     acceleration::meter_per_second_squared,
 ///     jerk::meter_per_second_cubed,
@@ -65,7 +65,7 @@ impl LinearJerkSpeedController {
     ///
     /// # Example
     /// ```ignore
-    /// use units::{
+    /// use uom::si::{
     ///     velocity::meter_per_second,
     ///     acceleration::meter_per_second_squared,
     ///     jerk::meter_per_second_cubed,
@@ -127,7 +127,7 @@ impl LinearJerkSpeedController {
     ///
     /// # Example
     /// ```ignore
-    /// use units::{
+    /// use uom::si::{
     ///     velocity::meter_per_second,
     ///     acceleration::meter_per_second_squared,
     ///     jerk::meter_per_second_cubed,

control-core/src/converters/angle_converter.rs

@@ -1,4 +1,4 @@
-use units::{angle::radian, f64::Angle};
+use uom::si::{angle::radian, f64::Angle};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct AngleConverter {

control-core/src/converters/angular_step_converter.rs

@@ -1,4 +1,4 @@
-use units::{
+use uom::si::{
     angle::revolution,
     angular_acceleration::radian_per_second_squared,
     angular_velocity::revolution_per_second,
@@ -90,7 +90,7 @@ mod tests {
     use super::*;
     use approx::assert_relative_eq;
     use std::f64::EPSILON;
-    use units::{
+    use uom::si::{
         angle::degree, angular_acceleration::degree_per_second_squared,
         angular_velocity::degree_per_second,
     };

control-core/src/converters/circular_converter.rs

@@ -14,14 +14,14 @@
 //!
 //! ```rust
 //! use control_core::converters::circular_converter::CircularConverter;
-//! use units::{f64::{Length, Velocity}, length::meter, velocity::meter_per_second};
+//! use uom::si::{f64::{Length, Velocity}, length::meter, velocity::meter_per_second};
 //!
 //! let converter = CircularConverter::from_radius(Length::new::<meter>(0.1));
 //! let velocity = Velocity::new::<meter_per_second>(1.0);
 //! let angular_velocity = converter.linear_to_angular_velocity(velocity);
 //! ```
 
-use units::{
+use uom::si::{
     acceleration::meter_per_second_squared,
     angle::radian,
     angular_acceleration::radian_per_second_squared,
@@ -199,7 +199,7 @@ impl CircularConverter {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use units::length::centimeter;
+    use uom::si::length::centimeter;
 
     #[test]
     fn test_constructors() {

control-core/src/converters/linear_step_converter.rs

@@ -1,4 +1,4 @@
-use units::{
+use uom::si::{
     angle::revolution,
     angular_velocity::revolution_per_second,
     f64::{Acceleration, Angle, AngularAcceleration, AngularVelocity, Length, Velocity},
@@ -251,7 +251,7 @@ mod tests {
     use super::*;
     use approx::assert_relative_eq;
     use std::f64::EPSILON;
-    use units::{
+    use uom::si::{
         acceleration::meter_per_second_squared, angular_acceleration::radian_per_second_squared,
         length::meter, velocity::meter_per_second,
     };

control-core/src/ethercat/eeprom_identification.rs

@@ -1,117 +1,3 @@
-use std::fmt::Display;
-
-use serde::Deserialize;
-use serde::Serialize;
-
-/// Identifies a spacifi machine
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
-pub struct MachineIdentificationUnique {
-    pub machine_identification: MachineIdentification,
-    pub serial: u16,
-}
-
-impl MachineIdentificationUnique {
-    /// Check if values are non-zero
-    pub const fn is_valid(&self) -> bool {
-        self.machine_identification.is_valid() && self.serial != 0
-    }
-}
-
-impl Display for MachineIdentificationUnique {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}/{}/{}",
-            self.machine_identification.vendor, self.machine_identification.machine, self.serial
-        )
-    }
-}
-
-/// Identifies a machine
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
-pub struct MachineIdentification {
-    pub vendor: u16,
-    pub machine: u16,
-}
-
-impl MachineIdentification {
-    /// Check if values are non-zero
-    pub const fn is_valid(&self) -> bool {
-        self.vendor != 0 && self.machine != 0
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct DeviceMachineIdentification {
-    pub machine_identification_unique: MachineIdentificationUnique,
-    pub role: u16,
-}
-
-impl DeviceMachineIdentification {
-    /// Check if values are non-zero
-    pub const fn is_valid(&self) -> bool {
-        self.machine_identification_unique.is_valid()
-            && self
-                .machine_identification_unique
-                .machine_identification
-                .machine
-                != 0
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct DeviceIdentification {
-    pub device_machine_identification: Option<DeviceMachineIdentification>,
-    pub device_hardware_identification: DeviceHardwareIdentification,
-}
-
-impl From<DeviceIdentificationIdentified> for DeviceIdentification {
-    fn from(value: DeviceIdentificationIdentified) -> Self {
-        Self {
-            device_machine_identification: Some(value.device_machine_identification),
-            device_hardware_identification: value.device_hardware_identification,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct DeviceIdentificationIdentified {
-    pub device_machine_identification: DeviceMachineIdentification,
-    pub device_hardware_identification: DeviceHardwareIdentification,
-}
-
-impl TryFrom<DeviceIdentification> for DeviceIdentificationIdentified {
-    type Error = anyhow::Error;
-
-    fn try_from(value: DeviceIdentification) -> Result<Self, Self::Error> {
-        let device_machine_identification =
-            value.device_machine_identification.ok_or(anyhow::anyhow!(
-                "[{}::DeviceIdentificationIdentified::try_from] No device machine identification",
-                module_path!()
-            ))?;
-
-        Ok(Self {
-            device_machine_identification,
-            device_hardware_identification: value.device_hardware_identification,
-        })
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub enum DeviceHardwareIdentification {
-    Ethercat(DeviceHardwareIdentificationEthercat),
-    Serial(DeviceHardwareIdentificationSerial),
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct DeviceHardwareIdentificationEthercat {
-    pub subdevice_index: usize,
-}
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct DeviceHardwareIdentificationSerial {
-    pub path: String,
-}
-
 use anyhow::Error;
 use anyhow::anyhow;
 use ethercat_hal::devices::ek1100::EK1100_IDENTITY_A;
@@ -147,6 +33,10 @@ use ethercat_hal::helpers::ethercrab_types::{
 use ethercrab::MainDevice;
 use ethercrab::SubDeviceIdentity;
 
+use crate::machines::identification::DeviceMachineIdentification;
+use crate::machines::identification::MachineIdentification;
+use crate::machines::identification::MachineIdentificationUnique;
+
 #[derive(Debug)]
 pub struct MachineIdentificationAddresses {
     pub vendor_word: u16,

control-core/src/ethercat/interface_discovery.rs

@@ -1,9 +1,10 @@
+use std::{process::Command, sync::Arc, time::Duration};
+
 use ethercrab::{
     MainDevice, MainDeviceConfig, PduStorage, Timeouts,
     std::{ethercat_now, tx_rx_task},
 };
 use interfaces::Interface;
-use std::{process::Command, sync::Arc, time::Duration};
 
 // Constants for EtherCAT configuration
 const IFACE_DISCOVERY_MAX_SUBDEVICES: usize = 16; // Must be power of 2 > 1
@@ -91,6 +92,9 @@ pub async fn discover_ethercat_interface() -> Result<String, anyhow::Error> {
     let mut interface: Option<&str> = None;
 
     for i in 0..interfaces.len() {
+        // Avoid NetworkManager hangups
+        set_interface_managed(&interfaces[i].name, false);
+
         match test_interface(&interfaces[i].name) {
             Ok(_) => {
                 // if interface found with ethercat Exit early, we expect only one interface with ethercat
@@ -103,7 +107,7 @@ pub async fn discover_ethercat_interface() -> Result<String, anyhow::Error> {
 
     for i in 0..interfaces.len() {
         if interface.is_some() && interface.unwrap() == &interfaces[i].name {
-            set_interface_managed(&interfaces[i].name, false);
+            continue;
         } else {
             set_interface_managed(&interfaces[i].name, true);
         }

control-core/src/ethercat/mod.rs

@@ -1 +1,2 @@
+pub mod eeprom_identification;
 pub mod interface_discovery;

control-core/src/lib.rs

@@ -4,11 +4,17 @@ pub mod downcast;
 pub mod ethercat;
 pub mod helpers;
 pub mod irq_handling;
+pub mod machines;
 pub mod modbus;
 pub mod realtime;
+pub mod rest;
 pub mod serial;
 pub mod socketio;
 pub mod transmission;
+pub mod uom_extensions;
 
 #[cfg(feature = "video-streaming")]
 pub mod video_streaming;
+
+#[macro_use]
+extern crate uom;

control-core/src/machines/api.rs

@@ -0,0 +1,27 @@
+use serde_json::Value;
+use smol::lock::Mutex;
+use std::sync::Arc;
+
+use crate::socketio::namespace::Namespace;
+
+pub trait MachineApi {
+    fn api_mutate(&mut self, value: Value) -> Result<(), anyhow::Error>;
+    fn api_event_namespace(&mut self) -> Arc<Mutex<Namespace>>;
+
+    /// Returns a list of available video stream identifiers for this machine
+    #[cfg(feature = "video-streaming")]
+    fn api_video_streams(&self) -> Vec<String> {
+        Vec::new()
+    }
+
+    /// Get a video stream receiver for the specified stream ID
+    /// Returns None if the stream doesn't exist
+    #[cfg(feature = "video-streaming")]
+    fn api_get_video_stream(
+        &mut self,
+        stream_id: &str,
+    ) -> Option<tokio::sync::broadcast::Receiver<Vec<u8>>> {
+        let _ = stream_id;
+        None
+    }
+}

control-core/src/machines/connection.rs

@@ -0,0 +1,208 @@
+use crate::downcast::Downcast;
+use crate::machines::identification::MachineIdentificationUnique;
+use crate::machines::manager::MachineManager;
+use crate::socketio::{event::GenericEvent, namespace::Namespace};
+use serde::Serialize;
+use smol::block_on;
+use smol::lock::RwLock;
+use std::sync::Arc;
+use std::sync::Weak;
+
+use super::Machine;
+use anyhow::anyhow;
+use smol::{channel::Sender, lock::Mutex};
+use socketioxide::extract::SocketRef;
+
+#[derive(Debug)]
+pub enum MachineConnection<M: Machine + ?Sized>
+where
+    Self: Sized,
+{
+    Error(anyhow::Error),
+    Disconnected,
+    Connected(Arc<Mutex<M>>),
+}
+
+#[derive(Debug)]
+pub struct MachineSlot<M: Machine + ?Sized>
+where
+    Self: Sized,
+{
+    pub machine_connection: MachineConnection<M>,
+    pub namespace: Arc<Mutex<Namespace>>,
+}
+
+pub type MachineConnectionGeneric = MachineConnection<dyn Machine>;
+
+pub type MachineSlotGeneric = MachineSlot<dyn Machine>;
+
+impl<M: Machine> Clone for MachineConnection<M> {
+    fn clone(&self) -> Self {
+        match self {
+            Self::Connected(m) => Self::Connected(m.clone()),
+            Self::Error(e) => Self::Error(anyhow!(e.to_string())),
+            Self::Disconnected => Self::Disconnected,
+        }
+    }
+}
+
+impl<M: Machine + ?Sized> MachineConnection<M> {
+    pub fn to_error(&self) -> Option<anyhow::Error> {
+        match self {
+            MachineConnection::Error(err) => Some(anyhow!(err.to_string())),
+            Self::Disconnected => Some(anyhow!("Machine is disconnected")),
+            _ => None,
+        }
+    }
+
+    pub fn to_machine(&self) -> Option<Arc<Mutex<M>>> {
+        match self {
+            Self::Connected(machine) => Some(machine.clone()),
+            _ => None,
+        }
+    }
+}
+
+impl<M: Machine + ?Sized> MachineSlot<M> {
+    pub fn new(socket_queue_tx: Sender<(SocketRef, Arc<GenericEvent>)>) -> Self {
+        let namespace = Namespace::new(socket_queue_tx);
+        Self {
+            machine_connection: MachineConnection::Disconnected,
+            namespace: Arc::new(Mutex::new(namespace)),
+        }
+    }
+
+    pub const fn is_connected(&self) -> bool {
+        matches!(self.machine_connection, MachineConnection::Connected(_))
+    }
+}
+
+pub trait CrossConnectableMachine<
+    F: CrossConnectableMachine<F, T>,
+    T: CrossConnectableMachine<T, F>,
+>: Machine
+{
+    fn get_cross_connection(&mut self) -> &mut MachineCrossConnection<F, T>;
+}
+
+#[derive(Debug)]
+pub struct MachineCrossConnection<
+    F: CrossConnectableMachine<F, T>,
+    T: CrossConnectableMachine<T, F>,
+> {
+    machine_manager: Weak<RwLock<MachineManager>>,
+    machine_identification_unique: MachineIdentificationUnique,
+    connected_machine: Weak<Mutex<MachineSlot<T>>>,
+    _make_compiler_happy: std::marker::PhantomData<F>, // This marks tells the typechecker, that we
+                                                       // need F in our type arguemnts. We are ok with
+                                                       // it being used only in a fake field. Without
+                                                       // F being fixed, we would not be anble to implement
+                                                       // reverse connecting and disconnecting properly,
+                                                       // as the type on the other side would decay
+                                                       // to an unknown type. See also https://github.com/qitechgmbh/control/pull/625#discussion_r2379566315
+}
+
+#[derive(Serialize, Debug, Clone)]
+pub struct MachineCrossConnectionState {
+    /// Connected Machine
+    pub machine_identification_unique: Option<MachineIdentificationUnique>,
+    pub is_available: bool,
+}
+
+impl<F: CrossConnectableMachine<F, T>, T: CrossConnectableMachine<T, F>>
+    MachineCrossConnection<F, T>
+{
+    pub fn new(
+        manager: Weak<RwLock<MachineManager>>,
+        machine_identification_unique: &MachineIdentificationUnique,
+    ) -> Self {
+        Self {
+            machine_manager: manager,
+            connected_machine: Weak::new(),
+            machine_identification_unique: machine_identification_unique.clone(),
+            _make_compiler_happy: std::marker::PhantomData,
+        }
+    }
+
+    pub fn set_connected_machine(
+        &mut self,
+        machine_identification_unique: &MachineIdentificationUnique,
+    ) {
+        if let Some(machine_manager) = self.machine_manager.upgrade() {
+            let machine_manager = block_on(machine_manager.read());
+
+            let slot: Arc<Mutex<MachineSlotGeneric>> =
+                match machine_manager.get(&machine_identification_unique) {
+                    Some(c) => c,
+                    None => return,
+                };
+
+            let slot: Arc<Mutex<MachineSlot<T>>> = match Downcast::downcast(&slot) {
+                Ok(s) => s,
+                Err(_) => return,
+            };
+
+            self.connected_machine = Arc::downgrade(&slot);
+        } else {
+            panic!("The machine manager has died, cannot do anything at this point");
+        }
+    }
+
+    pub fn reverse_connect(&self) {
+        if let Some(slot) = self.connected_machine.upgrade() {
+            let slot = &mut slot.lock_blocking();
+
+            if let MachineConnection::Connected(machine) = &slot.machine_connection {
+                let mut machine = machine.lock_blocking();
+                let cross_connection = machine.get_cross_connection();
+
+                if !cross_connection.is_connected() {
+                    cross_connection.set_connected_machine(&self.machine_identification_unique);
+                }
+            };
+        }
+    }
+
+    pub fn disconnect(&mut self) {
+        self.connected_machine = Weak::new();
+    }
+
+    pub fn reverse_disconnect(&mut self) {
+        if let Some(slot) = self.connected_machine.upgrade() {
+            let slot = slot.lock_blocking();
+
+            if let MachineConnection::Connected(machine) = &slot.machine_connection {
+                let mut machine = machine.lock_blocking();
+                let cross_connection = machine.get_cross_connection();
+                cross_connection.disconnect();
+            };
+        }
+    }
+
+    pub fn is_connected(&self) -> bool {
+        let arc = self.connected_machine.upgrade();
+        arc.is_some()
+    }
+
+    pub fn to_state(&self) -> MachineCrossConnectionState {
+        if let Some(slot) = self.connected_machine.upgrade() {
+            let connection = &slot.lock_blocking().machine_connection;
+
+            if let MachineConnection::Connected(machine) = connection {
+                let machine = machine.lock_blocking();
+
+                return MachineCrossConnectionState {
+                    machine_identification_unique: Some(
+                        machine.get_machine_identification_unique(),
+                    ),
+                    is_available: true,
+                };
+            }
+        }
+
+        MachineCrossConnectionState {
+            machine_identification_unique: None,
+            is_available: false,
+        }
+    }
+}

control-core/src/machines/identification.rs

@@ -0,0 +1,113 @@
+use std::fmt::Display;
+
+use serde::Deserialize;
+use serde::Serialize;
+
+/// Identifies a spacifi machine
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub struct MachineIdentificationUnique {
+    pub machine_identification: MachineIdentification,
+    pub serial: u16,
+}
+
+impl MachineIdentificationUnique {
+    /// Check if values are non-zero
+    pub const fn is_valid(&self) -> bool {
+        self.machine_identification.is_valid() && self.serial != 0
+    }
+}
+
+impl Display for MachineIdentificationUnique {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}/{}/{}",
+            self.machine_identification.vendor, self.machine_identification.machine, self.serial
+        )
+    }
+}
+
+/// Identifies a machine
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub struct MachineIdentification {
+    pub vendor: u16,
+    pub machine: u16,
+}
+
+impl MachineIdentification {
+    /// Check if values are non-zero
+    pub const fn is_valid(&self) -> bool {
+        self.vendor != 0 && self.machine != 0
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct DeviceMachineIdentification {
+    pub machine_identification_unique: MachineIdentificationUnique,
+    pub role: u16,
+}
+
+impl DeviceMachineIdentification {
+    /// Check if values are non-zero
+    pub const fn is_valid(&self) -> bool {
+        self.machine_identification_unique.is_valid()
+            && self
+                .machine_identification_unique
+                .machine_identification
+                .machine
+                != 0
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct DeviceIdentification {
+    pub device_machine_identification: Option<DeviceMachineIdentification>,
+    pub device_hardware_identification: DeviceHardwareIdentification,
+}
+
+impl From<DeviceIdentificationIdentified> for DeviceIdentification {
+    fn from(value: DeviceIdentificationIdentified) -> Self {
+        Self {
+            device_machine_identification: Some(value.device_machine_identification),
+            device_hardware_identification: value.device_hardware_identification,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct DeviceIdentificationIdentified {
+    pub device_machine_identification: DeviceMachineIdentification,
+    pub device_hardware_identification: DeviceHardwareIdentification,
+}
+
+impl TryFrom<DeviceIdentification> for DeviceIdentificationIdentified {
+    type Error = anyhow::Error;
+
+    fn try_from(value: DeviceIdentification) -> Result<Self, Self::Error> {
+        let device_machine_identification =
+            value.device_machine_identification.ok_or(anyhow::anyhow!(
+                "[{}::DeviceIdentificationIdentified::try_from] No device machine identification",
+                module_path!()
+            ))?;
+
+        Ok(Self {
+            device_machine_identification,
+            device_hardware_identification: value.device_hardware_identification,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum DeviceHardwareIdentification {
+    Ethercat(DeviceHardwareIdentificationEthercat),
+    Serial(DeviceHardwareIdentificationSerial),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct DeviceHardwareIdentificationEthercat {
+    pub subdevice_index: usize,
+}
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct DeviceHardwareIdentificationSerial {
+    pub path: String,
+}

control-core/src/machines/manager.rs

@@ -0,0 +1,297 @@
+use super::{
+    Machine,
+    identification::{DeviceIdentification, DeviceIdentificationIdentified},
+    new::MachineNewHardwareSerial,
+    registry::MachineRegistry,
+};
+use smol::{
+    channel::Sender,
+    lock::{Mutex, RwLock},
+};
+use socketioxide::extract::SocketRef;
+
+use crate::{
+    machines::{
+        connection::{
+            MachineConnection, MachineConnectionGeneric, MachineSlot, MachineSlotGeneric,
+        },
+        identification::MachineIdentificationUnique,
+        new::{MachineNewHardware, MachineNewHardwareEthercat, MachineNewParams},
+    },
+    serial::SerialDevice,
+    socketio::event::GenericEvent,
+};
+use std::{
+    collections::HashMap,
+    sync::{Arc, Weak},
+};
+
+#[derive(Debug)]
+pub struct MachineManager {
+    pub ethercat_machines: HashMap<MachineIdentificationUnique, Arc<Mutex<MachineSlotGeneric>>>,
+    pub serial_machines: HashMap<MachineIdentificationUnique, Arc<Mutex<MachineSlotGeneric>>>,
+}
+
+impl Default for MachineManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl MachineManager {
+    pub fn new() -> Self {
+        Self {
+            ethercat_machines: HashMap::new(),
+            serial_machines: HashMap::new(),
+        }
+    }
+
+    pub fn set_ethercat_devices<const MAX_SUBDEVICES: usize, const MAX_PDI: usize>(
+        &mut self,
+        device_identifications: &Vec<DeviceIdentification>,
+        machine_registry: &MachineRegistry,
+        hardware: &MachineNewHardwareEthercat,
+        socket_queue_tx: Sender<(SocketRef, Arc<GenericEvent>)>,
+        machine_manager: Weak<RwLock<Self>>,
+    ) {
+        // group devices by machine device identification
+        let device_grouping_result = group_devices_by_identification(device_identifications);
+
+        tracing::info!(
+            "Device Groups {}",
+            device_grouping_result.device_groups.len()
+        );
+
+        let machine_new_hardware = MachineNewHardware::Ethercat(hardware);
+
+        // iterate over all identified device groups but ignore unaffected machines
+        for device_group in device_grouping_result.device_groups.iter() {
+            // get the machine identification
+            let machine_identification_unique: MachineIdentificationUnique =
+                match device_group.first() {
+                    Some(device_identification) => device_identification
+                        .device_machine_identification
+                        .machine_identification_unique
+                        .clone(),
+                    None => continue, // Skip this group if empty
+                };
+
+            let slot =
+                self.get_or_create_slot(socket_queue_tx.clone(), machine_identification_unique);
+            let mut slot = slot.lock_blocking();
+
+            // create the machine
+            let new_machine = machine_registry.new_machine(&MachineNewParams {
+                device_group,
+                hardware: &machine_new_hardware,
+                socket_queue_tx: socket_queue_tx.clone(),
+                machine_manager: machine_manager.clone(),
+                namespace: slot.namespace.clone(),
+            });
+
+            slot.machine_connection = match new_machine {
+                Err(err) => MachineConnectionGeneric::Error(err),
+                Ok(machine) => MachineConnectionGeneric::Connected(machine),
+            };
+        }
+    }
+
+    fn get_or_create_slot(
+        &mut self,
+        socket_queue_tx: Sender<(SocketRef, Arc<GenericEvent>)>,
+        machine_identification: MachineIdentificationUnique,
+    ) -> Arc<Mutex<MachineSlotGeneric>> {
+        if let Some(slot) = self.get(&machine_identification) {
+            return slot;
+        }
+
+        let slot = Arc::new(Mutex::new(MachineSlot::new(socket_queue_tx)));
+        self.ethercat_machines
+            .insert(machine_identification, slot.clone());
+
+        return slot;
+    }
+
+    pub fn get(
+        &self,
+        machine_identification: &MachineIdentificationUnique,
+    ) -> Option<Arc<Mutex<MachineSlotGeneric>>> {
+        self.ethercat_machines
+            .get(machine_identification)
+            .or_else(|| self.serial_machines.get(machine_identification))
+            .map(|x| x.clone())
+    }
+
+    pub fn add_serial_device(
+        &mut self,
+        device_identification: &DeviceIdentification,
+        device: Arc<RwLock<dyn SerialDevice>>,
+        machine_registry: &MachineRegistry,
+        socket_queue_tx: Sender<(SocketRef, Arc<GenericEvent>)>,
+        machine_manager: Weak<RwLock<Self>>,
+    ) {
+        let hardware = MachineNewHardwareSerial { device };
+
+        let device_identification_identified: DeviceIdentificationIdentified =
+            device_identification
+                .clone()
+                .try_into()
+                .expect("Serial devices always have machine identification");
+
+        let machine_identification: MachineIdentificationUnique = device_identification_identified
+            .device_machine_identification
+            .machine_identification_unique
+            .clone();
+
+        let slot = self.get_or_create_slot(socket_queue_tx.clone(), machine_identification);
+        let mut slot = slot.lock_blocking();
+
+        let new_machine = machine_registry.new_machine(&MachineNewParams {
+            device_group: &vec![device_identification_identified.clone()],
+            hardware: &MachineNewHardware::Serial(&hardware),
+            socket_queue_tx,
+            machine_manager: machine_manager.clone(),
+            namespace: slot.namespace.clone(),
+        });
+
+        slot.machine_connection = match new_machine {
+            Err(err) => MachineConnectionGeneric::Error(err),
+            Ok(machine) => MachineConnectionGeneric::Connected(machine),
+        };
+
+        tracing::info!("Adding serial machine {:?}", slot);
+    }
+
+    pub fn remove_serial_device(&mut self, device_identification: &DeviceIdentification) {
+        let device_identification_identified: DeviceIdentificationIdentified =
+            device_identification
+                .clone()
+                .try_into()
+                .expect("Serial devices always have machine identification");
+
+        tracing::info!(
+            "Removing serial machine {:?}",
+            device_identification_identified
+        );
+
+        let machine_identification_unique = &device_identification_identified
+            .device_machine_identification
+            .machine_identification_unique;
+
+        if let Some(slot) = self.serial_machines.get(machine_identification_unique) {
+            let mut slot = slot.lock_blocking();
+            slot.machine_connection = MachineConnection::Disconnected;
+        }
+    }
+
+    pub fn get_ethercat_weak(
+        &self,
+        machine_identification: &MachineIdentificationUnique,
+    ) -> Option<Weak<Mutex<dyn Machine>>> {
+        self.get_weak(&self.ethercat_machines, machine_identification)
+    }
+
+    pub fn get_serial_weak(
+        &self,
+        machine_identification: &MachineIdentificationUnique,
+    ) -> Option<Weak<Mutex<dyn Machine>>> {
+        self.get_weak(&self.serial_machines, machine_identification)
+    }
+
+    fn get_weak(
+        &self,
+        machines: &HashMap<MachineIdentificationUnique, Arc<Mutex<MachineSlotGeneric>>>,
+        machine_identification: &MachineIdentificationUnique,
+    ) -> Option<Weak<Mutex<dyn Machine>>> {
+        let slot = machines.get(machine_identification).clone();
+
+        return slot.and_then(|slot| {
+            let connection = &slot.lock_blocking().machine_connection;
+            match connection {
+                MachineConnectionGeneric::Error(_) => None,
+                MachineConnectionGeneric::Disconnected => None,
+                MachineConnectionGeneric::Connected(machine) => Some(Arc::downgrade(&machine)),
+            }
+        });
+    }
+}
+
+/// Groups devices by machine identification
+///
+/// Returns a DeviceGroupingResult containing:
+/// - device_groups: a vector of devices grouped by machine identification
+/// - unidentified_devices: a vector of devices that could not be identified
+pub fn group_devices_by_identification(
+    device_identifications: &Vec<DeviceIdentification>,
+) -> DeviceGroupingResult {
+    let mut device_groups: Vec<Vec<DeviceIdentificationIdentified>> = Vec::new();
+    let mut unidentified_devices: Vec<DeviceIdentification> = Vec::new();
+
+    for device_identification in device_identifications {
+        // if vendor or serial or machine is 0, it is not a valid machine device
+        if let Some(device_machine_identification) =
+            device_identification.device_machine_identification.as_ref()
+        {
+            if !device_machine_identification.is_valid() {
+                unidentified_devices.push(device_identification.clone());
+
+                continue;
+            }
+        } else {
+            unidentified_devices.push(device_identification.clone());
+            continue;
+        }
+
+        // scan over all deice groups
+        // get the first DeviceMachineIdentification
+        // compare and append to the group
+        let mut found = false;
+        for check_group in device_groups.iter_mut() {
+            // get first device in group
+            let first_device = check_group.first().expect("group to not be empty");
+            let first_device_machine_identification = &first_device
+                .device_machine_identification
+                .machine_identification_unique;
+
+            // chek if it has machine identification
+            if let Some(device_machine_identification) =
+                device_identification.device_machine_identification.as_ref()
+            {
+                // compare with the current device
+                if first_device_machine_identification
+                    == &device_machine_identification.machine_identification_unique
+                {
+                    let device_identification_identified = device_identification
+                        .clone()
+                        .try_into()
+                        .expect("should have Some(DeviceMachineIdentification)");
+                    check_group.push(device_identification_identified);
+                    found = true;
+                    break;
+                }
+            }
+        }
+
+        if !found {
+            let device_identification_identified = device_identification
+                .clone()
+                .try_into()
+                .expect("should have Some(DeviceMachineIdentification)");
+            device_groups.push(vec![device_identification_identified]);
+        }
+    }
+
+    DeviceGroupingResult {
+        device_groups,
+        unidentified_devices,
+    }
+}
+
+/// Structure to hold the result of grouping devices by identification
+#[derive(Debug)]
+pub struct DeviceGroupingResult {
+    /// Devices grouped by machine identification
+    pub device_groups: Vec<Vec<DeviceIdentificationIdentified>>,
+    /// Devices that could not be identified
+    pub unidentified_devices: Vec<DeviceIdentification>,
+}

control-core/src/machines/manager_iter.rs

@@ -0,0 +1,84 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use smol::lock::Mutex;
+
+use crate::machines::connection::MachineSlotGeneric;
+
+use super::{identification::MachineIdentificationUnique, manager::MachineManager};
+
+pub enum MachineManagerIter<'a> {
+    EthercatMachines {
+        iter: std::collections::hash_map::Iter<
+            'a,
+            MachineIdentificationUnique,
+            Arc<Mutex<MachineSlotGeneric>>,
+        >,
+    },
+    SerialMachines {
+        iter: std::collections::hash_map::Iter<
+            'a,
+            MachineIdentificationUnique,
+            Arc<Mutex<MachineSlotGeneric>>,
+        >,
+    },
+    Done,
+}
+
+pub struct MachineManagerIterator<'a> {
+    iter: MachineManagerIter<'a>,
+    serial_machines: &'a HashMap<MachineIdentificationUnique, Arc<Mutex<MachineSlotGeneric>>>,
+}
+
+impl<'a> Iterator for MachineManagerIterator<'a> {
+    type Item = (
+        &'a MachineIdentificationUnique,
+        &'a Arc<Mutex<MachineSlotGeneric>>,
+    );
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            match &mut self.iter {
+                MachineManagerIter::EthercatMachines { iter } => {
+                    // Try to get the next item from ethercat_machines
+                    if let Some(item) = iter.next() {
+                        return Some(item);
+                    } else {
+                        // If ethercat_machines is exhausted, move to serial_machines
+                        self.iter = MachineManagerIter::SerialMachines {
+                            iter: self.serial_machines.iter(),
+                        };
+                        // Continue to the next iteration of the loop
+                        continue;
+                    }
+                }
+                MachineManagerIter::SerialMachines { iter } => {
+                    // Return the next item from serial_machines or None if exhausted
+                    if let Some(item) = iter.next() {
+                        return Some(item);
+                    } else {
+                        // If serial_machines is also exhausted, we're done
+                        self.iter = MachineManagerIter::Done;
+                        return None;
+                    }
+                }
+                MachineManagerIter::Done => {
+                    // We've exhausted both collections
+                    return None;
+                }
+            }
+        }
+    }
+}
+
+impl MachineManager {
+    // Returns an iterator over all machines (both ethercat and serial)
+    pub fn iter(&self) -> MachineManagerIterator<'_> {
+        MachineManagerIterator {
+            iter: MachineManagerIter::EthercatMachines {
+                iter: self.ethercat_machines.iter(),
+            },
+            serial_machines: &self.serial_machines,
+        }
+    }
+}

control-core/src/machines/mod.rs

@@ -0,0 +1,23 @@
+use new::MachineNewTrait;
+use std::any::Any;
+use std::fmt::Debug;
+
+use crate::machines::{
+    api::MachineApi, identification::MachineIdentificationUnique, new::MachineAct,
+};
+pub mod api;
+pub mod connection;
+pub mod identification;
+pub mod manager;
+pub mod manager_iter;
+pub mod new;
+pub mod registry;
+
+pub trait Machine: MachineAct + MachineNewTrait + MachineApi + Any + Debug + Send + Sync {
+    fn get_machine_identification_unique(&self) -> MachineIdentificationUnique;
+}
+
+pub trait AnyGetters: Any {
+    fn as_any(&self) -> &dyn Any;
+    fn as_any_mut(&mut self) -> &mut dyn Any;
+}

control-core/src/machines/new.rs

@@ -0,0 +1,279 @@
+use crate::{
+    machines::{identification::MachineIdentificationUnique, manager::MachineManager},
+    serial::SerialDevice,
+    socketio::namespace::Namespace,
+};
+
+use super::identification::DeviceIdentificationIdentified;
+use anyhow::Error;
+use ethercat_hal::{
+    devices::EthercatDevice, helpers::ethercrab_types::EthercrabSubDevicePreoperational,
+};
+use ethercrab::{SubDevice, SubDeviceRef};
+use smol::{
+    channel::Sender,
+    lock::{Mutex, RwLock},
+};
+use socketioxide::extract::SocketRef;
+use std::{
+    sync::{Arc, Weak},
+    time::Instant,
+};
+
+use crate::socketio::event::GenericEvent;
+
+pub trait MachineNewTrait {
+    fn new(params: &MachineNewParams<'_, '_, '_, '_, '_, '_, '_>) -> Result<Self, Error>
+    where
+        Self: Sized;
+}
+
+pub trait MachineAct {
+    fn act(&mut self, now: Instant);
+}
+
+pub struct MachineNewParams<
+    'maindevice,
+    'subdevices,
+    'device_identifications_identified,
+    'ethercat_devices,
+    'machine_new_hardware_etehrcat,
+    'machine_new_hardware_serial,
+    'machine_new_hardware,
+> where
+    'maindevice: 'machine_new_hardware,
+    'subdevices: 'machine_new_hardware,
+    'ethercat_devices: 'machine_new_hardware,
+    'machine_new_hardware_etehrcat: 'machine_new_hardware,
+{
+    pub device_group: &'device_identifications_identified Vec<DeviceIdentificationIdentified>,
+    pub hardware: &'machine_new_hardware MachineNewHardware<
+        'maindevice,
+        'subdevices,
+        'ethercat_devices,
+        'machine_new_hardware_etehrcat,
+        'machine_new_hardware_serial,
+    >,
+    pub socket_queue_tx: Sender<(SocketRef, Arc<GenericEvent>)>,
+    pub machine_manager: Weak<RwLock<MachineManager>>,
+
+    pub namespace: Arc<Mutex<Namespace>>,
+}
+
+impl MachineNewParams<'_, '_, '_, '_, '_, '_, '_> {
+    pub fn get_machine_identification_unique(&self) -> MachineIdentificationUnique {
+        self.device_group
+            .first()
+            .expect("device group must have at least one device")
+            .device_machine_identification
+            .machine_identification_unique
+            .clone()
+    }
+}
+
+pub enum MachineNewHardware<
+    'maindevice,
+    'subdevices,
+    'ethercat_devices,
+    'machine_new_hardware_etehrcat,
+    'machine_new_hardware_serial,
+> where
+    'maindevice: 'machine_new_hardware_etehrcat,
+    'subdevices: 'machine_new_hardware_etehrcat,
+    'ethercat_devices: 'machine_new_hardware_etehrcat,
+{
+    Ethercat(
+        &'machine_new_hardware_etehrcat MachineNewHardwareEthercat<
+            'maindevice,
+            'subdevices,
+            'ethercat_devices,
+        >,
+    ),
+    Serial(&'machine_new_hardware_serial MachineNewHardwareSerial),
+}
+
+pub struct MachineNewHardwareEthercat<'maindevice, 'subdevices, 'ethercat_devices> {
+    pub subdevices:
+        &'subdevices Vec<&'subdevices SubDeviceRef<'maindevice, &'subdevices SubDevice>>,
+    pub ethercat_devices: &'ethercat_devices Vec<Arc<RwLock<dyn EthercatDevice>>>,
+}
+
+pub struct MachineNewHardwareSerial {
+    pub device: Arc<RwLock<dyn SerialDevice>>,
+}
+
+// validates that all devices in the group have the same machine identification
+pub fn validate_same_machine_identification_unique(
+    identified_device_group: &Vec<DeviceIdentificationIdentified>,
+) -> Result<(), Error> {
+    let machine_identification_unique = &identified_device_group
+        .first()
+        .ok_or_else(|| {
+            anyhow::anyhow!(
+                "[{}::validate_same_machine_identification] No devices in group",
+                module_path!()
+            )
+        })?
+        .device_machine_identification
+        .machine_identification_unique;
+    for device in identified_device_group.iter() {
+        if device
+            .device_machine_identification
+            .machine_identification_unique
+            != *machine_identification_unique
+        {
+            return Err(anyhow::anyhow!(
+                "[{}::validate_same_machine_identification] Different machine identifications",
+                module_path!()
+            ));
+        }
+    }
+    Ok(())
+}
+
+/// validates that every role is unique
+pub fn validate_no_role_dublicates(
+    identified_device_group: &Vec<DeviceIdentificationIdentified>,
+) -> Result<(), Error> {
+    let mut roles = vec![];
+    for device in identified_device_group.iter() {
+        if roles.contains(&device.device_machine_identification.role) {
+            return Err(anyhow::anyhow!(
+                "[{}::validate_no_role_dublicates] Role dublicate",
+                module_path!(),
+            ));
+        }
+        roles.push(device.device_machine_identification.role);
+    }
+    Ok(())
+}
+
+// Inside control_core::machines::new module:
+pub fn get_device_identification_by_role(
+    identified_device_group: &Vec<DeviceIdentificationIdentified>,
+    role: u16,
+) -> Result<&DeviceIdentificationIdentified, Error> {
+    for device in identified_device_group.iter() {
+        if device.device_machine_identification.role == role {
+            return Ok(device);
+        }
+    }
+    Err(anyhow::anyhow!(
+        "[{}::get_device_identification_by_role] Role {} not found",
+        module_path!(),
+        role
+    ))
+}
+
+pub fn get_device_by_index<'maindevice>(
+    devices: &Vec<Arc<RwLock<dyn EthercatDevice>>>,
+    subdevice_index: usize,
+) -> Result<Arc<RwLock<dyn EthercatDevice>>, Error> {
+    Ok(devices
+        .get(subdevice_index)
+        .ok_or(anyhow::anyhow!(
+            "[{}::get_device_by_index] Index {} out of bounds for devices",
+            module_path!(),
+            subdevice_index
+        ))?
+        .clone())
+}
+
+pub fn get_subdevice_by_index<'subdevices, 'maindevice>(
+    subdevices: &'subdevices Vec<&EthercrabSubDevicePreoperational<'maindevice>>,
+    subdevice_index: usize,
+) -> Result<&'subdevices EthercrabSubDevicePreoperational<'maindevice>, Error> {
+    Ok(subdevices.get(subdevice_index).ok_or(anyhow::anyhow!(
+        "Index {} out of bounds for subdevices",
+        subdevice_index
+    ))?)
+}
+
+pub fn get_ethercat_device_by_index<'maindevice>(
+    ethercat_devices: &Vec<Arc<RwLock<dyn EthercatDevice>>>,
+    subdevice_index: usize,
+) -> Result<Arc<RwLock<dyn EthercatDevice>>, Error> {
+    Ok(ethercat_devices
+        .get(subdevice_index)
+        .ok_or(anyhow::anyhow!(
+            "[{}::get_ethercat_device_by_index] Index {} out of bounds for ethercat devices",
+            module_path!(),
+            subdevice_index
+        ))?
+        .clone())
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::machines::identification::{
+        DeviceHardwareIdentification, DeviceHardwareIdentificationEthercat,
+        DeviceMachineIdentification, MachineIdentification, MachineIdentificationUnique,
+    };
+
+    pub use super::*;
+
+    #[test]
+    fn test_get_device_identification_by_role() {
+        let device_identifications = vec![
+            // role 0
+            DeviceIdentificationIdentified {
+                device_machine_identification: DeviceMachineIdentification {
+                    machine_identification_unique: MachineIdentificationUnique {
+                        machine_identification: MachineIdentification {
+                            vendor: 1,
+                            machine: 1,
+                        },
+                        serial: 1,
+                    },
+                    role: 0,
+                },
+                device_hardware_identification: DeviceHardwareIdentification::Ethercat(
+                    DeviceHardwareIdentificationEthercat { subdevice_index: 0 },
+                ),
+            },
+            // role 1
+            DeviceIdentificationIdentified {
+                device_machine_identification: DeviceMachineIdentification {
+                    machine_identification_unique: MachineIdentificationUnique {
+                        machine_identification: MachineIdentification {
+                            vendor: 2,
+                            machine: 2,
+                        },
+                        serial: 2,
+                    },
+                    role: 2,
+                },
+                device_hardware_identification: DeviceHardwareIdentification::Ethercat(
+                    DeviceHardwareIdentificationEthercat { subdevice_index: 1 },
+                ),
+            },
+            // role 2
+            DeviceIdentificationIdentified {
+                device_machine_identification: DeviceMachineIdentification {
+                    machine_identification_unique: MachineIdentificationUnique {
+                        machine_identification: MachineIdentification {
+                            vendor: 3,
+                            machine: 3,
+                        },
+                        serial: 3,
+                    },
+                    role: 1,
+                },
+                device_hardware_identification: DeviceHardwareIdentification::Ethercat(
+                    DeviceHardwareIdentificationEthercat { subdevice_index: 2 },
+                ),
+            },
+        ];
+
+        // search for role 0
+        let result = get_device_identification_by_role(&device_identifications, 0);
+        assert_eq!(result.unwrap().device_machine_identification.role, 0,);
+
+        // search for role 1
+        let result = get_device_identification_by_role(&device_identifications, 1);
+        assert_eq!(result.unwrap().device_machine_identification.role, 1,);
+        // search for role 2
+        let result = get_device_identification_by_role(&device_identifications, 2);
+        assert_eq!(result.unwrap().device_machine_identification.role, 2,);
+    }
+}

control-core/src/machines/registry.rs

@@ -1,20 +1,10 @@
-#[cfg(feature = "mock-machine")]
-use crate::{extruder1::mock::ExtruderV2, mock::MockMachine, winder2::mock::Winder2};
-
-use crate::{Machine, MachineNewParams, machine_identification::MachineIdentification};
-#[cfg(not(feature = "mock-machine"))]
-use crate::{
-    aquapath1::AquaPathV1, buffer1::BufferV1, extruder1::ExtruderV2, laser::LaserMachine,
-    winder2::Winder2,
-};
-
-use lazy_static::lazy_static;
-
+use super::{Machine, identification::MachineIdentification, new::MachineNewParams};
 use anyhow::Error;
-use std::{any::TypeId, collections::HashMap};
+use smol::lock::Mutex;
+use std::{any::TypeId, collections::HashMap, sync::Arc};
 
 pub type MachineNewClosure =
-    Box<dyn Fn(&MachineNewParams) -> Result<Box<dyn Machine>, Error> + Send + Sync>;
+    Box<dyn Fn(&MachineNewParams) -> Result<Arc<Mutex<dyn Machine>>, Error> + Send + Sync>;
 
 pub struct MachineRegistry {
     type_map: HashMap<TypeId, (MachineIdentification, MachineNewClosure)>,
@@ -42,7 +32,9 @@ impl MachineRegistry {
             (
                 machine_identficiation.clone(),
                 // create a machine construction closure
-                Box::new(|machine_new_params| Ok(Box::new(T::new(machine_new_params)?))),
+                Box::new(|machine_new_params| {
+                    Ok(Arc::new(Mutex::new(T::new(machine_new_params)?)))
+                }),
             ),
         );
     }
@@ -50,7 +42,7 @@ impl MachineRegistry {
     pub fn new_machine(
         &self,
         machine_new_params: &MachineNewParams,
-    ) -> Result<Box<dyn Machine>, anyhow::Error> {
+    ) -> Result<Arc<Mutex<dyn Machine>>, anyhow::Error> {
         // get machiine identification
         let device_identification =
             &machine_new_params
@@ -80,24 +72,3 @@ impl MachineRegistry {
         (machine_new_closure)(machine_new_params)
     }
 }
-
-lazy_static! {
-    pub static ref MACHINE_REGISTRY: MachineRegistry = {
-        let mut mc = MachineRegistry::new();
-        mc.register::<Winder2>(Winder2::MACHINE_IDENTIFICATION);
-        mc.register::<ExtruderV2>(ExtruderV2::MACHINE_IDENTIFICATION);
-
-        #[cfg(feature = "mock-machine")]
-        mc.register::<MockMachine>(MockMachine::MACHINE_IDENTIFICATION);
-
-        #[cfg(not(feature = "mock-machine"))]
-        mc.register::<LaserMachine>(LaserMachine::MACHINE_IDENTIFICATION);
-
-        #[cfg(not(feature = "mock-machine"))]
-        mc.register::<BufferV1>(BufferV1::MACHINE_IDENTIFICATION);
-
-        #[cfg(not(feature = "mock-machine"))]
-        mc.register::<AquaPathV1>(AquaPathV1::MACHINE_IDENTIFICATION);
-        mc
-    };
-}

control-core/src/rest/mod.rs

@@ -0,0 +1 @@
+pub mod mutation;

control-core/src/rest/mutation.rs

@@ -2,7 +2,7 @@ use std::fmt::Debug;
 
 use serde::Serialize;
 
-use machines::machine_identification::MachineIdentificationUnique;
+use crate::machines::identification::MachineIdentificationUnique;
 
 #[derive(Debug, Serialize, Clone)]
 pub struct MutationResponse {

control-core/src/serial/mod.rs

@@ -1,10 +1,14 @@
-/*use std::{any::Any, sync::Arc};
+use std::{any::Any, sync::Arc};
 
-use smol::lock::RwLock;
+use smol::{channel::Sender, lock::RwLock};
 use std::fmt::Debug;
 
-use crate::machines::identification::DeviceIdentification;
+use crate::{
+    machines::identification::DeviceIdentification, serial::serial_detection::SerialDeviceRemoval,
+};
 
+pub mod panic;
+pub mod registry;
 pub mod serial_detection;
 
 pub trait SerialDevice: Any + Send + Sync + SerialDeviceNew + Debug {}
@@ -23,11 +27,11 @@ pub trait SerialDeviceThread {
 
 pub struct SerialDeviceNewParams {
     pub path: String,
+    pub device_thread_panic_tx: Sender<SerialDeviceRemoval<String>>,
 }
 
-#[derive(PartialEq, Eq, Clone, Debug, Hash)]
+#[derive(PartialEq, Eq, Clone, Debug)]
 pub struct SerialDeviceIdentification {
     pub vendor_id: u16,
     pub product_id: u16,
 }
-*/

control-core/src/serial/panic.rs

@@ -0,0 +1,53 @@
+use smol::channel::Sender;
+
+use crate::serial::serial_detection::SerialDeviceRemoval;
+
+/// Device-level panic handler for individual device crashes
+/// Sends device identifier and error information for cleanup
+/// Used by serial devices and other individual components that need to be removed on panic
+pub fn send_serial_device_panic<T>(
+    device_identifier: T,
+    thread_panic_tx: Sender<SerialDeviceRemoval<T>>,
+) where
+    T: Send + Sync + Clone + 'static,
+{
+    // Ensure backtrace is enabled for panics
+    if std::env::var("RUST_BACKTRACE").is_err() {
+        unsafe {
+            std::env::set_var("RUST_BACKTRACE", "full");
+        }
+    }
+
+    std::panic::set_hook(Box::new(move |panic_info| {
+        let thread_name = std::thread::current()
+            .name()
+            .unwrap_or("unnamed")
+            .to_string();
+        let location = panic_info.location().map_or("unknown".to_string(), |loc| {
+            format!("{}:{}:{}", loc.file(), loc.line(), loc.column())
+        });
+        let message = panic_info
+            .payload()
+            .downcast_ref::<&str>()
+            .unwrap_or(&"Box<dyn Any>")
+            .to_string();
+
+        let panic_message = format!(
+            "Device panicked in thread '{}' at {}: {}",
+            thread_name, location, message
+        );
+
+        // Send device panic info through channel
+        smol::block_on(async {
+            let _ = thread_panic_tx
+                .send(SerialDeviceRemoval::Error(
+                    device_identifier.clone(),
+                    anyhow::anyhow!("{}", panic_message),
+                ))
+                .await;
+        });
+
+        // Note: We don't call old_hook to avoid duplicate logging
+        // All logging is handled in the main thread when receiving panic details
+    }));
+}

control-core/src/serial/registry.rs

@@ -1,14 +1,8 @@
-use lazy_static::lazy_static;
-
+use super::SerialDeviceNewParams;
 use crate::{
-    SerialDevice, SerialDeviceIdentification, machine_identification::DeviceIdentification,
-    serial::devices::laser::Laser,
+    machines::identification::DeviceIdentification,
+    serial::{SerialDevice, SerialDeviceIdentification},
 };
-
-#[cfg(feature = "mock-machine")]
-use crate::serial::devices::mock::MockSerialDevice;
-
-use crate::SerialDeviceNewParams;
 use anyhow::{Error, Result};
 use smol::lock::RwLock;
 use std::{any::TypeId, collections::HashMap, sync::Arc};
@@ -100,22 +94,3 @@ impl SerialDeviceRegistry {
         }
     }
 }
-
-lazy_static! {
-    pub static ref SERIAL_DEVICE_REGISTRY: SerialDeviceRegistry = {
-        let mut sdr = SerialDeviceRegistry::new();
-        sdr.register::<Laser>(SerialDeviceIdentification {
-            vendor_id: 0x0403,
-            product_id: 0x6001,
-        });
-
-        // Register MockSerialDevice when mock-machine feature is enabled
-        #[cfg(feature = "mock-machine")]
-        sdr.register::<MockSerialDevice>(SerialDeviceIdentification {
-            vendor_id: 0x0001, // VENDOR_QITECH
-            product_id: 0x0007, // MACHINE_MOCK
-        });
-
-        sdr
-    };
-}

control-core/src/serial/serial_detection.rs

@@ -7,70 +7,194 @@
 */
 
 use serialport::{SerialPortInfo, SerialPortType, UsbPortInfo};
-use std::collections::HashMap;
+use smol::{
+    channel::{Receiver, Sender, unbounded},
+    lock::RwLock,
+};
+use std::{collections::HashMap, sync::Arc};
 
-use super::SerialDeviceIdentification;
-/// Handles scanning and caching of connected USB serial devices.
-pub struct SerialDetection {}
+use crate::{
+    helpers::compare_lists::compare_lists, machines::identification::DeviceIdentification,
+};
 
-impl SerialDetection {
-    /// Returns all serial ports on the system (minus macOS "cu" noise).
-    fn get_ports() -> Vec<SerialPortInfo> {
-        match serialport::available_ports() {
-            Ok(ports) => ports
-                .into_iter()
-                .filter(|port| !port.port_name.contains("cu"))
-                .collect(),
-            Err(_) => Vec::new(),
+use super::{
+    SerialDevice, SerialDeviceIdentification, SerialDeviceNewParams, registry::SerialDeviceRegistry,
+};
+
+pub enum SerialDeviceRemoval<T> {
+    Disconnect(T),
+    Error(T, anyhow::Error),
+}
+
+pub struct SerialDetection<'serialdeviceregistry> {
+    pub serial_device_registry: &'serialdeviceregistry SerialDeviceRegistry,
+    pub ports: HashMap<
+        String,
+        (
+            UsbPortInfo,
+            DeviceIdentification,
+            Arc<RwLock<dyn SerialDevice>>,
+        ),
+    >,
+    pub device_removal_signal_rx: Receiver<SerialDeviceRemoval<String>>,
+    pub device_removal_signal_tx: Sender<SerialDeviceRemoval<String>>,
+}
+
+impl<'serialdeviceregistry> SerialDetection<'serialdeviceregistry> {
+    pub fn new(serial_device_registry: &'serialdeviceregistry SerialDeviceRegistry) -> Self {
+        let (device_removal_signal_tx, device_removal_signal_rx) = unbounded();
+        SerialDetection {
+            serial_device_registry,
+            ports: HashMap::new(),
+            device_removal_signal_rx,
+            device_removal_signal_tx,
         }
     }
 
-    /// Extracts only USB serial devices from the port list.
-    fn extract_usb_serial_devices(port_list: Vec<SerialPortInfo>) -> HashMap<String, UsbPortInfo> {
-        let mut map = HashMap::new();
+    /*
+     *@return: Option::None if there are no available ports on device
+     *@return: Option::Some(Vec) with all available ports
+     *
+     *@description: detects all available ports and returns them as list
+     */
+    fn get_ports() -> Vec<SerialPortInfo> {
+        let all = match serialport::available_ports() {
+            Ok(ports) => ports,
+            Err(_) => return Vec::new(),
+        };
+
+        // exclude ports that contai "cu" in their name
+        all.into_iter()
+            .filter(|port| !port.port_name.contains("cu"))
+            .collect::<Vec<_>>()
+    }
+
+    /* @param: port_list -> list of available ports
+     *
+     * @return: Vec<(String, UsbPortInfo)> -> list of ports with their names and usb information
+     *
+     * @description: This function extracts the USB serial devices from the given list of ports.
+     */
+    fn extract_usb_serial_devices(
+        &self,
+        port_list: Vec<SerialPortInfo>,
+    ) -> Vec<(String, UsbPortInfo)> {
+        let mut usb_ports: Vec<(String, UsbPortInfo)> = Vec::new();
 
         for port in port_list {
-            if let SerialPortType::UsbPort(usb_info) = port.port_type {
-                map.insert(port.port_name, usb_info);
+            if let SerialPortType::UsbPort(usb_info) = &port.port_type {
+                usb_ports.push((port.port_name.to_string(), usb_info.clone()));
+            };
+        }
+
+        usb_ports
+    }
+
+    pub async fn check_ports(&mut self) -> CheckPortsResult {
+        // get available ports
+        let ports = Self::get_ports();
+
+        // extract all ports that are usb ports
+        let usb_ports = self.extract_usb_serial_devices(ports);
+
+        let last_usb_ports = self
+            .ports
+            .iter()
+            .map(|last_usb_port| (last_usb_port.0.clone(), last_usb_port.1.0.clone()))
+            .collect::<Vec<_>>();
+
+        let usb_ports_diff = compare_lists(&last_usb_ports, &usb_ports);
+
+        let mut result = CheckPortsResult {
+            added: Vec::new(),
+            removed: Vec::new(),
+        };
+
+        // reamove ports
+        for removed in usb_ports_diff.removed {
+            if let Some((_, device_identification, _)) = self.ports.remove(&removed.0) {
+                result.removed.push(device_identification);
+            }
+
+            tracing::trace!("Removed port: {}", removed.0);
+        }
+
+        // add new ports
+        for added in usb_ports_diff.added {
+            // add the port to the list
+            let serial_device_identification = SerialDeviceIdentification {
+                vendor_id: added.1.vid,
+                product_id: added.1.pid,
+            };
+
+            let device_result = self.serial_device_registry.new_serial_device(
+                &SerialDeviceNewParams {
+                    path: added.0.clone(),
+                    device_thread_panic_tx: self.device_removal_signal_tx.clone(),
+                },
+                &serial_device_identification,
+            );
+
+            // only if created device driver sucessfully
+            if let Ok((device_identification, device)) = device_result {
+                // add the device to the ports list
+                self.ports.insert(
+                    added.0.clone(),
+                    (
+                        added.1.clone(),
+                        device_identification.clone(),
+                        device.clone(),
+                    ),
+                );
+
+                // add to result list
+                result.added.push((device_identification, device.clone()));
+
+                tracing::trace!("Added port: {}", added.0);
             }
         }
-        map
+
+        result
     }
 
-    /// Scans for connected USB serial devices and updates the internal map.
-    /// Returns a clone of the map for quick access.
-    pub fn detect_devices() -> HashMap<String, UsbPortInfo> {
-        let ports = Self::get_ports();
-        let usb_devices = Self::extract_usb_serial_devices(ports);
-        usb_devices
-    }
+    pub async fn check_remove_signals(&mut self) -> Vec<DeviceIdentification> {
+        let mut removed_signals: Vec<DeviceIdentification> = Vec::new();
 
-    pub fn device_port_exists(device_path: &str) -> bool {
-        let ports = Self::get_ports();
-        return ports.iter().any(|p| p.port_name == device_path);
-    }
+        let mut add_removal_signal = |path: &String| {
+            if let Some(info) = self.ports.get(path) {
+                removed_signals.push(info.1.clone());
+            };
+            self.ports.remove(path);
+        };
 
-    pub fn device_id_exists(sdevid: SerialDeviceIdentification) -> bool {
-        let ports = Self::get_ports();
-        for port in ports {
-            if let SerialPortType::UsbPort(usb_info) = port.port_type {
-                if usb_info.vid == sdevid.vendor_id && usb_info.pid == sdevid.product_id {
-                    return true;
-                }
+        if self.device_removal_signal_rx.is_empty() {
+            return removed_signals;
+        }
+
+        let removal = self
+            .device_removal_signal_rx
+            .recv()
+            .await
+            .expect("Failed to receive removal signals");
+
+        match removal {
+            SerialDeviceRemoval::Disconnect(path) => {
+                add_removal_signal(&path);
+                tracing::trace!("Removed serial device after disconnect: {:?}", path);
+            }
+
+            SerialDeviceRemoval::Error(path, error) => {
+                add_removal_signal(&path);
+                tracing::error!("Removed erroring serial device: {:?}: {}", path, error);
             }
         }
-        return false;
-    }
 
-    pub fn get_path_by_id(
-        sdevid: SerialDeviceIdentification,
-        map: HashMap<String, UsbPortInfo>,
-    ) -> Option<String> {
-        for (port, usbport) in map.iter() {
-            if usbport.vid == sdevid.vendor_id && usbport.pid == sdevid.product_id {
-                return Some(port.clone());
-            }
-        }
-        return None;
+        removed_signals
     }
 }
+
+#[derive(Debug)]
+pub struct CheckPortsResult {
+    pub added: Vec<(DeviceIdentification, Arc<RwLock<dyn SerialDevice>>)>,
+    pub removed: Vec<DeviceIdentification>,
+}

control-core/src/socketio/mod.rs

@@ -1,2 +1,3 @@
 pub mod event;
 pub mod namespace;
+pub mod namespace_id;

control-core/src/socketio/namespace.rs

@@ -4,7 +4,7 @@ use socketioxide::extract::SocketRef;
 use std::{collections::HashMap, sync::Arc, time::Duration};
 use tracing::instrument;
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct Namespace {
     pub sockets: Vec<SocketRef>,
     pub events: HashMap<String, Vec<Arc<GenericEvent>>>,
@@ -118,6 +118,7 @@ impl Namespace {
     ) {
         // cache the event
         self.cache(event.clone(), buffer_fn);
+
         // emit the event - inlined from emit function
         // Send to global queue for each socket in the namespace
         for socket in self.sockets.clone() {
@@ -167,7 +168,7 @@ impl Namespace {
 
 impl Drop for Namespace {
     fn drop(&mut self) {
-        //self.disconnect_all();
+        self.disconnect_all();
     }
 }
 

control-core/src/socketio/namespace_id.rs

@@ -3,7 +3,7 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt;
 use std::str::FromStr;
 
-use machines::machine_identification::{MachineIdentification, MachineIdentificationUnique};
+use crate::machines::identification::{MachineIdentification, MachineIdentificationUnique};
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
 pub enum NamespaceId {

control-core/src/transmission/mod.rs

@@ -1,4 +1,4 @@
-use units::{
+use uom::si::{
     angle::radian,
     angular_velocity::radian_per_second,
     f64::{Angle, AngularVelocity, Length, Velocity},

control-core/src/uom_extensions/acceleration.rs

@@ -0,0 +1,7 @@
+unit! {
+    system: uom::si;
+    quantity: uom::si::acceleration;
+
+    @meter_per_minute_per_second: 0.016_666_666_666_666_67; "m/min/s", "meters per minute per second",
+        "meters per minute per second";
+}

control-core/src/uom_extensions/angular_acceleration.rs

@@ -0,0 +1,7 @@
+unit! {
+    system: uom::si;
+    quantity: uom::si::angular_acceleration;
+
+    @revolution_per_minute_per_second: 0.104_719_755_119_659_77; "rev/min/s", "revolutions per minute per second",
+        "revolutions per minute per second";
+}

control-core/src/uom_extensions/angular_jerk.rs

@@ -0,0 +1,7 @@
+unit! {
+    system: uom::si;
+    quantity: uom::si::angular_jerk;
+
+    @revolution_per_minute_per_second_squared: 0.104_719_755_119_659_77; "rev/min/s²", "revolution per minute per second squared",
+        "revolution per minute per second squared";
+}

control-core/src/uom_extensions/jerk.rs

@@ -0,0 +1,7 @@
+unit! {
+    system: uom::si;
+    quantity: uom::si::jerk;
+
+    @meter_per_minute_per_second_squared: 0.016_666_666_666_666_666_67; "m/min/s²", "meters per minute per second squared",
+        "meters per minute per second squared";
+}

control-core/src/uom_extensions/mod.rs

@@ -0,0 +1,5 @@
+pub mod acceleration;
+pub mod angular_acceleration;
+pub mod angular_jerk;
+pub mod jerk;
+pub mod velocity;

control-core/src/uom_extensions/velocity.rs

@@ -0,0 +1,7 @@
+unit! {
+    system: uom::si;
+    quantity: uom::si::velocity;
+
+    @meter_per_minute: 0.016_666_666_666_666_67; "m/min", "meters per minute",
+        "meters per minute";
+}

docs/machines/laser-DRE.md

@@ -1,69 +0,0 @@
-# Laser DRE Device Documentation
-
-## Overview
-The **Laser DRE** is a precision measurement device designed for real-time diameter measurement of rotating objects. It communicates over a **USB Serial interface** using the **Modbus RTU** protocol.
-
-Key features include:
-
-- High-speed diameter measurement
-- Dual-axis capability
-- USB Serial communication
-- Modbus RTU protocol support
-
----
-
-## Technical Specifications
-
-- **Communication Interface:** USB Serial
-- **Protocol:** Modbus RTU
-- **Axes:** 2-axis measurement
-- **Polling Rate:** Every 16 ms
-- **Measurement Rate:** 320 measurements per second (manufacturer specification)
-- **Measurement Type:** Diameter measurement | X/Y Axis width
-
----
-
-## Operation
-
-### Polling
-The device **polls the diameter every 16 milliseconds**, ensuring near real-time data acquisition for precise monitoring.
-
-### Measurement
-According to the manufacturer, the Laser DRE can measure the diameter **320 times per second**, providing high-resolution data for process control and analysis.
-
-### Axes
-The device is capable of measuring across **two axes**, allowing for comprehensive profiling of the object’s diameter and shape.
-
----
-
-## Communication Protocol
-
-The device uses **Modbus RTU** over the USB Serial connection. Key points for communication:
-
-- **Master/Slave Model:** The Laser DRE acts as a Modbus slave device.
-- **Function Codes:** Supports standard Modbus RTU function codes for reading measurements.
-- **Data Format:** Diameter measurements are transmitted in the format specified by the manufacturer (consult the device manual for exact register addresses and scaling).
-
----
-
-## Settings
-
-The device includes a small display that allows changing several operational settings:
-
-- **Unit:**
-  The laser can operate in **millimeters (mm)** or **inches (in)**.
-  Our software uses **millimeters**.
-
-- **Alarm:**
-  The laser can emit an audible alarm if the measured diameter is out of tolerance.
-  ⚠️ **Note:** The tolerance settings on the laser may differ from the tolerance configured in our software.
-
-- **Communication:**
-  Several communication parameters can be configured:
-  - **Set UART:** Configure **parity (8N1)** and **baud rate (38400)**.
-  - **Set Protocol:** Choose the communication protocol. *(We use **Modbus RTU**.)*
-  - **Set Slave Address:** The slave address of our laser is **1**.
-
-- **Calibration:**
-  The laser can be calibrated using **4 mm** and **8 mm** reference rods.
-

electron/package-lock.json

@@ -8,7 +8,7 @@
       "name": "qitech-control-electron",
       "version": "1.0.0",
       "dependencies": {
-        "@hookform/resolvers": "^5.2.2",
+        "@hookform/resolvers": "^4.1.2",
         "@icons-pack/react-simple-icons": "^11.2.0",
         "@jub3i/tree-kill": "^0.0.15",
         "@radix-ui/react-collapsible": "^1.1.12",
@@ -64,13 +64,13 @@
         "@electron-forge/maker-squirrel": "^7.6.1",
         "@electron-forge/maker-zip": "^7.6.1",
         "@electron-forge/plugin-auto-unpack-natives": "^7.6.1",
-        "@electron-forge/plugin-fuses": "^7.10.2",
+        "@electron-forge/plugin-fuses": "^7.8.0",
         "@electron-forge/plugin-vite": "^7.6.1",
         "@electron-forge/shared-types": "^7.4.0",
-        "@electron/fuses": "^1.8.0",
+        "@electron/fuses": "^2.0.0",
         "@eslint/compat": "^1.2.6",
         "@eslint/js": "^9.18.0",
-        "@playwright/test": "^1.56.1",
+        "@playwright/test": "^1.50.1",
         "@tailwindcss/postcss": "^4.0.6",
         "@testing-library/jest-dom": "^6.6.3",
         "@testing-library/react": "^16.3.0",
@@ -97,7 +97,7 @@
         "ts-node": "^10.9.2",
         "typescript": "^5.7.3",
         "typescript-eslint": "^8.24.1",
-        "vite": "^6.4.1",
+        "vite": "^6.3.6",
         "vitest": "^3.0.6"
       }
     },
@@ -175,6 +175,7 @@
       "version": "7.28.0",
       "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.0.tgz",
       "integrity": "sha512-UlLAnTPrFdNGoFtbSXwcGFQBtQZJCNjaN6hQNP3UPvuNXT1i82N26KL3dZeIpNalWywr9IuQuncaAfUaS1g6sQ==",
+      "peer": true,
       "dependencies": {
         "@ampproject/remapping": "^2.2.0",
         "@babel/code-frame": "^7.27.1",
@@ -638,6 +639,7 @@
           "url": "https://opencollective.com/csstools"
         }
       ],
+      "peer": true,
       "engines": {
         "node": ">=18"
       },
@@ -660,6 +662,7 @@
           "url": "https://opencollective.com/csstools"
         }
       ],
+      "peer": true,
       "engines": {
         "node": ">=18"
       }
@@ -926,62 +929,19 @@
       }
     },
     "node_modules/@electron-forge/plugin-fuses": {
-      "version": "7.10.2",
-      "resolved": "https://registry.npmjs.org/@electron-forge/plugin-fuses/-/plugin-fuses-7.10.2.tgz",
-      "integrity": "sha512-X8FaBL5pVvKCTBNaa9EjbH6vuaeIU7UcPSmP9501XF4zcKPCfTbQKz49LTMl7gd5YzUm82IlqRjte12LLpcSDQ==",
+      "version": "7.8.2",
+      "resolved": "https://registry.npmjs.org/@electron-forge/plugin-fuses/-/plugin-fuses-7.8.2.tgz",
+      "integrity": "sha512-BrN26y8xRuz43aJasktLvze2rh9XIxN6m4FR5NJvXbdcS0vUQvLSOgRm9koV5YL0/zr99OS5FXLiw04U+kKy1g==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
-        "@electron-forge/plugin-base": "7.10.2",
-        "@electron-forge/shared-types": "7.10.2"
+        "@electron-forge/plugin-base": "7.8.2",
+        "@electron-forge/shared-types": "7.8.2"
       },
       "engines": {
         "node": ">= 16.4.0"
       },
       "peerDependencies": {
-        "@electron/fuses": "^1.0.0"
-      }
-    },
-    "node_modules/@electron-forge/plugin-fuses/node_modules/@electron-forge/plugin-base": {
-      "version": "7.10.2",
-      "resolved": "https://registry.npmjs.org/@electron-forge/plugin-base/-/plugin-base-7.10.2.tgz",
-      "integrity": "sha512-+4YLmkLZxvS6JFXYNI4dHt8Il8iIvwk2o6lCJGwNysOUq2KOZ3Wu1He4Ko8HhKcO1VWbFvslbh57oQn963Aryw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@electron-forge/shared-types": "7.10.2"
-      },
-      "engines": {
-        "node": ">= 16.4.0"
-      }
-    },
-    "node_modules/@electron-forge/plugin-fuses/node_modules/@electron-forge/shared-types": {
-      "version": "7.10.2",
-      "resolved": "https://registry.npmjs.org/@electron-forge/shared-types/-/shared-types-7.10.2.tgz",
-      "integrity": "sha512-e2pd9RsdbKwsNf6UtKoolmJGy92Nc0/XO4SI91doV8cM954hM2XSYz3VHoqXebMFAF1JDfXoEUt6UCRbEDgMgw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@electron-forge/tracer": "7.10.2",
-        "@electron/packager": "^18.3.5",
-        "@electron/rebuild": "^3.7.0",
-        "listr2": "^7.0.2"
-      },
-      "engines": {
-        "node": ">= 16.4.0"
-      }
-    },
-    "node_modules/@electron-forge/plugin-fuses/node_modules/@electron-forge/tracer": {
-      "version": "7.10.2",
-      "resolved": "https://registry.npmjs.org/@electron-forge/tracer/-/tracer-7.10.2.tgz",
-      "integrity": "sha512-jhLLQbttfZViSOYn/3SJc8HML+jNZAytPVJwgGGd3coUiFysWJ2Xald99iqOiouPAhIigBfNPxQb/q/EbcDu4g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "chrome-trace-event": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 14.17.5"
+        "@electron/fuses": ">=1.0.0"
       }
     },
     "node_modules/@electron-forge/plugin-vite": {
@@ -1140,34 +1100,17 @@
       }
     },
     "node_modules/@electron/fuses": {
-      "version": "1.8.0",
-      "resolved": "https://registry.npmjs.org/@electron/fuses/-/fuses-1.8.0.tgz",
-      "integrity": "sha512-zx0EIq78WlY/lBb1uXlziZmDZI4ubcCXIMJ4uGjXzZW0nS19TjSPeXPAjzzTmKQlJUZm0SbmZhPKP7tuQ1SsEw==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@electron/fuses/-/fuses-2.0.0.tgz",
+      "integrity": "sha512-lyb1zK3YHeWUjaz7yiK0GnxSPduwASKMyiDbCtbn3spP6EEt+UWtktggWehG0icFrXAk3GwvcJ4nCrJO0N9IhQ==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "chalk": "^4.1.1",
-        "fs-extra": "^9.0.1",
-        "minimist": "^1.2.5"
-      },
+      "peer": true,
       "bin": {
         "electron-fuses": "dist/bin.js"
-      }
-    },
-    "node_modules/@electron/fuses/node_modules/fs-extra": {
-      "version": "9.1.0",
-      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
-      "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "at-least-node": "^1.0.0",
-        "graceful-fs": "^4.2.0",
-        "jsonfile": "^6.0.1",
-        "universalify": "^2.0.0"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">=22.12.0"
       }
     },
     "node_modules/@electron/get": {
@@ -2106,15 +2049,14 @@
       "dev": true
     },
     "node_modules/@hookform/resolvers": {
-      "version": "5.2.2",
-      "resolved": "https://registry.npmjs.org/@hookform/resolvers/-/resolvers-5.2.2.tgz",
-      "integrity": "sha512-A/IxlMLShx3KjV/HeTcTfaMxdwy690+L/ZADoeaTltLx+CVuzkeVIPuybK3jrRfw7YZnmdKsVVHAlEPIAEUNlA==",
-      "license": "MIT",
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/@hookform/resolvers/-/resolvers-4.1.3.tgz",
+      "integrity": "sha512-Jsv6UOWYTrEFJ/01ZrnwVXs7KDvP8XIo115i++5PWvNkNvkrsTfGiLS6w+eJ57CYtUtDQalUWovCZDHFJ8u1VQ==",
       "dependencies": {
         "@standard-schema/utils": "^0.3.0"
       },
       "peerDependencies": {
-        "react-hook-form": "^7.55.0"
+        "react-hook-form": "^7.0.0"
       }
     },
     "node_modules/@humanfs/core": {
@@ -2340,13 +2282,12 @@
       }
     },
     "node_modules/@playwright/test": {
-      "version": "1.56.1",
-      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.56.1.tgz",
-      "integrity": "sha512-vSMYtL/zOcFpvJCW71Q/OEGQb7KYBPAdKh35WNSkaZA75JlAO8ED8UN6GUNTm3drWomcbcqRPFqQbLae8yBTdg==",
+      "version": "1.54.2",
+      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.54.2.tgz",
+      "integrity": "sha512-A+znathYxPf+72riFd1r1ovOLqsIIB0jKIoPjyK2kqEIe30/6jF6BC7QNluHuwUmsD2tv1XZVugN8GqfTMOxsA==",
       "dev": true,
-      "license": "Apache-2.0",
       "dependencies": {
-        "playwright": "1.56.1"
+        "playwright": "1.54.2"
       },
       "bin": {
         "playwright": "cli.js"
@@ -4091,6 +4032,7 @@
       "resolved": "https://registry.npmjs.org/@tanstack/react-router/-/react-router-1.130.17.tgz",
       "integrity": "sha512-F1tyMEbX7PJclnA25hAFXhLKq4jqeODvvaogsd0/NX02Kmz3QoT9GV+rgpv2TxamU6RwjRgihSH06Dn5hM6SOw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@tanstack/history": "1.130.12",
         "@tanstack/react-store": "^0.7.0",
@@ -4172,6 +4114,7 @@
       "resolved": "https://registry.npmjs.org/@tanstack/router-core/-/router-core-1.130.17.tgz",
       "integrity": "sha512-0AH4s/52X2shYLifr9hR+6R6NpGsBp1M3LyjBTZm6Jlkud+nOhkkRxKxYS7l+JErRlffdxVHxMdoTnKcQ+duiQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@tanstack/history": "1.130.12",
         "@tanstack/store": "^0.7.0",
@@ -4405,8 +4348,7 @@
       "version": "5.0.4",
       "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
       "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
-      "dev": true,
-      "peer": true
+      "dev": true
     },
     "node_modules/@types/babel__core": {
       "version": "7.20.5",
@@ -4563,6 +4505,7 @@
       "integrity": "sha512-DRh5K+ka5eJic8CjH7td8QpYEV6Zo10gfRkjHCO3weqZHWDtAaSTFtl4+VMqOJ4N5jcuhZ9/l+yy8rVgw7BQeQ==",
       "devOptional": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "undici-types": "~7.10.0"
       }
@@ -4579,6 +4522,7 @@
       "resolved": "https://registry.npmjs.org/@types/react/-/react-19.1.16.tgz",
       "integrity": "sha512-WBM/nDbEZmDUORKnh5i1bTnAz6vTohUf9b8esSMu+b24+srbaxa04UbJgWx78CVfNXA20sNu0odEIluZDFdCog==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "csstype": "^3.0.2"
       }
@@ -4588,6 +4532,7 @@
       "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.1.7.tgz",
       "integrity": "sha512-i5ZzwYpqjmrKenzkoLM2Ibzt6mAsM7pxB6BCIouEVVmgiqaMj1TjaK7hnA36hbW5aZv20kx7Lw6hWzPWg0Rurw==",
       "devOptional": true,
+      "peer": true,
       "peerDependencies": {
         "@types/react": "^19.0.0"
       }
@@ -4670,6 +4615,7 @@
       "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.38.0.tgz",
       "integrity": "sha512-Zhy8HCvBUEfBECzIl1PKqF4p11+d0aUJS1GeUiuqK9WmOug8YCmC4h4bjyBvMyAMI9sbRczmrYL5lKg/YMbrcQ==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "8.38.0",
         "@typescript-eslint/types": "8.38.0",
@@ -5024,6 +4970,7 @@
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "dev": true,
+      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -5471,6 +5418,7 @@
           "url": "https://github.com/sponsors/ai"
         }
       ],
+      "peer": true,
       "dependencies": {
         "caniuse-lite": "^1.0.30001726",
         "electron-to-chromium": "^1.5.173",
@@ -6163,7 +6111,8 @@
     "node_modules/csstype": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
-      "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="
+      "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==",
+      "peer": true
     },
     "node_modules/data-urls": {
       "version": "5.0.0",
@@ -6436,8 +6385,7 @@
       "version": "0.5.16",
       "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
       "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
-      "dev": true,
-      "peer": true
+      "dev": true
     },
     "node_modules/dom-helpers": {
       "version": "5.2.1",
@@ -7437,6 +7385,7 @@
       "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.32.0.tgz",
       "integrity": "sha512-LSehfdpgMeWcTZkWZVIJl+tkZ2nuSkyyB9C27MZqFWXuph7DvaowgcTvKqxvpLW1JZIk8PN7hFY3Rj9LQ7m7lg==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.2.0",
         "@eslint-community/regexpp": "^4.12.1",
@@ -7497,6 +7446,7 @@
       "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-10.1.8.tgz",
       "integrity": "sha512-82GZUjRS0p/jganf6q1rEO25VSoHH0hKPCTrgillPjdI/3bgBhAE1QzHrHTizjpRvy6pGAvKjDJtk2pF9NDq8w==",
       "dev": true,
+      "peer": true,
       "bin": {
         "eslint-config-prettier": "bin/cli.js"
       },
@@ -8803,6 +8753,7 @@
           "url": "https://www.i18next.com/how-to/faq#i18next-is-awesome.-how-can-i-support-the-project"
         }
       ],
+      "peer": true,
       "dependencies": {
         "@babel/runtime": "^7.27.6"
       },
@@ -8865,6 +8816,7 @@
       "version": "10.1.1",
       "resolved": "https://registry.npmjs.org/immer/-/immer-10.1.1.tgz",
       "integrity": "sha512-s2MPrmjovJcoMaHtx6K11Ra7oD05NT97w1IC5zpMkT6Atjr7H8LjaDd81iIxUYpMKSRRNMJE703M1Fhr/TctHw==",
+      "peer": true,
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/immer"
@@ -9539,6 +9491,7 @@
       "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-26.1.0.tgz",
       "integrity": "sha512-Cvc9WUhxSMEo4McES3P7oK3QaXldCfNWp7pl2NNeiIFlCoLr3kfq9kb1fxftiwk1FLV7CvpvDfonxtzUDeSOPg==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "cssstyle": "^4.2.1",
         "data-urls": "^5.0.0",
@@ -10104,7 +10057,6 @@
       "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz",
       "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
       "dev": true,
-      "peer": true,
       "bin": {
         "lz-string": "bin/bin.js"
       }
@@ -11930,13 +11882,12 @@
       }
     },
     "node_modules/playwright": {
-      "version": "1.56.1",
-      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.56.1.tgz",
-      "integrity": "sha512-aFi5B0WovBHTEvpM3DzXTUaeN6eN0qWnTkKx4NQaH4Wvcmc153PdaY2UBdSYKaGYw+UyWXSVyxDUg5DoPEttjw==",
+      "version": "1.54.2",
+      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.54.2.tgz",
+      "integrity": "sha512-Hu/BMoA1NAdRUuulyvQC0pEqZ4vQbGfn8f7wPXcnqQmM+zct9UliKxsIkLNmz/ku7LElUNqmaiv1TG/aL5ACsw==",
       "dev": true,
-      "license": "Apache-2.0",
       "dependencies": {
-        "playwright-core": "1.56.1"
+        "playwright-core": "1.54.2"
       },
       "bin": {
         "playwright": "cli.js"
@@ -11949,11 +11900,10 @@
       }
     },
     "node_modules/playwright-core": {
-      "version": "1.56.1",
-      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.56.1.tgz",
-      "integrity": "sha512-hutraynyn31F+Bifme+Ps9Vq59hKuUCz7H1kDOcBs+2oGguKkWTU50bBWrtz34OUWmIwpBTWDxaRPXrIXkgvmQ==",
+      "version": "1.54.2",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.54.2.tgz",
+      "integrity": "sha512-n5r4HFbMmWsB4twG7tJLDN9gmBUeSPcsBZiWSE4DnYz9mJMAFqr2ID7+eGC9kpEnxExJ1epttwR59LEWCk8mtA==",
       "dev": true,
-      "license": "Apache-2.0",
       "bin": {
         "playwright-core": "cli.js"
       },
@@ -12049,6 +11999,7 @@
       "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.6.2.tgz",
       "integrity": "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==",
       "dev": true,
+      "peer": true,
       "bin": {
         "prettier": "bin/prettier.cjs"
       },
@@ -12162,7 +12113,6 @@
       "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz",
       "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==",
       "dev": true,
-      "peer": true,
       "dependencies": {
         "ansi-regex": "^5.0.1",
         "ansi-styles": "^5.0.0",
@@ -12177,7 +12127,6 @@
       "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
       "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
       "dev": true,
-      "peer": true,
       "engines": {
         "node": ">=10"
       },
@@ -12306,6 +12255,7 @@
       "version": "19.1.1",
       "resolved": "https://registry.npmjs.org/react/-/react-19.1.1.tgz",
       "integrity": "sha512-w8nqGImo45dmMIfljjMwOGtbmC/mk4CMYhWIicdSflH91J9TyCyczcPFXJzrZ/ZXcgGRFeP6BU0BEJTw6tZdfQ==",
+      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -12314,6 +12264,7 @@
       "version": "19.1.1",
       "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.1.1.tgz",
       "integrity": "sha512-Dlq/5LAZgF0Gaz6yiqZCf6VCcZs1ghAJyrsu84Q/GT0gV+mCxbfmKNoGRKBYMJ8IEdGPqu49YWXD02GCknEDkw==",
+      "peer": true,
       "dependencies": {
         "scheduler": "^0.26.0"
       },
@@ -12325,6 +12276,7 @@
       "version": "7.62.0",
       "resolved": "https://registry.npmjs.org/react-hook-form/-/react-hook-form-7.62.0.tgz",
       "integrity": "sha512-7KWFejc98xqG/F4bAxpL41NB3o1nnvQO1RWZT3TqRZYL8RryQETGfEdVnJN2fy1crCiBLLjkRBVK05j24FxJGA==",
+      "peer": true,
       "engines": {
         "node": ">=18.0.0"
       },
@@ -12365,8 +12317,7 @@
       "version": "17.0.2",
       "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz",
       "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
-      "dev": true,
-      "peer": true
+      "dev": true
     },
     "node_modules/react-lifecycles-compat": {
       "version": "3.0.4",
@@ -13117,6 +13068,7 @@
       "version": "1.3.2",
       "resolved": "https://registry.npmjs.org/seroval/-/seroval-1.3.2.tgz",
       "integrity": "sha512-RbcPH1n5cfwKrru7v7+zrZvjLurgHhGyso3HTyGtRivGWgYjbOmGuivCQaORNELjNONoK35nj28EoWul9sb1zQ==",
+      "peer": true,
       "engines": {
         "node": ">=10"
       }
@@ -13906,7 +13858,8 @@
     "node_modules/tailwindcss": {
       "version": "4.1.11",
       "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.11.tgz",
-      "integrity": "sha512-2E9TBm6MDD/xKYe+dvJZAmg3yxIEDNRc0jwlNyDg/4Fil2QcSLjFKGVff0lAf1jjeaArlG/M75Ey/EYr/OJtBA=="
+      "integrity": "sha512-2E9TBm6MDD/xKYe+dvJZAmg3yxIEDNRc0jwlNyDg/4Fil2QcSLjFKGVff0lAf1jjeaArlG/M75Ey/EYr/OJtBA==",
+      "peer": true
     },
     "node_modules/tailwindcss-animate": {
       "version": "1.0.7",
@@ -14008,7 +13961,8 @@
     "node_modules/tiny-invariant": {
       "version": "1.3.3",
       "resolved": "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.3.tgz",
-      "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg=="
+      "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==",
+      "peer": true
     },
     "node_modules/tiny-warning": {
       "version": "1.0.3",
@@ -14059,6 +14013,7 @@
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -14370,6 +14325,7 @@
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
       "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
       "devOptional": true,
+      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -14727,10 +14683,11 @@
       }
     },
     "node_modules/vite": {
-      "version": "6.4.1",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.1.tgz",
-      "integrity": "sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==",
+      "version": "6.3.6",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.3.6.tgz",
+      "integrity": "sha512-0msEVHJEScQbhkbVTb/4iHZdJ6SXp/AvxL2sjwYQFfBqleHtnCqv1J3sa9zbWz/6kW1m9Tfzn92vW+kZ1WV6QA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "esbuild": "^0.25.0",
         "fdir": "^6.4.4",
@@ -14852,6 +14809,7 @@
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -15395,6 +15353,7 @@
       "version": "3.25.76",
       "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
       "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "peer": true,
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"
       }

electron/package.json

@@ -28,13 +28,13 @@
     "@electron-forge/maker-squirrel": "^7.6.1",
     "@electron-forge/maker-zip": "^7.6.1",
     "@electron-forge/plugin-auto-unpack-natives": "^7.6.1",
-    "@electron-forge/plugin-fuses": "^7.10.2",
+    "@electron-forge/plugin-fuses": "^7.8.0",
     "@electron-forge/plugin-vite": "^7.6.1",
     "@electron-forge/shared-types": "^7.4.0",
-    "@electron/fuses": "^1.8.0",
+    "@electron/fuses": "^2.0.0",
     "@eslint/compat": "^1.2.6",
     "@eslint/js": "^9.18.0",
-    "@playwright/test": "^1.56.1",
+    "@playwright/test": "^1.50.1",
     "@tailwindcss/postcss": "^4.0.6",
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.3.0",
@@ -61,11 +61,11 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.7.3",
     "typescript-eslint": "^8.24.1",
-    "vite": "^6.4.1",
+    "vite": "^6.3.6",
     "vitest": "^3.0.6"
   },
   "dependencies": {
-    "@hookform/resolvers": "^5.2.2",
+    "@hookform/resolvers": "^4.1.2",
     "@icons-pack/react-simple-icons": "^11.2.0",
     "@jub3i/tree-kill": "^0.0.15",
     "@radix-ui/react-collapsible": "^1.1.12",

electron/src/assets/markdown/extruder/manual.md

@@ -720,7 +720,3 @@ The following persons must not work on the machine:
 ![QiTech Pro Extruder Electrical Diagram 2025 - Sheet 8](images/manuals/extruder/QiTech_Pro_Extruder_Electrical_Diagram_2025_8-008.png)
 
 ![QiTech Pro Extruder Electrical Diagram 2025 - Sheet 9](images/manuals/extruder/QiTech_Pro_Extruder_Electrical_Diagram_2025_9-009.png)
-
-## Mechanical Diagrams
-
-![QiTech Pro Extruder Nozzle 2025](images/manuals/extruder/Nozzle.png)

electron/src/client/mainNamespace.ts

@@ -145,17 +145,8 @@ export function mainMessageHandler(
   };
 }
 
-// Create the store instance once and export it
-export const mainNamespaceStore: StoreApi<MainNamespaceStore> =
-  createMainNamespaceStore();
-
-// Message handler stays the same
-export const mainMessageHandlerInstance: EventHandler =
-  mainMessageHandler(mainNamespaceStore);
-
-// Hook that uses the exported store
 const mainRoomImplementation = createNamespaceHookImplementation({
-  createStore: () => mainNamespaceStore, // use the exported store
+  createStore: createMainNamespaceStore,
   createEventHandler: mainMessageHandler,
 });
 

electron/src/client/socketioStore.ts

@@ -8,8 +8,6 @@ import { z } from "zod";
 import { toastError, toastZodError } from "@/components/Toast";
 import { MachineIdentificationUnique } from "@/machines/types";
 import { FPS_30 } from "@/lib/constants";
-import { mainNamespaceStore, createMainNamespaceStore } from "./mainNamespace";
-import { softReloadMainNamespaceStore } from "./softReload";
 
 /**
  * Simple buffer-based store updater to limit React re-renders to ~30 FPS
@@ -307,13 +305,27 @@ const useSocketioStore = create<SocketioStore>()((set, get) => ({
     // add handlers
     socket.on("connect", () => {
       console.log(`Connected to ${namespace_path}`);
+
+      // reset the store
       resetStore(set);
     });
     socket.on("disconnect", (reason) => {
       socket.disconnect();
+      console.warn(`Disconnected from ${namespace_path}, reason: ${reason}`);
+
+      // reset the store
       resetStore(set);
-      // Its hacky but i do not care, electron + react is annoying ...
-      window.location.reload();
+
+      // Attempt to reconnect after a short delay for any disconnect reason
+      console.log(
+        `Disconnected from ${namespace_path}, attempting reconnect in 1s...`,
+      );
+      setTimeout(() => {
+        if (get().hasNamespace(namespaceId) && !socket.connected) {
+          console.log(`Reconnecting to ${namespace_path}...`);
+          socket.connect();
+        }
+      }, 1000);
     });
 
     socket.on("event", (event: unknown) => {
@@ -322,9 +334,11 @@ const useSocketioStore = create<SocketioStore>()((set, get) => ({
       if (!event_parsed.success) {
         toastZodError(event_parsed.error, "Invalid event");
         return;
-      } // handle the event
+      }
+      // handle the event
       get().namespaces[namespace_path].handler(event_parsed.data);
     });
+
     // store the namespace initally
     set(
       produce((state: SocketioStore) => {
@@ -342,25 +356,8 @@ const useSocketioStore = create<SocketioStore>()((set, get) => ({
       }),
     );
 
-    if (namespace_path !== "/main") {
-      const intervalId = setInterval(() => {
-        const mainState = mainNamespaceStore.getState();
-        const machineExists =
-          namespaceId.type === "machine" &&
-          mainState.machines?.data?.machines.some(
-            (m) =>
-              m.machine_identification_unique.serial ===
-              namespaceId.machine_identification_unique.serial,
-          );
-        //console.log(machineExists);
-        if (machineExists && !socket.connected) {
-          socket.connect();
-          clearInterval(intervalId); // stop polling
-        }
-      }, 500);
-    } else {
-      socket.connect();
-    }
+    // finally connect
+    socket.connect();
   },
   incrementNamespace: (namespaceId: NamespaceId) => {
     const namespace_path = serializeNamespaceId(namespaceId);
@@ -389,7 +386,7 @@ const useSocketioStore = create<SocketioStore>()((set, get) => ({
 
     // check if the namespace exists
     const namespace = get().namespaces[namespace_path];
-    /*if (namespace) {
+    if (namespace) {
       set(
         produce((state: SocketioStore) => {
           // decrement the count
@@ -433,7 +430,7 @@ const useSocketioStore = create<SocketioStore>()((set, get) => ({
           }
         }),
       );
-    }*/
+    }
   },
 }));
 

electron/src/client/softReload.ts

@@ -1,17 +0,0 @@
-import { mainNamespaceStore, mainMessageHandler } from "./mainNamespace";
-
-// Soft reset function
-export function softReloadMainNamespaceStore() {
-  // 1️⃣ Reset the store to initial state
-  mainNamespaceStore.setState({
-    ethercatDevices: null,
-    machines: null,
-    ethercatInterfaceDiscovery: null,
-  });
-
-  // 2️⃣ Re-attach the message handler if needed
-  // This ensures future socket events still update the store
-  mainMessageHandler(mainNamespaceStore);
-
-  console.log("MainNamespaceStore soft reloaded");
-}

electron/src/components/UpdateProgressBar.tsx

@@ -1,137 +0,0 @@
-import React from "react";
-import { Icon } from "./Icon";
-import { cn } from "@/lib/utils";
-import type { UpdateStep } from "@/stores/updateStore";
-
-interface UpdateProgressBarProps {
-  steps: UpdateStep[];
-  overallProgress: number;
-  className?: string;
-}
-
-export function UpdateProgressBar({
-  steps,
-  overallProgress,
-  className,
-}: UpdateProgressBarProps) {
-  return (
-    <div className={cn("space-y-4", className)}>
-      {/* Overall Progress Bar */}
-      <div className="space-y-2">
-        <div className="flex items-center justify-between">
-          <span className="text-sm font-medium">Overall Progress</span>
-          <span className="text-sm font-semibold tabular-nums">
-            {overallProgress}%
-          </span>
-        </div>
-        <div className="relative h-2.5 w-full overflow-hidden rounded-full bg-gray-200 dark:bg-gray-800">
-          <div
-            className="h-full rounded-full bg-gray-900 transition-all duration-500 ease-out dark:bg-gray-100"
-            style={{ width: `${overallProgress}%` }}
-          />
-        </div>
-      </div>
-
-      {/* Steps List */}
-      <div className="space-y-2">
-        {steps.map((step) => (
-          <div
-            key={step.id}
-            className={cn(
-              "flex items-center gap-3 rounded border px-3 py-2.5 transition-all duration-200",
-              step.status === "in-progress" &&
-                "border-gray-400 bg-gray-50 dark:border-gray-600 dark:bg-gray-900",
-              step.status === "completed" &&
-                "border-gray-300 bg-white dark:border-gray-700 dark:bg-gray-950",
-              step.status === "error" &&
-                "border-red-300 bg-red-50 dark:border-red-800 dark:bg-red-950/30",
-              step.status === "pending" &&
-                "border-gray-200 bg-white dark:border-gray-800 dark:bg-gray-950",
-            )}
-          >
-            {/* Status Icon */}
-            <div className="flex-shrink-0">
-              {step.status === "pending" && (
-                <div className="size-5 rounded-full border-2 border-gray-300 dark:border-gray-700" />
-              )}
-              {step.status === "in-progress" && (
-                <Icon
-                  name="lu:Loader"
-                  className="size-5 animate-spin text-gray-600 dark:text-gray-400"
-                />
-              )}
-              {step.status === "completed" && (
-                <div className="flex size-5 items-center justify-center rounded-full bg-gray-700 dark:bg-gray-300">
-                  <Icon
-                    name="lu:Check"
-                    className="size-3 text-white dark:text-gray-900"
-                  />
-                </div>
-              )}
-              {step.status === "error" && (
-                <div className="flex size-5 items-center justify-center rounded-full bg-red-600 dark:bg-red-500">
-                  <Icon name="lu:X" className="size-3 text-white" />
-                </div>
-              )}
-            </div>
-
-            {/* Step Content */}
-            <div className="min-w-0 flex-1">
-              <div className="flex items-center justify-between gap-2">
-                <div className="flex items-center gap-2">
-                  <span
-                    className={cn(
-                      "text-sm",
-                      step.status === "completed" &&
-                        "text-gray-600 dark:text-gray-400",
-                      step.status === "error" &&
-                        "font-medium text-red-700 dark:text-red-400",
-                      step.status === "in-progress" &&
-                        "font-medium text-gray-900 dark:text-gray-100",
-                      step.status === "pending" &&
-                        "text-gray-500 dark:text-gray-500",
-                    )}
-                  >
-                    {step.label}
-                  </span>
-                  {/* Subsector Badge - minimal inline display */}
-                  <span
-                    className={cn("text-xs text-gray-400 dark:text-gray-600")}
-                  >
-                    (
-                    {step.id === "rust-build"
-                      ? "rust & electron"
-                      : step.subsector}
-                    )
-                  </span>
-                </div>
-                {/* Progress percentage for in-progress steps */}
-                {step.status === "in-progress" &&
-                  step.progress !== undefined &&
-                  step.progress > 0 && (
-                    <span className="text-xs font-medium text-gray-600 tabular-nums dark:text-gray-400">
-                      {Math.round(step.progress)}%
-                    </span>
-                  )}
-              </div>
-
-              {/* Progress bar for steps with detailed tracking */}
-              {step.status === "in-progress" &&
-                step.progress !== undefined &&
-                step.progress > 0 && (
-                  <div className="mt-2">
-                    <div className="h-1.5 w-full overflow-hidden rounded-full bg-gray-200 dark:bg-gray-700">
-                      <div
-                        className="h-full rounded-full bg-gray-700 transition-all duration-500 dark:bg-gray-300"
-                        style={{ width: `${step.progress}%` }}
-                      />
-                    </div>
-                  </div>
-                )}
-            </div>
-          </div>
-        ))}
-      </div>
-    </div>
-  );
-}

electron/src/control/EditValue.tsx

@@ -109,7 +109,7 @@ export function EditValue({
   type FormSchema = z.infer<typeof formSchema>;
 
   const form = useForm<FormSchema>({
-    resolver: zodResolver(formSchema),
+    resolver: zodResolver<FormSchema>(formSchema),
     values: { value: value ?? defaultOrZero },
     defaultValues: { value: defaultValue },
     mode: "all",

electron/src/helpers/ipc/update/update-channels.ts

@@ -2,4 +2,3 @@ export const UPDATE_EXECUTE = "update:execute";
 export const UPDATE_LOG = "update:log";
 export const UPDATE_END = "update:end";
 export const UPDATE_CANCEL = "update:cancel";
-export const UPDATE_STEP = "update:step";

electron/src/helpers/ipc/update/update-context.ts

@@ -3,7 +3,6 @@ import {
   UPDATE_END,
   UPDATE_EXECUTE,
   UPDATE_LOG,
-  UPDATE_STEP,
 } from "./update-channels";
 
 type UpdateExecuteInvokeParams = {
@@ -17,20 +16,11 @@ type UpdateExecuteInvokeParams = {
   };
 };
 
-type UpdateStepParams = {
-  stepId: string;
-  status: "pending" | "in-progress" | "completed" | "error";
-  progress?: number;
-};
-
 export function exposeUpdateContext() {
   const { contextBridge, ipcRenderer } = window.require("electron");
 
   let currentLogListener: ((event: any, log: string) => void) | null = null;
   let currentEndListener: ((event: any, params: any) => void) | null = null;
-  let currentStepListener:
-    | ((event: any, params: UpdateStepParams) => void)
-    | null = null;
 
   contextBridge.exposeInMainWorld("update", {
     execute: (params: UpdateExecuteInvokeParams) =>
@@ -62,17 +52,5 @@ export function exposeUpdateContext() {
 
       ipcRenderer.on(UPDATE_END, currentEndListener);
     },
-
-    onStep: (callback: (params: UpdateStepParams) => void) => {
-      if (currentStepListener) {
-        ipcRenderer.removeListener(UPDATE_STEP, currentStepListener);
-      }
-
-      currentStepListener = (_event, params) => {
-        callback(params);
-      };
-
-      ipcRenderer.on(UPDATE_STEP, currentStepListener);
-    },
   });
 }

electron/src/helpers/ipc/update/update-listeners.ts

@@ -4,7 +4,6 @@ import {
   UPDATE_END,
   UPDATE_EXECUTE,
   UPDATE_LOG,
-  UPDATE_STEP,
 } from "./update-channels";
 import { spawn, ChildProcess } from "child_process";
 import tkill from "@jub3i/tree-kill";
@@ -117,13 +116,6 @@ async function update(
           commit,
         });
 
-        // Reset Rust build progress tracking
-        rustBuildProgress = {
-          totalDerivations: 0,
-          builtDerivations: 0,
-          maxPercent: 0,
-        };
-
         const qitechControlEnv = process.env.QITECH_CONTROL_ENV;
         const homeDir =
           qitechControlEnv === "control-os" ? "/home/qitech" : process.env.HOME;
@@ -137,8 +129,6 @@ async function update(
 
         // 1. first make sure the clone path is empty by deleting it if it containsa .git folder
         const repoDir = `${homeDir}/${githubRepoName}`;
-
-        // Clear repo (not tracked in progress UI)
         const clearResult = await clearRepoDirectory(
           `${homeDir}/${githubRepoName}`,
           event,
@@ -149,10 +139,6 @@ async function update(
         }
 
         // 2. clone the repository
-        event.sender.send(UPDATE_STEP, {
-          stepId: "clone-repo",
-          status: "in-progress",
-        });
         const cloneResult = await cloneRepository(
           {
             githubRepoOwner,
@@ -165,19 +151,11 @@ async function update(
           event,
         );
         if (!cloneResult.success) {
-          event.sender.send(UPDATE_STEP, {
-            stepId: "clone-repo",
-            status: "error",
-          });
           event.sender.send(UPDATE_LOG, cloneResult.error);
           return;
         }
-        event.sender.send(UPDATE_STEP, {
-          stepId: "clone-repo",
-          status: "completed",
-        });
 
-        // 3. make the nixos-install.sh script executable (not tracked in progress UI)
+        // 3. make the nixos-install.sh script executable
         const chmodResult = await runCommand(
           "chmod",
           ["+x", "nixos-install.sh"],
@@ -190,35 +168,17 @@ async function update(
         }
 
         // 4. run the nixos-install.sh script
-        // This script will handle rust-build, electron-build, and system-install
-        // Start with rust-build (cargo builds)
-        event.sender.send(UPDATE_STEP, {
-          stepId: "rust-build",
-          status: "in-progress",
-        });
-
-        const installResult = await runCommandWithStepTracking(
+        const installResult = await runCommand(
           "./nixos-install.sh",
           [],
           repoDir,
           event,
         );
-
         if (!installResult.success) {
-          // Mark current and remaining steps as error
-          event.sender.send(UPDATE_STEP, {
-            stepId: "rust-build",
-            status: "error",
-          });
-          event.sender.send(UPDATE_STEP, {
-            stepId: "system-install",
-            status: "error",
-          });
           event.sender.send(UPDATE_LOG, installResult.error);
           return;
         }
 
-        // Success - steps are already marked as completed by runCommandWithStepTracking
         resolve();
       } catch (error: any) {
         reject(error);
@@ -284,7 +244,7 @@ async function cloneRepository(
     : `https://github.com/${githubRepoOwner}/${githubRepoName}.git`;
 
   // Determine clone arguments based on whether tag, branch, or commit is specified
-  const cloneArgs = ["clone", "--progress", repoUrl];
+  const cloneArgs = ["clone", repoUrl];
 
   if (tag) {
     // Clone a specific tag
@@ -373,11 +333,6 @@ async function runCommand(
       const log = data.toString();
       console.error(log);
       event.sender.send(UPDATE_LOG, log);
-
-      // Git outputs progress to stderr
-      if (cmd === "git" && args.includes("--progress")) {
-        parseGitProgress(log, event);
-      }
     });
 
     // Handle process completion
@@ -431,249 +386,6 @@ async function runCommand(
   }
 }
 
-// Parse Git clone progress
-function parseGitProgress(
-  log: string,
-  event: Electron.IpcMainInvokeEvent,
-): void {
-  // Git progress format: "Receiving objects: 45% (234/520)"
-  // or "Resolving deltas: 100% (150/150)"
-  const receivingMatch = log.match(/Receiving objects:\s*(\d+)%/);
-  const resolvingMatch = log.match(/Resolving deltas:\s*(\d+)%/);
-
-  if (receivingMatch) {
-    const percent = parseInt(receivingMatch[1], 10);
-    event.sender.send(UPDATE_STEP, {
-      stepId: "clone-repo",
-      status: "in-progress",
-      progress: Math.floor(percent * 0.8), // Receiving is 80% of clone
-    });
-  } else if (resolvingMatch) {
-    const percent = parseInt(resolvingMatch[1], 10);
-    event.sender.send(UPDATE_STEP, {
-      stepId: "clone-repo",
-      status: "in-progress",
-      progress: Math.floor(80 + percent * 0.2), // Resolving is last 20%
-    });
-  }
-}
-
-// Track Rust build progress
-let rustBuildProgress = {
-  totalDerivations: 0,
-  builtDerivations: 0,
-  maxPercent: 0, // Track max to prevent backward movement
-};
-
-// Parse Rust build output for progress
-function parseRustBuildOutput(
-  log: string,
-  event: Electron.IpcMainInvokeEvent,
-): void {
-  // Track derivations to build
-  const derivationsMatch = log.match(/these (\d+) derivations? will be built/i);
-  if (derivationsMatch) {
-    rustBuildProgress.totalDerivations = parseInt(derivationsMatch[1], 10);
-    rustBuildProgress.builtDerivations = 0;
-    rustBuildProgress.maxPercent = 0;
-    event.sender.send(UPDATE_STEP, {
-      stepId: "rust-build",
-      status: "in-progress",
-      progress: 0,
-    });
-    return;
-  }
-
-  // Track building packages
-  if (
-    log.includes("building '/nix/store/") ||
-    log.includes("building /nix/store/")
-  ) {
-    rustBuildProgress.builtDerivations++;
-
-    // Check if this is the server-deps package (one of the last builds)
-    const isServerDeps = log.includes("-server-deps");
-
-    let percent = 15;
-    if (isServerDeps) {
-      // server-deps indicates we're at 85%
-      percent = 85;
-    } else if (rustBuildProgress.totalDerivations > 0) {
-      const derivationProgress =
-        rustBuildProgress.builtDerivations / rustBuildProgress.totalDerivations;
-      percent = 15 + Math.floor(derivationProgress * 70); // Map to 15-85%
-    }
-
-    // Only move forward
-    percent = Math.max(percent, rustBuildProgress.maxPercent);
-    rustBuildProgress.maxPercent = percent;
-
-    event.sender.send(UPDATE_STEP, {
-      stepId: "rust-build",
-      status: "in-progress",
-      progress: percent,
-    });
-  }
-
-  // Track installing phase - go up to 90%
-  if (log.includes("installing") || log.includes("Installing")) {
-    const percent = Math.max(90, rustBuildProgress.maxPercent);
-    rustBuildProgress.maxPercent = percent;
-    event.sender.send(UPDATE_STEP, {
-      stepId: "rust-build",
-      status: "in-progress",
-      progress: percent,
-    });
-  }
-}
-
-// Enhanced version of runCommand that tracks build steps based on log output
-async function runCommandWithStepTracking(
-  cmd: string,
-  args: string[],
-  workingDir: string,
-  event: Electron.IpcMainInvokeEvent,
-): Promise<{ success: boolean; error?: string }> {
-  try {
-    const completeCommand = `${cmd} ${args.join(" ")}`;
-    const workingDirText = terminalGray(workingDir);
-    event.sender.send(
-      UPDATE_LOG,
-      `🚀 ${workingDirText} ${terminalColor("blue", completeCommand)}`,
-    );
-
-    const childProcess = spawn(cmd, args, {
-      cwd: workingDir,
-    });
-
-    // Store reference to current process for cancellation
-    currentUpdateProcess = childProcess;
-
-    // Track which steps have been marked as in-progress
-    // Note: rust-build is already marked as in-progress before calling this function
-    let systemInstallStarted = false;
-
-    // Function to process log output and update steps
-    const processLogForSteps = (log: string) => {
-      const logLower = log.toLowerCase();
-
-      // Parse Rust build progress
-      parseRustBuildOutput(log, event);
-
-      // Check for system install indicators
-      // System install happens after Rust build completes (at ~90%)
-      // Look for bootloader/activation messages that indicate final system installation
-      if (
-        !systemInstallStarted &&
-        rustBuildProgress.maxPercent >= 90 &&
-        (logLower.includes("updating grub") ||
-          logLower.includes("installing bootloader") ||
-          logLower.includes("updating bootloader") ||
-          logLower.includes("activating the configuration") ||
-          logLower.includes("building the system configuration") ||
-          logLower.includes("these 0 derivations"))
-      ) {
-        console.log("🟢 Detected system install start:", log.substring(0, 100));
-        // Mark rust as complete, start system install
-        event.sender.send(UPDATE_STEP, {
-          stepId: "rust-build",
-          status: "completed",
-        });
-        event.sender.send(UPDATE_STEP, {
-          stepId: "system-install",
-          status: "in-progress",
-        });
-        systemInstallStarted = true;
-      }
-    };
-
-    // Stream stdout logs back to renderer
-    childProcess.stdout.on("data", (data) => {
-      const log = data.toString();
-      console.log(log);
-      event.sender.send(UPDATE_LOG, log);
-      processLogForSteps(log);
-    });
-
-    // Stream stderr logs back to renderer
-    childProcess.stderr.on("data", (data) => {
-      const log = data.toString();
-      console.error(log);
-      event.sender.send(UPDATE_LOG, log);
-      processLogForSteps(log);
-    });
-
-    // Handle process completion
-    return new Promise((resolve, reject) => {
-      childProcess.on("close", (code, signal) => {
-        // Clear process reference when completed
-        if (currentUpdateProcess === childProcess) {
-          currentUpdateProcess = null;
-        }
-
-        if (signal === "SIGTERM" || signal === "SIGKILL") {
-          event.sender.send(UPDATE_LOG, terminalInfo("Command was cancelled"));
-          reject({
-            success: false,
-            error: "Command was cancelled",
-          });
-        } else if (code === 0) {
-          // Mark all remaining steps as completed on success
-          if (!systemInstallStarted) {
-            event.sender.send(UPDATE_STEP, {
-              stepId: "rust-build",
-              status: "completed",
-            });
-            event.sender.send(UPDATE_STEP, {
-              stepId: "system-install",
-              status: "completed",
-            });
-          } else {
-            event.sender.send(UPDATE_STEP, {
-              stepId: "system-install",
-              status: "completed",
-            });
-          }
-
-          event.sender.send(
-            UPDATE_LOG,
-            terminalSuccess("Command completed successfully"),
-          );
-          resolve({ success: true, error: undefined });
-        } else {
-          event.sender.send(
-            UPDATE_LOG,
-            terminalError(`Command failed with code ${code}`),
-          );
-          reject({
-            success: false,
-            error: terminalError(code?.toString() ?? "NO_CODE"),
-          });
-        }
-      });
-
-      childProcess.on("error", (err) => {
-        // Clear process reference on error
-        if (currentUpdateProcess === childProcess) {
-          currentUpdateProcess = null;
-        }
-
-        event.sender.send(
-          UPDATE_LOG,
-          terminalError(`Command error: ${err.message}`),
-        );
-        reject({
-          success: false,
-          error: terminalError(err.message),
-        });
-      });
-    });
-  } catch (error: any) {
-    event.sender.send(UPDATE_LOG, terminalError(`Error: ${error.toString()}`));
-    return { success: false, error: error.toString() };
-  }
-}
-
 function terminalColor(
   color: "blue" | "green" | "red" | "cyan" | "gray",
   text: string,

electron/src/helpers/update_helpers.ts

@@ -2,13 +2,6 @@ import type { UpdateInfo } from "@/stores/updateStore";
 import { useUpdateStore } from "@/stores/updateStore";
 
 let currentLogListener: ((line: string) => void) | null = null;
-let currentStepListener:
-  | ((params: {
-      stepId: string;
-      status: "pending" | "in-progress" | "completed" | "error";
-      progress?: number;
-    }) => void)
-  | null = null;
 
 export async function updateExecute(
   source: UpdateInfo,
@@ -21,32 +14,15 @@ export async function updateExecute(
       currentLogListener = null;
     }
 
-    if (currentStepListener) {
-      window.update.onStep(() => {}); // clear previous
-      currentStepListener = null;
-    }
-
     currentLogListener = onLog;
     window.update.onLog(currentLogListener);
 
-    // Set up step listener
-    currentStepListener = (params) => {
-      const { setStepStatus, setStepProgress } = useUpdateStore.getState();
-      setStepStatus(params.stepId, params.status);
-      if (params.progress !== undefined) {
-        setStepProgress(params.stepId, params.progress);
-      }
-    };
-    window.update.onStep(currentStepListener);
-
     window.update.execute(source);
 
     window.update.onEnd((params) => {
       window.update.onLog(() => {}); // remove listener
       window.update.onEnd(() => {});
-      window.update.onStep(() => {}); // remove step listener
       currentLogListener = null;
-      currentStepListener = null;
       resolve(params);
     });
   });
@@ -79,7 +55,6 @@ export async function updateCancel(): Promise<{
   const result = await window.update.cancel();
   window.update.onLog(() => {}); // remove listener
   window.update.onEnd(() => {}); // remove listener
-  window.update.onStep(() => {}); // remove step listener
   return result;
 }
 

electron/src/machines/buffer/buffer1/buffer1Namespace.ts

@@ -62,6 +62,7 @@ export const connectedMachineStateSchema = z.object({
 /**
  * Consolidated state event schema (state changes only)
  */
+
 export const stateEventDataSchema = z.object({
   mode_state: modeStateSchema,
   connected_machine_state: connectedMachineStateSchema,

electron/src/machines/extruder/extruder2/Extruder2Settings.tsx

@@ -239,50 +239,6 @@ export function Extruder2SettingsPage() {
                 />
               </Label>
             </ControlCard>
-            <ControlCard title="Temperature PID Settings (Nozzle) ">
-              <Label label="Kp">
-                <EditValue
-                  value={state?.pid_settings.temperature.nozzle.kp}
-                  defaultValue={
-                    defaultState?.pid_settings.temperature.nozzle.kp
-                  }
-                  min={0}
-                  max={100}
-                  step={0.001}
-                  renderValue={(v) => roundToDecimals(v, 3)}
-                  onChange={(v) => setTemperaturePidValue("nozzle", "kp", v)}
-                  title="Temperature PID KP"
-                />
-              </Label>
-              <Label label="Ki">
-                <EditValue
-                  value={state?.pid_settings.temperature.nozzle.ki}
-                  defaultValue={
-                    defaultState?.pid_settings.temperature.nozzle.ki
-                  }
-                  min={0}
-                  max={100}
-                  step={0.001}
-                  renderValue={(v) => roundToDecimals(v, 3)}
-                  onChange={(v) => setTemperaturePidValue("nozzle", "ki", v)}
-                  title="Temperature PID KI"
-                />
-              </Label>
-              <Label label="Kd">
-                <EditValue
-                  value={state?.pid_settings.temperature.nozzle.kd}
-                  defaultValue={
-                    defaultState?.pid_settings.temperature.nozzle.kd
-                  }
-                  min={0}
-                  max={100}
-                  step={0.001}
-                  renderValue={(v) => roundToDecimals(v, 3)}
-                  onChange={(v) => setTemperaturePidValue("nozzle", "kd", v)}
-                  title="Temperature PID KD"
-                />
-              </Label>
-            </ControlCard>
           </ControlGrid>
         </>
       )}

electron/src/machines/extruder/extruder2/extruder2Namespace.ts

@@ -149,12 +149,6 @@ export const pidSettingsSchema = z.object({
       kd: z.number(),
       zone: z.string(),
     }),
-    nozzle: z.object({
-      ki: z.number(),
-      kp: z.number(),
-      kd: z.number(),
-      zone: z.string(),
-    }),
   }),
   pressure: z.object({
     ki: z.number(),

electron/src/machines/extruder/extruder2/useExtruder.ts

@@ -294,7 +294,7 @@ export function useExtruder2() {
   };
 
   const setTemperaturePidValue = (
-    zone: "front" | "middle" | "back" | "nozzle",
+    zone: "front" | "middle" | "back",
     key: "kp" | "ki" | "kd",
     value: number,
   ) => {

electron/src/setup/UpdateExecutePage.tsx

@@ -3,7 +3,6 @@ import { Page } from "@/components/Page";
 import { SectionTitle } from "@/components/SectionTitle";
 import { Terminal } from "@/components/Terminal";
 import { TouchButton } from "@/components/touch/TouchButton";
-import { UpdateProgressBar } from "@/components/UpdateProgressBar";
 import { updateExecute, updateCancelWithStore } from "@/helpers/update_helpers";
 import { useUpdateStore } from "@/stores/updateStore";
 import { useSearch } from "@tanstack/react-router";
@@ -19,15 +18,12 @@ export function UpdateExecutePage() {
     isUpdating,
     terminalLines,
     currentUpdateInfo,
-    steps,
-    overallProgress,
     setUpdateInfo,
     startUpdate,
     stopUpdate,
     addTerminalLine,
     clearTerminalLines,
     resetUpdateState,
-    initializeSteps,
   } = useUpdateStore();
 
   // Set update info from search params when component mounts or search changes
@@ -54,7 +50,6 @@ export function UpdateExecutePage() {
       commit: search.commit,
     };
 
-    initializeSteps();
     startUpdate();
     // Perhaps we just need to clear the logs ?
     const res = await updateExecute(updateInfo, addTerminalLine);
@@ -143,15 +138,6 @@ export function UpdateExecutePage() {
         </Alert>
       )}
 
-      {/* Progress Bar */}
-      {isUpdating && (
-        <UpdateProgressBar
-          steps={steps}
-          overallProgress={overallProgress}
-          className="mb-4"
-        />
-      )}
-
       <Terminal
         lines={terminalLines}
         className="h-160"

electron/src/stores/updateStore.ts

@@ -10,21 +10,10 @@ export type UpdateInfo = {
   commit?: string;
 };
 
-export type UpdateStep = {
-  id: string;
-  label: string;
-  status: "pending" | "in-progress" | "completed" | "error";
-  subsector: "nixos" | "rust" | "electron" | "general";
-  progress?: number; // 0-100 for steps with detailed progress tracking
-};
-
 export type UpdateState = {
   isUpdating: boolean;
   terminalLines: string[];
   currentUpdateInfo: UpdateInfo | null;
-  steps: UpdateStep[];
-  currentStepIndex: number;
-  overallProgress: number; // 0-100
 };
 
 export type UpdateActions = {
@@ -34,80 +23,14 @@ export type UpdateActions = {
   addTerminalLine: (line: string) => void;
   clearTerminalLines: () => void;
   resetUpdateState: () => void;
-  setStepStatus: (stepId: string, status: UpdateStep["status"]) => void;
-  setStepProgress: (stepId: string, progress: number) => void;
-  initializeSteps: () => void;
-  updateProgress: (progress: number) => void;
 };
 
 export type UpdateStore = UpdateState & UpdateActions;
 
-const defaultSteps: UpdateStep[] = [
-  {
-    id: "clone-repo",
-    label: "Clone repository",
-    status: "pending",
-    subsector: "general",
-    progress: 0,
-  },
-  {
-    id: "rust-build",
-    label: "Build system packages",
-    status: "pending",
-    subsector: "rust",
-    progress: 0,
-  },
-  {
-    id: "system-install",
-    label: "Install system update",
-    status: "pending",
-    subsector: "nixos",
-    progress: 0,
-  },
-];
-
-// Helper function to calculate overall progress based on step weights and individual progress
-const calculateOverallProgress = (steps: UpdateStep[]): number => {
-  // Define weights for each step (should sum to 100)
-  const stepWeights: Record<string, number> = {
-    "clone-repo": 10, // 10% for cloning
-    "rust-build": 80, // 80% for building (goes up to 90% internally)
-    "system-install": 10, // 10% for system installation
-  };
-
-  let totalProgress = 0;
-
-  steps.forEach((step) => {
-    const weight = stepWeights[step.id] || 0;
-
-    if (step.status === "completed") {
-      // Completed steps contribute their full weight
-      totalProgress += weight;
-    } else if (step.status === "in-progress") {
-      // In-progress steps: use progress value or 0 if not yet set
-      const stepProgress = step.progress ?? 0;
-
-      if (step.id === "rust-build") {
-        // Rust build progress is 0-90%, map it to 0-100% of its weight
-        totalProgress += (stepProgress / 90) * weight;
-      } else {
-        // Other steps: progress is 0-100%
-        totalProgress += (stepProgress / 100) * weight;
-      }
-    }
-    // Pending and error steps contribute 0
-  });
-
-  return Math.round(Math.min(100, Math.max(0, totalProgress)));
-};
-
 const initialState: UpdateState = {
   isUpdating: false,
   terminalLines: [],
   currentUpdateInfo: null,
-  steps: defaultSteps,
-  currentStepIndex: 0,
-  overallProgress: 0,
 };
 
 export const useUpdateStore = create<UpdateStore>((set) => ({
@@ -182,63 +105,6 @@ export const useUpdateStore = create<UpdateStore>((set) => ({
         state.isUpdating = false;
         state.terminalLines = [];
         state.currentUpdateInfo = null;
-        state.steps = defaultSteps.map((step) => ({ ...step }));
-        state.currentStepIndex = 0;
-        state.overallProgress = 0;
-      }),
-    ),
-
-  initializeSteps: () =>
-    set(
-      produce((state: UpdateState) => {
-        state.steps = defaultSteps.map((step) => ({ ...step }));
-        state.currentStepIndex = 0;
-        state.overallProgress = 0;
-      }),
-    ),
-
-  setStepStatus: (stepId: string, status: UpdateStep["status"]) =>
-    set(
-      produce((state: UpdateState) => {
-        const stepIndex = state.steps.findIndex((s) => s.id === stepId);
-        if (stepIndex !== -1) {
-          state.steps[stepIndex].status = status;
-
-          // Update current step index and ensure progress is initialized
-          if (status === "in-progress") {
-            state.currentStepIndex = stepIndex;
-            // Initialize progress to 0 if not already set
-            if (state.steps[stepIndex].progress === undefined) {
-              state.steps[stepIndex].progress = 0;
-            }
-          }
-
-          // Calculate overall progress based on step weights and progress
-          state.overallProgress = calculateOverallProgress(state.steps);
-        }
-      }),
-    ),
-
-  setStepProgress: (stepId: string, progress: number) =>
-    set(
-      produce((state: UpdateState) => {
-        const stepIndex = state.steps.findIndex((s) => s.id === stepId);
-        if (stepIndex !== -1) {
-          state.steps[stepIndex].progress = Math.min(
-            100,
-            Math.max(0, progress),
-          );
-
-          // Recalculate overall progress when step progress changes
-          state.overallProgress = calculateOverallProgress(state.steps);
-        }
-      }),
-    ),
-
-  updateProgress: (progress: number) =>
-    set(
-      produce((state: UpdateState) => {
-        state.overallProgress = Math.min(100, Math.max(0, progress));
       }),
     ),
 }));

electron/src/types.d.ts

@@ -46,13 +46,6 @@ interface UpdateContext {
   onEnd: (
     callback: (params: { success: boolean; error?: string }) => void,
   ) => void;
-  onStep: (
-    callback: (params: {
-      stepId: string;
-      status: "pending" | "in-progress" | "completed" | "error";
-      progress?: number;
-    }) => void,
-  ) => void;
 }
 
 interface TroubleshootContext {

ethercat-eeprom-dump/Cargo.toml

@@ -8,7 +8,7 @@ workspace = true
 
 [dependencies]
 clap = { version = "4.5.40", features = ["derive"] }
-ethercrab = "0.6.0"
+ethercrab = { git = "https://github.com/ethercrab-rs/ethercrab", branch = "main", features = ["xdp"] }
 interfaces = "0.0.9"
 tokio = { version = "1.45.1", features = ["macros", "rt-multi-thread"] }
 ethercat_hal = { path = "../ethercat-hal" }

ethercat-hal/Cargo.toml

@@ -8,11 +8,11 @@ workspace = true
 
 [dependencies]
 anyhow = "1.0.100"
-ethercrab = "0.6"
+ethercrab = { git = "https://github.com/ethercrab-rs/ethercrab", branch = "main", features = ["xdp"] }
 ethercat_hal_derive = { version = "0.1.0", path = "../ethercat-hal-derive" }
-units = { path = "../units" }
 bitvec = { version = "1.0.1", features = ["alloc"] }
 smol = "2.0.2"
+uom = { version = "0.36.0", default-features = false, features = ["f64","si"] }
 rand = "0.9.2"
 futures = "0.3.31"
 tracing = "0.1.41"

ethercat-hal/src/devices/el3001.rs

@@ -14,7 +14,7 @@ use crate::{
     io::analog_input::{AnalogInputDevice, AnalogInputInput},
 };
 use ethercat_hal_derive::{EthercatDevice, RxPdo, TxPdo};
-use units::{electric_potential::volt, f64::ElectricPotential};
+use uom::si::{electric_potential::volt, f64::ElectricPotential};
 
 #[derive(EthercatDevice)]
 pub struct EL3001 {

ethercat-hal/src/devices/el3021.rs

@@ -17,8 +17,8 @@ use crate::{
     io::analog_input::{AnalogInputDevice, AnalogInputInput},
 };
 use ethercat_hal_derive::{EthercatDevice, RxPdo, TxPdo};
-use units::electric_current::milliampere;
-use units::f64::ElectricCurrent;
+use uom::si::electric_current::milliampere;
+use uom::si::f64::ElectricCurrent;
 
 #[derive(Debug, Clone)]
 pub struct EL3021Configuration {

ethercat-hal/src/devices/el3024.rs

@@ -17,8 +17,8 @@ use crate::{
     io::analog_input::{AnalogInputDevice, AnalogInputInput},
 };
 use ethercat_hal_derive::{EthercatDevice, RxPdo, TxPdo};
-use units::electric_current::milliampere;
-use units::f64::ElectricCurrent;
+use uom::si::electric_current::milliampere;
+use uom::si::f64::ElectricCurrent;
 
 #[derive(Debug, Clone)]
 pub struct EL3024Configuration {

ethercat-hal/src/devices/el3062_0030.rs

@@ -15,7 +15,7 @@ use crate::{
     io::analog_input::{AnalogInputDevice, AnalogInputInput},
 };
 use ethercat_hal_derive::EthercatDevice;
-use units::{electric_potential::volt, f64::ElectricPotential};
+use uom::si::{electric_potential::volt, f64::ElectricPotential};
 
 #[derive(Debug, Clone)]
 pub struct EL3062_0030Configuration {

ethercat-hal/src/devices/el7031_0030/mod.rs

@@ -5,7 +5,7 @@ use anyhow::anyhow;
 use coe::EL7031_0030Configuration;
 use ethercat_hal_derive::EthercatDevice;
 use pdo::{EL7031_0030RxPdo, EL7031_0030TxPdo};
-use units::{electric_potential::volt, f64::ElectricPotential};
+use uom::si::{electric_potential::volt, f64::ElectricPotential};
 
 use crate::{
     helpers::{

ethercat-hal/src/io/analog_input/physical.rs

@@ -1,4 +1,4 @@
-use units::f64::{ElectricCurrent, ElectricPotential};
+use uom::si::f64::{ElectricCurrent, ElectricPotential};
 
 #[derive(Debug, Clone)]
 pub enum AnalogInputValue {
@@ -77,9 +77,9 @@ mod tests {
 
     use super::*;
     use approx::assert_relative_eq;
-    use units::electric_current::milliampere;
-    use units::electric_potential::volt;
-    use units::f64::{ElectricCurrent, ElectricPotential};
+    use uom::si::electric_current::milliampere;
+    use uom::si::electric_potential::volt;
+    use uom::si::f64::{ElectricCurrent, ElectricPotential};
 
     #[test]
     fn test_analog_input_getter_voltage() {

ethercat-hal/src/io/analog_input_dummy.rs

@@ -57,7 +57,7 @@ impl AnalogInputDummy {
 
 #[cfg(test)]
 mod tests {
-    use units::{electric_potential::volt, f64::ElectricPotential};
+    use uom::si::{electric_potential::volt, f64::ElectricPotential};
 
     use super::*;
 

machines/Cargo.toml

@@ -1,53 +0,0 @@
-[package]
-name = "machines"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-ethercrab = "0.6"
-ethercat_hal = { path = "../ethercat-hal" }
-control_core = { path = "../control-core" }
-control_core_derive = { path = "../control-core-derive" }
-units = { path = "../units" }
-
-serde = "1.0.217"
-anyhow = "1.0.100"
-
-bitvec = "1.0.1"
-lazy_static = "1.5.0"
-euclid = "0.22.11"
-
-# concurrency
-smol = "2.0.2"
-futures = "0.3.31"
-
-# web
-serde_json = "1.0.143"
-socketioxide = { version = "0.17.2", features = ["msgpack"] }
-
-# serial
-serialport = "4.7.3"
-
-#tracing
-tracing = { version = "0.1.41", features = ["attributes"] }
-tonic = { version = "0.13.1", optional = true }
-
-[dev-dependencies]
-approx = "0.5.1"
-textplots = "0.8.7"
-
-[features]
-default = ["tracing-fmt"]
-never_type = []
-tracing-fmt = []
-mock-machine = []
-memory-locking = []
-io-uring = []
-development-build = []
-
-
-
-
-
-[package.metadata.cargo-machete]
-ignored =  ["tonic"]

machines/src/aquapath1/act.rs

@@ -1,59 +0,0 @@
-use super::{AquaPathV1, AquaPathV1Mode};
-use crate::{MachineAct, MachineMessage};
-use std::time::{Duration, Instant};
-
-impl MachineAct for AquaPathV1 {
-    fn act(&mut self, now_ts: Instant) {
-        let msg = self.api_receiver.try_recv();
-        match msg {
-            Ok(msg) => {
-                let _res = self.act_machine_message(msg);
-            }
-            Err(_) => (),
-        };
-
-        match self.mode {
-            AquaPathV1Mode::Standby => {
-                self.switch_to_standby();
-            }
-            AquaPathV1Mode::Auto => {
-                self.switch_to_auto();
-            }
-        }
-
-        let now = Instant::now();
-
-        self.front_controller.update(now_ts);
-        self.back_controller.update(now_ts);
-
-        if now.duration_since(self.last_measurement_emit) > Duration::from_secs_f64(1.0 / 30.0) {
-            self.emit_live_values();
-            self.last_measurement_emit = now;
-        }
-    }
-
-    fn act_machine_message(&mut self, msg: MachineMessage) {
-        match msg {
-            MachineMessage::SubscribeNamespace(namespace) => {
-                self.namespace.namespace = Some(namespace);
-                self.emit_state();
-            }
-            MachineMessage::UnsubscribeNamespace => self.namespace.namespace = None,
-            MachineMessage::HttpApiJsonRequest(value) => {
-                use crate::MachineApi;
-
-                let _res = self.api_mutate(value);
-            }
-            MachineMessage::ConnectToMachine(_machine_connection) =>
-            /*Doesnt connec to any Machine do nothing*/
-            {
-                ()
-            }
-            MachineMessage::DisconnectMachine(_machine_connection) =>
-            /*Doesnt connec to any Machine do nothing*/
-            {
-                ()
-            }
-        }
-    }
-}

machines/src/buffer1/act.rs

@@ -1,47 +0,0 @@
-use super::BufferV1;
-use crate::{MachineAct, MachineMessage};
-use std::time::{Duration, Instant};
-
-impl MachineAct for BufferV1 {
-    fn act(&mut self, now: Instant) {
-        let msg = self.api_receiver.try_recv();
-        match msg {
-            Ok(msg) => {
-                let _res = self.act_machine_message(msg);
-            }
-            Err(_) => (),
-        };
-        // if last measurement is older than 1 second, emit a new measurement
-        if now.duration_since(self.last_measurement_emit) > Duration::from_secs_f64(1.0 / 30.0) {
-            // Emit live values at 30 FPS
-            self.emit_live_values();
-
-            self.last_measurement_emit = now;
-        }
-    }
-
-    fn act_machine_message(&mut self, msg: MachineMessage) {
-        match msg {
-            MachineMessage::SubscribeNamespace(namespace) => {
-                self.namespace.namespace = Some(namespace);
-                self.emit_state();
-            }
-            MachineMessage::UnsubscribeNamespace => self.namespace.namespace = None,
-            MachineMessage::HttpApiJsonRequest(value) => {
-                use crate::MachineApi;
-
-                let _res = self.api_mutate(value);
-            }
-            MachineMessage::ConnectToMachine(_machine_connection) =>
-            /*Doesnt connec to any Macine do nothing*/
-            {
-                ()
-            }
-            MachineMessage::DisconnectMachine(_machine_connection) =>
-            /*Doesnt connec to any Machine do nothing*/
-            {
-                ()
-            }
-        }
-    }
-}

machines/src/extruder1/mock/act.rs

@@ -1,45 +0,0 @@
-use super::ExtruderV2;
-use crate::MachineAct;
-use crate::MachineMessage;
-use std::time::{Duration, Instant};
-
-impl MachineAct for ExtruderV2 {
-    fn act(&mut self, now: Instant) {
-        let msg = self.api_receiver.try_recv();
-        match msg {
-            Ok(msg) => {
-                let _res = self.act_machine_message(msg);
-            }
-            Err(_) => (),
-        };
-        // more than 33ms have passed since last emit (30 "fps" target)
-        if now.duration_since(self.last_measurement_emit) > Duration::from_secs_f64(1.0 / 30.0) {
-            self.maybe_emit_state_event();
-            // Emit live values at 30 FPS
-            self.emit_live_values();
-            self.last_measurement_emit = now;
-        }
-    }
-
-    fn act_machine_message(&mut self, msg: crate::MachineMessage) {
-        match msg {
-            MachineMessage::SubscribeNamespace(namespace) => {
-                self.namespace.namespace = Some(namespace);
-                self.emit_state();
-                tracing::info!("extruder1 received subscribe");
-            }
-            MachineMessage::UnsubscribeNamespace => self.namespace.namespace = None,
-            MachineMessage::HttpApiJsonRequest(value) => {
-                use crate::MachineApi;
-
-                let _res = self.api_mutate(value);
-            }
-            MachineMessage::ConnectToMachine(_machine_connection) => (),
-            MachineMessage::DisconnectMachine(_machine_connection) =>
-            /*Doesnt connec to any Machine do nothing*/
-            {
-                ()
-            }
-        }
-    }
-}

machines/src/laser/act.rs

@@ -1,71 +0,0 @@
-use super::LaserMachine;
-use crate::MachineAct;
-use crate::MachineMessage;
-use std::time::{Duration, Instant};
-
-/// Implements the `MachineAct` trait for the `LaserMachine`.
-///
-/// # Parameters
-/// - `_now_ts`: The current timestamp of type `Instant`.
-///
-/// # Returns
-/// A pinned `Future` that resolves to `()` and is `Send`-safe. The future encapsulates the asynchronous behavior of the `act` method.
-///
-/// # Description
-/// This method is called to perform periodic actions for the `LaserMachine`. Specifically:
-/// - It checks if the time elapsed since the last measurement emission exceeds 20 milliseconds.
-/// - If the condition is met, it asynchronously emits live values at 60 FPS.
-///
-/// The method ensures that the diameter value is updated approximately 60 times per second.
-///
-impl MachineAct for LaserMachine {
-    fn act(&mut self, now: Instant) {
-        let msg = self.api_receiver.try_recv();
-        match msg {
-            Ok(msg) => {
-                let _res = self.act_machine_message(msg);
-            }
-            Err(_) => (),
-        };
-        self.update();
-
-        // more than 33ms have passed since last emit (30 "fps" target)
-        if now.duration_since(self.last_measurement_emit) > Duration::from_secs_f64(1.0 / 30.0) {
-            self.emit_live_values();
-            self.last_measurement_emit = now;
-        }
-    }
-
-    fn act_machine_message(&mut self, msg: MachineMessage) {
-        tracing::info!("{:?}", msg);
-        match msg {
-            MachineMessage::SubscribeNamespace(namespace) => {
-                self.namespace.namespace = Some(namespace);
-                self.emit_state();
-            }
-            MachineMessage::UnsubscribeNamespace => match &mut self.namespace.namespace {
-                Some(namespace) => {
-                    tracing::info!("UnsubscribeNamespace");
-                    namespace.socket_queue_tx.close();
-                    namespace.sockets.clear();
-                    namespace.events.clear();
-                }
-                None => todo!(),
-            },
-            MachineMessage::HttpApiJsonRequest(value) => {
-                use crate::MachineApi;
-                let _res = self.api_mutate(value);
-            }
-            MachineMessage::ConnectToMachine(_machine_connection) =>
-            /*Doesnt connec to any Macine do nothing*/
-            {
-                ()
-            }
-            MachineMessage::DisconnectMachine(_machine_connection) =>
-            /*Doesnt connec to any Machine do nothing*/
-            {
-                ()
-            }
-        }
-    }
-}

machines/src/lib.rs

@@ -1,400 +0,0 @@
-use anyhow::Error;
-use control_core::socketio::event::GenericEvent;
-use control_core::socketio::namespace::Namespace;
-use ethercat_hal::devices::{
-    EthercatDevice, SubDeviceIdentityTuple, downcast_device, subdevice_identity_to_tuple,
-};
-use ethercat_hal::helpers::ethercrab_types::EthercrabSubDevicePreoperational;
-use ethercrab::{SubDevice, SubDeviceRef};
-use machine_identification::{
-    DeviceHardwareIdentification, DeviceHardwareIdentificationEthercat, DeviceIdentification,
-    DeviceIdentificationIdentified, MachineIdentificationUnique,
-};
-use serde::Serialize;
-use smol::channel::Sender;
-use socketioxide::extract::SocketRef;
-use std::fmt::Debug;
-use std::{any::Any, sync::Arc, time::Instant};
-pub mod aquapath1;
-#[cfg(not(feature = "mock-machine"))]
-pub mod buffer1;
-pub mod extruder1;
-pub mod laser;
-pub mod machine_identification;
-pub mod mock;
-pub mod registry;
-pub mod serial;
-pub mod winder2;
-
-pub const VENDOR_QITECH: u16 = 0x0001;
-pub const MACHINE_WINDER_V1: u16 = 0x0002;
-pub const MACHINE_EXTRUDER_V1: u16 = 0x0004;
-pub const MACHINE_LASER_V1: u16 = 0x0006;
-pub const MACHINE_MOCK: u16 = 0x0007;
-pub const MACHINE_AQUAPATH_V1: u16 = 0x0009;
-#[cfg(not(feature = "mock-machine"))]
-pub const MACHINE_BUFFER_V1: u16 = 0x0008;
-
-use serde_json::Value;
-use smol::lock::RwLock;
-
-#[derive(Serialize, Debug, Clone)]
-pub struct MachineCrossConnectionState {
-    machine_identification_unique: Option<MachineIdentificationUnique>,
-    is_available: bool,
-}
-
-pub struct CrossConnection {
-    pub src: MachineIdentificationUnique,
-    pub dest: MachineIdentificationUnique,
-}
-
-pub enum AsyncThreadMessage {
-    NoMsg,
-    ConnectOneWayRequest(CrossConnection),
-    DisconnectMachines(CrossConnection),
-}
-
-pub struct MachineNewParams<
-    'maindevice,
-    'subdevices,
-    'device_identifications_identified,
-    'ethercat_devices,
-    'machine_new_hardware_etehrcat,
-    'machine_new_hardware_serial,
-    'machine_new_hardware,
-> where
-    'maindevice: 'machine_new_hardware,
-    'subdevices: 'machine_new_hardware,
-    'ethercat_devices: 'machine_new_hardware,
-    'machine_new_hardware_etehrcat: 'machine_new_hardware,
-{
-    pub device_group: &'device_identifications_identified Vec<DeviceIdentificationIdentified>,
-    pub hardware: &'machine_new_hardware MachineNewHardware<
-        'maindevice,
-        'subdevices,
-        'ethercat_devices,
-        'machine_new_hardware_etehrcat,
-        'machine_new_hardware_serial,
-    >,
-    pub socket_queue_tx: Sender<(SocketRef, Arc<GenericEvent>)>,
-    pub main_thread_channel: Option<Sender<AsyncThreadMessage>>,
-    pub namespace: Option<Namespace>,
-}
-
-impl MachineNewParams<'_, '_, '_, '_, '_, '_, '_> {
-    pub fn get_machine_identification_unique(&self) -> MachineIdentificationUnique {
-        self.device_group
-            .first()
-            .expect("device group must have at least one device")
-            .device_machine_identification
-            .machine_identification_unique
-            .clone()
-    }
-}
-
-pub enum MachineNewHardware<
-    'maindevice,
-    'subdevices,
-    'ethercat_devices,
-    'machine_new_hardware_etehrcat,
-    'machine_new_hardware_serial,
-> where
-    'maindevice: 'machine_new_hardware_etehrcat,
-    'subdevices: 'machine_new_hardware_etehrcat,
-    'ethercat_devices: 'machine_new_hardware_etehrcat,
-{
-    Ethercat(
-        &'machine_new_hardware_etehrcat MachineNewHardwareEthercat<
-            'maindevice,
-            'subdevices,
-            'ethercat_devices,
-        >,
-    ),
-    Serial(&'machine_new_hardware_serial MachineNewHardwareSerial),
-}
-
-pub struct MachineNewHardwareEthercat<'maindevice, 'subdevices, 'ethercat_devices> {
-    pub subdevices:
-        &'subdevices Vec<&'subdevices SubDeviceRef<'maindevice, &'subdevices SubDevice>>,
-    pub ethercat_devices: &'ethercat_devices Vec<Arc<RwLock<dyn EthercatDevice>>>,
-}
-
-pub trait SerialDevice: Any + Send + Sync + SerialDeviceNew + Debug {}
-
-pub trait SerialDeviceNew {
-    fn new_serial(
-        params: &SerialDeviceNewParams,
-    ) -> Result<(DeviceIdentification, Arc<RwLock<Self>>), anyhow::Error>
-    where
-        Self: Sized;
-}
-
-pub trait SerialDeviceThread {
-    fn start_thread() -> Result<(), anyhow::Error>;
-}
-
-pub struct SerialDeviceNewParams {
-    pub path: String,
-}
-
-#[derive(PartialEq, Eq, Clone, Debug, Hash)]
-pub struct SerialDeviceIdentification {
-    pub vendor_id: u16,
-    pub product_id: u16,
-}
-
-pub struct MachineNewHardwareSerial {
-    pub device: Arc<RwLock<dyn SerialDevice>>,
-}
-
-// validates that all devices in the group have the same machine identification
-pub fn validate_same_machine_identification_unique(
-    identified_device_group: &Vec<DeviceIdentificationIdentified>,
-) -> Result<(), Error> {
-    let machine_identification_unique = &identified_device_group
-        .first()
-        .ok_or_else(|| {
-            anyhow::anyhow!(
-                "[{}::validate_same_machine_identification] No devices in group",
-                module_path!()
-            )
-        })?
-        .device_machine_identification
-        .machine_identification_unique;
-    for device in identified_device_group.iter() {
-        if device
-            .device_machine_identification
-            .machine_identification_unique
-            != *machine_identification_unique
-        {
-            return Err(anyhow::anyhow!(
-                "[{}::validate_same_machine_identification] Different machine identifications",
-                module_path!()
-            ));
-        }
-    }
-    Ok(())
-}
-
-/// validates that every role is unique
-pub fn validate_no_role_dublicates(
-    identified_device_group: &Vec<DeviceIdentificationIdentified>,
-) -> Result<(), Error> {
-    let mut roles = vec![];
-    for device in identified_device_group.iter() {
-        if roles.contains(&device.device_machine_identification.role) {
-            return Err(anyhow::anyhow!(
-                "[{}::validate_no_role_dublicates] Role dublicate",
-                module_path!(),
-            ));
-        }
-        roles.push(device.device_machine_identification.role);
-    }
-    Ok(())
-}
-
-// Inside control_core::machines::new module:
-pub fn get_device_identification_by_role(
-    identified_device_group: &Vec<DeviceIdentificationIdentified>,
-    role: u16,
-) -> Result<&DeviceIdentificationIdentified, Error> {
-    for device in identified_device_group.iter() {
-        if device.device_machine_identification.role == role {
-            return Ok(device);
-        }
-    }
-    Err(anyhow::anyhow!(
-        "[{}::get_device_identification_by_role] Role {} not found",
-        module_path!(),
-        role
-    ))
-}
-
-pub fn get_device_by_index<'maindevice>(
-    devices: &Vec<Arc<RwLock<dyn EthercatDevice>>>,
-    subdevice_index: usize,
-) -> Result<Arc<RwLock<dyn EthercatDevice>>, Error> {
-    Ok(devices
-        .get(subdevice_index)
-        .ok_or(anyhow::anyhow!(
-            "[{}::get_device_by_index] Index {} out of bounds for devices",
-            module_path!(),
-            subdevice_index
-        ))?
-        .clone())
-}
-
-pub fn get_subdevice_by_index<'subdevices, 'maindevice>(
-    subdevices: &'subdevices Vec<&EthercrabSubDevicePreoperational<'maindevice>>,
-    subdevice_index: usize,
-) -> Result<&'subdevices EthercrabSubDevicePreoperational<'maindevice>, Error> {
-    Ok(subdevices.get(subdevice_index).ok_or(anyhow::anyhow!(
-        "Index {} out of bounds for subdevices",
-        subdevice_index
-    ))?)
-}
-
-pub fn get_ethercat_device_by_index<'maindevice>(
-    ethercat_devices: &Vec<Arc<RwLock<dyn EthercatDevice>>>,
-    subdevice_index: usize,
-) -> Result<Arc<RwLock<dyn EthercatDevice>>, Error> {
-    Ok(ethercat_devices
-        .get(subdevice_index)
-        .ok_or(anyhow::anyhow!(
-            "[{}::get_ethercat_device_by_index] Index {} out of bounds for ethercat devices",
-            module_path!(),
-            subdevice_index
-        ))?
-        .clone())
-}
-
-pub trait MachineNewTrait {
-    fn new(params: &MachineNewParams<'_, '_, '_, '_, '_, '_, '_>) -> Result<Self, anyhow::Error>
-    where
-        Self: Sized;
-}
-
-#[derive(Debug)]
-pub struct MachineConnection {
-    pub ident: MachineIdentificationUnique,
-    pub connection: Sender<MachineMessage>,
-}
-
-pub trait MachineAct {
-    fn act_machine_message(&mut self, msg: MachineMessage);
-    fn act(&mut self, now: Instant);
-}
-
-// generic MachineMessage allows us to implement actions
-// to manage or mutate machines with simple messages sent to the Recv Channel of the given Machine,
-// which the machine itself will handle to avoid locking
-// This also allows for simplified "CrossConnections"
-#[derive(Debug)]
-pub enum MachineMessage {
-    SubscribeNamespace(Namespace),
-    UnsubscribeNamespace,
-    HttpApiJsonRequest(serde_json::Value),
-    ConnectToMachine(MachineConnection),
-    DisconnectMachine(MachineConnection),
-}
-
-pub trait MachineApi {
-    fn api_get_sender(&self) -> Sender<MachineMessage>;
-    fn api_mutate(&mut self, value: Value) -> Result<(), anyhow::Error>;
-    fn api_event_namespace(&mut self) -> Option<Namespace>;
-}
-
-pub trait Machine: MachineAct + MachineNewTrait + MachineApi + Any + Debug + Send + Sync {
-    fn get_machine_identification_unique(&self) -> MachineIdentificationUnique;
-    fn get_main_sender(&self) -> Option<Sender<AsyncThreadMessage>>;
-}
-
-pub trait AnyGetters: Any {
-    fn as_any(&self) -> &dyn Any;
-    fn as_any_mut(&mut self) -> &mut dyn Any;
-}
-
-async fn get_device_ident<
-    'maindevice,
-    'subdevices,
-    'device_identifications_identified,
-    'ethercat_devices,
-    'machine_new_hardware_etehrcat,
-    'machine_new_hardware_serial,
-    'machine_new_hardware,
->(
-    params: &MachineNewParams<
-        'maindevice,
-        'subdevices,
-        'device_identifications_identified,
-        'ethercat_devices,
-        'machine_new_hardware_etehrcat,
-        'machine_new_hardware_serial,
-        'machine_new_hardware,
-    >,
-    role: u16,
-) -> Result<DeviceHardwareIdentificationEthercat, anyhow::Error> {
-    let device_identification = get_device_identification_by_role(params.device_group, role)?;
-    let device_hardware_identification_ethercat =
-        match &device_identification.device_hardware_identification {
-            DeviceHardwareIdentification::Ethercat(device_hardware_identification_ethercat) => {
-                device_hardware_identification_ethercat
-            }
-            _ => {
-                return Err(anyhow::anyhow!(
-                    "[{}::MachineNewTrait/ExtruderV2::new] Device with role {} is not Ethercat",
-                    module_path!(),
-                    role
-                ));
-            }
-        };
-    return Ok(device_hardware_identification_ethercat.clone());
-}
-
-async fn get_ethercat_device<
-    'maindevice,
-    'subdevices,
-    'device_identifications_identified,
-    'ethercat_devices,
-    'machine_new_hardware_etehrcat,
-    'machine_new_hardware_serial,
-    'machine_new_hardware,
-    T,
->(
-    hardware: &&MachineNewHardwareEthercat<'maindevice, 'subdevices, 'ethercat_devices>,
-    params: &MachineNewParams<
-        'maindevice,
-        'subdevices,
-        'device_identifications_identified,
-        'ethercat_devices,
-        'machine_new_hardware_etehrcat,
-        'machine_new_hardware_serial,
-        'machine_new_hardware,
-    >,
-    role: u16,
-    expected_identities: Vec<SubDeviceIdentityTuple>,
-) -> Result<
-    (
-        Arc<RwLock<T>>,
-        &'subdevices SubDeviceRef<'subdevices, &'subdevices SubDevice>,
-    ),
-    anyhow::Error,
->
-where
-    T: 'static + Send + Sync + EthercatDevice,
-{
-    let device_hardware_identification_ethercat = get_device_ident(params, role).await?;
-    let subdevice_index = device_hardware_identification_ethercat.subdevice_index;
-
-    let subdevice = get_subdevice_by_index(hardware.subdevices, subdevice_index)?;
-    let subdevice_identity = subdevice.identity();
-
-    let actual_identity = subdevice_identity_to_tuple(&subdevice_identity);
-
-    let mut matched_any_identity = false;
-    for identity in expected_identities.clone() {
-        if actual_identity == identity {
-            matched_any_identity = true;
-        }
-    }
-
-    if !matched_any_identity {
-        return Err(anyhow::anyhow!(
-            "[{}::MachineNewTrait/ExtruderV2::new] Device identity mismatch: expected {:?}",
-            module_path!(),
-            expected_identities
-        ));
-    }
-
-    let ethercat_device =
-        get_ethercat_device_by_index(&hardware.ethercat_devices, subdevice_index)?;
-    let device = downcast_device::<T>(ethercat_device).await?;
-
-    {
-        let mut device_guard = device.write().await;
-        device_guard.set_used(true);
-    }
-
-    Ok((device, subdevice))
-}

machines/src/serial/devices/winder_mock/mod.rs

@@ -1,56 +0,0 @@
-use crate::{
-    MACHINE_WINDER_V1, SerialDevice, SerialDeviceNew, SerialDeviceNewParams, VENDOR_QITECH,
-    machine_identification::{
-        DeviceHardwareIdentification, DeviceHardwareIdentificationSerial, DeviceIdentification,
-        DeviceMachineIdentification, MachineIdentification, MachineIdentificationUnique,
-    },
-};
-use control_core::helpers::hashing::{byte_folding_u16, hash_djb2};
-use smol::lock::RwLock;
-use std::sync::Arc;
-
-/// Mock serial device for testing MockMachine
-/// This provides a minimal SerialDevice implementation that doesn't require actual hardware
-#[derive(Debug)]
-pub struct WinderMockSerialDevice {
-    pub path: String,
-}
-
-impl SerialDevice for WinderMockSerialDevice {}
-
-impl SerialDeviceNew for WinderMockSerialDevice {
-    fn new_serial(
-        params: &SerialDeviceNewParams,
-    ) -> Result<(DeviceIdentification, Arc<RwLock<Self>>), anyhow::Error>
-    where
-        Self: Sized,
-    {
-        // Generate a unique serial number based on the path
-        let hash = hash_djb2(params.path.as_bytes());
-        let serial = byte_folding_u16(&hash.to_le_bytes());
-
-        let device_identification = DeviceIdentification {
-            device_machine_identification: Some(DeviceMachineIdentification {
-                machine_identification_unique: MachineIdentificationUnique {
-                    machine_identification: MachineIdentification {
-                        vendor: VENDOR_QITECH,
-                        machine: MACHINE_WINDER_V1,
-                    },
-                    serial,
-                },
-                role: 0,
-            }),
-            device_hardware_identification: DeviceHardwareIdentification::Serial(
-                DeviceHardwareIdentificationSerial {
-                    path: params.path.clone(),
-                },
-            ),
-        };
-
-        let mock_serial_device = Arc::new(RwLock::new(WinderMockSerialDevice {
-            path: params.path.clone(),
-        }));
-
-        Ok((device_identification, mock_serial_device))
-    }
-}

machines/src/serial/init.rs

@@ -1,199 +0,0 @@
-use serialport::UsbPortInfo;
-use smol::Task;
-use std::{collections::HashMap, time::Duration};
-/*
-*@author: Alisher Darmenov
-*@company: QiTech
-*@created: 20.04.2025
-*
-*@description: This module is responsible for usb detection and validation, specially made with serialport to avoid complexity and size of tokio_serial
-*/
-use crate::SerialDeviceIdentification;
-use serialport::{SerialPortInfo, SerialPortType};
-/// Handles scanning and caching of connected USB serial devices.
-pub struct SerialDetection {}
-
-impl SerialDetection {
-    /// Returns all serial ports on the system (minus macOS "cu" noise).
-    fn get_ports() -> Vec<SerialPortInfo> {
-        match serialport::available_ports() {
-            Ok(ports) => ports
-                .into_iter()
-                .filter(|port| !port.port_name.contains("cu"))
-                .collect(),
-            Err(_) => Vec::new(),
-        }
-    }
-
-    /// Extracts only USB serial devices from the port list.
-    fn extract_usb_serial_devices(port_list: Vec<SerialPortInfo>) -> HashMap<String, UsbPortInfo> {
-        let mut map = HashMap::new();
-
-        for port in port_list {
-            if let SerialPortType::UsbPort(usb_info) = port.port_type {
-                map.insert(port.port_name, usb_info);
-            }
-        }
-        map
-    }
-
-    /// Scans for connected USB serial devices and updates the internal map.
-    /// Returns a clone of the map for quick access.
-    pub fn detect_devices() -> HashMap<String, UsbPortInfo> {
-        let ports = Self::get_ports();
-        let usb_devices = Self::extract_usb_serial_devices(ports);
-        usb_devices
-    }
-
-    pub fn device_port_exists(device_path: &str) -> bool {
-        let ports = Self::get_ports();
-        return ports.iter().any(|p| p.port_name == device_path);
-    }
-
-    pub fn device_id_exists(sdevid: SerialDeviceIdentification) -> bool {
-        let ports = Self::get_ports();
-        for port in ports {
-            if let SerialPortType::UsbPort(usb_info) = port.port_type {
-                if usb_info.vid == sdevid.vendor_id && usb_info.pid == sdevid.product_id {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    pub fn get_path_by_id(
-        sdevid: SerialDeviceIdentification,
-        map: HashMap<String, UsbPortInfo>,
-    ) -> Option<String> {
-        for (port, usbport) in map.iter() {
-            if usbport.vid == sdevid.vendor_id && usbport.pid == sdevid.product_id {
-                return Some(port.clone());
-            }
-        }
-        return None;
-    }
-}
-
-// Async function that runs until at least one serial device is found.
-pub async fn find_serial() -> Option<HashMap<String, UsbPortInfo>> {
-    smol::Timer::after(Duration::from_secs(1)).await;
-
-    let devices = SerialDetection::detect_devices();
-    if !devices.is_empty() {
-        return Some(devices);
-    } else {
-        return None;
-    }
-}
-
-// Returns a smol::Task that resolves when atleast one device is found.
-pub fn start_serial_discovery() -> Task<Option<HashMap<String, UsbPortInfo>>> {
-    smol::spawn(find_serial())
-}
-
-/*
-
-pub async fn handle_serial_device_hotplug(
-    app_state: Arc<SharedState>,
-    map: Option<HashMap<String, UsbPortInfo>>,
-) {
-    let laser_ident = SerialDeviceIdentification {
-        vendor_id: 0x0403,
-        product_id: 0x6001,
-    };
-
-    let laser = match map {
-        Some(map) => SerialDetection::get_path_by_id(laser_ident, map),
-        None => None,
-    };
-
-    let mut unique_ident: Option<MachineIdentificationUnique> = None;
-
-    {
-        let machines = app_state.machines.read_arc_blocking();
-        for (id, _) in machines.iter() {
-            if id.machine_identification == LaserMachine::MACHINE_IDENTIFICATION {
-                unique_ident = Some(id.clone());
-                break;
-            }
-        }
-    }
-
-    // Machine isnt connected, so add it back
-    if laser.is_some() && unique_ident.is_none() {
-        let serial_params = SerialDeviceNewParams {
-            path: laser.unwrap(),
-        };
-        let _ = match Laser::new_serial(&serial_params) {
-            Ok((device_identification, serial_device)) => {
-                {
-                    let mut machines = app_state.machines.write().await;
-                    machines.add_serial_device(
-                        &device_identification,
-                        serial_device,
-                        &MACHINE_REGISTRY,
-                        app_state.socketio_setup.socket_queue_tx.clone(),
-                        Arc::downgrade(&app_state.machines),
-                    );
-                }
-
-                let app_state_event = app_state.clone();
-                let main_namespace = &mut app_state_event
-                    .socketio_setup
-                    .namespaces
-                    .write()
-                    .await
-                    .main_namespace;
-                let event = MachinesEventBuilder().build(app_state_event.clone());
-                main_namespace.emit(MainNamespaceEvents::MachinesEvent(event));
-            }
-            _ => (),
-        };
-    } else if laser.is_none() && unique_ident.is_some() {
-        let serial_params = SerialDeviceNewParams {
-            path: "".to_string(),
-        };
-
-        let _ = match Laser::new_serial(&serial_params) {
-            Ok((device_identification, _)) => {
-                app_state
-                    .machines
-                    .write()
-                    .await
-                    .remove_serial_device(&device_identification);
-                drop(app_state.machines.clone());
-
-                app_state
-                    .machines
-                    .write_arc()
-                    .await
-                    .serial_machines
-                    .remove(&unique_ident.clone().unwrap());
-
-                app_state
-                    .machines
-                    .write_arc()
-                    .await
-                    .ethercat_machines
-                    .remove(&unique_ident.clone().unwrap());
-
-                drop(app_state.machines.clone());
-
-                let main_namespace = &mut app_state
-                    .socketio_setup
-                    .namespaces
-                    .write()
-                    .await
-                    .main_namespace;
-
-                let event = MachinesEventBuilder().build(app_state.clone());
-                main_namespace.emit(MainNamespaceEvents::MachinesEvent(event));
-            }
-            _ => (),
-        };
-    }
-}
-
-
-*/

machines/src/winder2/act.rs

@@ -1,66 +0,0 @@
-#[cfg(not(feature = "mock-machine"))]
-use super::Winder2;
-#[cfg(not(feature = "mock-machine"))]
-use crate::{MachineAct, MachineMessage};
-#[cfg(not(feature = "mock-machine"))]
-use std::time::{Duration, Instant};
-#[cfg(not(feature = "mock-machine"))]
-
-impl MachineAct for Winder2 {
-    fn act(&mut self, now: Instant) {
-        let machine_message = self.api_receiver.try_recv();
-        match machine_message {
-            Ok(machine_message) => self.act_machine_message(machine_message),
-            Err(_e) => (),
-        };
-        // sync the spool speed
-        self.sync_spool_speed(now);
-
-        // sync the puller speed
-        self.sync_puller_speed(now);
-
-        // sync the traverse speed
-        self.sync_traverse_speed();
-
-        // automatically stops or pulls after N Meters if enabled
-        self.stop_or_pull_spool(now);
-
-        if self.traverse_controller.did_change_state() {
-            self.emit_state();
-        }
-
-        // more than 33ms have passed since last emit (30 "fps" target)
-        if now.duration_since(self.last_measurement_emit) > Duration::from_secs_f64(1.0 / 30.0) {
-            self.emit_live_values();
-            self.last_measurement_emit = now;
-        }
-    }
-
-    fn act_machine_message(&mut self, msg: MachineMessage) {
-        match msg {
-            MachineMessage::SubscribeNamespace(namespace) => {
-                self.namespace.namespace = Some(namespace);
-                self.emit_state();
-            }
-            MachineMessage::UnsubscribeNamespace => self.namespace.namespace = None,
-            MachineMessage::HttpApiJsonRequest(value) => {
-                use crate::MachineApi;
-                let _res = self.api_mutate(value);
-            }
-            MachineMessage::ConnectToMachine(machine_connection) => {
-                if self.connected_machines.len() >= self.max_connected_machines {
-                    tracing::debug!(
-                        "Refusing to add Machine Connection {:?}, since self.connected_machines would be over the limit of {:?}",
-                        machine_connection,
-                        self.max_connected_machines
-                    );
-                    return;
-                }
-                self.connected_machines.push(machine_connection);
-            }
-            MachineMessage::DisconnectMachine(_machine_connection) => {
-                self.connected_machines.clear();
-            }
-        }
-    }
-}

machines/src/winder2/mock/act.rs

@@ -1,43 +0,0 @@
-use super::Winder2;
-use crate::MachineAct;
-use crate::MachineMessage;
-use std::time::{Duration, Instant};
-
-impl MachineAct for Winder2 {
-    fn act(&mut self, now: Instant) {
-        let msg = self.api_receiver.try_recv();
-        match msg {
-            Ok(msg) => {
-                let _res = self.act_machine_message(msg);
-            }
-            Err(_) => (),
-        };
-        // more than 33ms have passed since last emit (30 "fps" target)
-        if now.duration_since(self.last_measurement_emit) > Duration::from_secs_f64(1.0 / 30.0) {
-            self.emit_live_values();
-            self.last_measurement_emit = now;
-        }
-    }
-
-    fn act_machine_message(&mut self, msg: crate::MachineMessage) {
-        match msg {
-            MachineMessage::SubscribeNamespace(namespace) => {
-                self.namespace.namespace = Some(namespace);
-                self.emit_state();
-                tracing::info!("extruder1 received subscribe");
-            }
-            MachineMessage::UnsubscribeNamespace => self.namespace.namespace = None,
-            MachineMessage::HttpApiJsonRequest(value) => {
-                use crate::MachineApi;
-
-                let _res = self.api_mutate(value);
-            }
-            MachineMessage::ConnectToMachine(_machine_connection) => (),
-            MachineMessage::DisconnectMachine(_machine_connection) =>
-            /*Doesnt connec to any Machine do nothing*/
-            {
-                ()
-            }
-        }
-    }
-}

machines/src/winder2/mock/api.rs

@@ -1,68 +0,0 @@
-use super::Winder2;
-use crate::{MachineApi, winder2::api::Mutation};
-use serde_json::Value;
-use std::time::Instant;
-
-impl MachineApi for Winder2 {
-    fn api_mutate(&mut self, request_body: Value) -> Result<(), anyhow::Error> {
-        let mutation: Mutation = serde_json::from_value(request_body)?;
-        match mutation {
-            Mutation::EnableTraverseLaserpointer(enable) => self.set_laser(enable),
-            Mutation::SetMode(mode) => self.set_mode(&mode.into()),
-            Mutation::SetTraverseLimitOuter(limit) => self.traverse_set_limit_outer(limit),
-            Mutation::SetTraverseLimitInner(limit) => self.traverse_set_limit_inner(limit),
-            Mutation::SetTraverseStepSize(size) => self.traverse_set_step_size(size),
-            Mutation::SetTraversePadding(padding) => self.traverse_set_padding(padding),
-            Mutation::GotoTraverseLimitOuter => self.traverse_goto_limit_outer(),
-            Mutation::GotoTraverseLimitInner => self.traverse_goto_limit_inner(),
-            Mutation::GotoTraverseHome => self.traverse_goto_home(),
-            Mutation::SetPullerRegulationMode(regulation) => self.puller_set_regulation(regulation),
-            Mutation::SetPullerTargetSpeed(value) => self.puller_set_target_speed(value),
-            Mutation::SetPullerTargetDiameter(_) => todo!(),
-            Mutation::SetPullerForward(value) => self.puller_set_forward(value),
-            Mutation::SetPullerGearRatio(gear_ratio) => self.puller_set_gear_ratio(gear_ratio),
-            Mutation::SetSpoolRegulationMode(mode) => self.spool_set_regulation_mode(mode),
-            Mutation::SetSpoolMinMaxMinSpeed(speed) => self.spool_set_minmax_min_speed(speed),
-            Mutation::SetSpoolMinMaxMaxSpeed(speed) => self.spool_set_minmax_max_speed(speed),
-            Mutation::SetSpoolForward(value) => self.spool_set_forward(value),
-            Mutation::SetSpoolAdaptiveTensionTarget(value) => {
-                self.spool_set_adaptive_tension_target(value)
-            }
-            Mutation::SetSpoolAdaptiveRadiusLearningRate(value) => {
-                self.spool_set_adaptive_radius_learning_rate(value)
-            }
-            Mutation::SetSpoolAdaptiveMaxSpeedMultiplier(value) => {
-                self.spool_set_adaptive_max_speed_multiplier(value)
-            }
-            Mutation::SetSpoolAdaptiveAccelerationFactor(value) => {
-                self.spool_set_adaptive_acceleration_factor(value)
-            }
-            Mutation::SetSpoolAdaptiveDeaccelerationUrgencyMultiplier(value) => {
-                self.spool_set_adaptive_deacceleration_urgency_multiplier(value)
-            }
-            Mutation::SetSpoolAutomaticRequiredMeters(meters) => {
-                self.set_spool_automatic_required_meters(meters)
-            }
-            Mutation::SetSpoolAutomaticAction(mode) => self.set_spool_automatic_mode(mode),
-            Mutation::ResetSpoolProgress => self.stop_or_pull_spool_reset(Instant::now()),
-            Mutation::ZeroTensionArmAngle => self.tension_arm_zero(),
-            Mutation::SetConnectedMachine(machine_identification_unique) => {
-                self.set_connected_buffer(machine_identification_unique)
-            }
-            Mutation::DisconnectMachine(machine_identification_unique) => {
-                self.disconnect_buffer(machine_identification_unique)
-            }
-        }
-        Ok(())
-    }
-
-    fn api_event_namespace(
-        &mut self,
-    ) -> std::option::Option<control_core::socketio::namespace::Namespace> {
-        self.namespace.namespace.clone()
-    }
-
-    fn api_get_sender(&self) -> smol::channel::Sender<crate::MachineMessage> {
-        self.api_sender.clone()
-    }
-}

machines/src/winder2/mock/mock_emit.rs

@@ -1,253 +0,0 @@
-use std::time::Instant;
-
-use super::Winder2;
-use crate::machine_identification::{MachineIdentification, MachineIdentificationUnique};
-use crate::winder2::Winder2Mode;
-use crate::winder2::api::LiveValuesEvent;
-use crate::winder2::api::{ModeState, SpoolAutomaticActionMode, StateEvent, Winder2Events};
-use crate::winder2::puller_speed_controller::{GearRatio, PullerRegulationMode};
-use crate::winder2::spool_speed_controller::SpoolSpeedControllerType;
-use crate::{MACHINE_WINDER_V1, VENDOR_QITECH};
-use control_core::socketio::event::BuildEvent;
-use control_core::socketio::namespace::NamespaceCacheingLogic;
-
-impl Winder2 {
-    pub const MACHINE_IDENTIFICATION: MachineIdentification = MachineIdentification {
-        vendor: VENDOR_QITECH,
-        machine: MACHINE_WINDER_V1,
-    };
-
-    pub fn stop_or_pull_spool_reset(&mut self, _now: Instant) {}
-    /// Implement Mode
-    pub fn set_mode(&mut self, mode: &Winder2Mode) {
-        self.mode_state = ModeState {
-            mode: mode.clone().into(),
-            can_wind: true,
-        };
-        self.emit_state();
-    }
-
-    /// Implement Traverse
-    pub fn set_laser(&mut self, value: bool) {
-        self.traverse_state.laserpointer = value;
-        self.emit_state();
-    }
-
-    pub fn traverse_set_limit_inner(&mut self, limit: f64) {
-        self.traverse_state.limit_inner = limit;
-        self.emit_state();
-    }
-
-    pub fn traverse_set_limit_outer(&mut self, limit: f64) {
-        self.traverse_state.limit_outer = limit;
-        self.emit_state();
-    }
-
-    pub fn traverse_set_step_size(&mut self, step_size: f64) {
-        self.traverse_state.step_size = step_size;
-        self.emit_state();
-    }
-
-    pub fn traverse_set_padding(&mut self, padding: f64) {
-        self.traverse_state.padding = padding;
-        self.emit_state();
-    }
-
-    pub fn traverse_goto_limit_inner(&mut self) {
-        self.traverse_state.position_in = self.traverse_state.limit_inner;
-        self.emit_state();
-    }
-
-    pub fn traverse_goto_limit_outer(&mut self) {
-        self.traverse_state.position_in = self.traverse_state.limit_outer;
-        self.emit_state();
-    }
-
-    pub fn traverse_goto_home(&mut self) {
-        self.traverse_state.position_in = 0.0;
-        self.emit_state();
-    }
-
-    pub fn emit_live_values(&mut self) {
-        let event = LiveValuesEvent {
-            traverse_position: Some(0.0),
-            puller_speed: 0.0,
-            spool_rpm: 0.0,
-            tension_arm_angle: 0.0,
-            spool_progress: 0.0,
-        };
-
-        let event = event.build();
-
-        self.namespace.emit(Winder2Events::LiveValues(event));
-    }
-
-    pub fn build_state_event(&mut self) -> StateEvent {
-        use crate::MachineCrossConnectionState;
-
-        let connected_machine = self.connected_machines.get(0);
-
-        let ident = match connected_machine {
-            Some(machine) => Some(machine.ident.clone()),
-            None => None,
-        };
-
-        let cross_conn = MachineCrossConnectionState {
-            machine_identification_unique: ident,
-            is_available: connected_machine.is_some(),
-        };
-
-        StateEvent {
-            is_default_state: self.is_default_state,
-            traverse_state: self.traverse_state.clone(),
-            puller_state: self.puller_state.clone(),
-            spool_automatic_action_state: self.spool_automatic_action_state.clone(),
-            mode_state: self.mode_state.clone(),
-            tension_arm_state: self.tension_arm_state.clone(),
-            spool_speed_controller_state: self.spool_speed_controller_state.clone(),
-            connected_machine_state: cross_conn,
-        }
-    }
-
-    pub fn emit_state(&mut self) {
-        let state = self.build_state_event();
-        let event = state.build();
-        self.namespace.emit(Winder2Events::State(event));
-    }
-
-    /// Apply the mode changes to the spool
-    ///
-    /// It contains a transition matrix for atomic changes.
-    /// It will set [`Self::spool_mode`]
-    fn set_traverse_mode(&mut self, mode: &Winder2Mode) {
-        self.mode_state = ModeState {
-            mode: crate::winder2::api::Mode::Standby,
-            can_wind: true,
-        };
-        self.emit_state();
-    }
-
-    /// Implement Tension Arm
-    pub fn tension_arm_zero(&mut self) {
-        self.tension_arm_state.zeroed = true;
-        self.emit_state();
-    }
-
-    pub fn set_spool_automatic_required_meters(&mut self, meters: f64) {
-        self.spool_automatic_action_state.spool_required_meters = meters;
-        self.emit_state();
-    }
-
-    pub fn set_spool_automatic_mode(&mut self, mode: SpoolAutomaticActionMode) {
-        self.spool_automatic_action_state
-            .spool_automatic_action_mode = mode;
-        self.emit_state();
-    }
-
-    pub fn puller_set_regulation(&mut self, puller_regulation_mode: PullerRegulationMode) {
-        self.puller_state.regulation = puller_regulation_mode;
-        self.emit_state();
-    }
-
-    /// Set target speed in m/min
-    pub fn puller_set_target_speed(&mut self, target_speed: f64) {
-        self.puller_state.target_speed = target_speed;
-        self.emit_state();
-    }
-
-    /// Set target diameter in mm
-    pub fn puller_set_target_diameter(&mut self, target_diameter: f64) {
-        self.puller_state.target_diameter = target_diameter;
-        self.emit_state();
-    }
-
-    /// Set forward direction
-    pub fn puller_set_forward(&mut self, forward: bool) {
-        self.puller_state.forward = forward;
-        self.emit_state();
-    }
-
-    /// Set gear ratio for winding speed
-    pub fn puller_set_gear_ratio(&mut self, gear_ratio: GearRatio) {
-        self.puller_state.gear_ratio = gear_ratio;
-        self.emit_state();
-    }
-
-    // Spool Speed Controller API methods
-    pub fn spool_set_regulation_mode(&mut self, regulation_mode: SpoolSpeedControllerType) {
-        self.spool_speed_controller_state.regulation_mode = regulation_mode;
-        self.emit_state();
-    }
-
-    /// Set minimum speed for minmax mode in RPM
-    pub fn spool_set_minmax_min_speed(&mut self, min_speed_rpm: f64) {
-        self.spool_speed_controller_state.minmax_min_speed = min_speed_rpm;
-        self.emit_state();
-    }
-
-    /// Set maximum speed for minmax mode in RPM
-    pub fn spool_set_minmax_max_speed(&mut self, max_speed_rpm: f64) {
-        self.spool_speed_controller_state.minmax_max_speed = max_speed_rpm;
-        self.emit_state();
-    }
-
-    /// Set tension target for adaptive mode (0.0-1.0)
-    pub fn spool_set_adaptive_tension_target(&mut self, tension_target: f64) {
-        self.spool_speed_controller_state.adaptive_tension_target = tension_target;
-        self.emit_state();
-    }
-
-    /// Set radius learning rate for adaptive mode
-    pub fn spool_set_adaptive_radius_learning_rate(&mut self, radius_learning_rate: f64) {
-        self.spool_speed_controller_state
-            .adaptive_radius_learning_rate = radius_learning_rate;
-        self.emit_state();
-    }
-
-    /// Set max speed multiplier for adaptive mode
-    pub fn spool_set_adaptive_max_speed_multiplier(&mut self, max_speed_multiplier: f64) {
-        self.spool_speed_controller_state
-            .adaptive_max_speed_multiplier = max_speed_multiplier;
-        self.emit_state();
-    }
-
-    /// Set acceleration factor for adaptive mode
-    pub fn spool_set_adaptive_acceleration_factor(&mut self, acceleration_factor: f64) {
-        self.spool_speed_controller_state
-            .adaptive_acceleration_factor = acceleration_factor;
-        self.emit_state();
-    }
-
-    /// Set deacceleration urgency multiplier for adaptive mode
-    pub fn spool_set_adaptive_deacceleration_urgency_multiplier(
-        &mut self,
-        deacceleration_urgency_multiplier: f64,
-    ) {
-        self.spool_speed_controller_state
-            .adaptive_deacceleration_urgency_multiplier = deacceleration_urgency_multiplier;
-        self.emit_state();
-    }
-
-    /// Set forward rotation direction
-    pub fn spool_set_forward(&mut self, forward: bool) {
-        self.spool_speed_controller_state.forward = forward;
-        self.emit_state();
-    }
-
-    /// implement machine connection
-    /// set connected buffer
-    pub fn set_connected_buffer(
-        &mut self,
-        _machine_identification_unique: MachineIdentificationUnique,
-    ) {
-        self.emit_state();
-    }
-
-    /// disconnect buffer
-    pub fn disconnect_buffer(
-        &mut self,
-        _machine_identification_unique: MachineIdentificationUnique,
-    ) {
-        self.emit_state();
-    }
-}

machines/src/winder2/mock/mod.rs

@@ -1,64 +0,0 @@
-use std::time::Instant;
-
-pub mod act;
-pub mod api;
-pub mod mock_emit;
-pub mod new;
-
-use super::api::{
-    ModeState, PullerState, SpoolAutomaticActionState, SpoolSpeedControllerState, TensionArmState,
-    TraverseState, Winder2Namespace,
-};
-use crate::{
-    AsyncThreadMessage, Machine, MachineConnection, MachineMessage,
-    machine_identification::MachineIdentificationUnique,
-};
-use smol::channel::{Receiver, Sender};
-
-#[derive(Debug)]
-pub struct Winder2 {
-    machine_identification_unique: MachineIdentificationUnique,
-    namespace: Winder2Namespace,
-    last_measurement_emit: Instant,
-    pub is_default_state: bool,
-    /// traverse state
-    pub traverse_state: TraverseState,
-    /// puller state
-    pub puller_state: PullerState,
-    /// spool automatic action state and progress
-    pub spool_automatic_action_state: SpoolAutomaticActionState,
-    /// mode state
-    pub mode_state: ModeState,
-    /// tension arm state
-    pub tension_arm_state: TensionArmState,
-    /// spool speed controller state
-    pub spool_speed_controller_state: SpoolSpeedControllerState,
-
-    /// Receive from Api or MainThread
-    api_receiver: Receiver<MachineMessage>,
-    api_sender: Sender<MachineMessage>,
-
-    /// Communicate with main thread
-    main_sender: Option<Sender<AsyncThreadMessage>>,
-
-    /// All currently "connected" Machines
-    connected_machines: Vec<MachineConnection>,
-    /// Defaults to limit of 2
-    max_connected_machines: usize,
-}
-
-impl std::fmt::Display for Winder2 {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Winder2")
-    }
-}
-
-impl Machine for Winder2 {
-    fn get_machine_identification_unique(&self) -> MachineIdentificationUnique {
-        self.machine_identification_unique.clone()
-    }
-
-    fn get_main_sender(&self) -> Option<Sender<AsyncThreadMessage>> {
-        self.main_sender.clone()
-    }
-}

machines/src/winder2/mock/new.rs

@@ -1,57 +0,0 @@
-use crate::{
-    MachineNewParams, MachineNewTrait,
-    winder2::api::{
-        ModeState, PullerState, SpoolAutomaticActionState, SpoolSpeedControllerState,
-        TensionArmState, TraverseState, Winder2Namespace,
-    },
-};
-
-use super::Winder2;
-
-impl MachineNewTrait for Winder2 {
-    fn new(params: &MachineNewParams<'_, '_, '_, '_, '_, '_, '_>) -> Result<Self, anyhow::Error>
-    where
-        Self: Sized,
-    {
-        // Mock machine can work with either Serial or Ethercat hardware
-        // For the mock machine, we don't need to actually use the hardware
-        // We just validate that we have the expected hardware type
-        match params.hardware {
-            crate::MachineNewHardware::Serial(_) => {
-                // For serial mode, we could potentially use the serial device if needed
-                // but for a mock machine, we'll just note it and proceed
-            }
-            crate::MachineNewHardware::Ethercat(_) => {
-                // For ethercat mode, we could potentially use the ethercat devices
-                // but for a mock machine, we'll just note it and proceed
-            }
-        }
-
-        let now = std::time::Instant::now();
-
-        let (sender, receiver) = smol::channel::unbounded();
-        let mut winder_mock_machine = Self {
-            main_sender: params.main_thread_channel.clone(),
-            max_connected_machines: 2,
-            api_receiver: receiver,
-            api_sender: sender,
-            machine_identification_unique: params.get_machine_identification_unique(),
-            namespace: Winder2Namespace {
-                namespace: params.namespace.clone(),
-            },
-            last_measurement_emit: now,
-            is_default_state: true,
-            traverse_state: TraverseState::default(),
-            puller_state: PullerState::default(),
-            spool_automatic_action_state: SpoolAutomaticActionState::default(),
-            mode_state: ModeState::default(),
-            tension_arm_state: TensionArmState::default(),
-            spool_speed_controller_state: SpoolSpeedControllerState::default(),
-            connected_machines: vec![],
-        };
-
-        winder_mock_machine.emit_state();
-
-        Ok(winder_mock_machine)
-    }
-}

nixos/packages/server.nix

@@ -34,5 +34,5 @@ craneLib.buildPackage {
     inherit src strictDeps nativeBuildInputs buildInputs pname version;
   };
 
-  cargoExtraArgs = "-p server --features tracing-journald,io-uring --no-default-features";
+  cargoExtraArgs = "-p server --features tracing-journald,xdp --no-default-features";
 }

server/Cargo.toml

@@ -9,20 +9,24 @@ workspace = true
 
 
 [dependencies]
-ethercrab = "0.6"
+ethercrab = { git = "https://github.com/ethercrab-rs/ethercrab", branch = "main", features = ["xdp"] }
 ethercat_hal = { path = "../ethercat-hal" }
 control_core = { path = "../control-core" }
+control_core_derive = { path = "../control-core-derive" }
 
-units = { path = "../units" }
-machines = { path = "../machines"}
+uom = { version = "0.36.0", default-features = false, features = ["f64"] }
 serde = "1.0.217"
 anyhow = "1.0.100"
 
 bitvec = "1.0.1"
+lazy_static = "1.5.0"
+dhat = { version = "0.3.3", optional = true }
+euclid = "0.22.11"
 
 # concurrency
 smol = "2.0.2"
 tokio = { version = "1.45.1", features = ["rt-multi-thread"] }
+regex = "1.11.3"
 futures = "0.3.31"
 
 # web
@@ -43,12 +47,17 @@ tracing-subscriber = { version = "0.3.20", features = [
     "chrono",
     "registry",
 ] }
-utils = { version = "0.1.0", path="../utils" }
+tracing-opentelemetry = { version = "0.31.0", optional = true }
+opentelemetry = { version = "0.30.0", optional = true }
+opentelemetry_sdk = { version = "0.30.0", optional = true }
+opentelemetry-otlp = { version = "0.30.0", features = [
+    "grpc-tonic",
+], optional = true }
 tonic = { version = "0.13.1", optional = true }
-spin_sleep = "1.3.3"
-dhat = { version = "0.3.3", optional = true }
-ctrlc = { version = "3.3", optional = true }
 
+#[target.'cfg(not(target_env = "msvc"))'.dependencies]
+#tikv-jemallocator = { version = "0.6", features = ["profiling", "stats"] }
+#tikv-jemalloc-ctl = "0.6"
 
 [dev-dependencies]
 approx = "0.5.1"
@@ -57,16 +66,21 @@ textplots = "0.8.7"
 [features]
 default = ["tracing-fmt"]
 never_type = []
+dhat-heap = ["dep:dhat"]
 tracing-fmt = []
 tracing-journald = ["dep:tracing-journald"]
+tracing-otel = [
+    "dep:tracing-opentelemetry",
+    "dep:opentelemetry_sdk",
+    "dep:opentelemetry",
+    "dep:opentelemetry-otlp",
+    "dep:tonic",
+]
 mock-machine = []
 memory-locking = []
 io-uring = []
-development-build = ["ctrlc"]
-heap-profile = ["dhat"]
-
-
-
+xdp = []
+development-build = []
 
 [profile.release]
 codegen-units = 1

server/serial_detecton_loop.drawio

@@ -0,0 +1,158 @@
+<mxfile host="65bd71144e">
+    <diagram id="gGUUZ6BF0hv9_rCV74nS" name="Page-1">
+        <mxGraphModel dx="1120" dy="694" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="850" pageHeight="1100" math="0" shadow="0">
+            <root>
+                <mxCell id="0"/>
+                <mxCell id="1" parent="0"/>
+                <mxCell id="85" value="" style="swimlane;startSize=0;swimlaneFillColor=default;" vertex="1" parent="1">
+                    <mxGeometry x="60" y="170" width="770" height="610" as="geometry"/>
+                </mxCell>
+                <mxCell id="82" style="edgeStyle=none;html=1;entryX=1;entryY=0.5;entryDx=0;entryDy=0;exitX=1;exitY=0.5;exitDx=0;exitDy=0;" parent="1" source="81" target="5" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <mxPoint x="520" y="600" as="targetPoint"/>
+                        <Array as="points">
+                            <mxPoint x="800" y="240"/>
+                            <mxPoint x="800" y="730"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="83" style="edgeStyle=none;html=1;entryX=0.136;entryY=0.96;entryDx=0;entryDy=0;entryPerimeter=0;" parent="1" source="69" target="81" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="75" style="edgeStyle=none;html=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" parent="1" source="29" target="72" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="3" value="Serial Device Detection" style="swimlane;horizontal=0;whiteSpace=wrap;html=1;swimlaneFillColor=#FFFFFF;" parent="1" vertex="1">
+                    <mxGeometry x="90" y="320" width="410" height="450" as="geometry"/>
+                </mxCell>
+                <mxCell id="7" style="edgeStyle=none;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;" parent="3" source="5" target="6" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="20" value="Step 1" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="7" vertex="1" connectable="0">
+                    <mxGeometry x="-0.2303" relative="1" as="geometry">
+                        <mxPoint as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="5" value="Detect all connected devices" style="rounded=0;whiteSpace=wrap;html=1;" parent="3" vertex="1">
+                    <mxGeometry x="50" y="380" width="120" height="60" as="geometry"/>
+                </mxCell>
+                <mxCell id="18" style="edgeStyle=none;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;" parent="3" source="6" target="12" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="21" value="Step 2" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="18" vertex="1" connectable="0">
+                    <mxGeometry x="-0.0304" relative="1" as="geometry">
+                        <mxPoint as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="25" style="edgeStyle=none;html=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" parent="3" source="6" target="70" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <mxPoint x="259.9999999999998" y="320" as="targetPoint"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="26" value="Step 4 update" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="25" vertex="1" connectable="0">
+                    <mxGeometry x="-0.2714" y="-2" relative="1" as="geometry">
+                        <mxPoint x="14" y="8" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="6" value="Extract all USB Devices" style="rounded=0;whiteSpace=wrap;html=1;" parent="3" vertex="1">
+                    <mxGeometry x="50" y="290" width="120" height="60" as="geometry"/>
+                </mxCell>
+                <mxCell id="19" style="edgeStyle=none;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;" parent="3" source="70" target="12" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <mxPoint x="200" y="270" as="targetPoint"/>
+                        <mxPoint x="319.9999999999998" y="350" as="sourcePoint"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="22" value="Step 2" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="19" vertex="1" connectable="0">
+                    <mxGeometry x="0.2571" y="3" relative="1" as="geometry">
+                        <mxPoint as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="16" style="edgeStyle=none;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;" parent="3" source="12" target="13" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="23" value="Step 3" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="16" vertex="1" connectable="0">
+                    <mxGeometry x="-0.089" y="-3" relative="1" as="geometry">
+                        <mxPoint as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="17" style="edgeStyle=none;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" parent="3" source="12" target="15" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="24" value="Step 3" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="17" vertex="1" connectable="0">
+                    <mxGeometry x="-0.0688" y="2" relative="1" as="geometry">
+                        <mxPoint as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="12" value="Compare" style="rhombus;whiteSpace=wrap;html=1;" parent="3" vertex="1">
+                    <mxGeometry x="145" y="230" width="100" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="13" value="to add devices&lt;span style=&quot;font-family: monospace; font-size: 0px; text-align: start; text-wrap-mode: nowrap;&quot;&gt;%3CmxGraphModel%3E%3Croot%3E%3CmxCell%20id%3D%220%22%2F%3E%3CmxCell%20id%3D%221%22%20parent%3D%220%22%2F%3E%3CmxCell%20id%3D%222%22%20value%3D%22Connected%20Devices%22%20style%3D%22rounded%3D0%3BwhiteSpace%3Dwrap%3Bhtml%3D1%3B%22%20vertex%3D%221%22%20parent%3D%221%22%3E%3CmxGeometry%20x%3D%22240%22%20y%3D%22460%22%20width%3D%22120%22%20height%3D%2260%22%20as%3D%22geometry%22%2F%3E%3C%2FmxCell%3E%3C%2Froot%3E%3C%2FmxGraphModel%3E&lt;/span&gt;" style="shape=hexagon;perimeter=hexagonPerimeter2;whiteSpace=wrap;html=1;fixedSize=1;" parent="3" vertex="1">
+                    <mxGeometry x="267.5" y="190" width="90" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="37" style="edgeStyle=none;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;" parent="3" source="15" target="69" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <mxPoint x="269.9999999999998" y="70" as="targetPoint"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="38" value="&lt;span style=&quot;color: rgb(0, 0, 0);&quot;&gt;Step 7 Remove devices&lt;/span&gt;" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="37" vertex="1" connectable="0">
+                    <mxGeometry x="-0.157" y="-2" relative="1" as="geometry">
+                        <mxPoint as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="15" value="to delete devices" style="shape=hexagon;perimeter=hexagonPerimeter2;whiteSpace=wrap;html=1;fixedSize=1;" parent="3" vertex="1">
+                    <mxGeometry x="40" y="190" width="105" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="29" value="Check if device has known vid, pid" style="rounded=0;whiteSpace=wrap;html=1;" parent="3" vertex="1">
+                    <mxGeometry x="251.88" y="130" width="121.25" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="28" style="edgeStyle=none;html=1;exitX=0.5;exitY=0;exitDx=0;exitDy=0;" parent="3" source="13" target="29" edge="1">
+                    <mxGeometry relative="1" as="geometry">
+                        <mxPoint x="100.12121212121212" y="170" as="targetPoint"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="32" value="Step 5" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="28" vertex="1" connectable="0">
+                    <mxGeometry x="-0.2505" relative="1" as="geometry">
+                        <mxPoint as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="69" value="&lt;span style=&quot;color: rgb(0, 0, 0);&quot;&gt;Connected Devices&lt;/span&gt;" style="ellipse;whiteSpace=wrap;html=1;" parent="3" vertex="1">
+                    <mxGeometry x="32.5" y="40" width="120" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="70" value="&lt;span style=&quot;color: rgb(0, 0, 0);&quot;&gt;Previous detected usb devices&lt;/span&gt;" style="ellipse;whiteSpace=wrap;html=1;" parent="3" vertex="1">
+                    <mxGeometry x="250" y="290" width="120" height="60" as="geometry"/>
+                </mxCell>
+                <mxCell id="79" style="edgeStyle=none;html=1;entryX=0.933;entryY=0.67;entryDx=0;entryDy=0;entryPerimeter=0;" parent="3" source="69" target="69" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="80" value="Check old Devices" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="79" vertex="1" connectable="0">
+                    <mxGeometry x="0.1272" y="1" relative="1" as="geometry">
+                        <mxPoint x="37" y="-7" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="77" value="" style="edgeStyle=elbowEdgeStyle;elbow=vertical;endArrow=classic;html=1;curved=0;rounded=0;endSize=8;startSize=8;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=1;entryY=1;entryDx=0;entryDy=0;" parent="3" edge="1" source="72">
+                    <mxGeometry width="50" height="50" relative="1" as="geometry">
+                        <mxPoint x="555.07" y="120.86000000000001" as="sourcePoint"/>
+                        <mxPoint x="109.99640687119273" y="80.00213562373096" as="targetPoint"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="78" value="&lt;span style=&quot;color: rgb(0, 0, 0);&quot;&gt;Step 6 add devices&lt;/span&gt;" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="77" vertex="1" connectable="0">
+                    <mxGeometry x="0.3427" y="-3" relative="1" as="geometry">
+                        <mxPoint as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="68" value="Serial Device Registry" style="swimlane;horizontal=0;whiteSpace=wrap;html=1;swimlaneFillColor=#FFFFFF;" parent="1" vertex="1">
+                    <mxGeometry x="540" y="320" width="230" height="200" as="geometry">
+                        <mxRectangle x="440" y="330" width="40" height="150" as="alternateBounds"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="72" value="New Serial Device&amp;nbsp;" style="rounded=0;whiteSpace=wrap;html=1;" parent="68" vertex="1">
+                    <mxGeometry x="70" y="115" width="120" height="60" as="geometry"/>
+                </mxCell>
+                <mxCell id="81" value="Init Loop" style="shape=ext;double=1;rounded=0;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+                    <mxGeometry x="90" y="210" width="680" height="60" as="geometry"/>
+                </mxCell>
+            </root>
+        </mxGraphModel>
+    </diagram>
+</mxfile>

server/src/README.md

@@ -0,0 +1,11 @@
+# Server Structure
+
+- `/server`: Is Backend part that makes connection between Beckhoff and Electron. Implements machine logic.
+
+## EtherCAT
+
+- `/ethercat`: Implements logic of EtherCAT
+
+## Serial
+
+- `/serial`: Implements logic of Serial, starting from serial device detection ending with serial device registration as machine

server/src/app_state.rs

@@ -1,22 +1,20 @@
 use crate::ethercat::config::{MAX_SUBDEVICES, PDI_LEN};
-use crate::rest::handlers::write_machine_device_identification::MachineDeviceInfoRequest;
-use crate::socketio::main_namespace::MainNamespaceEvents;
-use crate::socketio::main_namespace::machines_event::{MachineObj, MachinesEventBuilder};
+use crate::performance_metrics::EthercatPerformanceMetrics;
+use crate::serial::registry::SERIAL_DEVICE_REGISTRY;
+use crate::socketio::main_namespace::machines_event::MachineObj;
 use crate::socketio::namespaces::Namespaces;
+use control_core::machines::Machine;
+use control_core::machines::identification::{DeviceIdentification, MachineIdentificationUnique};
+use control_core::machines::manager::MachineManager;
+use control_core::serial::serial_detection::SerialDetection;
 use control_core::socketio::event::GenericEvent;
 use ethercat_hal::devices::EthercatDevice;
-use ethercrab::SubDeviceRef;
 use ethercrab::{MainDevice, SubDeviceGroup, subdevice_group::Op};
-use machines::machine_identification::{DeviceIdentification, MachineIdentificationUnique};
-use machines::serial::registry::SERIAL_DEVICE_REGISTRY;
-use machines::{Machine, MachineMessage};
-use serde::{Deserialize, Serialize};
 use smol::channel::{Receiver, Sender};
-use smol::lock::{Mutex, RwLock};
+use smol::lock::RwLock;
 use socketioxide::SocketIo;
 use socketioxide::extract::SocketRef;
-use std::collections::{HashMap, HashSet};
-use std::fmt;
+use std::collections::HashMap;
 use std::sync::Arc;
 
 pub struct SocketioSetup {
@@ -27,71 +25,19 @@ pub struct SocketioSetup {
 }
 
 pub struct SerialSetup {
-    pub serial_registry: &'static SERIAL_DEVICE_REGISTRY,
+    pub serial_detection: SerialDetection<'static>,
 }
 
-/*
-Maybe better name needed ...
-Essentially isntead of changing machines with locks, we send messages to our "HOT" thread wehere the machines are executed.
-In there the Machines are built, destroyed, inspected etcetera.
-
-Only Machines requiring RT capabilities (Mostly EtherCat machines) should be added
-*/
-pub enum HotThreadMessage {
-    NoMsg,
-    AddMachines(Vec<Box<dyn Machine>>),
-    AddEtherCatSetup(EthercatSetup),
-    WriteMachineDeviceInfo(MachineDeviceInfoRequest),
-    DeleteMachine(MachineIdentificationUnique),
-}
-
-use crate::AsyncThreadMessage;
-
-/*
-    Instead of locking, etc only capture metadata on setup
-*/
-#[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct EtherCatDeviceMetaData {
-    pub configured_address: u16,
-    pub name: String,
-    pub vendor_id: u32,
-    pub product_id: u32,
-    pub revision: u32,
-    pub device_identification: DeviceIdentification,
-}
-
-impl EtherCatDeviceMetaData {
-    pub fn from_subdevice(
-        subdevice: &SubDeviceRef<'_, &ethercrab::SubDevice>,
-        device_identification: DeviceIdentification,
-    ) -> Self {
-        Self {
-            name: subdevice.name().to_string(),
-            configured_address: subdevice.configured_address(),
-            product_id: subdevice.identity().product_id,
-            revision: subdevice.identity().revision,
-            vendor_id: subdevice.identity().vendor_id,
-            device_identification,
-        }
-    }
-}
-
-pub struct SharedState {
+pub struct AppState {
     pub socketio_setup: SocketioSetup,
-    pub api_machines: Mutex<HashMap<MachineIdentificationUnique, Sender<MachineMessage>>>,
-    pub current_machines_meta: Mutex<Vec<MachineObj>>,
-    pub rt_machine_creation_channel: Sender<HotThreadMessage>,
-    pub main_channel: Sender<AsyncThreadMessage>,
-    pub ethercat_meta_data: RwLock<Vec<EtherCatDeviceMetaData>>,
+    pub ethercat_setup: Arc<RwLock<Option<EthercatSetup>>>,
+    pub serial_setup: Arc<RwLock<SerialSetup>>,
+    pub machines: Arc<RwLock<MachineManager>>,
+    pub performance_metrics: Arc<RwLock<EthercatPerformanceMetrics>>,
 }
 
-impl fmt::Debug for EthercatSetup {
-    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        Ok(())
-    }
-}
-
-use control_core::socketio::namespace::NamespaceCacheingLogic;
+pub type Machines =
+    HashMap<MachineIdentificationUnique, Result<Arc<RwLock<dyn Machine>>, anyhow::Error>>;
 
 pub struct EthercatSetup {
     /// All Ethercat devices
@@ -121,58 +67,46 @@ impl EthercatSetup {
     }
 }
 
-impl SharedState {
-    pub async fn send_machines_event(&self) {
-        let event = MachinesEventBuilder().build(self.current_machines_meta.lock().await.clone());
-        let main_namespace = &mut self.socketio_setup.namespaces.write().await.main_namespace;
-        main_namespace.emit(MainNamespaceEvents::MachinesEvent(event));
+impl Default for AppState {
+    fn default() -> Self {
+        Self::new()
     }
+}
 
-    /// Removes a machine by its unique identifier
-    pub async fn remove_machine(&self, machine_id: &MachineIdentificationUnique) {
-        let mut current_machines = self.current_machines_meta.lock().await;
-        // Retain only machines that do not match the given ID
-        current_machines.retain(|m| &m.machine_identification_unique != machine_id);
-        tracing::info!(
-            "remove_machine {:?} {:?}",
-            self.current_machines_meta,
-            self.api_machines
-        );
-    }
-
-    pub async fn add_machines_if_not_exists(&self, machines: Vec<MachineObj>) {
-        let mut current_machines = self.current_machines_meta.lock().await;
-        tracing::info!("add_machines_if_not_exists: {:?}", current_machines);
-        // Track existing machine identifiers for quick lookup
-        let existing_ids: HashSet<_> = current_machines
-            .iter()
-            .map(|m| m.machine_identification_unique.clone())
-            .collect();
-
-        for machine in machines {
-            if !existing_ids.contains(&machine.machine_identification_unique) {
-                current_machines.push(machine);
-            }
-        }
-    }
-
-    pub fn new(
-        sender: Sender<HotThreadMessage>,
-        main_async_channel: Sender<AsyncThreadMessage>,
-    ) -> Self {
+impl AppState {
+    pub fn new() -> Self {
         let (socket_queue_tx, socket_queue_rx) = smol::channel::unbounded();
         Self {
-            current_machines_meta: vec![].into(),
-            ethercat_meta_data: vec![].into(),
             socketio_setup: SocketioSetup {
                 socketio: RwLock::new(None),
                 namespaces: RwLock::new(Namespaces::new(socket_queue_tx.clone())),
                 socket_queue_tx,
                 socket_queue_rx,
             },
-            api_machines: Mutex::new(HashMap::new()),
-            rt_machine_creation_channel: sender,
-            main_channel: main_async_channel,
+            ethercat_setup: Arc::new(RwLock::new(None)),
+            serial_setup: Arc::new(RwLock::new(SerialSetup {
+                serial_detection: SerialDetection::new(&SERIAL_DEVICE_REGISTRY),
+            })),
+            machines: Arc::new(RwLock::new(MachineManager::new())),
+            performance_metrics: Arc::new(RwLock::new(EthercatPerformanceMetrics::new())),
         }
     }
+
+    pub fn get_machine_objs(&self) -> Vec<MachineObj> {
+        let machines = self.machines.read_blocking();
+        machines
+            .iter()
+            .map(|machine| {
+                let error = {
+                    let slot = machine.1.lock_blocking();
+                    slot.machine_connection.to_error().map(|e| e.to_string())
+                };
+
+                MachineObj {
+                    machine_identification_unique: machine.0.clone(),
+                    error,
+                }
+            })
+            .collect()
+    }
 }

server/src/ethercat/ethercat_discovery_info.rs

@@ -1,36 +0,0 @@
-use std::sync::Arc;
-
-use control_core::socketio::namespace::NamespaceCacheingLogic;
-
-use crate::{
-    app_state::SharedState,
-    socketio::main_namespace::{
-        MainNamespaceEvents, ethercat_interface_discovery_event::EthercatInterfaceDiscoveryEvent,
-    },
-};
-
-pub async fn send_ethercat_discovering(app_state: Arc<SharedState>) {
-    {
-        let main_namespace = &mut app_state
-            .socketio_setup
-            .namespaces
-            .write()
-            .await
-            .main_namespace;
-        let event = EthercatInterfaceDiscoveryEvent::Discovering(true).build();
-        main_namespace.emit(MainNamespaceEvents::EthercatInterfaceDiscoveryEvent(event));
-    }
-}
-pub async fn send_ethercat_found(app_state: Arc<SharedState>, interface: &str) {
-    // Notify client via socketio
-    let interface = interface.to_string();
-    let app_state_socketio = app_state.clone();
-    let main_namespace = &mut app_state_socketio
-        .socketio_setup
-        .namespaces
-        .write()
-        .await
-        .main_namespace;
-    let event = EthercatInterfaceDiscoveryEvent::Done(interface).build();
-    main_namespace.emit(MainNamespaceEvents::EthercatInterfaceDiscoveryEvent(event));
-}

server/src/ethercat/init.rs

@@ -1,23 +1,70 @@
-use control_core::ethercat::interface_discovery::discover_ethercat_interface;
-use smol::{Task, Timer};
-use std::time::Duration;
+use super::setup::setup_loop;
+use crate::{
+    app_state::AppState,
+    socketio::main_namespace::{
+        MainNamespaceEvents, ethercat_interface_discovery_event::EthercatInterfaceDiscoveryEvent,
+    },
+};
+use control_core::{
+    ethercat::interface_discovery::discover_ethercat_interface,
+    socketio::namespace::NamespaceCacheingLogic,
+};
+use std::sync::Arc;
 
-pub async fn find_ethercat_interface() -> Result<String, anyhow::Error> {
-    loop {
-        match discover_ethercat_interface().await {
-            Ok(interface) => {
-                tracing::info!("Found EtherCAT Interface at: {}", interface);
-                return Ok(interface);
-            }
-            Err(e) => {
-                tracing::warn!("No working interface found: {}. Retrying...", e);
-                Timer::after(Duration::from_secs(1)).await;
-            }
-        }
-    }
-}
+pub fn init_ethercat(app_state: Arc<AppState>) -> Result<(), anyhow::Error> {
+    let app_state_clone = app_state;
 
-// Returns a Future to the interface
-pub fn start_interface_discovery() -> Task<Result<String, anyhow::Error>> {
-    smol::spawn(find_ethercat_interface())
+    std::thread::Builder::new()
+        .name("init_ethercat".to_string())
+        .spawn(move || {
+            // Notify client via socketio
+            let app_state_socketio = app_state_clone.clone();
+            smol::block_on(async move {
+                let main_namespace = &mut app_state_socketio
+                    .socketio_setup
+                    .namespaces
+                    .write()
+                    .await
+                    .main_namespace;
+                let event = EthercatInterfaceDiscoveryEvent::Discovering(true).build();
+                main_namespace.emit(MainNamespaceEvents::EthercatInterfaceDiscoveryEvent(event));
+            });
+
+            // tries to find a suitable interface in a loop
+            let interface = smol::block_on(async {
+                loop {
+                    match discover_ethercat_interface().await {
+                        Ok(interface) => {
+                            tracing::info!("Found working interface: {}", interface);
+                            break interface;
+                        }
+                        Err(_) => {
+                            tracing::warn!("No working interface found, retrying...");
+                            // wait 1 seconds before retrying
+                            smol::Timer::after(std::time::Duration::from_secs(1)).await;
+                        }
+                    }
+                }
+            });
+
+            // Notify client via socketio
+            let interface_clone = interface.clone();
+            let app_state_socketio = app_state_clone.clone();
+            smol::block_on(async move {
+                let main_namespace = &mut app_state_socketio
+                    .socketio_setup
+                    .namespaces
+                    .write()
+                    .await
+                    .main_namespace;
+                let event = EthercatInterfaceDiscoveryEvent::Done(interface_clone).build();
+                main_namespace.emit(MainNamespaceEvents::EthercatInterfaceDiscoveryEvent(event));
+            });
+
+            if let Err(e) = smol::block_on(setup_loop(&interface, app_state_clone)) {
+                tracing::error!("EtherCAT setup failed: {:?}", e);
+            }
+        })?;
+
+    Ok(())
 }

server/src/ethercat/mod.rs

@@ -1,4 +1,3 @@
 pub mod config;
-pub mod ethercat_discovery_info;
 pub mod init;
 pub mod setup;

server/src/ethercat/setup.rs

@@ -1,175 +1,39 @@
-use crate::app_state::{EtherCatDeviceMetaData, EthercatSetup};
+use crate::app_state::EthercatSetup;
+use crate::machines::registry::MACHINE_REGISTRY;
 use crate::socketio::main_namespace::MainNamespaceEvents;
 use crate::socketio::main_namespace::ethercat_devices_event::EthercatDevicesEventBuilder;
-use crate::socketio::main_namespace::machines_event::MachineObj;
+use crate::socketio::main_namespace::machines_event::MachinesEventBuilder;
 use crate::{
-    app_state::SharedState,
+    app_state::AppState,
     ethercat::config::{MAX_FRAMES, MAX_PDU_DATA, MAX_SUBDEVICES, PDI_LEN},
 };
+use control_core::ethercat::eeprom_identification::read_device_identifications;
 #[cfg(all(target_os = "linux", not(feature = "development-build")))]
 use control_core::irq_handling::set_irq_affinity;
-use machines::machine_identification::{
+use control_core::machines::identification::{
     DeviceHardwareIdentification, DeviceHardwareIdentificationEthercat, DeviceIdentification,
-    DeviceIdentificationIdentified, MachineIdentificationUnique, read_device_identifications,
 };
-
+use control_core::machines::new::MachineNewHardwareEthercat;
 use control_core::realtime::{set_core_affinity, set_realtime_priority};
 use control_core::socketio::namespace::NamespaceCacheingLogic;
 use ethercat_hal::devices::devices_from_subdevices;
 use ethercrab::std::ethercat_now;
 use ethercrab::{MainDevice, MainDeviceConfig, PduStorage, RetryBehaviour, Timeouts};
-use machines::registry::{MACHINE_REGISTRY, MachineRegistry};
-use machines::{Machine, MachineNewHardware, MachineNewHardwareEthercat, MachineNewParams};
-use smol::channel::Sender;
-use socketioxide::extract::SocketRef;
 use std::{sync::Arc, time::Duration};
 
 const SM_OUTPUT: u16 = 0x1C32;
 const SM_INPUT: u16 = 0x1C33;
 
-/// Structure to hold the result of grouping devices by identification
-#[derive(Debug)]
-pub struct DeviceGroupingResult {
-    /// Devices grouped by machine identification
-    pub device_groups: Vec<Vec<DeviceIdentificationIdentified>>,
-    /// Devices that could not be identified
-    pub unidentified_devices: Vec<DeviceIdentification>,
-}
-
-pub fn group_devices_by_identification(
-    device_identifications: &Vec<DeviceIdentification>,
-) -> DeviceGroupingResult {
-    let mut device_groups: Vec<Vec<DeviceIdentificationIdentified>> = Vec::new();
-    let mut unidentified_devices: Vec<DeviceIdentification> = Vec::new();
-
-    for device_identification in device_identifications {
-        // if vendor or serial or machine is 0, it is not a valid machine device
-        if let Some(device_machine_identification) =
-            device_identification.device_machine_identification.as_ref()
-        {
-            if !device_machine_identification.is_valid() {
-                unidentified_devices.push(device_identification.clone());
-
-                continue;
-            }
-        } else {
-            unidentified_devices.push(device_identification.clone());
-            continue;
-        }
-
-        // scan over all deice groups
-        // get the first DeviceMachineIdentification
-        // compare and append to the group
-        let mut found = false;
-        for check_group in device_groups.iter_mut() {
-            // get first device in group
-            let first_device = check_group.first().expect("group to not be empty");
-            let first_device_machine_identification = &first_device
-                .device_machine_identification
-                .machine_identification_unique;
-
-            // chek if it has machine identification
-            if let Some(device_machine_identification) =
-                device_identification.device_machine_identification.as_ref()
-            {
-                // compare with the current device
-                if first_device_machine_identification
-                    == &device_machine_identification.machine_identification_unique
-                {
-                    let device_identification_identified = device_identification
-                        .clone()
-                        .try_into()
-                        .expect("should have Some(DeviceMachineIdentification)");
-                    check_group.push(device_identification_identified);
-                    found = true;
-                    break;
-                }
-            }
-        }
-
-        if !found {
-            let device_identification_identified = device_identification
-                .clone()
-                .try_into()
-                .expect("should have Some(DeviceMachineIdentification)");
-            device_groups.push(vec![device_identification_identified]);
-        }
-    }
-
-    DeviceGroupingResult {
-        device_groups,
-        unidentified_devices,
-    }
-}
-
-pub async fn set_ethercat_devices<const MAX_SUBDEVICES: usize, const MAX_PDI: usize>(
-    device_identifications: &Vec<DeviceIdentification>,
-    machine_registry: &MachineRegistry,
-    hardware: &MachineNewHardwareEthercat<'_, '_, '_>,
-    shared_state: Arc<SharedState>,
-    socket_queue_tx: Sender<(SocketRef, Arc<control_core::socketio::event::GenericEvent>)>,
-) -> Result<(), anyhow::Error> {
-    tracing::info!("set_ethercat_devices");
-    let device_grouping_result = group_devices_by_identification(device_identifications);
-    tracing::info!("{:?}", device_grouping_result.unidentified_devices);
-    let machine_new_hardware = MachineNewHardware::Ethercat(hardware);
-
-    let mut machines: Vec<Box<dyn Machine>> = vec![];
-    let mut machine_objs: Vec<MachineObj> = vec![];
-
-    for device_group in device_grouping_result.device_groups.iter() {
-        let machine_identification_unique: MachineIdentificationUnique = match device_group.first()
-        {
-            Some(device_identification) => device_identification
-                .device_machine_identification
-                .machine_identification_unique
-                .clone(),
-            None => continue, // Skip this group if empty
-        };
-
-        let new_machine = machine_registry.new_machine(&MachineNewParams {
-            device_group,
-            hardware: &machine_new_hardware,
-            socket_queue_tx: socket_queue_tx.clone(),
-            namespace: None,
-            main_thread_channel: Some(shared_state.main_channel.clone()),
-        });
-
-        match new_machine {
-            Ok(machine) => {
-                shared_state.clone().api_machines.lock().await.insert(
-                    machine_identification_unique.clone(),
-                    machine.api_get_sender(),
-                );
-                machine_objs.push(MachineObj {
-                    machine_identification_unique,
-                    error: None,
-                });
-                machines.push(machine);
-            }
-            Err(e) => machine_objs.push(MachineObj {
-                machine_identification_unique,
-                error: Some(e.to_string()),
-            }),
-        }
-    }
-
-    let _ = shared_state
-        .rt_machine_creation_channel
-        .send(crate::app_state::HotThreadMessage::AddMachines(machines))
-        .await;
-    shared_state.add_machines_if_not_exists(machine_objs).await;
-    shared_state.clone().send_machines_event().await;
-
-    Ok(())
-}
-
-pub async fn setup_loop(
-    interface: &str,
-    app_state: Arc<SharedState>,
-) -> Result<EthercatSetup, anyhow::Error> {
+pub async fn setup_loop(interface: &str, app_state: Arc<AppState>) -> Result<(), anyhow::Error> {
     tracing::info!("Starting Ethercat PDU loop");
 
+    // Erase all all setup data from `app_state`
+    {
+        tracing::debug!("Setting up Ethercat network");
+        let mut ethercat_setup_guard = app_state.ethercat_setup.write().await;
+        *ethercat_setup_guard = None;
+    }
+
     // Setup ethercrab tx/rx task
     let pdu_storage = Box::leak(Box::new(PduStorage::<MAX_FRAMES, MAX_PDU_DATA>::new()));
     let (tx, rx, pdu) = pdu_storage.try_split().expect("can only split once");
@@ -188,10 +52,12 @@ pub async fn setup_loop(
             let _ = set_core_affinity(3);
 
             // Set the thread to real-time priority
-            #[cfg(not(feature = "development-build"))]
             let _ = set_realtime_priority();
 
-            #[cfg(not(all(target_os = "linux", feature = "io-uring")))]
+            #[cfg(not(any(
+                all(target_os = "linux", feature = "io-uring"),
+                all(target_os = "linux", feature = "xdp")
+            )))]
             {
                 use ethercrab::std::tx_rx_task;
                 use futures::executor::block_on;
@@ -210,6 +76,14 @@ pub async fn setup_loop(
                 let _ = tx_rx_task_io_uring(&interface, tx, rx)
                     .expect("Failed to spawn TX/RX task (io_uring)");
             }
+
+            #[cfg(all(target_os = "linux", feature = "xdp"))]
+            {
+                use ethercrab::std::tx_rx_task_xdp;
+
+                let _ = tx_rx_task_xdp(&interface, tx, rx)
+                    .expect("Failed to spawn TX/RX task (io_uring)");
+            }
         })
         .expect("Building thread");
 
@@ -222,13 +96,13 @@ pub async fn setup_loop(
             // Default 30_000us
             pdu: Duration::from_micros(30_000),
             // Default 10ms
-            eeprom: Duration::from_millis(10),
+            eeprom: Duration::from_millis(100),
             // Default 0ms
             wait_loop_delay: Duration::from_millis(0),
             // Default 100ms
-            mailbox_echo: Duration::from_millis(100),
+            mailbox_echo: Duration::from_millis(1000),
             // Default 1000ms
-            mailbox_response: Duration::from_millis(1000),
+            mailbox_response: Duration::from_millis(10000),
         },
         MainDeviceConfig {
             // Default RetryBehaviour::None
@@ -237,17 +111,20 @@ pub async fn setup_loop(
             dc_static_sync_iterations: 10_000,
         },
     );
-    {
+
+    smol::block_on({
         let app_state_clone = app_state.clone();
-        let main_namespace = &mut app_state_clone
-            .socketio_setup
-            .namespaces
-            .write()
-            .await
-            .main_namespace;
-        let event = EthercatDevicesEventBuilder().initializing();
-        main_namespace.emit(MainNamespaceEvents::EthercatDevicesEvent(event));
-    }
+        async move {
+            let main_namespace = &mut app_state_clone
+                .socketio_setup
+                .namespaces
+                .write()
+                .await
+                .main_namespace;
+            let event = EthercatDevicesEventBuilder().initializing();
+            main_namespace.emit(MainNamespaceEvents::EthercatDevicesEvent(event));
+        }
+    });
 
     // Initalize subdevices
     // Fails if DC setup detects a mispatching working copunter, then just try again in loop
@@ -292,10 +169,6 @@ pub async fn setup_loop(
         .zip(&subdevices)
         .map(|((a, b), c)| (a, b, c))
         .collect::<Vec<_>>();
-
-    let mut ethercat_meta_devices = app_state.ethercat_meta_data.write().await;
-    ethercat_meta_devices.clear();
-
     // filter devices and if Option<DeviceMachineIdentification> is Some
     // return identified_devices, identified_device_identifications, identified_subdevices
     let (identified_device_identifications, identified_devices, identified_subdevices): (
@@ -323,22 +196,25 @@ pub async fn setup_loop(
         .fold(
             (Vec::new(), Vec::new(), Vec::new()),
             |mut acc, (identified_device_identification, identified_device, identified_subdevice)| {
-                acc.0.push(identified_device_identification.clone());
+                acc.0.push(identified_device_identification);
                 acc.1.push(identified_device);
                 acc.2.push(identified_subdevice);
-                ethercat_meta_devices.push(EtherCatDeviceMetaData::from_subdevice(identified_subdevice,identified_device_identification));
-
                 acc
             },
         );
-    tracing::info!("Found Devices: {:?}", ethercat_meta_devices);
-    drop(ethercat_meta_devices);
-
-    for subdevice in subdevices.iter() {
-        if subdevice.name() == "EL5152" {
-            subdevice.sdo_write(SM_OUTPUT, 0x1, 0x00u16).await?; //set sync mode (1) for free run (0)
-            subdevice.sdo_write(SM_INPUT, 0x1, 0x00u16).await?; //set sync mode (1) for free run (0)
-        }
+    // construct machines
+    {
+        let mut machines_guard = app_state.machines.write().await;
+        machines_guard.set_ethercat_devices::<MAX_SUBDEVICES, PDI_LEN>(
+            &identified_device_identifications,
+            &MACHINE_REGISTRY,
+            &MachineNewHardwareEthercat {
+                ethercat_devices: &identified_devices,
+                subdevices: &identified_subdevices,
+            },
+            app_state.socketio_setup.socket_queue_tx.clone(),
+            Arc::downgrade(&app_state.machines),
+        );
     }
 
     // remove subdevice from devices tuple
@@ -346,27 +222,25 @@ pub async fn setup_loop(
         .iter()
         .map(|(device_identification, device, _)| (device_identification.clone(), device.clone()))
         .collect::<Vec<_>>();
-    // Notify client via socketio
 
-    set_ethercat_devices::<MAX_SUBDEVICES, PDI_LEN>(
-        &identified_device_identifications,
-        &MACHINE_REGISTRY,
-        &MachineNewHardwareEthercat {
-            ethercat_devices: &identified_devices,
-            subdevices: &identified_subdevices,
-        },
-        app_state.clone(),
-        app_state.clone().socketio_setup.socket_queue_tx.clone(),
-    )
-    .await?;
-    /*let main_namespace = &mut app_state_clone
-        .socketio_setup
-        .namespaces
-        .write()
-        .await
-        .main_namespace;
-    let event = MachinesEventBuilder().build(app_state_clone.clone());
-    main_namespace.emit(MainNamespaceEvents::MachinesEvent(event));*/
+    for subdevice in subdevices.iter() {
+        if subdevice.name() == "EL5152" {
+            subdevice.sdo_write(SM_OUTPUT, 0x1, 0x00u16).await?; //set sync mode (1) for free run (0)
+            subdevice.sdo_write(SM_INPUT, 0x1, 0x00u16).await?; //set sync mode (1) for free run (0)
+        }
+    }
+    // Notify client via socketio
+    let app_state_clone = app_state.clone();
+    smol::block_on(async move {
+        let main_namespace = &mut app_state_clone
+            .socketio_setup
+            .namespaces
+            .write()
+            .await
+            .main_namespace;
+        let event = MachinesEventBuilder().build(app_state_clone.clone());
+        main_namespace.emit(MainNamespaceEvents::MachinesEvent(event));
+    });
 
     // Put group in operational state
     let group_op = match group_preop.into_op(&maindevice).await {
@@ -380,9 +254,20 @@ pub async fn setup_loop(
             err
         ))?,
     };
+
+    // Write all this stuff to `app_state`
     {
-        // Notify client via socketio
-        let app_state_clone = app_state.clone();
+        let mut ethercat_setup_guard = app_state.ethercat_setup.write().await;
+        *ethercat_setup_guard = Some(EthercatSetup {
+            devices,
+            group: group_op,
+            maindevice,
+        });
+    }
+
+    // Notify client via socketio
+    let app_state_clone = app_state.clone();
+    smol::block_on(async move {
         let main_namespace = &mut app_state_clone
             .socketio_setup
             .namespaces
@@ -393,12 +278,7 @@ pub async fn setup_loop(
             .build(app_state_clone.clone())
             .await;
         main_namespace.emit(MainNamespaceEvents::EthercatDevicesEvent(event));
-    }
-    tracing::info!("DONE WITH INIT");
-
-    return Ok(EthercatSetup {
-        devices,
-        group: group_op,
-        maindevice,
     });
+
+    Ok(())
 }

server/src/logging/mod.rs

@@ -6,6 +6,9 @@ pub mod fmt;
 #[cfg(feature = "tracing-journald")]
 pub mod journald;
 
+#[cfg(feature = "tracing-otel")]
+pub mod opentelemetry;
+
 /// Initialize the basic tracing system (without OpenTelemetry if enabled)
 /// OpenTelemetry layer is deferred until async runtime is available
 pub fn init_tracing() {
@@ -53,5 +56,21 @@ pub fn init_tracing() {
         }
     };
 
+    // Add OpenTelemetry layer if enabled, using a dedicated Tokio thread
+    let subscriber = {
+        #[cfg(feature = "tracing-otel")]
+        {
+            // First add a filter layer to block events from the OtelExporter thread
+            let subscriber = subscriber.with(opentelemetry::create_thread_filter_layer());
+
+            // Then add the OpenTelemetry layer
+            subscriber.with(opentelemetry::init_opentelemetry_tracing_with_tokio())
+        }
+        #[cfg(not(feature = "tracing-otel"))]
+        {
+            subscriber
+        }
+    };
+
     subscriber.init();
 }