further improved readability by moving feature flags to mod.rs

when selecting mock-machine feature extruder now appears as well
rewrote extruder and winder, also added mock-machine for extruder
2025-09-29 11:30:54 +02:00 · 2025-09-29 11:30:54 +02:00 · 2025-09-29 11:30:54 +02:00 · 2025-09-29 11:30:54 +02:00 · 2025-09-29 11:30:19 +02:00 · 2025-09-25 17:11:18 +02:00
36 changed files with 1871 additions and 1112 deletions
@@ -1678,15 +1678,6 @@ dependencies = [
 "serde",
 ]

-[[package]]
-name = "is-docker"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "928bae27f42bc99b60d9ac7334e3a21d10ad8f1835a4e12ec3ec0464765ed1b3"
-dependencies = [
- "once_cell",
-]
-
 [[package]]
 name = "is-terminal"
 version = "0.4.16"
@@ -1698,16 +1689,6 @@ dependencies = [
 "windows-sys 0.59.0",
 ]

-[[package]]
-name = "is-wsl"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "173609498df190136aa7dea1a91db051746d339e18476eed5ca40521f02d7aa5"
-dependencies = [
- "is-docker",
- "once_cell",
-]
-
 [[package]]
 name = "is_terminal_polyfill"
 version = "1.70.1"
@@ -2001,17 +1982,6 @@ version = "11.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"

-[[package]]
-name = "open"
-version = "5.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2483562e62ea94312f3576a7aca397306df7990b8d89033e18766744377ef95"
-dependencies = [
- "is-wsl",
- "libc",
- "pathdiff",
-]
-
 [[package]]
 name = "opentelemetry"
 version = "0.30.0"
@@ -2121,12 +2091,6 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"

-[[package]]
-name = "pathdiff"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
-
 [[package]]
 name = "pcap"
 version = "2.2.0"
@@ -2699,14 +2663,12 @@ dependencies = [
 "bitvec",
 "control_core",
 "control_core_derive",
- "crc",
 "dhat",
 "ethercat_hal",
 "ethercrab",
 "euclid",
 "futures",
 "lazy_static",
- "open",
 "opentelemetry",
 "opentelemetry-otlp",
 "opentelemetry_sdk",
@@ -2717,7 +2679,6 @@ dependencies = [
 "smol",
 "socketioxide",
 "textplots",
- "thread-priority",
 "tikv-jemalloc-ctl",
 "tikv-jemallocator",
 "tokio",
@@ -3032,20 +2993,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3bf63baf9f5039dadc247375c29eb13706706cfde997d0330d05aa63a77d8820"

-[[package]]
-name = "thread-priority"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd4ef372b29fbcc6cb0cef97bcbf3ffa9da90e02eb23dbf14db48ce30d11d2d5"
-dependencies = [
- "bitflags 2.9.0",
- "cfg-if",
- "libc",
- "log",
- "rustversion",
- "windows",
-]
-
 [[package]]
 name = "thread_local"
 version = "1.1.8"
@@ -3659,28 +3606,6 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

-[[package]]
-name = "windows"
-version = "0.61.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
-dependencies = [
- "windows-collections",
- "windows-core",
- "windows-future",
- "windows-link",
- "windows-numerics",
-]
-
-[[package]]
-name = "windows-collections"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
-dependencies = [
- "windows-core",
-]
-
 [[package]]
 name = "windows-core"
 version = "0.61.2"
@@ -3694,17 +3619,6 @@ dependencies = [
 "windows-strings 0.4.2",
 ]

-[[package]]
-name = "windows-future"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
-dependencies = [
- "windows-core",
- "windows-link",
- "windows-threading",
-]
-
 [[package]]
 name = "windows-implement"
 version = "0.60.0"
@@ -3733,16 +3647,6 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"

-[[package]]
-name = "windows-numerics"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
-dependencies = [
- "windows-core",
- "windows-link",
-]
-
 [[package]]
 name = "windows-registry"
 version = "0.4.0"
@@ -3844,15 +3748,6 @@ dependencies = [
 "windows_x86_64_msvc 0.53.0",
 ]

-[[package]]
-name = "windows-threading"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
-dependencies = [
- "windows-link",
-]
-
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.6"
@@ -8,7 +8,9 @@ workspace = true

 [dependencies]
 anyhow = "1.0.99"
+
 axum = "0.8.4"
+
 ethercat_hal = { path = "../ethercat-hal" }
 ethercrab = "0.6"
 interfaces = "0.0.9"
@@ -40,3 +42,6 @@ tokio = { version = "1.45.1", features = ["rt-multi-thread", "macros", "time"] }
 [features]
 default = []
 video-streaming = ["dep:tokio"]
+
+[package.metadata.cargo-machete]
+ignored =  ["axum","bitvec","control_core_derive"]
@@ -30,7 +30,7 @@ impl MachineRegistry {
        self.type_map.insert(
            TypeId::of::<T>(),
            (
-                machine_identficiation,
+                machine_identficiation.clone(),
                // create a machine construction closure
                Box::new(|machine_new_params| {
                    Ok(Arc::new(Mutex::new(T::new(machine_new_params)?)))
@@ -0,0 +1,145 @@
+# How can I add a new Machine?
+
+Adding a new machine follows a common structure in `server/machines/`.
+
+
+
+# TLDR
+
+Summary
+
+When adding a new machine:
+
+- Create Folder server/machines/YOUR_MACHINE_NAME/.
+- Add the 4 files (mod.rs, new.rs, act.rs, api.rs).
+- Register it in machines/mod.rs with a unique constant.
+- mod.rs: define the struct + emit functions.
+- new.rs: assemble devices/controllers into the machine.
+- act.rs: implement the machine loop (MachineAct).
+- api.rs: define request (mutations) and response (events) types.
+
+Tip: Start simple (copy MockMachine) and grow complexity as needed (add EtherCAT devices, controllers, etc.).
+
+---
+
+## 1. Create the folder
+
+Create a new directory:
+server/machines/YOUR_MACHINE_NAME
+
+At a minimum, this folder needs the following files:
+
+- `mod.rs`
+- `new.rs`
+- `act.rs`
+- `api.rs`
+
+---
+
+## 2. Register the module
+
+Add your machine to `server/machines/mod.rs`:
+
+```rust
+// mod.rs
+pub mod buffer1;
+pub mod extruder1;
+pub mod laser;
+pub mod mock;
+pub mod registry;
+pub mod winder2;
+pub mod YOUR_MACHINE;
+
+pub const VENDOR_QITECH: u16 = 0x0001;
+pub const MACHINE_WINDER_V1: u16 = 0x0002;
+pub const MACHINE_EXTRUDER_V1: u16 = 0x0004;
+pub const MACHINE_LASER_V1: u16 = 0x0006;
+pub const MACHINE_MOCK: u16 = 0x0007;
+pub const MACHINE_BUFFER_V1: u16 = 0x0008;
+pub const YOUR_MACHINE_V1: u16 = 0xffff; // pick a unique ID to avoid collisions also DO NOT touch any already defined ids!!
+```
+
+## 3. mod.rs
+
+This file defines your machine struct and the required event emitters.
+
+Look at MockMachine’s mod.rs for the simplest possible version.
+
+At a minimum, you need:
+- emit_state
+- emit_live_values
+- A machine struct for state(e.g. MockMachine, Extruder, Laser, Winder, …)
+
+More complex machines (e.g. Extruder, Winder) encapsulate controllers that in turn manage devices like EtherCAT terminals.
+
+## 4 new.rs
+
+This file implements MachineNewTrait for your machine.
+Here you assemble your machine from its parts — devices, controllers, and any state.
+
+Minimal example: see MockMachine → basically no devices, just returns a struct.
+
+Medium complexity: see Laser → wraps a single serial USB device.
+
+High complexity: see Extruder → configures multiple EtherCAT devices inside controllers.
+
+Think of new.rs as the factory:
+This is the place to declare which devices make up your machine and how they’re configured.
+
+## 5. act.rs
+
+This file implements the machine control loop using MachineAct.
+The act() method is called repeatedly by the control runtime.
+
+```rs
+impl MachineAct for YourMachine {
+    fn act(&mut self, _now_ts: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
+        Box::pin(async move {
+            let now = Instant::now();
+
+            // Update state, e.g. step a controller
+            self.some_controller.update();
+
+            // Emit live values ~30 Hz if machine is in Running mode
+            if now.duration_since(self.last_measurement_emit) > Duration::from_secs_f64(1.0 / 30.0) {
+                self.maybe_emit_state_event();
+                self.emit_live_values();
+                self.last_measurement_emit = now;
+            }
+        })
+    }
+}
+```
+
+## 6. api.rs
+
+Defines the frontend-facing API for your machine:
+
+Mutations → requests that the machine accepts
+(e.g. start/stop commands, setpoints, configuration updates).
+
+Events → responses emitted to the frontend
+(e.g. live sensor data, alarms, machine state changes).
+
+Look at MockMachine’s api.rs for a minimal version.
+
+```rs
+/// Mutations are API requests to control the machine
+#[derive(Debug, Clone, serde::Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum YourMachineMutation {
+    Start,
+    Stop,
+    SetSpeed { rpm: f64 },
+}
+
+/// Events are responses sent to the frontend
+#[derive(Debug, Clone, serde::Serialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum YourMachineEvent {
+    StateChanged { state: String },
+    LiveValues { rpm: f64, torque: f64 },
+}
+
+```
+
@@ -0,0 +1,128 @@
+# Performance/Stability Tweaks 
+## EtherCrab Config
+We set ethercrab to default settings for everything except for RetryBehaviour, so that one unlikely failure doesnt destroy the EtherCAT network.
+
+```rust
+    let maindevice = MainDevice::new(
+        pdu,
+        Timeouts {
+            // Default 5000ms
+            state_transition: Duration::from_millis(5000),
+            // Default 30_000us
+            pdu: Duration::from_micros(30_000),
+            // Default 10ms
+            eeprom: Duration::from_millis(10),
+            // Default 0ms
+            wait_loop_delay: Duration::from_millis(0),
+            // Default 100ms
+            mailbox_echo: Duration::from_millis(100),
+            // Default 1000ms
+            mailbox_response: Duration::from_millis(1000),
+        },
+        MainDeviceConfig {
+            // Default RetryBehaviour::None
+            retry_behaviour: RetryBehaviour::Count(5),
+            // Default 10_000
+            dc_static_sync_iterations: 10_000,
+        },
+    );
+
+```
+wait_loop_delay CAN in theory also decrease CPU usage if set exactly as the loop_delay we set, however this setting has caused us some issues, so we just leave it as is.
+
+## Realtime Kernel
+In our nixOs Config we use the latest realtime kernel and isolate TWO cores out of the Four available for the machines we use.
+
+```nix
+ #From configuration.nix
+ boot.loader.efi.canTouchEfiVariables = true;
+ boot.kernelPackages = pkgs.linuxPackages-rt_latest;
+ boot.kernelModules = [ "i915" ];
+```
+
+Notice how we hardcode the intel gpu kernel module. This is because only the GPU driver gets blacklisted for some reason. By specifying it manually it loads like before.
+
+One Core is used for the EtherCrab TXRX Thread and one is used for the machine Thread. 
+```
+    "isolcpus=2,3" # Isolate cpus 2 and 3 from scheduler for better latency, 2 runs ethercatthread and 3 runs server control-loop
+    "nohz_full=2,3" # In this mode, the periodic scheduler tick is stopped when only one task is running, reducing kernel interruptions on those CPUs.
+    "rcu_nocbs=2,3" # Moves RCU (Read-Copy Update) callback processing away from CPUs 2 and 3.
+```
+
+Essentially we completely disable acces from the operating system to these two cpus, which saves scheduler overhead, which would introduce noticable latency.
+Its not entirely clear yet if what we did here is overkill. Maybe we could use only one core and get away with that?
+Processor load normally hovers around 18% for one of the cores and like 9% for the other.
+
+We also have some minor cpu tweaks in configuration.nix
+```
+    # Graphical
+    "logo.nologo" # Remove kernel logo during boot
+
+    # Performance
+
+    # Specific Vulnerabilities Addressed by Mitigations:
+    # - Spectre variants (V1, V2, V4, SWAPGS, SpectreRSB, etc.)
+    # - Meltdown (Rogue Data Cache Load)
+    # - Foreshadow/L1TF (L1 Terminal Fault)
+    # - Microarchitectural Data Sampling (MDS, RIDL, Fallout, ZombieLoad)
+    # - SRBDS (Special Register Buffer Data Sampling)
+    # - TSX Asynchronous Abort (TAA)
+    # - iTLB Multihit
+    # - And others as they're discovered and mitigated
+    #
+    # With mitigations=off
+    # - PROS: Maximum performance, equivalent to pre-2018 behavior
+    # - CONS: Vulnerable to Spectre, Meltdown, Foreshadow, ZombieLoad, etc.
+    #         Should ONLY be used in completely trusted environments
+    # - Improves performance by 7-43%
+    "mitigation=off"
+    "intel_pstate=performance"    # Intel CPU-specific performance mode (if applicable)
+
+    # Memory Management
+    "transparent_hugepage=always" # Use larger memory pages for memory intense applications
+    "nmi_watchdog=0"              # Disable NMI watchdog for reduced CPU overhead and realtime execution
+
+    # High-throughput ethernet parameters
+    "pcie_aspm=off"         # Disable PCIe power management for NICs
+    "intel_iommu=off"       # Disable IOMMU (performance gain)
+
+    # Reliability
+    "panic=10"              # Auto-reboot 10 seconds after kernel panic
+    "oops=panic"            # Treat kernel oops as panic for auto-recovery
+    "usbcore.autosuspend=-1"     # Possibly fixes dre disconnect issue?
+```
+
+We should check if its really required to turn mitigations off as well.
+
+## Rust Code Optimizations
+
+In General we try to avoid memory allocations in our loop as much as possible, as it is not deterministic
+
+One problem we found, is that due to the realtime kernel our ethernet driver caused us quite large spikes in our tx_rx cycle time for EtherCAT.
+These spikes happen when CPU Load is very high on the two usable cores, causing the interrupt handler for Ethernet to stall.
+
+Which is why we reassign the interrupt handler on startup to the same core that the EtherCatTxRx Thread runs on:
+
+```rust
+#[cfg(target_os = "linux")]
+match set_irq_affinity(&interface, 3) {
+      Ok(_) => tracing::info!("ethernet interrupt handler now runs on cpu:{}", 3),
+      Err(e) => tracing::error!("set_irq_affinity failed: {:?}", e),
+}
+// Set core affinity to 4th core
+let _ = set_core_affinity(3);
+
+// Set the thread to real-time priority
+let _ = set_realtime_priority();
+```
+This means that the Interrupt Handler ALWAYS has enough ressources to cope with our demand for realtime communication with EtherCAT
+
+
+One Problem we have at the moment (we think) is the locking and async code blocking our server loop. 
+Note that this doesnt affect the EtherCAT communication at all.
+
+## Electron Optimizations (Not Yet Implemented)
+
+Currently we are struggling with the fact, that apparently Electron doesnt really have good support for HW acceleration on Linux.
+Electron runs with the software-renderer, which is VERY slow compared to a gpu. 
+This would eliminate the weird stuttering seen on Graphs and make them run buttery smooth, while also alleviating load off of the CPU.
@@ -115,3 +115,130 @@ pub fn (
    }
 }
 ```
+
+
+# Device Implementation Guide
+
+This section describes how to implement EtherCAT devices in the framework used by the QiTech Control project (via `ethercat-hal`, `server`, etc.). We include a running example of a simple digital output device (EL2004) and discuss how it fits into the larger architecture.
+
+## Architecture & Context
+
+The QiTech Control system is built as:
+
+- `ethercat-hal` / `ethercat-hal-derive`: Hardware abstraction, PDO / CoE handling, device traits.  
+- `server`: Glue code that reads device identities, instantiates the correct device types, performs CoE configuration, and runs cyclic process data.  
+- The `docs` directory documents APIs and device patterns.  
+  :contentReference[oaicite:0]{index=0}  
+
+In this architecture:
+
+1. During initialization, subdevice identity tuples (Vendor ID, Product ID, Revision) are read.
+2. The `server` matches identity tuples to concrete `Device` types and constructs them (via `NewEthercatDevice`).
+3. The device instance then handles PDO exchange, and optional CoE (configuration) writes.
+4. Higher-level application code interacts with devices via traits like `DigitalOutputDevice`, `DigitalInputDevice`, etc.
+
+---
+
+## Example: Simple Digital Output Device (EL2004)
+
+Below is a minimal example of a digital-output-only EtherCAT device. It shows how to map PDOs, implement traits, and define identity constants.
+
+```rust
+use super::{EthercatDeviceProcessing, NewEthercatDevice, SubDeviceIdentityTuple};
+use crate::helpers::ethercrab_types::EthercrabSubDevicePreoperational;
+use crate::io::digital_output::{DigitalOutputDevice, DigitalOutputOutput};
+use crate::pdo::{RxPdo, basic::BoolPdoObject};
+use ethercat_hal_derive::{EthercatDevice, RxPdo};
+
+/// EL2004 4-channel digital output device — 24 V DC, 0.5 A per channel
+#[derive(EthercatDevice)]
+pub struct EL2004 {
+    /// The Rx PDO where output bits are written by the master
+    pub rxpdo: EL2004RxPdo,
+    is_used: bool,
+}
+
+impl EthercatDeviceProcessing for EL2004 {}
+
+impl std::fmt::Debug for EL2004 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "EL2004")
+    }
+}
+
+impl NewEthercatDevice for EL2004 {
+    fn new() -> Self {
+        Self {
+            rxpdo: EL2004RxPdo::default(),
+            is_used: false,
+        }
+    }
+}
+
+impl DigitalOutputDevice<EL2004Port> for EL2004 {
+    fn set_output(&mut self, port: EL2004Port, value: DigitalOutputOutput) {
+        let expect_text = "All channels should be Some(_)";
+        match port {
+            EL2004Port::DO1 => {
+                self.rxpdo.channel1.as_mut().expect(expect_text).value = value.into()
+            }
+            EL2004Port::DO2 => {
+                self.rxpdo.channel2.as_mut().expect(expect_text).value = value.into()
+            }
+            EL2004Port::DO3 => {
+                self.rxpdo.channel3.as_mut().expect(expect_text).value = value.into()
+            }
+            EL2004Port::DO4 => {
+                self.rxpdo.channel4.as_mut().expect(expect_text).value = value.into()
+            }
+        }
+    }
+
+    fn get_output(&self, port: EL2004Port) -> DigitalOutputOutput {
+        let expect_text = "All channels should be Some(_)";
+        DigitalOutputOutput(match port {
+            EL2004Port::DO1 => self.rxpdo.channel1.as_ref().expect(expect_text).value,
+            EL2004Port::DO2 => self.rxpdo.channel2.as_ref().expect(expect_text).value,
+            EL2004Port::DO3 => self.rxpdo.channel3.as_ref().expect(expect_text).value,
+            EL2004Port::DO4 => self.rxpdo.channel4.as_ref().expect(expect_text).value,
+        })
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum EL2004Port {
+    DO1,
+    DO2,
+    DO3,
+    DO4,
+}
+
+#[derive(Debug, Clone, RxPdo)]
+pub struct EL2004RxPdo {
+    #[pdo_object_index(0x1600)]
+    pub channel1: Option<BoolPdoObject>,
+    #[pdo_object_index(0x1601)]
+    pub channel2: Option<BoolPdoObject>,
+    #[pdo_object_index(0x1602)]
+    pub channel3: Option<BoolPdoObject>,
+    #[pdo_object_index(0x1603)]
+    pub channel4: Option<BoolPdoObject>,
+}
+
+impl Default for EL2004RxPdo {
+    fn default() -> Self {
+        Self {
+            channel1: Some(BoolPdoObject::default()),
+            channel2: Some(BoolPdoObject::default()),
+            channel3: Some(BoolPdoObject::default()),
+            channel4: Some(BoolPdoObject::default()),
+        }
+    }
+}
+
+/// Identity constants for EL2004
+pub const EL2004_VENDOR_ID: u32 = 0x2;
+pub const EL2004_PRODUCT_ID: u32 = 131346514;
+pub const EL2004_REVISION_A: u32 = 1179648;
+pub const EL2004_IDENTITY_A: SubDeviceIdentityTuple =
+    (EL2004_VENDOR_ID, EL2004_PRODUCT_ID, EL2004_REVISION_A);
@@ -7,8 +7,8 @@ type DiameterVisualisationProps = {
  lowTolerance: number;
  highTolerance: number;
  diameter: TimeSeries;
-  x_value?: TimeSeries;
-  y_value?: TimeSeries;
+  x_diameter?: TimeSeries;
+  y_diameter?: TimeSeries;
 };

 // Ring color depending on tolerance
@@ -36,12 +36,12 @@ export function DiameterVisualisation({
  lowTolerance,
  highTolerance,
  diameter,
-  x_value,
-  y_value,
+  x_diameter,
+  y_diameter,
 }: DiameterVisualisationProps) {
  const actualDiameter = diameter.current?.value ?? 0.0;
-  const actualX = x_value?.current?.value ?? actualDiameter;
-  const actualY = y_value?.current?.value ?? actualDiameter;
+  const actualX = x_diameter?.current?.value ?? actualDiameter;
+  const actualY = y_diameter?.current?.value ?? actualDiameter;

  const minDia = targetDiameter - lowTolerance;
  const maxDia = targetDiameter + highTolerance;
@@ -55,9 +55,15 @@ export function DiameterVisualisation({
    inputMax: number,
    outputMin: number,
    outputMax: number,
-  ) =>
-    outputMin +
-    ((value - inputMin) * (outputMax - outputMin)) / (inputMax - inputMin);
+  ) => {
+    if (inputMax === inputMin) {
+      return (outputMin + outputMax) / 2;
+    }
+    return (
+      outputMin +
+      ((value - inputMin) * (outputMax - outputMin)) / (inputMax - inputMin)
+    );
+  };

  const clamp = (value: number, min: number, max: number) =>
    Math.min(Math.max(value, min), max);
@@ -14,8 +14,9 @@ import { DiameterVisualisation } from "../DiameterVisualisation";
 export function Laser1ControlPage() {
  const {
    diameter,
-    x_value,
-    y_value,
+    x_diameter,
+    y_diameter,
+    roundness,
    state,
    defaultState,
    setTargetDiameter,
@@ -36,8 +37,8 @@ export function Laser1ControlPage() {
            lowTolerance={lowerTolerance}
            highTolerance={higherTolerance}
            diameter={diameter}
-            x_value={x_value}
-            y_value={y_value}
+            x_diameter={x_diameter}
+            y_diameter={y_diameter}
          />
          <div className="flex flex-row items-center gap-6">
            <TimeSeriesValueNumeric
@@ -47,22 +48,31 @@ export function Laser1ControlPage() {
              renderValue={(value) => value.toFixed(3)}
            />
          </div>
-          {x_value?.current && (
+          {x_diameter?.current && (
            <div className="flex flex-row items-center gap-6">
              <TimeSeriesValueNumeric
                label="X-Diameter"
                unit="mm"
-                timeseries={x_value}
+                timeseries={x_diameter}
                renderValue={(value) => value.toFixed(3)}
              />
            </div>
          )}
-          {y_value?.current && (
+          {y_diameter?.current && (
            <div className="flex flex-row items-center gap-6">
              <TimeSeriesValueNumeric
                label="Y-Diameter"
                unit="mm"
-                timeseries={y_value}
+                timeseries={y_diameter}
+                renderValue={(value) => value.toFixed(3)}
+              />
+            </div>
+          )}
+          {roundness?.current && (
+            <div className="flex flex-row items-center gap-6">
+              <TimeSeriesValueNumeric
+                label="Roundness"
+                timeseries={roundness}
                renderValue={(value) => value.toFixed(3)}
              />
            </div>
@@ -10,18 +10,19 @@ import React from "react";
 import { useLaser1 } from "./useLaser1";

 export function Laser1GraphsPage() {
-  const { diameter, x_value, y_value, state } = useLaser1();
+  const { diameter, x_diameter, y_diameter, roundness, state } = useLaser1();

  const syncHook = useGraphSync("diameter-group");
  const targetDiameter = state?.laser_state?.target_diameter ?? 0;
  const lowerTolerance = state?.laser_state?.lower_tolerance ?? 0;
  const higherTolerance = state?.laser_state?.higher_tolerance ?? 0;

-  const isTwoAxis = !!x_value?.current || !!y_value?.current;
+  const isTwoAxis = !!x_diameter?.current || !!y_diameter?.current;

  const diameterColor = "#3b82f6";
  const xDiameterColor = "#ef4444";
  const yDiameterColor = "#22c55e";
+  const roundnessColor = "#eab308";

  const config: GraphConfig = {
    title: "Diameter",
@@ -110,15 +111,20 @@ export function Laser1GraphsPage() {
                ],
              },
              {
-                newData: x_value,
+                newData: x_diameter,
                color: xDiameterColor,
                title: "X-Diameter",
              },
              {
-                newData: y_value,
+                newData: y_diameter,
                color: yDiameterColor,
                title: "Y-Diameter",
              },
+              {
+                newData: roundness,
+                color: roundnessColor,
+                title: "Roundness",
+              },
            ]}
            unit="mm"
            renderValue={(value) => value.toFixed(3)}
@@ -28,8 +28,9 @@ import {
 */
 export const liveValuesEventDataSchema = z.object({
  diameter: z.number(),
-  x_value: z.number().nullable(),
-  y_value: z.number().nullable(),
+  x_diameter: z.number().nullable(),
+  y_diameter: z.number().nullable(),
+  roundness: z.number().nullable(),
 });

 /**
@@ -59,8 +60,9 @@ export type Laser1NamespaceStore = {

  // Time series data for live values
  diameter: TimeSeries;
-  x_value: TimeSeries;
-  y_value: TimeSeries;
+  x_diameter: TimeSeries;
+  y_diameter: TimeSeries;
+  roundness: TimeSeries;
 };

 // Constants for time durations
@@ -75,19 +77,19 @@ const { initialTimeSeries: diameter, insert: addDiameter } = createTimeSeries(
  ONE_HOUR,
 );

-const { initialTimeSeries: x_value, insert: addXValue } = createTimeSeries(
+const { initialTimeSeries: x_diameter, insert: addXDiameter } =
+  createTimeSeries(TWENTY_MILLISECOND, ONE_SECOND, FIVE_SECOND, ONE_HOUR);
+
+const { initialTimeSeries: y_diameter, insert: addYDiameter } =
+  createTimeSeries(TWENTY_MILLISECOND, ONE_SECOND, FIVE_SECOND, ONE_HOUR);
+
+const { initialTimeSeries: roundness, insert: addRoundness } = createTimeSeries(
  TWENTY_MILLISECOND,
  ONE_SECOND,
  FIVE_SECOND,
  ONE_HOUR,
 );

-const { initialTimeSeries: y_value, insert: addYValue } = createTimeSeries(
-  TWENTY_MILLISECOND,
-  ONE_SECOND,
-  FIVE_SECOND,
-  ONE_HOUR,
-);
 /**
 * Factory function to create a new Laser1 namespace store
 * @returns A new Zustand store instance for Laser1 namespace
@@ -98,8 +100,9 @@ export const createLaser1NamespaceStore = (): StoreApi<Laser1NamespaceStore> =>
      state: null,
      defaultState: null,
      diameter: diameter,
-      x_value: x_value,
-      y_value: y_value,
+      x_diameter,
+      y_diameter,
+      roundness: roundness,
    };
  });

@@ -143,31 +146,43 @@ export function laser1MessageHandler(
          value: liveValuesEvent.data.diameter,
          timestamp: event.ts,
        };
-        if (liveValuesEvent.data.x_value !== null) {
-          const xValue: TimeSeriesValue = {
-            value: liveValuesEvent.data.x_value,
-            timestamp: event.ts,
-          };
-          updateStore((state) => ({
-            ...state,
-            x_value: addXValue(state.x_value, xValue),
-          }));
-        }
-
-        if (liveValuesEvent.data.y_value !== null) {
-          const yValue: TimeSeriesValue = {
-            value: liveValuesEvent.data.y_value,
-            timestamp: event.ts,
-          };
-          updateStore((state) => ({
-            ...state,
-            y_value: addYValue(state.y_value, yValue),
-          }));
-        }
        updateStore((state) => ({
          ...state,
          diameter: addDiameter(state.diameter, diameterValue),
        }));
+
+        if (liveValuesEvent.data.x_diameter !== null) {
+          const xValue: TimeSeriesValue = {
+            value: liveValuesEvent.data.x_diameter,
+            timestamp: event.ts,
+          };
+          updateStore((state) => ({
+            ...state,
+            x_diameter: addXDiameter(state.x_diameter, xValue),
+          }));
+        }
+
+        if (liveValuesEvent.data.y_diameter !== null) {
+          const yValue: TimeSeriesValue = {
+            value: liveValuesEvent.data.y_diameter,
+            timestamp: event.ts,
+          };
+          updateStore((state) => ({
+            ...state,
+            y_diameter: addYDiameter(state.y_diameter, yValue),
+          }));
+        }
+
+        if (liveValuesEvent.data.roundness !== null) {
+          const roundnessValue: TimeSeriesValue = {
+            value: liveValuesEvent.data.roundness,
+            timestamp: event.ts,
+          };
+          updateStore((state) => ({
+            ...state,
+            roundness: addRoundness(state.roundness, roundnessValue),
+          }));
+        }
      } else {
        handleUnhandledEventError(eventName);
      }
@@ -11,7 +11,7 @@ import { produce } from "immer";

 function useLaser(machine_identification_unique: MachineIdentificationUnique) {
  // Get consolidated state and live values from namespace
-  const { state, defaultState, diameter, x_value, y_value } =
+  const { state, defaultState, diameter, x_diameter, y_diameter, roundness } =
    useLaser1Namespace(machine_identification_unique);

  // Single optimistic state for all state management
@@ -110,8 +110,9 @@ function useLaser(machine_identification_unique: MachineIdentificationUnique) {

    // Live values (TimeSeries)
    diameter,
-    x_value,
-    y_value,
+    x_diameter,
+    y_diameter,
+    roundness,

    // Loading states
    isLoading: stateOptimistic.isOptimistic,
@@ -15,3 +15,7 @@ ethercat_hal = { path = "../ethercat-hal" }
 control_core = { path = "../control-core" }
 futures = "0.3.31"
 anyhow = "1.0.99"
+
+
+[package.metadata.cargo-machete]
+ignored = ["interfaces"]
@@ -18,7 +18,6 @@ uom = { version = "0.36.0", default-features = false, features = ["f64"] }
 serde = "1.0.217"
 anyhow = "1.0.99"

-open = "5.3.2"
 bitvec = "1.0.1"
 lazy_static = "1.5.0"
 dhat = { version = "0.3.3", optional = true }
@@ -27,7 +26,6 @@ euclid = "0.22.11"
 # concurrency
 smol = "2.0.2"
 tokio = { version = "1.45.1", features = ["rt-multi-thread"] }
-thread-priority = "2.1.0"
 regex = "1.11.2"
 futures = "0.3.31"

@@ -38,7 +36,6 @@ tower-http = { version = "0.6.6", features = ["cors", "trace", "fs"] }
 axum = { version = "0.8.4", features = ["macros"] }

 # serial
-crc = "3.3.0"
 serialport = "4.7.3"

 #tracing
@@ -81,7 +78,11 @@ tracing-otel = [
 ]
 mock-machine = []
 io-uring = []
+development-build = []

 [profile.release]
 codegen-units = 1
 lto = "fat"
+
+[package.metadata.cargo-machete]
+ignored =  ["tonic"]
@@ -9,7 +9,7 @@ use crate::{
    ethercat::config::{MAX_FRAMES, MAX_PDU_DATA, MAX_SUBDEVICES, PDI_LEN},
 };
 use control_core::ethercat::eeprom_identification::read_device_identifications;
-#[cfg(target_os = "linux")]
+#[cfg(all(target_os = "linux", not(feature = "development-build")))]
 use control_core::irq_handling::set_irq_affinity;
 use control_core::machines::identification::{
    DeviceHardwareIdentification, DeviceHardwareIdentificationEthercat, DeviceIdentification,
@@ -47,7 +47,7 @@ pub async fn setup_loop(
        .spawn(move || {
            send_panic(thread_panic_tx_clone);

-            #[cfg(target_os = "linux")]
+            #[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),
                Err(e) => tracing::error!("set_irq_handler_affinity failed: {:?}", e),
@@ -127,7 +127,11 @@ pub async fn loop_once<'maindevice>(app_state: Arc<AppState>) -> Result<(), anyh
                )
            })?;
        }
-        // Apparently 500 Microseconds is a safe starting point for ethercat
+
+        #[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;
    }

@@ -1,8 +1,11 @@
+#[cfg(not(feature = "mock-machine"))]
+use crate::machines::extruder1::ExtruderV2;
+#[cfg(not(feature = "mock-machine"))]
 use control_core::machines::new::MachineAct;
+#[cfg(not(feature = "mock-machine"))]
 use std::time::{Duration, Instant};

-use crate::machines::extruder1::ExtruderV2;
-
+#[cfg(not(feature = "mock-machine"))]
 impl MachineAct for ExtruderV2 {
    fn act(&mut self, now: Instant) {
        self.temperature_controller_back.update(now);
@@ -1,4 +1,11 @@
-use super::{ExtruderV2, ExtruderV2Mode, HeatingType, mitsubishi_cs80::MotorStatus};
+use super::{ExtruderV2Mode, HeatingType, mitsubishi_cs80::MotorStatus};
+
+#[cfg(not(feature = "mock-machine"))]
+use super::ExtruderV2;
+
+#[cfg(feature = "mock-machine")]
+use super::mock::ExtruderV2;
+
 use control_core::{
    machines::api::MachineApi,
    socketio::{
@@ -23,11 +30,11 @@ use uom::si::{

 #[derive(Debug, Clone, Default, Serialize)]
 pub struct MotorStatusValues {
-    screw_rpm: f64, // rpm of motor
-    frequency: f64, // frequency of motor
-    voltage: f64,   // volt used for motor
-    current: f64,   // current used for the motor
-    power: f64,     // power in watts
+    pub screw_rpm: f64, // rpm of motor
+    pub frequency: f64, // frequency of motor
+    pub voltage: f64,   // volt used for motor
+    pub current: f64,   // current used for the motor
+    pub power: f64,     // power in watts
 }

 impl From<MotorStatus> for MotorStatusValues {
@@ -189,7 +196,7 @@ pub enum ExtruderV2Events {
 }

 #[derive(Deserialize, Serialize)]
-enum Mutation {
+pub enum Mutation {
    /// INVERTER
    /// Frequency Control
    // Set Rotation also starts the motor
@@ -257,6 +264,7 @@ impl CacheableEvents<Self> for ExtruderV2Events {
    }
 }

+#[cfg(not(feature = "mock-machine"))]
 impl MachineApi for ExtruderV2 {
    fn api_mutate(&mut self, request_body: Value) -> Result<(), anyhow::Error> {
        // there are multiple Modbus Frames that are "prebuilt"
@@ -0,0 +1,279 @@
+#[cfg(not(feature = "mock-machine"))]
+// Contains Implementations for All functions that use emit_state
+use crate::machines::extruder1::{
+    ExtruderV2, ExtruderV2Mode, HeatingType,
+    api::{
+        ExtruderSettingsState, ExtruderV2Events, HeatingState, HeatingStates, InverterStatusState,
+        LiveValuesEvent, ModeState, PidSettings, PidSettingsStates, PressureState, RegulationState,
+        RotationState, ScrewState, StateEvent,
+    },
+};
+use control_core::{
+    helpers::hasher_serializer::hash_with_serde_model,
+    socketio::{event::BuildEvent, namespace::NamespaceCacheingLogic},
+};
+use uom::si::{
+    angular_velocity::revolution_per_minute,
+    f64::{AngularVelocity, Pressure, ThermodynamicTemperature},
+    pressure::bar,
+    thermodynamic_temperature::degree_celsius,
+};
+
+#[cfg(not(feature = "mock-machine"))]
+impl ExtruderV2 {
+    pub fn build_state_event(&mut self) -> StateEvent {
+        StateEvent {
+            is_default_state: !std::mem::replace(&mut self.emitted_default_state, true),
+            rotation_state: RotationState {
+                forward: self.screw_speed_controller.get_rotation_direction(),
+            },
+            mode_state: ModeState {
+                mode: self.mode.clone(),
+            },
+            regulation_state: RegulationState {
+                uses_rpm: self.screw_speed_controller.get_uses_rpm(),
+            },
+            pressure_state: PressureState {
+                target_bar: self
+                    .screw_speed_controller
+                    .get_target_pressure()
+                    .get::<bar>(),
+                wiring_error: self.screw_speed_controller.get_wiring_error(),
+            },
+            screw_state: ScrewState {
+                target_rpm: self
+                    .screw_speed_controller
+                    .get_target_rpm()
+                    .get::<revolution_per_minute>(),
+            },
+            heating_states: HeatingStates {
+                nozzle: HeatingState {
+                    target_temperature: self
+                        .temperature_controller_nozzle
+                        .heating
+                        .target_temperature
+                        .get::<degree_celsius>(),
+                    wiring_error: self.temperature_controller_nozzle.heating.wiring_error,
+                },
+                front: HeatingState {
+                    target_temperature: self
+                        .temperature_controller_front
+                        .heating
+                        .target_temperature
+                        .get::<degree_celsius>(),
+                    wiring_error: self.temperature_controller_front.heating.wiring_error,
+                },
+                back: HeatingState {
+                    target_temperature: self
+                        .temperature_controller_back
+                        .heating
+                        .target_temperature
+                        .get::<degree_celsius>(),
+                    wiring_error: self.temperature_controller_back.heating.wiring_error,
+                },
+                middle: HeatingState {
+                    target_temperature: self
+                        .temperature_controller_middle
+                        .heating
+                        .target_temperature
+                        .get::<degree_celsius>(),
+                    wiring_error: self.temperature_controller_middle.heating.wiring_error,
+                },
+            },
+            extruder_settings_state: ExtruderSettingsState {
+                pressure_limit: self
+                    .screw_speed_controller
+                    .get_nozzle_pressure_limit()
+                    .get::<bar>(),
+                pressure_limit_enabled: self
+                    .screw_speed_controller
+                    .get_nozzle_pressure_limit_enabled(),
+            },
+            inverter_status_state: InverterStatusState {
+                running: self.screw_speed_controller.inverter.status.running,
+                forward_running: self.screw_speed_controller.inverter.status.forward_running,
+                reverse_running: self.screw_speed_controller.inverter.status.reverse_running,
+                up_to_frequency: self.screw_speed_controller.inverter.status.su,
+                overload_warning: self.screw_speed_controller.inverter.status.ol,
+                no_function: self.screw_speed_controller.inverter.status.no_function,
+                output_frequency_detection: self.screw_speed_controller.inverter.status.fu,
+                abc_fault: self.screw_speed_controller.inverter.status.abc_,
+                fault_occurence: self.screw_speed_controller.inverter.status.fault_occurence,
+            },
+            pid_settings: PidSettingsStates {
+                temperature: PidSettings {
+                    ki: 0.0,
+                    kp: 0.0,
+                    kd: 0.0,
+                },
+                pressure: PidSettings {
+                    ki: self.screw_speed_controller.pid.get_ki(),
+                    kp: self.screw_speed_controller.pid.get_kp(),
+                    kd: self.screw_speed_controller.pid.get_kd(),
+                },
+            },
+        }
+    }
+}
+
+#[cfg(not(feature = "mock-machine"))]
+impl ExtruderV2 {
+    pub fn emit_state(&mut self) {
+        let state = self.build_state_event();
+        let hash = hash_with_serde_model(self.screw_speed_controller.get_inverter_status());
+        self.last_status_hash = Some(hash);
+        let event = state.build();
+        self.namespace.emit(ExtruderV2Events::State(event));
+    }
+
+    pub fn maybe_emit_state_event(&mut self) {
+        let old_status_hash = match self.last_status_hash {
+            Some(event) => event,
+            None => {
+                self.emit_state();
+                return;
+            }
+        };
+        let status = self.screw_speed_controller.get_inverter_status();
+        let new_status_hash = hash_with_serde_model(status);
+        if new_status_hash != old_status_hash {
+            self.emit_state();
+        }
+    }
+
+    pub fn emit_live_values(&mut self) {
+        use std::time::Instant;
+        let now = Instant::now();
+        let combined_power = self.calculate_combined_power();
+        self.update_total_energy(combined_power, now);
+
+        let live_values = LiveValuesEvent {
+            motor_status: self.screw_speed_controller.get_motor_status().into(),
+            pressure: self.screw_speed_controller.get_pressure().get::<bar>(),
+            nozzle_temperature: self
+                .temperature_controller_nozzle
+                .heating
+                .temperature
+                .get::<degree_celsius>(),
+            front_temperature: self
+                .temperature_controller_front
+                .heating
+                .temperature
+                .get::<degree_celsius>(),
+            back_temperature: self
+                .temperature_controller_back
+                .heating
+                .temperature
+                .get::<degree_celsius>(),
+            middle_temperature: self
+                .temperature_controller_middle
+                .heating
+                .temperature
+                .get::<degree_celsius>(),
+            nozzle_power: self
+                .temperature_controller_nozzle
+                .get_heating_element_wattage(),
+            front_power: self
+                .temperature_controller_front
+                .get_heating_element_wattage(),
+            back_power: self
+                .temperature_controller_back
+                .get_heating_element_wattage(),
+            middle_power: self
+                .temperature_controller_middle
+                .get_heating_element_wattage(),
+            combined_power,
+            total_energy_kwh: self.total_energy_kwh,
+        };
+
+        let event = live_values.build();
+        self.namespace.emit(ExtruderV2Events::LiveValues(event));
+    }
+
+    // === Steuerungsfunktionen mit emit_state ===
+
+    pub fn set_nozzle_pressure_limit_is_enabled(&mut self, enabled: bool) {
+        self.screw_speed_controller
+            .set_nozzle_pressure_limit_is_enabled(enabled);
+        self.emit_state();
+    }
+
+    pub fn set_nozzle_pressure_limit(&mut self, pressure: f64) {
+        use uom::si::pressure::bar;
+        self.screw_speed_controller
+            .set_nozzle_pressure_limit(Pressure::new::<bar>(pressure));
+        self.emit_state();
+    }
+
+    pub fn enable_heating(&mut self) {
+        self.temperature_controller_back.allow_heating();
+        self.temperature_controller_front.allow_heating();
+        self.temperature_controller_middle.allow_heating();
+        self.temperature_controller_nozzle.allow_heating();
+        self.emit_state();
+    }
+
+    pub fn set_rotation_state(&mut self, forward: bool) {
+        self.screw_speed_controller.set_rotation_direction(forward);
+        self.emit_state();
+    }
+
+    pub fn set_mode_state(&mut self, mode: ExtruderV2Mode) {
+        self.switch_mode(mode);
+        self.emit_state();
+    }
+
+    pub fn set_regulation(&mut self, uses_rpm: bool) {
+        if !self.screw_speed_controller.get_uses_rpm() && uses_rpm {
+            self.screw_speed_controller
+                .set_target_screw_rpm(self.screw_speed_controller.target_rpm);
+            self.screw_speed_controller.set_uses_rpm(uses_rpm);
+        }
+
+        if self.screw_speed_controller.get_uses_rpm() && !uses_rpm {
+            self.screw_speed_controller.set_uses_rpm(uses_rpm);
+            self.screw_speed_controller.start_pressure_regulation();
+        }
+        self.emit_state();
+    }
+
+    pub fn set_target_pressure(&mut self, pressure: f64) {
+        self.screw_speed_controller
+            .set_target_pressure(Pressure::new::<bar>(pressure));
+        self.emit_state();
+    }
+
+    pub fn set_target_rpm(&mut self, rpm: f64) {
+        use uom::si::angular_velocity::revolution_per_minute;
+        self.screw_speed_controller
+            .set_target_screw_rpm(AngularVelocity::new::<revolution_per_minute>(rpm));
+        self.emit_state();
+    }
+
+    pub fn set_target_temperature(&mut self, target_temperature: f64, heating_type: HeatingType) {
+        let target_temp = ThermodynamicTemperature::new::<degree_celsius>(target_temperature);
+
+        match heating_type {
+            HeatingType::Nozzle => self
+                .temperature_controller_nozzle
+                .set_target_temperature(target_temp),
+            HeatingType::Front => self
+                .temperature_controller_front
+                .set_target_temperature(target_temp),
+            HeatingType::Back => self
+                .temperature_controller_back
+                .set_target_temperature(target_temp),
+            HeatingType::Middle => self
+                .temperature_controller_middle
+                .set_target_temperature(target_temp),
+        }
+        self.emit_state();
+    }
+
+    pub fn configure_pressure_pid(&mut self, settings: PidSettings) {
+        self.screw_speed_controller
+            .pid
+            .configure(settings.ki, settings.kp, settings.kd);
+        self.emit_state();
+    }
+}
@@ -0,0 +1,15 @@
+use crate::machines::extruder1::mock::ExtruderV2;
+use control_core::machines::new::MachineAct;
+use std::time::{Duration, Instant};
+
+impl MachineAct for ExtruderV2 {
+    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.maybe_emit_state_event();
+            // Emit live values at 30 FPS
+            self.emit_live_values();
+            self.last_measurement_emit = now;
+        }
+    }
+}
@@ -0,0 +1,44 @@
+use crate::machines::extruder1::{HeatingType, api::Mutation, mock::ExtruderV2};
+use control_core::machines::api::MachineApi;
+
+impl MachineApi for ExtruderV2 {
+    fn api_mutate(&mut self, request_body: serde_json::Value) -> Result<(), anyhow::Error> {
+        // there are multiple Modbus Frames that are "prebuilt"
+        let control: Mutation = serde_json::from_value(request_body)?;
+        match control {
+            Mutation::SetExtruderMode(mode) => self.set_mode_state(mode),
+            Mutation::SetInverterRotationDirection(forward) => self.set_rotation_state(forward),
+            Mutation::SetInverterRegulation(uses_rpm) => self.set_regulation(uses_rpm),
+            Mutation::SetInverterTargetPressure(bar) => self.set_target_pressure(bar),
+            Mutation::SetInverterTargetRpm(rpm) => self.set_target_rpm(rpm),
+            Mutation::ResetInverter(_) => (),
+            Mutation::SetFrontHeatingTargetTemperature(temp) => {
+                self.set_target_temperature(temp, HeatingType::Front)
+            }
+            Mutation::SetMiddleHeatingTemperature(temp) => {
+                self.set_target_temperature(temp, HeatingType::Middle)
+            }
+            Mutation::SetBackHeatingTargetTemperature(temp) => {
+                self.set_target_temperature(temp, HeatingType::Back)
+            }
+            Mutation::SetNozzleHeatingTemperature(temp) => {
+                self.set_target_temperature(temp, HeatingType::Nozzle)
+            }
+            Mutation::SetExtruderPressureLimit(pressure_limit) => {
+                self.set_nozzle_pressure_limit(pressure_limit);
+            }
+            Mutation::SetExtruderPressureLimitIsEnabled(enabled) => {
+                self.set_nozzle_pressure_limit_is_enabled(enabled);
+            }
+
+            Mutation::SetPressurePidSettings(settings) => {
+                self.configure_pressure_pid(settings);
+            }
+        }
+        Ok(())
+    }
+
+    fn api_event_namespace(&mut self) -> &mut control_core::socketio::namespace::Namespace {
+        &mut self.namespace.namespace
+    }
+}
@@ -0,0 +1,136 @@
+use crate::machines::extruder1::{
+    ExtruderV2Mode, HeatingType,
+    api::{ExtruderV2Events, LiveValuesEvent, ModeState, PidSettings, StateEvent},
+    mock::ExtruderV2,
+};
+use control_core::{
+    helpers::hasher_serializer::hash_with_serde_model,
+    socketio::{event::BuildEvent, namespace::NamespaceCacheingLogic},
+};
+
+impl ExtruderV2 {
+    pub fn build_state_event(&mut self) -> StateEvent {
+        // bad performance wise, but doesnt matter its only a mock machine
+        StateEvent {
+            is_default_state: !std::mem::replace(&mut self.emitted_default_state, true),
+            rotation_state: self.rotation_state.clone(),
+            mode_state: self.mode_state.clone(),
+            regulation_state: self.regulation_state.clone(),
+            pressure_state: self.pressure_state.clone(),
+            screw_state: self.screw_state.clone(),
+            heating_states: self.heating_states.clone(),
+            extruder_settings_state: self.extruder_settings_state.clone(),
+            inverter_status_state: self.inverter_status_state.clone(),
+            pid_settings: self.pid_settings.clone(),
+        }
+    }
+}
+
+impl ExtruderV2 {
+    pub fn emit_state(&mut self) {
+        let state = self.build_state_event();
+        let hash = hash_with_serde_model(self.inverter_status_state.clone());
+        self.last_status_hash = Some(hash);
+        let event = state.build();
+        self.namespace.emit(ExtruderV2Events::State(event));
+    }
+
+    pub fn maybe_emit_state_event(&mut self) {
+        let old_status_hash = match self.last_status_hash {
+            Some(event) => event,
+            None => {
+                self.emit_state();
+                return;
+            }
+        };
+        let status = self.inverter_status_state.clone();
+        let new_status_hash = hash_with_serde_model(status);
+        if new_status_hash != old_status_hash {
+            self.emit_state();
+        }
+    }
+
+    pub fn emit_live_values(&mut self) {
+        let live_values = LiveValuesEvent {
+            motor_status: self.motor_status.clone(),
+            pressure: self.pressure,
+            nozzle_temperature: self.nozzle_temperature,
+            front_temperature: self.front_temperature,
+            back_temperature: self.back_temperature,
+            middle_temperature: self.middle_temperature,
+            nozzle_power: self.nozzle_power,
+            front_power: self.front_power,
+            back_power: self.back_power,
+            middle_power: self.middle_power,
+            combined_power: self.combined_power,
+            total_energy_kwh: self.total_energy_kwh,
+        };
+
+        let event = live_values.build();
+        self.namespace.emit(ExtruderV2Events::LiveValues(event));
+    }
+
+    pub fn set_nozzle_pressure_limit_is_enabled(&mut self, enabled: bool) {
+        self.extruder_settings_state.pressure_limit_enabled = enabled;
+        self.emit_state();
+    }
+
+    pub fn set_nozzle_pressure_limit(&mut self, pressure: f64) {
+        self.extruder_settings_state.pressure_limit = pressure;
+        self.emit_state();
+    }
+
+    pub fn enable_heating(&mut self) {
+        self.back_heating_allowed = true;
+        self.front_heating_allowed = true;
+        self.nozzle_heating_allowed = true;
+        self.back_heating_allowed = true;
+        self.emit_state();
+    }
+
+    pub fn set_rotation_state(&mut self, forward: bool) {
+        self.rotation_state.forward = forward;
+        self.emit_state();
+    }
+
+    pub fn set_mode_state(&mut self, mode: ExtruderV2Mode) {
+        self.mode_state = ModeState { mode };
+        self.emit_state();
+    }
+
+    pub fn set_regulation(&mut self, uses_rpm: bool) {
+        self.regulation_state.uses_rpm = uses_rpm;
+        self.emit_state();
+    }
+
+    pub fn set_target_pressure(&mut self, pressure: f64) {
+        self.target_pressure = pressure;
+        self.emit_state();
+    }
+
+    pub fn set_target_rpm(&mut self, rpm: f64) {
+        self.screw_state.target_rpm = rpm;
+        self.emit_state();
+    }
+
+    pub fn set_target_temperature(&mut self, target_temperature: f64, heating_type: HeatingType) {
+        match heating_type {
+            HeatingType::Nozzle => {
+                self.heating_states.nozzle.target_temperature = target_temperature
+            }
+            HeatingType::Front => self.heating_states.front.target_temperature = target_temperature,
+            HeatingType::Back => self.heating_states.back.target_temperature = target_temperature,
+            HeatingType::Middle => {
+                self.heating_states.middle.target_temperature = target_temperature
+            }
+        }
+        self.emit_state();
+    }
+
+    pub fn configure_pressure_pid(&mut self, settings: PidSettings) {
+        self.pid_settings.pressure.ki = settings.ki;
+        self.pid_settings.pressure.kp = settings.kp;
+        self.pid_settings.pressure.kd = settings.kd;
+        self.emit_state();
+    }
+}
@@ -0,0 +1,103 @@
+#[cfg(feature = "mock-machine")]
+use control_core::machines::identification::MachineIdentification;
+#[cfg(feature = "mock-machine")]
+use control_core_derive::Machine;
+#[cfg(feature = "mock-machine")]
+use std::time::Instant;
+
+#[cfg(feature = "mock-machine")]
+use crate::machines::{
+    MACHINE_EXTRUDER_V1, VENDOR_QITECH,
+    extruder1::{
+        ExtruderV2Mode,
+        api::{
+            ExtruderSettingsState, ExtruderV2Namespace, HeatingStates, InverterStatusState,
+            ModeState, MotorStatusValues, PidSettingsStates, PressureState, RegulationState,
+            RotationState, ScrewState,
+        },
+    },
+};
+
+// Just checking mock-machine feature here to exclude these modules from compilation entirely
+#[cfg(feature = "mock-machine")]
+pub mod act;
+#[cfg(feature = "mock-machine")]
+pub mod api;
+#[cfg(feature = "mock-machine")]
+pub mod mock_emit;
+#[cfg(feature = "mock-machine")]
+pub mod new;
+
+#[cfg(feature = "mock-machine")]
+#[derive(Debug, Machine)]
+pub struct ExtruderV2 {
+    namespace: ExtruderV2Namespace,
+    last_measurement_emit: Instant,
+    last_status_hash: Option<u64>,
+    mode: ExtruderV2Mode,
+    /// Energy tracking for total consumption calculation
+    pub total_energy_kwh: f64,
+    pub last_energy_calculation_time: Option<Instant>,
+    /// will be initalized as false and set to true by `emit_state`
+    /// This way we can signal to the client that the first state emission is a default state
+    emitted_default_state: bool,
+    pub target_pressure: f64,
+
+    pub is_default_state: bool,
+    /// rotation state
+    pub rotation_state: RotationState,
+    /// mode state
+    pub mode_state: ModeState,
+    /// regulation state
+    pub regulation_state: RegulationState,
+    /// pressure state
+    pub pressure_state: PressureState,
+    /// screw state
+    pub screw_state: ScrewState,
+    /// heating states
+    pub heating_states: HeatingStates,
+    /// extruder settings state
+    pub extruder_settings_state: ExtruderSettingsState,
+    /// inverter status state
+    pub inverter_status_state: InverterStatusState,
+    /// pid settings
+    pub pid_settings: PidSettingsStates,
+
+    pub motor_status: MotorStatusValues,
+    /// pressure in bar
+    pub pressure: f64,
+    /// nozzle temperature in celsius
+    pub nozzle_temperature: f64,
+    /// front temperature in celsius
+    pub front_temperature: f64,
+    /// back temperature in celsius
+    pub back_temperature: f64,
+    /// middle temperature in celsius
+    pub middle_temperature: f64,
+    /// nozzle heating power in watts
+    pub nozzle_power: f64,
+    /// front heating power in watts
+    pub front_power: f64,
+    /// back heating power in watts
+    pub back_power: f64,
+    /// middle heating power in watts
+    pub middle_power: f64,
+    /// combined power consumption in watts
+    pub combined_power: f64,
+
+    pub nozzle_heating_allowed: bool,
+
+    pub front_heating_allowed: bool,
+
+    pub back_heating_allowed: bool,
+
+    pub middle_heating_allowed: bool,
+}
+
+#[cfg(feature = "mock-machine")]
+impl ExtruderV2 {
+    pub const MACHINE_IDENTIFICATION: MachineIdentification = MachineIdentification {
+        vendor: VENDOR_QITECH,
+        machine: MACHINE_EXTRUDER_V1,
+    };
+}
@@ -0,0 +1,127 @@
+use crate::machines::extruder1::{
+    ExtruderV2Mode,
+    api::{
+        ExtruderSettingsState, ExtruderV2Namespace, HeatingState, HeatingStates,
+        InverterStatusState, ModeState, MotorStatusValues, PidSettings, PidSettingsStates,
+        PressureState, RegulationState, RotationState, ScrewState,
+    },
+    mock::ExtruderV2,
+};
+
+impl control_core::machines::new::MachineNewTrait for ExtruderV2 {
+    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 {
+            namespace: ExtruderV2Namespace::new(params.socket_queue_tx.clone()),
+            last_measurement_emit: now,
+
+            mode: ExtruderV2Mode::Standby, // Start in standby mode
+            emitted_default_state: false,
+            last_status_hash: None,
+            total_energy_kwh: 0.0,
+            last_energy_calculation_time: None,
+            is_default_state: false,
+            rotation_state: RotationState { forward: false },
+            mode_state: ModeState {
+                mode: ExtruderV2Mode::Standby,
+            },
+            regulation_state: RegulationState { uses_rpm: true },
+            pressure_state: PressureState {
+                target_bar: 0.0,
+                wiring_error: false,
+            },
+            screw_state: ScrewState { target_rpm: 0.0 },
+            heating_states: HeatingStates {
+                nozzle: HeatingState {
+                    target_temperature: 0.0,
+                    wiring_error: false,
+                },
+                front: HeatingState {
+                    target_temperature: 0.0,
+                    wiring_error: false,
+                },
+                back: HeatingState {
+                    target_temperature: 0.0,
+                    wiring_error: false,
+                },
+                middle: HeatingState {
+                    target_temperature: 0.0,
+                    wiring_error: false,
+                },
+            },
+            extruder_settings_state: ExtruderSettingsState {
+                pressure_limit: 200.0,
+                pressure_limit_enabled: false,
+            },
+            inverter_status_state: InverterStatusState {
+                running: false,
+                forward_running: true,
+                reverse_running: true,
+                up_to_frequency: false,
+                overload_warning: false,
+                no_function: false,
+                output_frequency_detection: false,
+                abc_fault: false,
+                fault_occurence: false,
+            },
+            pid_settings: PidSettingsStates {
+                temperature: PidSettings {
+                    ki: 0.0,
+                    kp: 0.0,
+                    kd: 0.0,
+                },
+                pressure: PidSettings {
+                    ki: 0.0,
+                    kp: 0.0,
+                    kd: 0.0,
+                },
+            },
+            motor_status: MotorStatusValues {
+                screw_rpm: 0.0,
+                frequency: 0.0,
+                voltage: 0.0,
+                current: 0.0,
+                power: 0.0,
+            },
+            pressure: 0.0,
+            nozzle_temperature: 0.0,
+            front_temperature: 0.0,
+            back_temperature: 0.0,
+            middle_temperature: 0.0,
+            nozzle_power: 0.0,
+            front_power: 0.0,
+            back_power: 0.0,
+            middle_power: 0.0,
+            combined_power: 0.0,
+            nozzle_heating_allowed: false,
+            front_heating_allowed: false,
+            back_heating_allowed: false,
+            middle_heating_allowed: false,
+            target_pressure: 0.0,
+        };
+
+        extruder_mock_machine.emit_state();
+
+        Ok(extruder_mock_machine)
+    }
+}
@@ -1,30 +1,20 @@
 use crate::machines::{MACHINE_EXTRUDER_V1, VENDOR_QITECH};
-use api::{
-    ExtruderSettingsState, ExtruderV2Events, ExtruderV2Namespace, HeatingState, HeatingStates,
-    InverterStatusState, LiveValuesEvent, ModeState, PidSettings, PidSettingsStates, PressureState,
-    RegulationState, RotationState, ScrewState, StateEvent,
-};
-use control_core::helpers::hasher_serializer::hash_with_serde_model;
-use control_core::socketio::event::BuildEvent;
-use control_core::{
-    machines::identification::MachineIdentification, socketio::namespace::NamespaceCacheingLogic,
-};
+use api::ExtruderV2Namespace;
+use control_core::machines::identification::MachineIdentification;
 use control_core_derive::Machine;
 use screw_speed_controller::ScrewSpeedController;
 use serde::{Deserialize, Serialize};
 use std::time::Instant;
 use temperature_controller::TemperatureController;
 use uom::si::{
-    angular_velocity::{AngularVelocity, revolution_per_minute},
-    electric_current::ampere,
-    electric_potential::volt,
-    f64::{Pressure, ThermodynamicTemperature},
-    pressure::bar,
+    electric_current::ampere, electric_potential::volt, f64::ThermodynamicTemperature,
    thermodynamic_temperature::degree_celsius,
 };
 pub mod act;
 pub mod api;
+pub mod emit;
 pub mod mitsubishi_cs80;
+pub mod mock;
 pub mod new;
 pub mod screw_speed_controller;
 pub mod temperature_controller;
@@ -63,6 +53,7 @@ pub enum HeatingType {
 }

 #[derive(Debug, Machine)]
+#[cfg(not(feature = "mock-machine"))]
 pub struct ExtruderV2 {
    namespace: ExtruderV2Namespace,
    last_measurement_emit: Instant,
@@ -83,124 +74,14 @@ pub struct ExtruderV2 {
    emitted_default_state: bool,
 }

-impl ExtruderV2 {
-    pub fn build_state_event(&mut self) -> StateEvent {
-        StateEvent {
-            is_default_state: !std::mem::replace(&mut self.emitted_default_state, true),
-            rotation_state: RotationState {
-                forward: self.screw_speed_controller.get_rotation_direction(),
-            },
-            mode_state: ModeState {
-                mode: self.mode.clone(),
-            },
-            regulation_state: RegulationState {
-                uses_rpm: self.screw_speed_controller.get_uses_rpm(),
-            },
-            pressure_state: PressureState {
-                target_bar: self
-                    .screw_speed_controller
-                    .get_target_pressure()
-                    .get::<bar>(),
-                wiring_error: self.screw_speed_controller.get_wiring_error(),
-            },
-            screw_state: ScrewState {
-                target_rpm: self
-                    .screw_speed_controller
-                    .get_target_rpm()
-                    .get::<revolution_per_minute>(),
-            },
-            heating_states: HeatingStates {
-                nozzle: HeatingState {
-                    target_temperature: self
-                        .temperature_controller_nozzle
-                        .heating
-                        .target_temperature
-                        .get::<degree_celsius>(),
-                    wiring_error: self.temperature_controller_nozzle.heating.wiring_error,
-                },
-                front: HeatingState {
-                    target_temperature: self
-                        .temperature_controller_front
-                        .heating
-                        .target_temperature
-                        .get::<degree_celsius>(),
-                    wiring_error: self.temperature_controller_front.heating.wiring_error,
-                },
-                back: HeatingState {
-                    target_temperature: self
-                        .temperature_controller_back
-                        .heating
-                        .target_temperature
-                        .get::<degree_celsius>(),
-                    wiring_error: self.temperature_controller_back.heating.wiring_error,
-                },
-                middle: HeatingState {
-                    target_temperature: self
-                        .temperature_controller_middle
-                        .heating
-                        .target_temperature
-                        .get::<degree_celsius>(),
-                    wiring_error: self.temperature_controller_middle.heating.wiring_error,
-                },
-            },
-            extruder_settings_state: ExtruderSettingsState {
-                pressure_limit: self
-                    .screw_speed_controller
-                    .get_nozzle_pressure_limit()
-                    .get::<bar>(),
-                pressure_limit_enabled: self
-                    .screw_speed_controller
-                    .get_nozzle_pressure_limit_enabled(),
-            },
-            inverter_status_state: InverterStatusState {
-                running: self.screw_speed_controller.inverter.status.running,
-                forward_running: self.screw_speed_controller.inverter.status.forward_running,
-                reverse_running: self.screw_speed_controller.inverter.status.reverse_running,
-                up_to_frequency: self.screw_speed_controller.inverter.status.su,
-                overload_warning: self.screw_speed_controller.inverter.status.ol,
-                no_function: self.screw_speed_controller.inverter.status.no_function,
-                output_frequency_detection: self.screw_speed_controller.inverter.status.fu,
-                abc_fault: self.screw_speed_controller.inverter.status.abc_,
-                fault_occurence: self.screw_speed_controller.inverter.status.fault_occurence,
-            },
-            pid_settings: PidSettingsStates {
-                temperature: PidSettings {
-                    ki: 0.0, // TODO: Add temperature PID settings when available
-                    kp: 0.0,
-                    kd: 0.0,
-                },
-                pressure: PidSettings {
-                    ki: self.screw_speed_controller.pid.get_ki(),
-                    kp: self.screw_speed_controller.pid.get_kp(),
-                    kd: self.screw_speed_controller.pid.get_kd(),
-                },
-            },
-        }
-    }
-
-    pub fn maybe_emit_state_event(&mut self) {
-        let old_status_hash = match self.last_status_hash {
-            Some(event) => event,
-            None => {
-                self.emit_state();
-                return;
-            }
-        };
-        let status = self.screw_speed_controller.get_inverter_status();
-        let new_status_hash = hash_with_serde_model(status);
-        let should_emit = new_status_hash != old_status_hash;
-        if should_emit {
-            self.emit_state();
-        }
-    }
-}
-
+#[cfg(not(feature = "mock-machine"))]
 impl std::fmt::Display for ExtruderV2 {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "ExtruderV2")
    }
 }

+#[cfg(not(feature = "mock-machine"))]
 impl ExtruderV2 {
    pub const MACHINE_IDENTIFICATION: MachineIdentification = MachineIdentification {
        vendor: VENDOR_QITECH,
@@ -208,6 +89,7 @@ impl ExtruderV2 {
    };
 }

+#[cfg(not(feature = "mock-machine"))]
 impl ExtruderV2 {
    /// Calculate combined power consumption in watts
    fn calculate_combined_power(&mut self) -> f64 {
@@ -243,83 +125,7 @@ impl ExtruderV2 {
        self.last_energy_calculation_time = Some(now);
    }

-    pub fn emit_live_values(&mut self) {
-        let now = Instant::now();
-        let combined_power = self.calculate_combined_power();
-
-        // Update energy consumption
-        self.update_total_energy(combined_power, now);
-
-        let live_values = LiveValuesEvent {
-            motor_status: self.screw_speed_controller.get_motor_status().into(),
-            pressure: self.screw_speed_controller.get_pressure().get::<bar>(),
-            nozzle_temperature: self
-                .temperature_controller_nozzle
-                .heating
-                .temperature
-                .get::<degree_celsius>(),
-            front_temperature: self
-                .temperature_controller_front
-                .heating
-                .temperature
-                .get::<degree_celsius>(),
-            back_temperature: self
-                .temperature_controller_back
-                .heating
-                .temperature
-                .get::<degree_celsius>(),
-            middle_temperature: self
-                .temperature_controller_middle
-                .heating
-                .temperature
-                .get::<degree_celsius>(),
-            nozzle_power: self
-                .temperature_controller_nozzle
-                .get_heating_element_wattage(),
-            front_power: self
-                .temperature_controller_front
-                .get_heating_element_wattage(),
-            back_power: self
-                .temperature_controller_back
-                .get_heating_element_wattage(),
-            middle_power: self
-                .temperature_controller_middle
-                .get_heating_element_wattage(),
-            combined_power,
-            total_energy_kwh: self.total_energy_kwh,
-        };
-
-        let event = live_values.build();
-        self.namespace.emit(ExtruderV2Events::LiveValues(event));
-    }
-
-    pub fn emit_state(&mut self) {
-        let state = self.build_state_event();
-        let hash = hash_with_serde_model(self.screw_speed_controller.get_inverter_status());
-        self.last_status_hash = Some(hash);
-        let event = state.build();
-        self.namespace.emit(ExtruderV2Events::State(event));
-    }
-
-    // Extruder Settings Api Impl
-    fn set_nozzle_pressure_limit_is_enabled(&mut self, enabled: bool) {
-        self.screw_speed_controller
-            .set_nozzle_pressure_limit_is_enabled(enabled);
-        self.emit_state();
-    }
-
-    /// pressure is represented as bar
-    fn set_nozzle_pressure_limit(&mut self, pressure: f64) {
-        let nozzle_pressure_limit = Pressure::new::<bar>(pressure);
-        self.screw_speed_controller
-            .set_nozzle_pressure_limit(nozzle_pressure_limit);
-        self.emit_state();
-    }
-}
-
-impl ExtruderV2 {
-    // Set all relais to ZERO
-    // We dont need a function to enable again though, as the act Loop will detect the mode
+    // Funktionen ohne emit_state bleiben hier
    fn turn_heating_off(&mut self) {
        self.temperature_controller_back.disable();
        self.temperature_controller_front.disable();
@@ -327,15 +133,6 @@ impl ExtruderV2 {
        self.temperature_controller_nozzle.disable();
    }

-    fn enable_heating(&mut self) {
-        self.temperature_controller_back.allow_heating();
-        self.temperature_controller_front.allow_heating();
-        self.temperature_controller_middle.allow_heating();
-        self.temperature_controller_nozzle.allow_heating();
-        self.emit_state();
-    }
-
-    // Turn heating OFF and do nothing
    fn switch_to_standby(&mut self) {
        match self.mode {
            ExtruderV2Mode::Standby => (),
@@ -352,9 +149,7 @@ impl ExtruderV2 {
        self.mode = ExtruderV2Mode::Standby;
    }

-    // turn off motor if on and keep heating on
    fn switch_to_heat(&mut self) {
-        // From what mode are we transitioning ?
        match self.mode {
            ExtruderV2Mode::Standby => self.enable_heating(),
            ExtruderV2Mode::Heat => (),
@@ -366,7 +161,6 @@ impl ExtruderV2 {
        self.mode = ExtruderV2Mode::Heat;
    }

-    // keep heating on, and turn motor on
    fn switch_to_extrude(&mut self) {
        match self.mode {
            ExtruderV2Mode::Standby => {
@@ -379,7 +173,7 @@ impl ExtruderV2 {
                self.enable_heating();
                self.screw_speed_controller.reset_pid();
            }
-            ExtruderV2Mode::Extrude => (), // Do nothing, we are already extruding
+            ExtruderV2Mode::Extrude => (),
        }
        self.mode = ExtruderV2Mode::Extrude;
    }
@@ -395,85 +189,8 @@ impl ExtruderV2 {
            ExtruderV2Mode::Extrude => self.switch_to_extrude(),
        }
    }
-}
-
-impl ExtruderV2 {
-    fn set_rotation_state(&mut self, forward: bool) {
-        self.screw_speed_controller.set_rotation_direction(forward);
-        self.emit_state();
-    }

    fn reset_inverter(&mut self) {
        self.screw_speed_controller.inverter.reset_inverter();
    }
-
-    fn set_mode_state(&mut self, mode: ExtruderV2Mode) {
-        self.switch_mode(mode);
-        self.emit_state();
-    }
-}
-
-// Motor
-impl ExtruderV2 {
-    fn set_regulation(&mut self, uses_rpm: bool) {
-        if !self.screw_speed_controller.get_uses_rpm() && uses_rpm {
-            self.screw_speed_controller
-                .set_target_screw_rpm(self.screw_speed_controller.target_rpm);
-            self.screw_speed_controller.set_uses_rpm(uses_rpm);
-        }
-
-        if self.screw_speed_controller.get_uses_rpm() && !uses_rpm {
-            self.screw_speed_controller.set_uses_rpm(uses_rpm);
-            self.screw_speed_controller.start_pressure_regulation();
-        }
-        self.emit_state();
-    }
-
-    fn set_target_pressure(&mut self, pressure: f64) {
-        let pressure = Pressure::new::<bar>(pressure);
-        self.screw_speed_controller.set_target_pressure(pressure);
-        self.emit_state();
-    }
-
-    fn set_target_rpm(&mut self, rpm: f64) {
-        let revolution_per_minutes = AngularVelocity::new::<revolution_per_minute>(rpm);
-        self.screw_speed_controller
-            .set_target_screw_rpm(revolution_per_minutes);
-        self.emit_state();
-    }
-}
-
-// Heating
-impl ExtruderV2 {
-    fn set_target_temperature(&mut self, target_temperature: f64, heating_type: HeatingType) {
-        let target_temp = ThermodynamicTemperature::new::<degree_celsius>(target_temperature);
-
-        match heating_type {
-            HeatingType::Nozzle => self
-                .temperature_controller_nozzle
-                .set_target_temperature(target_temp),
-
-            HeatingType::Front => self
-                .temperature_controller_front
-                .set_target_temperature(target_temp),
-
-            HeatingType::Back => self
-                .temperature_controller_back
-                .set_target_temperature(target_temp),
-
-            HeatingType::Middle => self
-                .temperature_controller_middle
-                .set_target_temperature(target_temp),
-        }
-        self.emit_state();
-    }
-}
-
-impl ExtruderV2 {
-    fn configure_pressure_pid(&mut self, settings: PidSettings) {
-        self.screw_speed_controller
-            .pid
-            .configure(settings.ki, settings.kp, settings.kd);
-        self.emit_state();
-    }
 }
@@ -1,3 +1,4 @@
+#[cfg(not(feature = "mock-machine"))]
 use super::{
    ExtruderV2, ExtruderV2Mode, Heating, api::ExtruderV2Namespace, mitsubishi_cs80::MitsubishiCS80,
    screw_speed_controller::ScrewSpeedController,
@@ -40,6 +41,7 @@ use uom::si::{
    thermodynamic_temperature::degree_celsius,
 };

+#[cfg(not(feature = "mock-machine"))]
 impl MachineNewTrait for ExtruderV2 {
    fn new<'maindevice>(params: &MachineNewParams) -> Result<Self, Error> {
        // validate general stuff
@@ -19,6 +19,7 @@ use std::time::{Duration, Instant};
 ///
 impl MachineAct for LaserMachine {
    fn act(&mut self, now: Instant) {
+        self.update();
        // more than 33ms have passed since last emit (30 "fps" target)
        if now.duration_since(self.last_measurement_emit) > Duration::from_secs_f64(1.0 / 30.0) {
            self.emit_live_values();
@@ -21,8 +21,9 @@ use tracing::instrument;
 pub struct LiveValuesEvent {
    /// diameter measurement in mm
    pub diameter: f64,
-    pub x_value: Option<f64>,
-    pub y_value: Option<f64>,
+    pub x_diameter: Option<f64>,
+    pub y_diameter: Option<f64>,
+    pub roundness: Option<f64>,
 }

 impl LiveValuesEvent {
@@ -24,6 +24,12 @@ pub struct LaserMachine {
    namespace: LaserMachineNamespace,
    last_measurement_emit: Instant,

+    // laser values
+    diameter: Length,
+    x_diameter: Option<Length>,
+    y_diameter: Option<Length>,
+    roundness: Option<f64>,
+
    //laser target configuration
    laser_target: LaserTarget,

@@ -42,26 +48,16 @@ impl LaserMachine {
 impl LaserMachine {
    ///diameter in mm
    pub fn emit_live_values(&mut self) {
-        let laser_data = smol::block_on(async { self.laser.read().await.get_data().await });
-        let diameter = laser_data
-            .as_ref()
-            .map(|data| data.diameter.get::<millimeter>())
-            .unwrap_or(0.0);
-
-        let x_value = laser_data
-            .as_ref()
-            .and_then(|data| data.x_axis.as_ref())
-            .map(|x| x.get::<millimeter>());
-
-        let y_value = laser_data
-            .as_ref()
-            .and_then(|data| data.y_axis.as_ref())
-            .map(|y| y.get::<millimeter>());
+        let diameter = self.diameter.get::<millimeter>();
+        let x_diameter = self.x_diameter.map(|x| x.get::<millimeter>());
+        let y_diameter = self.y_diameter.map(|y| y.get::<millimeter>());
+        let roundness = self.roundness;

        let live_values = LiveValuesEvent {
            diameter,
-            x_value,
-            y_value,
+            x_diameter,
+            y_diameter,
+            roundness,
        };
        self.namespace
            .emit(LaserEvents::LiveValues(live_values.build()));
@@ -107,7 +103,52 @@ impl LaserMachine {
        self.laser_target.diameter = Length::new::<millimeter>(target_diameter);
        self.emit_state();
    }
+
+    ///
+    /// Roundness = min(x, y) / max(x, y)
+    ///
+    fn calculate_roundness(&mut self) -> Option<f64> {
+        match (self.x_diameter, self.y_diameter) {
+            (Some(x), Some(y)) => {
+                let x_val = x.get::<millimeter>();
+                let y_val = y.get::<millimeter>();
+
+                if x_val > 0.0 && y_val > 0.0 {
+                    let roundness = f64::min(x_val, y_val) / f64::max(x_val, y_val);
+                    Some(roundness)
+                } else if x_val == 0.0 && y_val == 0.0 {
+                    Some(0.0)
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    }
+
+    pub fn update(&mut self) {
+        let laser_data = smol::block_on(async { self.laser.read().await.get_data().await });
+        self.diameter = Length::new::<millimeter>(
+            laser_data
+                .as_ref()
+                .map(|data| data.diameter.get::<millimeter>())
+                .unwrap_or(0.0),
+        );
+
+        self.x_diameter = laser_data
+            .as_ref()
+            .and_then(|data| data.x_axis.as_ref())
+            .cloned();
+
+        self.y_diameter = laser_data
+            .as_ref()
+            .and_then(|data| data.y_axis.as_ref())
+            .cloned();
+
+        self.roundness = self.calculate_roundness();
+    }
 }
+
 #[derive(Debug, Clone)]
 pub struct LaserTarget {
    diameter: Length,
@@ -5,7 +5,10 @@ use crate::serial::{devices::laser::Laser, registry::SERIAL_DEVICE_REGISTRY};
 use super::{LaserMachine, LaserTarget, api::LaserMachineNamespace};
 use anyhow::Error;
 use control_core::machines::new::MachineNewTrait;
-use uom::si::{f64::Length, length::millimeter};
+use uom::{
+    ConstZero,
+    si::{f64::Length, length::millimeter},
+};

 impl MachineNewTrait for LaserMachine {
    fn new(
@@ -39,6 +42,10 @@ impl MachineNewTrait for LaserMachine {
            last_measurement_emit: Instant::now(),
            laser_target,
            emitted_default_state: false,
+            diameter: Length::ZERO,
+            x_diameter: None,
+            y_diameter: None,
+            roundness: None,
        };

        // Emit initial state
@@ -1,7 +1,11 @@
-use crate::machines::{
-    buffer1::BufferV1, extruder1::ExtruderV2, laser::LaserMachine, mock::MockMachine,
-    winder2::Winder2,
-};
+#[cfg(feature = "mock-machine")]
+use crate::machines::{extruder1::mock::ExtruderV2, mock::MockMachine};
+
+#[cfg(not(feature = "mock-machine"))]
+use crate::machines::extruder1::ExtruderV2;
+
+use crate::machines::{buffer1::BufferV1, laser::LaserMachine, winder2::Winder2};
+
 use control_core::machines::registry::MachineRegistry;
 use lazy_static::lazy_static;

@@ -11,6 +15,7 @@ lazy_static! {
        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);
        mc.register::<BufferV1>(BufferV1::MACHINE_IDENTIFICATION);
        mc
@@ -16,6 +16,10 @@ impl MachineAct for Winder2 {
        // automatically stops or pulls after N Meters if enabled
        self.stop_or_pull_spool(now);

+        if self.traverse_controller.did_change_state() {
+            self.emit_state();
+        }
+
        // more than 33ms have passed since last emit (30 "fps" target)
        if now.duration_since(self.last_measurement_emit) > Duration::from_secs_f64(1.0 / 30.0) {
            self.emit_live_values();
@@ -0,0 +1,398 @@
+use crate::machines::buffer1::BufferV1;
+use crate::machines::winder2::api::{
+    ConnectedMachineState, LiveValuesEvent, ModeState, PullerState, SpoolAutomaticActionMode,
+    SpoolAutomaticActionState, SpoolSpeedControllerState, StateEvent, TensionArmState,
+    TraverseState, Winder2Events,
+};
+use crate::machines::winder2::puller_speed_controller::PullerRegulationMode;
+use crate::machines::winder2::{Winder2, Winder2Mode, spool_speed_controller};
+use control_core::machines::identification::MachineIdentificationUnique;
+use control_core::machines::{ConnectedMachine, ConnectedMachineData, downcast_machine};
+use control_core::socketio::event::BuildEvent;
+use control_core::socketio::namespace::NamespaceCacheingLogic;
+use control_core::uom_extensions::velocity::meter_per_minute;
+use smol::block_on;
+use smol::lock::Mutex;
+use std::sync::Arc;
+use uom::si::angle::degree;
+use uom::si::angular_velocity::revolution_per_minute;
+use uom::si::f64::{Length, Velocity};
+use uom::si::length::{meter, millimeter};
+
+impl Winder2 {
+    // --- Traverse functions ---
+    pub fn traverse_set_limit_inner(&mut self, limit: f64) {
+        let new_inner = Length::new::<meter>(limit);
+        let current_outer = self.traverse_controller.get_limit_outer();
+        if !Self::validate_traverse_limits(new_inner, current_outer) {
+            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::<meter>(limit);
+        let current_inner = self.traverse_controller.get_limit_inner();
+        if !Self::validate_traverse_limits(current_inner, new_outer) {
+            return;
+        }
+        self.traverse_controller.set_limit_outer(new_outer);
+        self.emit_state();
+    }
+
+    pub fn traverse_set_step_size(&mut self, step_size: f64) {
+        self.traverse_controller
+            .set_step_size(Length::new::<meter>(step_size));
+        self.emit_state();
+    }
+
+    pub fn traverse_set_padding(&mut self, padding: f64) {
+        self.traverse_controller
+            .set_padding(Length::new::<meter>(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();
+    }
+
+    // --- Mode / Puller / Spool functions ---
+    pub fn set_mode(&mut self, mode: &Winder2Mode) {
+        let should_update = *mode != Winder2Mode::Wind || self.can_wind();
+        if should_update {
+            self.mode = mode.clone();
+            self.set_spool_mode(mode);
+            self.set_puller_mode(mode);
+            self.set_traverse_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();
+    }
+
+    pub fn puller_set_target_speed(&mut self, target_speed: f64) {
+        let target_speed = Velocity::new::<uom::si::velocity::meter_per_second>(target_speed);
+        self.puller_speed_controller.set_target_speed(target_speed);
+        self.emit_state();
+    }
+
+    pub fn puller_set_target_diameter(&mut self, target_diameter: f64) {
+        let target_diameter = Length::new::<meter>(target_diameter);
+        self.puller_speed_controller
+            .set_target_diameter(target_diameter);
+        self.emit_state();
+    }
+
+    pub fn puller_set_forward(&mut self, forward: bool) {
+        self.puller_speed_controller.set_forward(forward);
+        self.emit_state();
+    }
+
+    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();
+    }
+
+    pub fn spool_set_minmax_min_speed(&mut self, min_speed_rpm: f64) {
+        let min_speed = uom::si::f64::AngularVelocity::new::<
+            uom::si::angular_velocity::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();
+    }
+
+    pub fn spool_set_minmax_max_speed(&mut self, max_speed_rpm: f64) {
+        let max_speed = uom::si::f64::AngularVelocity::new::<
+            uom::si::angular_velocity::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();
+    }
+
+    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();
+    }
+
+    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();
+    }
+
+    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();
+    }
+
+    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();
+    }
+
+    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();
+    }
+
+    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 set_connected_buffer(
+        &mut self,
+        machine_identification_unique: MachineIdentificationUnique,
+    ) {
+        if !matches!(
+            machine_identification_unique.machine_identification,
+            BufferV1::MACHINE_IDENTIFICATION
+        ) {
+            return;
+        }
+        let machine_manager_arc = match self.machine_manager.upgrade() {
+            Some(machine_manager_arc) => machine_manager_arc,
+            None => return,
+        };
+        let machine_manager_guard = block_on(machine_manager_arc.read());
+        let buffer_weak = machine_manager_guard.get_machine_weak(&machine_identification_unique);
+        let buffer_weak = match buffer_weak {
+            Some(buffer_weak) => buffer_weak,
+            None => return,
+        };
+        let buffer_strong = match buffer_weak.upgrade() {
+            Some(buffer_strong) => buffer_strong,
+            None => return,
+        };
+
+        let buffer: Arc<Mutex<BufferV1>> = block_on(downcast_machine::<BufferV1>(buffer_strong))
+            .expect("failed downcasting machine");
+
+        let machine = Arc::downgrade(&buffer);
+
+        self.connected_buffer = Some(ConnectedMachine {
+            machine_identification_unique,
+            machine,
+        });
+        self.emit_state();
+
+        self.reverse_connect();
+    }
+
+    pub fn disconnect_buffer(
+        &mut self,
+        machine_identification_unique: MachineIdentificationUnique,
+    ) {
+        if !matches!(
+            machine_identification_unique.machine_identification,
+            BufferV1::MACHINE_IDENTIFICATION
+        ) {
+            return;
+        }
+        if let Some(connected) = &self.connected_buffer {
+            if let Some(buffer_arc) = connected.machine.upgrade() {
+                let future = async move {
+                    let mut buffer = buffer_arc.lock().await;
+                    if buffer.connected_winder.is_some() {
+                        buffer.connected_winder = None;
+                        buffer.emit_state();
+                    }
+                };
+                smol::spawn(future).detach();
+            }
+        }
+        self.connected_buffer = None;
+
+        self.emit_state();
+    }
+
+    pub fn tension_arm_zero(&mut self) {
+        self.tension_arm.zero();
+        self.emit_live_values();
+        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: ConnectedMachineState {
+                machine_identification_unique: self.connected_buffer.as_ref().map(
+                    |connected_machine| {
+                        ConnectedMachineData::from(connected_machine).machine_identification_unique
+                    },
+                ),
+                is_available: self
+                    .connected_buffer
+                    .as_ref()
+                    .map(|connected_machine| {
+                        ConnectedMachineData::from(connected_machine).is_available
+                    })
+                    .unwrap_or(false),
+            },
+        }
+    }
+    pub fn emit_state(&mut self) {
+        let state_event = self.build_state_event();
+        let event = state_event.build();
+        self.namespace.emit(Winder2Events::State(event));
+    }
+}
@@ -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;
@@ -9,52 +10,38 @@ pub mod puller_speed_controller;
 pub mod spool_speed_controller;
 pub mod tension_arm;
 pub mod traverse_controller;
-use api::{
-    LiveValuesEvent, ModeState, PullerState, SpoolAutomaticActionMode, SpoolAutomaticActionState,
-    SpoolSpeedControllerState, StateEvent, TensionArmState, TraverseState, Winder2Events,
-    Winder2Namespace,
-};
-use control_core::socketio::event::BuildEvent;
+
+use api::{SpoolAutomaticActionMode, Winder2Namespace};
 use control_core::{
    converters::angular_step_converter::AngularStepConverter,
    machines::{
-        ConnectedMachine, ConnectedMachineData, downcast_machine,
+        ConnectedMachine,
        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 futures::executor::block_on;
-use puller_speed_controller::{PullerRegulationMode, PullerSpeedController};
+use puller_speed_controller::PullerSpeedController;
 use smol::lock::{Mutex, RwLock};
 use spool_speed_controller::SpoolSpeedController;
-use std::{
-    fmt::Debug,
-    sync::{Arc, Weak},
-    time::Instant,
-};
+use std::{fmt::Debug, sync::Weak, time::Instant};
 use tension_arm::TensionArm;
 use traverse_controller::TraverseController;
 use uom::{
    ConstZero,
    si::{
-        angle::degree,
-        angular_velocity::revolution_per_minute,
-        f64::{Length, Velocity},
+        f64::Length,
        length::{meter, millimeter},
        velocity::meter_per_second,
    },
 };

-use crate::machines::{
-    MACHINE_WINDER_V1, VENDOR_QITECH, buffer1::BufferV1, winder2::api::ConnectedMachineState,
-};
+use crate::machines::{MACHINE_WINDER_V1, VENDOR_QITECH, buffer1::BufferV1};

 #[derive(Debug)]
 pub struct SpoolAutomaticAction {
@@ -116,224 +103,16 @@ impl Winder2 {
    };
 }

-/// Implement Traverse
+/// Implement Traverse helpers
 impl Winder2 {
    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
    fn validate_traverse_limits(inner: Length, outer: Length) -> bool {
        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: ConnectedMachineState {
-                machine_identification_unique: self.connected_buffer.as_ref().map(
-                    |connected_machine| {
-                        ConnectedMachineData::from(connected_machine).machine_identification_unique
-                    },
-                ),
-                is_available: self
-                    .connected_buffer
-                    .as_ref()
-                    .map(|connected_machine| {
-                        ConnectedMachineData::from(connected_machine).is_available
-                    })
-                    .unwrap_or(false),
-            },
-        }
-    }
-
-    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,
@@ -342,19 +121,13 @@ impl Winder2 {
        )
    }

-    /// Can wind capability check
    pub const fn can_wind(&self) -> bool {
-        // Check if tension arm is zeroed and traverse is homed
        self.tension_arm.zeroed
            && self.traverse_controller.is_homed()
            && !self.traverse_controller.is_going_home()
    }

-    /// Can go to inner limit capability check
    pub fn can_go_in(&self) -> bool {
-        // Check if traverse is homed, not in standby, not traversing
-        // Allow changing direction (even when going out)
-        // Disallow when homing is in progress
        self.traverse_controller.is_homed()
            && self.traverse_mode != TraverseMode::Standby
            && !self.traverse_controller.is_going_in()
@@ -363,11 +136,7 @@ impl Winder2 {
            && self.mode != Winder2Mode::Wind
    }

-    /// Can go to outer limit capability check
    pub fn can_go_out(&self) -> bool {
-        // Check if traverse is homed, not in standby, not traversing
-        // Allow changing direction (even when going in)
-        // Disallow when homing is in progress
        self.traverse_controller.is_homed()
            && self.traverse_mode != TraverseMode::Standby
            && !self.traverse_controller.is_going_out()
@@ -376,10 +145,7 @@ impl Winder2 {
            && self.mode != Winder2Mode::Wind
    }

-    /// Can go home capability check
    pub fn can_go_home(&self) -> bool {
-        // Check if not in standby, not traversing
-        // Allow going home even when going in or out
        self.traverse_mode != TraverseMode::Standby
            && !self.traverse_controller.is_going_home()
            && !self.traverse_controller.is_traversing()
@@ -387,211 +153,98 @@ impl Winder2 {
    }
 }

-impl Winder2 {}
-
-/// Implement Mode
+/// Implement Mode transitions (without emit)
 impl Winder2 {
-    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.
-    /// It will set [`Self::spool_mode`]
    fn set_spool_mode(&mut self, mode: &Winder2Mode) {
-        // Convert to `Winder2Mode` to `SpoolMode`
        let mode: SpoolMode = mode.clone().into();
-
-        // Transition matrix
        match self.spool_mode {
            SpoolMode::Standby => match mode {
-                SpoolMode::Standby => {}
-                SpoolMode::Hold => {
-                    // From [`SpoolMode::Standby`] to [`SpoolMode::Hold`]
-                    self.spool.set_enabled(true);
-                }
+                SpoolMode::Hold => self.spool.set_enabled(true),
                SpoolMode::Wind => {
                    self.spool.set_enabled(true);
-                    // self.spool_speed_controller.reset();
                    self.spool_speed_controller.set_enabled(true);
                }
+                _ => {}
            },
            SpoolMode::Hold => match mode {
-                SpoolMode::Standby => {
-                    // From [`SpoolMode::Hold`] to [`SpoolMode::Standby`]
-                    self.spool.set_enabled(false);
-                }
-                SpoolMode::Hold => {}
-                SpoolMode::Wind => {
-                    // From [`SpoolMode::Hold`] to [`SpoolMode::Wind`]
-                    // self.spool_speed_controller.reset();
-                    self.spool_speed_controller.set_enabled(true);
-                }
+                SpoolMode::Standby => self.spool.set_enabled(false),
+                SpoolMode::Wind => self.spool_speed_controller.set_enabled(true),
+                _ => {}
            },
            SpoolMode::Wind => match mode {
                SpoolMode::Standby => {
-                    // From [`SpoolMode::Wind`] to [`SpoolMode::Standby`]
                    self.spool.set_enabled(false);
                    self.spool_speed_controller.set_enabled(false);
                }
-                SpoolMode::Hold => {
-                    // From [`SpoolMode::Wind`] to [`SpoolMode::Hold`]
-                    self.spool_speed_controller.set_enabled(false);
-                }
-                SpoolMode::Wind => {}
+                SpoolMode::Hold => self.spool_speed_controller.set_enabled(false),
+                _ => {}
            },
        }
-
-        // Update the internal state
        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 => self.traverse_controller.goto_home(),
+                TraverseMode::Traverse => 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 => 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 => {}
+                TraverseMode::Hold => self.traverse_controller.goto_home(),
+                _ => {}
            },
        }

-        // 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.
-    /// It will set [`Self::puller_mode`]
    fn set_puller_mode(&mut self, mode: &Winder2Mode) {
-        // Convert to `Winder2Mode` to `PullerMode`
        let mode: PullerMode = mode.clone().into();
-
-        // Transition matrix
        match self.puller_mode {
            PullerMode::Standby => match mode {
-                PullerMode::Standby => {}
-                PullerMode::Hold => {
-                    // From [`PullerMode::Standby`] to [`PullerMode::Hold`]
-                    self.puller.set_enabled(true);
-                }
+                PullerMode::Hold => self.puller.set_enabled(true),
                PullerMode::Pull => {
-                    // From [`PullerMode::Standby`] to [`PullerMode::Pull`]
                    self.puller.set_enabled(true);
                    self.puller_speed_controller.set_enabled(true);
                }
+                _ => {}
            },
            PullerMode::Hold => match mode {
-                PullerMode::Standby => {
-                    // From [`PullerMode::Hold`] to [`PullerMode::Standby`]
-                    self.puller.set_enabled(false);
-                }
-                PullerMode::Hold => {}
-                PullerMode::Pull => {
-                    // From [`PullerMode::Hold`] to [`PullerMode::Pull`]
-                    self.puller_speed_controller.set_enabled(true);
-                }
+                PullerMode::Standby => self.puller.set_enabled(false),
+                PullerMode::Pull => self.puller_speed_controller.set_enabled(true),
+                _ => {}
            },
            PullerMode::Pull => match mode {
                PullerMode::Standby => {
-                    // From [`PullerMode::Pull`] to [`PullerMode::Standby`]
                    self.puller.set_enabled(false);
                    self.puller_speed_controller.set_enabled(false);
                }
-                PullerMode::Hold => {
-                    // From [`PullerMode::Pull`] to [`PullerMode::Hold`]
-                    self.puller_speed_controller.set_enabled(false);
-                }
-                PullerMode::Pull => {}
+                PullerMode::Hold => self.puller_speed_controller.set_enabled(false),
+                _ => {}
            },
        }
-
-        // Update the internal state
        self.puller_mode = mode;
    }
 }

-/// Implement Tension Arm
+/// Implement Spool calculations
 impl Winder2 {
-    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
-impl Winder2 {
-    /// called by `act`
    pub fn sync_spool_speed(&mut self, t: Instant) {
        let angular_velocity = self.spool_speed_controller.update_speed(
            t,
@@ -604,16 +257,6 @@ impl Winder2 {
        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,
@@ -624,8 +267,7 @@ impl Winder2 {
        }

        match self.mode {
-            Winder2Mode::Pull => self.calculate_spool_auto_progress_(now),
-            Winder2Mode::Wind => self.calculate_spool_auto_progress_(now),
+            Winder2Mode::Pull | Winder2Mode::Wind => self.calculate_spool_auto_progress_(now),
            _ => {
                self.spool_automatic_action.progress_last_check = now;
                return;
@@ -634,15 +276,15 @@ impl Winder2 {

        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);
+                    self.mode = Winder2Mode::Pull;
                }
                SpoolAutomaticActionMode::Hold => {
                    self.stop_or_pull_spool_reset(now);
-                    self.set_mode(&Winder2Mode::Hold);
+                    self.mode = Winder2Mode::Hold;
                }
+                _ => {}
            }
        }
    }
@@ -653,12 +295,10 @@ 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();

-        // Calculate distance pulled during this time interval
        let meters_pulled_this_interval = Length::new::<meter>(
            self.puller_speed_controller
                .last_speed
@@ -666,15 +306,13 @@ impl Winder2 {
                * dt,
        );

-        // Update total meters pulled
        self.spool_automatic_action.progress += meters_pulled_this_interval;
        self.spool_automatic_action.progress_last_check = now;
    }
 }

-/// Implement Puller
+/// Implement Puller calculations
 impl Winder2 {
-    /// called by `act`
    pub fn sync_puller_speed(&mut self, t: Instant) {
        let angular_velocity = self.puller_speed_controller.calc_angular_velocity(t);
        let steps_per_second = self
@@ -683,172 +321,10 @@ 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) {
-        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
+/// Implement machine connection helpers (without emit)
 impl Winder2 {
-    /// 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;
-        }
-        let machine_manager_arc = match self.machine_manager.upgrade() {
-            Some(machine_manager_arc) => machine_manager_arc,
-            None => return,
-        };
-        let machine_manager_guard = block_on(machine_manager_arc.read());
-        let buffer_weak = machine_manager_guard.get_machine_weak(&machine_identification_unique);
-        let buffer_weak = match buffer_weak {
-            Some(buffer_weak) => buffer_weak,
-            None => return,
-        };
-        let buffer_strong = match buffer_weak.upgrade() {
-            Some(buffer_strong) => buffer_strong,
-            None => return,
-        };
-
-        let buffer: Arc<Mutex<BufferV1>> = block_on(downcast_machine::<BufferV1>(buffer_strong))
-            .expect("failed downcasting machine");
-
-        let machine = Arc::downgrade(&buffer);
-
-        self.connected_buffer = Some(ConnectedMachine {
-            machine_identification_unique,
-            machine,
-        });
-        self.emit_state();
-
-        self.reverse_connect();
-    }
-
-    /// disconnect buffer
-    pub fn disconnect_buffer(
-        &mut self,
-        machine_identification_unique: MachineIdentificationUnique,
-    ) {
-        if !matches!(
-            machine_identification_unique.machine_identification,
-            BufferV1::MACHINE_IDENTIFICATION
-        ) {
-            return;
-        }
-        if let Some(connected) = &self.connected_buffer {
-            if let Some(buffer_arc) = connected.machine.upgrade() {
-                let future = async move {
-                    let mut buffer = buffer_arc.lock().await;
-                    if buffer.connected_winder.is_some() {
-                        buffer.connected_winder = None;
-                        buffer.emit_state();
-                    }
-                };
-                smol::spawn(future).detach();
-            }
-        }
-        self.connected_buffer = None;
-        self.emit_state();
-    }
-
-    /// initiate connection from buffer to winder
    pub fn reverse_connect(&mut self) {
        let machine_identification_unique = self.machine_identification_unique.clone();
        if let Some(connected) = &self.connected_buffer {
@@ -865,6 +341,7 @@ impl Winder2 {
    }
 }

+// Enums
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Winder2Mode {
    Standby,
@@ -932,52 +409,3 @@ impl std::fmt::Display for Winder2 {
        write!(f, "Winder2")
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use uom::si::{f64::Length, length::millimeter};
-
-    #[test]
-    fn test_validate_traverse_limits() {
-        // Test case 1: Valid limits with exactly 1.0mm difference (should pass)
-        let inner = Length::new::<millimeter>(15.0);
-        let outer = Length::new::<millimeter>(16.0);
-        assert!(Winder2::validate_traverse_limits(inner, outer));
-
-        // Test case 2: Invalid limits with exactly 0.9mm difference (should fail)
-        let inner = Length::new::<millimeter>(15.0);
-        let outer = Length::new::<millimeter>(15.9);
-        assert!(!Winder2::validate_traverse_limits(inner, outer));
-
-        // Test case 3: Invalid limits with less than 0.9mm difference (should fail)
-        let inner = Length::new::<millimeter>(15.0);
-        let outer = Length::new::<millimeter>(15.5);
-        assert!(!Winder2::validate_traverse_limits(inner, outer));
-
-        // Test case 4: Invalid limits where inner equals outer (should fail)
-        let inner = Length::new::<millimeter>(20.0);
-        let outer = Length::new::<millimeter>(20.0);
-        assert!(!Winder2::validate_traverse_limits(inner, outer));
-
-        // Test case 5: Invalid limits where inner is greater than outer (should fail)
-        let inner = Length::new::<millimeter>(25.0);
-        let outer = Length::new::<millimeter>(20.0);
-        assert!(!Winder2::validate_traverse_limits(inner, outer));
-
-        // Test case 6: Valid limits with large difference (should pass)
-        let inner = Length::new::<millimeter>(10.0);
-        let outer = Length::new::<millimeter>(80.0);
-        assert!(Winder2::validate_traverse_limits(inner, outer));
-
-        // Test case 7: Edge case - exactly 0.91mm difference (should pass)
-        let inner = Length::new::<millimeter>(15.0);
-        let outer = Length::new::<millimeter>(15.91);
-        assert!(Winder2::validate_traverse_limits(inner, outer));
-
-        // Test case 8: Edge case - exactly 0.89mm difference (should fail)
-        let inner = Length::new::<millimeter>(15.0);
-        let outer = Length::new::<millimeter>(15.89);
-        assert!(!Winder2::validate_traverse_limits(inner, outer));
-    }
-}
@@ -1,4 +1,6 @@
 #[cfg(feature = "mock-machine")]
+use crate::serial::devices::extruder_mock::ExtruderMockSerialDevice;
+#[cfg(feature = "mock-machine")]
 use {
    crate::app_state::AppState,
    crate::machines::registry::MACHINE_REGISTRY,
@@ -10,7 +12,6 @@ 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
@@ -48,12 +49,44 @@ pub fn init_mock(app_state: Arc<AppState>) -> Result<(), anyhow::Error> {
                    .main_namespace;
                let event = MachinesEventBuilder().build(app_state_event.clone()).await;
                main_namespace.emit(MainNamespaceEvents::MachinesEvent(event));
-                Ok(())
+                Ok::<(), anyhow::Error>(())
            }
            Err(e) => {
                tracing::error!("Failed to create mock serial device: {}", e);
                return Err(e);
            }
+        };
+
+        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()).await;
+                main_namespace.emit(MainNamespaceEvents::MachinesEvent(event));
+                Ok(())
+            }
+            Err(e) => {
+                tracing::error!("Failed to create extruder mock serial device: {}", e);
+                return Err(e);
+            }
        }
    });
 }
@@ -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_EXTRUDER_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 ExtruderMockSerialDevice {
+    pub path: String,
+}
+
+impl SerialDevice for ExtruderMockSerialDevice {}
+
+impl SerialDeviceNew for ExtruderMockSerialDevice {
+    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_EXTRUDER_V1,
+                    },
+                    serial,
+                },
+                role: 0,
+            }),
+            device_hardware_identification: DeviceHardwareIdentification::Serial(
+                DeviceHardwareIdentificationSerial {
+                    path: params.path.clone(),
+                },
+            ),
+        };
+
+        let mock_serial_device = Arc::new(RwLock::new(ExtruderMockSerialDevice {
+            path: params.path.clone(),
+        }));
+
+        Ok((device_identification, mock_serial_device))
+    }
+}
@@ -1,4 +1,5 @@
+#[cfg(feature = "mock-machine")]
+pub mod extruder_mock;
 pub mod laser;
-
 #[cfg(feature = "mock-machine")]
 pub mod mock;
Author	SHA1	Message	Date
kraemr	48fdde61dc	further improved readability by moving feature flags to mod.rs	2025-09-29 11:30:54 +02:00
kraemr	7bc700ac5f	when selecting mock-machine feature extruder now appears as well	2025-09-29 11:30:54 +02:00
93094049+kraemr@users.noreply.github.com	bdd6147f92	rewrote extruder and winder, also added mock-machine for extruder	2025-09-29 11:30:54 +02:00
93094049+kraemr@users.noreply.github.com	f7f65bdaaa	refactored all emit functions out of mod.rs for clarity for extruder	2025-09-29 11:30:54 +02:00
Robin Krämer	232b0782ca	Merge pull request #754 from qitechgmbh/748-add-feature-flag-or-env-var-for-setting-loop-timeout 748 add feature flag or env var for setting loop timeout	2025-09-29 11:30:19 +02:00
kraemr	c3c36a26b6	also added development-build flag to irq affinity code	2025-09-25 17:11:18 +02:00
kraemr	7f22bdfbf2	added feature development-build to set timeout	2025-09-25 17:06:42 +02:00
Robin Krämer	ff4c579f7b	Merge pull request #673 from qitechgmbh/632-add-documentation-for-creating-a-new-machine added documentation for adding a machine	2025-09-25 15:33:41 +02:00
93094049+kraemr@users.noreply.github.com	9683882775	added documentation for adding a machine	2025-09-25 15:32:33 +02:00
Robin Krämer	893e01532d	Merge pull request #753 from qitechgmbh/633-update-documentation-for-adding-new-devices updated devices documentation by adding an example and explaining the architecture	2025-09-25 14:53:17 +02:00
kraemr	713f78fa4e	updated devices documentation by adding an example and explaining how devices fit into the architecture	2025-09-25 14:50:32 +02:00
Robin Krämer	f444347fb9	Merge pull request #752 from qitechgmbh/751-document-performancestability-tweaks-made added performance and stabillity documentation	2025-09-25 11:37:04 +02:00
kraemr	ea03c0f755	added performance and stabillity documentation	2025-09-25 11:31:53 +02:00
Robin Krämer	e283a0f164	Merge pull request #745 from qitechgmbh/744-windermode-switch-from-modewind-to-modepull-or-modehold-disables-the-wind-button fixed emit state after state change	2025-09-23 15:41:28 +02:00
snacj	6820206d78	fixed emit state after state change	2025-09-23 15:38:47 +02:00
Robin Krämer	5069ee425c	Merge pull request #742 from qitechgmbh/681-remove-unused-or-redundant-crates removed unused crates	2025-09-23 13:37:48 +02:00
kraemr	f93f342508	added ignores for cargo machete	2025-09-23 13:17:29 +02:00
kraemr	c6d3563101	removed unused crates	2025-09-23 12:56:24 +02:00
Robin Krämer	f2f893c917	Merge pull request #741 from qitechgmbh/739-add-roundness-value-to-laser-graph-and-control-page Added Roundness Value to 2 Axis Laser	2025-09-22 14:27:30 +02:00
Robin KrämerandCopilot	bbbca4085d	Update server/src/machines/laser/mod.rs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2025-09-22 14:24:42 +02:00
Robin KrämerandCopilot	4fdf461520	Update server/src/machines/laser/mod.rs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2025-09-22 14:23:37 +02:00
snacj	dcfc6728ba	Made Roundness unitless	2025-09-22 14:10:25 +02:00
snacj	2673a92f50	Added Roundness Value to 2 Axis Laser	2025-09-22 13:39:59 +02:00