Fixed merge issues

diameter.

.gitignore

@@ -3,3 +3,5 @@ dist/
 .DS_Store
 Cargo.lock
 dhat-heap.json
+build.sh
+

CHANGELOG.md

@@ -1,3 +1,40 @@
+# `2.11.0`
+_21.10.2025_
+
+## General 
+- [#829](https://github.com/qitechgmbh/control/pull/829), [#834](https://github.com/qitechgmbh/control/pull/834), Improved overall system stability
+
+## Winder V2 
+- [#840](https://github.com/qitechgmbh/control/pull/840) Added XL Winder option
+- [#827](https://github.com/qitechgmbh/control/pull/827) Spool can now be run in reverse
+
+## Extruder V2
+- [#826](https://github.com/qitechgmbh/control/pull/826) Fine grained Temperature-PID configuration now possible
+
+
+# `2.10.0`
+_16.10.2025_
+
+## Winder V2
+- [#776](https://github.com/qitechgmbh/control/pull/776) Added explanation for padding in winder manual
+- [#804](https://github.com/qitechgmbh/control/pull/804) Added gearbox conversion
+
+## General 
+- [#717](https://github.com/qitechgmbh/control/pull/717) Show from option for graphs added
+- [#805](https://github.com/qitechgmbh/control/pull/805) Graphs run better now
+
+
+
+# `2.9.1`
+_10.10.2025_
+
+## Winder V2
+- [#796](https://github.com/qitechgmbh/control/pull/796) Winding in adaptive mode, while puller is in reverse mode is now possible
+
+## General
+- [#780](https://github.com/qitechgmbh/control/pull/780) Updates are faster now
+- [#746](https://github.com/qitechgmbh/control/pull/746) Improved scrollbar styling for manuals
+
 # `2.9.0`
 _06.10.2025_
 

Cargo.lock

@@ -2689,8 +2689,6 @@ dependencies = [
  "smol",
  "socketioxide",
  "textplots",
- "tikv-jemalloc-ctl",
- "tikv-jemallocator",
  "tokio",
  "tonic",
  "tower-http",
@@ -3013,37 +3011,6 @@ dependencies = [
  "once_cell",
 ]
 
-[[package]]
-name = "tikv-jemalloc-ctl"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f21f216790c8df74ce3ab25b534e0718da5a1916719771d3fec23315c99e468b"
-dependencies = [
- "libc",
- "paste",
- "tikv-jemalloc-sys",
-]
-
-[[package]]
-name = "tikv-jemalloc-sys"
-version = "0.6.0+5.3.0-1-ge13ca993e8ccb9ba9847cc330696e02839f328f7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd3c60906412afa9c2b5b5a48ca6a5abe5736aec9eb48ad05037a677e52e4e2d"
-dependencies = [
- "cc",
- "libc",
-]
-
-[[package]]
-name = "tikv-jemallocator"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cec5ff18518d81584f477e9bfdf957f5bb0979b0bac3af4ca30b5b3ae2d2865"
-dependencies = [
- "libc",
- "tikv-jemalloc-sys",
-]
-
 [[package]]
 name = "timerfd"
 version = "1.6.0"

README.md

@@ -7,6 +7,9 @@ QiTech Control is an industrial control panel software for the next generation o
 [![](https://img.youtube.com/vi/KI3YeBwfV-s/maxresdefault.jpg)](https://www.youtube.com/watch?v=KI3YeBwfV-s)
 *Click here to watch a video demo of our software.*
 
+[![](https://img.youtube.com/vi/55egCAkQgyM/maxresdefault.jpg)](https://youtu.be/55egCAkQgyM) 
+*Click here to watch a full explainer Video of our Software.*
+
 # Repo Structure
 
 Frontend
@@ -32,7 +35,7 @@ Other
 
 ## Backend
 
-To interface with Beckhoff and other EtherCAT devices we need an EtherCAY master stoftware. Possibilities are [PySOEM](https://github.com/bnjmnp/pysoem) (Python), [SOEM](https://github.com/OpenEtherCATsociety/SOEM) (C) and [Ethercrab](https://github.com/ethercrab-rs/ethercrab) (Rust). For realtime operation only C and Rust are suitable. We chose Rust because of safety and confidence in the written code.
+To interface with Beckhoff and other EtherCAT devices we need an EtherCAT master stoftware. Possibilities are [PySOEM](https://github.com/bnjmnp/pysoem) (Python), [SOEM](https://github.com/OpenEtherCATsociety/SOEM) (C) and [Ethercrab](https://github.com/ethercrab-rs/ethercrab) (Rust). For realtime operation only C and Rust are suitable. We chose Rust because of safety and confidence in the written code.
 
 [SocketIO](https://socket.io/) was chosen for performant event driven communication from the backend to the server. But we still use REST with [axum](https://docs.rs/axum/latest/axum/) for the communication thet benefits from the request/response model.
 

cargo_run_linux.sh

@@ -15,16 +15,18 @@ if [[ "$1" == "release" ]]; then
     cargo build --release
 else
     echo "Building Debug Code"
-    cargo build $FEATURE
+    cargo build $FEATURE --features development-build
 fi
 
 # Only setcap if not building with mock-machine
 if [ "$1" != "mock-machine" ]; then
     echo "Setting capabilities for server executable"
-    sudo setcap 'cap_net_raw,cap_sys_nice=eip' ./target/debug/server
+    sudo setcap 'cap_dac_override,cap_net_raw,cap_sys_nice,cap_ipc_lock=eip' ./target/debug/server
 
-    echo "Setting permissions for serial ports"
-#    sudo chown "root:$(groups | cut -f1 -d' ')" /dev/ttyUSB*
+    if compgen -G "/dev/ttyUSB*" > /dev/null; then
+      echo "Setting permissions for serial ports"
+      sudo chown "root:$(groups | cut -f1 -d' ')" /dev/ttyUSB*
+    fi
 fi
 
 # run

control-core/Cargo.toml

@@ -19,7 +19,7 @@ serde_json = "1.0.143"
 serialport = "4.7.3"
 smol = "2.0.2"
 socketioxide = "0.17.2"
-uom = "0.36.0"
+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"

control-core/src/controllers/deadtime_pi_controller.rs

@@ -0,0 +1,124 @@
+use std::time::{Duration, Instant};
+
+#[derive(Debug)]
+pub struct TimeAgnosticDeadTimePiController {
+    // Params
+    /// Proportional gain
+    kp: f64,
+    /// Integral gain
+    ki: f64,
+    // State
+    /// Proportional error
+    ep: f64,
+    /// Integral error
+    ei: f64,
+    /// Dead Time
+    dead: Duration,
+
+    last: Option<Instant>,
+}
+
+impl TimeAgnosticDeadTimePiController {
+    pub fn new(kp: f64, ki: f64, dead: Duration) -> Self {
+        Self {
+            kp,
+            ki,
+            dead,
+            ep: 0.0,
+            ei: 0.0,
+            last: None,
+        }
+    }
+
+    pub fn configure(&mut self, kp: f64, ki: f64) {
+        self.reset();
+        self.kp = kp;
+        self.ki = ki;
+    }
+
+    pub fn get_kp(&self) -> f64 {
+        self.kp
+    }
+
+    pub fn get_ki(&self) -> f64 {
+        self.ki
+    }
+
+    pub fn get_dead(&self) -> Duration {
+        self.dead
+    }
+
+    pub fn set_kp(&mut self, kp: f64) {
+        self.kp = kp;
+    }
+
+    pub fn set_ki(&mut self, ki: f64) {
+        self.ki = ki;
+    }
+
+    pub fn set_dead(&mut self, dead: Duration) {
+        self.dead = dead;
+    }
+
+    pub fn optional_clamp(value: f64, min: Option<f64>, max: Option<f64>) -> f64 {
+        match (min, max) {
+            (Some(min), Some(max)) => value.clamp(min, max),
+            (Some(min), None) => value.max(min),
+            (None, Some(max)) => value.min(max),
+            (None, None) => value,
+        }
+    }
+
+    pub fn update(&mut self, error: f64, t: Instant) -> f64 {
+        let kp = self.kp / 10000.0;
+        let ki = self.ki / 10000.0;
+        let signal = match self.last {
+            // First update
+            None => {
+                let ep = error;
+
+                // Initialize integral error
+                self.ei = 0.0;
+
+                // Proportional + Integral
+                let signal = kp * ep + ki * self.ei;
+
+                // Save state
+                self.ep = ep;
+                self.last = Some(t);
+
+                -signal
+            }
+            // Subsequent updates
+            Some(last) => {
+                // Calculate elapsed time
+                let dt = t.duration_since(last).as_secs_f64();
+
+                // Dead-time scaling factor
+                let dead_secs = self.dead.as_secs_f64();
+                let scale = (dt / dead_secs).min(1.0);
+
+                // Smoothed proportional error
+                let ep = self.ep + (error - self.ep) * scale;
+
+                // Integrate error over time
+                self.ei += error * dt;
+
+                // Proportional + Integral
+                let signal = kp * ep + ki * self.ei;
+
+                // Save state
+                self.ep = ep;
+                self.last = Some(t);
+
+                -signal
+            }
+        };
+        -signal
+    }
+
+    pub fn reset(&mut self) {
+        self.ep = 0.0;
+        //self.last = None;
+    }
+}

control-core/src/controllers/mod.rs

@@ -1,4 +1,5 @@
 pub mod clamping_timeagnostic_pid;
+pub mod deadtime_pi_controller;
 pub mod first_degree_motion;
 pub mod pid;
 pub mod second_degree_motion;

control-core/src/converters/angle_converter.rs

@@ -1,4 +1,4 @@
-use uom::si::angle::radian;
+use uom::si::{angle::radian, f64::Angle};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct AngleConverter {
@@ -63,7 +63,7 @@ impl AngleConverter {
     }
 
     /// Convert angle from mathematical system to this system (f32)
-    pub fn degrees_encode(&self, math_angle_degrees: f32) -> f32 {
+    pub fn degrees_encode(&self, math_angle_degrees: f64) -> f64 {
         let normalized_input = self.normalize_angle(math_angle_degrees);
 
         let mut result = normalized_input;
@@ -85,7 +85,7 @@ impl AngleConverter {
     }
 
     /// Convert angle from this system to mathematical system (f32)
-    pub fn degrees_decode(&self, system_angle_degrees: f32) -> f32 {
+    pub fn degrees_decode(&self, system_angle_degrees: f64) -> f64 {
         let normalized_input = self.normalize_angle(system_angle_degrees);
 
         let mut result = normalized_input;
@@ -107,14 +107,14 @@ impl AngleConverter {
     }
 
     /// Convert angle in radians from mathematical system to this system (f32)
-    pub fn radians_encode(&self, math_angle_radians: f32) -> f32 {
+    pub fn radians_encode(&self, math_angle_radians: f64) -> f64 {
         let degrees = math_angle_radians.to_degrees();
         let converted_degrees = self.degrees_encode(degrees);
         converted_degrees.to_radians()
     }
 
     /// Convert angle in radians from this system to mathematical system (f32)
-    pub fn radians_decode(&self, system_angle_radians: f32) -> f32 {
+    pub fn radians_decode(&self, system_angle_radians: f64) -> f64 {
         let degrees = system_angle_radians.to_degrees();
         let converted_degrees = self.degrees_decode(degrees);
         converted_degrees.to_radians()
@@ -179,7 +179,7 @@ impl AngleConverter {
     }
 
     /// Normalize angle to [0, 360) range (f32)
-    fn normalize_angle(&self, angle: f32) -> f32 {
+    fn normalize_angle(&self, angle: f64) -> f64 {
         let mut normalized = angle % 360.0;
         if normalized < 0.0 {
             normalized += 360.0;
@@ -207,30 +207,12 @@ impl AngleConverterUom {
         Self { angle_converter }
     }
 
-    pub fn encode(&self, angle: uom::si::f32::Angle) -> uom::si::f32::Angle {
-        uom::si::f32::Angle::new::<radian>(
-            self.angle_converter.radians_encode(angle.get::<radian>()),
-        )
+    pub fn encode(&self, angle: Angle) -> Angle {
+        Angle::new::<radian>(self.angle_converter.radians_encode(angle.get::<radian>()))
     }
 
-    pub fn decode(&self, angle: uom::si::f32::Angle) -> uom::si::f32::Angle {
-        uom::si::f32::Angle::new::<radian>(
-            self.angle_converter.radians_decode(angle.get::<radian>()),
-        )
-    }
-
-    pub fn encode_f64(&self, angle: uom::si::f64::Angle) -> uom::si::f64::Angle {
-        uom::si::f64::Angle::new::<radian>(
-            self.angle_converter
-                .radians_encode_f64(angle.get::<radian>()),
-        )
-    }
-
-    pub fn decode_f64(&self, angle: uom::si::f64::Angle) -> uom::si::f64::Angle {
-        uom::si::f64::Angle::new::<radian>(
-            self.angle_converter
-                .radians_decode_f64(angle.get::<radian>()),
-        )
+    pub fn decode(&self, angle: Angle) -> Angle {
+        Angle::new::<radian>(self.angle_converter.radians_decode(angle.get::<radian>()))
     }
 }
 
@@ -297,8 +279,8 @@ mod tests {
         let converter = AngleConverter::screen();
 
         // Test radians_encode
-        let result = converter.radians_encode(PI / 2.0); // 90° in radians
-        let expected = 270.0 * PI / 180.0; // 270° in radians
+        let result = converter.radians_encode(PI as f64 / 2.0) as f64; // 90° in radians
+        let expected: f64 = 270.0f64 * PI as f64 / 180.0f64; // 270° in radians
         assert!((result - expected).abs() < 1e-6);
     }
 
@@ -306,10 +288,10 @@ mod tests {
     fn test_roundtrip_conversion() {
         let converter = AngleConverter::new(true, false, true); // X-flip + CW
 
-        let original = 75.0_f32;
+        let original = 75.0_f64;
         let converted = converter.degrees_encode(original);
         let roundtrip = converter.degrees_decode(converted);
 
-        assert!((original - roundtrip).abs() < 1e-6);
+        assert!((original - roundtrip as f64).abs() < 1e-6);
     }
 }

control-core/src/ethercat/interface_discovery.rs

@@ -1,4 +1,4 @@
-use std::{sync::Arc, time::Duration};
+use std::{process::Command, sync::Arc, time::Duration};
 
 use ethercrab::{
     MainDevice, MainDeviceConfig, PduStorage, Timeouts,
@@ -12,14 +12,46 @@ const IFACE_DISCOVERY_MAX_PDU_DATA: usize = PduStorage::element_size(1100);
 const IFACE_DISCOVERY_MAX_FRAMES: usize = 16;
 const IFACE_DISCOVERY_MAX_PDI_LEN: usize = 128;
 
-/// Finds an ethernet interface that is suitable for EtherCAT communication.
-///
-/// ```ignore
-/// match discover_ethercat_interface().await {
-///     Ok(interface) => println!("Found working interface: {}", interface),
-///     Err(_) => println!("No working interface found"),
-/// }
-/// ```
+/// Sets a network interface to unmanaged by NetworkManager.
+/// Returns true if the command succeeded.
+pub fn set_interface_managed(interface: &str, managed: bool) -> bool {
+    let managed_str = match managed {
+        true => "yes",
+        false => "no",
+    };
+    tracing::info!(
+        "set_interface_managed for {} managed was set to: {}",
+        interface,
+        managed_str
+    );
+    let status = Command::new("nmcli")
+        .args(["dev", "set", interface, "managed", managed_str])
+        .status();
+
+    matches!(status, Ok(s) if s.success())
+}
+
+/// Returns true if the given network interface is Ethernet.
+/// Prevents testing wlan,loopback and other non ethernet devices
+fn is_ethernet(interface: &str) -> std::io::Result<bool> {
+    #[cfg(target_os = "linux")]
+    {
+        let base_path = format!("/sys/class/net/{}", interface);
+        let type_path = std::path::Path::new(&base_path).join("type");
+        let iface_type = std::fs::read_to_string(&type_path)?.trim().to_string();
+        // 1 means Ethernet
+        let reports_as_ethernet = iface_type == "1";
+        // Double-check that it's not a wireless interface
+        let uevent_path = std::path::Path::new(&base_path).join("uevent");
+        let uevent = std::fs::read_to_string(&uevent_path).unwrap_or_default();
+        // If "DEVTYPE=wlan" appears, it's lying
+        let actually_wifi = uevent.contains("DEVTYPE=wlan");
+        return Ok(reports_as_ethernet && !actually_wifi);
+    }
+    #[cfg(not(target_os = "linux"))]
+    return Ok(true);
+}
+
 pub async fn discover_ethercat_interface() -> Result<String, anyhow::Error> {
     tracing::info!("Discovering EtherCAT interface...");
 
@@ -37,7 +69,6 @@ pub async fn discover_ethercat_interface() -> Result<String, anyhow::Error> {
         } else {
             tracing::debug!("Suppressed panic in interface test: {}", panic_info);
         }
-        // Don't call the default hook, which would print the backtrace
     }));
 
     // Get eligible interfaces
@@ -48,6 +79,7 @@ pub async fn discover_ethercat_interface() -> Result<String, anyhow::Error> {
             iface.is_up()
                 && iface.is_running()
                 && !iface.is_loopback()
+                && is_ethernet(&iface.name).unwrap_or(false)
                 && !iface.name.starts_with("bridge")
                 && !iface.name.starts_with("utun")   // Exclude tunnel interfaces
                 && !iface.name.starts_with("awdl")   // Exclude Apple Wireless Direct Link
@@ -56,57 +88,42 @@ pub async fn discover_ethercat_interface() -> Result<String, anyhow::Error> {
         })
         .collect::<Vec<_>>();
 
-    // Sort interfaces by name
     interfaces.sort_by(|a, b| a.name.cmp(&b.name));
+    let mut interface: Option<&str> = None;
 
-    // Try all interfaces concurrently
-    let tasks = interfaces
-        .iter()
-        .map(|iface| {
-            let name = iface.name.clone();
-            std::thread::Builder::new()
-                .name(format!("ethercat-test-{}", name))
-                .spawn(move || {
-                    std::panic::catch_unwind(|| {
-                        smol::block_on(async {
-                            match test_interface(&name) {
-                                Ok(_) => {
-                                    tracing::info!("Found working EtherCAT interface: {}", name);
-                                    Some(name.clone())
-                                }
-                                Err(_) => {
-                                    tracing::debug!("Interface {} failed", name);
-                                    None
-                                }
-                            }
-                        })
-                    })
-                    .unwrap_or(None)
-                })
-                .expect("Failed to spawn thread")
-        })
-        .collect::<Vec<_>>();
+    for i in 0..interfaces.len() {
+        // Avoid NetworkManager hangups
+        set_interface_managed(&interfaces[i].name, false);
 
-    // Wait for all tasks to complete and collect successful results
-    let successful_interfaces: Vec<String> = tasks
-        .into_iter()
-        .filter_map(|task| task.join().expect("Should join thread"))
-        .collect();
+        match test_interface(&interfaces[i].name) {
+            Ok(_) => {
+                // if interface found with ethercat Exit early, we expect only one interface with ethercat
+                interface = Some(&interfaces[i].name);
+                break;
+            }
+            Err(_) => (),
+        }
+    }
 
-    // Return the first successful interface (they're sorted by name)
-    let result = successful_interfaces.into_iter().next();
+    for i in 0..interfaces.len() {
+        if interface.is_some() && interface.unwrap() == &interfaces[i].name {
+            continue;
+        } else {
+            set_interface_managed(&interfaces[i].name, true);
+        }
+    }
 
     // Restore the default panic hook
     std::panic::set_hook(default_hook);
 
-    match result {
-        Some(name) => Ok(name),
-        None => Err(anyhow::anyhow!("No suitable EtherCAT interface found")),
+    match interface {
+        Some(interface) => return Ok(interface.to_string()),
+        None => return Err(anyhow::anyhow!("No suitable EtherCAT interface found")),
     }
 }
 
 fn test_interface(interface: &str) -> Result<(), anyhow::Error> {
-    tracing::trace!("Testing interface: {}", interface);
+    tracing::info!("Testing interface: {}", interface);
 
     let pdu_storage = Box::leak(Box::new(PduStorage::<
         IFACE_DISCOVERY_MAX_FRAMES,
@@ -144,7 +161,7 @@ fn test_interface(interface: &str) -> Result<(), anyhow::Error> {
                 // Default 10000
                 dc_static_sync_iterations: 10000,
                 // Default None
-                retry_behaviour: ethercrab::RetryBehaviour::Count(5),
+                retry_behaviour: ethercrab::RetryBehaviour::Count(3),
             },
         ));
 

control-core/src/machines/connection.rs

@@ -92,7 +92,7 @@ pub struct MachineCrossConnection<
 > {
     machine_manager: Weak<RwLock<MachineManager>>,
     machine_identification_unique: MachineIdentificationUnique,
-    connected_machine: Weak<Mutex<MachineSlot<T>>>,
+    pub 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
@@ -102,7 +102,7 @@ pub struct MachineCrossConnection<
                                                        // to an unknown type. See also https://github.com/qitechgmbh/control/pull/625#discussion_r2379566315
 }
 
-#[derive(Serialize, Debug, Clone)]
+#[derive(Serialize, Debug, Clone, Default)]
 pub struct MachineCrossConnectionState {
     /// Connected Machine
     pub machine_identification_unique: Option<MachineIdentificationUnique>,

control-core/src/serial/mod.rs

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

control-core/src/serial/panic.rs

@@ -1,53 +0,0 @@
-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/serial_detection.rs

@@ -7,194 +7,70 @@
 */
 
 use serialport::{SerialPortInfo, SerialPortType, UsbPortInfo};
-use smol::{
-    channel::{Receiver, Sender, unbounded},
-    lock::RwLock,
-};
-use std::{collections::HashMap, sync::Arc};
+use std::collections::HashMap;
 
-use crate::{
-    helpers::compare_lists::compare_lists, machines::identification::DeviceIdentification,
-};
+use super::SerialDeviceIdentification;
+/// Handles scanning and caching of connected USB serial devices.
+pub struct SerialDetection {}
 
-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,
+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(),
         }
     }
 
-    /*
-     *@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();
+    /// 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 {
-                usb_ports.push((port.port_name.to_string(), usb_info.clone()));
-            };
+            if let SerialPortType::UsbPort(usb_info) = port.port_type {
+                map.insert(port.port_name, usb_info);
+            }
         }
-
-        usb_ports
+        map
     }
 
-    pub async fn check_ports(&mut self) -> CheckPortsResult {
-        // get available ports
+    /// 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();
-
-        // 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);
-            }
-        }
-
-        result
+        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);
-        };
-
-        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);
+    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;
+    }
 
-        removed_signals
+    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;
     }
 }
-
-#[derive(Debug)]
-pub struct CheckPortsResult {
-    pub added: Vec<(DeviceIdentification, Arc<RwLock<dyn SerialDevice>>)>,
-    pub removed: Vec<DeviceIdentification>,
-}

control-core/src/socketio/namespace.rs

@@ -118,7 +118,6 @@ 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() {

electron/package-lock.json

@@ -70,7 +70,7 @@
         "@electron/fuses": "^2.0.0",
         "@eslint/compat": "^1.2.6",
         "@eslint/js": "^9.18.0",
-        "@playwright/test": "^1.50.1",
+        "@playwright/test": "^1.56.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.3.6",
+        "vite": "^6.4.1",
         "vitest": "^3.0.6"
       }
     },
@@ -2278,12 +2278,13 @@
       }
     },
     "node_modules/@playwright/test": {
-      "version": "1.54.2",
-      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.54.2.tgz",
-      "integrity": "sha512-A+znathYxPf+72riFd1r1ovOLqsIIB0jKIoPjyK2kqEIe30/6jF6BC7QNluHuwUmsD2tv1XZVugN8GqfTMOxsA==",
+      "version": "1.56.1",
+      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.56.1.tgz",
+      "integrity": "sha512-vSMYtL/zOcFpvJCW71Q/OEGQb7KYBPAdKh35WNSkaZA75JlAO8ED8UN6GUNTm3drWomcbcqRPFqQbLae8yBTdg==",
       "dev": true,
+      "license": "Apache-2.0",
       "dependencies": {
-        "playwright": "1.54.2"
+        "playwright": "1.56.1"
       },
       "bin": {
         "playwright": "cli.js"
@@ -7014,16 +7015,6 @@
       "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
       "dev": true
     },
-    "node_modules/encoding": {
-      "version": "0.1.13",
-      "resolved": "https://registry.npmjs.org/encoding/-/encoding-0.1.13.tgz",
-      "integrity": "sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==",
-      "dev": true,
-      "optional": true,
-      "dependencies": {
-        "iconv-lite": "^0.6.2"
-      }
-    },
     "node_modules/end-of-stream": {
       "version": "1.4.5",
       "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
@@ -11877,12 +11868,13 @@
       }
     },
     "node_modules/playwright": {
-      "version": "1.54.2",
-      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.54.2.tgz",
-      "integrity": "sha512-Hu/BMoA1NAdRUuulyvQC0pEqZ4vQbGfn8f7wPXcnqQmM+zct9UliKxsIkLNmz/ku7LElUNqmaiv1TG/aL5ACsw==",
+      "version": "1.56.1",
+      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.56.1.tgz",
+      "integrity": "sha512-aFi5B0WovBHTEvpM3DzXTUaeN6eN0qWnTkKx4NQaH4Wvcmc153PdaY2UBdSYKaGYw+UyWXSVyxDUg5DoPEttjw==",
       "dev": true,
+      "license": "Apache-2.0",
       "dependencies": {
-        "playwright-core": "1.54.2"
+        "playwright-core": "1.56.1"
       },
       "bin": {
         "playwright": "cli.js"
@@ -11895,10 +11887,11 @@
       }
     },
     "node_modules/playwright-core": {
-      "version": "1.54.2",
-      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.54.2.tgz",
-      "integrity": "sha512-n5r4HFbMmWsB4twG7tJLDN9gmBUeSPcsBZiWSE4DnYz9mJMAFqr2ID7+eGC9kpEnxExJ1epttwR59LEWCk8mtA==",
+      "version": "1.56.1",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.56.1.tgz",
+      "integrity": "sha512-hutraynyn31F+Bifme+Ps9Vq59hKuUCz7H1kDOcBs+2oGguKkWTU50bBWrtz34OUWmIwpBTWDxaRPXrIXkgvmQ==",
       "dev": true,
+      "license": "Apache-2.0",
       "bin": {
         "playwright-core": "cli.js"
       },
@@ -14672,9 +14665,9 @@
       }
     },
     "node_modules/vite": {
-      "version": "6.3.6",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-6.3.6.tgz",
-      "integrity": "sha512-0msEVHJEScQbhkbVTb/4iHZdJ6SXp/AvxL2sjwYQFfBqleHtnCqv1J3sa9zbWz/6kW1m9Tfzn92vW+kZ1WV6QA==",
+      "version": "6.4.1",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.1.tgz",
+      "integrity": "sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==",
       "license": "MIT",
       "dependencies": {
         "esbuild": "^0.25.0",

electron/package.json

@@ -34,7 +34,7 @@
     "@electron/fuses": "^2.0.0",
     "@eslint/compat": "^1.2.6",
     "@eslint/js": "^9.18.0",
-    "@playwright/test": "^1.50.1",
+    "@playwright/test": "^1.56.1",
     "@tailwindcss/postcss": "^4.0.6",
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.3.0",
@@ -61,7 +61,7 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.7.3",
     "typescript-eslint": "^8.24.1",
-    "vite": "^6.3.6",
+    "vite": "^6.4.1",
     "vitest": "^3.0.6"
   },
   "dependencies": {

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

@@ -416,6 +416,29 @@ Then start the machine as follows:
 
 <br>
 
+**Understanding Padding**
+
+The **padding** parameter creates a safety margin that prevents the filament from winding too close to the spool edges. When you set the inner and outer limits during calibration, the padding value is automatically subtracted from the actual travel distance.
+
+**How padding works:**
+
+- When you have a 1.75mm diameter filament and the traverse moves to a flank position, the **center** of the filament aligns with that flank
+- If you set 1mm padding, the system automatically maintains at least 1mm distance from the flanks
+- This prevents the filament from overlapping or winding beyond the spool edges
+
+**Example:**
+
+- Outer limit: 90mm, Inner limit: 22mm
+- Padding: 1mm
+- **Actual winding area:** 89mm to 23mm (reduced by 1mm on each side)
+- This ensures the filament stays within the spool boundaries with a safe margin
+
+The default padding is 0.88mm, but you can adjust this value in the Control settings based on your filament diameter and winding requirements. Larger filaments may require more padding, while smaller filaments can use less padding for maximum spool utilization.
+
+![Padding example](images/manuals/winder/winder_padding_example_image.jpg)
+
+<br>
+
 **4. Start pulling**
 
 - Select “Control” in the function bar

electron/src/client/socketioStore.ts

@@ -386,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
@@ -430,7 +430,7 @@ const useSocketioStore = create<SocketioStore>()((set, get) => ({
           }
         }),
       );
-    }
+    }*/
   },
 }));
 

electron/src/components/MachineConnectionDropdown.tsx

@@ -10,7 +10,7 @@ import {
 import React from "react";
 
 import { Icon } from "@/components/Icon";
-import { ControlCard } from "@/control/ControlCard";
+import { TouchButton } from "./touch/TouchButton";
 
 interface MachineIdentificationUnique {
   machine_identification: {
@@ -49,67 +49,64 @@ export const MachineSelector: React.FC<MachineSelectorProps> = ({
   connectedMachineState,
   setConnectedMachine,
   clearConnectedMachine,
-  title = "Machine Connection",
 }) => {
   return (
-    <ControlCard title={title}>
-      <DropdownMenu>
-        <DropdownMenuTrigger asChild>
-          <button className="flex items-center gap-2 rounded border px-4 py-2 text-left">
-            <Icon name="lu:Settings" className="text-xl" />
-            <span>
-              {selectedMachine?.name ?? "Select a Machine"}{" "}
-              {selectedMachine?.machine_identification_unique.serial ?? ""}
-            </span>
-          </button>
-        </DropdownMenuTrigger>
-        <DropdownMenuContent align="start">
-          <DropdownMenuLabel>Available Machines</DropdownMenuLabel>
-          <DropdownMenuSeparator />
-          {machines.map((machine) => {
-            const isSelected =
-              connectedMachineState?.machine_identification_unique
-                ?.machine_identification.machine ===
-              machine.machine_identification_unique.machine_identification
-                .machine;
+    <DropdownMenu>
+      <DropdownMenuTrigger asChild>
+        <TouchButton className="text-md h-max px-6 py-6" variant="outline">
+          <div className="flex flex-row items-center gap-2 text-wrap">
+            <Icon name="lu:Link2" className="size-6" />
+            {selectedMachine?.name ?? "Select a Machine"}{" "}
+            {selectedMachine?.machine_identification_unique.serial ?? ""}
+          </div>
+        </TouchButton>
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align="start">
+        <DropdownMenuLabel>Available Machines</DropdownMenuLabel>
+        <DropdownMenuSeparator />
+        {machines.map((machine) => {
+          const isSelected =
+            connectedMachineState?.machine_identification_unique
+              ?.machine_identification.machine ===
+            machine.machine_identification_unique.machine_identification
+              .machine;
 
-            return (
-              <DropdownMenuItem
-                key={machine.machine_identification_unique.serial}
-                onClick={() =>
-                  setConnectedMachine(machine.machine_identification_unique)
-                }
-                className={`flex min-h-[48px] cursor-pointer items-center gap-2 py-2${
-                  isSelected ? "bg-blue-50" : ""
-                }`}
-              >
-                {connectedMachineState?.is_available ? (
-                  <Icon name="lu:Power" className="text-lg text-green-600" />
-                ) : (
-                  <Icon name="lu:Power" className="text-lg text-gray-400" />
-                )}
-                <span>
-                  {machine.name} – Serial:{" "}
-                  {machine.machine_identification_unique.serial}
-                </span>
-              </DropdownMenuItem>
-            );
-          })}
+          return (
+            <DropdownMenuItem
+              key={machine.machine_identification_unique.serial}
+              onClick={() =>
+                setConnectedMachine(machine.machine_identification_unique)
+              }
+              className={`flex h-max cursor-pointer items-center gap-2 px-6 py-6${
+                isSelected ? "bg-blue-50" : ""
+              }`}
+            >
+              {connectedMachineState?.is_available ? (
+                <Icon name="lu:Link2" className="size-6 text-green-600" />
+              ) : (
+                <Icon name="lu:Link2Off" className="size-6 text-black" />
+              )}
+              <span>
+                {machine.name} – Serial:{" "}
+                {machine.machine_identification_unique.serial}
+              </span>
+            </DropdownMenuItem>
+          );
+        })}
 
-          {clearConnectedMachine && (
-            <>
-              <DropdownMenuSeparator />
-              <DropdownMenuItem
-                onClick={clearConnectedMachine}
-                className="flex cursor-pointer items-center gap-2 text-red-600 hover:text-red-600"
-              >
-                <Icon name="lu:Settings" className="text-lg" />
-                <span>Clear Selection</span>
-              </DropdownMenuItem>
-            </>
-          )}
-        </DropdownMenuContent>
-      </DropdownMenu>
-    </ControlCard>
+        {clearConnectedMachine && (
+          <>
+            <DropdownMenuSeparator />
+            <DropdownMenuItem
+              onClick={clearConnectedMachine}
+              className="flex cursor-pointer items-center gap-2 text-red-600 hover:text-red-600"
+            >
+              <Icon name="lu:X" className="size-6 text-red-600" />
+              <span>Disconnect Machine</span>
+            </DropdownMenuItem>
+          </>
+        )}
+      </DropdownMenuContent>
+    </DropdownMenu>
   );
 };

electron/src/components/MarkdownWithToc.tsx

@@ -58,15 +58,10 @@ export function MarkdownWithToc({
           className={`sticky ${stickyTop}`}
           style={{ maxHeight: "calc(100vh - 6rem)" }}
         >
-          {/* Hide scrollbar for the TOC container across browsers */}
-          <style>{`
-            [data-toc-scroll-container] { -ms-overflow-style: none; scrollbar-width: none; }
-            [data-toc-scroll-container]::-webkit-scrollbar { display: none; }
-          `}</style>
+          {/* Table of Contents with hidden scrollbar */}
           <div
-            className="overflow-y-auto"
+            className="scrollbar-hidden overflow-y-auto"
             style={{ maxHeight: "calc(100vh - 8rem)" }}
-            data-toc-scroll-container
           >
             <MarkdownToc
               markdownContent={markdownContent}

electron/src/components/Terminal.tsx

@@ -199,7 +199,7 @@ export function Terminal({
       </div>
 
       {/* Virtualized List */}
-      <div className="flex-grow bg-black text-white">
+      <div className="flex-grow overflow-y-auto bg-neutral-900 p-4 text-neutral-300">
         <AutoSizer>
           {({ width, height }) => (
             <List

electron/src/components/graph/BigGraph.tsx

@@ -474,6 +474,7 @@ export function BigGraph({
     isLiveMode,
     selectedTimeWindow,
     visibleSeries, // Keep for initial creation
+    showFromTimestamp: syncGraph?.showFromTimestamp,
     setSelectedTimeWindow,
     setViewMode,
     setIsLiveMode,

electron/src/components/graph/GraphControls.tsx

@@ -2,6 +2,7 @@ import React, { useState } from "react";
 import { TouchButton } from "@/components/touch/TouchButton";
 import { Icon } from "@/components/Icon";
 import { ControlCard } from "@/control/ControlCard";
+import { TimeInput } from "@/components/time/TimeInput";
 import {
   DropdownMenu,
   DropdownMenuContent,
@@ -21,8 +22,14 @@ export function GraphControls({
   onSwitchToHistorical,
   onExport,
   timeWindowOptions = DEFAULT_TIME_WINDOW_OPTIONS,
+  showFromTimestamp,
+  onShowFromChange,
 }: ControlProps) {
   const getSelectedTimeWindowLabel = () => {
+    // If Show from Time is set, display "Show All" for the time window
+    if (showFromTimestamp) {
+      return "Show All";
+    }
     const option = timeWindowOptions.find((opt) => opt.value === timeWindow);
     return option ? option.label : "1m";
   };
@@ -35,7 +42,10 @@ export function GraphControls({
             <DropdownMenuTrigger asChild>
               <TouchButton
                 variant="outline"
-                className="h-auto border-gray-300 bg-white px-3 py-3 text-base text-gray-900 hover:bg-gray-50"
+                className={`h-auto border-gray-300 bg-white px-3 py-3 text-base text-gray-900 hover:bg-gray-50 ${
+                  showFromTimestamp ? "cursor-not-allowed opacity-50" : ""
+                }`}
+                disabled={!!showFromTimestamp}
               >
                 {getSelectedTimeWindowLabel()}
                 <Icon name="lu:ChevronDown" className="ml-2 size-4" />
@@ -60,6 +70,15 @@ export function GraphControls({
             </DropdownMenuContent>
           </DropdownMenu>
 
+          {/* Show From Time Input - only visible in historical mode */}
+          {!isLiveMode && onShowFromChange && (
+            <TimeInput
+              timestamp={showFromTimestamp}
+              onTimeChange={onShowFromChange}
+              onClear={() => onShowFromChange(null)}
+            />
+          )}
+
           <TouchButton
             onClick={onSwitchToHistorical}
             variant="outline"
@@ -109,10 +128,16 @@ export function FloatingControlPanel({
   onSwitchToHistorical,
   onExport,
   timeWindowOptions = DEFAULT_TIME_WINDOW_OPTIONS,
+  showFromTimestamp,
+  onShowFromChange,
 }: ControlProps) {
   const [isExpanded, setIsExpanded] = useState(false);
 
   const getSelectedTimeWindowLabel = () => {
+    // If Show from Time is set, display "Show All" for the time window
+    if (showFromTimestamp) {
+      return "Show All";
+    }
     const option = timeWindowOptions.find((opt) => opt.value === timeWindow);
     return option ? option.label : "1m";
   };
@@ -134,7 +159,10 @@ export function FloatingControlPanel({
               <DropdownMenuTrigger asChild>
                 <TouchButton
                   variant="outline"
-                  className="h-auto border-gray-300 bg-white px-3 py-3 text-base text-gray-900 hover:bg-gray-50"
+                  className={`h-auto border-gray-300 bg-white px-3 py-3 text-base text-gray-900 hover:bg-gray-50 ${
+                    showFromTimestamp ? "cursor-not-allowed opacity-50" : ""
+                  }`}
+                  disabled={!!showFromTimestamp}
                 >
                   {getSelectedTimeWindowLabel()}
                   <Icon name="lu:ChevronDown" className="ml-2 size-4" />
@@ -159,6 +187,15 @@ export function FloatingControlPanel({
               </DropdownMenuContent>
             </DropdownMenu>
 
+            {/* Show From Time Input - only visible in historical mode */}
+            {!isLiveMode && onShowFromChange && (
+              <TimeInput
+                timestamp={showFromTimestamp}
+                onTimeChange={onShowFromChange}
+                onClear={() => onShowFromChange(null)}
+              />
+            )}
+
             <TouchButton
               onClick={onSwitchToHistorical}
               variant="outline"

electron/src/components/graph/createChart.ts

@@ -31,10 +31,8 @@ export function createChart({
   setCursorValue,
   setCursorValues,
   visibleSeries,
-}: CreateChartParams & {
-  setCursorValues?: React.Dispatch<React.SetStateAction<(number | null)[]>>;
-  visibleSeries?: boolean[];
-}): (() => void) | undefined {
+  showFromTimestamp,
+}: CreateChartParams): (() => void) | undefined {
   if (!containerRef.current) return;
 
   // Get ALL series from original data
@@ -73,7 +71,7 @@ export function createChart({
     initialMin = manualScaleRef.current.x.min;
     initialMax = manualScaleRef.current.x.max;
   } else if (selectedTimeWindow === "all") {
-    initialMin = fullStart;
+    initialMin = showFromTimestamp ?? fullStart;
     initialMax = getHistoricalEndTimestamp();
   } else {
     const endTimestamp = getHistoricalEndTimestamp();
@@ -83,9 +81,10 @@ export function createChart({
         endTimestamp - (selectedTimeWindow as number),
         fullStart,
       );
-      initialMin = defaultViewStart;
+      initialMin = showFromTimestamp ?? defaultViewStart;
     } else {
-      initialMin = endTimestamp - (selectedTimeWindow as number);
+      initialMin =
+        showFromTimestamp ?? endTimestamp - (selectedTimeWindow as number);
     }
 
     initialMax = endTimestamp;

electron/src/components/graph/types.ts

@@ -10,6 +10,7 @@ export type PropGraphSync = {
   isLiveMode: boolean;
   xRange?: { min: number; max: number };
   historicalFreezeTimestamp?: number | null;
+  showFromTimestamp?: number | null;
   onTimeWindowChange?: (graphId: string, timeWindow: number | "all") => void;
   onViewModeChange?: (
     graphId: string,
@@ -81,6 +82,8 @@ export type ControlProps = {
   onSwitchToHistorical: () => void;
   onExport?: () => void;
   timeWindowOptions?: TimeWindowOption[];
+  showFromTimestamp?: number | null;
+  onShowFromChange?: (timestamp: number | null) => void;
 };
 
 export interface LiveModeHandlers {
@@ -128,6 +131,9 @@ export interface CreateChartParams {
   >;
   setIsLiveMode: React.Dispatch<React.SetStateAction<boolean>>;
   setCursorValue: React.Dispatch<React.SetStateAction<number | null>>;
+  setCursorValues: React.Dispatch<React.SetStateAction<(number | null)[]>>;
+  visibleSeries: boolean[];
+  showFromTimestamp?: number | null;
 }
 
 export interface AnimationState {

electron/src/components/graph/useBigGraphEffects.ts

@@ -41,6 +41,7 @@ interface UseBigGraphEffectsProps {
   isLiveMode: boolean;
   selectedTimeWindow: number | "all";
   visibleSeries: boolean[];
+  showFromTimestamp?: number | null;
 
   // State setters
   setSelectedTimeWindow: (value: number | "all") => void;
@@ -90,6 +91,7 @@ export function useBigGraphEffects({
   isLiveMode,
   selectedTimeWindow,
   visibleSeries,
+  showFromTimestamp,
 
   setSelectedTimeWindow,
   setViewMode,
@@ -275,6 +277,7 @@ export function useBigGraphEffects({
       setCursorValue,
       setCursorValues,
       visibleSeries,
+      showFromTimestamp,
     });
 
     setIsChartCreated(true);

electron/src/components/graph/useGraphSync.ts

@@ -15,6 +15,9 @@ export function useGraphSync(exportGroupId?: string) {
   const [xRange, setXRange] = useState<
     { min: number; max: number } | undefined
   >();
+  const [showFromTimestamp, setShowFromTimestamp] = useState<number | null>(
+    null,
+  );
 
   const historicalFreezeTimestampRef = useRef<number | null>(null);
   const graphDataRef = useRef<Map<string, () => GraphExportData | null>>(
@@ -59,6 +62,7 @@ export function useGraphSync(exportGroupId?: string) {
         viewMode?: "default" | "all" | "manual";
         isLiveMode?: boolean;
         xRange?: { min: number; max: number } | undefined;
+        showFromTimestamp?: number | null;
         clearHistoricalFreeze?: boolean;
         setHistoricalFreeze?: boolean;
       },
@@ -90,6 +94,8 @@ export function useGraphSync(exportGroupId?: string) {
         if (updates.viewMode !== undefined) setViewMode(updates.viewMode);
         if (updates.isLiveMode !== undefined) setIsLiveMode(updates.isLiveMode);
         if (updates.xRange !== undefined) setXRange(updates.xRange);
+        if (updates.showFromTimestamp !== undefined)
+          setShowFromTimestamp(updates.showFromTimestamp);
 
         // Handle historical freeze timestamp
         if (updates.clearHistoricalFreeze) {
@@ -195,6 +201,7 @@ export function useGraphSync(exportGroupId?: string) {
       viewMode: timeWindow === "all" ? "all" : "default",
       xRange: undefined,
       clearHistoricalFreeze: true,
+      showFromTimestamp: null, // Clear the show from timestamp when switching to live
     });
   }, [updateSyncState, timeWindow]);
 
@@ -206,6 +213,15 @@ export function useGraphSync(exportGroupId?: string) {
     });
   }, [updateSyncState]);
 
+  const handleShowFromChange = useCallback(
+    (timestamp: number | null) => {
+      updateSyncState("control", {
+        showFromTimestamp: timestamp,
+      });
+    },
+    [updateSyncState],
+  );
+
   const handleControlTimeWindowChange = useCallback(
     (newTimeWindow: number | "all") => {
       updateSyncState("control", {
@@ -225,6 +241,7 @@ export function useGraphSync(exportGroupId?: string) {
     isLiveMode,
     xRange,
     historicalFreezeTimestamp: historicalFreezeTimestampRef.current,
+    showFromTimestamp,
     onTimeWindowChange: handleTimeWindowChange,
     onViewModeChange: handleViewModeChange,
     onZoomChange: handleZoomChangeThrottled,
@@ -237,6 +254,8 @@ export function useGraphSync(exportGroupId?: string) {
     onSwitchToLive: handleSwitchToLive,
     onSwitchToHistorical: handleSwitchToHistorical,
     onExport: handleExport,
+    showFromTimestamp,
+    onShowFromChange: handleShowFromChange,
   };
 
   return {
@@ -250,5 +269,6 @@ export function useGraphSync(exportGroupId?: string) {
     isLiveMode,
     xRange,
     historicalFreezeTimestamp: historicalFreezeTimestampRef.current,
+    showFromTimestamp,
   };
 }

electron/src/components/time/TimeInput.tsx

@@ -0,0 +1,367 @@
+import React, { useState, useCallback, useEffect } from "react";
+import { TouchButton } from "@/components/touch/TouchButton";
+import { Icon } from "@/components/Icon";
+import { Dialog, DialogContent, DialogTrigger } from "@/components/ui/dialog";
+import { useForm, useWatch } from "react-hook-form";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { z } from "zod";
+import { Separator } from "@/components/ui/separator";
+
+type TimeInputProps = {
+  timestamp?: number | null;
+  onTimeChange?: (timestamp: number | null) => void;
+  onClear?: () => void;
+};
+
+const timeSchema = z.object({
+  hours: z.number().min(0).max(23),
+  minutes: z.number().min(0).max(59),
+  seconds: z.number().min(0).max(59),
+});
+
+type TimeFormData = z.infer<typeof timeSchema>;
+
+export function TimeInput({
+  timestamp,
+  onTimeChange,
+  onClear,
+}: TimeInputProps) {
+  const [isOpen, setIsOpen] = useState(false);
+
+  // Get current time for initial values
+  const getCurrentTime = useCallback(() => {
+    const now = new Date();
+    return {
+      hours: now.getHours(),
+      minutes: now.getMinutes(),
+      seconds: now.getSeconds(),
+    };
+  }, []);
+
+  // Get initial values based on timestamp or current time
+  const getInitialValues = useCallback(() => {
+    if (timestamp) {
+      const date = new Date(timestamp);
+      return {
+        hours: date.getHours(),
+        minutes: date.getMinutes(),
+        seconds: date.getSeconds(),
+      };
+    }
+    return getCurrentTime();
+  }, [timestamp, getCurrentTime]);
+
+  const form = useForm<TimeFormData>({
+    resolver: zodResolver(timeSchema),
+    defaultValues: getInitialValues(),
+    mode: "all",
+  });
+
+  // Convert timestamp to time components
+  const timestampToTime = useCallback((ts: number) => {
+    const date = new Date(ts);
+    return {
+      hours: date.getHours(),
+      minutes: date.getMinutes(),
+      seconds: date.getSeconds(),
+    };
+  }, []);
+
+  // Check if the selected time would be in the future (today)
+  const isTimeInFuture = useCallback((time: TimeFormData) => {
+    const now = new Date();
+    const date = new Date(
+      now.getFullYear(),
+      now.getMonth(),
+      now.getDate(),
+      time.hours,
+      time.minutes,
+      time.seconds,
+    );
+    return date.getTime() > now.getTime();
+  }, []);
+
+  // Convert time components to timestamp (today's date only)
+  const timeToTimestamp = useCallback((time: TimeFormData) => {
+    const now = new Date();
+    const date = new Date(
+      now.getFullYear(),
+      now.getMonth(),
+      now.getDate(),
+      time.hours,
+      time.minutes,
+      time.seconds,
+    );
+
+    return date.getTime();
+  }, []);
+
+  // Initialize form with timestamp or current time when dialog opens
+  useEffect(() => {
+    if (isOpen) {
+      const initialValues = getInitialValues();
+      form.reset(initialValues);
+    }
+  }, [isOpen, getInitialValues, form]);
+
+  const formatTimeDisplay = useCallback(() => {
+    if (!timestamp) return "Show from Time";
+    const time = timestampToTime(timestamp);
+    return `${time.hours.toString().padStart(2, "0")}:${time.minutes.toString().padStart(2, "0")}:${time.seconds.toString().padStart(2, "0")}`;
+  }, [timestamp, timestampToTime]);
+
+  // Increment/decrement functions with bounds checking and cascading
+  const adjustTimeValue = useCallback(
+    (field: "hours" | "minutes" | "seconds", increment: boolean) => {
+      // Define the order of fields for cascading
+      const fields: ("hours" | "minutes" | "seconds")[] = [
+        "seconds",
+        "minutes",
+        "hours",
+      ];
+      const startIndex = fields.indexOf(field);
+      let carry = increment ? 1 : -1;
+
+      for (let i = startIndex; i < fields.length; i++) {
+        const currentField = fields[i];
+        const currentValue = form.getValues(currentField);
+        const max = currentField === "hours" ? 23 : 59;
+        let newValue = currentValue + carry;
+        carry = 0;
+
+        if (increment) {
+          if (newValue > max) {
+            newValue = 0;
+            carry = 1;
+          }
+        } else {
+          if (newValue < 0) {
+            newValue = max;
+            carry = -1;
+          }
+        }
+
+        form.setValue(currentField, newValue, {
+          shouldValidate: true,
+          shouldDirty: true,
+          shouldTouch: true,
+        });
+
+        // If no carry, stop cascading
+        if (carry === 0) {
+          break;
+        }
+      }
+    },
+    [form],
+  );
+
+  const handleSubmit = () => {
+    form.handleSubmit((data) => {
+      // Prevent submission if time is in the future
+      if (isTimeInFuture(data)) {
+        return;
+      }
+
+      const newTimestamp = timeToTimestamp(data);
+      onTimeChange?.(newTimestamp);
+      setIsOpen(false);
+    })();
+  };
+
+  const handleAbort = () => {
+    if (timestamp) {
+      const time = timestampToTime(timestamp);
+      form.reset(time);
+    } else {
+      const currentTime = getCurrentTime();
+      form.reset(currentTime);
+    }
+    setIsOpen(false);
+  };
+
+  const handleClear = () => {
+    onClear?.();
+    setIsOpen(false);
+  };
+
+  // Watch individual form fields for real-time updates
+  const hours = useWatch({
+    control: form.control,
+    name: "hours",
+    defaultValue: getInitialValues().hours,
+  });
+
+  const minutes = useWatch({
+    control: form.control,
+    name: "minutes",
+    defaultValue: getInitialValues().minutes,
+  });
+
+  const seconds = useWatch({
+    control: form.control,
+    name: "seconds",
+    defaultValue: getInitialValues().seconds,
+  });
+
+  // Get current form values with fallback
+  const currentValues = {
+    hours: hours ?? 0,
+    minutes: minutes ?? 0,
+    seconds: seconds ?? 0,
+  };
+
+  // TimeValueInput component for individual time fields
+  const TimeValueInput = ({
+    field,
+    label,
+    value,
+  }: {
+    field: "hours" | "minutes" | "seconds";
+    label: string;
+    value: number;
+  }) => (
+    <div className="flex flex-col items-center gap-3">
+      <label className="text-sm font-medium text-gray-700">{label}</label>
+      <div className="flex flex-col items-center gap-2">
+        <TouchButton
+          variant="outline"
+          size="sm"
+          className="h-10 w-16 p-0"
+          onClick={(e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            adjustTimeValue(field, true);
+          }}
+        >
+          <Icon name="lu:ChevronUp" className="size-4" />
+        </TouchButton>
+        <div className="flex h-16 w-20 items-center justify-center rounded border-2 border-gray-300 bg-white font-mono text-3xl">
+          {value.toString().padStart(2, "0")}
+        </div>
+        <TouchButton
+          variant="outline"
+          size="sm"
+          className="h-10 w-16 p-0"
+          onClick={(e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            adjustTimeValue(field, false);
+          }}
+        >
+          <Icon name="lu:ChevronDown" className="size-4" />
+        </TouchButton>
+      </div>
+    </div>
+  );
+
+  return (
+    <Dialog open={isOpen} onOpenChange={setIsOpen}>
+      <DialogTrigger asChild>
+        <TouchButton
+          variant="outline"
+          className="h-auto border-gray-300 bg-white px-3 py-3 text-base text-gray-900 hover:bg-gray-50"
+        >
+          <Icon name="lu:Clock" className="mr-2 size-4" />
+          {formatTimeDisplay()}
+        </TouchButton>
+      </DialogTrigger>
+
+      <DialogContent className="max-w-2xl p-8">
+        <div className="flex flex-col gap-8">
+          {/* Header */}
+          <div className="flex min-h-[2.5rem] items-center justify-between">
+            <div className="flex items-center gap-3">
+              <Icon name="lu:Clock" className="size-6" />
+              <h3 className="text-xl font-semibold">Show from Time</h3>
+            </div>
+            {timestamp && (
+              <TouchButton
+                variant="ghost"
+                size="sm"
+                onClick={handleClear}
+                className="text-red-600 hover:text-red-700"
+              >
+                <Icon name="lu:X" className="mr-2 size-4" />
+                Clear
+              </TouchButton>
+            )}
+          </div>
+
+          {/* Description */}
+          <div className="-mt-4 text-base text-gray-600">
+            Set a specific time to display data from that point forward in the
+            graph.
+          </div>
+
+          {/* Error for future time */}
+          {isTimeInFuture(currentValues) && (
+            <div className="rounded-lg border border-red-200 bg-red-50 p-4">
+              <div className="flex items-start gap-3">
+                <Icon name="lu:X" className="mt-0.5 size-5 text-red-600" />
+                <div>
+                  <div className="font-medium text-red-800">
+                    Cannot set future time
+                  </div>
+                  <div className="mt-1 text-sm text-red-700">
+                    The selected time is in the future. Please choose a time
+                    that has already occurred today.
+                  </div>
+                </div>
+              </div>
+            </div>
+          )}
+
+          <Separator />
+
+          {/* Time inputs */}
+          <div className="flex items-center justify-center gap-8">
+            <TimeValueInput
+              field="hours"
+              label="Hours"
+              value={currentValues.hours}
+            />
+            <div className="mt-8 text-4xl font-bold">:</div>
+            <TimeValueInput
+              field="minutes"
+              label="Minutes"
+              value={currentValues.minutes}
+            />
+            <div className="mt-8 text-4xl font-bold">:</div>
+            <TimeValueInput
+              field="seconds"
+              label="Seconds"
+              value={currentValues.seconds}
+            />
+          </div>
+
+          <Separator />
+
+          {/* Action buttons */}
+          <div className="flex gap-4">
+            <TouchButton
+              variant="outline"
+              className="h-14 flex-1"
+              onClick={handleAbort}
+            >
+              <Icon name="lu:X" className="mr-2 size-4" />
+              Cancel
+            </TouchButton>
+            <TouchButton
+              className={`h-14 flex-1 ${
+                isTimeInFuture(currentValues)
+                  ? "cursor-not-allowed bg-gray-300 text-gray-500"
+                  : "bg-blue-600 text-white hover:bg-blue-700"
+              }`}
+              onClick={handleSubmit}
+              disabled={isTimeInFuture(currentValues)}
+            >
+              <Icon name="lu:Check" className="mr-2 size-4" />
+              Apply
+            </TouchButton>
+          </div>
+        </div>
+      </DialogContent>
+    </Dialog>
+  );
+}

electron/src/control/StatusBadge.tsx

@@ -4,7 +4,7 @@ import { cva } from "class-variance-authority";
 import React from "react";
 
 type Props = {
-  variant: "error" | "success";
+  variant: "error" | "success" | "info";
   children: React.ReactNode;
 };
 
@@ -14,10 +14,18 @@ export function StatusBadge({ variant, children }: Props) {
       variant: {
         error: "bg-red-500",
         success: "bg-green-600",
+        info: "bg-yellow-400 text-black",
       },
     },
   });
-  const icon: IconName = variant === "error" ? "lu:TriangleAlert" : "lu:Check";
+
+  const icon: IconName =
+    variant === "error"
+      ? "lu:TriangleAlert"
+      : variant === "success"
+        ? "lu:Check"
+        : "lu:Info";
+
   return (
     <Badge
       className={badgeStyle({

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

@@ -6,6 +6,7 @@ import { SelectionGroupBoolean } from "@/control/SelectionGroup";
 import { EditValue } from "@/control/EditValue";
 import { roundToDecimals } from "@/lib/decimal";
 import { useExtruder2 } from "./useExtruder";
+import { ControlGrid } from "@/control/ControlGrid";
 
 export function Extruder2SettingsPage() {
   const {
@@ -18,6 +19,7 @@ export function Extruder2SettingsPage() {
     setPressurePidKp,
     setPressurePidKi,
     setPressurePidKd,
+    setTemperaturePidValue,
   } = useExtruder2();
 
   const [showAdvanced, setShowAdvanced] = useState(false);
@@ -116,6 +118,128 @@ export function Extruder2SettingsPage() {
               />
             </Label>
           </ControlCard>
+          <ControlGrid>
+            <ControlCard title="Temperature PID Settings (Front) ">
+              <Label label="Kp">
+                <EditValue
+                  value={state?.pid_settings.temperature.front.kp}
+                  defaultValue={defaultState?.pid_settings.temperature.front.kp}
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("front", "kp", v)}
+                  title="Temperature PID KP"
+                />
+              </Label>
+              <Label label="Ki">
+                <EditValue
+                  value={state?.pid_settings.temperature.front.ki}
+                  defaultValue={defaultState?.pid_settings.temperature.front.ki}
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("front", "ki", v)}
+                  title="Temperature PID KI"
+                />
+              </Label>
+              <Label label="Kd">
+                <EditValue
+                  value={state?.pid_settings.temperature.front.kd}
+                  defaultValue={defaultState?.pid_settings.temperature.front.kd}
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("front", "kd", v)}
+                  title="Temperature PID KD"
+                />
+              </Label>
+            </ControlCard>
+            <ControlCard title="Temperature PID Settings (Middle) ">
+              <Label label="Kp">
+                <EditValue
+                  value={state?.pid_settings.temperature.middle.kp}
+                  defaultValue={
+                    defaultState?.pid_settings.temperature.middle.kp
+                  }
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("middle", "kp", v)}
+                  title="Temperature PID KP"
+                />
+              </Label>
+              <Label label="Ki">
+                <EditValue
+                  value={state?.pid_settings.temperature.middle.ki}
+                  defaultValue={
+                    defaultState?.pid_settings.temperature.middle.ki
+                  }
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("middle", "ki", v)}
+                  title="Temperature PID KI"
+                />
+              </Label>
+              <Label label="Kd">
+                <EditValue
+                  value={state?.pid_settings.temperature.middle.kd}
+                  defaultValue={
+                    defaultState?.pid_settings.temperature.middle.kd
+                  }
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("middle", "kd", v)}
+                  title="Temperature PID KD"
+                />
+              </Label>
+            </ControlCard>
+            <ControlCard title="Temperature PID Settings (Back) ">
+              <Label label="Kp">
+                <EditValue
+                  value={state?.pid_settings.temperature.back.kp}
+                  defaultValue={defaultState?.pid_settings.temperature.back.kp}
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("back", "kp", v)}
+                  title="Temperature PID KP"
+                />
+              </Label>
+              <Label label="Ki">
+                <EditValue
+                  value={state?.pid_settings.temperature.back.ki}
+                  defaultValue={defaultState?.pid_settings.temperature.back.ki}
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("back", "ki", v)}
+                  title="Temperature PID KI"
+                />
+              </Label>
+              <Label label="Kd">
+                <EditValue
+                  value={state?.pid_settings.temperature.back.kd}
+                  defaultValue={defaultState?.pid_settings.temperature.back.kd}
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("back", "kd", v)}
+                  title="Temperature PID KD"
+                />
+              </Label>
+            </ControlCard>
+          </ControlGrid>
         </>
       )}
     </Page>

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

@@ -131,9 +131,24 @@ export const inverterStatusStateSchema = z.object({
  */
 export const pidSettingsSchema = z.object({
   temperature: z.object({
-    ki: z.number(),
-    kp: z.number(),
-    kd: z.number(),
+    front: z.object({
+      ki: z.number(),
+      kp: z.number(),
+      kd: z.number(),
+      zone: z.string(),
+    }),
+    middle: z.object({
+      ki: z.number(),
+      kp: z.number(),
+      kd: z.number(),
+      zone: z.string(),
+    }),
+    back: 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

@@ -293,6 +293,33 @@ export function useExtruder2() {
     );
   };
 
+  const setTemperaturePidValue = (
+    zone: "front" | "middle" | "back",
+    key: "kp" | "ki" | "kd",
+    value: number,
+  ) => {
+    updateStateOptimistically(
+      (current) => {
+        current.data.pid_settings.temperature[zone][key] = value;
+      },
+      () => {
+        const currentState = stateOptimistic.value;
+        if (currentState) {
+          const settings = produce(
+            currentState.data.pid_settings.temperature[zone],
+            (draft) => {
+              draft[key] = value;
+            },
+          );
+          requestTemperaturePidSettings({
+            machine_identification_unique: machineIdentification,
+            data: { SetTemperaturePidSettings: settings },
+          });
+        }
+      },
+    );
+  };
+
   const resetInverter = () => {
     // No optimistic update needed for reset
     requestResetInverter({
@@ -356,6 +383,17 @@ export function useExtruder2() {
     }),
   );
 
+  const { request: requestTemperaturePidSettings } = useMachineMutation(
+    z.object({
+      SetTemperaturePidSettings: z.object({
+        ki: z.number(),
+        kp: z.number(),
+        kd: z.number(),
+        zone: z.string(),
+      }),
+    }),
+  );
+
   const { request: requestResetInverter } = useMachineMutation(
     z.object({ ResetInverter: z.boolean() }),
   );
@@ -404,6 +442,7 @@ export function useExtruder2() {
     setPressurePidKp,
     setPressurePidKi,
     setPressurePidKd,
+    setTemperaturePidValue,
     resetInverter,
   };
 }

electron/src/machines/laser/laser1/Laser1ControlPage.tsx

@@ -72,6 +72,7 @@ export function Laser1ControlPage() {
             <div className="flex flex-row items-center gap-6">
               <TimeSeriesValueNumeric
                 label="Roundness"
+                icon="lu:Circle"
                 timeseries={roundness}
                 renderValue={(value) => value.toFixed(3)}
               />

electron/src/machines/laser/laser1/Laser1Page.tsx

@@ -20,6 +20,12 @@ export function Laser1Page() {
           title: "Graphs",
           icon: "lu:ChartSpline",
         },
+        {
+          link: "settings",
+          activeLink: "settings",
+          title: "Config",
+          icon: "lu:Settings",
+        },
         // {
         //     link: "manual",
         //     activeLink: "manual",

electron/src/machines/laser/laser1/Laser1Settings.tsx

@@ -0,0 +1,42 @@
+import React from "react";
+import { Page } from "@/components/Page";
+import { ControlCard } from "@/control/ControlCard";
+import { Label } from "@/control/Label";
+import { useLaser1 } from "./useLaser1";
+import { MachineSelector } from "@/components/MachineConnectionDropdown";
+import { ControlGrid } from "@/control/ControlGrid";
+
+export function Laser1SettingsPage() {
+  const {
+    state,
+    selectedMachine,
+    filteredMachines,
+    setConnectedWinder,
+    disconnectWinder,
+  } = useLaser1();
+
+  return (
+    <Page>
+      <ControlGrid>
+        <ControlCard title="Speed by Diameter Settings">
+          <Label label="Associated Winder">
+            <MachineSelector
+              machines={filteredMachines}
+              selectedMachine={selectedMachine}
+              connectedMachineState={state?.connected_winder_state}
+              setConnectedMachine={setConnectedWinder}
+              clearConnectedMachine={() => {
+                if (!selectedMachine) return;
+                setConnectedWinder({
+                  machine_identification: { vendor: 0, machine: 0 },
+                  serial: 0,
+                });
+                disconnectWinder(selectedMachine.machine_identification_unique);
+              }}
+            />
+          </Label>
+        </ControlCard>
+      </ControlGrid>
+    </Page>
+  );
+}

electron/src/machines/laser/laser1/laser1Namespace.ts

@@ -23,6 +23,24 @@ import {
 } from "@/lib/timeseries";
 
 // ========== Event Schema Definitions ==========
+/**
+ * Connected machine state schema
+ */
+export const machineIdentificationSchema = z.object({
+  vendor: z.number(),
+  machine: z.number(),
+});
+
+export const machineIdentificationUniqueSchema = z.object({
+  machine_identification: machineIdentificationSchema,
+  serial: z.number(),
+});
+
+export const connectedMachineStateSchema = z.object({
+  machine_identification_unique: machineIdentificationUniqueSchema.nullable(),
+  is_available: z.boolean(),
+});
+
 /**
  * Live values from Laser (30 FPS)
  */
@@ -43,6 +61,7 @@ export const stateEventDataSchema = z.object({
     lower_tolerance: z.number(),
     target_diameter: z.number(),
   }),
+  connected_winder_state: connectedMachineStateSchema,
 });
 
 // ========== Event Schemas with Wrappers ==========

electron/src/machines/laser/laser1/useLaser1.ts

@@ -1,13 +1,18 @@
 import { toastError } from "@/components/Toast";
 import { useMachineMutate as useMachineMutation } from "@/client/useClient";
-import { MachineIdentificationUnique } from "@/machines/types";
-import { laser1 } from "@/machines/properties";
+import {
+  machineIdentification,
+  machineIdentificationUnique,
+  MachineIdentificationUnique,
+} from "@/machines/types";
+import { laser1, VENDOR_QITECH } from "@/machines/properties";
 import { laser1SerialRoute } from "@/routes/routes";
 import { z } from "zod";
 import { useLaser1Namespace, StateEvent } from "./laser1Namespace";
 import { useEffect, useMemo } from "react";
 import { useStateOptimistic } from "@/lib/useStateOptimistic";
 import { produce } from "immer";
+import { useMachines } from "@/client/useMachines";
 
 function useLaser(machine_identification_unique: MachineIdentificationUnique) {
   // Get consolidated state and live values from namespace
@@ -54,6 +59,16 @@ function useLaser(machine_identification_unique: MachineIdentificationUnique) {
   const { request: requestHigherTolerance } = useMachineMutation(
     schemaHigherTolerance,
   );
+  const { request: requestConnectedWinder } = useMachineMutation(
+    z.object({
+      SetConnectedWinder: machineIdentificationUnique,
+    }),
+  );
+  const { request: requestDisconnectWinder } = useMachineMutation(
+    z.object({
+      DisconnectWinder: machineIdentificationUnique,
+    }),
+  );
 
   // Action functions with verb-first names
   const setTargetDiameter = (target_diameter: number) => {
@@ -101,10 +116,80 @@ function useLaser(machine_identification_unique: MachineIdentificationUnique) {
     );
   };
 
+  const setConnectedWinder = (machineIdentificationUnique: {
+    machine_identification: {
+      vendor: number;
+      machine: number;
+    };
+    serial: number;
+  }) => {
+    updateStateOptimistically(
+      (current) => {
+        current.data.connected_winder_state.machine_identification_unique =
+          machineIdentificationUnique;
+      },
+      () =>
+        requestConnectedWinder({
+          machine_identification_unique,
+          data: { SetConnectedWinder: machineIdentificationUnique },
+        }),
+    );
+  };
+
+  const disconnectWinder = (machineIdentificationUnique: {
+    machine_identification: {
+      vendor: number;
+      machine: number;
+    };
+    serial: number;
+  }) => {
+    updateStateOptimistically(
+      (current) => {
+        current.data.connected_winder_state.machine_identification_unique =
+          null;
+      },
+      () =>
+        requestDisconnectWinder({
+          machine_identification_unique,
+          data: { DisconnectWinder: machineIdentificationUnique },
+        }),
+    );
+  };
+
+  // General Helper functions
+  const machines = useMachines();
+  // Filter machines for the correct type
+  const filteredMachines = useMemo(
+    () =>
+      machines.filter(
+        (m) =>
+          m.machine_identification_unique.machine_identification.vendor ===
+            VENDOR_QITECH &&
+          m.machine_identification_unique.machine_identification.machine ===
+            0x0002,
+      ),
+    [machines, machineIdentification],
+  );
+
+  // Get selected machine by serial
+  const selectedMachine = useMemo(() => {
+    const serial =
+      state?.data.connected_winder_state?.machine_identification_unique?.serial;
+
+    return (
+      filteredMachines.find(
+        (m) => m.machine_identification_unique.serial === serial,
+      ) ?? null
+    );
+  }, [filteredMachines, state]);
+
   return {
     // Consolidated state
     state: stateOptimistic.value?.data,
 
+    filteredMachines,
+    selectedMachine,
+
     // Default state for initial values
     defaultState: defaultState?.data,
 
@@ -122,6 +207,8 @@ function useLaser(machine_identification_unique: MachineIdentificationUnique) {
     setTargetDiameter,
     setLowerTolerance,
     setHigherTolerance,
+    setConnectedWinder,
+    disconnectWinder,
   };
 }
 

electron/src/machines/winder/winder2/Winder2ControlPage.tsx

@@ -13,7 +13,11 @@ import { Label } from "@/control/Label";
 import { TouchButton } from "@/components/touch/TouchButton";
 import { StatusBadge } from "@/control/StatusBadge";
 import { useWinder2 } from "./useWinder";
-import { Mode, SpoolAutomaticActionMode } from "./winder2Namespace";
+import {
+  Mode,
+  SpoolAutomaticActionMode,
+  getGearRatioMultiplier,
+} from "./winder2Namespace";
 import { TensionArm } from "../TensionArm";
 import { roundDegreesToDecimals, roundToDecimals } from "@/lib/decimal";
 import { Spool } from "../Spool";
@@ -24,9 +28,11 @@ import {
   DialogHeader,
   DialogTitle,
 } from "@/components/ui/dialog";
+import { getWinder2TraverseMax } from "./winder2Config";
 
 export function Winder2ControlPage() {
   const [showResetConfirmDialog, setShowResetConfirmDialog] = useState(false);
+  const traverseMax = getWinder2TraverseMax();
 
   // use optimistic state
   const {
@@ -54,6 +60,13 @@ export function Winder2ControlPage() {
     isDisabled,
   } = useWinder2();
 
+  // Calculate max speed based on gear ratio
+  const gearRatioMultiplier = getGearRatioMultiplier(
+    state?.puller_state?.gear_ratio,
+  );
+  const maxMotorSpeed = 75; // Maximum motor speed in m/min
+  const maxTargetSpeed = maxMotorSpeed / gearRatioMultiplier;
+
   const handleResetProgress = () => {
     // Check if the machine is currently in Wind mode
     if (state?.mode_state?.mode === "Wind") {
@@ -91,7 +104,7 @@ export function Winder2ControlPage() {
           {state?.traverse_state && (
             <TraverseBar
               inside={0}
-              outside={180}
+              outside={traverseMax}
               min={state?.traverse_state.limit_inner}
               max={state?.traverse_state.limit_outer}
               current={traversePosition.current?.value ?? 0}
@@ -110,7 +123,7 @@ export function Winder2ControlPage() {
                 min={Math.max(0, (state?.traverse_state?.limit_inner ?? 0) + 1)}
                 minLabel="IN"
                 maxLabel="OUT"
-                max={180}
+                max={traverseMax}
                 renderValue={(value) => roundToDecimals(value, 0)}
                 onChange={setTraverseLimitOuter}
               />
@@ -134,8 +147,8 @@ export function Winder2ControlPage() {
                 // We use 1mm buffer to ensure the backend validation (which requires outer > inner + 0.9mm) will pass
                 // Formula: max_inner = outer_limit - 1mm
                 max={Math.min(
-                  180,
-                  (state?.traverse_state?.limit_outer ?? 180) - 1,
+                  traverseMax,
+                  (state?.traverse_state?.limit_outer ?? traverseMax) - 1,
                 )}
                 defaultValue={defaultState?.traverse_state?.limit_inner}
                 minLabel="IN"
@@ -259,13 +272,18 @@ export function Winder2ControlPage() {
                 Diameter: {
                   children: "Diameter",
                   icon: "lu:Sun",
-                  disabled: true,
+                  disabled: !state?.connected_laser_state.is_available,
                 },
               }}
               onChange={setPullerRegulationMode}
               disabled={isDisabled}
               loading={isLoading}
             />
+            {state?.connected_laser_state?.is_available !== true ? (
+              <StatusBadge variant={"info"}>
+                {"No associated Laser found"}
+              </StatusBadge>
+            ) : null}
           </Label>
           <Label label="Target Speed">
             <EditValue
@@ -274,7 +292,7 @@ export function Winder2ControlPage() {
               title="Target Speed"
               defaultValue={defaultState?.puller_state?.target_speed}
               min={0}
-              max={75}
+              max={maxTargetSpeed}
               step={0.1}
               renderValue={(value) => roundToDecimals(value, 1)}
               onChange={setPullerTargetSpeed}

electron/src/machines/winder/winder2/Winder2PresetsPage.tsx

@@ -67,6 +67,16 @@ const previewEntries: PresetPreviewEntries<Winder2> = [
     renderValue: (data: PresetData<Winder2>) =>
       data.puller_state?.forward ? "Forward" : "Backward",
   },
+  {
+    name: "Puller Gear Ratio",
+    renderValue: (data: PresetData<Winder2>) => {
+      const ratio = data.puller_state?.gear_ratio;
+      if (ratio === "OneToOne") return "1:1";
+      if (ratio === "OneToFive") return "1:5";
+      if (ratio === "OneToTen") return "1:10";
+      return "N/A";
+    },
+  },
   {
     name: "Puller Target Speed",
     unit: "m/min",
@@ -91,6 +101,11 @@ const previewEntries: PresetPreviewEntries<Winder2> = [
     renderValue: (data: PresetData<Winder2>) =>
       data.spool_speed_controller_state?.regulation_mode,
   },
+  {
+    name: "Spool Direction",
+    renderValue: (data: PresetData<Winder2>) =>
+      data.spool_speed_controller_state?.forward ? "Forward" : "Reverse",
+  },
   {
     name: "Spool Min Speed",
     unit: "rpm",
@@ -153,8 +168,10 @@ export function Winder2PresetsPage() {
     setPullerTargetDiameter,
     setPullerForward,
     setPullerTargetSpeed,
+    setPullerGearRatio,
 
     setSpoolRegulationMode,
+    setSpoolForward,
 
     setSpoolMinMaxMinSpeed,
     setSpoolMinMaxMaxSpeed,
@@ -177,11 +194,13 @@ export function Winder2PresetsPage() {
     setPullerRegulationMode(preset.data?.puller_state?.regulation ?? "Speed");
     setPullerForward(preset.data?.puller_state?.forward ?? true);
     setPullerTargetSpeed(preset.data?.puller_state?.target_speed ?? 1.0);
+    setPullerGearRatio(preset.data?.puller_state?.gear_ratio ?? "OneToOne");
     // setPullerTargetDiameter(preset.data?.puller_state?.target_diameter ?? 1.75);
 
     setSpoolRegulationMode(
       preset.data?.spool_speed_controller_state?.regulation_mode ?? "MinMax",
     );
+    setSpoolForward(preset.data?.spool_speed_controller_state?.forward ?? true);
     setSpoolMinMaxMinSpeed(
       preset.data?.spool_speed_controller_state?.minmax_min_speed ?? 0,
     );

electron/src/machines/winder/winder2/Winder2Settings.tsx

@@ -2,24 +2,37 @@ import { Page } from "@/components/Page";
 import { ControlCard } from "@/control/ControlCard";
 import { ControlGrid } from "@/control/ControlGrid";
 import { EditValue } from "@/control/EditValue";
-import React from "react";
+import React, { useState } from "react";
 import { useWinder2 } from "./useWinder";
 import { roundToDecimals } from "@/lib/decimal";
 import { Label } from "@/control/Label";
 import { SelectionGroupBoolean } from "@/control/SelectionGroup";
 import { SelectionGroup } from "@/control/SelectionGroup";
 import { MachineSelector } from "@/components/MachineConnectionDropdown";
+import {
+  getWinder2XLMode,
+  setWinder2XLMode,
+  WINDER2_TRAVERSE_MAX_STANDARD,
+  WINDER2_TRAVERSE_MAX_XL,
+} from "./winder2Config";
 
 export function Winder2SettingPage() {
+  const [xlMode, setXlMode] = useState(getWinder2XLMode());
+
   const {
     state,
     defaultState,
     setTraverseStepSize,
     setTraversePadding,
+    setTraverseLimitInner,
+    setTraverseLimitOuter,
+    gotoTraverseHome,
     setPullerForward,
+    setPullerGearRatio,
     setSpoolRegulationMode,
     setSpoolMinMaxMinSpeed,
     setSpoolMinMaxMaxSpeed,
+    setSpoolForward,
     setSpoolAdaptiveTensionTarget,
     setSpoolAdaptiveRadiusLearningRate,
     setSpoolAdaptiveMaxSpeedMultiplier,
@@ -27,16 +40,67 @@ export function Winder2SettingPage() {
     setSpoolAdaptiveDeaccelerationUrgencyMultiplier,
     isLoading,
     isDisabled,
+    setSpeedPiKp,
+    setSpeedPiKi,
     selectedMachine,
     filteredMachines,
+    setConnectedLaser,
+    disconnectLaser,
     setConnectedMachine,
-    disconnectMachine,
   } = useWinder2();
 
+  const handleXlModeChange = (enabled: boolean) => {
+    setWinder2XLMode(enabled);
+    setXlMode(enabled);
+
+    // When switching from XL to normal mode, reset traverse limits to default values
+    if (!enabled && defaultState) {
+      // Only reset if current values exceed the standard max
+      const currentOuter = state?.traverse_state?.limit_outer ?? 0;
+      const currentInner = state?.traverse_state?.limit_inner ?? 0;
+      const defaultOuter = defaultState.traverse_state?.limit_outer;
+      const defaultInner = defaultState.traverse_state?.limit_inner;
+
+      if (
+        currentOuter > WINDER2_TRAVERSE_MAX_STANDARD &&
+        defaultOuter !== undefined
+      ) {
+        setTraverseLimitOuter(defaultOuter);
+        setTraverseLimitInner(defaultInner);
+      }
+      if (
+        currentInner > WINDER2_TRAVERSE_MAX_STANDARD &&
+        defaultInner !== undefined
+      ) {
+        setTraverseLimitOuter(defaultOuter);
+        setTraverseLimitInner(defaultInner);
+      }
+
+      // Home the traverse when switching from XL to normal mode
+      gotoTraverseHome();
+    }
+  };
+
   return (
     <Page>
       <ControlGrid>
         <ControlCard title="Traverse">
+          <Label label="Traverse Size">
+            <SelectionGroupBoolean
+              value={xlMode}
+              disabled={isDisabled}
+              loading={isLoading}
+              optionFalse={{
+                children: `Standard (${WINDER2_TRAVERSE_MAX_STANDARD}mm)`,
+                icon: "lu:Settings",
+              }}
+              optionTrue={{
+                children: `XL (${WINDER2_TRAVERSE_MAX_XL}mm)`,
+                icon: "lu:Maximize2",
+              }}
+              onChange={handleXlModeChange}
+            />
+          </Label>
           <Label label="Step Size">
             <EditValue
               value={state?.traverse_state?.step_size}
@@ -87,6 +151,23 @@ export function Winder2SettingPage() {
             />
           </Label>
 
+          <Label label="Rotation Direction">
+            <SelectionGroupBoolean
+              value={state?.spool_speed_controller_state?.forward}
+              disabled={isDisabled}
+              loading={isLoading}
+              optionFalse={{
+                children: "Reverse",
+                icon: "lu:RotateCcw",
+              }}
+              optionTrue={{
+                children: "Forward",
+                icon: "lu:RotateCw",
+              }}
+              onChange={(value) => setSpoolForward(value)}
+            />
+          </Label>
+
           {state?.spool_speed_controller_state?.regulation_mode ===
             "MinMax" && (
             <>
@@ -249,21 +330,75 @@ export function Winder2SettingPage() {
               onChange={(value) => setPullerForward(value)}
             />
           </Label>
+          <Label label="Gear Ratio">
+            <SelectionGroup
+              value={state?.puller_state?.gear_ratio}
+              disabled={isDisabled}
+              loading={isLoading}
+              options={{
+                OneToOne: {
+                  children: "1:1",
+                  icon: "lu:Circle",
+                },
+                OneToFive: {
+                  children: "1:5",
+                  icon: "lu:Cog",
+                },
+                OneToTen: {
+                  children: "1:10",
+                  icon: "lu:Cog",
+                },
+              }}
+              onChange={(value) =>
+                setPullerGearRatio(
+                  value as "OneToOne" | "OneToFive" | "OneToTen",
+                )
+              }
+            />
+          </Label>
+        </ControlCard>
+        <ControlCard title="Diameter-Based Winder Control">
+          <Label label="Associated Laser">
+            <MachineSelector
+              machines={filteredMachines}
+              selectedMachine={selectedMachine}
+              connectedMachineState={state?.connected_laser_state}
+              setConnectedMachine={setConnectedLaser}
+              clearConnectedMachine={() => {
+                if (!selectedMachine) return;
+                setConnectedMachine({
+                  machine_identification: { vendor: 0, machine: 0 },
+                  serial: 0,
+                });
+                disconnectLaser(selectedMachine.machine_identification_unique);
+              }}
+            />
+          </Label>
+          <Label label="PI Controller Kp Factor">
+            <EditValue
+              value={state?.pi_settings?.kp}
+              defaultValue={defaultState?.pi_settings?.kp}
+              min={0}
+              max={1000}
+              step={0.001}
+              renderValue={(v) => roundToDecimals(v, 3)}
+              onChange={setSpeedPiKp}
+              title="Speed P KP"
+            />
+          </Label>
+          <Label label="PI Controller Ki Factor">
+            <EditValue
+              value={state?.pi_settings?.ki}
+              defaultValue={defaultState?.pi_settings?.ki}
+              min={0}
+              max={1000}
+              step={0.001}
+              renderValue={(v) => roundToDecimals(v, 3)}
+              onChange={setSpeedPiKi}
+              title="Speed P KI"
+            />
+          </Label>
         </ControlCard>
-        <MachineSelector
-          machines={filteredMachines}
-          selectedMachine={selectedMachine}
-          connectedMachineState={state?.connected_machine_state}
-          setConnectedMachine={setConnectedMachine}
-          clearConnectedMachine={() => {
-            if (!selectedMachine) return;
-            setConnectedMachine({
-              machine_identification: { vendor: 0, machine: 0 },
-              serial: 0,
-            });
-            disconnectMachine(selectedMachine.machine_identification_unique);
-          }}
-        />
       </ControlGrid>
     </Page>
   );

electron/src/machines/winder/winder2/useWinder.ts

@@ -19,6 +19,8 @@ import {
   PullerRegulation,
   SpoolAutomaticActionMode,
   spoolAutomaticActionModeSchema,
+  gearRatioSchema,
+  GearRatio,
 } from "./winder2Namespace";
 import { useEffect, useMemo } from "react";
 import { produce } from "immer";
@@ -120,6 +122,9 @@ export function useWinder2() {
   const { request: requestPullerSetForward } = useMachineMutation(
     z.object({ SetPullerForward: z.boolean() }),
   );
+  const { request: requestPullerSetGearRatio } = useMachineMutation(
+    z.object({ SetPullerGearRatio: gearRatioSchema }),
+  );
   const { request: requestSpoolSetRegulationMode } = useMachineMutation(
     z.object({ SetSpoolRegulationMode: spoolRegulationModeSchema }),
   );
@@ -129,6 +134,9 @@ export function useWinder2() {
   const { request: requestSpoolSetMinMaxMaxSpeed } = useMachineMutation(
     z.object({ SetSpoolMinMaxMaxSpeed: z.number() }),
   );
+  const { request: requestSpoolSetForward } = useMachineMutation(
+    z.object({ SetSpoolForward: z.boolean() }),
+  );
   const { request: requestSpoolSetAdaptiveTensionTarget } = useMachineMutation(
     z.object({ SetSpoolAdaptiveTensionTarget: z.number() }),
   );
@@ -171,6 +179,27 @@ export function useWinder2() {
     }),
   );
 
+  const { request: requestConnectedLaser } = useMachineMutation(
+    z.object({
+      SetConnectedLaser: machineIdentificationUnique,
+    }),
+  );
+
+  const { request: requestDisconnectLaser } = useMachineMutation(
+    z.object({
+      DisconnectLaser: machineIdentificationUnique,
+    }),
+  );
+
+  const { request: requestSpeedPiSettings } = useMachineMutation(
+    z.object({
+      SetSpeedPiSettings: z.object({
+        kp: z.number(),
+        ki: z.number(),
+      }),
+    }),
+  );
+
   // Helper function for optimistic updates using produce
   const updateStateOptimistically = (
     producer: (current: StateEvent) => void,
@@ -366,6 +395,28 @@ export function useWinder2() {
     );
   };
 
+  const setPullerGearRatio = (gearRatio: GearRatio) => {
+    updateStateOptimistically(
+      (current) => {
+        current.data.puller_state.gear_ratio = gearRatio;
+        // Reset target speed to 0 to prevent sudden speed changes
+        current.data.puller_state.target_speed = 0;
+      },
+      async () => {
+        // First set the target speed to 0
+        await requestPullerSetTargetSpeed({
+          machine_identification_unique: machineIdentification,
+          data: { SetPullerTargetSpeed: 0 },
+        });
+        // Then set the gear ratio
+        await requestPullerSetGearRatio({
+          machine_identification_unique: machineIdentification,
+          data: { SetPullerGearRatio: gearRatio },
+        });
+      },
+    );
+  };
+
   const setSpoolAutomaticRequiredMeters = (meters: number) => {
     updateStateOptimistically(
       (current) => {
@@ -440,6 +491,19 @@ export function useWinder2() {
     );
   };
 
+  const setSpoolForward = (forward: boolean) => {
+    updateStateOptimistically(
+      (current) => {
+        current.data.spool_speed_controller_state.forward = forward;
+      },
+      () =>
+        requestSpoolSetForward({
+          machine_identification_unique: machineIdentification,
+          data: { SetSpoolForward: forward },
+        }),
+    );
+  };
+
   const setSpoolAdaptiveTensionTarget = (value: number) => {
     updateStateOptimistically(
       (current) => {
@@ -550,6 +614,85 @@ export function useWinder2() {
     );
   };
 
+  const setSpeedPiKp = (kp: number) => {
+    updateStateOptimistically(
+      (current) => {
+        current.data.pi_settings.kp = kp;
+      },
+      () => {
+        const currentState = stateOptimistic.value;
+        if (currentState) {
+          const settings = produce(currentState.data.pi_settings, (draft) => {
+            draft.kp = kp;
+          });
+          requestSpeedPiSettings({
+            machine_identification_unique: machineIdentification,
+            data: { SetSpeedPiSettings: settings },
+          });
+        }
+      },
+    );
+  };
+
+  const setSpeedPiKi = (ki: number) => {
+    updateStateOptimistically(
+      (current) => {
+        current.data.pi_settings.ki = ki;
+      },
+      () => {
+        const currentState = stateOptimistic.value;
+        if (currentState) {
+          const settings = produce(currentState.data.pi_settings, (draft) => {
+            draft.ki = ki;
+          });
+          requestSpeedPiSettings({
+            machine_identification_unique: machineIdentification,
+            data: { SetSpeedPiSettings: settings },
+          });
+        }
+      },
+    );
+  };
+
+  const setConnectedLaser = (machineIdentificationUnique: {
+    machine_identification: {
+      vendor: number;
+      machine: number;
+    };
+    serial: number;
+  }) => {
+    updateStateOptimistically(
+      (current) => {
+        current.data.connected_laser_state.machine_identification_unique =
+          machineIdentificationUnique;
+      },
+      () =>
+        requestConnectedLaser({
+          machine_identification_unique,
+          data: { SetConnectedLaser: machineIdentificationUnique },
+        }),
+    );
+  };
+
+  const disconnectLaser = (machineIdentificationUnique: {
+    machine_identification: {
+      vendor: number;
+      machine: number;
+    };
+    serial: number;
+  }) => {
+    updateStateOptimistically(
+      (current) => {
+        current.data.connected_laser_state.machine_identification_unique = null;
+      },
+      () =>
+        requestDisconnectLaser({
+          machine_identification_unique,
+          data: { DisconnectLaser: machineIdentificationUnique },
+        }),
+    );
+  };
+
   // Calculate loading states
   const isLoading = stateOptimistic.isOptimistic;
   const isDisabled = !stateOptimistic.isInitialized;
@@ -564,7 +707,7 @@ export function useWinder2() {
           m.machine_identification_unique.machine_identification.vendor ===
             VENDOR_QITECH &&
           m.machine_identification_unique.machine_identification.machine ===
-            0x0008,
+            0x0006,
       ),
     [machines, machineIdentification],
   );
@@ -572,8 +715,7 @@ export function useWinder2() {
   // Get selected machine by serial
   const selectedMachine = useMemo(() => {
     const serial =
-      state?.data.connected_machine_state?.machine_identification_unique
-        ?.serial;
+      state?.data.connected_laser_state?.machine_identification_unique?.serial;
 
     return (
       filteredMachines.find(
@@ -619,17 +761,23 @@ export function useWinder2() {
     setPullerTargetDiameter,
     setPullerRegulationMode,
     setPullerForward,
+    setPullerGearRatio,
     setSpoolAutomaticRequiredMeters,
     setSpoolAutomaticAction,
     setSpoolRegulationMode,
     setSpoolMinMaxMinSpeed,
     setSpoolMinMaxMaxSpeed,
+    setSpoolForward,
     setSpoolAdaptiveTensionTarget,
     setSpoolAdaptiveRadiusLearningRate,
     setSpoolAdaptiveMaxSpeedMultiplier,
     setSpoolAdaptiveAccelerationFactor,
     setSpoolAdaptiveDeaccelerationUrgencyMultiplier,
+    setSpeedPiKp,
+    setSpeedPiKi,
     setConnectedMachine,
     disconnectMachine,
+    setConnectedLaser,
+    disconnectLaser,
   };
 }

electron/src/machines/winder/winder2/winder2Config.ts

@@ -0,0 +1,35 @@
+/**
+ * Configuration helper for Winder2 machine settings
+ */
+
+const WINDER2_XL_MODE_KEY = "winder2_xl_mode";
+
+export const WINDER2_TRAVERSE_MAX_STANDARD = 180; // mm
+export const WINDER2_TRAVERSE_MAX_XL = 385; // mm
+
+/**
+ * Get the XL mode setting from localStorage
+ * @returns true if XL mode is enabled, false otherwise
+ */
+export function getWinder2XLMode(): boolean {
+  const stored = localStorage.getItem(WINDER2_XL_MODE_KEY);
+  return stored === "true";
+}
+
+/**
+ * Set the XL mode setting in localStorage
+ * @param enabled - true to enable XL mode, false to disable
+ */
+export function setWinder2XLMode(enabled: boolean): void {
+  localStorage.setItem(WINDER2_XL_MODE_KEY, enabled.toString());
+}
+
+/**
+ * Get the maximum traverse limit based on XL mode
+ * @returns the maximum traverse limit in mm
+ */
+export function getWinder2TraverseMax(): number {
+  return getWinder2XLMode()
+    ? WINDER2_TRAVERSE_MAX_XL
+    : WINDER2_TRAVERSE_MAX_STANDARD;
+}

electron/src/machines/winder/winder2/winder2Namespace.ts

@@ -39,9 +39,36 @@ export const liveValuesEventDataSchema = z.object({
 /**
  * Puller regulation type enum
  */
-export const pullerRegulationSchema = z.enum(["Speed", "Diameter"]);
+export const pullerRegulationSchema = z.enum([
+  "Speed",
+  "Diameter",
+]);
 export type PullerRegulation = z.infer<typeof pullerRegulationSchema>;
 
+/**
+ * Gear ratio enum for winding speed
+ */
+export const gearRatioSchema = z.enum(["OneToOne", "OneToFive", "OneToTen"]);
+export type GearRatio = z.infer<typeof gearRatioSchema>;
+
+/**
+ * Get the multiplier for a gear ratio
+ */
+export function getGearRatioMultiplier(
+  gearRatio: GearRatio | undefined,
+): number {
+  switch (gearRatio) {
+    case "OneToOne":
+      return 1.0;
+    case "OneToFive":
+      return 5.0;
+    case "OneToTen":
+      return 10.0;
+    default:
+      return 1.0;
+  }
+}
+
 /**
  * Machine operation mode enum
  */
@@ -105,6 +132,7 @@ export const pullerStateSchema = z.object({
   target_speed: z.number(),
   target_diameter: z.number(),
   forward: z.boolean(),
+  gear_ratio: gearRatioSchema,
 });
 
 /**
@@ -116,7 +144,7 @@ export const modeStateSchema = z.object({
 });
 
 /**
- *  Connected machine state scheme
+ *  Connected machine state schema
  */
 export const machineIdentificationSchema = z.object({
   vendor: z.number(),
@@ -133,6 +161,14 @@ export const connectedMachineStateSchema = z.object({
   is_available: z.boolean(),
 });
 
+/**
+ * PI Controller settings schema
+ */
+export const piSettingsSchema = z.object({
+  kp: z.number(),
+  ki: z.number(),
+});
+
 /**
  * Tension arm state schema
  */
@@ -152,6 +188,7 @@ export const spoolSpeedControllerStateSchema = z.object({
   adaptive_max_speed_multiplier: z.number(),
   adaptive_acceleration_factor: z.number(),
   adaptive_deacceleration_urgency_multiplier: z.number(),
+  forward: z.boolean(),
 });
 
 /**
@@ -166,6 +203,8 @@ export const stateEventDataSchema = z.object({
   spool_speed_controller_state: spoolSpeedControllerStateSchema,
   spool_automatic_action_state: spoolAutomaticActionStateSchema,
   connected_machine_state: connectedMachineStateSchema,
+  connected_laser_state: connectedMachineStateSchema,
+  pi_settings: piSettingsSchema,
 });
 
 // ========== Event Schemas with Wrappers ==========

electron/src/routes/routes.tsx

@@ -41,6 +41,7 @@ import { Aquapath1GraphPage } from "@/machines/aquapath/aquapath1/Aquapath1Graph
 
 import { z } from "zod";
 import { Laser1PresetsPage } from "@/machines/laser/laser1/Laser1PresetsPage";
+import { Laser1SettingsPage } from "@/machines/laser/laser1/Laser1Settings";
 // make a route tree like this
 // _mainNavigation/machines/winder2/$serial/control
 // _mainNavigation/configuration/a
@@ -156,6 +157,12 @@ export const laser1PresetsRoute = createRoute({
   component: () => <Laser1PresetsPage />,
 });
 
+export const laser1SettingsRoute = createRoute({
+  getParentRoute: () => laser1SerialRoute,
+  path: "settings",
+  component: () => <Laser1SettingsPage />,
+});
+
 export const mock1SerialRoute = createRoute({
   getParentRoute: () => machinesRoute,
   path: "mock1/$serial",
@@ -312,6 +319,7 @@ export const rootTree = RootRoute.addChildren([
         laser1ControlRoute,
         laser1GraphsRoute,
         laser1PresetsRoute,
+        laser1SettingsRoute,
       ]),
 
       aquapath1SerialRoute.addChildren([

electron/src/setup/ChooseVersionPage.tsx

@@ -3,11 +3,7 @@ import { Page } from "@/components/Page";
 import { SectionTitle } from "@/components/SectionTitle";
 import { TouchButton } from "@/components/touch/TouchButton";
 import React, { useEffect, useState } from "react";
-import {
-  defaultGithubSource,
-  GithubSource,
-  GithubSourceDialog,
-} from "./GithubSourceDialog";
+import { GithubSourceDialog } from "./GithubSourceDialog";
 import { LoadingSpinner } from "@/components/LoadingSpinner";
 import { Alert } from "@/components/Alert";
 import { useNavigate } from "@tanstack/react-router";
@@ -21,6 +17,7 @@ import {
   isNixOSAvailable,
 } from "@/helpers/nixos_helpers";
 import { useUpdateStore } from "@/stores/updateStore";
+import { useGithubSourceStore } from "@/stores/githubSourceStore";
 
 export function ChooseVersionPage() {
   const navigate = useNavigate();
@@ -54,8 +51,7 @@ export function ChooseVersionPage() {
     string | null
   >(null);
 
-  const [githubSource, setGithubSource] =
-    useState<GithubSource>(defaultGithubSource);
+  const { githubSource, setGithubSource } = useGithubSourceStore();
 
   const githubApiUrl = `https://api.github.com/repos/${githubSource.githubRepoOwner}/${githubSource.githubRepoName}`;
 

electron/src/setup/GithubSourceDialog.tsx

@@ -114,11 +114,13 @@ export function GithubSourceDialogContent({
             name="githubRepoOwner"
             render={({ field }) => (
               <FormItem>
-                <FormLabel>Serial</FormLabel>
+                <FormLabel>GitHub Repository Owner</FormLabel>
                 <FormControl>
                   <Input placeholder="qitechgmbh" {...field} />
                 </FormControl>
-                <FormDescription>Serial number of the machine.</FormDescription>
+                <FormDescription>
+                  Name of the GitHub repository owner.
+                </FormDescription>
                 <FormMessage />
               </FormItem>
             )}

electron/src/stores/githubSourceStore.ts

@@ -0,0 +1,29 @@
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+import { GithubSource, defaultGithubSource } from "@/setup/GithubSourceDialog";
+
+export type GithubSourceState = {
+  githubSource: GithubSource;
+};
+
+export type GithubSourceActions = {
+  setGithubSource: (source: GithubSource) => void;
+  resetGithubSource: () => void;
+};
+
+export type GithubSourceStore = GithubSourceState & GithubSourceActions;
+
+export const useGithubSourceStore = create<GithubSourceStore>()(
+  persist(
+    (set) => ({
+      githubSource: defaultGithubSource,
+
+      setGithubSource: (source: GithubSource) => set({ githubSource: source }),
+
+      resetGithubSource: () => set({ githubSource: defaultGithubSource }),
+    }),
+    {
+      name: "github-source-storage",
+    },
+  ),
+);

electron/src/styles/global.css

@@ -177,3 +177,107 @@
     @apply bg-background text-foreground;
   }
 }
+
+/* macOS-style scrollbars */
+@layer base {
+  /* WebKit browsers (Safari, Chrome, newer Edge) */
+  ::-webkit-scrollbar {
+    width: 8px;
+    height: 16px;
+  }
+
+  ::-webkit-scrollbar-track {
+    background: transparent;
+  }
+
+  ::-webkit-scrollbar-thumb {
+    background: rgba(0, 0, 0, 0.2);
+    border-radius: 10px;
+    border: 2px solid transparent;
+    background-clip: content-box;
+    transition: background-color 0.2s ease;
+  }
+
+  ::-webkit-scrollbar-thumb:hover {
+    background: rgba(0, 0, 0, 0.4);
+    background-clip: content-box;
+  }
+
+  ::-webkit-scrollbar-thumb:active {
+    background: rgba(0, 0, 0, 0.6);
+    background-clip: content-box;
+  }
+
+  ::-webkit-scrollbar-corner {
+    background: transparent;
+  }
+
+  /* Dark mode adjustments */
+  .dark ::-webkit-scrollbar-thumb {
+    background: rgba(255, 255, 255, 0.2);
+    background-clip: content-box;
+  }
+
+  .dark ::-webkit-scrollbar-thumb:hover {
+    background: rgba(255, 255, 255, 0.4);
+    background-clip: content-box;
+  }
+
+  .dark ::-webkit-scrollbar-thumb:active {
+    background: rgba(255, 255, 255, 0.6);
+    background-clip: content-box;
+  }
+
+  /* Firefox */
+  html,
+  body {
+    scrollbar-width: thin;
+    scrollbar-color: rgba(0, 0, 0, 0.2) transparent;
+  }
+
+  .dark html,
+  .dark body {
+    scrollbar-color: rgba(255, 255, 255, 0.2) transparent;
+  }
+
+  /* Auto-hide behavior for overlay scrollbars */
+  @media (pointer: fine) {
+    ::-webkit-scrollbar {
+      width: 4px;
+      height: 4px;
+    }
+
+    ::-webkit-scrollbar:hover {
+      width: 8px;
+      height: 8px;
+    }
+
+    /* Container hover shows scrollbars */
+    .scrollbar-visible:hover::-webkit-scrollbar {
+      width: 8px;
+      height: 8px;
+    }
+  }
+
+  /* Utility classes for scrollbar customization */
+  .scrollbar-hidden {
+    -ms-overflow-style: none;
+    scrollbar-width: none;
+  }
+
+  .scrollbar-hidden::-webkit-scrollbar {
+    display: none;
+  }
+
+  .scrollbar-always-visible::-webkit-scrollbar {
+    width: 8px !important;
+    height: 8px !important;
+  }
+
+  @media (pointer: fine) {
+    .scrollbar-always-visible::-webkit-scrollbar {
+      width: 8px !important;
+      height: 8px !important;
+    }
+  }
+}

ethercat-hal/Cargo.toml

@@ -12,7 +12,7 @@ ethercrab = "0.6"
 ethercat_hal_derive = { version = "0.1.0", path = "../ethercat-hal-derive" }
 bitvec = { version = "1.0.1", features = ["alloc"] }
 smol = "2.0.2"
-uom = "0.36.0"
+uom = { version = "0.36.0", default-features = false, features = ["f64","si"] }
 rand = "0.9.2"
 futures = "0.3.31"
 tracing = "0.1.41"

flake.nix

@@ -64,6 +64,7 @@
             libpcap
             nodejs_22
             nodePackages.npm
+            lldb
           ];
 
           hardeningDisable = [ "fortify" ];

nixos/modules/qitech.nix

@@ -78,18 +78,20 @@ serviceConfig = {
   Restart = "always";
   RestartSec = "10s";
 
-  # Capabilities (unchanged, as you wanted)
-  CapabilityBoundingSet = "CAP_NET_RAW CAP_NET_ADMIN CAP_SYS_NICE CAP_DAC_OVERRIDE";
-  AmbientCapabilities     = "CAP_NET_RAW CAP_NET_ADMIN CAP_SYS_NICE CAP_DAC_OVERRIDE";
+  # Capabilities
+  CapabilityBoundingSet = "CAP_NET_RAW CAP_IPC_LOCK CAP_NET_ADMIN CAP_SYS_NICE CAP_DAC_OVERRIDE";
+  AmbientCapabilities     = "CAP_NET_RAW CAP_IPC_LOCK CAP_NET_ADMIN CAP_SYS_NICE CAP_DAC_OVERRIDE";
 
   # Hardening options
   NoNewPrivileges = true;
   ProtectSystem = "strict";
+
   # Open only /proc/irq explicitly
   ReadWritePaths = [ "/proc/irq" ];
   ProtectHome = true;
   PrivateTmp = true;
   PrivateDevices = false;
+
   # Must disable this to allow /proc/irq writes
   ProtectKernelTunables = false;
   ProtectControlGroups = true;

nixos/os/configuration.nix

@@ -15,12 +15,15 @@ in
     consoleMode = "max";  # Use the highest available resolution
   };
   boot.loader.efi.canTouchEfiVariables = true;
-  boot.kernelPackages = pkgs.linuxPackages-rt_latest;
+  boot.kernelPackages = pkgs.linuxPackages_6_13;
   boot.kernelModules = [ "i915" ];
 
 
 
   boot.kernelParams = [
+    # Realtime Preemption
+    "preempt=full"
+
     # Graphical
     "logo.nologo" # Remove kernel logo during boot
 

nixos/packages/electron.nix

@@ -102,11 +102,10 @@ installPhase = ''
       --name="QiTech Control" \
       --single-instance \
       --winrm-class="de.qitech.control-electron" \
-      --enable-gpu \ 
+      --enable-gpu \
       --ignore-gpu-blocklist \
       --enable-gpu-rasterization \
-      --disable-software-rasterizer \ 
-      --use-gl=desktop \
+      --disable-software-rasterizer \
       "\$@"
     EOF
     chmod +x $out/bin/qitech-control-electron

server/Cargo.toml

@@ -55,10 +55,6 @@ opentelemetry-otlp = { version = "0.30.0", features = [
 ], optional = true }
 tonic = { version = "0.13.1", 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"
 textplots = "0.8.7"
@@ -77,6 +73,7 @@ tracing-otel = [
     "dep:tonic",
 ]
 mock-machine = []
+memory-locking = []
 io-uring = []
 development-build = []
 

server/src/app_state.rs

@@ -6,7 +6,6 @@ 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::{MainDevice, SubDeviceGroup, subdevice_group::Op};
@@ -25,7 +24,7 @@ pub struct SocketioSetup {
 }
 
 pub struct SerialSetup {
-    pub serial_detection: SerialDetection<'static>,
+    pub serial_registry: &'static SERIAL_DEVICE_REGISTRY,
 }
 
 pub struct AppState {
@@ -85,7 +84,7 @@ impl AppState {
             },
             ethercat_setup: Arc::new(RwLock::new(None)),
             serial_setup: Arc::new(RwLock::new(SerialSetup {
-                serial_detection: SerialDetection::new(&SERIAL_DEVICE_REGISTRY),
+                serial_registry: &SERIAL_DEVICE_REGISTRY,
             })),
             machines: Arc::new(RwLock::new(MachineManager::new())),
             performance_metrics: Arc::new(RwLock::new(EthercatPerformanceMetrics::new())),

server/src/ethercat/ethercat_discovery_info.rs

@@ -0,0 +1,38 @@
+use std::sync::Arc;
+
+use control_core::socketio::namespace::NamespaceCacheingLogic;
+
+use crate::{
+    app_state::AppState,
+    socketio::main_namespace::{
+        MainNamespaceEvents, ethercat_interface_discovery_event::EthercatInterfaceDiscoveryEvent,
+    },
+};
+
+pub async fn send_ethercat_discovering(app_state: Arc<AppState>) {
+    {
+        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<AppState>, interface: &str) {
+    // Notify client via socketio
+    let interface = interface.to_string();
+    let app_state_socketio = app_state.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).build();
+        main_namespace.emit(MainNamespaceEvents::EthercatInterfaceDiscoveryEvent(event));
+    });
+}

server/src/ethercat/init.rs

@@ -1,82 +1,23 @@
-use super::setup::setup_loop;
-use crate::{
-    app_state::AppState,
-    panic::{PanicDetails, send_panic},
-    socketio::main_namespace::{
-        MainNamespaceEvents, ethercat_interface_discovery_event::EthercatInterfaceDiscoveryEvent,
-    },
-};
-use control_core::{
-    ethercat::interface_discovery::discover_ethercat_interface,
-    socketio::namespace::NamespaceCacheingLogic,
-};
-use smol::channel::Sender;
-use std::sync::Arc;
+use control_core::ethercat::interface_discovery::discover_ethercat_interface;
+use smol::{Task, Timer};
+use std::time::Duration;
 
-pub fn init_ethercat(
-    thread_panic_tx: Sender<PanicDetails>,
-    app_state: Arc<AppState>,
-) -> Result<(), anyhow::Error> {
-    let thread_panic_tx_clone = thread_panic_tx;
-    let app_state_clone = app_state;
-
-    std::thread::Builder::new()
-        .name("init_ethercat".to_string())
-        .spawn(move || {
-            send_panic(thread_panic_tx_clone.clone());
-
-            // 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(
-                thread_panic_tx_clone,
-                &interface,
-                app_state_clone,
-            )) {
-                tracing::error!("EtherCAT setup failed: {:?}", e);
+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;
+            }
+        }
+    }
+}
 
-    Ok(())
+// Returns a Future to the interface
+pub fn start_interface_discovery() -> Task<Result<String, anyhow::Error>> {
+    smol::spawn(find_ethercat_interface())
 }

server/src/ethercat/mod.rs

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

server/src/ethercat/setup.rs

@@ -1,6 +1,5 @@
 use crate::app_state::EthercatSetup;
 use crate::machines::registry::MACHINE_REGISTRY;
-use crate::panic::{PanicDetails, send_panic};
 use crate::socketio::main_namespace::MainNamespaceEvents;
 use crate::socketio::main_namespace::ethercat_devices_event::EthercatDevicesEventBuilder;
 use crate::socketio::main_namespace::machines_event::MachinesEventBuilder;
@@ -18,19 +17,14 @@ 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::std::{ethercat_now, tx_rx_task};
 use ethercrab::{MainDevice, MainDeviceConfig, PduStorage, RetryBehaviour, Timeouts};
-use smol::channel::Sender;
 use std::{sync::Arc, time::Duration};
 
 const SM_OUTPUT: u16 = 0x1C32;
 const SM_INPUT: u16 = 0x1C33;
 
-pub async fn setup_loop(
-    thread_panic_tx: Sender<PanicDetails>,
-    interface: &str,
-    app_state: Arc<AppState>,
-) -> Result<(), 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`
@@ -44,12 +38,10 @@ pub async fn setup_loop(
     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");
     let interface = interface.to_string();
-    let thread_panic_tx_clone = thread_panic_tx.clone();
+
     std::thread::Builder::new()
         .name("EthercatTxRxThread".to_owned())
         .spawn(move || {
-            send_panic(thread_panic_tx_clone);
-
             #[cfg(all(target_os = "linux", not(feature = "development-build")))]
             match set_irq_affinity(&interface, 3) {
                 Ok(_) => tracing::info!("ethernet interrupt handler now runs on cpu:{}", 3),
@@ -60,27 +52,14 @@ 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")))]
-            {
-                use ethercrab::std::tx_rx_task;
-                use futures::executor::block_on;
-
-                let rt = smol::LocalExecutor::new();
-                let _ = block_on(rt.run(async {
-                    tx_rx_task(&interface, tx, rx)
-                        .expect("spawn TX/RX task")
-                        .await
-                }));
-            }
-            #[cfg(all(target_os = "linux", feature = "io-uring"))]
-            {
-                use ethercrab::std::tx_rx_task_io_uring;
-
-                let _ = tx_rx_task_io_uring(&interface, tx, rx)
-                    .expect("Failed to spawn TX/RX task (io_uring)");
-            }
+            let rt = smol::LocalExecutor::new();
+            let _ = smol::block_on(rt.run(async {
+                tx_rx_task(&interface, tx, rx)
+                    .expect("spawn TX/RX task")
+                    .await
+            }));
         })
         .expect("Building thread");
 
@@ -93,13 +72,13 @@ pub async fn setup_loop(
             // Default 30_000us
             pdu: Duration::from_micros(30_000),
             // Default 10ms
-            eeprom: Duration::from_millis(100),
+            eeprom: Duration::from_millis(10),
             // Default 0ms
             wait_loop_delay: Duration::from_millis(0),
             // Default 100ms
-            mailbox_echo: Duration::from_millis(1000),
+            mailbox_echo: Duration::from_millis(100),
             // Default 1000ms
-            mailbox_response: Duration::from_millis(10000),
+            mailbox_response: Duration::from_millis(1000),
         },
         MainDeviceConfig {
             // Default RetryBehaviour::None

server/src/jemalloc_stats.rs

@@ -1,64 +0,0 @@
-use std::{thread::sleep, time::Duration};
-
-pub fn init_jemalloc_stats() {
-    std::thread::Builder::new()
-        .name("jemalloc-stats".to_string())
-        .spawn(|| {
-            let mut last_allocated = 0usize;
-            let mut last_time = std::time::Instant::now();
-
-            loop {
-                smol::block_on(async {
-                    sleep(Duration::from_secs(10));
-                    // Advance epoch and get allocated bytes
-                    let _ = tikv_jemalloc_ctl::epoch::advance();
-
-                    if let Ok(allocated_bytes) =
-                        unsafe { tikv_jemalloc_ctl::raw::read::<usize>(b"stats.allocated\0") }
-                    {
-                        let current_time = std::time::Instant::now();
-                        let time_diff = current_time.duration_since(last_time).as_secs_f64();
-
-                        let change = allocated_bytes as i64 - last_allocated as i64;
-                        let change_per_sec = if time_diff > 0.0 {
-                            (change as f64 / time_diff) as i64
-                        } else {
-                            0
-                        };
-
-                        let change_str = if change_per_sec >= 0 {
-                            format!("+{} KB/s", format_bytes(change_per_sec))
-                        } else {
-                            format!("-{} KB/s", format_bytes(-change_per_sec))
-                        };
-
-                        let formatted = format_bytes(allocated_bytes as i64);
-
-                        tracing::debug!("Memory: {} KB ({})", formatted, change_str);
-                        last_allocated = allocated_bytes;
-                        last_time = current_time;
-                    }
-                });
-            }
-        })
-        .expect("Failed to spawn jemalloc-stats thread");
-}
-
-fn format_bytes(bytes: i64) -> String {
-    let kb = bytes / 1024;
-    format!("{}", kb)
-        .chars()
-        .rev()
-        .enumerate()
-        .map(|(i, c)| {
-            if i > 0 && i % 3 == 0 {
-                format!("_{}", c)
-            } else {
-                c.to_string()
-            }
-        })
-        .collect::<String>()
-        .chars()
-        .rev()
-        .collect::<String>()
-}

server/src/loop.rs

@@ -1,61 +1,81 @@
-use crate::app_state::AppState;
-use crate::panic::{PanicDetails, send_panic};
+use crate::{app_state::AppState, ethercat::setup::setup_loop};
 use bitvec::prelude::*;
 use control_core::machines::connection::MachineConnection;
-use control_core::realtime::{set_core_affinity, set_realtime_priority};
-use smol::channel::Sender;
+use control_core::realtime::set_core_affinity;
+#[cfg(not(feature = "development-build"))]
+use control_core::realtime::set_realtime_priority;
 use std::sync::Arc;
-use std::time::{Duration, Instant};
+use std::time::Instant;
 use tracing::{instrument, trace_span};
 
-pub fn init_loop(
-    thread_panic_tx: Sender<PanicDetails>,
+pub fn start_loop_thread(
+    interface: &str,
     app_state: Arc<AppState>,
-) -> Result<(), anyhow::Error> {
+) -> Result<std::thread::JoinHandle<()>, std::io::Error> {
+    let res = smol::block_on(async { setup_loop(interface, app_state.clone()).await });
+    match res {
+        Ok(_) => tracing::info!("Successfully initialized EtherCAT network"),
+        Err(e) => {
+            tracing::error!(
+                "[{}::init_loop] Failed to initialize EtherCAT network \n{:?}",
+                module_path!(),
+                e
+            );
+        }
+    }
     // Start control loop
-    std::thread::Builder::new()
+    let res = std::thread::Builder::new()
         .name("loop".to_owned())
         .spawn(move || {
-            send_panic(thread_panic_tx.clone());
-            let rt = smol::LocalExecutor::new();
-
-            // Set core affinity to third core
             let _ = set_core_affinity(2);
-
-            // Set the thread to real-time priority
+            #[cfg(not(feature = "development-build"))]
             if let Err(e) = set_realtime_priority() {
                 tracing::error!(
-                    "[{}::init_loop] Failed to set real-time priority \n{:?}",
+                    "[{}::init_loop] Failed to set thread to real-time priority \n{:?}",
                     module_path!(),
                     e
                 );
             } else {
                 tracing::info!(
-                    "[{}::init_loop] Real-time priority set successfully",
+                    "[{}::init_loop] Real-time priority set successfully for current thread",
                     module_path!()
                 );
             }
 
-            loop {
-                let res = smol::block_on(rt.run(async { loop_once(app_state.clone()).await }));
+            let rt = smol::LocalExecutor::new();
+            // Instead of creating a NEW async task every iteration of our realtime txrx loop, create it ONCE
+            smol::block_on(async {
+                rt.run(async {
+                    loop {
+                        if let Err(e) = loop_once(app_state.clone()).await {
+                            tracing::error!("Loop failed\n{:?}", e);
+                            std::process::exit(1);
+                        }
+                    }
+                })
+                .await;
+            });
 
-                if let Err(err) = res {
-                    tracing::error!("Loop failed\n{:?}", err);
-                    break;
+            /*
+                // If timeouts keep happenning do a spin_sleep, better then thread_sleep and allows for more deterministic timing
+                let elapsed = start.elapsed();
+                if elapsed < target_cycle {
+                    spin_sleep::sleep(target_cycle - elapsed);
                 }
-            }
-            // Exit the entire program if the Loop fails (gets restarted by systemd if running on NixOS)
-            std::process::exit(1);
-        })
-        .map_err(|e| {
-            anyhow::anyhow!(
-                "[{}::init_loop] Failed to spawn loop thread\n{:?}",
-                module_path!(),
-                e
-            )
-        })?;
+            */
 
-    Ok(())
+            if let Some(last_loop_start) = app_state
+                .performance_metrics
+                .read_arc_blocking()
+                .last_loop_start
+            {
+                tracing::info!("Failing Loop Took {:?}", last_loop_start.elapsed());
+            }
+            // Exit the entire program if the Loop fails
+            // gets restarted by systemd if running on NixOS, or different distro wtih the same sysd service
+            std::process::exit(1);
+        });
+    return res;
 }
 
 #[instrument(skip(app_state))]
@@ -128,12 +148,6 @@ pub async fn loop_once<'maindevice>(app_state: Arc<AppState>) -> Result<(), anyh
                 )
             })?;
         }
-
-        #[cfg(feature = "development-build")]
-        smol::Timer::after(Duration::from_micros(2000)).await;
-
-        #[cfg(not(feature = "development-build"))]
-        smol::Timer::after(Duration::from_micros(500)).await;
     }
 
     // execute machines

server/src/machines/aquapath1/new.rs

@@ -1,20 +1,16 @@
 use super::{AquaPathV1, AquaPathV1Mode};
-use crate::machines::aquapath1::{
-    Flow, Temperature, api::AquaPathV1Namespace, controller::Controller,
+use crate::machines::{
+    aquapath1::{Flow, Temperature, api::AquaPathV1Namespace, controller::Controller},
+    get_ethercat_device,
 };
 use anyhow::Error;
-use control_core::machines::{
-    identification::DeviceHardwareIdentification,
-    new::{
-        MachineNewHardware, MachineNewParams, MachineNewTrait, get_device_identification_by_role,
-        get_ethercat_device_by_index, get_subdevice_by_index, validate_no_role_dublicates,
-        validate_same_machine_identification_unique,
-    },
+use control_core::machines::new::{
+    MachineNewHardware, MachineNewParams, MachineNewTrait, get_subdevice_by_index,
+    validate_no_role_dublicates, validate_same_machine_identification_unique,
 };
 use ethercat_hal::{
     coe::ConfigurableDevice,
     devices::{
-        EthercatDeviceUsed, downcast_device,
         ek1100::{EK1100, EK1100_IDENTITY_A},
         el2008::{EL2008, EL2008_IDENTITY_A, EL2008Port},
         el3204::{EL3204, EL3204_IDENTITY_A, EL3204_IDENTITY_B, EL3204Port},
@@ -23,7 +19,6 @@ use ethercat_hal::{
             EL5152, EL5152_IDENTITY_A, EL5152Configuration, EL5152Port,
             EL5152PredefinedPdoAssignment,
         },
-        subdevice_identity_to_tuple,
     },
     io::{
         analog_output::AnalogOutput, digital_output::DigitalOutput, encoder_input::EncoderInput,
@@ -56,217 +51,46 @@ impl MachineNewTrait for AquaPathV1 {
 
         smol::block_on(async {
             // Role 0 - Buscoupler EK1100
-            {
-                let device_identification =
-                    get_device_identification_by_role(params.device_group, 0)?;
-                let device_hardware_identification_ethercat = match &device_identification
-                    .device_hardware_identification
-                {
-                    DeviceHardwareIdentification::Ethercat(
-                        device_hardware_identification_ethercat,
-                    ) => device_hardware_identification_ethercat,
-                    _ => Err(anyhow::anyhow!(
-                        "[{}::MachineNewTrait/AquaPath1::new] Device with role 0 is not Ethercat",
-                        module_path!()
-                    ))?,
-                };
-                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 device = match subdevice_identity_to_tuple(&subdevice_identity) {
-                    EK1100_IDENTITY_A => {
-                        let ethercat_device = get_ethercat_device_by_index(
-                            &hardware.ethercat_devices,
-                            subdevice_index,
-                        )?;
-                        downcast_device::<EK1100>(ethercat_device).await?
-                    }
-                    _ => {
-                        return Err(anyhow::anyhow!(
-                            "[{}::MachineNewTrait/AquaPath1::new] Device with role 0 is not an EK1100",
-                            module_path!()
-                        ));
-                    }
-                };
-                {
-                    let mut device_guard = device.write().await;
-                    device_guard.set_used(true);
-                }
-            }
+            let _ek1100 =
+                get_ethercat_device::<EK1100>(hardware, params, 0, [EK1100_IDENTITY_A].to_vec());
 
             // Role 1 - EL2008 Digital Output Module
-            let el2008 = {
-                let device_identification =
-                    get_device_identification_by_role(params.device_group, 1)?;
-                let device_hardware_identification_ethercat = match &device_identification
-                    .device_hardware_identification
-                {
-                    DeviceHardwareIdentification::Ethercat(
-                        device_hardware_identification_ethercat,
-                    ) => device_hardware_identification_ethercat,
-                    _ => Err(anyhow::anyhow!(
-                        "[{}::MachineNewTrait/AquaPath1::new] Device with role 1 is not Ethercat",
-                        module_path!()
-                    ))?,
-                };
-                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 device = match subdevice_identity_to_tuple(&subdevice_identity) {
-                    EL2008_IDENTITY_A => {
-                        let ethercat_device = get_ethercat_device_by_index(
-                            &hardware.ethercat_devices,
-                            subdevice_index,
-                        )?;
-                        downcast_device::<EL2008>(ethercat_device).await?
-                    }
-                    _ => {
-                        return Err(anyhow::anyhow!(
-                            "[{}::MachineNewTrait/AquaPath1::new] Device with role 1 is not an EL2008",
-                            module_path!()
-                        ));
-                    }
-                };
-                {
-                    let mut device_guard = device.write().await;
-                    device_guard.set_used(true);
-                }
-                device
-            };
+            let el2008 =
+                get_ethercat_device::<EL2008>(hardware, params, 1, [EL2008_IDENTITY_A].to_vec())
+                    .await?
+                    .0;
 
             // Role 2 - EL4002 Analog Output Module
-            let el4002 = {
-                let device_identification =
-                    get_device_identification_by_role(params.device_group, 2)?;
-                let device_hardware_identification_ethercat = match &device_identification
-                    .device_hardware_identification
-                {
-                    DeviceHardwareIdentification::Ethercat(
-                        device_hardware_identification_ethercat,
-                    ) => device_hardware_identification_ethercat,
-                    _ => Err(anyhow::anyhow!(
-                        "[{}::MachineNewTrait/AquaPath1::new] Device with role 2 is not Ethercat",
-                        module_path!()
-                    ))?,
-                };
+            let el4002 =
+                get_ethercat_device::<EL4002>(hardware, params, 2, [EL4002_IDENTITY_A].to_vec())
+                    .await?
+                    .0;
 
-                let subdevice = get_subdevice_by_index(
-                    hardware.subdevices,
-                    device_hardware_identification_ethercat.subdevice_index,
-                )?;
-                let subdevice_index = device_hardware_identification_ethercat.subdevice_index;
-                let subdevice_identity = subdevice.identity();
+            let el3204 = get_ethercat_device::<EL3204>(
+                hardware,
+                params,
+                3,
+                [EL3204_IDENTITY_A, EL3204_IDENTITY_B].to_vec(),
+            )
+            .await?
+            .0;
 
-                let device = match subdevice_identity_to_tuple(&subdevice_identity) {
-                    EL4002_IDENTITY_A => {
-                        let ethercat_device = get_ethercat_device_by_index(
-                            &hardware.ethercat_devices,
-                            subdevice_index,
-                        )?;
-                        downcast_device::<EL4002>(ethercat_device).await?
-                    }
-                    _ => Err(anyhow::anyhow!(
-                        "[{}::MachineNewTrait/AquaPath1::new] Device with role 2 is not an EL4002",
-                        module_path!()
-                    ))?,
-                };
+            let el5152 =
+                get_ethercat_device::<EL5152>(hardware, params, 4, [EL5152_IDENTITY_A].to_vec())
+                    .await?
+                    .0;
 
-                {
-                    let mut device_guard = device.write().await;
-                    device_guard.set_used(true);
-                }
-                device
-            };
-            let el3204 = {
-                let device_identification =
-                    get_device_identification_by_role(params.device_group, 3)?;
-                let device_hardware_identification_ethercat = match &device_identification
-                    .device_hardware_identification
-                {
-                    DeviceHardwareIdentification::Ethercat(
-                        device_hardware_identification_ethercat,
-                    ) => device_hardware_identification_ethercat,
-                    _ => Err(anyhow::anyhow!(
-                        "[{}::MachineNewTrait/AquaPath1::new] Device with role 3 is not Ethercat",
-                        module_path!()
-                    ))?, //uncommented
-                };
-                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 device = match subdevice_identity_to_tuple(&subdevice_identity) {
-                    EL3204_IDENTITY_A | EL3204_IDENTITY_B => {
-                        let ethercat_device = get_ethercat_device_by_index(
-                            &hardware.ethercat_devices,
-                            subdevice_index,
-                        )?;
-                        downcast_device::<EL3204>(ethercat_device).await?
-                    }
-                    _ => {
-                        return Err(anyhow::anyhow!(
-                            "[{}::MachineNewTrait/AquaPath1::new] Device with role 3 is not an EL3204",
-                            module_path!()
-                        ));
-                    }
-                };
-                {
-                    let mut device_guard = device.write().await;
-                    device_guard.set_used(true);
-                }
-                device
+            let config = EL5152Configuration {
+                pdo_assignment: EL5152PredefinedPdoAssignment::Frequency,
+                ..Default::default()
             };
+            let subdevice = get_subdevice_by_index(hardware.subdevices, 4)?;
+            el5152
+                .write()
+                .await
+                .write_config(&subdevice, &config)
+                .await?;
 
-            let el5152 = {
-                let device_identification =
-                    get_device_identification_by_role(params.device_group, 4)?;
-                let device_hardware_identification_ethercat = match &device_identification
-                    .device_hardware_identification
-                {
-                    DeviceHardwareIdentification::Ethercat(
-                        device_hardware_identification_ethercat,
-                    ) => device_hardware_identification_ethercat,
-                    _ => Err(anyhow::anyhow!(
-                        "[{}::MachineNewTrait/AquaPath1::new] Device with role 4 is not Ethercat",
-                        module_path!()
-                    ))?,
-                };
-
-                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 device = match subdevice_identity_to_tuple(&subdevice_identity) {
-                    EL5152_IDENTITY_A => {
-                        let ethercat_device = get_ethercat_device_by_index(
-                            &hardware.ethercat_devices,
-                            subdevice_index,
-                        )?;
-                        downcast_device::<EL5152>(ethercat_device).await?
-                    }
-                    _ => {
-                        return Err(anyhow::anyhow!(
-                            "[{}::MachineNewTrait/AquaPath1::new] Device with role 4 is not an EL5152",
-                            module_path!()
-                        ));
-                    }
-                };
-
-                let config = EL5152Configuration {
-                    pdo_assignment: EL5152PredefinedPdoAssignment::Frequency,
-                    ..Default::default()
-                };
-                device
-                    .write()
-                    .await
-                    .write_config(&subdevice, &config)
-                    .await?;
-
-                {
-                    let mut device_guard = device.write().await;
-                    device_guard.set_used(true);
-                }
-                device
-            };
             let enc1 = EncoderInput::new(el5152.clone(), EL5152Port::ENC1);
 
             let enc2 = EncoderInput::new(el5152.clone(), EL5152Port::ENC2);

server/src/machines/buffer1/mod.rs

@@ -3,6 +3,8 @@ pub mod api;
 pub mod buffer_tower_controller;
 pub mod new;
 
+#[cfg(not(feature = "mock-machine"))]
+use crate::machines::{MACHINE_BUFFER_V1, VENDOR_QITECH, winder2::Winder2};
 use api::{Buffer1Namespace, BufferV1Events, LiveValuesEvent, ModeState, StateEvent};
 use buffer_tower_controller::BufferTowerController;
 use control_core::machines::connection::{CrossConnectableMachine, MachineCrossConnection};
@@ -18,8 +20,6 @@ use serde::{Deserialize, Serialize};
 use smol::lock::RwLock;
 use std::{sync::Weak, time::Instant};
 
-use crate::machines::{MACHINE_BUFFER_V1, VENDOR_QITECH, winder2::Winder2};
-
 #[derive(Debug, Machine)]
 pub struct BufferV1 {
     // controllers

server/src/machines/extruder1/api.rs

@@ -183,9 +183,24 @@ pub struct PidSettings {
     pub kd: f64,
 }
 
+#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
+pub struct TemperaturePidStates {
+    pub front: TemperaturePid,
+    pub middle: TemperaturePid,
+    pub back: TemperaturePid,
+}
+
+#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
+pub struct TemperaturePid {
+    pub ki: f64,
+    pub kp: f64,
+    pub kd: f64,
+    pub zone: String,
+}
+
 #[derive(Serialize, Debug, Clone, PartialEq)]
 pub struct PidSettingsStates {
-    pub temperature: PidSettings,
+    pub temperature: TemperaturePidStates,
     pub pressure: PidSettings,
 }
 
@@ -217,6 +232,7 @@ pub enum Mutation {
 
     // Pid Configure
     SetPressurePidSettings(PidSettings),
+    SetTemperaturePidSettings(TemperaturePid),
 
     // Reset
     ResetInverter(bool),
@@ -292,6 +308,10 @@ impl MachineApi for ExtruderV2 {
             Mutation::SetPressurePidSettings(settings) => {
                 self.configure_pressure_pid(settings);
             }
+
+            Mutation::SetTemperaturePidSettings(settings) => {
+                self.configure_temperature_pid(settings);
+            }
         }
         Ok(())
     }

server/src/machines/extruder1/emit.rs

@@ -5,7 +5,7 @@ use crate::machines::extruder1::{
     api::{
         ExtruderSettingsState, ExtruderV2Events, HeatingState, HeatingStates, InverterStatusState,
         LiveValuesEvent, ModeState, PidSettings, PidSettingsStates, PressureState, RegulationState,
-        RotationState, ScrewState, StateEvent,
+        RotationState, ScrewState, StateEvent, TemperaturePid,
     },
 };
 #[cfg(not(feature = "mock-machine"))]
@@ -27,6 +27,8 @@ use uom::si::thermodynamic_temperature::ThermodynamicTemperature;
 #[cfg(not(feature = "mock-machine"))]
 impl ExtruderV2 {
     pub fn build_state_event(&mut self) -> StateEvent {
+        use crate::machines::extruder1::api::{TemperaturePid, TemperaturePidStates};
+
         StateEvent {
             is_default_state: !std::mem::replace(&mut self.emitted_default_state, true),
             rotation_state: RotationState {
@@ -106,10 +108,25 @@ impl ExtruderV2 {
                 fault_occurence: self.screw_speed_controller.inverter.status.fault_occurence,
             },
             pid_settings: PidSettingsStates {
-                temperature: PidSettings {
-                    ki: 0.0,
-                    kp: 0.0,
-                    kd: 0.0,
+                temperature: TemperaturePidStates {
+                    front: TemperaturePid {
+                        ki: self.temperature_controller_front.pid.get_ki(),
+                        kp: self.temperature_controller_front.pid.get_kp(),
+                        kd: self.temperature_controller_front.pid.get_kd(),
+                        zone: String::from("front"),
+                    },
+                    middle: TemperaturePid {
+                        ki: self.temperature_controller_middle.pid.get_ki(),
+                        kp: self.temperature_controller_middle.pid.get_kp(),
+                        kd: self.temperature_controller_middle.pid.get_kd(),
+                        zone: String::from("middle"),
+                    },
+                    back: TemperaturePid {
+                        ki: self.temperature_controller_back.pid.get_ki(),
+                        kp: self.temperature_controller_back.pid.get_kp(),
+                        kd: self.temperature_controller_back.pid.get_kd(),
+                        zone: String::from("back"),
+                    },
                 },
                 pressure: PidSettings {
                     ki: self.screw_speed_controller.pid.get_ki(),
@@ -279,4 +296,32 @@ impl ExtruderV2 {
             .configure(settings.ki, settings.kp, settings.kd);
         self.emit_state();
     }
+
+    pub fn configure_temperature_pid(&mut self, settings: TemperaturePid) {
+        match settings.zone.as_str() {
+            "front" => {
+                self.temperature_controller_front.pid.configure(
+                    settings.ki,
+                    settings.kp,
+                    settings.kd,
+                );
+            }
+            "middle" => {
+                self.temperature_controller_middle.pid.configure(
+                    settings.ki,
+                    settings.kp,
+                    settings.kd,
+                );
+            }
+            "back" => {
+                self.temperature_controller_back.pid.configure(
+                    settings.ki,
+                    settings.kp,
+                    settings.kd,
+                );
+            }
+            _ => tracing::warn!("Unknown zone: {}", settings.zone),
+        }
+        self.emit_state();
+    }
 }

server/src/machines/extruder1/mock/api.rs

@@ -37,6 +37,10 @@ impl MachineApi for ExtruderV2 {
             Mutation::SetPressurePidSettings(settings) => {
                 self.configure_pressure_pid(settings);
             }
+
+            Mutation::SetTemperaturePidSettings(settings) => {
+                self.configure_temperature_pid(settings);
+            }
         }
         Ok(())
     }

server/src/machines/extruder1/mock/mock_emit.rs

@@ -1,6 +1,6 @@
 use crate::machines::extruder1::{
     ExtruderV2Mode, HeatingType,
-    api::{ExtruderV2Events, LiveValuesEvent, ModeState, PidSettings, StateEvent},
+    api::{ExtruderV2Events, LiveValuesEvent, ModeState, PidSettings, StateEvent, TemperaturePid},
     mock::ExtruderV2,
 };
 use control_core::{
@@ -133,4 +133,26 @@ impl ExtruderV2 {
         self.pid_settings.pressure.kd = settings.kd;
         self.emit_state();
     }
+
+    pub fn configure_temperature_pid(&mut self, settings: TemperaturePid) {
+        match settings.zone.as_str() {
+            "front" => {
+                self.pid_settings.temperature.front.ki = settings.ki;
+                self.pid_settings.temperature.front.kp = settings.kp;
+                self.pid_settings.temperature.front.kd = settings.kd;
+            }
+            "middle" => {
+                self.pid_settings.temperature.middle.ki = settings.ki;
+                self.pid_settings.temperature.middle.kp = settings.kp;
+                self.pid_settings.temperature.middle.kd = settings.kd;
+            }
+            "back" => {
+                self.pid_settings.temperature.back.ki = settings.ki;
+                self.pid_settings.temperature.back.kp = settings.kp;
+                self.pid_settings.temperature.back.kd = settings.kd;
+            }
+            _ => tracing::warn!("Unknown zone: {}", settings.zone),
+        }
+        self.emit_state();
+    }
 }

server/src/machines/extruder1/mock/new.rs

@@ -3,7 +3,8 @@ use crate::machines::extruder1::{
     api::{
         ExtruderSettingsState, ExtruderV2Namespace, HeatingState, HeatingStates,
         InverterStatusState, ModeState, MotorStatusValues, PidSettings, PidSettingsStates,
-        PressureState, RegulationState, RotationState, ScrewState,
+        PressureState, RegulationState, RotationState, ScrewState, TemperaturePid,
+        TemperaturePidStates,
     },
     mock::ExtruderV2,
 };
@@ -88,10 +89,25 @@ impl control_core::machines::new::MachineNewTrait for ExtruderV2 {
                 fault_occurence: false,
             },
             pid_settings: PidSettingsStates {
-                temperature: PidSettings {
-                    ki: 0.0,
-                    kp: 0.0,
-                    kd: 0.0,
+                temperature: TemperaturePidStates {
+                    front: TemperaturePid {
+                        ki: 0.0,
+                        kp: 0.0,
+                        kd: 0.0,
+                        zone: String::from("front"),
+                    },
+                    middle: TemperaturePid {
+                        ki: 0.0,
+                        kp: 0.0,
+                        kd: 0.0,
+                        zone: String::from("middle"),
+                    },
+                    back: TemperaturePid {
+                        ki: 0.0,
+                        kp: 0.0,
+                        kd: 0.0,
+                        zone: String::from("back"),
+                    },
                 },
                 pressure: PidSettings {
                     ki: 0.0,

server/src/machines/extruder1/new.rs

@@ -86,9 +86,7 @@ impl MachineNewTrait for ExtruderV2 {
         // if its async the compiler thinks &subdevices is persisted in the future which might never execute
         // so we can't drop subdevices unless this machine is dropped, which is bad
         smol::block_on(async {
-            // Role 0
-            // Buscoupler
-            // EK1100
+            // Role 0 - Buscoupler EK1100
             let _ek1100 =
                 get_ethercat_device::<EK1100>(hardware, params, 0, [EK1100_IDENTITY_A].to_vec());
 

server/src/machines/laser/act.rs

@@ -19,8 +19,10 @@ use std::time::{Duration, Instant};
 ///
 impl MachineAct for LaserMachine {
     fn act(&mut self, now: Instant) {
+        // sync the diameter
+        self.set_measured_diameter();
         self.update();
-        // more than 33ms have passed since last emit (30 "fps" target)
+        // The live values are updated approximately 60 times per second
         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;

server/src/machines/laser/api.rs

@@ -1,6 +1,9 @@
 use super::LaserMachine;
 use control_core::{
-    machines::api::MachineApi,
+    machines::{
+        api::MachineApi, connection::MachineCrossConnectionState,
+        identification::MachineIdentificationUnique,
+    },
     socketio::{
         event::{Event, GenericEvent},
         namespace::{
@@ -36,6 +39,8 @@ pub struct StateEvent {
     pub is_default_state: bool,
     /// laser state
     pub laser_state: LaserState,
+    /// connected winder state
+    pub connected_winder_state: MachineCrossConnectionState,
 }
 
 impl StateEvent {
@@ -54,6 +59,13 @@ pub struct LaserState {
     pub target_diameter: f64,
 }
 
+#[derive(Serialize, Debug, Clone)]
+pub struct ConnectedMachineState {
+    /// Connected Machine
+    pub machine_identification_unique: Option<MachineIdentificationUnique>,
+    pub is_available: bool,
+}
+
 pub enum LaserEvents {
     LiveValues(Event<LiveValuesEvent>),
     State(Event<StateEvent>),
@@ -91,6 +103,11 @@ enum Mutation {
     SetTargetDiameter(f64),
     SetLowerTolerance(f64),
     SetHigherTolerance(f64),
+
+    // Connect Machine
+    SetConnectedWinder(MachineIdentificationUnique),
+    // Disconnect Machine
+    DisconnectWinder(MachineIdentificationUnique),
 }
 
 impl NamespaceCacheingLogic<LaserEvents> for LaserMachineNamespace {
@@ -117,6 +134,12 @@ impl MachineApi for LaserMachine {
             Mutation::SetTargetDiameter(target_diameter) => {
                 self.set_target_diameter(target_diameter);
             }
+            Mutation::SetConnectedWinder(machine_identification_unique) => {
+                self.set_connected_winder(machine_identification_unique);
+            }
+            Mutation::DisconnectWinder(machine_identification_unique) => {
+                self.disconnect_winder(machine_identification_unique);
+            }
         }
         Ok(())
     }

server/src/machines/laser/mod.rs

@@ -1,15 +1,22 @@
 use crate::{
-    machines::{MACHINE_LASER_V1, VENDOR_QITECH},
+    machines::{MACHINE_LASER_V1, VENDOR_QITECH, winder2::Winder2},
     serial::devices::laser::Laser,
 };
 use api::{LaserEvents, LaserMachineNamespace, LaserState, LiveValuesEvent, StateEvent};
 use control_core::{
-    machines::identification::{MachineIdentification, MachineIdentificationUnique},
+    machines::{
+        connection::{CrossConnectableMachine, MachineConnection, MachineCrossConnection},
+        identification::{MachineIdentification, MachineIdentificationUnique},
+        manager::MachineManager,
+    },
     socketio::namespace::NamespaceCacheingLogic,
 };
 use control_core_derive::Machine;
 use smol::lock::RwLock;
-use std::{sync::Arc, time::Instant};
+use std::{
+    sync::{Arc, Weak},
+    time::Instant,
+};
 use uom::si::{f64::Length, length::millimeter};
 
 pub mod act;
@@ -18,8 +25,6 @@ pub mod new;
 
 #[derive(Debug, Machine)]
 pub struct LaserMachine {
-    machine_identification_unique: MachineIdentificationUnique,
-
     // drivers
     laser: Arc<RwLock<Laser>>,
 
@@ -27,6 +32,13 @@ pub struct LaserMachine {
     namespace: LaserMachineNamespace,
     last_measurement_emit: Instant,
 
+    // machine connection
+    pub machine_manager: Weak<RwLock<MachineManager>>,
+    pub machine_identification_unique: MachineIdentificationUnique,
+
+    // connected machines
+    pub connected_winder: MachineCrossConnection<LaserMachine, Winder2>,
+
     // laser values
     diameter: Length,
     x_diameter: Option<Length>,
@@ -41,6 +53,12 @@ pub struct LaserMachine {
     emitted_default_state: bool,
 }
 
+impl CrossConnectableMachine<LaserMachine, Winder2> for LaserMachine {
+    fn get_cross_connection(&mut self) -> &mut MachineCrossConnection<LaserMachine, Winder2> {
+        &mut self.connected_winder
+    }
+}
+
 impl LaserMachine {
     pub const MACHINE_IDENTIFICATION: MachineIdentification = MachineIdentification {
         vendor: VENDOR_QITECH,
@@ -74,6 +92,7 @@ impl LaserMachine {
         StateEvent {
             is_default_state: false,
             laser_state: laser,
+            connected_winder_state: self.connected_winder.to_state(),
         }
     }
 
@@ -85,6 +104,7 @@ impl LaserMachine {
                 lower_tolerance: self.laser_target.lower_tolerance.get::<millimeter>(),
                 target_diameter: self.laser_target.diameter.get::<millimeter>(),
             },
+            connected_winder_state: self.connected_winder.to_state(),
         };
 
         self.namespace.emit(LaserEvents::State(state.build()));
@@ -150,6 +170,70 @@ impl LaserMachine {
     }
 }
 
+/// implement machine connection
+impl LaserMachine {
+    /// set connected winder
+    pub fn set_connected_winder(
+        &mut self,
+        machine_identification_unique: MachineIdentificationUnique,
+    ) {
+        if !matches!(
+            machine_identification_unique.machine_identification,
+            Winder2::MACHINE_IDENTIFICATION
+        ) {
+            return;
+        }
+
+        self.connected_winder
+            .set_connected_machine(&machine_identification_unique);
+        self.connected_winder.reverse_connect();
+
+        self.emit_state();
+    }
+    /// disconnect winder
+    pub fn disconnect_winder(
+        &mut self,
+        machine_identification_unique: MachineIdentificationUnique,
+    ) {
+        if !matches!(
+            machine_identification_unique.machine_identification,
+            Winder2::MACHINE_IDENTIFICATION
+        ) {
+            return;
+        }
+
+        self.connected_winder.reverse_disconnect();
+        self.connected_winder.disconnect();
+
+        self.emit_state();
+    }
+}
+
+impl LaserMachine {
+    fn set_measured_diameter(&mut self) {
+        let diameter = smol::block_on(async {
+            self.laser
+                .read()
+                .await
+                .get_data()
+                .await
+                .map(|laser_data| laser_data.diameter.get::<millimeter>())
+        });
+
+        if let Some(slot) = self.get_cross_connection().connected_machine.upgrade() {
+            let slot = slot.lock_blocking();
+
+            if let MachineConnection::Connected(machine) = &slot.machine_connection {
+                let mut winder = machine.lock_blocking();
+
+                winder
+                    .puller_speed_controller
+                    .set_measured_diameter(diameter.unwrap_or(0.0));
+            }
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct LaserTarget {
     diameter: Length,

server/src/machines/laser/new.rs

@@ -4,6 +4,7 @@ use crate::serial::{devices::laser::Laser, registry::SERIAL_DEVICE_REGISTRY};
 
 use super::{LaserMachine, LaserTarget, api::LaserMachineNamespace};
 use anyhow::Error;
+use control_core::machines::connection::MachineCrossConnection;
 use control_core::machines::new::{MachineNewHardware, MachineNewTrait};
 use uom::ConstZero;
 use uom::si::{f64::Length, length::millimeter};
@@ -34,6 +35,7 @@ impl MachineNewTrait for LaserMachine {
             lower_tolerance: Length::new::<millimeter>(0.05),
             diameter: Length::new::<millimeter>(1.75),
         };
+
         let mut laser_machine = Self {
             machine_identification_unique: params.get_machine_identification_unique(),
             laser,
@@ -43,6 +45,11 @@ impl MachineNewTrait for LaserMachine {
             last_measurement_emit: Instant::now(),
             laser_target,
             emitted_default_state: false,
+            machine_manager: params.machine_manager.clone(),
+            connected_winder: MachineCrossConnection::new(
+                params.machine_manager.clone(),
+                &params.get_machine_identification_unique(),
+            ),
             diameter: Length::ZERO,
             x_diameter: None,
             y_diameter: None,

server/src/machines/mod.rs

@@ -14,7 +14,10 @@ use ethercrab::{SubDevice, SubDeviceRef};
 use smol::lock::RwLock;
 
 pub mod aquapath1;
+
+#[cfg(not(feature = "mock-machine"))]
 pub mod buffer1;
+
 pub mod extruder1;
 pub mod laser;
 pub mod mock;
@@ -26,9 +29,11 @@ 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_BUFFER_V1: u16 = 0x0008;
 pub const MACHINE_AQUAPATH_V1: u16 = 0x0009;
 
+#[cfg(not(feature = "mock-machine"))]
+pub const MACHINE_BUFFER_V1: u16 = 0x0008;
+
 async fn get_device_ident<
     'maindevice,
     'subdevices,

server/src/machines/registry.rs

@@ -1,12 +1,12 @@
 #[cfg(feature = "mock-machine")]
-use crate::machines::{extruder1::mock::ExtruderV2, mock::MockMachine};
+use crate::machines::{extruder1::mock::ExtruderV2, mock::MockMachine, winder2::mock::Winder2};
 
 #[cfg(not(feature = "mock-machine"))]
-use crate::machines::extruder1::ExtruderV2;
-
 use crate::machines::{
-    aquapath1::AquaPathV1, buffer1::BufferV1, laser::LaserMachine, winder2::Winder2,
+    aquapath1::AquaPathV1, buffer1::BufferV1, extruder1::ExtruderV2, laser::LaserMachine,
+    winder2::Winder2,
 };
+
 use control_core::machines::registry::MachineRegistry;
 use lazy_static::lazy_static;
 
@@ -14,11 +14,18 @@ lazy_static! {
     pub static ref MACHINE_REGISTRY: MachineRegistry = {
         let mut mc = MachineRegistry::new();
         mc.register::<Winder2>(Winder2::MACHINE_IDENTIFICATION);
-        mc.register::<LaserMachine>(LaserMachine::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
     };

server/src/machines/winder2/act.rs

@@ -1,7 +1,11 @@
+#[cfg(not(feature = "mock-machine"))]
 use super::Winder2;
+#[cfg(not(feature = "mock-machine"))]
 use control_core::machines::new::MachineAct;
+#[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) {
         // sync the spool speed

server/src/machines/winder2/adaptive_spool_speed_controller.rs

@@ -186,7 +186,7 @@ impl AdaptiveSpoolSpeedController {
         puller_speed_controller: &PullerSpeedController,
     ) -> AngularVelocity {
         let min_speed = AngularVelocity::ZERO;
-        let max_speed = self.get_max_speed(puller_speed_controller);
+        let max_speed = self.get_max_speed(puller_speed_controller).abs();
 
         // Calculate filament tension from arm angle
         let tension_arm_angle = tension_arm.get_angle();

server/src/machines/winder2/api.rs

@@ -1,30 +1,63 @@
-use super::{Winder2, Winder2Mode, puller_speed_controller::PullerRegulationMode};
-use control_core::{
-    machines::{
-        api::MachineApi, connection::MachineCrossConnectionState,
-        identification::MachineIdentificationUnique,
-    },
-    socketio::{
-        event::{Event, GenericEvent},
-        namespace::{
-            CacheFn, CacheableEvents, Namespace, NamespaceCacheingLogic, cache_duration,
-            cache_first_and_last_event,
+#[cfg(feature = "mock-machine")]
+mod winder2_imports {
+    pub use super::super::Winder2Mode;
+    pub use super::super::puller_speed_controller::{GearRatio, PullerRegulationMode};
+    pub use serde::Deserialize;
+    pub use serde::Serialize;
+
+    pub use std::{sync::Arc, time::Duration};
+
+    pub use control_core::{
+        machines::{
+            connection::MachineCrossConnectionState, identification::MachineIdentificationUnique,
         },
-    },
-};
+        socketio::{
+            event::{Event, GenericEvent},
+            namespace::{
+                CacheFn, CacheableEvents, Namespace, NamespaceCacheingLogic, cache_duration,
+                cache_first_and_last_event,
+            },
+        },
+    };
+    pub use control_core_derive::BuildEvent;
+    pub use smol::lock::Mutex;
+    pub use tracing::instrument;
+}
 
-use control_core_derive::BuildEvent;
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use smol::lock::Mutex;
-use std::{
-    sync::Arc,
-    time::{Duration, Instant},
-};
-use tracing::instrument;
+#[cfg(not(feature = "mock-machine"))]
+mod winder2_imports {
+    pub use super::super::puller_speed_controller::{GearRatio, PullerRegulationMode};
+    pub use super::super::{Winder2, Winder2Mode};
+    pub use control_core::{
+        machines::{
+            api::MachineApi, connection::MachineCrossConnectionState,
+            identification::MachineIdentificationUnique,
+        },
+        socketio::{
+            event::{Event, GenericEvent},
+            namespace::{
+                CacheFn, CacheableEvents, Namespace, NamespaceCacheingLogic, cache_duration,
+                cache_first_and_last_event,
+            },
+        },
+    };
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+    pub use control_core_derive::BuildEvent;
+    pub use serde::{Deserialize, Serialize};
+    pub use serde_json::Value;
+    pub use smol::lock::Mutex;
+    pub use std::{
+        sync::Arc,
+        time::{Duration, Instant},
+    };
+    pub use tracing::instrument;
+}
+
+pub use winder2_imports::*;
+
+#[derive(Serialize, Deserialize, Debug, Clone, Default)]
 pub enum Mode {
+    #[default]
     Standby,
     Hold,
     Pull,
@@ -54,7 +87,7 @@ impl From<Mode> for Winder2Mode {
 }
 
 #[derive(Deserialize, Serialize)]
-enum Mutation {
+pub enum Mutation {
     // Traverse
     /// Position in mm from home point
     SetTraverseLimitOuter(f64),
@@ -76,11 +109,13 @@ enum Mutation {
     SetPullerTargetSpeed(f64),
     SetPullerTargetDiameter(f64),
     SetPullerForward(bool),
+    SetPullerGearRatio(GearRatio),
 
     // Spool Speed Controller
     SetSpoolRegulationMode(super::spool_speed_controller::SpoolSpeedControllerType),
     SetSpoolMinMaxMinSpeed(f64),
     SetSpoolMinMaxMaxSpeed(f64),
+    SetSpoolForward(bool),
 
     // Adaptive Spool Speed Controller Parameters
     SetSpoolAdaptiveTensionTarget(f64),
@@ -100,11 +135,16 @@ enum Mutation {
     // Mode
     SetMode(Mode),
 
+    // Pid Configure
+    SetSpeedPiSettings(PiSettings),
+
     // Connected Machine
     SetConnectedMachine(MachineIdentificationUnique),
+    SetConnectedLaser(MachineIdentificationUnique),
 
     // Disconnect Machine
     DisconnectMachine(MachineIdentificationUnique),
+    DisconnectLaser(MachineIdentificationUnique),
 }
 
 #[derive(Serialize, Debug, Clone, Default)]
@@ -142,11 +182,15 @@ pub struct StateEvent {
     pub tension_arm_state: TensionArmState,
     /// spool speed controller state
     pub spool_speed_controller_state: SpoolSpeedControllerState,
-    /// connected machine state
+    /// connected machine state (Buffer)
     pub connected_machine_state: MachineCrossConnectionState,
+    /// connected laser state
+    pub connected_laser_state: MachineCrossConnectionState,
+    /// pi settings
+    pub pi_settings: PiSettingsStates,
 }
 
-#[derive(Serialize, Debug, Clone)]
+#[derive(Serialize, Debug, Clone, Default)]
 pub struct TraverseState {
     /// min position in mm
     pub limit_inner: f64,
@@ -180,7 +224,7 @@ pub struct TraverseState {
     pub can_go_home: bool,
 }
 
-#[derive(Serialize, Debug, Clone)]
+#[derive(Serialize, Debug, Clone, Default)]
 pub struct PullerState {
     /// regulation type
     pub regulation: PullerRegulationMode,
@@ -190,22 +234,25 @@ pub struct PullerState {
     pub target_diameter: f64,
     /// forward rotation direction
     pub forward: bool,
+    /// gear ratio for winding speed
+    pub gear_ratio: GearRatio,
 }
 
-#[derive(Deserialize, Serialize, Debug, Clone)]
+#[derive(Deserialize, Serialize, Debug, Clone, Default)]
 pub enum SpoolAutomaticActionMode {
+    #[default]
     NoAction,
     Pull,
     Hold,
 }
 
-#[derive(Serialize, Debug, Clone)]
+#[derive(Serialize, Debug, Clone, Default)]
 pub struct SpoolAutomaticActionState {
     pub spool_required_meters: f64,
     pub spool_automatic_action_mode: SpoolAutomaticActionMode,
 }
 
-#[derive(Serialize, Debug, Clone)]
+#[derive(Serialize, Debug, Clone, Default)]
 pub struct ModeState {
     /// mode
     pub mode: Mode,
@@ -219,7 +266,7 @@ pub struct TensionArmState {
     pub zeroed: bool,
 }
 
-#[derive(Serialize, Debug, Clone)]
+#[derive(Serialize, Debug, Clone, Default)]
 pub struct SpoolSpeedControllerState {
     /// regulation mode
     pub regulation_mode: super::spool_speed_controller::SpoolSpeedControllerType,
@@ -237,6 +284,27 @@ pub struct SpoolSpeedControllerState {
     pub adaptive_acceleration_factor: f64,
     /// deacceleration urgency multiplier for adaptive mode
     pub adaptive_deacceleration_urgency_multiplier: f64,
+    /// forward rotation direction
+    pub forward: bool,
+}
+
+#[derive(Serialize, Debug, Clone)]
+pub struct ConnectedMachineState {
+    /// Connected Machine
+    pub machine_identification_unique: Option<MachineIdentificationUnique>,
+    pub is_available: bool,
+}
+
+#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
+pub struct PiSettings {
+    pub kp: f64,
+    pub ki: f64,
+}
+
+#[derive(Serialize, Debug, Clone)]
+pub struct PiSettingsStates {
+    pub kp: f64,
+    pub ki: f64,
 }
 
 pub enum Winder2Events {
@@ -279,6 +347,7 @@ impl CacheableEvents<Self> for Winder2Events {
     }
 }
 
+#[cfg(not(feature = "mock-machine"))]
 impl MachineApi for Winder2 {
     fn api_mutate(&mut self, request_body: Value) -> Result<(), anyhow::Error> {
         let mutation: Mutation = serde_json::from_value(request_body)?;
@@ -296,9 +365,11 @@ impl MachineApi for Winder2 {
             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)
             }
@@ -326,6 +397,15 @@ impl MachineApi for Winder2 {
             Mutation::DisconnectMachine(machine_identification_unique) => {
                 self.disconnect_buffer(machine_identification_unique)
             }
+            Mutation::SetConnectedLaser(machine_identification_unique) => {
+                self.set_connected_laser(machine_identification_unique)
+            }
+            Mutation::DisconnectLaser(machine_identification_unique) => {
+                self.disconnect_laser(machine_identification_unique)
+            }
+            Mutation::SetSpeedPiSettings(settings) => {
+                self.configure_pi_controller(settings);
+            }
         }
         Ok(())
     }

server/src/machines/winder2/emit.rs

@@ -0,0 +1,575 @@
+#[cfg(not(feature = "mock-machine"))]
+mod winder2_imports {
+    pub use super::super::puller_speed_controller::PullerRegulationMode;
+
+    pub use super::super::{TraverseMode, Winder2, Winder2Mode, api, spool_speed_controller};
+    pub use crate::machines::buffer1::BufferV1;
+    pub use crate::machines::laser::LaserMachine;
+    pub use crate::machines::winder2::api::{PiSettings, PiSettingsStates};
+
+    pub use api::{
+        LiveValuesEvent, ModeState, PullerState, SpoolAutomaticActionMode,
+        SpoolAutomaticActionState, SpoolSpeedControllerState, StateEvent, TensionArmState,
+        TraverseState, Winder2Events,
+    };
+    pub use control_core::socketio::event::BuildEvent;
+    pub use control_core::{
+        machines::identification::MachineIdentificationUnique,
+        socketio::namespace::NamespaceCacheingLogic, uom_extensions::velocity::meter_per_minute,
+    };
+    pub use std::time::Instant;
+    pub use uom::si::{
+        angle::degree,
+        angular_velocity::revolution_per_minute,
+        f64::{Length, Velocity},
+        length::{meter, millimeter},
+    };
+}
+
+#[cfg(not(feature = "mock-machine"))]
+pub use winder2_imports::*;
+
+#[cfg(not(feature = "mock-machine"))]
+impl Winder2 {
+    /// Implement Spool
+    /// called by `act`
+    pub fn sync_spool_speed(&mut self, t: Instant) {
+        let angular_velocity = self.spool_speed_controller.update_speed(
+            t,
+            &self.tension_arm,
+            &self.puller_speed_controller,
+        );
+
+        // Apply direction based on forward setting
+        let directed_angular_velocity = if self.spool_speed_controller.get_forward() {
+            angular_velocity
+        } else {
+            -angular_velocity
+        };
+
+        let steps_per_second = self
+            .spool_step_converter
+            .angular_velocity_to_steps(directed_angular_velocity);
+        let _ = self.spool.set_speed(steps_per_second);
+    }
+
+    pub fn stop_or_pull_spool(&mut self, now: Instant) {
+        if matches!(
+            self.spool_automatic_action.mode,
+            SpoolAutomaticActionMode::NoAction
+        ) {
+            self.calculate_spool_auto_progress_(now);
+            return;
+        }
+
+        match self.mode {
+            Winder2Mode::Pull => self.calculate_spool_auto_progress_(now),
+            Winder2Mode::Wind => self.calculate_spool_auto_progress_(now),
+            _ => {
+                self.spool_automatic_action.progress_last_check = now;
+                return;
+            }
+        }
+
+        if self.spool_automatic_action.progress >= self.spool_automatic_action.target_length {
+            match self.spool_automatic_action.mode {
+                SpoolAutomaticActionMode::NoAction => (),
+                SpoolAutomaticActionMode::Pull => {
+                    self.stop_or_pull_spool_reset(now);
+                    self.set_mode(&Winder2Mode::Pull);
+                }
+                SpoolAutomaticActionMode::Hold => {
+                    self.stop_or_pull_spool_reset(now);
+                    self.set_mode(&Winder2Mode::Hold);
+                }
+            }
+        }
+    }
+    /// Implement Mode
+    pub fn set_mode(&mut self, mode: &Winder2Mode) {
+        let should_update = *mode != Winder2Mode::Wind || self.can_wind();
+
+        if should_update {
+            // all transitions are allowed
+            self.mode = mode.clone();
+
+            // Apply the mode changes to the spool and puller
+            self.set_spool_mode(mode);
+            self.set_puller_mode(mode);
+            self.set_traverse_mode(mode);
+        }
+        self.emit_state();
+    }
+
+    /// Implement Traverse
+    pub fn set_laser(&mut self, value: bool) {
+        self.laser.set(value);
+        self.emit_state();
+    }
+
+    pub fn traverse_set_limit_inner(&mut self, limit: f64) {
+        let new_inner = Length::new::<millimeter>(limit);
+        let current_outer = self.traverse_controller.get_limit_outer();
+
+        // Validate the new inner limit against current outer limit
+        if !Self::validate_traverse_limits(new_inner, current_outer) {
+            // Don't update if validation fails - keep the current value
+            return;
+        }
+        self.traverse_controller.set_limit_inner(new_inner);
+        self.emit_state();
+    }
+
+    pub fn traverse_set_limit_outer(&mut self, limit: f64) {
+        let new_outer = Length::new::<millimeter>(limit);
+        let current_inner = self.traverse_controller.get_limit_inner();
+
+        // Validate the new outer limit against current inner limit
+        if !Self::validate_traverse_limits(current_inner, new_outer) {
+            // Don't update if validation fails - keep the current value
+            return;
+        }
+
+        self.traverse_controller.set_limit_outer(new_outer);
+        self.emit_state();
+    }
+
+    pub fn traverse_set_step_size(&mut self, step_size: f64) {
+        let step_size = Length::new::<millimeter>(step_size);
+        self.traverse_controller.set_step_size(step_size);
+        self.emit_state();
+    }
+
+    pub fn traverse_set_padding(&mut self, padding: f64) {
+        let padding = Length::new::<millimeter>(padding);
+        self.traverse_controller.set_padding(padding);
+        self.emit_state();
+    }
+
+    pub fn traverse_goto_limit_inner(&mut self) {
+        if self.can_go_in() {
+            self.traverse_controller.goto_limit_inner();
+        }
+        self.emit_state();
+    }
+
+    pub fn traverse_goto_limit_outer(&mut self) {
+        if self.can_go_out() {
+            self.traverse_controller.goto_limit_outer();
+        }
+        self.emit_state();
+    }
+
+    pub fn traverse_goto_home(&mut self) {
+        if self.can_go_home() {
+            self.traverse_controller.goto_home();
+        }
+        self.emit_state();
+    }
+
+    pub fn emit_live_values(&mut self) {
+        let angle_deg = self.tension_arm.get_angle().get::<degree>();
+
+        // Wrap [270;<360] to [-90; 0]
+        // This is done to reduce flicker in the graphs around the zero point
+        let angle_deg = if angle_deg >= 270.0 {
+            angle_deg - 360.0
+        } else {
+            angle_deg
+        };
+
+        // Calculate puller speed from current motor steps
+        let steps_per_second = self.puller.get_speed();
+        let angular_velocity = self
+            .puller_speed_controller
+            .converter
+            .steps_to_angular_velocity(steps_per_second as f64);
+        let motor_speed = self
+            .puller_speed_controller
+            .angular_velocity_to_speed(angular_velocity);
+
+        // Divide by gear ratio to get actual puller/material speed
+        let puller_speed = motor_speed / self.puller_speed_controller.get_gear_ratio().multiplier();
+
+        // Calculate spool RPM from current motor steps (always positive regardless of direction)
+        let spool_rpm = self
+            .spool_step_converter
+            .steps_to_angular_velocity(self.spool.get_speed() as f64)
+            .get::<revolution_per_minute>()
+            .abs();
+
+        let live_values = LiveValuesEvent {
+            traverse_position: self
+                .traverse_controller
+                .get_current_position()
+                .map(|x| x.get::<millimeter>()),
+            puller_speed: puller_speed.get::<meter_per_minute>().abs(),
+            spool_rpm,
+            tension_arm_angle: angle_deg,
+            spool_progress: self.spool_automatic_action.progress.get::<meter>(),
+        };
+
+        let event = live_values.build();
+        self.namespace.emit(Winder2Events::LiveValues(event));
+    }
+
+    pub fn build_state_event(&mut self) -> StateEvent {
+        StateEvent {
+            is_default_state: !std::mem::replace(&mut self.emitted_default_state, true),
+            traverse_state: TraverseState {
+                limit_inner: self
+                    .traverse_controller
+                    .get_limit_inner()
+                    .get::<millimeter>(),
+                limit_outer: self
+                    .traverse_controller
+                    .get_limit_outer()
+                    .get::<millimeter>(),
+                position_in: self
+                    .traverse_controller
+                    .get_limit_inner()
+                    .get::<millimeter>(),
+                position_out: self
+                    .traverse_controller
+                    .get_limit_outer()
+                    .get::<millimeter>(),
+                is_going_in: self.traverse_controller.is_going_in(),
+                is_going_out: self.traverse_controller.is_going_out(),
+                is_homed: self.traverse_controller.is_homed(),
+                is_going_home: self.traverse_controller.is_going_home(),
+                is_traversing: self.traverse_controller.is_traversing(),
+                laserpointer: self.laser.get(),
+                step_size: self.traverse_controller.get_step_size().get::<millimeter>(),
+                padding: self.traverse_controller.get_padding().get::<millimeter>(),
+                can_go_in: self.can_go_in(),
+                can_go_out: self.can_go_out(),
+                can_go_home: self.can_go_home(),
+            },
+            puller_state: PullerState {
+                regulation: self.puller_speed_controller.regulation_mode.clone(),
+                target_speed: self
+                    .puller_speed_controller
+                    .target_speed
+                    .get::<meter_per_minute>(),
+                target_diameter: self
+                    .puller_speed_controller
+                    .target_diameter
+                    .get::<millimeter>(),
+                forward: self.puller_speed_controller.forward,
+                gear_ratio: self.puller_speed_controller.gear_ratio,
+            },
+            mode_state: ModeState {
+                mode: self.mode.clone().into(),
+                can_wind: self.can_wind(),
+            },
+            tension_arm_state: TensionArmState {
+                zeroed: self.tension_arm.zeroed,
+            },
+            spool_speed_controller_state: SpoolSpeedControllerState {
+                regulation_mode: self.spool_speed_controller.get_type().clone(),
+                minmax_min_speed: self
+                    .spool_speed_controller
+                    .get_minmax_min_speed()
+                    .get::<revolution_per_minute>(),
+                minmax_max_speed: self
+                    .spool_speed_controller
+                    .get_minmax_max_speed()
+                    .get::<revolution_per_minute>(),
+                adaptive_tension_target: self.spool_speed_controller.get_adaptive_tension_target(),
+                adaptive_radius_learning_rate: self
+                    .spool_speed_controller
+                    .get_adaptive_radius_learning_rate(),
+                adaptive_max_speed_multiplier: self
+                    .spool_speed_controller
+                    .get_adaptive_max_speed_multiplier(),
+                adaptive_acceleration_factor: self
+                    .spool_speed_controller
+                    .get_adaptive_acceleration_factor(),
+                adaptive_deacceleration_urgency_multiplier: self
+                    .spool_speed_controller
+                    .get_adaptive_deacceleration_urgency_multiplier(),
+                forward: self.spool_speed_controller.get_forward(),
+            },
+            spool_automatic_action_state: SpoolAutomaticActionState {
+                spool_required_meters: self.spool_automatic_action.target_length.get::<meter>(),
+                spool_automatic_action_mode: self.spool_automatic_action.mode.clone(),
+            },
+            connected_machine_state: self.connected_buffer.to_state(),
+            connected_laser_state: self.connected_laser.to_state(),
+            pi_settings: PiSettingsStates {
+                    kp: self.puller_speed_controller.p_dead_controller.get_kp(),
+                    ki: self.puller_speed_controller.p_dead_controller.get_ki(),
+            },
+        }
+    }
+
+    pub fn emit_state(&mut self) {
+        let state_event = self.build_state_event();
+        let event = state_event.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) {
+        // Convert to `Winder2Mode` to `TraverseMode`
+        let mode: TraverseMode = mode.clone().into();
+
+        // If coming out of standby
+        if self.traverse_mode == TraverseMode::Standby && mode != TraverseMode::Standby {
+            self.traverse.set_enabled(true);
+            self.traverse_controller.set_enabled(true);
+        }
+
+        // If going into standby
+        if mode == TraverseMode::Standby && self.traverse_mode != TraverseMode::Standby {
+            // If we are going into standby, we need to stop the traverse
+            self.traverse.set_enabled(false);
+            self.traverse_controller.set_enabled(false);
+        }
+
+        // Transition matrix
+        match self.traverse_mode {
+            TraverseMode::Standby => match mode {
+                TraverseMode::Standby => {}
+                TraverseMode::Hold => {
+                    // From [`TraverseMode::Standby`] to [`TraverseMode::Hold`]
+                    self.traverse.set_enabled(true);
+                    self.traverse_controller.set_enabled(true);
+                    self.traverse_controller.goto_home();
+                }
+                TraverseMode::Traverse => {
+                    // From [`TraverseMode::Standby`] to [`TraverseMode::Wind`]
+                    self.traverse.set_enabled(true);
+                    self.traverse_controller.set_enabled(true);
+                    self.traverse_controller.start_traversing();
+                }
+            },
+            TraverseMode::Hold => match mode {
+                TraverseMode::Standby => {
+                    // From [`TraverseMode::Hold`] to [`TraverseMode::Standby`]
+                    self.traverse.set_enabled(false);
+                    self.traverse_controller.set_enabled(false);
+                }
+                TraverseMode::Hold => {}
+                TraverseMode::Traverse => {
+                    // From [`TraverseMode::Hold`] to [`TraverseMode::Wind`]
+                    self.traverse_controller.start_traversing();
+                }
+            },
+            TraverseMode::Traverse => match mode {
+                TraverseMode::Standby => {
+                    // From [`TraverseMode::Wind`] to [`TraverseMode::Standby`]
+                    self.traverse.set_enabled(false);
+                    self.traverse_controller.set_enabled(false);
+                }
+                TraverseMode::Hold => {
+                    // From [`TraverseMode::Wind`] to [`TraverseMode::Hold`]
+                    self.traverse_controller.goto_home();
+                }
+                TraverseMode::Traverse => {}
+            },
+        }
+
+        // Update the internal state
+        self.traverse_mode = mode;
+        self.emit_state();
+    }
+
+    /// Implement Tension Arm
+    pub fn tension_arm_zero(&mut self) {
+        self.tension_arm.zero();
+        self.emit_live_values(); // For angle update
+        // For state update
+        self.emit_state();
+    }
+
+    pub fn set_spool_automatic_required_meters(&mut self, meters: f64) {
+        self.spool_automatic_action.target_length = Length::new::<meter>(meters);
+        self.emit_state();
+    }
+
+    pub fn set_spool_automatic_mode(&mut self, mode: SpoolAutomaticActionMode) {
+        self.spool_automatic_action.mode = mode;
+        self.emit_state();
+    }
+
+    pub fn puller_set_regulation(&mut self, puller_regulation_mode: PullerRegulationMode) {
+        self.puller_speed_controller
+            .set_regulation_mode(puller_regulation_mode);
+        self.emit_state();
+    }
+
+    /// Set target speed in m/min
+    pub fn puller_set_target_speed(&mut self, target_speed: f64) {
+        // Convert m/min to velocity
+        let target_speed = Velocity::new::<meter_per_minute>(target_speed);
+        self.puller_speed_controller.set_target_speed(target_speed);
+        self.emit_state();
+    }
+
+    /// Set target diameter in mm
+    pub fn puller_set_target_diameter(&mut self, target_diameter: f64) {
+        // Convert m/min to velocity
+        let target_diameter = Length::new::<millimeter>(target_diameter);
+        self.puller_speed_controller
+            .set_target_diameter(target_diameter);
+        self.emit_state();
+    }
+
+    /// Set forward direction
+    pub fn puller_set_forward(&mut self, forward: bool) {
+        self.puller_speed_controller.set_forward(forward);
+        self.emit_state();
+    }
+
+    /// Set gear ratio for winding speed
+    pub fn puller_set_gear_ratio(&mut self, gear_ratio: super::puller_speed_controller::GearRatio) {
+        self.puller_speed_controller.set_gear_ratio(gear_ratio);
+        self.emit_state();
+    }
+
+    // Spool Speed Controller API methods
+    pub fn spool_set_regulation_mode(
+        &mut self,
+        regulation_mode: spool_speed_controller::SpoolSpeedControllerType,
+    ) {
+        self.spool_speed_controller.set_type(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) {
+        let min_speed = uom::si::f64::AngularVelocity::new::<revolution_per_minute>(min_speed_rpm);
+        if let Err(e) = self.spool_speed_controller.set_minmax_min_speed(min_speed) {
+            tracing::error!("Failed to set spool min speed: {:?}", e);
+        }
+        self.emit_state();
+    }
+
+    /// Set maximum speed for minmax mode in RPM
+    pub fn spool_set_minmax_max_speed(&mut self, max_speed_rpm: f64) {
+        let max_speed = uom::si::f64::AngularVelocity::new::<revolution_per_minute>(max_speed_rpm);
+        if let Err(e) = self.spool_speed_controller.set_minmax_max_speed(max_speed) {
+            tracing::error!("Failed to set spool max speed: {:?}", e);
+        }
+        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
+            .set_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
+            .set_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
+            .set_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
+            .set_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
+            .set_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.set_forward(forward);
+        self.emit_state();
+    }
+
+    /// implement machine connection
+    /// set connected buffer
+    pub fn set_connected_buffer(
+        &mut self,
+        machine_identification_unique: MachineIdentificationUnique,
+    ) {
+        if !matches!(
+            machine_identification_unique.machine_identification,
+            BufferV1::MACHINE_IDENTIFICATION
+        ) {
+            return;
+        }
+
+        self.connected_buffer
+            .set_connected_machine(&machine_identification_unique);
+        self.connected_buffer.reverse_connect();
+
+        self.emit_state();
+    }
+
+    /// disconnect buffer
+    pub fn disconnect_buffer(
+        &mut self,
+        machine_identification_unique: MachineIdentificationUnique,
+    ) {
+        if !matches!(
+            machine_identification_unique.machine_identification,
+            BufferV1::MACHINE_IDENTIFICATION
+        ) {
+            return;
+        }
+
+        self.connected_buffer.reverse_disconnect();
+        self.connected_buffer.disconnect();
+
+        self.emit_state();
+    }
+    /// set connected laser
+    pub fn set_connected_laser(
+        &mut self,
+        machine_identification_unique: MachineIdentificationUnique,
+    ) {
+        if !matches!(
+            machine_identification_unique.machine_identification,
+            LaserMachine::MACHINE_IDENTIFICATION
+        ) {
+            return;
+        }
+
+        self.connected_laser
+            .set_connected_machine(&machine_identification_unique);
+        self.connected_laser.reverse_connect();
+
+        self.emit_state();
+    }
+
+    /// disconnect laser
+    pub fn disconnect_laser(&mut self, machine_identification_unique: MachineIdentificationUnique) {
+        if !matches!(
+            machine_identification_unique.machine_identification,
+            LaserMachine::MACHINE_IDENTIFICATION
+        ) {
+            return;
+        }
+
+        self.connected_laser.reverse_disconnect();
+        self.connected_laser.disconnect();
+
+        self.emit_state();
+    }
+}

server/src/machines/winder2/filament_tension.rs

@@ -77,7 +77,7 @@ impl FilamentTensionCalculator {
     pub fn calc_filament_length(&self, tension_arm_angle: Angle) -> Length {
         let tension_arm_angle_rad = self
             .angle_converter
-            .decode_f64(tension_arm_angle)
+            .decode(tension_arm_angle)
             .get::<radian>();
 
         // Calculate tension arm tip position (flipped Y-axis: 0° = down, 90° = left)

server/src/machines/winder2/mock/act.rs

@@ -0,0 +1,13 @@
+use crate::machines::winder2::mock::Winder2;
+use control_core::machines::new::MachineAct;
+use std::time::{Duration, Instant};
+
+impl MachineAct for Winder2 {
+    fn act(&mut self, now: Instant) {
+        // 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;
+        }
+    }
+}

server/src/machines/winder2/mock/api.rs

@@ -0,0 +1,67 @@
+use std::{sync::Arc, time::Instant};
+
+use control_core::{machines::api::MachineApi, socketio::namespace::Namespace};
+use serde_json::Value;
+use smol::lock::Mutex;
+
+use crate::machines::winder2::api::Mutation;
+
+use super::Winder2;
+
+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) -> Arc<Mutex<Namespace>> {
+        self.namespace.namespace.clone()
+    }
+}

server/src/machines/winder2/mock/mock_emit.rs

@@ -0,0 +1,242 @@
+use std::time::Instant;
+
+use crate::machines::winder2::Winder2Mode;
+use crate::machines::winder2::api::LiveValuesEvent;
+use crate::machines::winder2::api::{
+    ModeState, SpoolAutomaticActionMode, StateEvent, Winder2Events,
+};
+use crate::machines::winder2::puller_speed_controller::{GearRatio, PullerRegulationMode};
+use crate::machines::winder2::spool_speed_controller::SpoolSpeedControllerType;
+use crate::machines::{MACHINE_WINDER_V1, VENDOR_QITECH};
+use control_core::machines::identification::{MachineIdentification, MachineIdentificationUnique};
+use control_core::socketio::event::BuildEvent;
+use control_core::socketio::namespace::NamespaceCacheingLogic;
+
+use super::Winder2;
+
+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 {
+        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: self.connected_machine_state.clone(),
+        }
+    }
+
+    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::machines::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();
+    }
+}

server/src/machines/winder2/mock/mod.rs

@@ -0,0 +1,44 @@
+use std::time::Instant;
+
+use control_core::machines::{
+    connection::MachineCrossConnectionState, identification::MachineIdentificationUnique,
+};
+use control_core_derive::Machine;
+pub mod act;
+pub mod api;
+pub mod mock_emit;
+pub mod new;
+use crate::machines::winder2::api::Winder2Namespace;
+
+use super::api::{
+    ModeState, PullerState, SpoolAutomaticActionState, SpoolSpeedControllerState, TensionArmState,
+    TraverseState,
+};
+
+#[derive(Debug, Machine)]
+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,
+    /// connected machine state
+    pub connected_machine_state: MachineCrossConnectionState,
+}
+
+impl std::fmt::Display for Winder2 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Winder2")
+    }
+}

server/src/machines/winder2/mock/new.rs

@@ -0,0 +1,53 @@
+use crate::machines::winder2::{
+    api::{
+        ModeState, PullerState, SpoolAutomaticActionState, SpoolSpeedControllerState,
+        TensionArmState, TraverseState, Winder2Namespace,
+    },
+    mock::Winder2,
+};
+use control_core::machines::connection::MachineCrossConnectionState;
+
+impl control_core::machines::new::MachineNewTrait for Winder2 {
+    fn new(
+        params: &control_core::machines::new::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 {
+            control_core::machines::new::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
+            }
+            control_core::machines::new::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 mut extruder_mock_machine = Self {
+            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_machine_state: MachineCrossConnectionState::default(),
+        };
+
+        extruder_mock_machine.emit_state();
+
+        Ok(extruder_mock_machine)
+    }
+}

server/src/machines/winder2/mod.rs

@@ -2,6 +2,7 @@ pub mod act;
 pub mod adaptive_spool_speed_controller;
 pub mod api;
 pub mod clamp_revolution;
+pub mod emit;
 pub mod filament_tension;
 pub mod minmax_spool_speed_controller;
 pub mod new;
@@ -10,46 +11,47 @@ pub mod spool_speed_controller;
 pub mod tension_arm;
 pub mod traverse_controller;
 
-use std::{fmt::Debug, sync::Weak, time::Instant};
+#[cfg(feature = "mock-machine")]
+pub mod mock;
 
-use api::{
-    LiveValuesEvent, ModeState, PullerState, SpoolAutomaticActionMode, SpoolAutomaticActionState,
-    SpoolSpeedControllerState, StateEvent, TensionArmState, TraverseState, Winder2Events,
-    Winder2Namespace,
-};
-use control_core::socketio::event::BuildEvent;
-use control_core::{
-    converters::angular_step_converter::AngularStepConverter,
-    machines::{
-        connection::{CrossConnectableMachine, MachineCrossConnection},
-        identification::{MachineIdentification, MachineIdentificationUnique},
-        manager::MachineManager,
-    },
-    socketio::namespace::NamespaceCacheingLogic,
-    uom_extensions::velocity::meter_per_minute,
-};
-use control_core_derive::Machine;
-use ethercat_hal::io::{
-    digital_input::DigitalInput, digital_output::DigitalOutput,
-    stepper_velocity_el70x1::StepperVelocityEL70x1,
-};
-use puller_speed_controller::{PullerRegulationMode, PullerSpeedController};
-use smol::lock::RwLock;
-use spool_speed_controller::SpoolSpeedController;
-use tension_arm::TensionArm;
-use traverse_controller::TraverseController;
-use uom::{
-    ConstZero,
-    si::{
-        angle::degree,
-        angular_velocity::revolution_per_minute,
-        f64::{Length, Velocity},
-        length::{meter, millimeter},
-        velocity::meter_per_second,
-    },
-};
+#[cfg(feature = "mock-machine")]
+mod winder2_imports {
+    pub use super::api::SpoolAutomaticActionMode;
+    pub use std::time::Instant;
+    pub use uom::si::f64::Length;
+}
 
-use crate::machines::{MACHINE_WINDER_V1, VENDOR_QITECH, buffer1::BufferV1};
+#[cfg(not(feature = "mock-machine"))]
+mod winder2_imports {
+    pub use super::api::SpoolAutomaticActionMode;
+    pub use super::api::Winder2Namespace;
+    pub use super::puller_speed_controller::PullerSpeedController;
+    pub use super::spool_speed_controller::SpoolSpeedController;
+    pub use super::tension_arm::TensionArm;
+    pub use super::traverse_controller::TraverseController;
+    pub use control_core::{
+        converters::angular_step_converter::AngularStepConverter,
+        machines::{
+            connection::{CrossConnectableMachine, MachineCrossConnection},
+            identification::{MachineIdentification, MachineIdentificationUnique},
+            manager::MachineManager,
+        },
+    };
+    pub use control_core_derive::Machine;
+    pub use ethercat_hal::io::{
+        digital_input::DigitalInput, digital_output::DigitalOutput,
+        stepper_velocity_el70x1::StepperVelocityEL70x1,
+    };
+    pub use smol::lock::RwLock;
+    pub use std::{fmt::Debug, sync::Weak, time::Instant};
+    pub use uom::si::f64::Length;
+
+    pub use uom::ConstZero;
+    pub use uom::si::{length::meter, length::millimeter, velocity::meter_per_second};
+    pub use crate::machines::{buffer1::BufferV1, laser::LaserMachine, winder2::api::PiSettings, MACHINE_WINDER_V1, VENDOR_QITECH};
+}
+
+pub use winder2_imports::*;
 
 #[derive(Debug)]
 pub struct SpoolAutomaticAction {
@@ -59,6 +61,18 @@ pub struct SpoolAutomaticAction {
     pub mode: SpoolAutomaticActionMode,
 }
 
+impl Default for SpoolAutomaticAction {
+    fn default() -> Self {
+        SpoolAutomaticAction {
+            progress: Length::new::<uom::si::length::meter>(0.0),
+            progress_last_check: Instant::now(),
+            target_length: Length::new::<uom::si::length::meter>(0.0),
+            mode: SpoolAutomaticActionMode::default(),
+        }
+    }
+}
+
+#[cfg(not(feature = "mock-machine"))]
 #[derive(Debug, Machine)]
 pub struct Winder2 {
     // drivers
@@ -82,6 +96,7 @@ pub struct Winder2 {
 
     // connected machines
     pub connected_buffer: MachineCrossConnection<Winder2, BufferV1>,
+    pub connected_laser: MachineCrossConnection<Winder2, LaserMachine>,
 
     // mode
     pub mode: Winder2Mode,
@@ -104,24 +119,26 @@ pub struct Winder2 {
     emitted_default_state: bool,
 }
 
+#[cfg(not(feature = "mock-machine"))]
 impl CrossConnectableMachine<Winder2, BufferV1> for Winder2 {
     fn get_cross_connection(&mut self) -> &mut MachineCrossConnection<Winder2, BufferV1> {
         &mut self.connected_buffer
     }
 }
 
+#[cfg(not(feature = "mock-machine"))]
+impl CrossConnectableMachine<Winder2, LaserMachine> for Winder2 {
+    fn get_cross_connection(&mut self) -> &mut MachineCrossConnection<Winder2, LaserMachine> {
+        &mut self.connected_laser
+    }
+}
+
 impl Winder2 {
     pub const MACHINE_IDENTIFICATION: MachineIdentification = MachineIdentification {
         vendor: VENDOR_QITECH,
         machine: MACHINE_WINDER_V1,
     };
 
-    /// Implement Traverse
-    fn set_laser(&mut self, value: bool) {
-        self.laser.set(value);
-        self.emit_state();
-    }
-
     /// Validates that traverse limits maintain proper constraints:
     /// - Inner limit must be smaller than outer limit
     /// - At least 0.9mm difference between inner and outer limits
@@ -129,197 +146,6 @@ impl Winder2 {
         outer > inner + Length::new::<millimeter>(0.9)
     }
 
-    pub fn traverse_set_limit_inner(&mut self, limit: f64) {
-        let new_inner = Length::new::<millimeter>(limit);
-        let current_outer = self.traverse_controller.get_limit_outer();
-
-        // Validate the new inner limit against current outer limit
-        if !Self::validate_traverse_limits(new_inner, current_outer) {
-            // Don't update if validation fails - keep the current value
-            return;
-        }
-        self.traverse_controller.set_limit_inner(new_inner);
-        self.emit_state();
-    }
-
-    pub fn traverse_set_limit_outer(&mut self, limit: f64) {
-        let new_outer = Length::new::<millimeter>(limit);
-        let current_inner = self.traverse_controller.get_limit_inner();
-
-        // Validate the new outer limit against current inner limit
-        if !Self::validate_traverse_limits(current_inner, new_outer) {
-            // Don't update if validation fails - keep the current value
-            return;
-        }
-
-        self.traverse_controller.set_limit_outer(new_outer);
-        self.emit_state();
-    }
-
-    pub fn traverse_set_step_size(&mut self, step_size: f64) {
-        let step_size = Length::new::<millimeter>(step_size);
-        self.traverse_controller.set_step_size(step_size);
-        self.emit_state();
-    }
-
-    pub fn traverse_set_padding(&mut self, padding: f64) {
-        let padding = Length::new::<millimeter>(padding);
-        self.traverse_controller.set_padding(padding);
-        self.emit_state();
-    }
-
-    pub fn traverse_goto_limit_inner(&mut self) {
-        if self.can_go_in() {
-            self.traverse_controller.goto_limit_inner();
-        }
-        self.emit_state();
-    }
-
-    pub fn traverse_goto_limit_outer(&mut self) {
-        if self.can_go_out() {
-            self.traverse_controller.goto_limit_outer();
-        }
-        self.emit_state();
-    }
-
-    pub fn traverse_goto_home(&mut self) {
-        if self.can_go_home() {
-            self.traverse_controller.goto_home();
-        }
-        self.emit_state();
-    }
-
-    pub fn emit_live_values(&mut self) {
-        let angle_deg = self.tension_arm.get_angle().get::<degree>();
-
-        // Wrap [270;<360] to [-90; 0]
-        // This is done to reduce flicker in the graphs around the zero point
-        let angle_deg = if angle_deg >= 270.0 {
-            angle_deg - 360.0
-        } else {
-            angle_deg
-        };
-
-        // Calculate puller speed from current motor steps
-        let steps_per_second = self.puller.get_speed();
-        let angular_velocity = self
-            .puller_speed_controller
-            .converter
-            .steps_to_angular_velocity(steps_per_second as f64);
-        let puller_speed = self
-            .puller_speed_controller
-            .angular_velocity_to_speed(angular_velocity);
-
-        // Calculate spool RPM from current motor steps
-        let spool_rpm = self
-            .spool_step_converter
-            .steps_to_angular_velocity(self.spool.get_speed() as f64)
-            .get::<revolution_per_minute>();
-
-        let live_values = LiveValuesEvent {
-            traverse_position: self
-                .traverse_controller
-                .get_current_position()
-                .map(|x| x.get::<millimeter>()),
-            puller_speed: puller_speed.get::<meter_per_minute>(),
-            spool_rpm,
-            tension_arm_angle: angle_deg,
-            spool_progress: self.spool_automatic_action.progress.get::<meter>(),
-        };
-
-        let event = live_values.build();
-        self.namespace.emit(Winder2Events::LiveValues(event));
-    }
-
-    pub fn build_state_event(&mut self) -> StateEvent {
-        StateEvent {
-            is_default_state: !std::mem::replace(&mut self.emitted_default_state, true),
-            traverse_state: TraverseState {
-                limit_inner: self
-                    .traverse_controller
-                    .get_limit_inner()
-                    .get::<millimeter>(),
-                limit_outer: self
-                    .traverse_controller
-                    .get_limit_outer()
-                    .get::<millimeter>(),
-                position_in: self
-                    .traverse_controller
-                    .get_limit_inner()
-                    .get::<millimeter>(),
-                position_out: self
-                    .traverse_controller
-                    .get_limit_outer()
-                    .get::<millimeter>(),
-                is_going_in: self.traverse_controller.is_going_in(),
-                is_going_out: self.traverse_controller.is_going_out(),
-                is_homed: self.traverse_controller.is_homed(),
-                is_going_home: self.traverse_controller.is_going_home(),
-                is_traversing: self.traverse_controller.is_traversing(),
-                laserpointer: self.laser.get(),
-                step_size: self.traverse_controller.get_step_size().get::<millimeter>(),
-                padding: self.traverse_controller.get_padding().get::<millimeter>(),
-                can_go_in: self.can_go_in(),
-                can_go_out: self.can_go_out(),
-                can_go_home: self.can_go_home(),
-            },
-            puller_state: PullerState {
-                regulation: self.puller_speed_controller.regulation_mode.clone(),
-                target_speed: self
-                    .puller_speed_controller
-                    .target_speed
-                    .get::<meter_per_minute>(),
-                target_diameter: self
-                    .puller_speed_controller
-                    .target_diameter
-                    .get::<millimeter>(),
-                forward: self.puller_speed_controller.forward,
-            },
-            mode_state: ModeState {
-                mode: self.mode.clone().into(),
-                can_wind: self.can_wind(),
-            },
-            tension_arm_state: TensionArmState {
-                zeroed: self.tension_arm.zeroed,
-            },
-            spool_speed_controller_state: SpoolSpeedControllerState {
-                regulation_mode: self.spool_speed_controller.get_type().clone(),
-                minmax_min_speed: self
-                    .spool_speed_controller
-                    .get_minmax_min_speed()
-                    .get::<revolution_per_minute>(),
-                minmax_max_speed: self
-                    .spool_speed_controller
-                    .get_minmax_max_speed()
-                    .get::<revolution_per_minute>(),
-                adaptive_tension_target: self.spool_speed_controller.get_adaptive_tension_target(),
-                adaptive_radius_learning_rate: self
-                    .spool_speed_controller
-                    .get_adaptive_radius_learning_rate(),
-                adaptive_max_speed_multiplier: self
-                    .spool_speed_controller
-                    .get_adaptive_max_speed_multiplier(),
-                adaptive_acceleration_factor: self
-                    .spool_speed_controller
-                    .get_adaptive_acceleration_factor(),
-                adaptive_deacceleration_urgency_multiplier: self
-                    .spool_speed_controller
-                    .get_adaptive_deacceleration_urgency_multiplier(),
-            },
-            spool_automatic_action_state: SpoolAutomaticActionState {
-                spool_required_meters: self.spool_automatic_action.target_length.get::<meter>(),
-                spool_automatic_action_mode: self.spool_automatic_action.mode.clone(),
-            },
-            connected_machine_state: self.connected_buffer.to_state(),
-        }
-    }
-
-    pub fn emit_state(&mut self) {
-        let state_event = self.build_state_event();
-        let event = state_event.build();
-        self.namespace.emit(Winder2Events::State(event));
-    }
-
     pub fn sync_traverse_speed(&mut self) {
         self.traverse_controller.update_speed(
             &mut self.traverse,
@@ -372,22 +198,6 @@ impl Winder2 {
             && self.mode != Winder2Mode::Wind
     }
 
-    /// Implement Mode
-    fn set_mode(&mut self, mode: &Winder2Mode) {
-        let should_update = *mode != Winder2Mode::Wind || self.can_wind();
-
-        if should_update {
-            // all transitions are allowed
-            self.mode = mode.clone();
-
-            // Apply the mode changes to the spool and puller
-            self.set_spool_mode(mode);
-            self.set_puller_mode(mode);
-            self.set_traverse_mode(mode);
-        }
-        self.emit_state();
-    }
-
     /// Apply the mode changes to the spool
     ///
     /// It contains a transition matrix for atomic changes.
@@ -440,75 +250,6 @@ impl Winder2 {
         self.spool_mode = mode;
     }
 
-    /// 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) {
-        // Convert to `Winder2Mode` to `TraverseMode`
-        let mode: TraverseMode = mode.clone().into();
-
-        // If coming out of standby
-        if self.traverse_mode == TraverseMode::Standby && mode != TraverseMode::Standby {
-            self.traverse.set_enabled(true);
-            self.traverse_controller.set_enabled(true);
-        }
-
-        // If going into standby
-        if mode == TraverseMode::Standby && self.traverse_mode != TraverseMode::Standby {
-            // If we are going into standby, we need to stop the traverse
-            self.traverse.set_enabled(false);
-            self.traverse_controller.set_enabled(false);
-        }
-
-        // Transition matrix
-        match self.traverse_mode {
-            TraverseMode::Standby => match mode {
-                TraverseMode::Standby => {}
-                TraverseMode::Hold => {
-                    // From [`TraverseMode::Standby`] to [`TraverseMode::Hold`]
-                    self.traverse.set_enabled(true);
-                    self.traverse_controller.set_enabled(true);
-                    self.traverse_controller.goto_home();
-                }
-                TraverseMode::Traverse => {
-                    // From [`TraverseMode::Standby`] to [`TraverseMode::Wind`]
-                    self.traverse.set_enabled(true);
-                    self.traverse_controller.set_enabled(true);
-                    self.traverse_controller.start_traversing();
-                }
-            },
-            TraverseMode::Hold => match mode {
-                TraverseMode::Standby => {
-                    // From [`TraverseMode::Hold`] to [`TraverseMode::Standby`]
-                    self.traverse.set_enabled(false);
-                    self.traverse_controller.set_enabled(false);
-                }
-                TraverseMode::Hold => {}
-                TraverseMode::Traverse => {
-                    // From [`TraverseMode::Hold`] to [`TraverseMode::Wind`]
-                    self.traverse_controller.start_traversing();
-                }
-            },
-            TraverseMode::Traverse => match mode {
-                TraverseMode::Standby => {
-                    // From [`TraverseMode::Wind`] to [`TraverseMode::Standby`]
-                    self.traverse.set_enabled(false);
-                    self.traverse_controller.set_enabled(false);
-                }
-                TraverseMode::Hold => {
-                    // From [`TraverseMode::Wind`] to [`TraverseMode::Hold`]
-                    self.traverse_controller.goto_home();
-                }
-                TraverseMode::Traverse => {}
-            },
-        }
-
-        // Update the internal state
-        self.traverse_mode = mode;
-        self.emit_state();
-    }
-
     /// Apply the mode changes to the puller
     ///
     /// It contains a transition matrix for atomic changes.
@@ -560,71 +301,6 @@ impl Winder2 {
         self.puller_mode = mode;
     }
 
-    /// Implement Tension Arm
-    fn tension_arm_zero(&mut self) {
-        self.tension_arm.zero();
-        self.emit_live_values(); // For angle update
-        // For state update
-        self.emit_state();
-    }
-
-    /// Implement Spool
-    /// called by `act`
-    pub fn sync_spool_speed(&mut self, t: Instant) {
-        let angular_velocity = self.spool_speed_controller.update_speed(
-            t,
-            &self.tension_arm,
-            &self.puller_speed_controller,
-        );
-        let steps_per_second = self
-            .spool_step_converter
-            .angular_velocity_to_steps(angular_velocity);
-        let _ = self.spool.set_speed(steps_per_second);
-    }
-
-    pub fn set_spool_automatic_required_meters(&mut self, meters: f64) {
-        self.spool_automatic_action.target_length = Length::new::<meter>(meters);
-        self.emit_state();
-    }
-
-    pub fn set_spool_automatic_mode(&mut self, mode: SpoolAutomaticActionMode) {
-        self.spool_automatic_action.mode = mode;
-        self.emit_state();
-    }
-
-    pub fn stop_or_pull_spool(&mut self, now: Instant) {
-        if matches!(
-            self.spool_automatic_action.mode,
-            SpoolAutomaticActionMode::NoAction
-        ) {
-            self.calculate_spool_auto_progress_(now);
-            return;
-        }
-
-        match self.mode {
-            Winder2Mode::Pull => self.calculate_spool_auto_progress_(now),
-            Winder2Mode::Wind => self.calculate_spool_auto_progress_(now),
-            _ => {
-                self.spool_automatic_action.progress_last_check = now;
-                return;
-            }
-        }
-
-        if self.spool_automatic_action.progress >= self.spool_automatic_action.target_length {
-            match self.spool_automatic_action.mode {
-                SpoolAutomaticActionMode::NoAction => (),
-                SpoolAutomaticActionMode::Pull => {
-                    self.stop_or_pull_spool_reset(now);
-                    self.set_mode(&Winder2Mode::Pull);
-                }
-                SpoolAutomaticActionMode::Hold => {
-                    self.stop_or_pull_spool_reset(now);
-                    self.set_mode(&Winder2Mode::Hold);
-                }
-            }
-        }
-    }
-
     pub const fn stop_or_pull_spool_reset(&mut self, now: Instant) {
         self.spool_automatic_action.progress = Length::ZERO;
         self.spool_automatic_action.progress_last_check = now;
@@ -632,6 +308,7 @@ impl Winder2 {
 
     pub fn calculate_spool_auto_progress_(&mut self, now: Instant) {
         // Calculate time elapsed since last progress check (in minutes)
+
         let dt = now
             .duration_since(self.spool_automatic_action.progress_last_check)
             .as_secs_f64();
@@ -645,7 +322,7 @@ impl Winder2 {
         );
 
         // Update total meters pulled
-        self.spool_automatic_action.progress += meters_pulled_this_interval;
+        self.spool_automatic_action.progress += meters_pulled_this_interval.abs();
         self.spool_automatic_action.progress_last_check = now;
     }
 
@@ -659,135 +336,14 @@ impl Winder2 {
             .angular_velocity_to_steps(angular_velocity);
         let _ = self.puller.set_speed(steps_per_second);
     }
+}
 
-    pub fn puller_set_regulation(&mut self, puller_regulation_mode: PullerRegulationMode) {
+impl Winder2 {
+    pub fn configure_pi_controller(&mut self, settings: PiSettings) {
+        // Implement pid to controll speed of winder
         self.puller_speed_controller
-            .set_regulation_mode(puller_regulation_mode);
-        self.emit_state();
-    }
-
-    /// Set target speed in m/min
-    pub fn puller_set_target_speed(&mut self, target_speed: f64) {
-        // Convert m/min to velocity
-        let target_speed = Velocity::new::<meter_per_minute>(target_speed);
-        self.puller_speed_controller.set_target_speed(target_speed);
-        self.emit_state();
-    }
-
-    /// Set target diameter in mm
-    pub fn puller_set_target_diameter(&mut self, target_diameter: f64) {
-        // Convert m/min to velocity
-        let target_diameter = Length::new::<millimeter>(target_diameter);
-        self.puller_speed_controller
-            .set_target_diameter(target_diameter);
-        self.emit_state();
-    }
-
-    /// Set forward direction
-    pub fn puller_set_forward(&mut self, forward: bool) {
-        self.puller_speed_controller.set_forward(forward);
-        self.emit_state();
-    }
-
-    // Spool Speed Controller API methods
-    pub fn spool_set_regulation_mode(
-        &mut self,
-        regulation_mode: spool_speed_controller::SpoolSpeedControllerType,
-    ) {
-        self.spool_speed_controller.set_type(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) {
-        let min_speed = uom::si::f64::AngularVelocity::new::<revolution_per_minute>(min_speed_rpm);
-        if let Err(e) = self.spool_speed_controller.set_minmax_min_speed(min_speed) {
-            tracing::error!("Failed to set spool min speed: {:?}", e);
-        }
-        self.emit_state();
-    }
-
-    /// Set maximum speed for minmax mode in RPM
-    pub fn spool_set_minmax_max_speed(&mut self, max_speed_rpm: f64) {
-        let max_speed = uom::si::f64::AngularVelocity::new::<revolution_per_minute>(max_speed_rpm);
-        if let Err(e) = self.spool_speed_controller.set_minmax_max_speed(max_speed) {
-            tracing::error!("Failed to set spool max speed: {:?}", e);
-        }
-        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
-            .set_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
-            .set_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
-            .set_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
-            .set_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
-            .set_adaptive_deacceleration_urgency_multiplier(deacceleration_urgency_multiplier);
-        self.emit_state();
-    }
-
-    /// implement machine connection
-    /// set connected buffer
-    pub fn set_connected_buffer(
-        &mut self,
-        machine_identification_unique: MachineIdentificationUnique,
-    ) {
-        if !matches!(
-            machine_identification_unique.machine_identification,
-            BufferV1::MACHINE_IDENTIFICATION
-        ) {
-            return;
-        }
-
-        self.connected_buffer
-            .set_connected_machine(&machine_identification_unique);
-        self.connected_buffer.reverse_connect();
-
-        self.emit_state();
-    }
-
-    /// disconnect buffer
-    pub fn disconnect_buffer(
-        &mut self,
-        machine_identification_unique: MachineIdentificationUnique,
-    ) {
-        if !matches!(
-            machine_identification_unique.machine_identification,
-            BufferV1::MACHINE_IDENTIFICATION
-        ) {
-            return;
-        }
-
-        self.connected_buffer.reverse_disconnect();
-        self.connected_buffer.disconnect();
+            .p_dead_controller
+            .configure(settings.kp, settings.ki);
 
         self.emit_state();
     }
@@ -855,12 +411,14 @@ impl From<Winder2Mode> for PullerMode {
     }
 }
 
+#[cfg(not(feature = "mock-machine"))]
 impl std::fmt::Display for Winder2 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "Winder2")
     }
 }
 
+#[cfg(not(feature = "mock-machine"))]
 #[cfg(test)]
 mod tests {
     use super::*;

server/src/machines/winder2/new.rs

@@ -1,50 +1,63 @@
-use std::time::Instant;
+#[cfg(not(feature = "mock-machine"))]
+mod winder2_imports {
+    pub use super::super::api::Winder2Namespace;
+    pub use super::super::tension_arm::TensionArm;
+    pub use super::super::{Winder2, Winder2Mode};
+    pub use crate::machines::winder2::puller_speed_controller::PullerSpeedController;
+    pub use crate::machines::winder2::spool_speed_controller::SpoolSpeedController;
+    pub use crate::machines::winder2::traverse_controller::TraverseController;
+    pub use anyhow::Error;
+    pub use control_core::converters::angular_step_converter::AngularStepConverter;
+    pub use control_core::converters::linear_step_converter::LinearStepConverter;
+    pub use control_core::machines::connection::MachineCrossConnection;
+    pub use control_core::machines::new::{
+        MachineNewHardware, MachineNewParams, MachineNewTrait, validate_no_role_dublicates,
+        validate_same_machine_identification_unique,
+    };
 
-use super::api::Winder2Namespace;
-use super::tension_arm::TensionArm;
-use super::{Winder2, Winder2Mode};
+    pub use control_core::uom_extensions::velocity::meter_per_minute;
+    pub use ethercat_hal::coe::ConfigurableDevice;
+    pub use ethercat_hal::devices::ek1100::EK1100;
+    pub use ethercat_hal::devices::el2002::{EL2002, EL2002_IDENTITY_B, EL2002Port};
+    pub use ethercat_hal::devices::el7031::coe::EL7031Configuration;
+    pub use ethercat_hal::devices::el7031::pdo::EL7031PredefinedPdoAssignment;
+    pub use ethercat_hal::devices::el7031::{
+        EL7031, EL7031_IDENTITY_A, EL7031_IDENTITY_B, EL7031DigitalInputPort, EL7031StepperPort,
+    };
+    pub use ethercat_hal::devices::el7031_0030::coe::EL7031_0030Configuration;
+    pub use ethercat_hal::devices::el7031_0030::pdo::EL7031_0030PredefinedPdoAssignment;
+    pub use ethercat_hal::devices::el7031_0030::{
+        self, EL7031_0030, EL7031_0030_IDENTITY_A, EL7031_0030AnalogInputPort,
+        EL7031_0030StepperPort,
+    };
+    pub use ethercat_hal::devices::el7041_0052::coe::EL7041_0052Configuration;
+    pub use ethercat_hal::devices::el7041_0052::{
+        EL7041_0052, EL7041_0052_IDENTITY_A, EL7041_0052Port,
+    };
+    pub use ethercat_hal::devices::{ek1100::EK1100_IDENTITY_A, el2002::EL2002_IDENTITY_A};
+    pub use ethercat_hal::io::analog_input::AnalogInput;
+    pub use ethercat_hal::io::digital_input::DigitalInput;
+    pub use ethercat_hal::io::digital_output::DigitalOutput;
+    pub use ethercat_hal::io::stepper_velocity_el70x1::StepperVelocityEL70x1;
+    pub use ethercat_hal::shared_config;
+    pub use ethercat_hal::shared_config::el70x1::{EL70x1OperationMode, StmMotorConfiguration};
+    pub use std::time::Instant;
+    pub use uom::ConstZero;
+    pub use uom::si::f64::{Length, Velocity};
+    pub use uom::si::length::{centimeter, meter, millimeter};
+}
+
+#[cfg(not(feature = "mock-machine"))]
+pub use winder2_imports::*;
+
+#[cfg(not(feature = "mock-machine"))]
 use crate::machines::get_ethercat_device;
-use crate::machines::winder2::puller_speed_controller::PullerSpeedController;
-use crate::machines::winder2::spool_speed_controller::SpoolSpeedController;
-use crate::machines::winder2::traverse_controller::TraverseController;
-use anyhow::Error;
-use control_core::converters::angular_step_converter::AngularStepConverter;
-use control_core::converters::linear_step_converter::LinearStepConverter;
-use control_core::machines::connection::MachineCrossConnection;
-use control_core::machines::new::{
-    MachineNewHardware, MachineNewParams, MachineNewTrait, validate_no_role_dublicates,
-    validate_same_machine_identification_unique,
-};
-use control_core::uom_extensions::velocity::meter_per_minute;
-use ethercat_hal::coe::ConfigurableDevice;
-use ethercat_hal::devices::ek1100::EK1100;
-use ethercat_hal::devices::el2002::{EL2002, EL2002_IDENTITY_B, EL2002Port};
-use ethercat_hal::devices::el7031::coe::EL7031Configuration;
-use ethercat_hal::devices::el7031::pdo::EL7031PredefinedPdoAssignment;
-use ethercat_hal::devices::el7031::{
-    EL7031, EL7031_IDENTITY_A, EL7031_IDENTITY_B, EL7031DigitalInputPort, EL7031StepperPort,
-};
-use ethercat_hal::devices::el7031_0030::coe::EL7031_0030Configuration;
-use ethercat_hal::devices::el7031_0030::pdo::EL7031_0030PredefinedPdoAssignment;
-use ethercat_hal::devices::el7031_0030::{
-    self, EL7031_0030, EL7031_0030_IDENTITY_A, EL7031_0030AnalogInputPort, EL7031_0030StepperPort,
-};
-use ethercat_hal::devices::el7041_0052::coe::EL7041_0052Configuration;
-use ethercat_hal::devices::el7041_0052::{EL7041_0052, EL7041_0052_IDENTITY_A, EL7041_0052Port};
-use ethercat_hal::devices::{ek1100::EK1100_IDENTITY_A, el2002::EL2002_IDENTITY_A};
-use ethercat_hal::io::analog_input::AnalogInput;
-use ethercat_hal::io::digital_input::DigitalInput;
-use ethercat_hal::io::digital_output::DigitalOutput;
-use ethercat_hal::io::stepper_velocity_el70x1::StepperVelocityEL70x1;
-use ethercat_hal::shared_config;
-use ethercat_hal::shared_config::el70x1::{EL70x1OperationMode, StmMotorConfiguration};
-use uom::ConstZero;
-use uom::si::f64::{Length, Velocity};
-use uom::si::length::{centimeter, meter, millimeter};
 
+#[cfg(not(feature = "mock-machine"))]
 impl MachineNewTrait for Winder2 {
     fn new<'maindevice>(params: &MachineNewParams) -> Result<Self, Error> {
         // validate general stuff
+
         let device_identification = params.device_group.to_vec();
 
         validate_same_machine_identification_unique(&device_identification)?;
@@ -177,14 +190,6 @@ impl MachineNewTrait for Winder2 {
 
             let mode = Winder2Mode::Standby;
 
-            let machine_id = params
-                .device_group
-                .first()
-                .expect("device group must have at least one device")
-                .device_machine_identification
-                .machine_identification_unique
-                .clone();
-
             let mut new = Self {
                 traverse: StepperVelocityEL70x1::new(el7031.clone(), EL7031StepperPort::STM1),
                 traverse_end_stop: DigitalInput::new(el7031, EL7031DigitalInputPort::DI1),
@@ -229,11 +234,15 @@ impl MachineNewTrait for Winder2 {
                     mode: super::api::SpoolAutomaticActionMode::NoAction,
                 },
                 machine_manager: params.machine_manager.clone(),
-                machine_identification_unique: machine_id,
+                machine_identification_unique: params.get_machine_identification_unique(),
                 connected_buffer: MachineCrossConnection::new(
                     params.machine_manager.clone(),
                     &params.get_machine_identification_unique(),
                 ),
+                connected_laser: MachineCrossConnection::new(
+                    params.machine_manager.clone(),
+                    &params.get_machine_identification_unique(),
+                ),
             };
 
             // initalize events

server/src/machines/winder2/puller_speed_controller.rs

@@ -1,7 +1,12 @@
-use std::time::Instant;
+use std::{
+    time::{Duration, Instant},
+};
 
 use control_core::{
-    controllers::second_degree_motion::linear_jerk_speed_controller::LinearJerkSpeedController,
+    controllers::{
+        deadtime_pi_controller::TimeAgnosticDeadTimePiController,
+        second_degree_motion::linear_jerk_speed_controller::LinearJerkSpeedController,
+    },
     converters::linear_step_converter::LinearStepConverter,
     uom_extensions::{
         acceleration::meter_per_minute_per_second, jerk::meter_per_minute_per_second_squared,
@@ -11,22 +16,54 @@ use control_core::{
 use serde::{Deserialize, Serialize};
 use uom::{
     ConstZero,
-    si::f64::{Acceleration, AngularVelocity, Jerk, Length, Velocity},
+    si::{
+        f64::{Acceleration, AngularVelocity, Jerk, Length, Velocity},
+        length::{meter, millimeter},
+        time::second,
+    },
 };
 
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq)]
+pub enum GearRatio {
+    OneToOne,
+    OneToFive,
+    OneToTen,
+}
+
+impl GearRatio {
+    /// Get the speed multiplier for this gear ratio
+    pub fn multiplier(&self) -> f64 {
+        match self {
+            GearRatio::OneToOne => 1.0,
+            GearRatio::OneToFive => 5.0,
+            GearRatio::OneToTen => 10.0,
+        }
+    }
+}
+
+impl Default for GearRatio {
+    fn default() -> Self {
+        GearRatio::OneToOne
+    }
+}
+
 #[derive(Debug)]
 pub struct PullerSpeedController {
     enabled: bool,
     pub target_speed: Velocity,
     pub target_diameter: Length,
+    pub measured_diameter: Length,
     pub regulation_mode: PullerRegulationMode,
     /// Forward rotation direction. If false, applies negative sign to speed
     pub forward: bool,
+    /// Gear ratio for winding speed (1:5 or 1:10)
+    pub gear_ratio: GearRatio,
     /// Linear acceleration controller to dampen speed change
     acceleration_controller: LinearJerkSpeedController,
     /// Converter for linear to angular transformations
     pub converter: LinearStepConverter,
     pub last_speed: Velocity,
+    pub p_dead_controller: TimeAgnosticDeadTimePiController,
 }
 
 impl PullerSpeedController {
@@ -43,8 +80,10 @@ impl PullerSpeedController {
             enabled: false,
             target_speed,
             target_diameter,
+            measured_diameter: Length::ZERO,
             regulation_mode: PullerRegulationMode::Speed,
             forward: true,
+            gear_ratio: GearRatio::default(),
             acceleration_controller: LinearJerkSpeedController::new_simple(
                 Some(speed),
                 acceleration,
@@ -52,6 +91,11 @@ impl PullerSpeedController {
             ),
             converter,
             last_speed: Velocity::ZERO,
+            p_dead_controller: TimeAgnosticDeadTimePiController::new(
+                0.1 / 10000.0,
+                0.0,
+                Duration::ZERO,
+            ),
         }
     }
 
@@ -67,6 +111,10 @@ impl PullerSpeedController {
         self.target_diameter = target;
     }
 
+    pub fn set_measured_diameter(&mut self, target: f64) {
+        self.measured_diameter = Length::new::<millimeter>(target);
+    }
+
     pub const fn set_regulation_mode(&mut self, regulation: PullerRegulationMode) {
         self.regulation_mode = regulation;
     }
@@ -75,15 +123,41 @@ impl PullerSpeedController {
         self.forward = forward;
     }
 
+    pub const fn set_gear_ratio(&mut self, gear_ratio: GearRatio) {
+        self.gear_ratio = gear_ratio;
+    }
+
+    pub const fn get_gear_ratio(&self) -> GearRatio {
+        self.gear_ratio
+    }
+
     fn update_speed(&mut self, t: Instant) -> Velocity {
-        let speed = match self.enabled {
-            true => match self.regulation_mode {
-                PullerRegulationMode::Speed => self.target_speed,
-                PullerRegulationMode::Diameter => unimplemented!(),
-            },
-            false => Velocity::ZERO,
+        if !self.enabled {
+            return Velocity::ZERO;
+        }
+
+        let base_speed = match self.regulation_mode {
+            PullerRegulationMode::Speed => {
+                let directional_target = if self.forward {
+                    self.target_speed
+                } else {
+                    -self.target_speed
+                };
+                self.acceleration_controller.update(directional_target, t)
+            }
+            PullerRegulationMode::Diameter => {
+                let diameter_speed = self.speed_from_diameter(t);
+                if self.forward {
+                    diameter_speed
+                } else {
+                    -diameter_speed
+                }
+            }
         };
 
+        // Apply gear ratio multiplier
+        let speed = base_speed * self.gear_ratio.multiplier();
+
         let speed = if self.forward { speed } else { -speed };
 
         let speed = self.acceleration_controller.update(speed, t);
@@ -92,6 +166,49 @@ impl PullerSpeedController {
         speed
     }
 
+    fn speed_from_diameter(&mut self, now: Instant) -> Velocity {
+        // get current error
+        let error =
+            self.measured_diameter.get::<millimeter>() - self.target_diameter.get::<millimeter>();
+
+        // calculate/set deadtime based of speed and distance
+        let deadtime = Self::calc_deadtime(self.last_speed, Length::new::<meter>(2.0));
+        self.p_dead_controller.set_dead(deadtime);
+
+        // get speed change from p controller
+        let speed_change = self.p_dead_controller.update(error, now);
+
+        // apply speed change to target speed
+        let next_speed = self.last_speed + Velocity::new::<meter_per_minute>(speed_change);
+
+        // clamp the speed to 0 - 50 for safety
+        Self::clamp_speed(
+            next_speed,
+            Velocity::new::<meter_per_minute>(0.0),
+            Velocity::new::<meter_per_minute>(50.0),
+        )
+    }
+
+    fn calc_deadtime(speed: Velocity, distance: Length) -> Duration {
+        // check if speed is 0 => This should not happen
+        if speed <= Velocity::ZERO {
+            return Duration::from_secs(180);
+        }
+        // get the duration based of distance and speed
+        let secs = (distance / speed).get::<second>().max(0.0);
+        Duration::from_secs_f64(secs)
+    }
+
+    fn clamp_speed(speed: Velocity, min: Velocity, max: Velocity) -> Velocity {
+        if speed < min {
+            min
+        } else if speed > max {
+            max
+        } else {
+            speed
+        }
+    }
+
     pub fn speed_to_angular_velocity(&self, speed: Velocity) -> AngularVelocity {
         // Use the converter to transform from linear velocity to angular velocity
         self.converter.velocity_to_angular_velocity(speed)
@@ -112,8 +229,9 @@ impl PullerSpeedController {
     }
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone, Default)]
 pub enum PullerRegulationMode {
+    #[default]
     Speed,
     Diameter,
 }

server/src/machines/winder2/spool_speed_controller.rs

@@ -10,8 +10,9 @@ use serde::{Deserialize, Serialize};
 use std::time::Instant;
 use uom::si::f64::AngularVelocity;
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub enum SpoolSpeedControllerType {
+    #[default]
     Adaptive,
     MinMax,
 }
@@ -21,6 +22,7 @@ pub struct SpoolSpeedController {
     adaptive_controller: AdaptiveSpoolSpeedController,
     minmax_controller: MinMaxSpoolSpeedController,
     r#type: SpoolSpeedControllerType,
+    forward: bool,
 }
 
 impl Default for SpoolSpeedController {
@@ -35,6 +37,7 @@ impl SpoolSpeedController {
             adaptive_controller: AdaptiveSpoolSpeedController::new(),
             minmax_controller: MinMaxSpoolSpeedController::new(),
             r#type: SpoolSpeedControllerType::Adaptive,
+            forward: true,
         }
     }
 
@@ -180,4 +183,12 @@ impl SpoolSpeedController {
         self.adaptive_controller
             .set_deacceleration_urgency_multiplier(deacceleration_urgency_multiplier);
     }
+
+    pub const fn get_forward(&self) -> bool {
+        self.forward
+    }
+
+    pub const fn set_forward(&mut self, forward: bool) {
+        self.forward = forward;
+    }
 }

server/src/main.rs

@@ -1,129 +1,71 @@
-#[cfg(all(not(target_env = "msvc"), not(feature = "dhat-heap")))]
-use tikv_jemallocator::Jemalloc;
-
-#[cfg(all(not(target_env = "msvc"), not(feature = "dhat-heap")))]
-#[global_allocator]
-static GLOBAL: Jemalloc = Jemalloc;
-
-#[cfg(feature = "dhat-heap")]
-#[global_allocator]
-static ALLOC: dhat::Alloc = dhat::Alloc;
-
-use app_state::AppState;
+use futures::{FutureExt, select};
 #[cfg(feature = "mock-machine")]
 use mock::init::init_mock;
-use std::{sync::Arc, time::Duration};
 
-use r#loop::init_loop;
-use rest::init::init_api;
-#[cfg(not(feature = "mock-machine"))]
-use serial::init::init_serial;
-
-#[cfg(all(not(target_env = "msvc"), not(feature = "dhat-heap")))]
-use jemalloc_stats::init_jemalloc_stats;
-
-#[cfg(not(feature = "mock-machine"))]
-use crate::ethercat::init::init_ethercat;
-use crate::panic::init_panic;
-use crate::socketio::queue::init_socketio_queue;
+#[cfg(feature = "mock-machine")]
+pub mod mock;
 
+use crate::panic::init_panic_handling;
+use app_state::AppState;
+use ethercat::{
+    ethercat_discovery_info::{send_ethercat_discovering, send_ethercat_found},
+    init::start_interface_discovery,
+};
+use r#loop::start_loop_thread;
+use rest::init::start_api_thread;
+use serial::init::{handle_serial_device_hotplug, start_serial_discovery};
+use socketio::queue::start_socketio_queue;
+use std::sync::Arc;
 pub mod app_state;
 pub mod ethercat;
 pub mod logging;
 pub mod r#loop;
 pub mod machines;
-#[cfg(feature = "mock-machine")]
-pub mod mock;
 pub mod panic;
 pub mod performance_metrics;
 pub mod rest;
 pub mod serial;
 pub mod socketio;
 
-#[cfg(all(not(target_env = "msvc"), not(feature = "dhat-heap")))]
-pub mod jemalloc_stats;
-
 fn main() {
-    // Initialize panic handling
-    let thread_panic_tx = init_panic();
     logging::init_tracing();
     tracing::info!("Tracing initialized successfully");
-
-    // lock memory (not working thus commented out)
-    // if let Err(e) = lock_memory() {
-    //     tracing::error!("[{}::main] Failed to lock memory: {:?}", module_path!(), e);
-    // } else {
-    //     tracing::info!("[{}::main] Memory locked successfully", module_path!());
-    // }
-
-    #[cfg(all(not(target_env = "msvc"), not(feature = "dhat-heap")))]
-    init_jemalloc_stats();
+    init_panic_handling();
 
     let app_state = Arc::new(AppState::new());
 
-    // Spawn init thread
-    let init_thread = std::thread::Builder::new()
-        .name("init".to_string())
-        .spawn({
-            let thread_panic_tx = thread_panic_tx;
-            let app_state = app_state;
-            move || {
-                #[cfg(feature = "dhat-heap")]
-                init_dhat_heap_profiling();
+    let _ = start_api_thread(app_state.clone());
+    let mut socketio_fut = start_socketio_queue(app_state.clone()).fuse();
+    let mut ethercat_fut = start_interface_discovery().fuse();
+    let mut serial_fut = start_serial_discovery().fuse();
 
-                init_socketio_queue(thread_panic_tx.clone(), app_state.clone());
-                init_api(thread_panic_tx.clone(), app_state.clone())
-                    .expect("Failed to initialize API");
-                init_loop(thread_panic_tx.clone(), app_state.clone())
-                    .expect("Failed to initialize loop");
-
-                #[cfg(feature = "mock-machine")]
-                init_mock(app_state.clone()).expect("Failed to initialize mock machines");
-
-                #[cfg(not(feature = "mock-machine"))]
-                init_serial(thread_panic_tx.clone(), app_state.clone())
-                    .expect("Failed to initialize Serial");
-
-                #[cfg(not(feature = "mock-machine"))]
-                init_ethercat(thread_panic_tx.clone(), app_state)
-                    .expect("Failed to initialize EtherCAT");
-            }
-        })
-        .expect("Failed to spawn init thread");
-
-    // Wait for init thread to complete
-    init_thread.join().expect("Init thread panicked");
-
-    // Keep the main thread alive indefinitely
-    // The program should only exit via panic handling or external signals
-    loop {
-        std::thread::sleep(Duration::from_secs(u64::MAX));
-    }
-}
-
-#[cfg(feature = "dhat-heap")]
-fn init_dhat_heap_profiling() {
-    use std::{process::exit, time::Duration};
-
-    let profiler = dhat::Profiler::new_heap();
+    smol::block_on(async { send_ethercat_discovering(app_state.clone()).await });
 
     smol::block_on(async {
-        let dhat_analysis_time = std::time::Duration::from_secs(60);
-        let dhat_analysis_start = std::time::Instant::now();
-        tracing::info!(
-            "Starting dhat heap profiler for {} seconds",
-            dhat_analysis_time.as_secs()
-        );
-
         loop {
-            use std::time::Duration;
-            smol::Timer::after(Duration::from_secs(1)).await;
+            // lets the async runtime decide which future to run next
+            select! {
+                res = ethercat_fut => {
+                    tracing::info!("EtherCAT task finished: {:?}", res);
+                    match res {
+                        Ok(interface) =>
+                        {
+                            send_ethercat_found(app_state.clone(), &interface).await;
+                            let _ = start_loop_thread(&interface, app_state.clone());
+                        },
+                        Err(_) => (),
+                    };
 
-            // if `dhat-heap` is enabled, we will analyze the heap for 60 seconds and then exit
-            if dhat_analysis_start.elapsed() > dhat_analysis_time {
-                drop(profiler);
-                exit(0)
+                },
+                res = serial_fut => {
+                    let _ = handle_serial_device_hotplug(app_state.clone(),res).await;
+                    serial_fut = start_serial_discovery().fuse();
+                },
+                res = socketio_fut => {
+                    // In theory it should never finish
+                    tracing::warn!("SocketIO task finished: {:?}", res);
+                },
             }
         }
-    })
+    });
 }

server/src/mock/init.rs

@@ -1,5 +1,6 @@
 #[cfg(feature = "mock-machine")]
 use crate::serial::devices::extruder_mock::ExtruderMockSerialDevice;
+use crate::serial::devices::winder_mock::WinderMockSerialDevice;
 #[cfg(feature = "mock-machine")]
 use {
     crate::app_state::AppState,
@@ -12,16 +13,15 @@ use {
     },
     std::sync::Arc,
 };
+
 #[cfg(feature = "mock-machine")]
 pub fn init_mock(app_state: Arc<AppState>) -> Result<(), anyhow::Error> {
     // For mock devices, we need to manually create and add them to the machine manager
     // since they won't be detected by the serial detection loop
     return smol::block_on(async {
         // Create a mock serial device manually
-        let (device_thread_panic_tx, _device_thread_panic_rx) = smol::channel::unbounded();
         let serial_params = SerialDeviceNewParams {
             path: "/dev/mock-serial".to_string(),
-            device_thread_panic_tx,
         };
 
         // Create the mock serial device
@@ -57,7 +57,39 @@ pub fn init_mock(app_state: Arc<AppState>) -> Result<(), anyhow::Error> {
             }
         };
 
-        match ExtruderMockSerialDevice::new_serial(&serial_params) {
+        let _ = match ExtruderMockSerialDevice::new_serial(&serial_params) {
+            Ok((device_identification, mock_serial_device)) => {
+                // Add the mock device to the machine manager
+                {
+                    let mut machine_guard = app_state.machines.write().await;
+                    machine_guard.add_serial_device(
+                        &device_identification,
+                        mock_serial_device,
+                        &MACHINE_REGISTRY,
+                        app_state.socketio_setup.socket_queue_tx.clone(),
+                        Arc::downgrade(&app_state.machines),
+                    );
+                }
+
+                // Notify clients via socketio about the new machine
+                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));
+                Ok::<(), anyhow::Error>(())
+            }
+            Err(e) => {
+                tracing::error!("Failed to create extruder mock serial device: {}", e);
+                return Err(e);
+            }
+        };
+
+        match WinderMockSerialDevice::new_serial(&serial_params) {
             Ok((device_identification, mock_serial_device)) => {
                 // Add the mock device to the machine manager
                 {

server/src/panic.rs

@@ -1,173 +1,43 @@
-use smol::channel::{Sender, unbounded};
-use std::process::exit;
-use tracing::error;
+use std::{backtrace::Backtrace, panic::PanicHookInfo, thread};
 
-#[derive(Debug, Clone)]
-pub struct PanicDetails {
-    pub thread_name: Option<String>,
-    pub message: Option<String>,
-    pub location: Option<PanicDetailsLocation>,
-    pub backtrace: String,
-}
+fn panic_hook(panic_info: &PanicHookInfo) {
+    let backtrace = Backtrace::capture().to_string();
 
-#[derive(Clone, Debug)]
-pub struct PanicDetailsLocation {
-    pub file: String,
-    pub line: u32,
-    pub column: u32,
-}
+    let thread = thread::current();
+    let thread = thread.name().unwrap_or("<unknown>");
+    let locataion = panic_info
+        .location()
+        .map_or_else(|| "<unknown>".to_string(), ToString::to_string);
 
-impl std::fmt::Display for PanicDetailsLocation {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}:{}:{}", self.file, self.line, self.column)
-    }
-}
+    let message = panic_info
+        .payload()
+        .downcast_ref::<String>()
+        .cloned()
+        .or_else(|| {
+            panic_info
+                .payload()
+                .downcast_ref::<&str>()
+                .map(ToString::to_string)
+        })
+        .unwrap_or_else(|| "<unknown>".to_string());
 
-impl From<&std::panic::Location<'_>> for PanicDetailsLocation {
-    fn from(location: &std::panic::Location<'_>) -> Self {
-        Self {
-            file: location.file().to_string(),
-            line: location.line(),
-            column: location.column(),
-        }
-    }
-}
+    tracing::error!("thread '{}' panicked at {}:", thread, locataion);
+    eprintln!("{}\n", message);
+    eprintln!("Backtrace:\n{}", backtrace);
 
-impl std::fmt::Display for PanicDetails {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let fmt_thread_name = match &self.thread_name {
-            Some(name) => format!("'{}'", name),
-            None => "<unknown>".to_string(),
-        };
-
-        let fmt_message = match &self.message {
-            Some(message) => format!("'{}'", message),
-            None => "<no message>".to_string(),
-        };
-
-        let fmt_location = match &self.location {
-            Some(location) => location.to_string(),
-            None => "<no location>".to_string(),
-        };
-
-        // Apply syntax highlighting to backtrace
-        let highlighted_backtrace = self.highlight_backtrace();
-
-        write!(
-            f,
-            "thread {} panicked at {}, {}\n{}",
-            fmt_thread_name, fmt_message, fmt_location, highlighted_backtrace
-        )
-    }
-}
-
-impl PanicDetails {
-    /// Highlights backtrace lines that contain server or control-core crate references
-    /// and the line immediately following them
-    fn highlight_backtrace(&self) -> String {
-        use regex::Regex;
-
-        // Regex to match lines starting with digits followed by colon
-        let line_regex = Regex::new(r"^\s*(\d+):\s*(.*)$").unwrap();
-
-        let lines: Vec<&str> = self.backtrace.lines().collect();
-        let mut result = Vec::new();
-        let mut highlight_next = false;
-
-        for line in lines.iter() {
-            if let Some(captures) = line_regex.captures(line) {
-                let line_num = &captures[1];
-                let content = &captures[2];
-
-                // Check if the line contains server or control-core
-                if content.contains("server") || content.contains("control-core") {
-                    // Red highlighting for relevant lines
-                    result.push(format!("\x1b[91m{}: {}\x1b[0m", line_num, content));
-                    highlight_next = true;
-                } else {
-                    // Dim gray for other numbered lines
-                    result.push(format!("\x1b[90m{}: {}\x1b[0m", line_num, content));
-                }
-            } else {
-                // Non-numbered lines (headers, location info, etc.)
-                if highlight_next {
-                    // Highlight the line after a matched regex line in yellow
-                    result.push(format!("\x1b[93m{}\x1b[0m", line));
-                    highlight_next = false;
-                } else {
-                    // Default color for other non-numbered lines
-                    result.push(line.to_string());
-                }
-            }
-        }
-
-        result.join("\n")
-    }
-}
-
-/// Thread-level panic handler for general thread crashes
-/// Sends detailed panic information including backtrace
-pub fn send_panic(thread_panic_tx: Sender<PanicDetails>) {
-    // 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| {
-        // Capture backtrace at panic site
-        let backtrace = std::backtrace::Backtrace::force_capture();
-
-        let thread_name = std::thread::current().name().map(|name| name.to_string());
-
-        let message = if let Some(s) = panic_info.payload().downcast_ref::<&str>() {
-            Some(s.to_string())
-        } else {
-            panic_info.payload().downcast_ref::<String>().cloned()
-        };
-
-        let panic_details = PanicDetails {
-            thread_name,
-            message,
-            location: panic_info.location().map(|loc| loc.into()),
-            backtrace: backtrace.to_string(),
-        };
-
-        // Send detailed panic info through channel
-        let _ = smol::block_on(thread_panic_tx.send(panic_details));
-    }));
+    std::process::exit(1);
 }
 
 /// Initialize panic handling system
 /// Sets up panic handler and starts dedicated panic monitoring thread
-pub fn init_panic() -> Sender<PanicDetails> {
-    let (thread_panic_tx, thread_panic_rx) = unbounded::<PanicDetails>();
-    send_panic(thread_panic_tx.clone());
+pub fn init_panic_handling() {
+    // Ensure backtrace is enabled for panics
+    if std::env::var("RUST_BACKTRACE").is_err() {
+        unsafe {
+            std::env::set_var("RUST_BACKTRACE", "full");
+            std::env::set_var("RUST_LIB_BACKTRACE", "1");
+        }
+    }
 
-    // Start panic monitoring thread
-    let thread_panic_rx_clone = thread_panic_rx;
-    std::thread::Builder::new()
-        .name("panic".to_string())
-        .spawn(move || {
-            // Create an executor for this thread
-            let rt = smol::Executor::new();
-            smol::block_on(rt.run(async {
-                loop {
-                    match thread_panic_rx_clone.recv().await {
-                        Ok(panic_details) => {
-                            error!("{}", panic_details);
-                            exit(1);
-                        }
-                        Err(_) => {
-                            // Channel closed, exit gracefully
-                            break;
-                        }
-                    }
-                }
-            }))
-        })
-        .expect("Failed to spawn panic monitoring thread");
-
-    thread_panic_tx
+    std::panic::set_hook(Box::new(panic_hook));
 }

server/src/performance_metrics.rs

@@ -10,8 +10,8 @@ const METRICS_LOG_INTERVAL_SECS: u64 = 30; // Log every 30 seconds
 pub struct EthercatPerformanceMetrics {
     txrx_times: VecDeque<Duration>,
     loop_times: VecDeque<Duration>,
-    last_loop_start: Option<Instant>,
-    last_log_time: Instant,
+    pub last_loop_start: Option<Instant>,
+    pub last_log_time: Instant,
 }
 
 impl Default for EthercatPerformanceMetrics {

server/src/rest/init.rs

@@ -1,72 +1,57 @@
-use super::handlers::machine_mutation::post_machine_mutate;
-use super::handlers::write_machine_device_identification::post_write_machine_device_identification;
-use crate::app_state::AppState;
-use crate::panic::{PanicDetails, send_panic};
-use crate::socketio::init::init_socketio;
-use anyhow::anyhow;
+use anyhow::Result;
 use axum::routing::post;
-use smol::channel::Sender;
 use std::sync::Arc;
-use std::thread::JoinHandle;
+use std::thread;
 use tower_http::cors::CorsLayer;
 use tower_http::trace::{DefaultMakeSpan, DefaultOnRequest, DefaultOnResponse, TraceLayer};
 use tracing::Level;
 
-pub fn init_api(
-    thread_panic_tx: Sender<PanicDetails>,
-    app_state: Arc<AppState>,
-) -> Result<JoinHandle<()>, anyhow::Error> {
-    std::thread::Builder::new()
-        .name("api".to_string())
-        .spawn(|| {
-            send_panic(thread_panic_tx);
+use super::handlers::machine_mutation::post_machine_mutate;
+use super::handlers::write_machine_device_identification::post_write_machine_device_identification;
+use crate::app_state::AppState;
+use crate::socketio::init::init_socketio;
 
-            let rt = tokio::runtime::Builder::new_current_thread()
-                .enable_io()
-                .enable_time()
-                .build()
-                .expect("Failed to create runtime");
+async fn init_api(app_state: Arc<AppState>) -> Result<()> {
+    let cors = CorsLayer::permissive();
+    let socketio_layer = init_socketio(&app_state).await;
 
-            rt.block_on(async {
-                // allow all CORS requests
-                let cors = CorsLayer::permissive();
+    let trace_layer = TraceLayer::new_for_http()
+        .make_span_with(DefaultMakeSpan::new().level(Level::DEBUG))
+        .on_request(DefaultOnRequest::new().level(Level::TRACE))
+        .on_response(DefaultOnResponse::new().level(Level::TRACE));
 
-                // creat socketio layer
-                let socketio_layer = init_socketio(&app_state).await;
+    let app = axum::Router::new()
+        .route(
+            "/api/v1/write_machine_device_identification",
+            post(post_write_machine_device_identification),
+        )
+        .route("/api/v1/machine/mutate", post(post_machine_mutate))
+        .layer(socketio_layer)
+        .layer(cors)
+        .layer(trace_layer)
+        .with_state(app_state);
 
-                // Create a more detailed trace layer for HTTP requests
-                let trace_layer = TraceLayer::new_for_http()
-                    .make_span_with(
-                        DefaultMakeSpan::new()
-                            .level(Level::DEBUG)
-                            .include_headers(false),
-                    )
-                    .on_request(DefaultOnRequest::new().level(Level::TRACE))
-                    .on_response(
-                        DefaultOnResponse::new()
-                            .level(Level::TRACE)
-                            .include_headers(false),
-                    );
+    let listener = tokio::net::TcpListener::bind("0.0.0.0:3001")
+        .await
+        .expect("Failed to bind to port 3001");
 
-                // make axum server to serve the data on /ethercat
-                let app = axum::Router::new()
-                    .route(
-                        "/api/v1/write_machine_device_identification",
-                        post(post_write_machine_device_identification),
-                    )
-                    .route("/api/v1/machine/mutate", post(post_machine_mutate))
-                    .layer(socketio_layer)
-                    .layer(cors)
-                    .layer(trace_layer)
-                    .with_state(app_state);
+    tracing::info!("HTTP server running on 0.0.0.0:3001");
 
-                let listener = tokio::net::TcpListener::bind("0.0.0.0:3001")
-                    .await
-                    .expect("Failed to bind to port 3001");
+    axum::serve(listener, app)
+        .await
+        .map_err(|e| anyhow::anyhow!("Server error: {}", e))
+}
 
-                tracing::info!("Starting HTTP server on 0.0.0.0:3001");
-                axum::serve(listener, app).await.expect("Failed to serve");
-            });
-        })
-        .map_err(|e| anyhow!("Failed to spawn API thread: {}", e))
+/// Starts the API server in its own thread with a single-threaded Tokio runtime
+pub fn start_api_thread(app_state: Arc<AppState>) -> std::thread::JoinHandle<()> {
+    thread::spawn(move || {
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .expect("Failed to create Tokio runtime");
+
+        if let Err(err) = rt.block_on(init_api(app_state)) {
+            eprintln!("API server exited with error: {err:?}");
+        }
+    })
 }

server/src/serial/devices/laser/mod.rs

@@ -17,10 +17,7 @@ use control_core::{
         DeviceMachineIdentification, MachineIdentification, MachineIdentificationUnique,
     },
     modbus::{self, ModbusRequest, ModbusResponse},
-    serial::{
-        SerialDevice, SerialDeviceNew, SerialDeviceNewParams, panic::send_serial_device_panic,
-        serial_detection::SerialDeviceRemoval,
-    },
+    serial::{SerialDevice, SerialDeviceNew, SerialDeviceNewParams},
 };
 use serialport::SerialPort;
 use serialport::{ClearBuffer, DataBits, FlowControl, Parity, StopBits};
@@ -125,27 +122,13 @@ impl SerialDeviceNew for Laser {
             path: params.path.clone(),
         }));
 
-        // Spawn the device thread
-        let device_thread_panic_tx = params.device_thread_panic_tx.clone();
+        //// Spawn the device thread
         let _self_clone = _self.clone();
-        let path = params.path.clone();
         thread::Builder::new()
             .name("laser".to_owned())
             .spawn(move || {
-                send_serial_device_panic(path.clone(), device_thread_panic_tx.clone());
                 smol::block_on(async {
-                    let process_result = Self::process(_self_clone).await;
-
-                    let removal = match process_result {
-                        Ok(_) => SerialDeviceRemoval::Disconnect(path),
-                        Err(e) => SerialDeviceRemoval::Error(path, e),
-                    };
-
-                    // if the task exists we want to remove the device
-                    device_thread_panic_tx
-                        .send(removal)
-                        .await
-                        .expect("Failed to send device removal signal");
+                    let _ = Self::process(_self_clone).await;
                 });
             })?;
 

server/src/serial/devices/mod.rs

@@ -3,3 +3,5 @@ pub mod extruder_mock;
 pub mod laser;
 #[cfg(feature = "mock-machine")]
 pub mod mock;
+#[cfg(feature = "mock-machine")]
+pub mod winder_mock;

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

@@ -0,0 +1,59 @@
+use std::sync::Arc;
+
+use control_core::{
+    helpers::hashing::{byte_folding_u16, hash_djb2},
+    machines::identification::{
+        DeviceHardwareIdentification, DeviceHardwareIdentificationSerial, DeviceIdentification,
+        DeviceMachineIdentification, MachineIdentification, MachineIdentificationUnique,
+    },
+    serial::{SerialDevice, SerialDeviceNew, SerialDeviceNewParams},
+};
+use smol::lock::RwLock;
+
+use crate::machines::{MACHINE_WINDER_V1, VENDOR_QITECH};
+
+/// 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))
+    }
+}

server/src/serial/init.rs

@@ -1,83 +1,139 @@
-use crate::panic::{PanicDetails, send_panic};
-use crate::socketio::main_namespace::MainNamespaceEvents;
-use crate::socketio::main_namespace::machines_event::MachinesEventBuilder;
-use crate::{app_state::AppState, machines::registry::MACHINE_REGISTRY};
-use control_core::socketio::namespace::NamespaceCacheingLogic;
-use smol::channel::Sender;
-use std::{sync::Arc, thread, time::Duration};
+use control_core::{
+    machines::identification::MachineIdentificationUnique,
+    serial::{
+        SerialDeviceIdentification, SerialDeviceNew, SerialDeviceNewParams,
+        serial_detection::SerialDetection,
+    },
+    socketio::namespace::NamespaceCacheingLogic,
+};
+use serialport::UsbPortInfo;
+use smol::Task;
+use std::{collections::HashMap, sync::Arc, time::Duration};
 
-pub fn init_serial(
-    thread_panic_tx: Sender<PanicDetails>,
-    app_state: Arc<AppState>,
-) -> Result<(), anyhow::Error> {
-    let thread_panic_tx_clone = thread_panic_tx;
+use crate::{
+    app_state::AppState,
+    machines::{laser::LaserMachine, registry::MACHINE_REGISTRY},
+    socketio::main_namespace::{MainNamespaceEvents, machines_event::MachinesEventBuilder},
+};
 
-    let app_state_clone = app_state.clone();
+use super::devices::laser::Laser;
 
-    thread::Builder::new()
-        .name("SerialDetectionThread".to_owned())
-        .spawn(move || {
-            let app_state_clone = app_state_clone;
-            smol::block_on(async move {
-                send_panic(thread_panic_tx_clone);
+// 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;
+    }
+}
 
-                let rt = smol::LocalExecutor::new();
-                rt.run(async {
-                    loop {
-                        let result = {
-                            let mut serial_setup_guard = app_state_clone.serial_setup.write().await;
+// 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())
+}
 
-                            let mut port_result =
-                                serial_setup_guard.serial_detection.check_ports().await;
+// This function handles a disconnection and or reconnection of Laser
+// You can easily rewrite it when we have more serialdevices
+// TODO: Add A static list of known SeriadeviceIdents
+pub async fn handle_serial_device_hotplug(
+    app_state: Arc<AppState>,
+    map: Option<HashMap<String, UsbPortInfo>>,
+) {
+    let laser_ident = SerialDeviceIdentification {
+        vendor_id: 0x0403,
+        product_id: 0x6001,
+    };
 
-                            let mut removed_signals = serial_setup_guard
-                                .serial_detection
-                                .check_remove_signals()
-                                .await;
+    let laser = match map {
+        Some(map) => SerialDetection::get_path_by_id(laser_ident, map),
+        None => None,
+    };
 
-                            port_result.removed.append(&mut removed_signals);
+    let mut unique_ident: Option<MachineIdentificationUnique> = None;
 
-                            port_result
-                        };
+    {
+        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;
+            }
+        }
+    }
 
-                        if !result.added.is_empty() || !result.removed.is_empty() {
-                            // sync serial device discovery to machine manager
-                            {
-                                let mut machine_guard = app_state_clone.machines.write().await;
-                                // turn added devices into machines
-                                for (device_identifiaction, device) in result.added {
-                                    machine_guard.add_serial_device(
-                                        &device_identifiaction,
-                                        device.clone(),
-                                        &MACHINE_REGISTRY,
-                                        app_state_clone.socketio_setup.socket_queue_tx.clone(),
-                                        Arc::downgrade(&app_state.machines),
-                                    )
-                                }
-                                for device_identification in result.removed {
-                                    machine_guard.remove_serial_device(&device_identification)
-                                }
-                            }
+    // 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),
+                    );
+                }
 
-                            // Notify client via socketio
-                            let app_state_event = app_state.clone();
-                            smol::block_on(async {
-                                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));
-                            });
-                        }
-                        smol::Timer::after(Duration::from_millis(300)).await;
-                    }
-                })
-                .await;
-            });
-        })
-        .expect("Failed to spawn SerialTxRxThread");
-    Ok(())
+                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));
+            }
+            _ => (),
+        };
+    }
 }