first working wago blink example

Revert "Merge pull request #914 from qitechgmbh/bin-directory"

.github/workflows/rust.yml

@@ -46,3 +46,6 @@ jobs:
 
       - name: Run tests
         run: cargo test --verbose
+
+      - name: Mock Machine
+        run: cargo build --features development-build --features mock-machine

.gitignore

@@ -4,4 +4,7 @@ dist/
 Cargo.lock
 dhat-heap.json
 build.sh
-
+shell.nix
+node_modules/
+runtime_metrics.csv
+compile_metrics.csv

CHANGELOG.md

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

Cargo.toml

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

README.md

@@ -74,7 +74,9 @@ We could combine the code of the frontend and backend using [Doxius](https://dio
 | Laser        | V1      | ???          | Diameter Measuring Laser    | -                                                      | 1 (Qitech Industries GmbH) | 6          | Yes         |                                 |
 | Mock         | -       | ???          | Mock Machine for Testing    | -                                                      | 1 (Qitech Industries GmbH) | 7          | Yes         | -                               |
 
-# More Docs
+# More Docs    docs
+
+/assets
 
 - [x] [Architecture & Data Flow](./docs/architecture-overview.md)
 
@@ -152,3 +154,404 @@ We could combine the code of the frontend and backend using [Doxius](https://dio
 - [x] [Ethercat Basics](./docs/ethercat-basics.md)
 
 - [x] [NixOS Operating System](./docs/nixos/README.md)
+
+
+## Minimal Example — LED Control on the EL2004  
+A complete hardware + software walkthrough
+
+---
+
+## Table of Contents
+1. [Introduction](#1-introduction)  
+2. [Requirements](#2-requirements)  
+3. [Hardware Setup](#3-hardware-setup)  
+4. [Software Setup](#4-software-setup)  
+5. [Demo](#5-demo)  
+6. [References](#6-references)  
+7. [Acknowledgements](#7-acknowledgements)
+
+---
+
+# 1. Introduction
+
+The EL2004 LED Toggle Example is a minimal demonstration showing how to control digital outputs on a **Beckhoff EL2004 EtherCAT terminal** using the QiTech machine framework.  
+It represents the simplest possible hardware interaction in the system:  
+**toggling LED outputs using the QiTech Control Dashboard.**
+
+---
+
+# 2. Requirements
+
+## Hardware
+- Beckhoff **EL2004 EtherCAT Terminal** (4-channel digital output)  
+- Beckhoff **EK1100 EtherCAT Coupler**  
+- **24 V DC power supply** (AC/DC adapter + DC hollow plug)  
+- Jumper / bridge wires (0.5–1.5 mm² recommended)  
+- A **Linux PC** (Ubuntu/Debian recommended)  
+- Standard Ethernet cable  
+- Flat screwdriver  
+
+## Software  
+*(Installation steps in Section 4)*  
+- Rust toolchain  
+- Node.js + npm  
+- Git  
+- QiTech Control repository  
+- EtherCAT HAL (included inside repo)
+
+---
+
+# 3. Hardware Setup
+
+## 3.1 Schematic
+
+![](./docs/assets/schematic.png)
+
+---
+
+## 3.2 EK1100 Wiring
+
+This wiring configuration powers the EL2004 and prepares it for LED control.  
+It is not the only possible wiring but is the **simplest functional setup**.
+
+### ⚠️ Safety Warning  
+Always disconnect power before wiring.  
+Working on live EtherCAT terminals can cause serious damage or electrical shock.
+
+---
+
+## 3.2.1 Safe Wiring Procedure (Beckhoff Recommended)
+
+1. Insert a screwdriver **straight** into the square release hole.  
+2. Insert the stripped wire into the round opening.  
+3. Remove the screwdriver — the spring clamp locks the wire.
+
+![](./docs/assets/wiring.png)
+
+---
+
+## 3.2.2 Wiring Steps (Used in This Example)
+
+We supply power using a **DC hollow-plug adapter**, like this one:  
+https://www.amazon.de/dp/B093FTFZ8Q
+
+Perform the following wiring on the EK1100:
+
+1. Red wire **(+24 V)** → Terminal **2**  
+2. Black wire **(0 V)** → Terminal **3**  
+3. Jumper wire from **Terminal 1 → Terminal 6**  
+4. Jumper wire from **Terminal 5 → Terminal 7**  
+
+After wiring, your module should look like **Figure 1**.
+
+---
+
+### **Figure 1 — EK1100 Minimal Wiring**
+<img src="./docs/assets/ek1100.jpeg" width="400">
+
+
+---
+
+## 3.3 EL2004 Integration
+
+Slide the EL2004 onto the **right side of the EK1100** until it locks.  
+The EtherCAT E-Bus and power contacts connect automatically — **no wiring required**.
+
+### **Figure 2 — EL2004 Terminal**
+<img src="./docs/assets/el2004.jpeg" width="400">
+
+---
+
+## 3.4 Final Assembled Setup
+
+### **Figure 3 — EK1100 + EL2004 Connected**
+<img src="./docs/assets/complete.jpeg" width="400">
+
+---
+
+## 3.5 Power & Ethernet
+
+### Power  
+Connect the 24 V adapter to the hollow plug used earlier.
+**Example AC/DC Adapter (Figure 4):**
+
+<img src="./docs/assets/adapter.jpeg" width="400">
+
+
+### Ethernet  
+Use a standard LAN cable to connect your PC → EK1100.
+The final powered up and connected setup should look like this:
+
+<img src="./docs/assets/power.jpeg" width="400">
+
+---
+
+# 4. Software Setup
+
+## 4.1 Installing on Ubuntu/Debian
+
+Paste this into your terminal:
+
+```bash
+# Press Enter when prompted
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+
+sudo apt update
+sudo apt install -y npm nodejs git
+
+git clone git@github.com:qitechgmbh/control.git
+cd control/electron
+npm install
+```
+## 4.2 Running the Backend
+```bash
+./cargo_run_linux.sh
+```
+This script:
+
+- Builds the backend
+
+- Grants required system capabilities (raw sockets)
+
+- Starts EtherCAT communication
+
+Ensure the EK1100 is connected.
+
+## 4.3 Running the Frontend
+```bash
+cd electron
+npm run start
+```
+This launches the QiTech Control dashboard.
+# 5. Demo
+
+## 5.1 Assigning Devices in the Dashboard
+
+Once the backend + frontend are running, you should see:
+
+    EK1100 Coupler
+
+    EL2004 Digital Output Terminal
+![](./docs/assets/discovery.png)
+
+Steps:
+
+- Click Assign on the EK1100
+
+- Select TestMachine V1
+ 
+![](./docs/assets/setmachine.png)
+
+
+- Enter a serial number (use the same for EK1100 + EL2004)
+
+![](./docs/assets/serserial.png)
+
+- Click Write
+
+- Repeat for the EL2004
+
+## 5.2 Testing LED Control
+Navigate to:
+
+Machines → TestMachine
+![](./docs/assets/machinedetected.png)
+You will see this interface:
+
+![](./docs/assets/machinecontrol.png)
+
+**You can now toggle the four digital outputs of the EL2004.**
+# 6. References
+
+This guide incorporates information from official Beckhoff documentation.
+All diagrams, product names, and figures belong to Beckhoff Automation GmbH & Co. KG and are used here solely for educational purposes.
+
+Referenced Manuals
+
+[Beckhoff EK1100 Documentation](https://download.beckhoff.com/download/Document/io/ethercat-terminals/ek110x_ek15xx_en.pdf)
+
+[Beckhoff EL2004 Documentation](https://download.beckhoff.com/download/Document/io/ethercat-terminals/el20xx_el2124_de.pdf)
+
+# 7. Acknowledgements
+
+This tutorial is inspired by the clarity and educational quality of Beckhoff manuals.
+All wiring illustrations and hardware descriptions in this guide are provided for demonstration purposes only and do not replace official Beckhoff installation guidelines.
+
+Special thanks to the QiTech engineering team for providing the backend architecture, EtherCAT HAL abstraction, and the TestMachine framework that makes this example possible.
+
+---
+
+Minimal Example - Analog Input EL3021
+===
+### Table of Contents
+1. Introduction
+2. Requirements
+3. Hardware Setup
+4. Software Setup
+5. Demo
+6. References
+
+### 1. Introduction
+The EL3021 Analog Input example demonstrates how to measure analog current on a **Beckhoff EL3021 EtherCAT teminal** using the QiTech machine framework.
+
+### 2. Requirements
+## Hardware
+- Beckhoff **EL3021 EtherCAT Terminal** (1-channel analog input)  
+- Beckhoff **EK1100 EtherCAT Coupler**
+- **24 V DC power supply** (AC/DC adapter + DC hollow plug)
+- **Adjustable DC power supply** (or any other means of producing 4-20mA DC @ <10V )
+- Jumper / bridge wires (0.5–1.5 mm² recommended)  
+- A **Linux PC** (Ubuntu/Debian recommended)  
+- Standard Ethernet cable  
+- Flat screwdriver  
+
+### 3. Hardware Setup
+#### 3.1 Schematic
+![](./docs/assets/EL3021_schematic.png)
+The 24V supply powers the EL2004, while the adjustable power supply generates the analog input signal for the EL3021.
+#### ⚠️ Safety Warning  
+Always disconnect power before wiring.  
+Working on live EtherCAT terminals can cause serious damage or electrical shock.
+
+#### 3.2.1 Safe Wiring Procedure (Beckhoff Recommended)
+
+1. Insert a screwdriver **straight** into the square release hole.  
+2. Insert the stripped wire into the round opening.  
+3. Remove the screwdriver — the spring clamp locks the wire.
+
+![](./docs/assets/wiring.png)
+
+---
+
+#### 3.2.2 Wiring Steps (Used in This Example)
+
+We supply power using a **DC hollow-plug adapter**, like this one:  
+https://www.amazon.de/dp/B093FTFZ8Q
+
+Perform the following wiring on the EK1100:
+
+1. Red wire **(+24 V)** → Terminal **2**  
+2. Black wire **(0 V)** → Terminal **3**  
+3. Jumper wire from **Terminal 1 → Terminal 6**  
+4. Jumper wire from **Terminal 5 → Terminal 7**  
+
+After wiring, your module should look like **Figure 1**.
+
+---
+
+#### **Figure 1 — EK1100 Minimal Wiring**
+<img src="./docs/assets/ek1100.jpeg" width="400">
+
+
+---
+
+#### 3.3 EL3021 Integration
+
+Slide the EL3021 onto the **right side of the EK1100** until it locks.  
+The EtherCAT E-Bus and power contacts connect automatically.
+Then you need to wire the adjustable power supply to the EL3021.
+
+#### **Figure 2 — EL3021 Terminal**
+<img src="./docs/assets/EL3021.jpg" width="400">
+
+1. Wire ⊕ to **Terminal 1**
+2. Wire ⊖ to **Terminal 2**
+---
+
+#### 3.4 Final Assembled Setup
+
+#### **Figure 3 — EK1100 + EL3021 Connected**
+<img src="./docs/assets/EK1100+EL3021.jpg" width="400">
+
+---
+
+### 3.5 Power & Ethernet
+
+#### 3.5.1 Power  
+Connect the 24 V adapter to the hollow plug used earlier.
+
+#### Example AC/DC Adapter (Figure 4):
+
+<img src="./docs/assets/adapter.jpeg" width="400">
+
+
+#### 3.5.2 Ethernet  
+Use a standard LAN cable to connect your PC → EK1100.
+The final powered up and connected setup should look like this:
+
+<img src="./docs/assets/EL3021_power+eth.jpg" width="400">
+
+---
+
+### 4. Software Setup
+
+#### 4.1 Installing on Ubuntu/Debian
+
+Paste this into your terminal:
+
+```bash
+# Press Enter when prompted
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+
+sudo apt update
+sudo apt install -y npm nodejs git
+
+git clone git@github.com:qitechgmbh/control.git
+cd control/electron
+npm install
+```
+#### 4.2 Running the Backend
+```bash
+./cargo_run_linux.sh
+```
+This script:
+
+- Builds the backend
+
+- Grants required system capabilities (raw sockets)
+
+- Starts EtherCAT communication
+
+Ensure the EK1100 is connected.
+
+#### 4.3 Running the Frontend
+```bash
+cd electron
+npm run start
+```
+This launches the QiTech Control dashboard.
+
+### 5. Demo
+#### 5.1 Assigning Devices in the Dashboard
+Once both backend and frontend are running, the Setup -> EtherCat page should look something like this:
+![](./docs/assets/EL3021_overview.png)
+Listing the EK1100 and the EL3021.
+
+To assign the two devices to a machine, click "Assign" on both devices. This should open the following pop-up modal:
+
+**EK1100**
+![](./docs/assets/EL3021_assign.png)
+1. Select "AnalogTest V1" under "Maschine"
+2. Choose a serial number to uniquely identify the machine (1 in this example)
+3. Under "Device Role" select "0 - Bus Coupler"
+
+**EL3021**
+![](./docs/assets/EL3021_assign2.png)
+1. Select "AnalogTest V1" under "Maschine"
+2. Use the same serial number you chose for the EK1100
+3. Under "Device Role" select "1 - EL3021"
+---
+The machine is now configured.
+A new Tab "AnalogTest" should appear in the right sidebar. Clicking that tab should show the machine control interface:
+![](./docs/assets/EL3021_control.png)
+Results should show the current measured by the analog input - the current set on the adjustable power supply.
+
+
+### 6. References
+This guide incorporates information from official Beckhoff documentation.
+All diagrams, product names, and figures belong to Beckhoff Automation GmbH & Co. KG and are used here solely for educational purposes.
+
+Referenced Manuals
+
+[Beckhoff EK1100 Documentation](https://download.beckhoff.com/download/Document/io/ethercat-terminals/ek110x_ek15xx_en.pdf)
+[Beckhoff EL3021 Documentation](https://download.beckhoff.com/download/Document/io/ethercat-terminals/el30xx_de.pdf)

cargo_run_linux.sh

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

compile_metrics.sh

@@ -0,0 +1,67 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+BUILD_DIR="${BUILD_DIR:-target}"
+CSV_FILE="${CSV_FILE:-compile_metrics.csv}"
+DEFAULT_PKG="server"
+
+if [ "$#" -eq 0 ]; then
+  set -- cargo build
+fi
+
+if [ "${1:-}" = "cargo" ] && [ "${2:-}" = "build" ]; then
+  cargo clean
+  BUILD_CMD=(cargo rustc -p "$DEFAULT_PKG")
+  shift 2
+  BUILD_CMD+=("$@")
+  BUILD_CMD+=(-- --emit=llvm-ir -C debuginfo=0)
+else
+  BUILD_CMD=("$@")
+fi
+
+compile_start_ns=$(date +%s%N)
+"${BUILD_CMD[@]}"
+compile_end_ns=$(date +%s%N)
+compile_ms=$(( (compile_end_ns - compile_start_ns) / 1000000 ))
+
+if [ -d "$BUILD_DIR" ]; then
+  llvm_ir_lines=$(
+    find "$BUILD_DIR" -type f -name '*.ll' -print0 \
+      | xargs -0 cat \
+      | wc -l
+  )
+else
+  llvm_ir_lines=0
+fi
+
+bin_path=""
+
+if [ -n "${BINARY_PATH:-}" ] && [ -f "$BINARY_PATH" ]; then
+  bin_path="$BINARY_PATH"
+elif [ -f "./target/release/server" ]; then
+  bin_path="./target/release/server"
+elif [ -f "./target/debug/server" ]; then
+  bin_path="./target/debug/server"
+elif [ -f "./server/target/release/server" ]; then
+  bin_path="./server/target/release/server"
+elif [ -f "./server/target/debug/server" ]; then
+  bin_path="./server/target/debug/server"
+fi
+
+if [ -n "$bin_path" ]; then
+  binary_size_bytes=$(stat -c '%s' "$bin_path")
+else
+  binary_size_bytes=0
+fi
+
+finished_timestamp_ms=$(($(date +%s%N) / 1000000))
+finished_datetime=$(date -Iseconds)
+
+if [ ! -f "$CSV_FILE" ]; then
+  echo "datetime,finished_timestamp_ms,compile_ms,llvm_ir_lines,binary_size_bytes" > "$CSV_FILE"
+fi
+
+echo "${finished_datetime},${finished_timestamp_ms},${compile_ms},${llvm_ir_lines},${binary_size_bytes}" \
+  >> "$CSV_FILE"
+
+echo "Metrics recorded in $CSV_FILE"

control-core/Cargo.toml

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

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

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

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

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

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

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

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

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

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

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

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

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

control-core/src/converters/angle_converter.rs

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

control-core/src/converters/angular_step_converter.rs

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

control-core/src/converters/circular_converter.rs

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

control-core/src/converters/linear_step_converter.rs

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

control-core/src/ethercat/interface_discovery.rs

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

control-core/src/ethercat/mod.rs

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

control-core/src/lib.rs

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

control-core/src/machines/api.rs

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

control-core/src/machines/connection.rs

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

control-core/src/machines/identification.rs

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

control-core/src/machines/manager.rs

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

control-core/src/machines/manager_iter.rs

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

control-core/src/machines/mod.rs

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

control-core/src/machines/new.rs

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

control-core/src/machines/registry.rs

@@ -1,74 +0,0 @@
-use super::{Machine, identification::MachineIdentification, new::MachineNewParams};
-use anyhow::Error;
-use smol::lock::Mutex;
-use std::{any::TypeId, collections::HashMap, sync::Arc};
-
-pub type MachineNewClosure =
-    Box<dyn Fn(&MachineNewParams) -> Result<Arc<Mutex<dyn Machine>>, Error> + Send + Sync>;
-
-pub struct MachineRegistry {
-    type_map: HashMap<TypeId, (MachineIdentification, MachineNewClosure)>,
-}
-
-impl Default for MachineRegistry {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl MachineRegistry {
-    pub fn new() -> Self {
-        Self {
-            type_map: HashMap::new(),
-        }
-    }
-
-    pub fn register<T: Machine + 'static>(
-        &mut self,
-        machine_identficiation: MachineIdentification,
-    ) {
-        self.type_map.insert(
-            TypeId::of::<T>(),
-            (
-                machine_identficiation.clone(),
-                // create a machine construction closure
-                Box::new(|machine_new_params| {
-                    Ok(Arc::new(Mutex::new(T::new(machine_new_params)?)))
-                }),
-            ),
-        );
-    }
-
-    pub fn new_machine(
-        &self,
-        machine_new_params: &MachineNewParams,
-    ) -> Result<Arc<Mutex<dyn Machine>>, anyhow::Error> {
-        // get machiine identification
-        let device_identification =
-            &machine_new_params
-                .device_group
-                .first()
-                .ok_or(anyhow::anyhow!(
-                    "[{}::MachineConstructor::new_machine] No device in group",
-                    module_path!()
-                ))?;
-
-        // find machine new function by comparing MachineIdentification
-        let (_, machine_new_closure) = self
-            .type_map
-            .values()
-            .find(|(mi, _)| {
-                mi == &device_identification
-                    .device_machine_identification
-                    .machine_identification_unique
-                    .machine_identification
-            })
-            .ok_or(anyhow::anyhow!(
-                "[{}::MachineConstructor::new_machine] Machine not found",
-                module_path!()
-            ))?;
-
-        // call machine new function by reference
-        (machine_new_closure)(machine_new_params)
-    }
-}

control-core/src/rest/mod.rs

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

control-core/src/serial/mod.rs

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

control-core/src/serial/panic.rs

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

control-core/src/serial/serial_detection.rs

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

control-core/src/socketio/mod.rs

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

control-core/src/socketio/namespace.rs

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

control-core/src/transmission/mod.rs

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

control-core/src/uom_extensions/acceleration.rs

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

control-core/src/uom_extensions/angular_acceleration.rs

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

control-core/src/uom_extensions/angular_jerk.rs

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

control-core/src/uom_extensions/jerk.rs

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

control-core/src/uom_extensions/mod.rs

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

control-core/src/uom_extensions/velocity.rs

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

docs/machines/laser-DRE.md

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

electron/.gitignore

@@ -73,7 +73,7 @@ typings/
 # vuepress build output
 .vuepress/dist
 
-# Serverless directories
+# Serverless directoriesProcessMetrics
 .serverless/
 
 # FuseBox cache

electron/package.json

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

electron/src/App.tsx

@@ -9,6 +9,7 @@ import { RouterProvider } from "@tanstack/react-router";
 import { Toaster } from "./components/ui/sonner";
 import { enableMapSet } from "immer";
 import { useGlobalLogStreaming } from "./hooks/useGlobalLogStreaming";
+import { GlobalLaserToastManager } from "./setup/GlobalLaserToastManager";
 
 export default function App() {
   const { i18n } = useTranslation();
@@ -21,7 +22,12 @@ export default function App() {
     updateAppLanguage(i18n);
   }, [i18n]);
 
-  return <RouterProvider router={router} />;
+  return (
+    <>
+      <GlobalLaserToastManager />
+      <RouterProvider router={router} />
+    </>
+  );
 }
 
 // enable immer MapSet plugin

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

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

electron/src/client/mainNamespace.ts

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

electron/src/client/socketioStore.ts

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

electron/src/client/softReload.ts

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

electron/src/components/SidebarLayout.tsx

@@ -1,10 +1,16 @@
 import { OutsideCorner } from "@/components/OutsideCorner";
 import { useMachines } from "@/client/useMachines";
 import { useOnSubpath } from "@/lib/useOnSubpath";
-import { Link, Outlet } from "@tanstack/react-router";
-import { Fragment } from "react";
+import {
+  Link,
+  Outlet,
+  useRouter,
+  useRouterState,
+} from "@tanstack/react-router";
+import { Fragment, useEffect } from "react";
 import React from "react";
 import { Icon, IconName } from "./Icon";
+import { useMainNamespace } from "@/client/mainNamespace";
 
 type SidebarItemContent = {
   link: string;
@@ -57,7 +63,51 @@ export function useSidebarlessWidth() {
 
 export function SidebarLayout() {
   const machines = useMachines();
+  const router = useRouter();
+  const routerState = useRouterState();
+  const { machines: machinesEvent } = useMainNamespace();
   const [contentWidth, setContentWidth] = React.useState<number>(0);
+
+  // Machine connection guard: redirect to setup if selected machine disconnects
+  useEffect(() => {
+    // Wait for machines data to be loaded
+    if (!machinesEvent?.data) return;
+
+    // Extract serial from current path (e.g., /machines/laser1/12345/control)
+    const pathMatch = routerState.location.pathname.match(
+      /\/machines\/[^/]+\/(\d+)/,
+    );
+    if (!pathMatch) return; // Not on a machine page
+
+    // Safety check: ensure pathMatch has at least 2 elements (full match + capture group)
+    if (pathMatch.length < 2) {
+      console.warn("[ConnectionGuard] Invalid pathMatch structure:", pathMatch);
+      return;
+    }
+
+    // Parse serial number with error handling
+    const serialString = pathMatch[1];
+    const serialNumber = parseInt(serialString, 10);
+
+    // Check if parseInt succeeded (NaN means parsing failed)
+    if (isNaN(serialNumber)) {
+      console.warn(
+        `[ConnectionGuard] Failed to parse serial number from "${serialString}"`,
+        { pathname: routerState.location.pathname },
+      );
+      return;
+    }
+
+    // Check if machine still exists in the raw machines data
+    const machineExists = machinesEvent.data.machines.some(
+      (m) => m.machine_identification_unique.serial === serialNumber,
+    );
+
+    if (!machineExists) {
+      router.navigate({ to: "/_sidebar/setup/machines" });
+    }
+  }, [machines, machinesEvent, routerState.location.pathname, router]);
+
   const items: SidebarItemContent[] = [
     ...machines.map((machine) => ({
       link: `/_sidebar/machines/${machine.slug}/${machine.machine_identification_unique.serial}/control`,

electron/src/components/UpdateProgressBar.tsx

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

electron/src/components/graph/types.ts

@@ -63,7 +63,11 @@ export type DataSeries = SeriesData | SeriesData[];
 export type BigGraphProps = {
   newData: DataSeries;
   unit?: Unit;
-  renderValue?: (value: number) => string;
+  renderValue?: (
+    value: number,
+    seriesIndex?: number,
+    seriesTitle?: string,
+  ) => string;
   config: GraphConfig;
   graphId: string;
   syncGraph?: PropGraphSync;

electron/src/control/EditValue.tsx

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

electron/src/control/MinMaxValue.tsx

@@ -0,0 +1,173 @@
+import { Icon, IconName } from "@/components/Icon";
+import React, { useState, useMemo } from "react";
+import {
+  getUnitIcon,
+  renderValueToReactNode,
+  renderUnitSymbol,
+  Unit,
+} from "./units";
+import { Label } from "./Label";
+import { TimeSeries, TimeSeriesValue } from "@/lib/timeseries";
+
+type TimeframeOption = {
+  label: string;
+  value: number; // in milliseconds
+};
+
+export const TIMEFRAME_OPTIONS: TimeframeOption[] = [
+  { label: "1 min", value: 1 * 60 * 1000 },
+  { label: "5 min", value: 5 * 60 * 1000 },
+  { label: "10 min", value: 10 * 60 * 1000 },
+  { label: "30 min", value: 30 * 60 * 1000 },
+  { label: "1 hour", value: 60 * 60 * 1000 },
+];
+
+type Props = {
+  label: string;
+  unit?: Unit;
+  timeseries: TimeSeries;
+  icon?: IconName;
+  renderValue?: (value: number) => string;
+  defaultTimeframe?: number; // in milliseconds, defaults to 5 minutes
+  /** Optional externally-controlled timeframe (ms). When provided, component becomes controlled. */
+  timeframe?: number;
+  /** Optional callback when timeframe is changed via this component's selector */
+  onTimeframeChange?: (t: number) => void;
+  /** When true, hide the built-in timeframe selector (useful when sharing a selector outside) */
+  hideSelector?: boolean;
+};
+
+export function MinMaxValue({
+  unit,
+  timeseries,
+  icon,
+  label,
+  renderValue,
+  defaultTimeframe = 5 * 60 * 1000, // 5 minutes default
+  timeframe,
+  onTimeframeChange,
+  hideSelector = false,
+}: Props) {
+  const [internalTimeframe, setInternalTimeframe] = useState(defaultTimeframe);
+  const selectedTimeframe = timeframe ?? internalTimeframe;
+
+  // Calculate min/max from the timeseries using the selected timeframe
+  const { min, max, hasData } = useMemo(() => {
+    // Use short series for timeframes <= 5 seconds, otherwise use long series
+    // Short series typically has ~5 second retention with high resolution
+    // Long series typically has ~1 hour retention with lower resolution
+    const series =
+      selectedTimeframe <= 5000 ? timeseries.short : timeseries.long;
+
+    // Manually calculate min/max to exclude zero values (which might be invalid readings)
+    const cutoffTime = series.lastTimestamp - selectedTimeframe;
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    let hasValidData = false;
+    let dataCount = 0;
+
+    const { values: raw, index, size, validCount } = series;
+
+    const startIdx = validCount < size ? 0 : index;
+
+    for (let i = 0; i < validCount; i++) {
+      const idx = (startIdx + i) % size;
+      const val = raw[idx];
+
+      if (
+        val &&
+        val.timestamp > 0 &&
+        val.timestamp >= cutoffTime &&
+        val.value > 0
+      ) {
+        hasValidData = true;
+        dataCount++;
+        if (val.value < min) min = val.value;
+        if (val.value > max) max = val.value;
+      }
+    }
+
+    if (!hasValidData) {
+      return { min: 0, max: 0, hasData: false };
+    }
+
+    return { min, max, hasData: true };
+  }, [
+    timeseries.short,
+    timeseries.long,
+    timeseries.current,
+    selectedTimeframe,
+  ]);
+
+  return (
+    <div className="flex w-full flex-col gap-3">
+      <Label label={label}>
+        <div className="flex flex-row items-center gap-6">
+          {/* Min Value */}
+          <div className="flex flex-row items-center gap-2">
+            <Icon
+              name={icon ?? (unit ? getUnitIcon(unit) : undefined)}
+              className="size-5 text-blue-500"
+            />
+            <div className="flex flex-col">
+              <span className="text-xs text-gray-500">Min</span>
+              <div className="flex flex-row items-center gap-1">
+                <span className="font-mono text-xl font-bold">
+                  {hasData
+                    ? renderValueToReactNode(min, unit, renderValue)
+                    : "-"}
+                </span>
+                {hasData && (
+                  <span className="text-sm">{renderUnitSymbol(unit)}</span>
+                )}
+              </div>
+            </div>
+          </div>
+
+          {/* Max Value */}
+          <div className="flex flex-row items-center gap-2">
+            <Icon
+              name={icon ?? (unit ? getUnitIcon(unit) : undefined)}
+              className="size-5 text-red-500"
+            />
+            <div className="flex flex-col">
+              <span className="text-xs text-gray-500">Max</span>
+              <div className="flex flex-row items-center gap-1">
+                <span className="font-mono text-xl font-bold">
+                  {hasData
+                    ? renderValueToReactNode(max, unit, renderValue)
+                    : "-"}
+                </span>
+                {hasData && (
+                  <span className="text-sm">{renderUnitSymbol(unit)}</span>
+                )}
+              </div>
+            </div>
+          </div>
+        </div>
+      </Label>
+
+      {/* Timeframe Selector (hidden when sharing selector externally) */}
+      {!hideSelector && (
+        <div className="flex flex-row flex-wrap gap-2">
+          {TIMEFRAME_OPTIONS.map((option) => (
+            <button
+              key={option.value}
+              onClick={() => {
+                if (onTimeframeChange) onTimeframeChange(option.value);
+                else setInternalTimeframe(option.value);
+              }}
+              className={`rounded-md px-3 py-1 text-sm transition-colors ${
+                selectedTimeframe === option.value
+                  ? "bg-blue-500 text-white"
+                  : "bg-gray-200 text-gray-700 hover:bg-gray-300"
+              }`}
+            >
+              {option.label}
+            </button>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}

electron/src/control/units.tsx

@@ -25,6 +25,8 @@ export function getUnitIcon(unit: Unit): IconName {
       return "lu:Gauge";
     case "mHz":
       return "lu:AudioWaveform";
+    case "Hz":
+      return "lu:AudioWaveform";
     case "W":
       return "lu:Zap";
     case "V":
@@ -35,6 +37,18 @@ export function getUnitIcon(unit: Unit): IconName {
       return "lu:BatteryFull";
     case "l/min":
       return "lu:Waves";
+    case "%":
+      return "lu:ChartNoAxesColumn";
+    case "µs":
+      return "lu:RefreshCcw";
+    case "s":
+      return "lu:Clock";
+    case "MiB":
+      return "lu:MemoryStick";
+    case "Mbit/s":
+      return "lu:Network";
+    case "/s":
+      return "lu:Gauge";
     default:
       return "lu:ChartNoAxesColumn";
   }
@@ -62,6 +76,8 @@ export function renderUnitSymbol(unit: Unit | undefined): string {
       return "m/min";
     case "mHz":
       return "mHz";
+    case "Hz":
+      return "Hz";
     case "W":
       return "W";
     case "V":
@@ -72,6 +88,18 @@ export function renderUnitSymbol(unit: Unit | undefined): string {
       return "kWh";
     case "l/min":
       return "l/min";
+    case "%":
+      return "%";
+    case "µs":
+      return "µs";
+    case "s":
+      return "s";
+    case "MiB":
+      return "MiB";
+    case "Mbit/s":
+      return "Mbit/s";
+    case "/s":
+      return "/s";
     default:
       return "";
   }
@@ -121,6 +149,8 @@ export function renderUnitSymbolLong(unit: Unit): string {
       return "meters/minute";
     case "mHz":
       return "millihertz";
+    case "Hz":
+      return "hertz";
     case "W":
       return "watts";
     case "V":
@@ -131,6 +161,18 @@ export function renderUnitSymbolLong(unit: Unit): string {
       return "kilowatt-hours";
     case "l/min":
       return "liters/minute";
+    case "%":
+      return "percent";
+    case "µs":
+      return "microseconds";
+    case "s":
+      return "seconds";
+    case "MiB":
+      return "mebibytes";
+    case "Mbit/s":
+      return "megabits/second";
+    case "/s":
+      return "per second";
     default:
       return "";
   }
@@ -147,11 +189,18 @@ export const units = [
   "bar",
   "m/min",
   "mHz",
+  "Hz",
   "W",
   "V",
   "A",
   "kWh",
   "l/min",
+  "%",
+  "µs",
+  "s",
+  "MiB",
+  "Mbit/s",
+  "/s",
 ] as const;
 
 export type Unit = (typeof units)[number];

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

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

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

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

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

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

electron/src/helpers/update_helpers.ts

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

electron/src/machines/analoginputtestmachine/AnalogInputTestMachineControlPage.tsx

@@ -0,0 +1,59 @@
+import { MiniGraph } from "@/components/graph/MiniGraph";
+import { Page } from "@/components/Page";
+import { ControlCard } from "@/control/ControlCard";
+import { ControlGrid } from "@/control/ControlGrid";
+
+import React from "react";
+import { useAnalogInputTestMachine } from "./useAnalogInputTestMachine";
+
+export function AnalogInputTestMachineControl(): React.JSX.Element {
+  const { seriesData, state, updateMeasurementRate } =
+    useAnalogInputTestMachine();
+
+  if (!seriesData) return <div>Initializing Sensor...</div>;
+
+  return (
+    <Page>
+      <ControlGrid columns={2}>
+        <ControlCard title="Measurement Control">
+          <div
+            style={{
+              display: "flex",
+              flexDirection: "row",
+              justifyContent: "space-between",
+            }}
+          >
+            <div>Measurement Rate (Hz)</div>
+            <input
+              type="number"
+              style={{
+                border: "2px solid transparent",
+                borderRadius: "4px",
+                padding: "3px",
+              }}
+              className={"bg-neutral-100 shadow"}
+              value={state.measurementRateHz}
+              onChange={(v) => {
+                const val = Number(v.currentTarget.value);
+                updateMeasurementRate(val);
+              }}
+              min={1}
+            ></input>
+          </div>
+        </ControlCard>
+        <ControlCard title="Results">
+          <div className="flex flex-row">
+            <MiniGraph
+              newData={seriesData}
+              width={500}
+              renderValue={(v) => v.toFixed(2)}
+            ></MiniGraph>
+            <div className="flex flex-col justify-center">
+              {seriesData.current?.value.toFixed(2)}mA
+            </div>
+          </div>
+        </ControlCard>
+      </ControlGrid>
+    </Page>
+  );
+}

electron/src/machines/analoginputtestmachine/AnalogInputTestMachinePage.tsx

@@ -0,0 +1,21 @@
+import { Topbar } from "@/components/Topbar";
+import { analogInputTestMachineSerialRoute } from "@/routes/routes";
+import React from "react";
+
+export function AnalogInputTestMachine(): React.JSX.Element {
+  const { serial } = analogInputTestMachineSerialRoute.useParams();
+
+  return (
+    <Topbar
+      pathname={`/_sidebar/machines/analoginputtestmachine/${serial}`}
+      items={[
+        {
+          link: "control",
+          activeLink: "control",
+          title: "Control",
+          icon: "lu:CirclePlay",
+        },
+      ]}
+    />
+  );
+}

electron/src/machines/analoginputtestmachine/useAnalogInputTestMachine.ts

@@ -0,0 +1,107 @@
+import { useMachineMutate } from "@/client/useClient";
+import {
+  createTimeSeries,
+  TimeSeries,
+  TimeSeriesValue,
+  TimeSeriesWithInsert,
+} from "@/lib/timeseries";
+import { useEffect, useMemo, useState } from "react";
+import z from "zod";
+import {
+  StateEvent,
+  useAnalogInputTestMachineNamespace,
+} from "./useAnalogInputTestMachineNamespace";
+import { toastError } from "@/components/Toast";
+import { MachineIdentificationUnique } from "../types";
+import { analogInputTestMachineSerialRoute } from "@/routes/routes";
+import { analogInputTestMachine } from "../properties";
+import { useStateOptimistic } from "@/lib/useStateOptimistic";
+import { produce } from "immer";
+
+export function useAnalogInputTestMachine() {
+  const { serial: serialString } =
+    analogInputTestMachineSerialRoute.useParams();
+  const machineIdentification: MachineIdentificationUnique = useMemo(() => {
+    const serial = parseInt(serialString);
+    if (isNaN(serial)) {
+      toastError(
+        "Invalid Serial Number",
+        `"${serialString}" is not a valid serial number.`,
+      );
+      return {
+        machine_identification: { vendor: 0, machine: 0 },
+        serial: 0,
+      };
+    }
+    return {
+      machine_identification: analogInputTestMachine.machine_identification,
+      serial,
+    };
+  }, [serialString]);
+
+  const state = useAnalogInputTestMachineNamespace({
+    type: "machine",
+    machine_identification_unique: machineIdentification,
+  });
+
+  const mutateMachine = useMachineMutate(
+    z.object({
+      measurement_rate_hz: z.number(),
+    }),
+  );
+
+  const stateOptimistic = useStateOptimistic<StateEvent>();
+
+  const updateStateOptimistically = (
+    producer: (current: StateEvent) => void,
+    serverRequest?: () => void,
+  ) => {
+    const currentState = stateOptimistic.value;
+    if (currentState)
+      stateOptimistic.setOptimistic(produce(currentState, producer));
+    serverRequest?.();
+  };
+
+  const updateMeasurementRate = (val: number) => {
+    updateStateOptimistically(
+      (current) => {
+        current.measurementRateHz = val;
+      },
+      () => {
+        mutateMachine.request({
+          machine_identification_unique: machineIdentification,
+          data: { measurement_rate_hz: val },
+        });
+      },
+    );
+  };
+
+  const timeSeries: TimeSeriesWithInsert = createTimeSeries(
+    20,
+    1000,
+    5000,
+    60 * 60 * 1000,
+  );
+
+  const [seriesData, setSeriesData] = useState<TimeSeries | null>(
+    timeSeries.initialTimeSeries,
+  );
+
+  useEffect(() => {
+    const measurement = state.currentMeasurement;
+
+    if (measurement && seriesData) {
+      const dataPoint: TimeSeriesValue = {
+        value: measurement[0] * 1000,
+        timestamp: Number(measurement[1]),
+      };
+      setSeriesData(timeSeries.insert(seriesData, dataPoint));
+    }
+  }, [state]);
+
+  return {
+    seriesData,
+    state,
+    updateMeasurementRate,
+  };
+}

electron/src/machines/analoginputtestmachine/useAnalogInputTestMachineNamespace.ts

@@ -0,0 +1,67 @@
+import {
+  createNamespaceHookImplementation,
+  EventHandler,
+  eventSchema,
+} from "@/client/socketioStore";
+import z from "zod";
+import { create, StoreApi } from "zustand";
+
+// ========== Event Schema ==========
+
+export const stateEventDataSchema = z.object({
+  measurementRateHz: z.number().optional(),
+  currentMeasurement: z.tuple([z.number(), z.string()]).optional(),
+});
+
+export const stateEventSchema = eventSchema(stateEventDataSchema);
+
+export type StateEvent = z.infer<typeof stateEventDataSchema>;
+
+// ========== Store ==========
+export type AnalogInputTestMachineNamespaceStore = z.infer<
+  typeof stateEventDataSchema
+>;
+
+const createMachineStore = (): StoreApi<AnalogInputTestMachineNamespaceStore> =>
+  create<AnalogInputTestMachineNamespaceStore>(() => ({
+    measurementRateHz: 1,
+    currentMeasurement: undefined,
+  }));
+
+// ========== Message Handler ==========
+function analogInputTestMachineMessageHandler(
+  store: StoreApi<AnalogInputTestMachineNamespaceStore>,
+): EventHandler {
+  return (event) => {
+    const oldState = store.getState();
+    const newMeasurementDataHz = event.data["MeasurementRateHz"];
+    const newMeasurement: [number, string] = event.data["Measurement"];
+
+    switch (event.name) {
+      case "MeasurementRateHz":
+        if (
+          newMeasurementDataHz &&
+          newMeasurementDataHz !== oldState.measurementRateHz
+        )
+          store.setState({
+            ...oldState,
+            measurementRateHz: newMeasurementDataHz,
+          });
+        break;
+      case "Measurement":
+        if (newMeasurement && newMeasurement !== oldState.currentMeasurement)
+          store.setState({
+            ...oldState,
+            currentMeasurement: newMeasurement,
+          });
+        break;
+    }
+  };
+}
+
+// ========== Namespace Hook ==========
+export const useAnalogInputTestMachineNamespace =
+  createNamespaceHookImplementation({
+    createStore: () => createMachineStore(),
+    createEventHandler: analogInputTestMachineMessageHandler,
+  });

electron/src/machines/aquapath/aquapath1/Aquapath1ControlPage.tsx

@@ -39,7 +39,7 @@ export function Aquapath1ControlPage() {
           <div className="grid grid-cols-2 gap-6">
             <div className="flex flex-col gap-8">
               <TimeSeriesValueNumeric
-                label="Front Flow"
+                label="Flow 1"
                 unit="l/min"
                 timeseries={front_flow}
                 renderValue={(value) => value.toFixed(1)}
@@ -48,7 +48,7 @@ export function Aquapath1ControlPage() {
 
             <div className="flex flex-col gap-8">
               <TimeSeriesValueNumeric
-                label="Back Flow"
+                label="Flow 2"
                 unit="l/min"
                 timeseries={back_flow}
                 renderValue={(value) => value.toFixed(1)}
@@ -57,7 +57,7 @@ export function Aquapath1ControlPage() {
           </div>
 
           <div className="mt-8">
-            <Label label="Front Pump">
+            <Label label="Pump 1">
               <SelectionGroup<"On" | "Off">
                 value={frontTargetFlow ? "On" : "Off"}
                 orientation="vertical"
@@ -86,7 +86,7 @@ export function Aquapath1ControlPage() {
               />
             </Label>
 
-            <Label label="Back Pump">
+            <Label label="Pump 2">
               <SelectionGroup<"On" | "Off">
                 value={backTargetFlow ? "On" : "Off"}
                 orientation="vertical"
@@ -121,20 +121,14 @@ export function Aquapath1ControlPage() {
           <div className="grid grid-cols-2 gap-6">
             <div className="flex flex-col gap-8">
               <TimeSeriesValueNumeric
-                label="Front in"
+                label="Reservoir 1"
                 unit="C"
                 timeseries={front_temperature}
                 renderValue={(value) => value.toFixed(1)}
               />
-              <TimeSeriesValueNumeric
-                label="Front Reservoir"
-                unit="C"
-                timeseries={front_temp_reservoir}
-                renderValue={(value) => value.toFixed(1)}
-              />
-              <Label label="Set Front Target Temperature">
+              <Label label="Set Reservoir 1 Target Temperature">
                 <EditValue
-                  title="Set Front Target Temperature"
+                  title="Set Reservoir 1 Target Temperature"
                   value={frontTargetTemperature}
                   unit="C"
                   renderValue={(value) => value.toFixed(1)}
@@ -150,20 +144,14 @@ export function Aquapath1ControlPage() {
 
             <div className="flex flex-col gap-8">
               <TimeSeriesValueNumeric
-                label="Back in"
+                label="Reservoir 2"
                 unit="C"
                 timeseries={back_temperature}
                 renderValue={(value) => value.toFixed(1)}
               />
-              <TimeSeriesValueNumeric
-                label="Back Reservoir"
-                unit="C"
-                timeseries={back_temp_reservoir}
-                renderValue={(value) => value.toFixed(1)}
-              />
-              <Label label="Set Back Target Temperature">
+              <Label label="Set Reservoir 2 Target Temperature">
                 <EditValue
-                  title="Set Back Target Temperature"
+                  title="Set Reservoir 2 Target Temperature"
                   value={backTargetTemperature}
                   unit="C"
                   renderValue={(value) => value.toFixed(1)}

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

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

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

@@ -152,7 +152,7 @@ export function Extruder2ControlPage() {
                 unit="rpm"
                 title="Target Output RPM"
                 min={0}
-                max={106}
+                max={44}
                 renderValue={(value) => roundToDecimals(value, 0)}
                 onChange={setInverterTargetRpm}
               />

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

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

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

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

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

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

electron/src/machines/extruder/extruder3/Extruder3ControlPage.tsx

@@ -0,0 +1,258 @@
+import { ControlCard } from "@/control/ControlCard";
+import { Page } from "@/components/Page";
+import React from "react";
+import { ControlGrid } from "@/control/ControlGrid";
+import {
+  SelectionGroup,
+  SelectionGroupBoolean,
+} from "@/control/SelectionGroup";
+import { HeatingZone } from "../HeatingZone";
+import { Label } from "@/control/Label";
+import { EditValue } from "@/control/EditValue";
+import { roundToDecimals } from "@/lib/decimal";
+import { useExtruder3 } from "./useExtruder";
+import { TimeSeriesValueNumeric } from "@/control/TimeSeriesValue";
+import { StatusBadge } from "@/control/StatusBadge";
+
+export function Extruder3ControlPage() {
+  const {
+    state,
+    defaultState,
+    nozzleTemperature,
+    nozzlePower,
+    frontTemperature,
+    frontPower,
+    backTemperature,
+    backPower,
+    middleTemperature,
+    middlePower,
+    pressure,
+
+    motorScrewRpm,
+    motorPower,
+    motorCurrent,
+    totalEnergyKWh,
+    combinedPower,
+
+    setExtruderMode,
+    setBackHeatingTemperature,
+    setFrontHeatingTemperature,
+    setMiddleHeatingTemperature,
+    setNozzleHeatingTemperature,
+    setInverterRegulation,
+    setInverterTargetPressure,
+    setInverterTargetRpm,
+
+    isLoading,
+    isDisabled,
+  } = useExtruder3();
+
+  function isZoneReadyForExtrusion(
+    temperature: number,
+    targetTemperature: number,
+  ) {
+    // if temperature is 90% of the target temperature, then we are ready for extrusion
+    return temperature >= 0.9 * targetTemperature && targetTemperature > 0.0;
+  }
+
+  const allZonesReadyForExtrude = () => {
+    const frontReady = isZoneReadyForExtrusion(
+      frontTemperature.current?.value ?? 0,
+      state?.heating_states.front.target_temperature ?? 1,
+    );
+    const middleReady = isZoneReadyForExtrusion(
+      middleTemperature.current?.value ?? 0,
+      state?.heating_states.middle.target_temperature ?? 1,
+    );
+    const backReady = isZoneReadyForExtrusion(
+      backTemperature.current?.value ?? 0,
+      state?.heating_states.back.target_temperature ?? 1,
+    );
+    const nozzleReady = isZoneReadyForExtrusion(
+      nozzleTemperature.current?.value ?? 0,
+      state?.heating_states.nozzle.target_temperature ?? 1,
+    );
+
+    return frontReady && middleReady && backReady && nozzleReady;
+  };
+
+  return (
+    <Page>
+      <ControlGrid>
+        <HeatingZone
+          title={"Heating Front"}
+          heatingState={state?.heating_states.front}
+          heatingTimeSeries={frontTemperature}
+          heatingPower={frontPower}
+          onChangeTargetTemp={setFrontHeatingTemperature}
+          min={0}
+          max={300}
+        />
+        <HeatingZone
+          title={"Heating Middle"}
+          heatingState={state?.heating_states.middle}
+          heatingTimeSeries={middleTemperature}
+          heatingPower={middlePower}
+          onChangeTargetTemp={setMiddleHeatingTemperature}
+          min={0}
+          max={300}
+        />
+        <HeatingZone
+          title={"Heating Back"}
+          heatingState={state?.heating_states.back}
+          heatingTimeSeries={backTemperature}
+          heatingPower={backPower}
+          onChangeTargetTemp={setBackHeatingTemperature}
+          min={0}
+          max={300}
+        />
+        <HeatingZone
+          title={"Heating Nozzle"}
+          heatingState={state?.heating_states.nozzle}
+          heatingTimeSeries={nozzleTemperature}
+          heatingPower={nozzlePower}
+          onChangeTargetTemp={setNozzleHeatingTemperature}
+          min={0}
+          max={300}
+        />
+        <ControlCard className="bg-red" title="Screw Drive">
+          {state?.inverter_status_state.overload_warning == true ? (
+            <StatusBadge variant="error">
+              Inverter is overloaded! Please check the extruder and reduce load
+              if necessary.
+            </StatusBadge>
+          ) : state?.inverter_status_state.fault_occurence == true ? (
+            <StatusBadge variant="error">
+              Inverter encountered an error!! Press the restart button in Config
+            </StatusBadge>
+          ) : state?.inverter_status_state.running == true &&
+            state.inverter_status_state.fault_occurence == false ? (
+            <StatusBadge variant="success">Running</StatusBadge>
+          ) : null}
+          {state?.inverter_status_state.running == false &&
+            state.inverter_status_state.fault_occurence == false && (
+              <StatusBadge variant="success">Healthy</StatusBadge>
+            )}
+
+          <Label label="Regulation">
+            <SelectionGroupBoolean
+              value={state?.regulation_state.uses_rpm}
+              optionTrue={{ children: "RPM" }}
+              optionFalse={{ children: "Pressure" }}
+              onChange={setInverterRegulation}
+              disabled={isDisabled}
+              loading={isLoading}
+            />
+          </Label>
+          <div className="flex flex-row flex-wrap gap-4">
+            <Label label="Target Output RPM">
+              <EditValue
+                value={state?.screw_state.target_rpm}
+                defaultValue={defaultState?.screw_state.target_rpm}
+                unit="rpm"
+                title="Target Output RPM"
+                min={0}
+                max={100}
+                renderValue={(value) => roundToDecimals(value, 0)}
+                onChange={setInverterTargetRpm}
+              />
+            </Label>
+            <Label label="Target Pressure">
+              <EditValue
+                value={state?.pressure_state.target_bar}
+                defaultValue={defaultState?.pressure_state.target_bar}
+                unit="bar"
+                title="Target Pressure"
+                min={0.0}
+                max={270.0}
+                renderValue={(value) => roundToDecimals(value, 0)}
+                onChange={setInverterTargetPressure}
+              />
+            </Label>
+          </div>
+          <div className="flex flex-row flex-wrap gap-4">
+            <TimeSeriesValueNumeric
+              label="Rpm"
+              unit="rpm"
+              renderValue={(value) => roundToDecimals(value, 0)}
+              timeseries={motorScrewRpm}
+            />
+
+            {state?.pressure_state?.wiring_error && (
+              <StatusBadge variant="error">
+                Cant Measure Pressure! Check Pressure Sensor Wiring!
+              </StatusBadge>
+            )}
+            <TimeSeriesValueNumeric
+              label="Pressure"
+              unit="bar"
+              renderValue={(value) => roundToDecimals(value, 0)}
+              timeseries={pressure}
+            />
+          </div>
+        </ControlCard>
+
+        <ControlCard className="bg-red" title="Mode">
+          <SelectionGroup<"Standby" | "Heat" | "Extrude">
+            value={state?.mode_state.mode}
+            orientation="vertical"
+            className="grid h-full grid-cols-2 gap-2"
+            options={{
+              Standby: {
+                children: "Standby",
+                icon: "lu:CirclePause",
+                isActiveClassName: "bg-green-600",
+                className: "h-full",
+              },
+              Heat: {
+                children: "Heat",
+                icon: "lu:Flame",
+                isActiveClassName: "bg-green-600",
+                className: "h-full",
+              },
+              Extrude: {
+                children: "Extrude",
+                icon: "lu:ArrowBigLeftDash",
+                isActiveClassName: "bg-green-600",
+                className: "h-full",
+                confirmation: allZonesReadyForExtrude()
+                  ? undefined
+                  : "Temperature is too low. Are you sure you want to extrude?",
+              },
+            }}
+            onChange={setExtruderMode}
+            disabled={isDisabled}
+            loading={isLoading}
+          />
+        </ControlCard>
+
+        <ControlCard className="bg-blue" title="Power Consumption">
+          <TimeSeriesValueNumeric
+            label="Total Power"
+            unit="W"
+            renderValue={(value) => roundToDecimals(value, 0)}
+            timeseries={combinedPower}
+          />
+          <TimeSeriesValueNumeric
+            label="Motor Power"
+            unit="W"
+            renderValue={(value) => roundToDecimals(value, 0)}
+            timeseries={motorPower}
+          />
+          <TimeSeriesValueNumeric
+            label="Motor Current"
+            unit="A"
+            renderValue={(value) => roundToDecimals(value, 1)}
+            timeseries={motorCurrent}
+          />
+          <TimeSeriesValueNumeric
+            label="Total Energy Consumption"
+            unit="kWh"
+            renderValue={(value) => roundToDecimals(value, 3)}
+            timeseries={totalEnergyKWh}
+          />
+        </ControlCard>
+      </ControlGrid>
+    </Page>
+  );
+}

electron/src/machines/extruder/extruder3/Extruder3Graph.tsx

@@ -0,0 +1,325 @@
+import { Page } from "@/components/Page";
+import {
+  AutoSyncedBigGraph,
+  SyncedFloatingControlPanel,
+  useGraphSync,
+  type GraphConfig,
+} from "@/components/graph";
+import React from "react";
+import { useExtruder3 } from "./useExtruder";
+
+export function Extruder3GraphsPage() {
+  const {
+    state,
+    nozzleTemperature,
+    nozzlePower,
+    frontTemperature,
+    frontPower,
+    backTemperature,
+    backPower,
+    middleTemperature,
+    middlePower,
+    pressure,
+    motorScrewRpm,
+    motorCurrent,
+    motorPower,
+    combinedPower,
+  } = useExtruder3();
+
+  const syncHook = useGraphSync("extruder-graphs");
+
+  // Base config
+  const baseConfig: GraphConfig = {
+    defaultTimeWindow: 30 * 60 * 1000, // 30 minutes
+    exportFilename: "extruder_data",
+    showLegend: true,
+    title: "extruder data",
+  };
+
+  const temperatureData = [
+    ...(nozzleTemperature
+      ? [
+          {
+            newData: nozzleTemperature,
+            title: "Nozzle",
+            color: "#ef4444",
+            lines:
+              state?.heating_states.nozzle?.target_temperature !== undefined
+                ? [
+                    {
+                      type: "target" as const,
+                      value: state.heating_states.nozzle.target_temperature,
+                      color: "#ef4444",
+                      show: true,
+                    },
+                  ]
+                : [],
+          },
+        ]
+      : []),
+    ...(frontTemperature
+      ? [
+          {
+            newData: frontTemperature,
+            title: "Front",
+            color: "#f59e0b",
+            lines:
+              state?.heating_states.front?.target_temperature !== undefined
+                ? [
+                    {
+                      type: "target" as const,
+                      value: state.heating_states.front.target_temperature,
+                      color: "#f59e0b",
+                      show: true,
+                    },
+                  ]
+                : [],
+          },
+        ]
+      : []),
+    ...(middleTemperature
+      ? [
+          {
+            newData: middleTemperature,
+            title: "Middle",
+            color: "#8b5cf6",
+            lines:
+              state?.heating_states.middle?.target_temperature !== undefined
+                ? [
+                    {
+                      type: "target" as const,
+                      value: state.heating_states.middle.target_temperature,
+                      color: "#8b5cf6",
+                      show: true,
+                    },
+                  ]
+                : [],
+          },
+        ]
+      : []),
+    ...(backTemperature
+      ? [
+          {
+            newData: backTemperature,
+            title: "Back",
+            color: "#3b82f6",
+            lines:
+              state?.heating_states.back?.target_temperature !== undefined
+                ? [
+                    {
+                      type: "target" as const,
+                      value: state.heating_states.back.target_temperature,
+                      color: "#3b82f6",
+                      show: true,
+                    },
+                  ]
+                : [],
+          },
+        ]
+      : []),
+  ];
+
+  const temperatureConfig: GraphConfig = {
+    ...baseConfig,
+    title: "Temperatures",
+    exportFilename: "temperatures_data",
+    colors: {
+      primary: "#ef4444",
+      grid: "#e2e8f0",
+      axis: "#64748b",
+      background: "#ffffff",
+    },
+  };
+
+  // Combined Power Graph (no target lines for power)
+  const powerData = [
+    ...(nozzlePower
+      ? [
+          {
+            newData: nozzlePower,
+            title: "Nozzle",
+            color: "#ef4444",
+          },
+        ]
+      : []),
+    ...(frontPower
+      ? [
+          {
+            newData: frontPower,
+            title: "Front",
+            color: "#f59e0b",
+          },
+        ]
+      : []),
+    ...(middlePower
+      ? [
+          {
+            newData: middlePower,
+            title: "Middle",
+            color: "#8b5cf6",
+          },
+        ]
+      : []),
+    ...(backPower
+      ? [
+          {
+            newData: backPower,
+            title: "Back",
+            color: "#3b82f6",
+          },
+        ]
+      : []),
+    ...(motorPower
+      ? [
+          {
+            newData: motorPower,
+            title: "Motor",
+            color: "#10b981",
+          },
+        ]
+      : []),
+    ...(combinedPower
+      ? [
+          {
+            newData: combinedPower,
+            title: "Total",
+            color: "#000000",
+          },
+        ]
+      : []),
+  ];
+
+  const powerConfig: GraphConfig = {
+    ...baseConfig,
+    title: "Power Outputs",
+    exportFilename: "power_data",
+    colors: {
+      primary: "#10b981",
+      grid: "#e2e8f0",
+      axis: "#64748b",
+      background: "#ffffff",
+    },
+  };
+
+  const currentConfig: GraphConfig = {
+    ...baseConfig,
+    title: "Motor Current",
+    exportFilename: "motor_current_data",
+    colors: {
+      primary: "#3b82f6",
+      grid: "#e2e8f0",
+      axis: "#64748b",
+      background: "#ffffff",
+    },
+  };
+
+  // Pressure Graph with connected target line
+  const pressureConfig: GraphConfig = {
+    ...baseConfig,
+    title: "Pressure",
+    exportFilename: "pressure_data",
+    colors: {
+      primary: "#3b82f6",
+      grid: "#e2e8f0",
+      axis: "#64748b",
+      background: "#ffffff",
+    },
+  };
+
+  // RPM Graph with connected target line
+  const rpmConfig: GraphConfig = {
+    ...baseConfig,
+    title: "RPM",
+    exportFilename: "rpm_data",
+    colors: {
+      primary: "#8b5cf6",
+      grid: "#e2e8f0",
+      axis: "#64748b",
+      background: "#ffffff",
+    },
+  };
+
+  return (
+    <Page className="pb-25">
+      <div className="flex flex-col gap-4">
+        <AutoSyncedBigGraph
+          syncHook={syncHook}
+          newData={{
+            newData: pressure,
+            color: "#3b82f6",
+            lines:
+              state?.pressure_state.target_bar !== undefined
+                ? [
+                    {
+                      type: "target" as const,
+                      value: state.pressure_state.target_bar,
+                      color: "#3b82f6",
+                      show: true,
+                    },
+                  ]
+                : [],
+          }}
+          config={pressureConfig}
+          unit="bar"
+          renderValue={(value) => value.toFixed(2)}
+          graphId="pressure-graph"
+        />
+
+        <AutoSyncedBigGraph
+          syncHook={syncHook}
+          newData={temperatureData}
+          config={temperatureConfig}
+          unit="C"
+          renderValue={(value) => value.toFixed(1)}
+          graphId="combined-temperatures"
+        />
+
+        <AutoSyncedBigGraph
+          syncHook={syncHook}
+          newData={powerData}
+          config={powerConfig}
+          unit="W"
+          renderValue={(value) => value.toFixed(1)}
+          graphId="combined-power"
+        />
+
+        <AutoSyncedBigGraph
+          syncHook={syncHook}
+          newData={{
+            newData: motorCurrent,
+            color: "#3b82f6",
+          }}
+          config={currentConfig}
+          unit="A"
+          renderValue={(value) => value.toFixed(2)}
+          graphId="motor-current"
+        />
+
+        <AutoSyncedBigGraph
+          syncHook={syncHook}
+          newData={{
+            newData: motorScrewRpm,
+            color: "#8b5cf6",
+            lines:
+              state?.screw_state.target_rpm !== undefined
+                ? [
+                    {
+                      type: "target" as const,
+                      value: state.screw_state.target_rpm,
+                      color: "#8b5cf6",
+                      show: true,
+                    },
+                  ]
+                : [],
+          }}
+          config={rpmConfig}
+          unit="rpm"
+          renderValue={(value) => value.toFixed(0)}
+          graphId="rpm-graph"
+        />
+      </div>
+
+      <SyncedFloatingControlPanel controlProps={syncHook.controlProps} />
+    </Page>
+  );
+}

electron/src/machines/extruder/extruder3/Extruder3Manual.tsx

@@ -0,0 +1,12 @@
+import { Page } from "@/components/Page";
+import { MarkdownWithToc } from "@/components/MarkdownWithToc";
+import React from "react";
+import extruderManualContent from "@/assets/markdown/extruder/manual.md?raw";
+
+export function ExtruderV3ManualPage() {
+  return (
+    <Page>
+      <MarkdownWithToc markdownContent={extruderManualContent} />
+    </Page>
+  );
+}

electron/src/machines/extruder/extruder3/Extruder3Page.tsx

@@ -0,0 +1,44 @@
+import { Topbar } from "@/components/Topbar";
+import { extruder3Route } from "@/routes/routes";
+import React from "react";
+
+export function Extruder3Page() {
+  const { serial } = extruder3Route.useParams();
+  return (
+    <Topbar
+      pathname={`/_sidebar/machines/extruder3/${serial}`}
+      items={[
+        {
+          link: "control",
+          title: "Control",
+          icon: "lu:CirclePlay",
+          activeLink: "control",
+        },
+        {
+          link: "graphs",
+          title: "Graphs",
+          icon: "lu:ChartSpline",
+          activeLink: "graphs",
+        },
+        {
+          link: "settings",
+          title: "Config",
+          icon: "lu:Settings",
+          activeLink: "settings",
+        },
+        {
+          link: "manual",
+          title: "Manual",
+          icon: "lu:BookOpen",
+          activeLink: "manual",
+        },
+        {
+          link: "presets",
+          title: "Presets",
+          icon: "lu:Save",
+          activeLink: "presets",
+        },
+      ]}
+    />
+  );
+}

electron/src/machines/extruder/extruder3/Extruder3PresetsPage.tsx

@@ -0,0 +1,203 @@
+import React from "react";
+import { PresetsPage } from "@/components/preset/PresetsPage";
+import { extruder3 } from "@/machines/properties";
+import { useExtruder3 } from "./useExtruder";
+import { z } from "zod";
+import {
+  PresetPreviewEntries,
+  previewSeparator,
+} from "@/components/preset/PresetPreviewTable";
+import { Preset, PresetData } from "@/lib/preset/preset";
+
+const extruder3PresetDataSchema = z
+  .object({
+    targetFrontHeatingTemperature: z.number(),
+    targetMiddleHeatingTemperature: z.number(),
+    targetBackHeatingTemperature: z.number(),
+    targetNozzleHeatingTemperature: z.number(),
+
+    targetInverterRpm: z.number(),
+    targetInverterPressure: z.number(),
+    inverterRegulation: z.enum(["RPM", "Pressure"]),
+
+    inverterRotationDirection: z.enum(["Forward", "Backward"]),
+
+    pressureLimit: z.number(),
+    pressureLimitEnabled: z.boolean(),
+
+    pidPressureKp: z.number(),
+    pidPressureKi: z.number(),
+    pidPressureKd: z.number(),
+  })
+  .partial();
+
+type Extruder3 = typeof extruder3PresetDataSchema;
+
+const schemas = new Map([[1, extruder3PresetDataSchema]]);
+
+const previewEntries: PresetPreviewEntries<Extruder3> = [
+  {
+    name: "Target Front Temperature",
+    unit: "C",
+    renderValue: (data: PresetData<Extruder3>) =>
+      data.targetFrontHeatingTemperature?.toFixed(1),
+  },
+  {
+    name: "Target Middle Temperature",
+    unit: "C",
+    renderValue: (data: PresetData<Extruder3>) =>
+      data.targetMiddleHeatingTemperature?.toFixed(1),
+  },
+  {
+    name: "Target Back Temperature",
+    unit: "C",
+    renderValue: (data: PresetData<Extruder3>) =>
+      data.targetBackHeatingTemperature?.toFixed(1),
+  },
+  {
+    name: "Target Nozzle Temperature",
+    unit: "C",
+    renderValue: (data: PresetData<Extruder3>) =>
+      data.targetNozzleHeatingTemperature?.toFixed(1),
+  },
+  previewSeparator,
+  {
+    name: "Inverter Regulation",
+    renderValue: (data: PresetData<Extruder3>) => data.inverterRegulation,
+  },
+  {
+    name: "Target Inverter RPM",
+    unit: "rpm",
+    renderValue: (data: PresetData<Extruder3>) =>
+      data.targetInverterRpm?.toFixed(2),
+  },
+  {
+    name: "Target Inverter Pressure",
+    unit: "bar",
+    renderValue: (data: PresetData<Extruder3>) =>
+      data.targetInverterPressure?.toFixed(1),
+  },
+  {
+    name: "Inverter Direction",
+    renderValue: (data: PresetData<Extruder3>) =>
+      data.inverterRotationDirection,
+  },
+  previewSeparator,
+  {
+    name: "Pressure Limit",
+    unit: "bar",
+    renderValue: (data: PresetData<Extruder3>) =>
+      data.pressureLimit?.toFixed(1),
+  },
+  {
+    name: "Enable Pressure Limit",
+    renderValue: (data: PresetData<Extruder3>) =>
+      data.pressureLimitEnabled ? "on" : "off",
+  },
+  previewSeparator,
+  {
+    name: "PID Pressue Kp",
+    renderValue: (data: PresetData<Extruder3>) =>
+      data.pidPressureKp?.toFixed(4),
+  },
+  {
+    name: "PID Pressue Ki",
+    renderValue: (data: PresetData<Extruder3>) =>
+      data.pidPressureKi?.toFixed(4),
+  },
+  {
+    name: "PID Pressue Kd",
+    renderValue: (data: PresetData<Extruder3>) =>
+      data.pidPressureKd?.toFixed(4),
+  },
+];
+
+export function Extruder3PresetsPage() {
+  const {
+    state,
+    defaultState,
+
+    setFrontHeatingTemperature,
+    setMiddleHeatingTemperature,
+    setBackHeatingTemperature,
+    setNozzleHeatingTemperature,
+
+    setInverterTargetRpm,
+    setInverterTargetPressure,
+    setInverterRegulation,
+    setInverterRotationDirection,
+
+    setExtruderPressureLimit,
+    setExtruderPressureLimitEnabled,
+
+    setPressurePidKd,
+    setPressurePidKi,
+    setPressurePidKp,
+  } = useExtruder3();
+
+  const toPresetData = (s?: typeof state): PresetData<Extruder3> => ({
+    targetFrontHeatingTemperature: s?.heating_states.front.target_temperature,
+    targetMiddleHeatingTemperature: s?.heating_states.middle.target_temperature,
+    targetBackHeatingTemperature: s?.heating_states.back.target_temperature,
+    targetNozzleHeatingTemperature: s?.heating_states.nozzle.target_temperature,
+
+    targetInverterRpm: s?.screw_state.target_rpm,
+    targetInverterPressure: s?.pressure_state.target_bar,
+    inverterRegulation: s?.regulation_state.uses_rpm ? "RPM" : "Pressure",
+
+    inverterRotationDirection: s?.rotation_state?.forward
+      ? "Forward"
+      : "Backward",
+
+    pressureLimit: s?.extruder_settings_state.pressure_limit,
+    pressureLimitEnabled: s?.extruder_settings_state.pressure_limit_enabled,
+
+    pidPressureKp: s?.pid_settings.pressure.kp,
+    pidPressureKi: s?.pid_settings.pressure.ki,
+    pidPressureKd: s?.pid_settings.pressure.kd,
+  });
+
+  const defaults = toPresetData(defaultState);
+
+  const applyPreset = (preset: Preset<Extruder3>) => {
+    setFrontHeatingTemperature(
+      preset.data.targetFrontHeatingTemperature ?? 150.0,
+    );
+    setMiddleHeatingTemperature(
+      preset.data.targetMiddleHeatingTemperature ?? 150.0,
+    );
+    setBackHeatingTemperature(
+      preset.data.targetBackHeatingTemperature ?? 150.0,
+    );
+    setNozzleHeatingTemperature(
+      preset.data.targetNozzleHeatingTemperature ?? 150.0,
+    );
+
+    setInverterTargetRpm(preset.data.targetInverterRpm ?? 0);
+    setInverterTargetPressure(preset.data.targetInverterPressure ?? 0);
+    setInverterRegulation(preset.data.inverterRegulation === "RPM");
+
+    setInverterRotationDirection(
+      preset.data.inverterRotationDirection === "Forward",
+    );
+
+    setExtruderPressureLimit(preset.data.pressureLimit ?? 100.0);
+    setExtruderPressureLimitEnabled(preset.data.pressureLimitEnabled ?? true);
+
+    setPressurePidKp(preset.data.pidPressureKp ?? 0.16);
+    setPressurePidKi(preset.data.pidPressureKi ?? 0.0);
+    setPressurePidKd(preset.data.pidPressureKd ?? 0.008);
+  };
+
+  return (
+    <PresetsPage
+      machine_identification={extruder3.machine_identification}
+      currentState={toPresetData(state)}
+      schemas={schemas}
+      schemaVersion={1}
+      applyPreset={applyPreset}
+      previewEntries={previewEntries}
+      defaultState={defaults}
+    />
+  );
+}

electron/src/machines/extruder/extruder3/Extruder3Settings.tsx

@@ -0,0 +1,291 @@
+import React, { useState } from "react";
+import { Page } from "@/components/Page";
+import { ControlCard } from "@/control/ControlCard";
+import { Label } from "@/control/Label";
+import { SelectionGroupBoolean } from "@/control/SelectionGroup";
+import { EditValue } from "@/control/EditValue";
+import { roundToDecimals } from "@/lib/decimal";
+import { useExtruder3 } from "./useExtruder";
+import { ControlGrid } from "@/control/ControlGrid";
+
+export function Extruder3SettingsPage() {
+  const {
+    state,
+    defaultState,
+    setInverterRotationDirection,
+    resetInverter,
+    setExtruderPressureLimit,
+    setExtruderPressureLimitEnabled,
+    setPressurePidKp,
+    setPressurePidKi,
+    setPressurePidKd,
+    setTemperaturePidValue,
+  } = useExtruder3();
+
+  const [showAdvanced, setShowAdvanced] = useState(false);
+
+  return (
+    <Page>
+      <ControlCard className="bg-red" title="Inverter Settings">
+        <Label label="Rotation Direction">
+          <SelectionGroupBoolean
+            value={state?.rotation_state.forward}
+            optionTrue={{ children: "Forward" }}
+            optionFalse={{ children: "Backward" }}
+            onChange={setInverterRotationDirection}
+          />
+        </Label>
+
+        <Label label="Reset Inverter">
+          <button
+            onClick={resetInverter}
+            className="inline-block w-fit max-w-max rounded bg-red-600 px-4 py-4 text-base whitespace-nowrap text-white hover:bg-red-700"
+            style={{ minWidth: "auto", width: "fit-content" }}
+          >
+            Reset Inverter
+          </button>
+        </Label>
+      </ControlCard>
+
+      <ControlCard className="bg-red" title="Extruder Settings">
+        <Label label="Nozzle Pressure Limit">
+          <EditValue
+            value={state?.extruder_settings_state.pressure_limit}
+            defaultValue={defaultState?.extruder_settings_state.pressure_limit}
+            unit="bar"
+            title="Nozzle Pressure Limit"
+            min={0}
+            max={350}
+            renderValue={(value) => roundToDecimals(value, 0)}
+            onChange={setExtruderPressureLimit}
+          />
+        </Label>
+        <Label label="Nozzle Pressure Limit Enabled">
+          <SelectionGroupBoolean
+            value={state?.extruder_settings_state.pressure_limit_enabled}
+            optionTrue={{ children: "Enabled" }}
+            optionFalse={{ children: "Disabled" }}
+            onChange={setExtruderPressureLimitEnabled}
+          />
+        </Label>
+        <Label label="Show Advanced PID Settings">
+          <SelectionGroupBoolean
+            value={showAdvanced}
+            optionTrue={{ children: "Show" }}
+            optionFalse={{ children: "Hide" }}
+            onChange={setShowAdvanced}
+          />
+        </Label>
+      </ControlCard>
+
+      {showAdvanced && (
+        <>
+          <ControlCard title="Pressure PID Settings ">
+            <Label label="Kp">
+              <EditValue
+                value={state?.pid_settings.pressure.kp}
+                defaultValue={defaultState?.pid_settings.pressure.kp}
+                min={0}
+                max={100}
+                step={0.01}
+                renderValue={(v) => roundToDecimals(v, 2)}
+                onChange={setPressurePidKp}
+                title="Pressure PID KP"
+              />
+            </Label>
+            <Label label="Ki">
+              <EditValue
+                value={state?.pid_settings.pressure.ki}
+                defaultValue={defaultState?.pid_settings.pressure.ki}
+                min={0}
+                max={100}
+                step={0.01}
+                renderValue={(v) => roundToDecimals(v, 2)}
+                onChange={setPressurePidKi}
+                title="Pressure PID KI"
+              />
+            </Label>
+            <Label label="Kd">
+              <EditValue
+                value={state?.pid_settings.pressure.kd}
+                defaultValue={defaultState?.pid_settings.pressure.kd}
+                min={0}
+                max={100}
+                step={0.01}
+                renderValue={(v) => roundToDecimals(v, 2)}
+                onChange={setPressurePidKd}
+                title="Pressure PID KD"
+              />
+            </Label>
+          </ControlCard>
+          <ControlGrid>
+            <ControlCard title="Temperature PID Settings (Front) ">
+              <Label label="Kp">
+                <EditValue
+                  value={state?.pid_settings.temperature.front.kp}
+                  defaultValue={defaultState?.pid_settings.temperature.front.kp}
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("front", "kp", v)}
+                  title="Temperature PID KP"
+                />
+              </Label>
+              <Label label="Ki">
+                <EditValue
+                  value={state?.pid_settings.temperature.front.ki}
+                  defaultValue={defaultState?.pid_settings.temperature.front.ki}
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("front", "ki", v)}
+                  title="Temperature PID KI"
+                />
+              </Label>
+              <Label label="Kd">
+                <EditValue
+                  value={state?.pid_settings.temperature.front.kd}
+                  defaultValue={defaultState?.pid_settings.temperature.front.kd}
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("front", "kd", v)}
+                  title="Temperature PID KD"
+                />
+              </Label>
+            </ControlCard>
+            <ControlCard title="Temperature PID Settings (Middle) ">
+              <Label label="Kp">
+                <EditValue
+                  value={state?.pid_settings.temperature.middle.kp}
+                  defaultValue={
+                    defaultState?.pid_settings.temperature.middle.kp
+                  }
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("middle", "kp", v)}
+                  title="Temperature PID KP"
+                />
+              </Label>
+              <Label label="Ki">
+                <EditValue
+                  value={state?.pid_settings.temperature.middle.ki}
+                  defaultValue={
+                    defaultState?.pid_settings.temperature.middle.ki
+                  }
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("middle", "ki", v)}
+                  title="Temperature PID KI"
+                />
+              </Label>
+              <Label label="Kd">
+                <EditValue
+                  value={state?.pid_settings.temperature.middle.kd}
+                  defaultValue={
+                    defaultState?.pid_settings.temperature.middle.kd
+                  }
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("middle", "kd", v)}
+                  title="Temperature PID KD"
+                />
+              </Label>
+            </ControlCard>
+            <ControlCard title="Temperature PID Settings (Back) ">
+              <Label label="Kp">
+                <EditValue
+                  value={state?.pid_settings.temperature.back.kp}
+                  defaultValue={defaultState?.pid_settings.temperature.back.kp}
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("back", "kp", v)}
+                  title="Temperature PID KP"
+                />
+              </Label>
+              <Label label="Ki">
+                <EditValue
+                  value={state?.pid_settings.temperature.back.ki}
+                  defaultValue={defaultState?.pid_settings.temperature.back.ki}
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("back", "ki", v)}
+                  title="Temperature PID KI"
+                />
+              </Label>
+              <Label label="Kd">
+                <EditValue
+                  value={state?.pid_settings.temperature.back.kd}
+                  defaultValue={defaultState?.pid_settings.temperature.back.kd}
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("back", "kd", v)}
+                  title="Temperature PID KD"
+                />
+              </Label>
+            </ControlCard>
+            <ControlCard title="Temperature PID Settings (Nozzle) ">
+              <Label label="Kp">
+                <EditValue
+                  value={state?.pid_settings.temperature.nozzle.kp}
+                  defaultValue={
+                    defaultState?.pid_settings.temperature.nozzle.kp
+                  }
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("nozzle", "kp", v)}
+                  title="Temperature PID KP"
+                />
+              </Label>
+              <Label label="Ki">
+                <EditValue
+                  value={state?.pid_settings.temperature.nozzle.ki}
+                  defaultValue={
+                    defaultState?.pid_settings.temperature.nozzle.ki
+                  }
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("nozzle", "ki", v)}
+                  title="Temperature PID KI"
+                />
+              </Label>
+              <Label label="Kd">
+                <EditValue
+                  value={state?.pid_settings.temperature.nozzle.kd}
+                  defaultValue={
+                    defaultState?.pid_settings.temperature.nozzle.kd
+                  }
+                  min={0}
+                  max={100}
+                  step={0.001}
+                  renderValue={(v) => roundToDecimals(v, 3)}
+                  onChange={(v) => setTemperaturePidValue("nozzle", "kd", v)}
+                  title="Temperature PID KD"
+                />
+              </Label>
+            </ControlCard>
+          </ControlGrid>
+        </>
+      )}
+    </Page>
+  );
+}