Merge pull request #829 from qitechgmbh/808-lock-kernel-in-nix-to-last-working-rt-kernel

Newest kernel with realtime preemption

.gitattributes

@@ -0,0 +1,3 @@
+.png filter=lfs diff=lfs merge=lfs -text
+.jpg filter=lfs diff=lfs merge=lfs -text
+.jpeg filter=lfs diff=lfs merge=lfs -text

.github/copilot-instructions.md

@@ -0,0 +1,29 @@
+This is a machine control software project.
+
+## Repository structure
+
+### Frontend
+
+`/electron`: Frontend code for the control software built with React and Electron.
+
+### Backend
+
+`/server`: Implements machine setup & loop. Exposes a REST & Socket.io API for the electron frontend.
+`/ethercat-hal`: Hardware abstraction layer for Beckhoff (and possibly other EtherCat) devices and protocols.
+`/ethercat-hal-derive`: Macros for ethercat-hal
+`/control-core`: Generic logic for the server.
+
+### HMI Panel Operating System
+
+`/nixos`: Custom Linux with realtime kernel & preconfigured for touchscreens.
+
+### Other
+
+/docs: Documentation for the project.
+
+## Key Guidelines
+
+1. Follow Rust & Typescript best practices and idiomatic patterns
+2. Maintain existing code structure and organization
+3. Write unit tests for new functionality where applicable.
+4. Document public APIs and complex logic in code. Suggest changes to the `docs/` folder when appropriate

.mailmap

@@ -0,0 +1,49 @@
+# Canonical identities on the left, aliases on the right.
+# Format options:
+#   Canon Name <canon@example.com> <alias@example.com>
+#   Canon Name <canon@example.com> Alias Name <alias@example.com>
+
+# Icedsoda -> Philipp
+Philipp <29167146+1cedsoda@users.noreply.github.com> <29167146+1cedsoda@users.noreply.github.com>
+
+# kraemr / Robin Krämer -> Robin
+Robin <93094049+kraemr@users.noreply.github.com> <93094049+kraemr@users.noreply.github.com>
+Robin <93094049+kraemr@users.noreply.github.com> Robin Krämer <93094049+kraemr@users.noreply.github.com>
+
+# Oshgnacknak -> Josh
+Josh <osh@oshgnacknak.de> <osh@oshgnacknak.de>
+
+# Milan
+Milan <61654753+MilanVDB@users.noreply.github.com>
+
+# dependabot stays as bot
+Dependabot <49699333+dependabot[bot]@users.noreply.github.com> <49699333+dependabot[bot]@users.noreply.github.com>
+
+# Medformatik / Florian -> Florian
+Florian <dev@fwcr.de> <dev@fwcr.de>
+Florian <dev@fwcr.de> Medformatik <dev@fwcr.de>
+
+# Anatomik5 -> Alisher (merge noreply + gmail under Alisher)
+Alisher <115714693+Anatomik5@users.noreply.github.com> <115714693+Anatomik5@users.noreply.github.com>
+Alisher <115714693+Anatomik5@users.noreply.github.com> Anatomik5 <darmenovalisher@gmail.com>
+Alisher <115714693+Anatomik5@users.noreply.github.com> Darmenov Alisher <115714693+Anatomik5@users.noreply.github.com>
+
+# snacj -> Melvin
+Melvin <0xsnacj@proton.me> <0xsnacj@proton.me>
+Melvin <0xsnacj@proton.me> snacj <bbmelvin@gmx.de>
+Melvin <0xsnacj@proton.me> Melvin Spieß <0xsnacj@proton.me>
+
+# Janhegerq -> Jan
+Jan <219994445+Janhegerq@users.noreply.github.com> <219994445+Janhegerq@users.noreply.github.com>
+Jan <219994445+Janhegerq@users.noreply.github.com> <19994445+Janhegerq@users.noreply.github.com>
+
+# Christian / TheBest6337 -> christian
+Christian <christian.zschoegner@outlook.de> <christian.zschoegner@outlook.de>
+Christian <christian.zschoegner@outlook.de> TheBest6337 <christian.zschoegner@outlook.de>
+Christian <christian.zschoegner@outlook.de> Christian <80114847+TheBest6337@users.noreply.github.com>
+
+# nixos-install.sh
+nixos-install.sh <nixos-install.sh@localhost> <nixos-install.sh@localhost>
+
+# copilot-swe-agent bot
+Copilot <198982749+Copilot@users.noreply.github.com> <198982749+Copilot@users.noreply.github.com>

.vscode/settings.json

@@ -1,5 +1,6 @@
 {
     "typescript.inlayHints.enumMemberValues.enabled": false,
-     "git.detectSubmodules": true,
-     "git.detectSubmodulesLimit": 10,
+    "git.detectSubmodules": true,
+    "git.detectSubmodulesLimit": 10,
+    "rust-analyzer.check.command": "clippy",
 }

CHANGELOG.md

@@ -1,36 +1,148 @@
+# `2.10.0`
+_16.10.2025_
+
+## Winder V2
+- [#776](https://github.com/qitechgmbh/control/pull/776) Added explanation for padding in winder manual
+- [#804](https://github.com/qitechgmbh/control/pull/804) Added gearbox conversion
+
+## General 
+- [#717](https://github.com/qitechgmbh/control/pull/717) Show from option for graphs added
+- [#805](https://github.com/qitechgmbh/control/pull/805) Graphs run better now
+
+
+
+# `2.9.1`
+_10.10.2025_
+
+## Winder V2
+- [#796](https://github.com/qitechgmbh/control/pull/796) Winding in adaptive mode, while puller is in reverse mode is now possible
+
+## General
+- [#780](https://github.com/qitechgmbh/control/pull/780) Updates are faster now
+- [#746](https://github.com/qitechgmbh/control/pull/746) Improved scrollbar styling for manuals
+
+# `2.9.0`
+_06.10.2025_
+
+## Winder V2
+- [#778](https://github.com/qitechgmbh/control/pull/778) Increased Winder Traverse Step size limit
+
+## General
+- [#725](https://github.com/qitechgmbh/control/pull/725) Improved troubleshooting and update page
+- [#625](https://github.com/qitechgmbh/control/pull/625) Improved stability of Machine-Connections
+
+
+# `2.8.0`
+_30.09.2025_
+
+
+## Laser V1
+- [#741](https://github.com/qitechgmbh/control/pull/741) Added roundness measurement to two-axis Laser
+
+
+## Winder V2
+- [#745](https://github.com/qitechgmbh/control/pull/745), [#756](https://github.com/qitechgmbh/control/pull/756) improved Winder Frontend
+
+## General
+- [#447](https://github.com/qitechgmbh/control/pull/447) added AquaPath Machine
+
+
+
+
+# `2.7.0`
+
+_17.09.2025_
+
+## Extruder V2
+
+- [#695](https://github.com/qitechgmbh/control/pull/695) Pressure and Rpm Regulation properly switch again
+
+## Winder V2
+
+- [#727](https://github.com/qitechgmbh/control/pull/727) Removed estimated diameter
+
+## Laser V1
+
+- [#731](https://github.com/qitechgmbh/control/pull/731) Added Laser with two-axis measurements
+
+## General
+
+- [#679](https://github.com/qitechgmbh/control/pull/679),[#677](https://github.com/qitechgmbh/control/pull/677),[#698](https://github.com/qitechgmbh/control/pull/698), [#684](https://github.com/qitechgmbh/control/pull/684),[#706](https://github.com/qitechgmbh/control/pull/706) Greatly improved overall system latency and stability
+
+- [#720](https://github.com/qitechgmbh/control/pull/720), [#686](https://github.com/qitechgmbh/control/pull/686) Improved User Interface
+
+# `2.6.0`
+
+_03.09.2025_
+
+## Extruder V2
+
+- [#658](https://github.com/qitechgmbh/control/pull/658) Added manual
+- [#639](https://github.com/qitechgmbh/control/pull/639) Swapped order of screw speed regulation buttons
+
+## Laser V1
+
+- [#642](https://github.com/qitechgmbh/control/pull/642) Improved stability of laser connection
+
+## General
+
+- [#657](https://github.com/qitechgmbh/control/pull/657) Time frame for graphs is now remembered
+- [#641](https://github.com/qitechgmbh/control/pull/641) Removed duplicate scrollbar from manuals
+
+# `2.5.0`
+
+_27.08.2025_
+
+## Extruder V2
+
+- [#595](https://github.com/qitechgmbh/control/pull/600) Simplified power graphs
+- [#593](https://github.com/qitechgmbh/control/pull/599) Added identifiers for temperature sensors in temperature graph
+
+## Winder V2
+
+- [#598](https://github.com/qitechgmbh/control/pull/601) Images now load properly in the manual
+
+## General
+
+- [#540](https://github.com/qitechgmbh/control/pull/592) Improved readability of the presets
+- [#591](https://github.com/qitechgmbh/control/pull/626) Significantly improved user interface performance and stability
+
 # `2.4.0`
+
 _14.08.2025_
 
-## Winder V2 
+## Winder V2
+
 - [#550](https://github.com/qitechgmbh/control/pull/551) Can now reset wound distance while winding
-  
+
 ## General
-- [#568](https://github.com/qitechgmbh/control/pull/569) switched to a Realtime Linuxkernel on nixos
-- [#574](https://github.com/qitechgmbh/control/pull/587) isolated cores 2 and 3 on nixos to guarentee strict timings for ethercat
-- [#588](https://github.com/qitechgmbh/control/pull/589) limited frontend to 30 fps to reduce cpu usage
-- [#572](https://github.com/qitechgmbh/control/pull/572) switched to io_uring to reduce latency
-
 
+- [#568](https://github.com/qitechgmbh/control/pull/569),[#572](https://github.com/qitechgmbh/control/pull/572), [#574](https://github.com/qitechgmbh/control/pull/587) Improved EtherCAT performance
+- [#588](https://github.com/qitechgmbh/control/pull/589) Improved frontend performance
 
 # `2.3.0`
+
 _06.08.2025_
 
 ## Extruder V2
+
 - [#520](https://github.com/qitechgmbh/control/pull/523) added warning message incase inverter is overloaded
 - [#501](https://github.com/qitechgmbh/control/pull/508) raised pressure limit of pressured PID mode for extruder
 - [#519](https://github.com/qitechgmbh/control/pull/549) added total power consumption monitor and graphs for voltage,current and wattage of the motor
 
-## Winder V2 
+## Winder V2
+
 - [#64](https://github.com/qitechgmbh/control/pull/504) added winder handbook
 
 ## Laser V1
+
 - [#497](https://github.com/qitechgmbh/control/pull/498) improved diameter visualisation
 
 ## General
+
 - [#62](https://github.com/qitechgmbh/control/pull/514),[#524](https://github.com/qitechgmbh/control/pull/528) added machine presets to load configurations
 - [#526](https://github.com/qitechgmbh/control/pull/541) added import and export of presets
 
-
 # `2.2.0`
 
 _15.07.2025_
@@ -43,6 +155,7 @@ _15.07.2025_
 - [#169](https://github.com/qitechgmbh/control/pull/492), Added a Confirmation Dialog when extruder has not reached 90% of target temperature
 
 ## Winder V2
+
 - [#471](https://github.com/qitechgmbh/control/pull/480), Added a live value to track the pulled distance and the option of switching to a different Mode after a given distance.
 
 ## General

Cargo.lock

@@ -99,9 +99,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.98"
+version = "1.0.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
+checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
 
 [[package]]
 name = "approx"
@@ -284,9 +284,9 @@ checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
 [[package]]
 name = "axum"
-version = "0.8.4"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "021e862c184ae977658b36c4500f7feac3221ca5da43e3f25bd04ab6c79a29b5"
+checksum = "8a18ed336352031311f4e0b4dd2ff392d4fbb370777c9d18d7fc9d7359f73871"
 dependencies = [
  "axum-core",
  "axum-macros",
@@ -304,8 +304,7 @@ dependencies = [
  "mime",
  "percent-encoding",
  "pin-project-lite",
- "rustversion",
- "serde",
+ "serde_core",
  "serde_json",
  "serde_path_to_error",
  "serde_urlencoded",
@@ -319,9 +318,9 @@ dependencies = [
 
 [[package]]
 name = "axum-core"
-version = "0.5.2"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68464cd0412f486726fb3373129ef5d2993f90c34bc2bc1c1e9943b2f4fc7ca6"
+checksum = "59446ce19cd142f8833f856eb31f3eb097812d1479ab224f54d72428ca21ea22"
 dependencies = [
  "bytes",
  "futures-core",
@@ -330,7 +329,6 @@ dependencies = [
  "http-body-util",
  "mime",
  "pin-project-lite",
- "rustversion",
  "sync_wrapper",
  "tower-layer",
  "tower-service",
@@ -581,6 +579,7 @@ dependencies = [
  "approx",
  "axum",
  "bitvec",
+ "control_core_derive",
  "core_affinity",
  "crc",
  "erased-serde",
@@ -595,10 +594,20 @@ dependencies = [
  "smol",
  "socketioxide",
  "textplots",
+ "tokio",
  "tracing",
  "uom",
 ]
 
+[[package]]
+name = "control_core_derive"
+version = "0.1.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.105",
+]
+
 [[package]]
 name = "core-foundation"
 version = "0.10.0"
@@ -944,11 +953,12 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "erased-serde"
-version = "0.4.6"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e004d887f51fcb9fef17317a2f3525c887d8aa3f4f50fed920816a688284a5b7"
+checksum = "259d404d09818dec19332e31d94558aeb442fea04c817006456c24b5460bbd4b"
 dependencies = [
  "serde",
+ "serde_core",
  "typeid",
 ]
 
@@ -1009,6 +1019,7 @@ dependencies = [
  "futures",
  "rand",
  "smol",
+ "tracing",
  "uom",
 ]
 
@@ -1667,15 +1678,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "is-docker"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "928bae27f42bc99b60d9ac7334e3a21d10ad8f1835a4e12ec3ec0464765ed1b3"
-dependencies = [
- "once_cell",
-]
-
 [[package]]
 name = "is-terminal"
 version = "0.4.16"
@@ -1687,16 +1689,6 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
-[[package]]
-name = "is-wsl"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "173609498df190136aa7dea1a91db051746d339e18476eed5ca40521f02d7aa5"
-dependencies = [
- "is-docker",
- "once_cell",
-]
-
 [[package]]
 name = "is_terminal_polyfill"
 version = "1.70.1"
@@ -1736,9 +1728,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.175"
+version = "0.2.176"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543"
+checksum = "58f929b4d672ea937a23a1ab494143d968337a5f47e56d0815df1e0890ddf174"
 
 [[package]]
 name = "libloading"
@@ -1815,11 +1807,11 @@ dependencies = [
 
 [[package]]
 name = "matchers"
-version = "0.1.0"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
+checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
 dependencies = [
- "regex-automata 0.1.10",
+ "regex-automata",
 ]
 
 [[package]]
@@ -1943,12 +1935,11 @@ checksum = "43794a0ace135be66a25d3ae77d41b91615fb68ae937f904090203e81f755b65"
 
 [[package]]
 name = "nu-ansi-term"
-version = "0.46.0"
+version = "0.50.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
+checksum = "d4a28e057d01f97e61255210fcff094d74ed0466038633e95017f5beb68e4399"
 dependencies = [
- "overload",
- "winapi",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1991,17 +1982,6 @@ version = "11.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
 
-[[package]]
-name = "open"
-version = "5.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2483562e62ea94312f3576a7aca397306df7990b8d89033e18766744377ef95"
-dependencies = [
- "is-wsl",
- "libc",
- "pathdiff",
-]
-
 [[package]]
 name = "opentelemetry"
 version = "0.30.0"
@@ -2076,12 +2056,6 @@ dependencies = [
  "thiserror",
 ]
 
-[[package]]
-name = "overload"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
-
 [[package]]
 name = "parking"
 version = "2.2.1"
@@ -2117,12 +2091,6 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
-[[package]]
-name = "pathdiff"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
-
 [[package]]
 name = "pcap"
 version = "2.2.0"
@@ -2412,42 +2380,27 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.11.1"
+version = "1.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+checksum = "8b5288124840bee7b386bc413c487869b360b2b4ec421ea56425128692f2a82c"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.4.9",
- "regex-syntax 0.8.5",
+ "regex-automata",
+ "regex-syntax",
 ]
 
 [[package]]
 name = "regex-automata"
-version = "0.1.10"
+version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
-dependencies = [
- "regex-syntax 0.6.29",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.4.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+checksum = "833eb9ce86d40ef33cb1306d8accf7bc8ec2bfea4355cbdebb3df68b40925cad"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax 0.8.5",
+ "regex-syntax",
 ]
 
-[[package]]
-name = "regex-syntax"
-version = "0.6.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
-
 [[package]]
 name = "regex-syntax"
 version = "0.8.5"
@@ -2587,18 +2540,28 @@ dependencies = [
 
 [[package]]
 name = "serde"
-version = "1.0.219"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.219"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2607,9 +2570,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.140"
+version = "1.0.143"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
+checksum = "d401abef1d108fbd9cbaebc3e46611f4b1021f714a0597a71f41ee463f5f4a5a"
 dependencies = [
  "itoa",
  "memchr",
@@ -2683,9 +2646,9 @@ dependencies = [
 
 [[package]]
 name = "serialport"
-version = "4.7.2"
+version = "4.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdb0bc984f6af6ef8bab54e6cf2071579ee75b9286aa9f2319a0d220c28b0a2b"
+checksum = "2acaf3f973e8616d7ceac415f53fc60e190b2a686fbcf8d27d0256c741c5007b"
 dependencies = [
  "bitflags 2.9.0",
  "cfg-if",
@@ -2709,28 +2672,23 @@ dependencies = [
  "axum",
  "bitvec",
  "control_core",
- "crc",
+ "control_core_derive",
  "dhat",
  "ethercat_hal",
  "ethercrab",
  "euclid",
  "futures",
  "lazy_static",
- "open",
  "opentelemetry",
  "opentelemetry-otlp",
  "opentelemetry_sdk",
  "regex",
  "serde",
  "serde_json",
- "serial",
  "serialport",
  "smol",
  "socketioxide",
  "textplots",
- "thread-priority",
- "tikv-jemalloc-ctl",
- "tikv-jemallocator",
  "tokio",
  "tonic",
  "tower-http",
@@ -3043,20 +3001,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3bf63baf9f5039dadc247375c29eb13706706cfde997d0330d05aa63a77d8820"
 
-[[package]]
-name = "thread-priority"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd4ef372b29fbcc6cb0cef97bcbf3ffa9da90e02eb23dbf14db48ce30d11d2d5"
-dependencies = [
- "bitflags 2.9.0",
- "cfg-if",
- "libc",
- "log",
- "rustversion",
- "windows",
-]
-
 [[package]]
 name = "thread_local"
 version = "1.1.8"
@@ -3067,37 +3011,6 @@ dependencies = [
  "once_cell",
 ]
 
-[[package]]
-name = "tikv-jemalloc-ctl"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f21f216790c8df74ce3ab25b534e0718da5a1916719771d3fec23315c99e468b"
-dependencies = [
- "libc",
- "paste",
- "tikv-jemalloc-sys",
-]
-
-[[package]]
-name = "tikv-jemalloc-sys"
-version = "0.6.0+5.3.0-1-ge13ca993e8ccb9ba9847cc330696e02839f328f7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd3c60906412afa9c2b5b5a48ca6a5abe5736aec9eb48ad05037a677e52e4e2d"
-dependencies = [
- "cc",
- "libc",
-]
-
-[[package]]
-name = "tikv-jemallocator"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cec5ff18518d81584f477e9bfdf957f5bb0979b0bac3af4ca30b5b3ae2d2865"
-dependencies = [
- "libc",
- "tikv-jemalloc-sys",
-]
-
 [[package]]
 name = "timerfd"
 version = "1.6.0"
@@ -3378,15 +3291,15 @@ dependencies = [
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.3.19"
+version = "0.3.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8189decb5ac0fa7bc8b96b7cb9b2701d60d48805aca84a238004d665fcc4008"
+checksum = "2054a14f5307d601f88daf0553e1cbf472acc4f2c51afab632431cdcd72124d5"
 dependencies = [
  "chrono",
  "matchers",
  "nu-ansi-term",
  "once_cell",
- "regex",
+ "regex-automata",
  "sharded-slab",
  "smallvec",
  "thread_local",
@@ -3670,28 +3583,6 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
-[[package]]
-name = "windows"
-version = "0.61.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
-dependencies = [
- "windows-collections",
- "windows-core",
- "windows-future",
- "windows-link",
- "windows-numerics",
-]
-
-[[package]]
-name = "windows-collections"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
-dependencies = [
- "windows-core",
-]
-
 [[package]]
 name = "windows-core"
 version = "0.61.2"
@@ -3705,17 +3596,6 @@ dependencies = [
  "windows-strings 0.4.2",
 ]
 
-[[package]]
-name = "windows-future"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
-dependencies = [
- "windows-core",
- "windows-link",
- "windows-threading",
-]
-
 [[package]]
 name = "windows-implement"
 version = "0.60.0"
@@ -3744,16 +3624,6 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
 
-[[package]]
-name = "windows-numerics"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
-dependencies = [
- "windows-core",
- "windows-link",
-]
-
 [[package]]
 name = "windows-registry"
 version = "0.4.0"
@@ -3855,15 +3725,6 @@ dependencies = [
  "windows_x86_64_msvc 0.53.0",
 ]
 
-[[package]]
-name = "windows-threading"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
-dependencies = [
- "windows-link",
-]
-
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.6"

Cargo.toml

@@ -5,6 +5,23 @@ members = [
     "ethercat-hal-derive",
     "control-core",
     "ethercat-eeprom-dump",
+    "control-core-derive",
 ]
 exclude = []
 resolver = "2"
+
+[workspace.lints.clippy]
+# Individual lints (priority 0)
+
+# don't lint poissbilities for let chains because they were introduces after Rust 1.86
+collapsible_if = "allow"
+
+# Lint groups (priority -1)
+correctness = { level = "warn", priority = -1 }
+suspicious = { level = "warn", priority = -1 }
+complexity = { level = "warn", priority = -1 }
+perf = { level = "warn", priority = -1 }
+style = { level = "warn", priority = -1 }
+pendantic = { level = "warn", priority = -1 }
+cargo = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }

README.md

@@ -7,6 +7,9 @@ QiTech Control is an industrial control panel software for the next generation o
 [![](https://img.youtube.com/vi/KI3YeBwfV-s/maxresdefault.jpg)](https://www.youtube.com/watch?v=KI3YeBwfV-s)
 *Click here to watch a video demo of our software.*
 
+[![](https://img.youtube.com/vi/55egCAkQgyM/maxresdefault.jpg)](https://youtu.be/55egCAkQgyM) 
+*Click here to watch a full explainer Video of our Software.*
+
 # Repo Structure
 
 Frontend
@@ -32,7 +35,7 @@ Other
 
 ## Backend
 
-To interface with Beckhoff and other EtherCAT devices we need an EtherCAY master stoftware. Possibilities are [PySOEM](https://github.com/bnjmnp/pysoem) (Python), [SOEM](https://github.com/OpenEtherCATsociety/SOEM) (C) and [Ethercrab](https://github.com/ethercrab-rs/ethercrab) (Rust). For realtime operation only C and Rust are suitable. We chose Rust because of safety and confidence in the written code.
+To interface with Beckhoff and other EtherCAT devices we need an EtherCAT master stoftware. Possibilities are [PySOEM](https://github.com/bnjmnp/pysoem) (Python), [SOEM](https://github.com/OpenEtherCATsociety/SOEM) (C) and [Ethercrab](https://github.com/ethercrab-rs/ethercrab) (Rust). For realtime operation only C and Rust are suitable. We chose Rust because of safety and confidence in the written code.
 
 [SocketIO](https://socket.io/) was chosen for performant event driven communication from the backend to the server. But we still use REST with [axum](https://docs.rs/axum/latest/axum/) for the communication thet benefits from the request/response model.
 
@@ -64,12 +67,12 @@ We could combine the code of the frontend and backend using [Doxius](https://dio
 | Machine Type | Version | Release Date | Description                 | Change to Previous Version                             | Vendor ID                  | Machine ID | Implemented | Docs                            |
 | ------------ | ------- | ------------ | --------------------------- | ------------------------------------------------------ | -------------------------- | ---------- | ----------- | ------------------------------- |
 | Winder       | V1      | ???          | Winding Filaments & Similar | -                                                      | 1 (Qitech Industries GmbH) | 1          | Reserved    | -                               |
-| Winder       | V2      | 2025         | Winding Filaments & Similar | Reengineered Traverse                                  | 1 (Qitech Industries GmbH) | 2          | In Progress | [](./docs/machines/winder-1.md) |
+| Winder       | V2      | 2025         | Winding Filaments & Similar | Reengineered Traverse                                  | 1 (Qitech Industries GmbH) | 2          | Yes         | [](./docs/machines/winder-1.md) |
 | Extruder     | V1      | ???          | Single Screw Extruder       | -                                                      | 1 (Qitech Industries GmbH) | 3          | Reserved    | -                               |
-| Extruder     | V2      | 2025         | Single Screw Extruder       | PT100 Thermometers, Optional Additional Heating Zone 4 | 1 (Qitech Industries GmbH) | 4          | Not Yet     |                                 |
-| Waterway     | V1      | 2025         | Filament Water Cooling      | -                                                      | 1 (Qitech Industries GmbH) | 5          | Not Yet     |                                 |
-| Laser        | V1      | ???          | Diameter Measuring Laser    | -                                                      | 1 (Qitech Industries GmbH) | 6          | Not Yet     |                                 |
-| Mock         | -       | ???          | Mock Machine for Testing    | -                                                      | 1 (Qitech Industries GmbH) | 7          | Not Yet     | -                               |
+| Extruder     | V2      | 2025         | Single Screw Extruder       | PT100 Thermometers, Optional Additional Heating Zone 4 | 1 (Qitech Industries GmbH) | 4          | Yes         |                                 |
+| Waterway     | V1      | 2025         | Filament Water Cooling      | -                                                      | 1 (Qitech Industries GmbH) | 5          | In Progress     |                                 |
+| Laser        | V1      | ???          | Diameter Measuring Laser    | -                                                      | 1 (Qitech Industries GmbH) | 6          | Yes         |                                 |
+| Mock         | -       | ???          | Mock Machine for Testing    | -                                                      | 1 (Qitech Industries GmbH) | 7          | Yes         | -                               |
 
 # More Docs
 

cargo_run_linux.sh

@@ -1,5 +1,7 @@
 #!/bin/bash
 
+set -e
+
 FEATURE=""
 
 # Check if "mock-machine" was passed as an argument
@@ -7,6 +9,7 @@ if [[ "$1" == "mock-machine" ]]; then
     echo "Building Debug Code with mock-machine feature"
     FEATURE="--features mock-machine"
 fi
+
 if [[ "$1" == "release" ]]; then
     echo "building Release Code"
     cargo build --release
@@ -18,8 +21,13 @@ fi
 # Only setcap if not building with mock-machine
 if [ "$1" != "mock-machine" ]; then
     echo "Setting capabilities for server executable"
-    sudo setcap 'cap_net_raw,cap_sys_nice=eip' ./target/debug/server
+    sudo setcap 'cap_dac_override,cap_net_raw,cap_sys_nice,cap_ipc_lock=eip' ./target/debug/server
+
+    if compgen -G "/dev/ttyUSB*" > /dev/null; then
+      echo "Setting permissions for serial ports"
+      sudo chown "root:$(groups | cut -f1 -d' ')" /dev/ttyUSB*
+    fi
 fi
+
 # run
 ./target/debug/server
-

compile_nix_pkgs.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+
+# Nix store uses sqlite ... SO HAHAHAHAHH NO CONCURRENT ACCESS AHAHAHHAHAHAHHAHAHAHAH
+time nix build .#packages.x86_64-linux.server --impure --extra-experimental-features nix-command --extra-experimental-features flakes --out-link /tmp/server-result
+serverstore=$(readlink -f /tmp/server-result) 
+
+time nix build .#packages.x86_64-linux.electron --impure --option sandbox false --extra-experimental-features nix-command --extra-experimental-features flakes --out-link /tmp/electron-result
+electronstore=$(readlink -f /tmp/electron-result)
+
+
+nix copy --to "file:///opt/dev-cache" \
+  $(readlink -f /tmp/server-result) \
+  $(readlink -f /tmp/electron-result) --extra-experimental-features nix-command
+
+nix store sign \
+  --key-file /opt/dev-cache/cache-private-key.pem \
+  --store "file:///opt/dev-cache" \
+  --extra-experimental-features nix-command \
+  "$serverstore" "$electronstore"
+
+
+nix path-info "$serverstore" --extra-experimental-features nix-command --extra-experimental-features flakes
+
+
+# nix verify --store "file:///opt/dev-cache" \
+#   --trusted-public-keys "$(cat /opt/dev-cache/cache-public-key.pem)" --extra-experimental-features nix-command --extra-experimental-features flakes \
+#   "$FIRST_PATH" || echo "Verification failed!" 
+
+
+#time nix build .#packages.x86_64-linux.electron --extra-experimental-features nix-command --extra-experimental-features flakes --out-link /tmp/electron-result
+#electronstore=$(readlink -f /tmp/electron-result)
+
+#nix-store --generate-binary-cache-key cache.key cache.pem --extra-experimental-features nix-command
+#nix store sign --key-file cache.key "$serverstore" --extra-experimental-features nix-command
+#nix path-info --json "$serverstore" --extra-experimental-features nix-command --extra-experimental-features flakes
+#export
+#nix-store --export /nix/store/<hash>-server > nix-cache/server.nar
+#nix-store --export /nix/store/<hash>-electron > nix-cache/electron.nar
+
+# Any http server
+# cd ~/nix-cache
+# python3 -m http.server 8080
+# 

control-core-derive/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "control_core_derive"
+version = "0.1.0"
+edition = "2024"
+
+[lints]
+workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = { version = "2.0", features = ["full"] }

control-core-derive/src/lib.rs

@@ -0,0 +1,65 @@
+use proc_macro::TokenStream;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use syn::{DeriveInput, Error};
+
+#[proc_macro_derive(BuildEvent)]
+pub fn build_event_derive(item: TokenStream) -> TokenStream {
+    build_event_derive2(item.into()).unwrap().into()
+}
+
+fn build_event_derive2(item: TokenStream2) -> Result<TokenStream2, Error> {
+    // Parse the input tokens into a syntax tree
+    let ast: DeriveInput = syn::parse2(item)?;
+
+    let ident = &ast.ident;
+    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
+
+    // Generate the BuildEvent impl
+    let expanded = quote! {
+        impl #impl_generics control_core::socketio::event::BuildEvent for #ident #ty_generics #where_clause {
+            #[doc = "Implemented by the BuildEvent derive macro"]
+            fn build(&self) -> control_core::socketio::event::Event<Self> {
+
+                control_core::socketio::event::Event::new(stringify!(#ident), self.clone())
+
+            }
+        }
+    };
+
+    Ok(expanded)
+}
+
+#[proc_macro_derive(Machine)]
+pub fn machine_derive(item: TokenStream) -> TokenStream {
+    machine_derive2(item.into()).unwrap().into()
+}
+
+fn machine_derive2(item: TokenStream2) -> Result<TokenStream2, Error> {
+    // Parse the input tokens into a syntax tree
+    let ast: DeriveInput = syn::parse2(item)?;
+
+    let ident = &ast.ident;
+
+    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
+
+    let expanded = quote! {
+        impl #impl_generics control_core::machines::Machine for #ident #ty_generics #where_clause {
+            fn get_machine_identification_unique(&self) -> control_core::machines::identification::MachineIdentificationUnique {
+                self.machine_identification_unique.clone()
+            }
+        }
+
+        impl #impl_generics control_core::machines::AnyGetters for #ident #ty_generics #where_clause {
+            fn as_any(&self) -> &dyn std::any::Any {
+                self
+            }
+
+            fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+                self
+            }
+        }
+    };
+
+    Ok(expanded)
+}

control-core/Cargo.toml

@@ -3,28 +3,45 @@ name = "control_core"
 version = "0.1.0"
 edition = "2024"
 
+[lints]
+workspace = true
+
 [dependencies]
-anyhow = "1.0.98"
-axum = "0.8.4"
+anyhow = "1.0.100"
+
+axum = "0.8.6"
+
 ethercat_hal = { path = "../ethercat-hal" }
 ethercrab = "0.6"
 interfaces = "0.0.9"
 serde = "1.0.219"
-serde_json = "1.0.140"
-serialport = "4.7.2"
+serde_json = "1.0.143"
+serialport = "4.7.3"
 smol = "2.0.2"
 socketioxide = "0.17.2"
-uom = "0.36.0"
+uom = { version = "0.36.0", default-features = false, features = ["f64"] }
 bitvec = { version = "1.0.1", features = ["alloc"] }
 crc = "3.3.0"
 serial = "0.4.0"
 tracing = "0.1.41"
-erased-serde = "0.4.6"
+erased-serde = "0.4.8"
 core_affinity = "0.8.3"
+control_core_derive = { version = "0.1.0", path = "../control-core-derive" }
+tokio = { version = "1.45.1", features = ["sync"], optional = true }
+
 
 [target.'cfg(unix)'.dependencies]
-libc = "0.2.175"
+libc = "0.2.176"
 
 [dev-dependencies]
 approx = "0.5.1"
 textplots = "0.8"
+tokio = { version = "1.45.1", features = ["rt-multi-thread", "macros", "time"] }
+
+
+[features]
+default = []
+video-streaming = ["dep:tokio"]
+
+[package.metadata.cargo-machete]
+ignored =  ["axum","bitvec","control_core_derive"]

control-core/src/controllers/clamping_timeagnostic_pid.rs

@@ -33,7 +33,7 @@ pub struct ClampingTimeagnosticPidController {
 }
 
 impl ClampingTimeagnosticPidController {
-    pub fn new(
+    pub const fn new(
         kp: f64,
         ki: f64,
         kd: f64,
@@ -65,7 +65,7 @@ impl ClampingTimeagnosticPidController {
         }
     }
 
-    pub fn simple_new(kp: f64, ki: f64, kd: f64) -> Self {
+    pub const fn simple_new(kp: f64, ki: f64, kd: f64) -> Self {
         Self {
             kp,
             ki,
@@ -85,26 +85,26 @@ impl ClampingTimeagnosticPidController {
         }
     }
 
-    pub fn get_kp(&self) -> f64 {
+    pub const fn get_kp(&self) -> f64 {
         self.kp
     }
 
-    pub fn get_ki(&self) -> f64 {
+    pub const fn get_ki(&self) -> f64 {
         self.ki
     }
 
-    pub fn get_kd(&self) -> f64 {
+    pub const fn get_kd(&self) -> f64 {
         self.kd
     }
 
-    pub fn configure(&mut self, ki: f64, kp: f64, kd: f64) {
+    pub const fn configure(&mut self, ki: f64, kp: f64, kd: f64) {
         self.reset();
         self.kp = kp;
         self.ki = ki;
         self.kd = kd;
     }
 
-    pub fn optional_clamp(value: f64, min: Option<f64>, max: Option<f64>) -> f64 {
+    pub const fn optional_clamp(value: f64, min: Option<f64>, max: Option<f64>) -> f64 {
         match (min, max) {
             (Some(min), Some(max)) => value.clamp(min, max),
             (Some(min), None) => value.max(min),
@@ -114,7 +114,7 @@ impl ClampingTimeagnosticPidController {
     }
 
     pub fn update(&mut self, error: f64, t: Instant) -> f64 {
-        let signal = match self.last {
+        match self.last {
             // First update
             None => {
                 // Calculate error
@@ -122,15 +122,10 @@ impl ClampingTimeagnosticPidController {
 
                 // Calculate signal
                 let signal = self.kp * ep;
-                let clamped_signal = ClampingTimeagnosticPidController::optional_clamp(
-                    signal,
-                    self.min_signal,
-                    self.max_signal,
-                );
+                let clamped_signal = Self::optional_clamp(signal, self.min_signal, self.max_signal);
 
                 // Set values
-                self.ep =
-                    ClampingTimeagnosticPidController::optional_clamp(ep, self.min_ep, self.max_ep);
+                self.ep = Self::optional_clamp(ep, self.min_ep, self.max_ep);
                 self.ei = 0.0;
                 self.ed = 0.0;
                 self.last = Some(t);
@@ -143,23 +138,11 @@ impl ClampingTimeagnosticPidController {
                 let dt = t.duration_since(last).as_secs_f64();
 
                 // Calculate errors
-                let ep = ClampingTimeagnosticPidController::optional_clamp(
-                    error,
-                    self.min_ep,
-                    self.max_ep,
-                );
+                let ep = Self::optional_clamp(error, self.min_ep, self.max_ep);
 
-                let ei = ClampingTimeagnosticPidController::optional_clamp(
-                    self.ei + ep * dt,
-                    self.min_ei,
-                    self.max_ei,
-                );
+                let ei = Self::optional_clamp(ep.mul_add(dt, self.ei), self.min_ei, self.max_ei);
 
-                let ed = ClampingTimeagnosticPidController::optional_clamp(
-                    (ep - self.ep) / dt,
-                    self.min_ed,
-                    self.max_ed,
-                );
+                let ed = Self::optional_clamp((ep - self.ep) / dt, self.min_ed, self.max_ed);
 
                 // Make factors timeagnostic
                 let kp = self.kp * dt;
@@ -167,12 +150,8 @@ impl ClampingTimeagnosticPidController {
                 let kd = self.kd * dt;
 
                 // Calculate signal
-                let signal = kp * ep + ki * ei + kd * ed;
-                let clamped_signal = ClampingTimeagnosticPidController::optional_clamp(
-                    signal,
-                    self.min_signal,
-                    self.max_signal,
-                );
+                let signal = kd.mul_add(ed, kp.mul_add(ep, ki * ei));
+                let clamped_signal = Self::optional_clamp(signal, self.min_signal, self.max_signal);
 
                 // Set values
                 self.ep = ep;
@@ -182,12 +161,10 @@ impl ClampingTimeagnosticPidController {
 
                 clamped_signal
             }
-        };
-
-        signal
+        }
     }
 
-    pub fn reset(&mut self) {
+    pub const fn reset(&mut self) {
         self.ep = 0.0;
         self.ei = 0.0;
         self.ed = 0.0;

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

@@ -22,7 +22,7 @@ pub struct AccelerationSpeedController {
 }
 
 impl AccelerationSpeedController {
-    pub fn new(
+    pub const fn new(
         min_speed: Option<f64>,
         max_speed: Option<f64>,
         min_acceleration: f64,
@@ -98,16 +98,16 @@ impl AccelerationSpeedController {
         new_speed
     }
 
-    pub fn reset(&mut self, initial_speed: f64) {
+    pub const fn reset(&mut self, initial_speed: f64) {
         self.last_speed = initial_speed;
         self.last_t = None; // Reset the last update time
     }
 
-    pub fn set_max_acceleration(&mut self, acceleration: f64) {
+    pub const fn set_max_acceleration(&mut self, acceleration: f64) {
         self.max_acceleration = acceleration;
     }
 
-    fn apply_speed_limits(&self, speed: f64) -> f64 {
+    const fn apply_speed_limits(&self, speed: f64) -> f64 {
         let mut limited_speed = speed;
 
         if let Some(min) = self.min_speed {
@@ -121,23 +121,23 @@ impl AccelerationSpeedController {
         limited_speed
     }
 
-    pub fn get_min_speed(&self) -> Option<f64> {
+    pub const fn get_min_speed(&self) -> Option<f64> {
         self.min_speed
     }
 
-    pub fn get_max_speed(&self) -> Option<f64> {
+    pub const fn get_max_speed(&self) -> Option<f64> {
         self.max_speed
     }
 
-    pub fn set_min_speed(&mut self, min_speed: Option<f64>) {
+    pub const fn set_min_speed(&mut self, min_speed: Option<f64>) {
         self.min_speed = min_speed;
     }
 
-    pub fn set_max_speed(&mut self, max_speed: Option<f64>) {
+    pub const fn set_max_speed(&mut self, max_speed: Option<f64>) {
         self.max_speed = max_speed;
     }
 
-    pub fn set_min_acceleration(&mut self, deceleration: f64) {
+    pub const fn set_min_acceleration(&mut self, deceleration: f64) {
         self.min_acceleration = deceleration;
     }
 }

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

@@ -53,7 +53,7 @@ impl AngularAccelerationSpeedController {
     pub fn update(&mut self, target_speed: AngularVelocity, t: Instant) -> AngularVelocity {
         let target_speed = target_speed.get::<radian_per_second>();
         let new_speed = self.controller.update(target_speed, t);
-        return AngularVelocity::new::<radian_per_second>(new_speed);
+        AngularVelocity::new::<radian_per_second>(new_speed)
     }
 
     pub fn reset(&mut self, initial_speed: AngularVelocity) {
@@ -73,13 +73,13 @@ impl AngularAccelerationSpeedController {
     pub fn get_min_speed(&self) -> Option<AngularVelocity> {
         self.controller
             .get_min_speed()
-            .map(|s| AngularVelocity::new::<radian_per_second>(s))
+            .map(AngularVelocity::new::<radian_per_second>)
     }
 
     pub fn get_max_speed(&self) -> Option<AngularVelocity> {
         self.controller
             .get_max_speed()
-            .map(|s| AngularVelocity::new::<radian_per_second>(s))
+            .map(AngularVelocity::new::<radian_per_second>)
     }
 
     pub fn set_min_speed(&mut self, min_speed: Option<AngularVelocity>) {

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

@@ -48,7 +48,7 @@ impl LinearAccelerationLimitingController {
     pub fn update(&mut self, target_speed: Velocity, t: Instant) -> Velocity {
         let target_speed = target_speed.get::<meter_per_second>();
         let new_speed = self.controller.update(target_speed, t);
-        return Velocity::new::<meter_per_second>(new_speed);
+        Velocity::new::<meter_per_second>(new_speed)
     }
     pub fn reset(&mut self, initial_speed: Velocity) {
         let initial_speed = initial_speed.get::<meter_per_second>();
@@ -65,12 +65,12 @@ impl LinearAccelerationLimitingController {
     pub fn get_min_speed(&self) -> Option<Velocity> {
         self.controller
             .get_min_speed()
-            .map(|s| Velocity::new::<meter_per_second>(s))
+            .map(Velocity::new::<meter_per_second>)
     }
     pub fn get_max_speed(&self) -> Option<Velocity> {
         self.controller
             .get_max_speed()
-            .map(|s| Velocity::new::<meter_per_second>(s))
+            .map(Velocity::new::<meter_per_second>)
     }
     pub fn set_min_speed(&mut self, min_speed: Option<Velocity>) {
         self.controller

control-core/src/controllers/pid.rs

@@ -21,7 +21,7 @@ pub struct PidController {
 }
 
 impl PidController {
-    pub fn new(kp: f64, ki: f64, kd: f64) -> Self {
+    pub const fn new(kp: f64, ki: f64, kd: f64) -> Self {
         Self {
             kp,
             ki,
@@ -33,27 +33,27 @@ impl PidController {
         }
     }
 
-    pub fn configure(&mut self, ki: f64, kp: f64, kd: f64) {
+    pub const fn configure(&mut self, ki: f64, kp: f64, kd: f64) {
         self.reset();
         self.kp = kp;
         self.ki = ki;
         self.kd = kd;
     }
 
-    pub fn get_kp(&self) -> f64 {
+    pub const fn get_kp(&self) -> f64 {
         self.kp
     }
 
-    pub fn get_ki(&self) -> f64 {
+    pub const fn get_ki(&self) -> f64 {
         self.ki
     }
 
-    pub fn get_kd(&self) -> f64 {
+    pub const fn get_kd(&self) -> f64 {
         self.kd
     }
 
     pub fn update(&mut self, error: f64, t: Instant) -> f64 {
-        let signal = match self.last {
+        match self.last {
             // First update
             None => {
                 // Calculate error
@@ -78,11 +78,11 @@ impl PidController {
 
                 // Calculate errors
                 let ep = error;
-                let ei = self.ei + ep * dt;
+                let ei = ep.mul_add(dt, self.ei);
                 let ed = (ep - self.ep) / dt;
 
                 // Calculate signal
-                let signal = self.kp * ep + self.ki * ei + self.kd * ed;
+                let signal = self.kd.mul_add(ed, self.kp.mul_add(ep, self.ki * ei));
 
                 // Set values
                 self.ep = ep;
@@ -92,12 +92,10 @@ impl PidController {
 
                 signal
             }
-        };
-
-        signal
+        }
     }
 
-    pub fn reset(&mut self) {
+    pub const fn reset(&mut self) {
         self.ep = 0.0;
         self.ei = 0.0;
         self.ed = 0.0;

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

@@ -3,7 +3,7 @@ use std::fmt;
 // Remove the anyhow::Ok import as it conflicts with std::result::Ok
 
 /// Errors that can occur when creating or using the motion controller
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum MotionControllerError {
     InvalidSpeedLimits,
     InvalidAccelerationLimits,
@@ -14,25 +14,25 @@ pub enum MotionControllerError {
 impl fmt::Display for MotionControllerError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            MotionControllerError::InvalidSpeedLimits => {
+            Self::InvalidSpeedLimits => {
                 write!(
                     f,
                     "Invalid speed limits: min_speed must be ≤ 0 and max_speed must be ≥ 0"
                 )
             }
-            MotionControllerError::InvalidAccelerationLimits => {
+            Self::InvalidAccelerationLimits => {
                 write!(
                     f,
                     "Invalid acceleration limits: min_acceleration must be < 0 and max_acceleration must be > 0"
                 )
             }
-            MotionControllerError::InvalidPositionLimits => {
+            Self::InvalidPositionLimits => {
                 write!(
                     f,
                     "Invalid position limits: min_position must be ≤ max_position"
                 )
             }
-            MotionControllerError::ZeroDeceleration => {
+            Self::ZeroDeceleration => {
                 write!(
                     f,
                     "Zero deceleration rate: cannot plan motion without deceleration capability"
@@ -148,7 +148,7 @@ struct MotionConstants {
 }
 
 /// Represents the current phase of motion
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum MotionPhase {
     Idle,
     IncreasingSpeed,
@@ -170,7 +170,7 @@ pub struct ControllerBuilder {
 
 impl ControllerBuilder {
     /// Create a new builder
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self {
             min_speed: None,
             max_speed: None,
@@ -184,28 +184,36 @@ impl ControllerBuilder {
     }
 
     /// Set speed limits (min_speed ≤ 0, max_speed ≥ 0)
-    pub fn speed_limits(mut self, min_speed: f64, max_speed: f64) -> Self {
+    pub const fn speed_limits(mut self, min_speed: f64, max_speed: f64) -> Self {
         self.min_speed = Some(min_speed);
         self.max_speed = Some(max_speed);
         self
     }
 
     /// Set acceleration limits (min_acceleration < 0, max_acceleration > 0)
-    pub fn acceleration_limits(mut self, min_acceleration: f64, max_acceleration: f64) -> Self {
+    pub const fn acceleration_limits(
+        mut self,
+        min_acceleration: f64,
+        max_acceleration: f64,
+    ) -> Self {
         self.min_acceleration = Some(min_acceleration);
         self.max_acceleration = Some(max_acceleration);
         self
     }
 
     /// Set position limits (optional)
-    pub fn position_limits(mut self, min_position: Option<f64>, max_position: Option<f64>) -> Self {
+    pub const fn position_limits(
+        mut self,
+        min_position: Option<f64>,
+        max_position: Option<f64>,
+    ) -> Self {
         self.min_position = min_position;
         self.max_position = max_position;
         self
     }
 
     /// Set tolerances for position and speed comparisons
-    pub fn tolerances(mut self, position_tolerance: f64, speed_tolerance: f64) -> Self {
+    pub const fn tolerances(mut self, position_tolerance: f64, speed_tolerance: f64) -> Self {
         self.position_tolerance = position_tolerance;
         self.speed_tolerance = speed_tolerance;
         self
@@ -322,7 +330,7 @@ impl AccelerationPositionController {
 
         let motion_constants = Self::calculate_motion_constants(&config);
 
-        Ok(AccelerationPositionController {
+        Ok(Self {
             config,
             current_position: 0.0,
             current_speed: 0.0,
@@ -366,19 +374,19 @@ impl AccelerationPositionController {
         }
 
         Self::new(
-            -speed,               // min_speed
-            speed,                // max_speed
-            -acceleration,        // min_acceleration
-            acceleration,         // max_acceleration
-            position.map(|p| -p), // min_position
-            position.map(|p| p),  // max_position
-            1e-6,                 // position_tolerance (default)
-            1e-6,                 // speed_tolerance (default)
+            -speed,                     // min_speed
+            speed,                      // max_speed
+            -acceleration,              // min_acceleration
+            acceleration,               // max_acceleration
+            position.map(|p| -p.abs()), // min_position
+            position.map(|p| p.abs()),  // max_position
+            1e-6,                       // position_tolerance (default)
+            1e-6,                       // speed_tolerance (default)
         )
     }
 
     /// Create a new builder for the controller
-    pub fn builder() -> ControllerBuilder {
+    pub const fn builder() -> ControllerBuilder {
         ControllerBuilder::new()
     }
 
@@ -564,8 +572,10 @@ impl AccelerationPositionController {
 
         // Calculate distance needed to reach cruise speed from current speed
         let speed_change_distance = if current_speed_in_direction < cruise_speed.abs() {
-            (cruise_speed.abs().powi(2) - current_speed_in_direction.max(0.0).powi(2))
-                / (2.0 * acceleration_rate)
+            current_speed_in_direction.max(0.0).mul_add(
+                -current_speed_in_direction.max(0.0),
+                cruise_speed.abs().powi(2),
+            ) / (2.0 * acceleration_rate)
         } else {
             0.0
         };
@@ -579,8 +589,10 @@ impl AccelerationPositionController {
             // Using corrected kinematic equation: v_peak² = v_current² + 2*a*d_total*a_accel*a_decel/(a_accel + a_decel)
             let accel_decel_factor =
                 (acceleration_rate * deceleration_rate) / (acceleration_rate + deceleration_rate);
-            let discriminant = current_speed_in_direction.max(0.0).powi(2)
-                + 2.0 * abs_position_change * accel_decel_factor;
+            let discriminant = current_speed_in_direction.max(0.0).mul_add(
+                current_speed_in_direction.max(0.0),
+                2.0 * abs_position_change * accel_decel_factor,
+            );
 
             if discriminant >= 0.0 {
                 self.peak_speed = discriminant.sqrt() * cruise_speed.signum();
@@ -634,7 +646,7 @@ impl AccelerationPositionController {
                 self.current_acceleration = self.config.max_acceleration * self.direction as f64;
 
                 // Update speed
-                let new_speed = self.current_speed + self.current_acceleration * dt;
+                let new_speed = self.current_acceleration.mul_add(dt, self.current_speed);
 
                 // Check if we've reached peak speed
                 if (self.direction > 0 && new_speed >= self.peak_speed)
@@ -665,7 +677,7 @@ impl AccelerationPositionController {
                 self.current_acceleration = self.config.min_acceleration * self.direction as f64;
 
                 // Update speed
-                let new_speed = self.current_speed + self.current_acceleration * dt;
+                let new_speed = self.current_acceleration.mul_add(dt, self.current_speed);
 
                 // Check if we've reached zero speed or target
                 if (self.current_speed > 0.0 && new_speed <= 0.0)
@@ -689,7 +701,7 @@ impl AccelerationPositionController {
         }
 
         // Update position based on current speed
-        let new_position = self.current_position + self.current_speed * dt;
+        let new_position = self.current_speed.mul_add(dt, self.current_position);
 
         // Check position limits and handle violations
         let mut position_limited = false;
@@ -742,7 +754,7 @@ impl AccelerationPositionController {
     ///
     /// Returns the current position of the controlled object.
     /// This value is updated with each call to `update()`.
-    pub fn get_position(&self) -> f64 {
+    pub const fn get_position(&self) -> f64 {
         self.current_position
     }
 
@@ -751,7 +763,7 @@ impl AccelerationPositionController {
     /// Returns the current speed (velocity) of the controlled object.
     /// Positive values indicate motion towards increasing position,
     /// negative values indicate motion towards decreasing position.
-    pub fn get_speed(&self) -> f64 {
+    pub const fn get_speed(&self) -> f64 {
         self.current_speed
     }
 
@@ -759,32 +771,32 @@ impl AccelerationPositionController {
     ///
     /// Returns the current acceleration of the controlled object.
     /// Positive values indicate increasing speed, negative values indicate decreasing speed.
-    pub fn get_acceleration(&self) -> f64 {
+    pub const fn get_acceleration(&self) -> f64 {
         self.current_acceleration
     }
 
     /// Get the target position
-    pub fn get_target_position(&self) -> f64 {
+    pub const fn get_target_position(&self) -> f64 {
         self.target_position
     }
 
     /// Get the current motion phase
-    pub fn get_motion_phase(&self) -> MotionPhase {
+    pub const fn get_motion_phase(&self) -> MotionPhase {
         self.motion_phase
     }
 
     /// Get the direction of motion
-    pub fn get_direction(&self) -> i8 {
+    pub const fn get_direction(&self) -> i8 {
         self.direction
     }
 
     /// Get the calculated peak speed for current motion
-    pub fn get_peak_speed(&self) -> f64 {
+    pub const fn get_peak_speed(&self) -> f64 {
         self.peak_speed
     }
 
     /// Get the position at which deceleration will begin
-    pub fn get_deceleration_position(&self) -> f64 {
+    pub const fn get_deceleration_position(&self) -> f64 {
         self.deceleration_position
     }
 
@@ -837,7 +849,7 @@ impl AccelerationPositionController {
     }
 
     /// Force the controller to stop at current position
-    pub fn emergency_stop(&mut self) {
+    pub const fn emergency_stop(&mut self) {
         self.target_position = self.current_position;
         self.current_speed = 0.0;
         self.current_acceleration = 0.0;
@@ -1006,32 +1018,32 @@ impl AccelerationPositionController {
     }
 
     /// Get the minimum speed limit
-    pub fn get_min_speed(&self) -> f64 {
+    pub const fn get_min_speed(&self) -> f64 {
         self.config.min_speed
     }
 
     /// Get the maximum speed limit
-    pub fn get_max_speed(&self) -> f64 {
+    pub const fn get_max_speed(&self) -> f64 {
         self.config.max_speed
     }
 
     /// Get the minimum acceleration limit
-    pub fn get_min_acceleration(&self) -> f64 {
+    pub const fn get_min_acceleration(&self) -> f64 {
         self.config.min_acceleration
     }
 
     /// Get the maximum acceleration limit
-    pub fn get_max_acceleration(&self) -> f64 {
+    pub const fn get_max_acceleration(&self) -> f64 {
         self.config.max_acceleration
     }
 
     /// Get the minimum position limit
-    pub fn get_min_position(&self) -> Option<f64> {
+    pub const fn get_min_position(&self) -> Option<f64> {
         self.config.min_position
     }
 
     /// Get the maximum position limit
-    pub fn get_max_position(&self) -> Option<f64> {
+    pub const fn get_max_position(&self) -> Option<f64> {
         self.config.max_position
     }
 
@@ -1068,17 +1080,17 @@ impl AccelerationPositionController {
     }
 
     /// Get the position tolerance
-    pub fn get_position_tolerance(&self) -> f64 {
+    pub const fn get_position_tolerance(&self) -> f64 {
         self.config.position_tolerance
     }
 
     /// Get the speed tolerance
-    pub fn get_speed_tolerance(&self) -> f64 {
+    pub const fn get_speed_tolerance(&self) -> f64 {
         self.config.speed_tolerance
     }
 
     /// Set tolerances for position and speed comparisons
-    pub fn set_tolerances(&mut self, position_tolerance: f64, speed_tolerance: f64) {
+    pub const fn set_tolerances(&mut self, position_tolerance: f64, speed_tolerance: f64) {
         self.config.position_tolerance = position_tolerance;
         self.config.speed_tolerance = speed_tolerance;
     }

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

@@ -102,16 +102,12 @@ impl AngularAccelerationPositionController {
 
     /// Get the minimum angle position limit
     pub fn get_min_position(&self) -> Option<Angle> {
-        self.controller
-            .get_min_position()
-            .map(|angle| Angle::new::<radian>(angle))
+        self.controller.get_min_position().map(Angle::new::<radian>)
     }
 
     /// Get the maximum angle position limit
     pub fn get_max_position(&self) -> Option<Angle> {
-        self.controller
-            .get_max_position()
-            .map(|angle| Angle::new::<radian>(angle))
+        self.controller.get_max_position().map(Angle::new::<radian>)
     }
 
     /// Set the minimum angle position limit

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

@@ -236,7 +236,7 @@ impl AngularJerkSpeedController {
     pub fn get_min_speed(&self) -> Option<AngularVelocity> {
         self.controller
             .get_min_speed()
-            .map(|speed| AngularVelocity::new::<radian_per_second>(speed))
+            .map(AngularVelocity::new::<radian_per_second>)
     }
 
     /// Get the maximum angular velocity limit
@@ -248,7 +248,7 @@ impl AngularJerkSpeedController {
     pub fn get_max_speed(&self) -> Option<AngularVelocity> {
         self.controller
             .get_max_speed()
-            .map(|speed| AngularVelocity::new::<radian_per_second>(speed))
+            .map(AngularVelocity::new::<radian_per_second>)
     }
 
     /// Set the minimum angular velocity limit

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

@@ -88,7 +88,7 @@ impl JerkSpeedController {
         )
         .expect("Failed to create AccelerationPositionController");
 
-        JerkSpeedController { base_controller }
+        Self { base_controller }
     }
 
     /// Create a new speed controller with simple symmetric limits
@@ -183,7 +183,7 @@ impl JerkSpeedController {
     ///
     /// # Returns
     /// Current speed as a floating-point value
-    pub fn get_speed(&self) -> f64 {
+    pub const fn get_speed(&self) -> f64 {
         self.base_controller.get_position()
     }
 
@@ -193,7 +193,7 @@ impl JerkSpeedController {
     ///
     /// # Returns
     /// Current acceleration as a floating-point value
-    pub fn get_acceleration(&self) -> f64 {
+    pub const fn get_acceleration(&self) -> f64 {
         self.base_controller.get_speed()
     }
 
@@ -203,7 +203,7 @@ impl JerkSpeedController {
     ///
     /// # Returns
     /// Current jerk as a floating-point value
-    pub fn get_jerk(&self) -> f64 {
+    pub const fn get_jerk(&self) -> f64 {
         self.base_controller.get_acceleration()
     }
 
@@ -213,7 +213,7 @@ impl JerkSpeedController {
     ///
     /// # Returns
     /// Target speed as a floating-point value
-    pub fn get_target_speed(&self) -> f64 {
+    pub const fn get_target_speed(&self) -> f64 {
         self.base_controller.get_target_position()
     }
 
@@ -223,7 +223,7 @@ impl JerkSpeedController {
     ///
     /// # Returns
     /// Minimum speed limit as an Option<f64>, None if no limit is set
-    pub fn get_min_speed(&self) -> Option<f64> {
+    pub const fn get_min_speed(&self) -> Option<f64> {
         self.base_controller.get_min_position()
     }
 
@@ -233,7 +233,7 @@ impl JerkSpeedController {
     ///
     /// # Returns
     /// Maximum speed limit as an Option<f64>, None if no limit is set
-    pub fn get_max_speed(&self) -> Option<f64> {
+    pub const fn get_max_speed(&self) -> Option<f64> {
         self.base_controller.get_max_position()
     }
 

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

@@ -205,9 +205,7 @@ impl LinearAccelerationPositionController {
     /// # Returns
     /// Minimum position limit as an Option<Length>, None if no limit is set
     pub fn get_min_position(&self) -> Option<Length> {
-        self.controller
-            .get_min_position()
-            .map(|length| Length::new::<meter>(length))
+        self.controller.get_min_position().map(Length::new::<meter>)
     }
 
     /// Get the maximum position limit
@@ -217,9 +215,7 @@ impl LinearAccelerationPositionController {
     /// # Returns  
     /// Maximum position limit as an Option<Length>, None if no limit is set
     pub fn get_max_position(&self) -> Option<Length> {
-        self.controller
-            .get_max_position()
-            .map(|length| Length::new::<meter>(length))
+        self.controller.get_max_position().map(Length::new::<meter>)
     }
 
     /// Set the minimum position limit

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

@@ -195,14 +195,14 @@ impl LinearJerkSpeedController {
     pub fn get_min_speed(&self) -> Option<Velocity> {
         self.controller
             .get_min_speed()
-            .map(|speed| Velocity::new::<meter_per_second>(speed))
+            .map(Velocity::new::<meter_per_second>)
     }
 
     /// Get the maximum velocity limit
     pub fn get_max_speed(&self) -> Option<Velocity> {
         self.controller
             .get_max_speed()
-            .map(|speed| Velocity::new::<meter_per_second>(speed))
+            .map(Velocity::new::<meter_per_second>)
     }
 
     /// Set the minimum velocity limit

control-core/src/converters/angle_converter.rs

@@ -1,8 +1,6 @@
-use std::f32::consts::PI;
+use uom::si::{angle::radian, f64::Angle};
 
-use uom::si::angle::radian;
-
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct AngleConverter {
     pub flip_x: bool, // true to flip X-axis (mirror horizontally)
     pub flip_y: bool, // true to flip Y-axis (mirror vertically)
@@ -11,7 +9,7 @@ pub struct AngleConverter {
 
 impl AngleConverter {
     /// Create a custom coordinate system
-    pub fn new(flip_x: bool, flip_y: bool, is_cw: bool) -> Self {
+    pub const fn new(flip_x: bool, flip_y: bool, is_cw: bool) -> Self {
         Self {
             flip_x,
             flip_y,
@@ -20,52 +18,52 @@ impl AngleConverter {
     }
 
     /// Standard mathematical coordinate system (CCW positive, 0° at positive X)
-    pub fn mathematical() -> Self {
+    pub const fn mathematical() -> Self {
         Self::new(false, false, false)
     }
 
     /// Screen/graphics coordinate system (CW positive, 0° at positive X, Y-flipped)
-    pub fn screen() -> Self {
+    pub const fn screen() -> Self {
         Self::new(false, true, false)
     }
 
     /// System where 0° points up, clockwise positive
-    pub fn y_up_cw() -> Self {
+    pub const fn y_up_cw() -> Self {
         Self::new(false, false, true)
     }
 
     /// System where 0° points down, counter-clockwise positive
-    pub fn y_down_ccw() -> Self {
+    pub const fn y_down_ccw() -> Self {
         Self::new(false, true, true)
     }
 
     /// System where 0° points left, clockwise positive
-    pub fn x_left_cw() -> Self {
+    pub const fn x_left_cw() -> Self {
         Self::new(true, false, false)
     }
 
     /// System where 0° points right, counter-clockwise positive (same as mathematical)
-    pub fn x_right_ccw() -> Self {
+    pub const fn x_right_ccw() -> Self {
         Self::mathematical()
     }
 
     /// System where 0° points up, counter-clockwise positive
-    pub fn y_up_ccw() -> Self {
+    pub const fn y_up_ccw() -> Self {
         Self::new(false, false, false)
     }
 
     /// System where 0° points down, clockwise positive
-    pub fn y_down_cw() -> Self {
+    pub const fn y_down_cw() -> Self {
         Self::new(false, true, false)
     }
 
     /// System where 0° points left, counter-clockwise positive
-    pub fn x_left_ccw() -> Self {
+    pub const fn x_left_ccw() -> Self {
         Self::new(true, false, true)
     }
 
     /// Convert angle from mathematical system to this system (f32)
-    pub fn degrees_encode(&self, math_angle_degrees: f32) -> f32 {
+    pub fn degrees_encode(&self, math_angle_degrees: f64) -> f64 {
         let normalized_input = self.normalize_angle(math_angle_degrees);
 
         let mut result = normalized_input;
@@ -75,7 +73,7 @@ impl AngleConverter {
             (false, false) => {}                      // No change
             (true, false) => result = 180.0 - result, // X-flip: mirror across Y-axis
             (false, true) => result = -result,        // Y-flip: mirror across X-axis
-            (true, true) => result = 180.0 + result,  // Both flips: 180° rotation
+            (true, true) => result += 180.0,          // Both flips: 180° rotation
         }
 
         // Handle rotation direction
@@ -87,7 +85,7 @@ impl AngleConverter {
     }
 
     /// Convert angle from this system to mathematical system (f32)
-    pub fn degrees_decode(&self, system_angle_degrees: f32) -> f32 {
+    pub fn degrees_decode(&self, system_angle_degrees: f64) -> f64 {
         let normalized_input = self.normalize_angle(system_angle_degrees);
 
         let mut result = normalized_input;
@@ -102,24 +100,24 @@ impl AngleConverter {
             (false, false) => {}                      // No change
             (true, false) => result = 180.0 - result, // X-flip: mirror across Y-axis
             (false, true) => result = -result,        // Y-flip: mirror across X-axis
-            (true, true) => result = result - 180.0,  // Both flips: inverse 180° rotation
+            (true, true) => result -= 180.0,          // Both flips: inverse 180° rotation
         }
 
         self.normalize_angle(result)
     }
 
     /// Convert angle in radians from mathematical system to this system (f32)
-    pub fn radians_encode(&self, math_angle_radians: f32) -> f32 {
-        let degrees = math_angle_radians * 180.0 / PI;
+    pub fn radians_encode(&self, math_angle_radians: f64) -> f64 {
+        let degrees = math_angle_radians.to_degrees();
         let converted_degrees = self.degrees_encode(degrees);
-        converted_degrees * PI / 180.0
+        converted_degrees.to_radians()
     }
 
     /// Convert angle in radians from this system to mathematical system (f32)
-    pub fn radians_decode(&self, system_angle_radians: f32) -> f32 {
-        let degrees = system_angle_radians * 180.0 / PI;
+    pub fn radians_decode(&self, system_angle_radians: f64) -> f64 {
+        let degrees = system_angle_radians.to_degrees();
         let converted_degrees = self.degrees_decode(degrees);
-        converted_degrees * PI / 180.0
+        converted_degrees.to_radians()
     }
 
     /// Convert angle from mathematical system to this system (f64)
@@ -133,7 +131,7 @@ impl AngleConverter {
             (false, false) => {}                      // No change
             (true, false) => result = 180.0 - result, // X-flip: mirror across Y-axis
             (false, true) => result = -result,        // Y-flip: mirror across X-axis
-            (true, true) => result = 180.0 + result,  // Both flips: 180° rotation
+            (true, true) => result += 180.0,          // Both flips: 180° rotation
         }
 
         // Handle rotation direction
@@ -160,7 +158,7 @@ impl AngleConverter {
             (false, false) => {}                      // No change
             (true, false) => result = 180.0 - result, // X-flip: mirror across Y-axis
             (false, true) => result = -result,        // Y-flip: mirror across X-axis
-            (true, true) => result = result - 180.0,  // Both flips: inverse 180° rotation
+            (true, true) => result -= 180.0,          // Both flips: inverse 180° rotation
         }
 
         self.normalize_angle_f64(result)
@@ -168,20 +166,20 @@ impl AngleConverter {
 
     /// Convert angle in radians from mathematical system to this system (f64)
     pub fn radians_encode_f64(&self, math_angle_radians: f64) -> f64 {
-        let degrees = math_angle_radians * 180.0 / std::f64::consts::PI;
+        let degrees = math_angle_radians.to_degrees();
         let converted_degrees = self.degrees_encode_f64(degrees);
-        converted_degrees * std::f64::consts::PI / 180.0
+        converted_degrees.to_radians()
     }
 
     /// Convert angle in radians from this system to mathematical system (f64)
     pub fn radians_decode_f64(&self, system_angle_radians: f64) -> f64 {
-        let degrees = system_angle_radians * 180.0 / std::f64::consts::PI;
+        let degrees = system_angle_radians.to_degrees();
         let converted_degrees = self.degrees_decode_f64(degrees);
-        converted_degrees * std::f64::consts::PI / 180.0
+        converted_degrees.to_radians()
     }
 
     /// Normalize angle to [0, 360) range (f32)
-    fn normalize_angle(&self, angle: f32) -> f32 {
+    fn normalize_angle(&self, angle: f64) -> f64 {
         let mut normalized = angle % 360.0;
         if normalized < 0.0 {
             normalized += 360.0;
@@ -205,39 +203,23 @@ pub struct AngleConverterUom {
 }
 
 impl AngleConverterUom {
-    pub fn new(angle_converter: AngleConverter) -> Self {
+    pub const fn new(angle_converter: AngleConverter) -> Self {
         Self { angle_converter }
     }
 
-    pub fn encode(&self, angle: uom::si::f32::Angle) -> uom::si::f32::Angle {
-        uom::si::f32::Angle::new::<radian>(
-            self.angle_converter.radians_encode(angle.get::<radian>()),
-        )
+    pub fn encode(&self, angle: Angle) -> Angle {
+        Angle::new::<radian>(self.angle_converter.radians_encode(angle.get::<radian>()))
     }
 
-    pub fn decode(&self, angle: uom::si::f32::Angle) -> uom::si::f32::Angle {
-        uom::si::f32::Angle::new::<radian>(
-            self.angle_converter.radians_decode(angle.get::<radian>()),
-        )
-    }
-
-    pub fn encode_f64(&self, angle: uom::si::f64::Angle) -> uom::si::f64::Angle {
-        uom::si::f64::Angle::new::<radian>(
-            self.angle_converter
-                .radians_encode_f64(angle.get::<radian>()),
-        )
-    }
-
-    pub fn decode_f64(&self, angle: uom::si::f64::Angle) -> uom::si::f64::Angle {
-        uom::si::f64::Angle::new::<radian>(
-            self.angle_converter
-                .radians_decode_f64(angle.get::<radian>()),
-        )
+    pub fn decode(&self, angle: Angle) -> Angle {
+        Angle::new::<radian>(self.angle_converter.radians_decode(angle.get::<radian>()))
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use std::f32::consts::PI;
+
     use super::*;
 
     #[test]
@@ -297,8 +279,8 @@ mod tests {
         let converter = AngleConverter::screen();
 
         // Test radians_encode
-        let result = converter.radians_encode(PI / 2.0); // 90° in radians
-        let expected = 270.0 * PI / 180.0; // 270° in radians
+        let result = converter.radians_encode(PI as f64 / 2.0) as f64; // 90° in radians
+        let expected: f64 = 270.0f64 * PI as f64 / 180.0f64; // 270° in radians
         assert!((result - expected).abs() < 1e-6);
     }
 
@@ -306,10 +288,10 @@ mod tests {
     fn test_roundtrip_conversion() {
         let converter = AngleConverter::new(true, false, true); // X-flip + CW
 
-        let original = 75.0_f32;
+        let original = 75.0_f64;
         let converted = converter.degrees_encode(original);
         let roundtrip = converter.degrees_decode(converted);
 
-        assert!((original - roundtrip).abs() < 1e-6);
+        assert!((original - roundtrip as f64).abs() < 1e-6);
     }
 }

control-core/src/converters/angular_step_converter.rs

@@ -18,7 +18,7 @@ pub struct AngularStepConverter {
 
 impl AngularStepConverter {
     /// Create a new converter with the specified steps per revolution
-    pub fn new(steps_per_revolution: i16) -> Self {
+    pub const fn new(steps_per_revolution: i16) -> Self {
         Self {
             steps_per_revolution,
         }

control-core/src/converters/circular_converter.rs

@@ -0,0 +1,279 @@
+//! # Circular Converter
+//!
+//! This module provides the `CircularConverter` which handles transformations between
+//! linear and angular measurements for circular motion systems.
+//!
+//! ## Usage
+//!
+//! The `CircularConverter` is designed to work alongside other converters:
+//! - Use `AngularStepConverter` for angular-to-step conversions
+//! - Use `LinearStepConverter` for complete linear-to-step conversions (uses `CircularConverter` internally)
+//! - Use `CircularConverter` directly when you need linear-to-angular conversions without steps
+//!
+//! ## Examples
+//!
+//! ```rust
+//! use control_core::converters::circular_converter::CircularConverter;
+//! use uom::si::{f64::{Length, Velocity}, length::meter, velocity::meter_per_second};
+//!
+//! let converter = CircularConverter::from_radius(Length::new::<meter>(0.1));
+//! let velocity = Velocity::new::<meter_per_second>(1.0);
+//! let angular_velocity = converter.linear_to_angular_velocity(velocity);
+//! ```
+
+use uom::si::{
+    acceleration::meter_per_second_squared,
+    angle::radian,
+    angular_acceleration::radian_per_second_squared,
+    angular_velocity::radian_per_second,
+    f64::{Acceleration, Angle, AngularAcceleration, AngularVelocity, Length, Velocity},
+    length::meter,
+    velocity::meter_per_second,
+};
+
+/// A converter that handles transformations between linear and angular measurements
+/// for circular motion. This includes conversions for position, velocity, acceleration,
+/// and higher-order derivatives based on a circle's geometric properties.
+#[derive(Debug, Clone)]
+pub struct CircularConverter {
+    radius: Length,
+    circumference: Length,
+    diameter: Length,
+}
+
+impl CircularConverter {
+    /// Create a new converter from radius
+    pub fn from_radius(radius: Length) -> Self {
+        let diameter = radius * 2.0;
+        let circumference =
+            Length::new::<meter>(2.0 * std::f64::consts::PI * radius.get::<meter>());
+        Self {
+            radius,
+            diameter,
+            circumference,
+        }
+    }
+
+    /// Create a new converter from diameter
+    pub fn from_diameter(diameter: Length) -> Self {
+        let radius = diameter / 2.0;
+        Self::from_radius(radius)
+    }
+
+    /// Create a new converter from circumference
+    pub fn from_circumference(circumference: Length) -> Self {
+        let radius =
+            Length::new::<meter>(circumference.get::<meter>() / (2.0 * std::f64::consts::PI));
+        Self::from_radius(radius)
+    }
+
+    /// Get the radius
+    pub fn radius(&self) -> Length {
+        self.radius
+    }
+
+    /// Get the diameter
+    pub fn diameter(&self) -> Length {
+        self.diameter
+    }
+
+    /// Get the circumference
+    pub fn circumference(&self) -> Length {
+        self.circumference
+    }
+
+    // Linear to Angular Position Conversions
+
+    /// Convert linear distance to angular position
+    /// Formula: angle = distance / radius
+    pub fn linear_to_angular_position(&self, distance: Length) -> Angle {
+        let angle_rad = distance.get::<meter>() / self.radius.get::<meter>();
+        Angle::new::<radian>(angle_rad)
+    }
+
+    /// Convert angular position to linear distance
+    /// Formula: distance = angle * radius
+    pub fn angular_to_linear_position(&self, angle: Angle) -> Length {
+        let distance = angle.get::<radian>() * self.radius.get::<meter>();
+        Length::new::<meter>(distance)
+    }
+
+    // Linear to Angular Velocity Conversions
+
+    /// Convert linear velocity to angular velocity
+    /// Formula: angular_velocity = linear_velocity / radius
+    pub fn linear_to_angular_velocity(&self, velocity: Velocity) -> AngularVelocity {
+        let angular_velocity_rad_per_s =
+            velocity.get::<meter_per_second>() / self.radius.get::<meter>();
+        AngularVelocity::new::<radian_per_second>(angular_velocity_rad_per_s)
+    }
+
+    /// Convert angular velocity to linear velocity
+    /// Formula: linear_velocity = angular_velocity * radius
+    pub fn angular_to_linear_velocity(&self, angular_velocity: AngularVelocity) -> Velocity {
+        let velocity = angular_velocity.get::<radian_per_second>() * self.radius.get::<meter>();
+        Velocity::new::<meter_per_second>(velocity)
+    }
+
+    // Linear to Angular Acceleration Conversions
+
+    /// Convert linear acceleration to angular acceleration
+    /// Formula: angular_acceleration = linear_acceleration / radius
+    pub fn linear_to_angular_acceleration(
+        &self,
+        acceleration: Acceleration,
+    ) -> AngularAcceleration {
+        let angular_acceleration_rad_per_s2 =
+            acceleration.get::<meter_per_second_squared>() / self.radius.get::<meter>();
+        AngularAcceleration::new::<radian_per_second_squared>(angular_acceleration_rad_per_s2)
+    }
+
+    /// Convert angular acceleration to linear acceleration
+    /// Formula: linear_acceleration = angular_acceleration * radius
+    pub fn angular_to_linear_acceleration(
+        &self,
+        angular_acceleration: AngularAcceleration,
+    ) -> Acceleration {
+        let acceleration =
+            angular_acceleration.get::<radian_per_second_squared>() * self.radius.get::<meter>();
+        Acceleration::new::<meter_per_second_squared>(acceleration)
+    }
+
+    // Jerk Conversions (using f64 for now since UOM may not have jerk units)
+
+    /// Convert linear jerk to angular jerk
+    /// Formula: angular_jerk = linear_jerk / radius
+    /// Units: rad/s³ = (m/s³) / m
+    pub fn linear_to_angular_jerk(&self, linear_jerk: f64) -> f64 {
+        linear_jerk / self.radius.get::<meter>()
+    }
+
+    /// Convert angular jerk to linear jerk
+    /// Formula: linear_jerk = angular_jerk * radius
+    /// Units: m/s³ = (rad/s³) * m
+    pub fn angular_to_linear_jerk(&self, angular_jerk: f64) -> f64 {
+        angular_jerk * self.radius.get::<meter>()
+    }
+
+    // Arc Length Calculations
+
+    /// Calculate arc length from angle
+    /// Formula: arc_length = angle * radius
+    pub fn angle_to_arc_length(&self, angle: Angle) -> Length {
+        self.angular_to_linear_position(angle)
+    }
+
+    /// Calculate angle from arc length
+    /// Formula: angle = arc_length / radius
+    pub fn arc_length_to_angle(&self, arc_length: Length) -> Angle {
+        self.linear_to_angular_position(arc_length)
+    }
+
+    // Circumference-based calculations
+
+    /// Convert linear distance to number of revolutions
+    /// Formula: revolutions = distance / circumference
+    pub fn linear_distance_to_revolutions(&self, distance: Length) -> f64 {
+        distance.get::<meter>() / self.circumference.get::<meter>()
+    }
+
+    /// Convert number of revolutions to linear distance
+    /// Formula: distance = revolutions * circumference
+    pub fn revolutions_to_linear_distance(&self, revolutions: f64) -> Length {
+        Length::new::<meter>(revolutions * self.circumference.get::<meter>())
+    }
+
+    /// Convert linear velocity to revolutions per second
+    /// Formula: rps = velocity / circumference
+    pub fn linear_velocity_to_rps(&self, velocity: Velocity) -> f64 {
+        velocity.get::<meter_per_second>() / self.circumference.get::<meter>()
+    }
+
+    /// Convert revolutions per second to linear velocity
+    /// Formula: velocity = rps * circumference
+    pub fn rps_to_linear_velocity(&self, rps: f64) -> Velocity {
+        Velocity::new::<meter_per_second>(rps * self.circumference.get::<meter>())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use uom::si::length::centimeter;
+
+    #[test]
+    fn test_constructors() {
+        let radius = Length::new::<centimeter>(5.0);
+        let diameter = Length::new::<centimeter>(10.0);
+        let circumference = Length::new::<centimeter>(2.0 * std::f64::consts::PI * 5.0);
+
+        let converter1 = CircularConverter::from_radius(radius);
+        let converter2 = CircularConverter::from_diameter(diameter);
+        let converter3 = CircularConverter::from_circumference(circumference);
+
+        // All should have approximately the same values
+        assert!((converter1.radius().get::<centimeter>() - 5.0).abs() < 1e-10);
+        assert!((converter2.radius().get::<centimeter>() - 5.0).abs() < 1e-10);
+        assert!((converter3.radius().get::<centimeter>() - 5.0).abs() < 1e-10);
+
+        assert!((converter1.diameter().get::<centimeter>() - 10.0).abs() < 1e-10);
+        assert!((converter2.diameter().get::<centimeter>() - 10.0).abs() < 1e-10);
+        assert!((converter3.diameter().get::<centimeter>() - 10.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_position_conversions() {
+        let converter = CircularConverter::from_radius(Length::new::<meter>(1.0));
+
+        // Test linear to angular
+        let distance = Length::new::<meter>(std::f64::consts::PI);
+        let angle = converter.linear_to_angular_position(distance);
+        assert!((angle.get::<radian>() - std::f64::consts::PI).abs() < 1e-10);
+
+        // Test angular to linear
+        let angle = Angle::new::<radian>(std::f64::consts::PI / 2.0);
+        let distance = converter.angular_to_linear_position(angle);
+        assert!((distance.get::<meter>() - std::f64::consts::PI / 2.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_velocity_conversions() {
+        let converter = CircularConverter::from_radius(Length::new::<meter>(0.5));
+
+        // Test linear to angular
+        let velocity = Velocity::new::<meter_per_second>(1.0);
+        let angular_velocity = converter.linear_to_angular_velocity(velocity);
+        assert!((angular_velocity.get::<radian_per_second>() - 2.0).abs() < 1e-10);
+
+        // Test angular to linear
+        let angular_velocity = AngularVelocity::new::<radian_per_second>(4.0);
+        let velocity = converter.angular_to_linear_velocity(angular_velocity);
+        assert!((velocity.get::<meter_per_second>() - 2.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_revolution_conversions() {
+        let converter = CircularConverter::from_radius(Length::new::<meter>(1.0));
+
+        // One full revolution should equal circumference
+        let revolutions = 1.0;
+        let distance = converter.revolutions_to_linear_distance(revolutions);
+        assert!((distance.get::<meter>() - converter.circumference().get::<meter>()).abs() < 1e-10);
+
+        // Converting back should give 1 revolution
+        let calculated_revolutions = converter.linear_distance_to_revolutions(distance);
+        assert!((calculated_revolutions - 1.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_jerk_conversions() {
+        let converter = CircularConverter::from_radius(Length::new::<meter>(2.0));
+
+        let linear_jerk = 4.0; // m/s³
+        let angular_jerk = converter.linear_to_angular_jerk(linear_jerk);
+        assert!((angular_jerk - 2.0).abs() < 1e-10); // 4.0 / 2.0 = 2.0 rad/s³
+
+        let calculated_linear_jerk = converter.angular_to_linear_jerk(angular_jerk);
+        assert!((calculated_linear_jerk - linear_jerk).abs() < 1e-10);
+    }
+}

control-core/src/converters/linear_step_converter.rs

@@ -1,14 +1,11 @@
 use uom::si::{
-    acceleration::meter_per_second_squared,
     angle::revolution,
-    angular_acceleration::radian_per_second_squared,
     angular_velocity::revolution_per_second,
     f64::{Acceleration, Angle, AngularAcceleration, AngularVelocity, Length, Velocity},
-    length::meter,
-    velocity::meter_per_second,
 };
 
 use super::angular_step_converter::AngularStepConverter;
+use super::circular_converter::CircularConverter;
 
 /// Converts between linear measurements and motor steps
 ///
@@ -18,57 +15,52 @@ use super::angular_step_converter::AngularStepConverter;
 #[derive(Debug, Clone)]
 pub struct LinearStepConverter {
     angular_step_converter: AngularStepConverter,
-    radius: Length,
-    circumference: Length,
+    circular_converter: CircularConverter,
 }
 
 // Constructor and basic getters
 impl LinearStepConverter {
     /// Create a new converter from radius and steps per revolution
     pub fn from_radius(steps_per_revolution: i16, radius: Length) -> Self {
-        let circumference =
-            Length::new::<meter>(2.0 * std::f64::consts::PI * radius.get::<meter>());
         Self {
             angular_step_converter: AngularStepConverter::new(steps_per_revolution),
-            radius,
-            circumference,
+            circular_converter: CircularConverter::from_radius(radius),
         }
     }
 
     /// Create a new converter from diameter and steps per revolution
     pub fn from_diameter(steps_per_revolution: i16, diameter: Length) -> Self {
-        let radius = diameter / 2.0;
-        Self::from_radius(steps_per_revolution, radius)
+        Self {
+            angular_step_converter: AngularStepConverter::new(steps_per_revolution),
+            circular_converter: CircularConverter::from_diameter(diameter),
+        }
     }
 
     /// Create a new converter from circumference and steps per revolution
     pub fn from_circumference(steps_per_revolution: i16, circumference: Length) -> Self {
-        let radius =
-            Length::new::<meter>(circumference.get::<meter>() / (2.0 * std::f64::consts::PI));
         Self {
             angular_step_converter: AngularStepConverter::new(steps_per_revolution),
-            radius,
-            circumference,
+            circular_converter: CircularConverter::from_circumference(circumference),
         }
     }
 
     /// Get the radius used by the converter
     pub fn radius(&self) -> Length {
-        self.radius
+        self.circular_converter.radius()
     }
 
     /// Get the diameter of the system
     pub fn diameter(&self) -> Length {
-        self.radius * 2.0
+        self.circular_converter.diameter()
     }
 
     /// Get the circumference of the system
     pub fn circumference(&self) -> Length {
-        self.circumference
+        self.circular_converter.circumference()
     }
 
     /// Get the steps per revolution
-    pub fn steps_per_revolution(&self) -> i16 {
+    pub const fn steps_per_revolution(&self) -> i16 {
         self.angular_step_converter.steps_per_revolution
     }
 }
@@ -79,8 +71,10 @@ impl LinearStepConverter {
     ///
     /// Formula: steps = (distance / circumference) * steps_per_revolution
     pub fn distance_to_steps(&self, distance: Length) -> f64 {
-        // Convert distance to angle: angle = distance/circumference (in revolutions)
-        let revolutions = distance.get::<meter>() / self.circumference.get::<meter>();
+        // Convert distance to revolutions using CircularConverter
+        let revolutions = self
+            .circular_converter
+            .linear_distance_to_revolutions(distance);
         let angle = Angle::new::<revolution>(revolutions);
 
         // Convert angle to steps
@@ -94,21 +88,19 @@ impl LinearStepConverter {
         // Convert steps to angle
         let angle = self.angular_step_converter.steps_to_angle(steps);
 
-        // Convert angle to distance: distance = angle * circumference
+        // Convert angle to distance using CircularConverter
         let revolutions = angle.get::<revolution>();
-        let distance = revolutions * self.circumference.get::<meter>();
-
-        Length::new::<meter>(distance)
+        self.circular_converter
+            .revolutions_to_linear_distance(revolutions)
     }
 
     /// Convert linear velocity to steps/second
     ///
     /// Formula: steps/second = (velocity / circumference) * steps_per_revolution
     pub fn velocity_to_steps(&self, velocity: Velocity) -> f64 {
-        // Convert linear velocity to angular velocity: ω = v/circumference (in rev/s)
-        let linear_velocity = velocity.get::<meter_per_second>();
-        let angular_velocity_rps = linear_velocity / self.circumference.get::<meter>();
-        let angular_velocity = AngularVelocity::new::<revolution_per_second>(angular_velocity_rps);
+        // Convert linear velocity to revolutions per second using CircularConverter
+        let rps = self.circular_converter.linear_velocity_to_rps(velocity);
+        let angular_velocity = AngularVelocity::new::<revolution_per_second>(rps);
 
         // Convert angular velocity to steps/second
         self.angular_step_converter
@@ -124,23 +116,19 @@ impl LinearStepConverter {
             .angular_step_converter
             .steps_to_angular_velocity(steps_per_second);
 
-        // Convert angular velocity to linear velocity: v = ω * circumference
-        let angular_velocity_rps = angular_velocity.get::<revolution_per_second>();
-        let linear_velocity = angular_velocity_rps * self.circumference.get::<meter>();
-
-        Velocity::new::<meter_per_second>(linear_velocity)
+        // Convert angular velocity to linear velocity using CircularConverter
+        let rps = angular_velocity.get::<revolution_per_second>();
+        self.circular_converter.rps_to_linear_velocity(rps)
     }
 
     /// Convert linear acceleration to steps/second²
     ///
     /// Formula: steps/second² = (acceleration / radius) * (steps_per_revolution / (2π))
     pub fn acceleration_to_steps(&self, acceleration: Acceleration) -> f64 {
-        // Convert linear acceleration to angular acceleration: α = a/r
-        let linear_acceleration = acceleration.get::<meter_per_second_squared>();
-        // Calculate angular acceleration in radians per second squared
-        let angular_acceleration_rad_per_s2 = linear_acceleration / self.radius.get::<meter>();
-        let angular_acceleration =
-            AngularAcceleration::new::<radian_per_second_squared>(angular_acceleration_rad_per_s2);
+        // Convert linear acceleration to angular acceleration using CircularConverter
+        let angular_acceleration = self
+            .circular_converter
+            .linear_to_angular_acceleration(acceleration);
 
         // Convert angular acceleration to steps/second²
         self.angular_step_converter
@@ -156,12 +144,9 @@ impl LinearStepConverter {
             .angular_step_converter
             .steps_to_angular_acceleration(steps_per_second_squared);
 
-        // Convert angular acceleration to linear acceleration: a = α * r
-        let angular_acceleration_rad_per_s2 =
-            angular_acceleration.get::<radian_per_second_squared>();
-        let linear_acceleration = angular_acceleration_rad_per_s2 * self.radius.get::<meter>();
-
-        Acceleration::new::<meter_per_second_squared>(linear_acceleration)
+        // Convert angular acceleration to linear acceleration using CircularConverter
+        self.circular_converter
+            .angular_to_linear_acceleration(angular_acceleration)
     }
 }
 
@@ -171,7 +156,9 @@ impl LinearStepConverter {
     ///
     /// Formula: angle (in revolutions) = distance / circumference
     pub fn distance_to_angle(&self, distance: Length) -> Angle {
-        let revolutions = distance.get::<meter>() / self.circumference.get::<meter>();
+        let revolutions = self
+            .circular_converter
+            .linear_distance_to_revolutions(distance);
         Angle::new::<revolution>(revolutions)
     }
 
@@ -180,26 +167,24 @@ impl LinearStepConverter {
     /// Formula: distance = angle (in revolutions) * circumference
     pub fn angle_to_distance(&self, angle: Angle) -> Length {
         let revolutions = angle.get::<revolution>();
-        let distance = revolutions * self.circumference.get::<meter>();
-        Length::new::<meter>(distance)
+        self.circular_converter
+            .revolutions_to_linear_distance(revolutions)
     }
 
     /// Convert linear velocity to angular velocity
     ///
     /// Formula: angular velocity (in rev/s) = velocity / circumference
     pub fn velocity_to_angular_velocity(&self, velocity: Velocity) -> AngularVelocity {
-        let linear_velocity = velocity.get::<meter_per_second>();
-        let angular_velocity_rps = linear_velocity / self.circumference.get::<meter>();
-        AngularVelocity::new::<revolution_per_second>(angular_velocity_rps)
+        let rps = self.circular_converter.linear_velocity_to_rps(velocity);
+        AngularVelocity::new::<revolution_per_second>(rps)
     }
 
     /// Convert angular velocity to linear velocity
     ///
     /// Formula: velocity = angular velocity (in rev/s) * circumference
     pub fn angular_velocity_to_velocity(&self, angular_velocity: AngularVelocity) -> Velocity {
-        let angular_velocity_rps = angular_velocity.get::<revolution_per_second>();
-        let linear_velocity = angular_velocity_rps * self.circumference.get::<meter>();
-        Velocity::new::<meter_per_second>(linear_velocity)
+        let rps = angular_velocity.get::<revolution_per_second>();
+        self.circular_converter.rps_to_linear_velocity(rps)
     }
 
     /// Convert linear acceleration to angular acceleration
@@ -209,9 +194,8 @@ impl LinearStepConverter {
         &self,
         acceleration: Acceleration,
     ) -> AngularAcceleration {
-        let linear_acceleration = acceleration.get::<meter_per_second_squared>();
-        let angular_acceleration_rad_per_s2 = linear_acceleration / self.radius.get::<meter>();
-        AngularAcceleration::new::<radian_per_second_squared>(angular_acceleration_rad_per_s2)
+        self.circular_converter
+            .linear_to_angular_acceleration(acceleration)
     }
 
     /// Convert angular acceleration to linear acceleration
@@ -221,10 +205,8 @@ impl LinearStepConverter {
         &self,
         angular_acceleration: AngularAcceleration,
     ) -> Acceleration {
-        let angular_acceleration_rad_per_s2 =
-            angular_acceleration.get::<radian_per_second_squared>();
-        let linear_acceleration = angular_acceleration_rad_per_s2 * self.radius.get::<meter>();
-        Acceleration::new::<meter_per_second_squared>(linear_acceleration)
+        self.circular_converter
+            .angular_to_linear_acceleration(angular_acceleration)
     }
 }
 
@@ -269,6 +251,10 @@ mod tests {
     use super::*;
     use approx::assert_relative_eq;
     use std::f64::EPSILON;
+    use uom::si::{
+        acceleration::meter_per_second_squared, angular_acceleration::radian_per_second_squared,
+        length::meter, velocity::meter_per_second,
+    };
 
     #[test]
     fn test_new() {

control-core/src/converters/mod.rs

@@ -1,5 +1,5 @@
 pub mod angle_converter;
 pub mod angular_step_converter;
+pub mod circular_converter;
 pub mod linear_step_converter;
 pub mod motor_converter;
-pub mod transmission_converter;

control-core/src/converters/transmission_converter.rs

@@ -1,22 +0,0 @@
-use uom::si::f64::AngularVelocity;
-
-#[derive(Debug, Clone)]
-pub struct TransmissionConverter {
-    pub transmission_ratio: f64,
-}
-
-impl TransmissionConverter {
-    pub fn new() -> Self {
-        Self {
-            transmission_ratio: 34.0,
-        }
-    }
-
-    pub fn calculate_screw_output_rpm(&self, rpm: AngularVelocity) -> AngularVelocity {
-        rpm / self.transmission_ratio
-    }
-
-    pub fn calculate_screw_input_rpm(&self, screw_rpm: AngularVelocity) -> AngularVelocity {
-        screw_rpm * self.transmission_ratio
-    }
-}

control-core/src/downcast.rs

@@ -0,0 +1,36 @@
+use anyhow::anyhow;
+use smol::lock::Mutex;
+use std::any::Any;
+use std::sync::Arc;
+
+pub trait Downcast<T> {
+    fn downcast(&self) -> Result<T, anyhow::Error>;
+}
+
+pub trait DowncastRef<T> {
+    fn downcast_ref(&self) -> Result<&T, anyhow::Error>;
+}
+
+impl<T: 'static, U: Any + 'static> Downcast<Arc<Mutex<T>>> for Arc<Mutex<U>> {
+    fn downcast(&self) -> Result<Arc<Mutex<T>>, anyhow::Error> {
+        // Acquire a read lock on the RwLock
+        let lock = self.lock_blocking();
+
+        // Check if the inner type can be downcasted to T
+        let any: &dyn Any = &*lock;
+
+        if any.is::<T>() {
+            // Clone the Arc and return it as the desired type
+            let cloned: Arc<Mutex<dyn Any>> = self.clone();
+
+            // Transmute the Arc to the desired type
+            unsafe {
+                let arc = Arc::from_raw(Arc::into_raw(cloned) as *const Mutex<T>);
+
+                Ok(arc)
+            }
+        } else {
+            Err(anyhow!("[{}::downcast] Downcast failed", module_path!()))
+        }
+    }
+}

control-core/src/ethercat/eeprom_identification.rs

@@ -7,6 +7,7 @@ use ethercat_hal::devices::el2002::EL2002_IDENTITY_A;
 use ethercat_hal::devices::el2002::EL2002_IDENTITY_B;
 use ethercat_hal::devices::el2004::EL2004_IDENTITY_A;
 use ethercat_hal::devices::el2008::EL2008_IDENTITY_A;
+use ethercat_hal::devices::el2008::EL2008_IDENTITY_B;
 use ethercat_hal::devices::el2521::{
     EL2521_IDENTITY_0000_A, EL2521_IDENTITY_0000_B, EL2521_IDENTITY_0024_A,
 };
@@ -17,6 +18,8 @@ use ethercat_hal::devices::el3024::EL3024_IDENTITY_A;
 use ethercat_hal::devices::el3062_0030::EL3062_0030_IDENTITY_A;
 use ethercat_hal::devices::el3204::EL3204_IDENTITY_A;
 use ethercat_hal::devices::el3204::EL3204_IDENTITY_B;
+use ethercat_hal::devices::el4002::EL4002_IDENTITY_A;
+use ethercat_hal::devices::el5152::EL5152_IDENTITY_A;
 use ethercat_hal::devices::el6021::{
     EL6021_IDENTITY_A, EL6021_IDENTITY_B, EL6021_IDENTITY_C, EL6021_IDENTITY_D,
 };
@@ -43,7 +46,12 @@ pub struct MachineIdentificationAddresses {
 }
 
 impl MachineIdentificationAddresses {
-    pub fn new(vendor_word: u16, serial_word: u16, machine_word: u16, device_word: u16) -> Self {
+    pub const fn new(
+        vendor_word: u16,
+        serial_word: u16,
+        machine_word: u16,
+        device_word: u16,
+    ) -> Self {
         Self {
             vendor_word,
             serial_word,
@@ -73,7 +81,7 @@ pub async fn read_device_identifications<'maindevice>(
 ) -> Vec<Result<DeviceMachineIdentification, Error>> {
     let mut result = Vec::new();
     for subdevice in subdevices.iter() {
-        let identification = machine_device_identification(&subdevice, maindevice).await;
+        let identification = machine_device_identification(subdevice, maindevice).await;
         result.push(identification);
     }
     result
@@ -220,11 +228,11 @@ pub async fn write_machine_device_identification<'maindevice, const MAX_PDI: usi
 
 /// Returns the EEPROM addresses for the machine device identification
 /// based on the subdevice's identity
-pub fn get_identification_addresses<'maindevice>(
+pub fn get_identification_addresses(
     subdevice_identity: &SubDeviceIdentity,
     subdevice_name: &str,
 ) -> Result<MachineIdentificationAddresses, Error> {
-    let identity_tuple = subdevice_identity_to_tuple(&subdevice_identity);
+    let identity_tuple = subdevice_identity_to_tuple(subdevice_identity);
 
     Ok(match identity_tuple {
         EK1100_IDENTITY_A => MachineIdentificationAddresses::default(),
@@ -232,22 +240,25 @@ pub fn get_identification_addresses<'maindevice>(
         EL1008_IDENTITY_A => MachineIdentificationAddresses::default(),
         EL2002_IDENTITY_A | EL2002_IDENTITY_B => MachineIdentificationAddresses::default(),
         EL2004_IDENTITY_A => MachineIdentificationAddresses::default(),
-        EL3204_IDENTITY_A | EL3204_IDENTITY_B => MachineIdentificationAddresses::default(),
-        EL2008_IDENTITY_A => MachineIdentificationAddresses::default(),
-        EL3001_IDENTITY_A => MachineIdentificationAddresses::default(),
+        EL2008_IDENTITY_A | EL2008_IDENTITY_B => MachineIdentificationAddresses::default(),
         EL2521_IDENTITY_0000_A | EL2521_IDENTITY_0000_B | EL2521_IDENTITY_0024_A => {
             MachineIdentificationAddresses::default()
         }
         EL2522_IDENTITY_A => MachineIdentificationAddresses::default(),
+        EL3001_IDENTITY_A => MachineIdentificationAddresses::default(),
         EL3021_IDENTITY_A => MachineIdentificationAddresses::default(),
         EL3024_IDENTITY_A => MachineIdentificationAddresses::default(),
         EL3062_0030_IDENTITY_A => MachineIdentificationAddresses::default(),
-        EL7031_IDENTITY_A | EL7031_IDENTITY_B => MachineIdentificationAddresses::default(),
-        EL7031_0030_IDENTITY_A => MachineIdentificationAddresses::default(),
-        EL7041_0052_IDENTITY_A => MachineIdentificationAddresses::default(),
+        EL3204_IDENTITY_A | EL3204_IDENTITY_B => MachineIdentificationAddresses::default(),
+        EL4002_IDENTITY_A => MachineIdentificationAddresses::default(),
+        EL5152_IDENTITY_A => MachineIdentificationAddresses::default(),
         EL6021_IDENTITY_A | EL6021_IDENTITY_B | EL6021_IDENTITY_C | EL6021_IDENTITY_D => {
             MachineIdentificationAddresses::default()
         }
+        EL7031_IDENTITY_A | EL7031_IDENTITY_B => MachineIdentificationAddresses::default(),
+        EL7031_0030_IDENTITY_A => MachineIdentificationAddresses::default(),
+        EL7041_0052_IDENTITY_A => MachineIdentificationAddresses::default(),
+
         _ => {
             // block_on(u16dump(&subdevice, maindevice, 0x00, 0xff))?;
             Err(anyhow!(
@@ -273,8 +284,8 @@ async fn u16dump<'maindevice>(
         words.push(subdevice.eeprom_read(maindevice, word).await?);
     }
 
-    print!(
-        "EEPROM dump for {} from 0x{:04x} to 0x{:04x}\n",
+    println!(
+        "EEPROM dump for {} from 0x{:04x} to 0x{:04x}",
         subdevice.name(),
         start_byte / 2,
         end_byte / 2
@@ -289,7 +300,7 @@ fn u16print(start_byte: u16, end_byte: u16, data: Vec<u16>) {
     let table_start_word = start_byte & 0xfff0;
     let table_end_word = (end_byte & 0xfff0_u16) + 0x10_u16;
 
-    let rows = table_end_word - table_start_word >> 4;
+    let rows = (table_end_word - table_start_word) >> 4;
 
     for row in 0..rows {
         print!("0x{:04x} | ", (table_start_word + row * 0x10) / 2);
@@ -306,7 +317,7 @@ fn u16print(start_byte: u16, end_byte: u16, data: Vec<u16>) {
                 }
             }
         }
-        print!("\n");
+        println!();
     }
 }
 

control-core/src/ethercat/interface_discovery.rs

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

control-core/src/helpers/hasher_serializer.rs

@@ -0,0 +1,337 @@
+use serde::Serialize;
+use serde::ser::{
+    SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
+    SerializeTupleStruct, SerializeTupleVariant, Serializer,
+};
+use std::error::Error;
+use std::fmt::Display;
+use std::hash::{DefaultHasher, Hasher};
+
+#[derive(Debug)]
+pub struct HashSerializerError {}
+
+impl std::fmt::Display for HashSerializerError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&format!("{:?}", self))
+        // f.debug_struct("HashSerialiyerError")
+        // .finish()
+    }
+}
+
+impl Error for HashSerializerError {}
+
+impl serde::ser::Error for HashSerializerError {
+    fn custom<T>(_msg: T) -> Self
+    where
+        T: Display,
+    {
+        Self {}
+    }
+}
+
+pub struct HashSerializer<'a, H: Hasher>(&'a mut H);
+impl<H: Hasher> SerializeSeq for HashSerializer<'_, H> {
+    type Ok = ();
+    type Error = HashSerializerError;
+
+    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
+    where
+        T: ?Sized + Serialize,
+    {
+        value.serialize(HashSerializer(self.0))
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        Ok(())
+    }
+}
+
+impl<H: Hasher> SerializeTuple for HashSerializer<'_, H> {
+    type Ok = ();
+    type Error = HashSerializerError;
+
+    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
+    where
+        T: ?Sized + Serialize,
+    {
+        value.serialize(HashSerializer(self.0))
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        Ok(())
+    }
+}
+
+impl<H: Hasher> SerializeTupleStruct for HashSerializer<'_, H> {
+    type Ok = ();
+    type Error = HashSerializerError;
+
+    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
+    where
+        T: ?Sized + Serialize,
+    {
+        value.serialize(HashSerializer(self.0))
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        Ok(())
+    }
+}
+
+impl<H: Hasher> SerializeTupleVariant for HashSerializer<'_, H> {
+    type Ok = ();
+    type Error = HashSerializerError;
+
+    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
+    where
+        T: ?Sized + Serialize,
+    {
+        value.serialize(HashSerializer(self.0))
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        Ok(())
+    }
+}
+
+impl<H: Hasher> SerializeMap for HashSerializer<'_, H> {
+    type Ok = ();
+    type Error = HashSerializerError;
+
+    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
+    where
+        T: ?Sized + Serialize,
+    {
+        key.serialize(HashSerializer(self.0))
+    }
+
+    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
+    where
+        T: ?Sized + Serialize,
+    {
+        value.serialize(HashSerializer(self.0))
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        Ok(())
+    }
+}
+
+impl<H: Hasher> SerializeStruct for HashSerializer<'_, H> {
+    type Ok = ();
+    type Error = HashSerializerError;
+
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
+    where
+        T: ?Sized + Serialize,
+    {
+        // Optional: hash the field name to avoid collisions
+        self.0.write(key.as_bytes());
+        value.serialize(HashSerializer(self.0))
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        Ok(())
+    }
+}
+
+impl<H: Hasher> SerializeStructVariant for HashSerializer<'_, H> {
+    type Ok = ();
+    type Error = HashSerializerError;
+
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
+    where
+        T: ?Sized + Serialize,
+    {
+        self.0.write(key.as_bytes());
+        value.serialize(HashSerializer(self.0))
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        Ok(())
+    }
+}
+
+impl<H: Hasher> Serializer for HashSerializer<'_, H> {
+    type Ok = ();
+    type Error = HashSerializerError;
+    type SerializeSeq = Self;
+    type SerializeTuple = Self;
+    type SerializeTupleStruct = Self;
+    type SerializeTupleVariant = Self;
+    type SerializeMap = Self;
+    type SerializeStruct = Self;
+    type SerializeStructVariant = Self;
+
+    fn serialize_bool(self, v: bool) -> Result<(), Self::Error> {
+        self.0.write_u8(v as u8);
+        Ok(())
+    }
+
+    fn serialize_i8(self, v: i8) -> Result<(), Self::Error> {
+        self.0.write_i8(v);
+        Ok(())
+    }
+
+    fn serialize_i16(self, v: i16) -> Result<(), Self::Error> {
+        self.0.write_i16(v);
+        Ok(())
+    }
+
+    fn serialize_i32(self, v: i32) -> Result<(), Self::Error> {
+        self.0.write_i32(v);
+        Ok(())
+    }
+
+    fn serialize_i64(self, v: i64) -> Result<(), Self::Error> {
+        self.0.write_i64(v);
+        Ok(())
+    }
+
+    fn serialize_u8(self, v: u8) -> Result<(), Self::Error> {
+        self.0.write_u8(v);
+        Ok(())
+    }
+
+    fn serialize_u16(self, v: u16) -> Result<(), Self::Error> {
+        self.0.write_u16(v);
+        Ok(())
+    }
+
+    fn serialize_u32(self, v: u32) -> Result<(), Self::Error> {
+        self.0.write_u32(v);
+        Ok(())
+    }
+
+    fn serialize_u64(self, v: u64) -> Result<(), Self::Error> {
+        self.0.write_u64(v);
+        Ok(())
+    }
+
+    fn serialize_f32(self, v: f32) -> Result<(), Self::Error> {
+        self.0.write_u32(v.to_bits());
+        Ok(())
+    }
+
+    fn serialize_f64(self, v: f64) -> Result<(), Self::Error> {
+        self.0.write_u64(v.to_bits());
+        Ok(())
+    }
+
+    fn serialize_char(self, v: char) -> Result<(), Self::Error> {
+        let mut buf = [0; 4];
+        self.0.write(v.encode_utf8(&mut buf).as_bytes());
+        Ok(())
+    }
+
+    fn serialize_str(self, v: &str) -> Result<(), Self::Error> {
+        self.0.write(v.as_bytes());
+        Ok(())
+    }
+
+    fn serialize_bytes(self, v: &[u8]) -> Result<(), Self::Error> {
+        self.0.write(v);
+        Ok(())
+    }
+
+    fn serialize_none(self) -> Result<(), Self::Error> {
+        self.0.write_u8(0); // type tag for None
+        Ok(())
+    }
+
+    fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<(), Self::Error> {
+        self.0.write_u8(1); // type tag for Some
+        value.serialize(self)
+    }
+
+    fn serialize_unit(self) -> Result<(), Self::Error> {
+        self.0.write_u8(0);
+        Ok(())
+    }
+
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Self::Error> {
+        self.serialize_unit()
+    }
+
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        variant_index: u32,
+        _variant: &'static str,
+    ) -> Result<(), Self::Error> {
+        self.0.write_u32(variant_index);
+        Ok(())
+    }
+
+    fn serialize_newtype_struct<T: ?Sized + Serialize>(
+        self,
+        _name: &'static str,
+        value: &T,
+    ) -> Result<(), Self::Error> {
+        value.serialize(self)
+    }
+
+    fn serialize_newtype_variant<T: ?Sized + Serialize>(
+        self,
+        _name: &'static str,
+        variant_index: u32,
+        _variant: &'static str,
+        value: &T,
+    ) -> Result<(), Self::Error> {
+        self.0.write_u32(variant_index);
+        value.serialize(self)
+    }
+
+    // For sequences, tuples, maps, structs, just return self for now
+    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+        Ok(self)
+    }
+    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
+        Ok(self)
+    }
+    fn serialize_tuple_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
+        Ok(self)
+    }
+    fn serialize_tuple_variant(
+        self,
+        _name: &'static str,
+        variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
+        self.0.write_u32(variant_index);
+        Ok(self)
+    }
+    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+        Ok(self)
+    }
+    fn serialize_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStruct, Self::Error> {
+        Ok(self)
+    }
+    fn serialize_struct_variant(
+        self,
+        _name: &'static str,
+        variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant, Self::Error> {
+        self.0.write_u32(variant_index);
+        Ok(self)
+    }
+}
+
+// A helper that uses Serialize to feed into a Hasher without allocating a buffer:
+pub fn hash_with_serde_model<T: Serialize>(value: T) -> u64 {
+    let mut h = DefaultHasher::new();
+    let ser = HashSerializer(&mut h);
+    value.serialize(ser).expect("serialize to hasher failed");
+    h.finish()
+}

control-core/src/helpers/interpolation.rs

@@ -63,11 +63,11 @@ pub fn scale<T>(normalized_value: f64, new_min: T, new_max: T) -> T
 where
     T: Into<f64> + From<f64>,
 {
-    let normalized_value: f64 = normalized_value.into();
+    let normalized_value: f64 = normalized_value;
     let new_min: f64 = new_min.into();
     let new_max: f64 = new_max.into();
 
-    let result = normalized_value * (new_max - new_min) + new_min;
+    let result = normalized_value.mul_add(new_max - new_min, new_min);
     T::from(result)
 }
 
@@ -128,11 +128,11 @@ where
     // If we are under X we scale linearly from 0 to y
     // If we are over X we scale linearly from y to 1
     if value_f64 < x_f64 {
-        return normalize(value_f64, 0.0, x_f64) * y_f64;
+        normalize(value_f64, 0.0, x_f64) * y_f64
     } else if value_f64 > x_f64 {
-        return normalize(value_f64, x_f64, 1.0) * (1.0 - y_f64) + y_f64;
+        normalize(value_f64, x_f64, 1.0).mul_add(1.0 - y_f64, y_f64)
     } else {
-        return y_f64;
+        y_f64
     }
 }
 
@@ -273,7 +273,7 @@ pub fn interpolate_exponential(normalized_value: f64, steepness: f64) -> f64 {
         return normalized_value;
     }
     let numerator = steepness.exp().powf(normalized_value) - 1.0;
-    let denominator = steepness.exp() - 1.0;
+    let denominator = steepness.exp_m1();
 
     clip(numerator / denominator)
 }
@@ -414,7 +414,7 @@ pub fn interpolate_inflected_exponential(x: f64, steepness: f64) -> f64 {
 
         // Use standard exponential interpolation
         let result = interpolate_exponential(x_norm, steepness);
-        0.5 + 0.5 * result
+        0.5f64.mul_add(result, 0.5)
     }
 }
 

control-core/src/helpers/loop_trottle.rs

@@ -1,189 +0,0 @@
-use smol::Timer;
-use std::time::{Duration, Instant};
-use tracing::instrument;
-
-pub struct LoopThrottle {
-    target_cycle_time: Duration,
-    update_interval_cycles: usize,
-    window_start: Instant,
-    total_cycles: usize,
-    delay: Duration,
-    last_avg_cycle_time: Duration,
-    on_update: Option<Box<dyn Fn(LoopThrottleUpdate)>>,
-}
-
-pub struct LoopThrottleUpdate {
-    pub delay: Duration,
-    pub avg_cycle_time: Duration,
-    pub error: i128, // Error in nanoseconds
-}
-impl LoopThrottle {
-    pub fn new(
-        target_cycle_time: Duration,
-        update_interval_cycles: usize,
-        on_update: Option<Box<dyn Fn(LoopThrottleUpdate)>>,
-    ) -> Self {
-        Self {
-            target_cycle_time,
-            update_interval_cycles,
-            window_start: Instant::now(),
-            total_cycles: 0,
-            delay: target_cycle_time,
-            last_avg_cycle_time: target_cycle_time,
-            on_update,
-        }
-    }
-    #[instrument(skip_all)]
-    pub async fn sleep(&mut self) {
-        self.total_cycles += 1;
-
-        // Check if it's time to update (every N cycles)
-        if self.total_cycles % self.update_interval_cycles == 0 {
-            let actual_total_time = self.window_start.elapsed();
-
-            // Use integer arithmetic where possible
-            let avg_actual_cycle_time_nanos =
-                actual_total_time.as_nanos() / self.update_interval_cycles as u128;
-            let target_cycle_time_nanos = self.target_cycle_time.as_nanos();
-
-            // Calculate error in nanoseconds (signed)
-            let error_nanos = target_cycle_time_nanos as i128 - avg_actual_cycle_time_nanos as i128;
-
-            // Update current delay, allowing zero or negative values to become zero
-            let new_delay_nanos = (self.delay.as_nanos() as i128 + error_nanos).max(0) as u64;
-
-            self.delay = Duration::from_nanos(new_delay_nanos);
-            self.last_avg_cycle_time = Duration::from_nanos(avg_actual_cycle_time_nanos as u64);
-
-            // Reset for next measurement window
-            self.window_start = Instant::now();
-            self.total_cycles = 0; // Reset to prevent overflow
-
-            // if we have an update callback, call it
-            if let Some(on_update) = &self.on_update {
-                on_update(LoopThrottleUpdate {
-                    delay: self.delay,
-                    avg_cycle_time: self.last_avg_cycle_time,
-                    error: error_nanos,
-                });
-            }
-        }
-
-        Timer::after(self.delay).await;
-    }
-
-    pub fn get_cycle_time(&self) -> Duration {
-        self.last_avg_cycle_time
-    }
-
-    pub fn get_delay(&self) -> Duration {
-        self.delay
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use smol::block_on;
-
-    #[test]
-    fn test_adaptive_throttle_timing() {
-        block_on(async {
-            let update_interval_cycles = 100;
-            let target_cycle_time = Duration::from_micros(5);
-            let mut throttle = LoopThrottle::new(target_cycle_time, update_interval_cycles, None);
-
-            let test_start = Instant::now();
-            let mut cycle_times = Vec::new();
-
-            // Run for several cycles to trigger multiple updates
-            for _ in 0..10000 {
-                let cycle_start = Instant::now();
-
-                // Simulate some work
-                Timer::after(Duration::from_micros(5)).await;
-
-                throttle.sleep().await;
-
-                let cycle_time = cycle_start.elapsed();
-                cycle_times.push(cycle_time);
-            }
-
-            let total_test_time = test_start.elapsed();
-            let avg_cycle_time = cycle_times.iter().sum::<Duration>() / cycle_times.len() as u32;
-
-            println!("Test completed in: {:?}", total_test_time);
-            println!("Average cycle time: {:?}", avg_cycle_time);
-            println!("Target cycle time: {:?}", target_cycle_time);
-            println!("Last measured avg: {:?}", throttle.get_cycle_time());
-
-            // Assert that we're reasonably close to target timing
-            let tolerance = Duration::from_millis(10);
-            assert!(
-                avg_cycle_time >= target_cycle_time.saturating_sub(tolerance)
-                    && avg_cycle_time <= target_cycle_time + tolerance,
-                "Average cycle time {:?} not within tolerance of target {:?}",
-                avg_cycle_time,
-                target_cycle_time
-            );
-        });
-    }
-
-    #[test]
-    fn test_throttle_adaptation() {
-        block_on(async {
-            let target_cycle_time = Duration::from_millis(100);
-            let update_interval_cycles = 3;
-            let mut throttle = LoopThrottle::new(target_cycle_time, update_interval_cycles, None);
-
-            let initial_delay = throttle.get_delay();
-
-            // Run enough cycles to trigger multiple updates
-            for _ in 0..12 {
-                // Add variable work to test adaptation
-                Timer::after(Duration::from_millis(10)).await;
-                throttle.sleep().await;
-            }
-
-            println!("Initial delay: {:?}", initial_delay);
-            println!("Final delay: {:?}", throttle.get_delay());
-            println!("Last avg cycle time: {:?}", throttle.get_cycle_time());
-
-            assert!(throttle.get_cycle_time() > Duration::ZERO);
-        });
-    }
-
-    #[test]
-    fn test_throttle_initialization() {
-        let update_interval_cycles = 10;
-        let target_cycle_time = Duration::from_millis(75);
-        let throttle = LoopThrottle::new(target_cycle_time, update_interval_cycles, None);
-
-        assert_eq!(throttle.get_delay(), target_cycle_time);
-        assert_eq!(throttle.get_cycle_time(), target_cycle_time);
-        assert_eq!(throttle.total_cycles, 0);
-    }
-
-    #[test]
-    fn test_overflow_protection() {
-        block_on(async {
-            let target_cycle_time = Duration::from_micros(1);
-            let update_interval_cycles = 5;
-            let mut throttle = LoopThrottle::new(target_cycle_time, update_interval_cycles, None);
-
-            // Run many cycles to ensure total_cycles resets properly
-            for i in 0..50 {
-                throttle.sleep().await;
-
-                // Verify that total_cycles never exceeds update_interval_cycles
-                assert!(
-                    throttle.total_cycles <= update_interval_cycles,
-                    "Cycle {}: total_cycles ({}) exceeded update_interval_cycles ({})",
-                    i,
-                    throttle.total_cycles,
-                    update_interval_cycles
-                );
-            }
-        });
-    }
-}

control-core/src/helpers/mod.rs

@@ -1,6 +1,6 @@
 pub mod compare_lists;
+pub mod hasher_serializer;
 pub mod hashing;
 pub mod interpolation;
-pub mod loop_trottle;
 pub mod moving_time_window;
 pub mod retry;

control-core/src/helpers/moving_time_window.rs

@@ -11,56 +11,40 @@ pub trait DivideByCount {
 
 impl DivideByCount for f64 {
     fn divide_by_count(self, count: usize) -> Self {
-        self / (count as f64)
+        self / (count as Self)
     }
 }
 
 impl DivideByCount for f32 {
     fn divide_by_count(self, count: usize) -> Self {
-        self / (count as f32)
+        self / (count as Self)
     }
 }
 
 impl DivideByCount for i32 {
     fn divide_by_count(self, count: usize) -> Self {
-        self / (count as i32)
+        self / (count as Self)
     }
 }
 
 impl DivideByCount for i64 {
     fn divide_by_count(self, count: usize) -> Self {
-        self / (count as i64)
+        self / (count as Self)
     }
 }
 
 impl DivideByCount for u32 {
     fn divide_by_count(self, count: usize) -> Self {
-        self / (count as u32)
+        self / (count as Self)
     }
 }
 
 impl DivideByCount for u64 {
     fn divide_by_count(self, count: usize) -> Self {
-        self / (count as u64)
+        self / (count as Self)
     }
 }
 
-/// A generic moving time window that works with numeric types.
-///
-/// # Examples
-///
-/// ```rust
-/// use std::time::{Duration, Instant};
-/// use control_core::helpers::moving_time_window::MovingTimeWindow;
-///
-/// let mut window = MovingTimeWindow::new(Duration::from_secs(10), 100);
-/// window.update(1.5, Instant::now());
-/// window.update(2.5, Instant::now());
-///
-/// let average = window.average();
-/// println!("Average: {}", average);
-/// ```
-
 // Type aliases for common use cases
 pub type F64Window = MovingTimeWindow<f64>;
 pub type F32Window = MovingTimeWindow<f32>;
@@ -194,15 +178,14 @@ where
             .samples
             .iter()
             .map(|(v, _)| *v)
-            .fold(None, |acc, val| match acc {
-                None => Some(val),
-                Some(current_max) => {
+            .fold(None, |acc, val| {
+                acc.map_or(Some(val), |current_max| {
                     if val > current_max {
                         Some(val)
                     } else {
                         Some(current_max)
                     }
-                }
+                })
             })
             .unwrap_or_default();
 
@@ -229,15 +212,14 @@ where
             .samples
             .iter()
             .map(|(v, _)| *v)
-            .fold(None, |acc, val| match acc {
-                None => Some(val),
-                Some(current_min) => {
+            .fold(None, |acc, val| {
+                acc.map_or(Some(val), |current_min| {
                     if val < current_min {
                         Some(val)
                     } else {
                         Some(current_min)
                     }
-                }
+                })
             })
             .unwrap_or_default();
 

control-core/src/irq_handling.rs

@@ -0,0 +1,113 @@
+#[cfg(target_os = "linux")]
+use libc;
+use std::ffi::CString;
+use std::io;
+use std::str;
+
+#[cfg(target_os = "linux")]
+fn read_proc_interrupts() -> Result<String, io::Error> {
+    let path = CString::new("/proc/interrupts").unwrap();
+    // O_RDONLY
+    let fd = unsafe { libc::open(path.as_ptr(), libc::O_RDONLY) };
+    if fd < 0 {
+        return Err(io::Error::from_raw_os_error(-fd));
+    }
+
+    let mut buf: Vec<u8> = Vec::new();
+    let mut chunk = [0u8; 8192];
+
+    loop {
+        let n = unsafe { libc::read(fd, chunk.as_mut_ptr() as *mut _, chunk.len()) };
+        if n < 0 {
+            let e = io::Error::from_raw_os_error(-n as i32);
+            unsafe { libc::close(fd) };
+            return Err(e);
+        } else if n == 0 {
+            break;
+        } else {
+            buf.extend_from_slice(&chunk[..n as usize]);
+        }
+    }
+    unsafe { libc::close(fd) };
+    Ok(String::from_utf8_lossy(&buf).into_owned())
+}
+
+#[cfg(target_os = "linux")]
+fn get_interface_irq(proc_content: &str, interface_name: &str) -> Option<u32> {
+    for line in proc_content.lines() {
+        if line.contains(interface_name) {
+            if let Some(colon_pos) = line.find(':') {
+                let head = &line[..colon_pos].trim();
+                // try parse head as integer IRQ number
+                if let Ok(irq) = head.parse::<u32>() {
+                    return Some(irq);
+                }
+            }
+        }
+    }
+    None
+}
+
+/// Since kernel 3.0 it’s possible to use the /proc/irq/<IRQ-NUMBER>/smp_affinity_list
+/// With comma seperated values
+/// This function takes the irq identifier and writes the cpu string
+/// into /proc/irq/irq_number/smp_affinity_list
+#[cfg(target_os = "linux")]
+fn set_irq_affinity_raw(irq: u32, cpu: &str) -> Result<(), io::Error> {
+    let path: String = format!("/proc/irq/{}/smp_affinity_list", irq);
+    let cpath = CString::new(path.clone()).unwrap();
+    // We want to completely overwrite the smp affinities, so that we guarentee execution on the specified cores
+    let file_descriptor = unsafe { libc::open(cpath.as_ptr(), libc::O_WRONLY) };
+
+    if file_descriptor < 0 {
+        tracing::info!("Permission denied to write: {}", path);
+        return Err(io::Error::new(
+            io::ErrorKind::PermissionDenied,
+            format!("failed to open {}: errno {}", path, -file_descriptor),
+        ));
+    }
+    // convert to "raw bytes"
+    // cpu needs to be a string because we need the raw ascii code 48 = '0' and so on as bytes
+    let bytes = cpu.as_bytes();
+    let mut bytes_written_total = 0usize;
+
+    while bytes_written_total < bytes.len() {
+        let to_write = &bytes[bytes_written_total..];
+        let bytes_written = unsafe {
+            libc::write(
+                file_descriptor,
+                to_write.as_ptr() as *const _,
+                to_write.len(),
+            )
+        };
+        if bytes_written < 0 {
+            let e = io::Error::from_raw_os_error(-bytes_written as i32);
+            unsafe { libc::close(file_descriptor) };
+            return Err(e);
+        }
+        bytes_written_total += bytes_written as usize;
+    }
+    unsafe { libc::close(file_descriptor) };
+    Ok(())
+}
+
+/// This is used to make sure that a given irq handler runs on the expected cpu
+/// On Realtime systems this is the make or break fix for certain usecases like ethercrab
+/// On our machines the 99.99th percentile of cycle times was very bad ~5-11 ms while ethercat is supposed to be in the microseconds
+/// After pinning the ethernet irq to the core that the ethercat code ran on 99.99th percentile went down to ~200us (microseconds)
+/// Example input: irq_name: "eno1" , cpu: 2
+/// Remember that cpu cores are counted from 0
+#[cfg(target_os = "linux")]
+pub fn set_irq_affinity(irq_name: &str, cpu: u32) -> Result<(), anyhow::Error> {
+    let proc_contents = read_proc_interrupts()?;
+    let irq = get_interface_irq(&proc_contents, irq_name);
+    if irq.is_none() {
+        return Err(anyhow::anyhow!("Couldnt find irq number!"));
+    }
+    let res = set_irq_affinity_raw(irq.unwrap(), &cpu.to_string());
+    if res.is_err() {
+        return Err(anyhow::anyhow!("Couldnt write affinity list!"));
+    } else {
+        return Ok(());
+    }
+}

control-core/src/lib.rs

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

control-core/src/machines/connection.rs

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

control-core/src/machines/identification.rs

@@ -12,7 +12,7 @@ pub struct MachineIdentificationUnique {
 
 impl MachineIdentificationUnique {
     /// Check if values are non-zero
-    pub fn is_valid(&self) -> bool {
+    pub const fn is_valid(&self) -> bool {
         self.machine_identification.is_valid() && self.serial != 0
     }
 }
@@ -36,12 +36,12 @@ pub struct MachineIdentification {
 
 impl MachineIdentification {
     /// Check if values are non-zero
-    pub fn is_valid(&self) -> bool {
+    pub const fn is_valid(&self) -> bool {
         self.vendor != 0 && self.machine != 0
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct DeviceMachineIdentification {
     pub machine_identification_unique: MachineIdentificationUnique,
     pub role: u16,
@@ -49,7 +49,7 @@ pub struct DeviceMachineIdentification {
 
 impl DeviceMachineIdentification {
     /// Check if values are non-zero
-    pub fn is_valid(&self) -> bool {
+    pub const fn is_valid(&self) -> bool {
         self.machine_identification_unique.is_valid()
             && self
                 .machine_identification_unique
@@ -59,7 +59,7 @@ impl DeviceMachineIdentification {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct DeviceIdentification {
     pub device_machine_identification: Option<DeviceMachineIdentification>,
     pub device_hardware_identification: DeviceHardwareIdentification,
@@ -67,14 +67,14 @@ pub struct DeviceIdentification {
 
 impl From<DeviceIdentificationIdentified> for DeviceIdentification {
     fn from(value: DeviceIdentificationIdentified) -> Self {
-        DeviceIdentification {
+        Self {
             device_machine_identification: Some(value.device_machine_identification),
             device_hardware_identification: value.device_hardware_identification,
         }
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct DeviceIdentificationIdentified {
     pub device_machine_identification: DeviceMachineIdentification,
     pub device_hardware_identification: DeviceHardwareIdentification,
@@ -90,24 +90,24 @@ impl TryFrom<DeviceIdentification> for DeviceIdentificationIdentified {
                 module_path!()
             ))?;
 
-        Ok(DeviceIdentificationIdentified {
+        Ok(Self {
             device_machine_identification,
             device_hardware_identification: value.device_hardware_identification,
         })
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub enum DeviceHardwareIdentification {
     Ethercat(DeviceHardwareIdentificationEthercat),
     Serial(DeviceHardwareIdentificationSerial),
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct DeviceHardwareIdentificationEthercat {
     pub subdevice_index: usize,
 }
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct DeviceHardwareIdentificationSerial {
     pub path: String,
 }

control-core/src/machines/manager.rs

@@ -1,3 +1,9 @@
+use super::{
+    Machine,
+    identification::{DeviceIdentification, DeviceIdentificationIdentified},
+    new::MachineNewHardwareSerial,
+    registry::MachineRegistry,
+};
 use smol::{
     channel::Sender,
     lock::{Mutex, RwLock},
@@ -6,6 +12,9 @@ use socketioxide::extract::SocketRef;
 
 use crate::{
     machines::{
+        connection::{
+            MachineConnection, MachineConnectionGeneric, MachineSlot, MachineSlotGeneric,
+        },
         identification::MachineIdentificationUnique,
         new::{MachineNewHardware, MachineNewHardwareEthercat, MachineNewParams},
     },
@@ -17,18 +26,16 @@ use std::{
     sync::{Arc, Weak},
 };
 
-use super::{
-    Machine,
-    identification::{DeviceIdentification, DeviceIdentificationIdentified},
-    new::MachineNewHardwareSerial,
-    registry::MachineRegistry,
-};
 #[derive(Debug)]
 pub struct MachineManager {
-    pub ethercat_machines:
-        HashMap<MachineIdentificationUnique, Result<Arc<Mutex<dyn Machine>>, anyhow::Error>>,
-    pub serial_machines:
-        HashMap<MachineIdentificationUnique, Result<Arc<Mutex<dyn Machine>>, anyhow::Error>>,
+    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 {
@@ -45,11 +52,8 @@ impl MachineManager {
         machine_registry: &MachineRegistry,
         hardware: &MachineNewHardwareEthercat,
         socket_queue_tx: Sender<(SocketRef, Arc<GenericEvent>)>,
-        machine_manager: Weak<RwLock<MachineManager>>,
+        machine_manager: Weak<RwLock<Self>>,
     ) {
-        // empty ethercat machines
-        self.ethercat_machines.clear();
-
         // group devices by machine device identification
         let device_grouping_result = group_devices_by_identification(device_identifications);
 
@@ -63,10 +67,18 @@ impl MachineManager {
         // 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 = match device_group.first() {
-                Some(device_identification) => &device_identification.device_machine_identification,
-                None => continue, // Skip this group if empty
-            };
+            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 {
@@ -74,23 +86,40 @@ impl MachineManager {
                 hardware: &machine_new_hardware,
                 socket_queue_tx: socket_queue_tx.clone(),
                 machine_manager: machine_manager.clone(),
+                namespace: slot.namespace.clone(),
             });
 
-            // insert the machine into the ethercat machines map
-            self.ethercat_machines.insert(
-                machine_identification.machine_identification_unique.clone(),
-                new_machine,
-            );
+            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<&Result<Arc<Mutex<dyn Machine>>, anyhow::Error>> {
+    ) -> 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(
@@ -99,7 +128,7 @@ impl MachineManager {
         device: Arc<RwLock<dyn SerialDevice>>,
         machine_registry: &MachineRegistry,
         socket_queue_tx: Sender<(SocketRef, Arc<GenericEvent>)>,
-        machine_manager: Weak<RwLock<MachineManager>>,
+        machine_manager: Weak<RwLock<Self>>,
     ) {
         let hardware = MachineNewHardwareSerial { device };
 
@@ -109,21 +138,28 @@ impl MachineManager {
                 .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(),
         });
 
-        tracing::info!("Adding serial machine {:?}", new_machine);
+        slot.machine_connection = match new_machine {
+            Err(err) => MachineConnectionGeneric::Error(err),
+            Ok(machine) => MachineConnectionGeneric::Connected(machine),
+        };
 
-        self.serial_machines.insert(
-            device_identification_identified
-                .device_machine_identification
-                .machine_identification_unique,
-            new_machine,
-        );
+        tracing::info!("Adding serial machine {:?}", slot);
     }
 
     pub fn remove_serial_device(&mut self, device_identification: &DeviceIdentification) {
@@ -138,53 +174,45 @@ impl MachineManager {
             device_identification_identified
         );
 
-        self.serial_machines.remove(
-            &device_identification_identified
-                .device_machine_identification
-                .machine_identification_unique,
-        );
+        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_machine_weak(
+    pub fn get_ethercat_weak(
         &self,
         machine_identification: &MachineIdentificationUnique,
     ) -> Option<Weak<Mutex<dyn Machine>>> {
-        let machine = self.ethercat_machines.get(machine_identification);
-        let machine = match machine {
-            Some(machine) => machine,
-            None => {
-                return None;
-            }
-        };
-        let machine = match machine {
-            Ok(machine) => machine,
-            Err(_) => {
-                return None;
-            }
-        };
-        let machine_weak = Arc::downgrade(machine);
-        return Some(machine_weak);
+        self.get_weak(&self.ethercat_machines, machine_identification)
     }
 
     pub fn get_serial_weak(
         &self,
         machine_identification: &MachineIdentificationUnique,
     ) -> Option<Weak<Mutex<dyn Machine>>> {
-        let machine = self.serial_machines.get(machine_identification);
-        let machine = match machine {
-            Some(machine) => machine,
-            None => {
-                return None;
+        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)),
             }
-        };
-        let machine = match machine {
-            Ok(machine) => machine,
-            Err(_) => {
-                return None;
-            }
-        };
-        let machine_weak = Arc::downgrade(machine);
-        return Some(machine_weak);
+        });
     }
 }
 

control-core/src/machines/manager_iter.rs

@@ -1,22 +1,25 @@
-use std::{collections::HashMap, sync::Arc};
+use std::collections::HashMap;
+use std::sync::Arc;
 
 use smol::lock::Mutex;
 
-use super::{Machine, identification::MachineIdentificationUnique, manager::MachineManager};
+use crate::machines::connection::MachineSlotGeneric;
+
+use super::{identification::MachineIdentificationUnique, manager::MachineManager};
 
 pub enum MachineManagerIter<'a> {
     EthercatMachines {
         iter: std::collections::hash_map::Iter<
             'a,
             MachineIdentificationUnique,
-            Result<Arc<Mutex<dyn Machine>>, anyhow::Error>,
+            Arc<Mutex<MachineSlotGeneric>>,
         >,
     },
     SerialMachines {
         iter: std::collections::hash_map::Iter<
             'a,
             MachineIdentificationUnique,
-            Result<Arc<Mutex<dyn Machine>>, anyhow::Error>,
+            Arc<Mutex<MachineSlotGeneric>>,
         >,
     },
     Done,
@@ -24,14 +27,13 @@ pub enum MachineManagerIter<'a> {
 
 pub struct MachineManagerIterator<'a> {
     iter: MachineManagerIter<'a>,
-    serial_machines:
-        &'a HashMap<MachineIdentificationUnique, Result<Arc<Mutex<dyn Machine>>, anyhow::Error>>,
+    serial_machines: &'a HashMap<MachineIdentificationUnique, Arc<Mutex<MachineSlotGeneric>>>,
 }
 
 impl<'a> Iterator for MachineManagerIterator<'a> {
     type Item = (
         &'a MachineIdentificationUnique,
-        &'a Result<Arc<Mutex<dyn Machine>>, anyhow::Error>,
+        &'a Arc<Mutex<MachineSlotGeneric>>,
     );
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -71,7 +73,7 @@ impl<'a> Iterator for MachineManagerIterator<'a> {
 
 impl MachineManager {
     // Returns an iterator over all machines (both ethercat and serial)
-    pub fn iter(&self) -> MachineManagerIterator {
+    pub fn iter(&self) -> MachineManagerIterator<'_> {
         MachineManagerIterator {
             iter: MachineManagerIter::EthercatMachines {
                 iter: self.ethercat_machines.iter(),

control-core/src/machines/mod.rs

@@ -1,80 +1,23 @@
-use anyhow::anyhow;
-use api::MachineApi;
 use new::MachineNewTrait;
-use serde::Serialize;
-use smol::lock::Mutex;
 use std::any::Any;
 use std::fmt::Debug;
-use std::sync::{Arc, Weak};
 
-use crate::machines::identification::MachineIdentificationUnique;
-use crate::machines::new::MachineAct;
+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 {
+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;
-}
-/// Casts a `dyn Machine` to a specific machine type
-pub async fn downcast_machine<T: Machine>(
-    machine: Arc<Mutex<dyn Machine>>,
-) -> Result<Arc<Mutex<T>>, anyhow::Error> {
-    // Acquire a read lock on the RwLock
-    let read_lock = machine.lock().await;
-
-    // Check if the inner type can be downcasted to T
-    if read_lock.as_any().is::<T>() {
-        // Clone the Arc and return it as the desired type
-        let cloned_machine = Arc::clone(&machine);
-        // Transmute the Arc to the desired type
-        unsafe {
-            Ok(Arc::from_raw(
-                Arc::into_raw(cloned_machine) as *const Mutex<T>
-            ))
-        }
-    } else {
-        Err(anyhow!(
-            "[{}::downcast_machine] Downcast failed",
-            module_path!()
-        ))
-    }
-}
-
-/// Trait to get strong count to see if Weak has reference
-pub trait GetStrongCount {
-    fn get_strong_count(&self) -> usize;
-}
-
-impl<T> GetStrongCount for Weak<Mutex<T>> {
-    fn get_strong_count(&self) -> usize {
-        self.strong_count()
-    }
-}
-
-#[derive(Debug)]
-pub struct ConnectedMachine<T: GetStrongCount> {
-    pub machine_identification_unique: MachineIdentificationUnique,
-    pub machine: T,
-}
-
-#[derive(Serialize, Debug, Clone, PartialEq)]
-pub struct ConnectedMachineData {
-    pub machine_identification_unique: MachineIdentificationUnique,
-    pub is_available: bool,
-}
-
-impl<T> From<&ConnectedMachine<T>> for ConnectedMachineData
-where
-    T: GetStrongCount,
-{
-    fn from(value: &ConnectedMachine<T>) -> Self {
-        Self {
-            machine_identification_unique: value.machine_identification_unique.clone(),
-            is_available: value.machine.get_strong_count() != 0,
-        }
-    }
+    fn as_any_mut(&mut self) -> &mut dyn Any;
 }

control-core/src/machines/new.rs

@@ -1,4 +1,8 @@
-use crate::{machines::manager::MachineManager, serial::SerialDevice};
+use crate::{
+    machines::{identification::MachineIdentificationUnique, manager::MachineManager},
+    serial::SerialDevice,
+    socketio::namespace::Namespace,
+};
 
 use super::identification::DeviceIdentificationIdentified;
 use anyhow::Error;
@@ -6,10 +10,12 @@ use ethercat_hal::{
     devices::EthercatDevice, helpers::ethercrab_types::EthercrabSubDevicePreoperational,
 };
 use ethercrab::{SubDevice, SubDeviceRef};
-use smol::{channel::Sender, lock::RwLock};
+use smol::{
+    channel::Sender,
+    lock::{Mutex, RwLock},
+};
 use socketioxide::extract::SocketRef;
 use std::{
-    pin::Pin,
     sync::{Arc, Weak},
     time::Instant,
 };
@@ -17,15 +23,13 @@ use std::{
 use crate::socketio::event::GenericEvent;
 
 pub trait MachineNewTrait {
-    fn new<'maindevice, 'subdevices>(
-        params: &MachineNewParams<'maindevice, 'subdevices, '_, '_, '_, '_, '_>,
-    ) -> Result<Self, Error>
+    fn new(params: &MachineNewParams<'_, '_, '_, '_, '_, '_, '_>) -> Result<Self, Error>
     where
         Self: Sized;
 }
 
 pub trait MachineAct {
-    fn act(&mut self, now: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>>;
+    fn act(&mut self, now: Instant);
 }
 
 pub struct MachineNewParams<
@@ -52,6 +56,19 @@ pub struct MachineNewParams<
     >,
     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<

control-core/src/machines/registry.rs

@@ -10,6 +10,12 @@ 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 {
@@ -24,7 +30,7 @@ impl MachineRegistry {
         self.type_map.insert(
             TypeId::of::<T>(),
             (
-                machine_identficiation,
+                machine_identficiation.clone(),
                 // create a machine construction closure
                 Box::new(|machine_new_params| {
                     Ok(Arc::new(Mutex::new(T::new(machine_new_params)?)))

control-core/src/modbus/mod.rs

@@ -2,10 +2,10 @@ pub mod modbus_serial_interface;
 
 use anyhow::Error;
 use crc::{CRC_16_MODBUS, Crc};
-use serial;
+use serialport::SerialPort;
 use std::time::Duration;
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ParityType {
     Even,
     Odd,
@@ -62,17 +62,17 @@ impl From<ModbusExceptionCode> for u8 {
 impl From<u8> for ModbusExceptionCode {
     fn from(value: u8) -> Self {
         match value {
-            0 => ModbusExceptionCode::None,
-            1 => ModbusExceptionCode::IllegalFunction,
-            2 => ModbusExceptionCode::IllegalDataAddress,
-            3 => ModbusExceptionCode::IllegalDataValue,
-            4 => ModbusExceptionCode::SlaveDeviceFailure,
-            5 => ModbusExceptionCode::Acknowledge,
-            6 => ModbusExceptionCode::SlaveDeviceBusy,
-            8 => ModbusExceptionCode::MemoryParityError,
-            10 => ModbusExceptionCode::GatewayPathUnavailable,
-            11 => ModbusExceptionCode::GatewayTargetDeviceFailedToRespond,
-            other => ModbusExceptionCode::Unknown(other),
+            0 => Self::None,
+            1 => Self::IllegalFunction,
+            2 => Self::IllegalDataAddress,
+            3 => Self::IllegalDataValue,
+            4 => Self::SlaveDeviceFailure,
+            5 => Self::Acknowledge,
+            6 => Self::SlaveDeviceBusy,
+            8 => Self::MemoryParityError,
+            10 => Self::GatewayPathUnavailable,
+            11 => Self::GatewayTargetDeviceFailedToRespond,
+            other => Self::Unknown(other),
         }
     }
 }
@@ -97,10 +97,10 @@ impl TryFrom<u8> for ModbusFunctionCode {
 
     fn try_from(value: u8) -> Result<Self, Self::Error> {
         match value {
-            0x03 => Ok(ModbusFunctionCode::ReadHoldingRegister),
-            0x04 => Ok(ModbusFunctionCode::ReadInputRegister),
-            0x06 => Ok(ModbusFunctionCode::PresetHoldingRegister),
-            0x08 => Ok(ModbusFunctionCode::DiagnoseFunction),
+            0x03 => Ok(Self::ReadHoldingRegister),
+            0x04 => Ok(Self::ReadInputRegister),
+            0x06 => Ok(Self::PresetHoldingRegister),
+            0x08 => Ok(Self::DiagnoseFunction),
             _ => Err(anyhow::anyhow!("Error: Modbus Function Code doesnt exist!")),
         }
     }
@@ -119,7 +119,7 @@ impl From<ModbusFunctionCode> for u8 {
 
 impl From<ModbusRequest> for Vec<u8> {
     fn from(request: ModbusRequest) -> Self {
-        let mut buffer = Vec::new();
+        let mut buffer = Self::new();
 
         buffer.push(request.slave_id);
         buffer.push(request.function_code.into()); // convert functioncode into u8 and push it
@@ -132,7 +132,7 @@ impl From<ModbusRequest> for Vec<u8> {
         // convert u16 value to le_bytes and add it to the end of the frame
         buffer.extend_from_slice(&result_crc.to_le_bytes());
 
-        return buffer;
+        buffer
     }
 }
 /// Reads data from a Modbus device via a serial port.
@@ -143,9 +143,7 @@ impl From<ModbusRequest> for Vec<u8> {
 /// # Returns
 /// A `Result` containing an `Option` with the raw Modbus response as a `Vec<u8>` if successful,
 /// or `None` if the response is invalid or an error occurs.
-pub fn receive_data_modbus(
-    port: &mut dyn serial::SerialPort,
-) -> Result<Option<Vec<u8>>, anyhow::Error> {
+pub fn receive_data_modbus(port: &mut dyn SerialPort) -> Result<Option<Vec<u8>>, anyhow::Error> {
     let mut buf: [u8; 256] = [0; 256];
     let data_length = port.read(&mut buf)?;
     if data_length == 0 {
@@ -155,7 +153,7 @@ pub fn receive_data_modbus(
 }
 
 /// Computes Modbus CRC-16 using `crc` crate.
-pub fn modbus_crc16(data: &[u8]) -> u16 {
+pub const fn modbus_crc16(data: &[u8]) -> u16 {
     let modbus: Crc<u16> = Crc::<u16>::new(&CRC_16_MODBUS);
     modbus.checksum(data)
 }
@@ -206,23 +204,17 @@ fn extract_crc(raw_data: &Vec<u8>) -> Result<u16, Error> {
 }
 impl TryFrom<Vec<u8>> for ModbusResponse {
     type Error = anyhow::Error;
-    fn try_from(value: Vec<u8>) -> Result<ModbusResponse, Error> {
-        let crc = match extract_crc(&value) {
-            Ok(crc_value) => crc_value,
-            Err(err) => return Err(err),
-        };
+    fn try_from(value: Vec<u8>) -> Result<Self, Error> {
+        let crc = extract_crc(&value)?;
 
         let function_code_res = ModbusFunctionCode::try_from(value[1]);
-        let function_code = match function_code_res {
-            Ok(code) => code,
-            Err(err) => return Err(err),
-        };
+        let function_code = function_code_res?;
 
-        Ok(ModbusResponse {
+        Ok(Self {
             slave_id: value[0],
-            function_code: function_code,
+            function_code,
             data: value[2..value.len() - 2].to_vec(), // get data without the crc
-            crc: crc,
+            crc,
         })
     }
 }
@@ -234,23 +226,23 @@ impl TryFrom<Vec<u8>> for ModbusResponse {
 /// machine_operation_delay_nano: Delay for the given operation in nanoseconds as specified by the slaves datasheet (example: mitsubishi csfr84 has 12ms for read write in RAM)
 /// baudrate: bits per second
 /// message_size: size of original message in bytes
-pub fn calculate_modbus_rtu_timeout(
+pub const fn calculate_modbus_rtu_timeout(
     bits: u8,
     machine_operation_delay_nano: Duration,
     baudrate: u32,
     message_size: usize,
 ) -> Duration {
     let nanoseconds_per_bit: u64 = (1000000 / baudrate) as u64;
-    let nanoseconds_per_byte: u64 = bits as u64 * nanoseconds_per_bit as u64;
+    let nanoseconds_per_byte: u64 = bits as u64 * nanoseconds_per_bit;
 
     let transmission_timeout: u64 = nanoseconds_per_byte * message_size as u64;
-    let silent_time: u64 = (nanoseconds_per_byte * (35)) / 10 as u64; // silent_time is 3.5x of character length,which is 11 bit for 8E1
+    let silent_time: u64 = (nanoseconds_per_byte * (35)) / 10_u64; // silent_time is 3.5x of character length,which is 11 bit for 8E1
 
     let mut full_timeout: u64 = transmission_timeout;
     full_timeout += machine_operation_delay_nano.as_nanos() as u64;
     full_timeout += silent_time;
 
-    return Duration::from_nanos(full_timeout);
+    Duration::from_nanos(full_timeout)
 }
 
 #[cfg(test)]

control-core/src/modbus/modbus_serial_interface.rs

@@ -66,7 +66,7 @@ impl ModbusSerialInterface {
         }
     }
 
-    pub fn is_initialized(&self) -> bool {
+    pub const fn is_initialized(&self) -> bool {
         !matches!(self.state, State::Uninitialized)
     }
 
@@ -199,7 +199,7 @@ impl ModbusSerialInterface {
         Some(Duration::from_nanos(total_timeout))
     }
 
-    pub fn get_response(&self) -> Option<&ModbusResponse> {
+    pub const fn get_response(&self) -> Option<&ModbusResponse> {
         self.response.as_ref()
     }
 

control-core/src/realtime.rs

@@ -1,7 +1,7 @@
 use tracing::debug;
 use tracing::error;
 
-#[cfg(unix)]
+#[cfg(target_os = "linux")]
 /// Makes the current thread a real-time thread using the PREEMPT_RT capabilities of Linux.
 ///
 /// This function configures the current thread with real-time scheduling properties by:
@@ -47,7 +47,7 @@ use tracing::error;
 ///
 /// - `Ok(())` if the real-time priority was successfully set
 /// - `Err` with the error message if setting the priority failed
-#[cfg(unix)]
+#[cfg(target_os = "linux")]
 pub fn set_realtime_priority() -> Result<(), anyhow::Error> {
     use anyhow::anyhow;
     use libc::{SCHED_FIFO, pthread_setschedparam, sched_param};
@@ -84,9 +84,9 @@ pub fn set_realtime_priority() -> Result<(), anyhow::Error> {
     Ok(())
 }
 
-#[cfg(not(unix))]
+#[cfg(not(target_os = "linux"))]
 pub fn set_realtime_priority() -> Result<(), anyhow::Error> {
-    log::error!("This platform does not support realtime threads");
+    tracing::error!("This platform does not support realtime threads");
     Ok(())
 }
 
@@ -137,7 +137,7 @@ pub fn set_realtime_priority() -> Result<(), anyhow::Error> {
 /// # How it works
 ///
 /// [Rest of documentation as before...]
-#[cfg(unix)]
+#[cfg(target_os = "linux")]
 pub fn lock_memory() -> Result<(), Box<dyn std::error::Error>> {
     use libc::{MCL_FUTURE, mlockall};
 
@@ -154,9 +154,9 @@ pub fn lock_memory() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
-#[cfg(not(unix))]
+#[cfg(not(target_os = "linux"))]
 pub fn lock_memory() -> Result<(), Box<dyn std::error::Error>> {
-    log::error!("This platform does not support memory locking");
+    tracing::error!("This platform does not support memory locking");
     Ok(())
 }
 

control-core/src/rest/mutation.rs

@@ -11,13 +11,13 @@ pub struct MutationResponse {
 }
 
 impl MutationResponse {
-    pub fn success() -> Self {
+    pub const fn success() -> Self {
         Self {
             success: true,
             error: None,
         }
     }
-    pub fn error(error: String) -> Self {
+    pub const fn error(error: String) -> Self {
         Self {
             success: false,
             error: Some(error),
@@ -33,3 +33,19 @@ where
     pub machine_identification_unique: MachineIdentificationUnique,
     pub data: T,
 }
+
+#[derive(Debug, serde::Deserialize)]
+pub struct MachineVideoStreamListBody {
+    pub machine_identification_unique: MachineIdentificationUnique,
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub struct MachineVideoStreamBody {
+    pub machine_identification_unique: MachineIdentificationUnique,
+    pub stream_id: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct VideoStreamListResponse {
+    pub streams: Vec<String>,
+}

control-core/src/serial/mod.rs

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

control-core/src/serial/panic.rs

@@ -1,11 +1,13 @@
 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<(T, anyhow::Error)>,
+    thread_panic_tx: Sender<SerialDeviceRemoval<T>>,
 ) where
     T: Send + Sync + Clone + 'static,
 {
@@ -16,7 +18,6 @@ pub fn send_serial_device_panic<T>(
         }
     }
 
-    let device_id_clone = device_identifier.clone();
     std::panic::set_hook(Box::new(move |panic_info| {
         let thread_name = std::thread::current()
             .name()
@@ -39,8 +40,8 @@ pub fn send_serial_device_panic<T>(
         // Send device panic info through channel
         smol::block_on(async {
             let _ = thread_panic_tx
-                .send((
-                    device_id_clone.clone(),
+                .send(SerialDeviceRemoval::Error(
+                    device_identifier.clone(),
                     anyhow::anyhow!("{}", panic_message),
                 ))
                 .await;

control-core/src/serial/registry.rs

@@ -20,6 +20,12 @@ pub struct SerialDeviceRegistry {
     pub type_map: HashMap<TypeId, (SerialDeviceIdentification, SerialDeviceNewClosure)>,
 }
 
+impl Default for SerialDeviceRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl SerialDeviceRegistry {
     pub fn new() -> Self {
         Self {

control-core/src/serial/serial_detection.rs

@@ -21,6 +21,11 @@ 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<
@@ -31,14 +36,13 @@ pub struct SerialDetection<'serialdeviceregistry> {
             Arc<RwLock<dyn SerialDevice>>,
         ),
     >,
-    pub device_removal_signal_rx: Receiver<(String, anyhow::Error)>,
-    pub device_removal_signal_tx: Sender<(String, anyhow::Error)>,
+    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::<(String, anyhow::Error)>();
+        let (device_removal_signal_tx, device_removal_signal_rx) = unbounded();
         SerialDetection {
             serial_device_registry,
             ports: HashMap::new(),
@@ -78,15 +82,12 @@ impl<'serialdeviceregistry> SerialDetection<'serialdeviceregistry> {
         let mut usb_ports: Vec<(String, UsbPortInfo)> = Vec::new();
 
         for port in port_list {
-            match &port.port_type {
-                SerialPortType::UsbPort(usb_info) => {
-                    usb_ports.push((port.port_name.to_string(), usb_info.clone()));
-                }
-                _ => {}
+            if let SerialPortType::UsbPort(usb_info) = &port.port_type {
+                usb_ports.push((port.port_name.to_string(), usb_info.clone()));
             };
         }
 
-        return usb_ports;
+        usb_ports
     }
 
     pub async fn check_ports(&mut self) -> CheckPortsResult {
@@ -158,18 +159,36 @@ impl<'serialdeviceregistry> SerialDetection<'serialdeviceregistry> {
 
     pub async fn check_remove_signals(&mut self) -> Vec<DeviceIdentification> {
         let mut removed_signals: Vec<DeviceIdentification> = Vec::new();
-        match self.device_removal_signal_rx.try_recv() {
-            Ok((path, error)) => {
-                // remove the device when the tuple positon 1 equals signal
-                if let Some(info) = self.ports.get(&path.clone()) {
-                    removed_signals.push(info.1.clone());
-                };
-                self.ports.remove(&path);
 
-                tracing::trace!("Removed device: {:?}: {}", path, error);
-            }
-            Err(_) => {}
+        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);
+            }
+        }
+
         removed_signals
     }
 }

control-core/src/socketio/event.rs

@@ -21,6 +21,10 @@ impl std::fmt::Debug for GenericEvent {
     }
 }
 
+pub trait BuildEvent: Serialize + Send + Sync + Clone {
+    fn build(&self) -> Event<Self>;
+}
+
 #[derive(Debug, Clone, Serialize)]
 pub struct Event<T>
 where

control-core/src/socketio/namespace.rs

@@ -30,7 +30,7 @@ impl Namespace {
     #[instrument(skip_all)]
     pub fn subscribe(&mut self, socket: SocketRef) {
         // add the socket to the list
-        self.sockets.push(socket.clone());
+        self.sockets.push(socket);
     }
 
     /// Removes a socket from the namespace.
@@ -81,7 +81,7 @@ impl Namespace {
         for (_event_name, events) in event_groups {
             for event in events {
                 // Send to global queue instead of per-socket queue
-                self.send_to_queue(&socket, &event, "reemit");
+                self.send_to_queue(&socket, event, "reemit");
             }
         }
     }
@@ -97,13 +97,10 @@ impl Namespace {
     fn cache(
         &mut self,
         event: Arc<GenericEvent>,
-        buffer_fn: &Box<dyn Fn(&mut Vec<Arc<GenericEvent>>, &Arc<GenericEvent>) -> ()>,
+        buffer_fn: &Box<dyn Fn(&mut Vec<Arc<GenericEvent>>, &Arc<GenericEvent>)>,
     ) {
-        let mut cached_events_for_key = self
-            .events
-            .entry(event.name.clone())
-            .or_insert_with(Vec::new);
-        buffer_fn(&mut cached_events_for_key, &event);
+        let cached_events_for_key = self.events.entry(event.name.clone()).or_default();
+        buffer_fn(cached_events_for_key, &event);
     }
 
     /// Emits an event to all sockets in the namespace and caches it.
@@ -117,10 +114,10 @@ impl Namespace {
     pub fn emit(
         &mut self,
         event: Arc<GenericEvent>,
-        buffer_fn: &Box<dyn Fn(&mut Vec<Arc<GenericEvent>>, &Arc<GenericEvent>) -> ()>,
+        buffer_fn: &Box<dyn Fn(&mut Vec<Arc<GenericEvent>>, &Arc<GenericEvent>)>,
     ) {
         // cache the event
-        self.cache(event.clone(), &buffer_fn);
+        self.cache(event.clone(), buffer_fn);
 
         // emit the event - inlined from emit function
         // Send to global queue for each socket in the namespace
@@ -191,7 +188,7 @@ pub trait CacheableEvents<Events> {
     fn event_cache_fn(&self) -> CacheFn;
 }
 
-pub type CacheFn = Box<dyn Fn(&mut Vec<Arc<GenericEvent>>, &Arc<GenericEvent>) -> ()>;
+pub type CacheFn = Box<dyn Fn(&mut Vec<Arc<GenericEvent>>, &Arc<GenericEvent>)>;
 
 /// [`BufferFn`] that stores the last n events
 pub fn cache_n_events(n: usize) -> CacheFn {
@@ -223,7 +220,6 @@ pub fn cache_first_and_last_event() -> CacheFn {
         if events.len() == 2 {
             events.remove(1);
             events.push(event.clone());
-            return;
         }
     })
 }

control-core/src/socketio/namespace_id.rs

@@ -17,8 +17,8 @@ impl Serialize for NamespaceId {
         S: Serializer,
     {
         match self {
-            NamespaceId::Main => serializer.serialize_str("/main"),
-            NamespaceId::Machine(id) => {
+            Self::Main => serializer.serialize_str("/main"),
+            Self::Machine(id) => {
                 let path = format!(
                     "/machine/{}/{}/{}",
                     id.machine_identification.vendor, id.machine_identification.machine, id.serial
@@ -36,7 +36,7 @@ impl<'de> Deserialize<'de> for NamespaceId {
     {
         struct NamespaceIdVisitor;
 
-        impl<'de> Visitor<'de> for NamespaceIdVisitor {
+        impl Visitor<'_> for NamespaceIdVisitor {
             type Value = NamespaceId;
 
             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -85,7 +85,7 @@ impl FromStr for NamespaceId {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         if s == "/main" {
-            return Ok(NamespaceId::Main);
+            return Ok(Self::Main);
         }
 
         if let Some(machine_path) = s.strip_prefix("/machine/") {
@@ -101,7 +101,7 @@ impl FromStr for NamespaceId {
                     .parse::<u16>()
                     .map_err(|_| "Invalid serial id".to_string())?;
 
-                return Ok(NamespaceId::Machine(MachineIdentificationUnique {
+                return Ok(Self::Machine(MachineIdentificationUnique {
                     machine_identification: MachineIdentification { vendor, machine },
                     serial,
                 }));
@@ -116,8 +116,8 @@ impl FromStr for NamespaceId {
 impl fmt::Display for NamespaceId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            NamespaceId::Main => write!(f, "/main"),
-            NamespaceId::Machine(id) => {
+            Self::Main => write!(f, "/main"),
+            Self::Machine(id) => {
                 write!(
                     f,
                     "/machine/{}/{}/{}",

control-core/src/transmission/fixed.rs

@@ -0,0 +1,27 @@
+use crate::transmission::Transmission;
+
+#[derive(Debug, Clone)]
+pub struct FixedTransmission {
+    ratio: f64,
+}
+
+impl Transmission for FixedTransmission {
+    fn get_ratio(&self) -> f64 {
+        self.ratio
+    }
+}
+
+impl FixedTransmission {
+    /// Creates a new FixedTransmission with the specified ratio.
+    ///
+    /// # Arguments
+    ///
+    /// * `ratio` - The transmission ratio (output over input).
+    ///
+    /// # Returns
+    ///
+    /// A new instance of FixedTransmission.
+    pub const fn new(ratio: f64) -> Self {
+        Self { ratio }
+    }
+}

control-core/src/transmission/mod.rs

@@ -0,0 +1,95 @@
+use uom::si::{
+    angle::radian,
+    angular_velocity::radian_per_second,
+    f64::{Angle, AngularVelocity, Length, Velocity},
+    length::meter,
+    velocity::meter_per_second,
+};
+
+pub mod fixed;
+
+/// A trait representing a mechanical transmission system that converts input to output
+/// with a specific gear ratio.
+///
+/// This trait provides methods for working with transmission ratios and converting
+/// between input and output values based on the transmission's gear ratio.
+pub trait Transmission {
+    /// Returns the transmission ratio of this transmission system.
+    ///
+    /// The ratio represents the relationship between input and output speeds/torques.
+    /// A ratio greater than 1.0 indicates speed reduction (torque multiplication),
+    /// while a ratio less than 1.0 indicates speed increase (torque reduction).
+    ///
+    /// # Returns
+    ///
+    /// The transmission ratio as a floating-point number.
+    fn get_ratio(&self) -> f64;
+
+    /// Converts an input value to the corresponding output value using the transmission ratio.
+    ///
+    /// This method multiplies the input by the transmission ratio to calculate the output.
+    /// Typically used for converting input speed to output speed in a transmission system.
+    ///
+    /// # Arguments
+    ///
+    /// * `input` - The input value to be converted
+    ///
+    /// # Returns
+    ///
+    /// The output value after applying the transmission ratio.
+    fn calculate_output(&self, input: f64) -> f64 {
+        input * self.get_ratio()
+    }
+
+    /// Converts an output value to the corresponding input value using the transmission ratio.
+    ///
+    /// This method divides the output by the transmission ratio to calculate the required input.
+    /// Typically used for determining what input is needed to achieve a desired output.
+    ///
+    /// # Arguments
+    ///
+    /// * `output` - The output value to be converted back to input
+    ///
+    /// # Returns
+    ///
+    /// The input value required to produce the given output.
+    fn calculate_input(&self, output: f64) -> f64 {
+        output / self.get_ratio()
+    }
+
+    fn calculate_angular_output(&self, input: Angle) -> Angle {
+        Angle::new::<radian>(self.calculate_output(input.get::<radian>()))
+    }
+
+    fn calculate_angular_input(&self, output: Angle) -> Angle {
+        Angle::new::<radian>(self.calculate_input(output.get::<radian>()))
+    }
+
+    fn calculate_angular_velocity_output(&self, input: AngularVelocity) -> AngularVelocity {
+        AngularVelocity::new::<radian_per_second>(
+            self.calculate_output(input.get::<radian_per_second>()),
+        )
+    }
+
+    fn calculate_angular_velocity_input(&self, output: AngularVelocity) -> AngularVelocity {
+        AngularVelocity::new::<radian_per_second>(
+            self.calculate_input(output.get::<radian_per_second>()),
+        )
+    }
+
+    fn calculate_linear_output(&self, input: Length) -> Length {
+        Length::new::<meter>(self.calculate_output(input.get::<meter>()))
+    }
+
+    fn calculate_linear_input(&self, output: Length) -> Length {
+        Length::new::<meter>(self.calculate_input(output.get::<meter>()))
+    }
+
+    fn calculate_linear_velocity_output(&self, input: Velocity) -> Velocity {
+        Velocity::new::<meter_per_second>(self.calculate_output(input.get::<meter_per_second>()))
+    }
+
+    fn calculate_linear_velocity_input(&self, output: Velocity) -> Velocity {
+        Velocity::new::<meter_per_second>(self.calculate_input(output.get::<meter_per_second>()))
+    }
+}

control-core/src/video_streaming/mod.rs

@@ -0,0 +1,208 @@
+use anyhow::Error;
+use std::collections::HashMap;
+use tokio::sync::broadcast;
+
+/// Video stream manager that handles multiple video streams per machine with true broadcasting
+/// Uses tokio broadcast channels to ensure all subscribers receive all messages without stealing
+#[derive(Debug)]
+pub struct VideoStreamManager {
+    /// Each stream has its own broadcast transmitter and template receiver
+    streams: HashMap<String, (broadcast::Sender<Vec<u8>>, broadcast::Receiver<Vec<u8>>)>,
+}
+
+impl VideoStreamManager {
+    pub fn new() -> Self {
+        Self {
+            streams: HashMap::new(),
+        }
+    }
+
+    /// Send a frame to all subscribers of a stream
+    /// Returns Ok if the frame was sent, Err if the stream doesn't exist
+    pub fn send_frame(&self, stream_id: &str, frame: Vec<u8>) -> Result<(), Error> {
+        if let Some((tx, _rx)) = self.streams.get(stream_id) {
+            match tx.send(frame) {
+                Ok(_) => Ok(()),
+                Err(_) => Ok(()), // No receivers, but that's not an error
+            }
+        } else {
+            Err(anyhow::anyhow!("Stream '{}' not found", stream_id))
+        }
+    }
+
+    /// Register a new video stream with the given ID
+    pub fn add_stream(&mut self, stream_id: String) {
+        let (tx, rx) = broadcast::channel::<Vec<u8>>(256); // 256 frame buffer capacity
+        self.streams.insert(stream_id, (tx, rx));
+    }
+
+    /// Get list of available stream IDs
+    pub fn get_streams(&self) -> Vec<String> {
+        self.streams.keys().cloned().collect()
+    }
+
+    /// Check if a stream exists
+    pub fn has_stream(&self, stream_id: &str) -> bool {
+        self.streams.contains_key(stream_id)
+    }
+
+    /// Remove a stream and all its subscribers
+    pub fn remove_stream(&mut self, stream_id: &str) -> bool {
+        self.streams.remove(stream_id).is_some()
+    }
+
+    /// Subscribe to a video stream and get a receiver
+    /// Returns the receiver for the new subscription
+    pub fn subscribe_to_stream(&self, stream_id: &str) -> Option<broadcast::Receiver<Vec<u8>>> {
+        self.streams
+            .get(stream_id)
+            .map(|(_tx, rx)| rx.resubscribe()) // Resubscribe to create a new independent receiver
+    }
+
+    /// Get subscriber count for a stream
+    pub fn get_subscriber_count(&self, stream_id: &str) -> usize {
+        self.streams
+            .get(stream_id)
+            .map_or(0, |(tx, _rx)| tx.receiver_count())
+    }
+
+    /// Get a stream transmitter for sending frames (used by machines to send video)
+    /// Returns None if the stream doesn't exist
+    pub fn get_sender(&self, stream_id: &str) -> Option<broadcast::Sender<Vec<u8>>> {
+        self.streams.get(stream_id).map(|(tx, _rx)| tx.clone())
+    }
+}
+
+impl Default for VideoStreamManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_video_stream_manager() {
+        let mut manager = VideoStreamManager::new();
+
+        // Register streams
+        manager.register_stream("camera1".to_string());
+        manager.register_stream("camera2".to_string());
+
+        assert_eq!(manager.get_stream_ids().len(), 2);
+        assert!(manager.has_stream("camera1"));
+        assert!(manager.has_stream("camera2"));
+        assert!(!manager.has_stream("camera3"));
+
+        // Subscribe to streams
+        let mut rx1 = manager.subscribe_to_stream("camera1").unwrap();
+        let mut rx2 = manager.subscribe_to_stream("camera1").unwrap();
+        let mut rx3 = manager.subscribe_to_stream("camera2").unwrap();
+
+        assert_eq!(manager.get_subscriber_count("camera1"), 3); // Original + 2 clones
+        assert_eq!(manager.get_subscriber_count("camera2"), 2); // Original + 1 clone
+        assert_eq!(manager.get_subscriber_count("nonexistent"), 0);
+
+        // Send frames
+        let frame1 = vec![1, 2, 3, 4];
+        let frame2 = vec![5, 6, 7, 8];
+
+        assert!(manager.send_single_frame("camera1", frame1.clone()));
+        assert!(manager.send_single_frame("camera2", frame2.clone()));
+        assert!(!manager.send_single_frame("nonexistent", vec![]));
+
+        // Both camera1 subscribers should receive the frame
+        assert_eq!(rx1.recv().await.unwrap(), frame1);
+        assert_eq!(rx2.recv().await.unwrap(), frame1);
+
+        // Camera2 subscriber should receive its frame
+        assert_eq!(rx3.recv().await.unwrap(), frame2);
+    }
+
+    #[tokio::test]
+    async fn test_video_frame_broadcasting() {
+        let mut manager = VideoStreamManager::new();
+        manager.register_stream("main_camera".to_string());
+
+        // Multiple clients subscribe to the same camera
+        let mut rx1 = manager.subscribe_to_stream("main_camera").unwrap();
+        let mut rx2 = manager.subscribe_to_stream("main_camera").unwrap();
+        let mut rx3 = manager.subscribe_to_stream("main_camera").unwrap();
+
+        // Simulate video frames
+        let frames = vec![
+            vec![0xFF, 0xD8, 0xFF, 0xE0], // JPEG header
+            vec![0x00, 0x01, 0x02, 0x03], // Frame 1
+            vec![0x04, 0x05, 0x06, 0x07], // Frame 2
+        ];
+
+        for frame in &frames {
+            assert!(manager.send_single_frame("main_camera", frame.clone()));
+        }
+
+        // All clients should receive all frames in order
+        for frame in &frames {
+            assert_eq!(rx1.recv().await.unwrap(), *frame);
+            assert_eq!(rx2.recv().await.unwrap(), *frame);
+            assert_eq!(rx3.recv().await.unwrap(), *frame);
+        }
+    }
+
+    #[test]
+    fn test_stream_management() {
+        let mut manager = VideoStreamManager::new();
+
+        // Initially no streams
+        assert_eq!(manager.get_stream_ids().len(), 0);
+
+        // Add streams
+        manager.register_stream("front_camera".to_string());
+        manager.register_stream("rear_camera".to_string());
+        manager.register_stream("side_camera".to_string());
+
+        let mut stream_ids = manager.get_stream_ids();
+        stream_ids.sort(); // Sort for consistent testing
+        assert_eq!(
+            stream_ids,
+            vec!["front_camera", "rear_camera", "side_camera"]
+        );
+
+        // Remove a stream
+        assert!(manager.remove_stream("rear_camera"));
+        assert!(!manager.remove_stream("rear_camera")); // Already removed
+        assert!(!manager.has_stream("rear_camera"));
+
+        assert_eq!(manager.get_stream_ids().len(), 2);
+    }
+
+    #[tokio::test]
+    async fn test_send_frame_results() {
+        let mut manager = VideoStreamManager::new();
+        manager.register_stream("test_camera".to_string());
+
+        // One initial receiver (the original one created in register_stream)
+        let result = manager.send_frame("test_camera", vec![1, 2, 3]).unwrap();
+        assert_eq!(result, 1); // Number of subscribers
+
+        // Add subscribers by cloning the receiver
+        let _rx1 = manager.subscribe_to_stream("test_camera").unwrap();
+        let _rx2 = manager.subscribe_to_stream("test_camera").unwrap();
+
+        // Send frame to multiple subscribers (original + 2 clones = 3 total)
+        let result = manager.send_frame("test_camera", vec![4, 5, 6]).unwrap();
+        assert_eq!(result, 3); // Number of subscribers
+
+        // Try sending to non-existent stream
+        let result = manager.send_frame("nonexistent", vec![7, 8, 9]);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), "Stream 'nonexistent' not found");
+    }
+
+    #[test]
+    fn test_default_video_stream_manager() {
+        let manager = VideoStreamManager::default();
+        assert_eq!(manager.get_stream_ids().len(), 0);
+    }
+}

docs/developer-docs/adding-a-machine.md

@@ -0,0 +1,145 @@
+# How can I add a new Machine?
+
+Adding a new machine follows a common structure in `server/machines/`.
+
+
+
+# TLDR
+
+Summary
+
+When adding a new machine:
+
+- Create Folder server/machines/YOUR_MACHINE_NAME/.
+- Add the 4 files (mod.rs, new.rs, act.rs, api.rs).
+- Register it in machines/mod.rs with a unique constant.
+- mod.rs: define the struct + emit functions.
+- new.rs: assemble devices/controllers into the machine.
+- act.rs: implement the machine loop (MachineAct).
+- api.rs: define request (mutations) and response (events) types.
+
+Tip: Start simple (copy MockMachine) and grow complexity as needed (add EtherCAT devices, controllers, etc.).
+
+---
+
+## 1. Create the folder
+
+Create a new directory:
+server/machines/YOUR_MACHINE_NAME
+
+At a minimum, this folder needs the following files:
+
+- `mod.rs`
+- `new.rs`
+- `act.rs`
+- `api.rs`
+
+---
+
+## 2. Register the module
+
+Add your machine to `server/machines/mod.rs`:
+
+```rust
+// mod.rs
+pub mod buffer1;
+pub mod extruder1;
+pub mod laser;
+pub mod mock;
+pub mod registry;
+pub mod winder2;
+pub mod YOUR_MACHINE;
+
+pub const VENDOR_QITECH: u16 = 0x0001;
+pub const MACHINE_WINDER_V1: u16 = 0x0002;
+pub const MACHINE_EXTRUDER_V1: u16 = 0x0004;
+pub const MACHINE_LASER_V1: u16 = 0x0006;
+pub const MACHINE_MOCK: u16 = 0x0007;
+pub const MACHINE_BUFFER_V1: u16 = 0x0008;
+pub const YOUR_MACHINE_V1: u16 = 0xffff; // pick a unique ID to avoid collisions also DO NOT touch any already defined ids!!
+```
+
+## 3. mod.rs
+
+This file defines your machine struct and the required event emitters.
+
+Look at MockMachine’s mod.rs for the simplest possible version.
+
+At a minimum, you need:
+- emit_state
+- emit_live_values
+- A machine struct for state(e.g. MockMachine, Extruder, Laser, Winder, …)
+
+More complex machines (e.g. Extruder, Winder) encapsulate controllers that in turn manage devices like EtherCAT terminals.
+
+## 4 new.rs
+
+This file implements MachineNewTrait for your machine.
+Here you assemble your machine from its parts — devices, controllers, and any state.
+
+Minimal example: see MockMachine → basically no devices, just returns a struct.
+
+Medium complexity: see Laser → wraps a single serial USB device.
+
+High complexity: see Extruder → configures multiple EtherCAT devices inside controllers.
+
+Think of new.rs as the factory:
+This is the place to declare which devices make up your machine and how they’re configured.
+
+## 5. act.rs
+
+This file implements the machine control loop using MachineAct.
+The act() method is called repeatedly by the control runtime.
+
+```rs
+impl MachineAct for YourMachine {
+    fn act(&mut self, _now_ts: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
+        Box::pin(async move {
+            let now = Instant::now();
+
+            // Update state, e.g. step a controller
+            self.some_controller.update();
+
+            // Emit live values ~30 Hz if machine is in Running mode
+            if now.duration_since(self.last_measurement_emit) > Duration::from_secs_f64(1.0 / 30.0) {
+                self.maybe_emit_state_event();
+                self.emit_live_values();
+                self.last_measurement_emit = now;
+            }
+        })
+    }
+}
+```
+
+## 6. api.rs
+
+Defines the frontend-facing API for your machine:
+
+Mutations → requests that the machine accepts
+(e.g. start/stop commands, setpoints, configuration updates).
+
+Events → responses emitted to the frontend
+(e.g. live sensor data, alarms, machine state changes).
+
+Look at MockMachine’s api.rs for a minimal version.
+
+```rs
+/// Mutations are API requests to control the machine
+#[derive(Debug, Clone, serde::Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum YourMachineMutation {
+    Start,
+    Stop,
+    SetSpeed { rpm: f64 },
+}
+
+/// Events are responses sent to the frontend
+#[derive(Debug, Clone, serde::Serialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum YourMachineEvent {
+    StateChanged { state: String },
+    LiveValues { rpm: f64, torque: f64 },
+}
+
+```
+

docs/developer-docs/code-style-backend.md

@@ -0,0 +1,94 @@
+# Code Style
+
+# General Code styling
+
+Try to adhere to the rust style guide:
+https://doc.rust-lang.org/nightly/style-guide/
+
+# Beckhoff terminals and Machines
+
+For Beckhoff terminals you should first implement the basic functionality, then an Interpreter of the device/data is built on top.
+A good example of how to do this is by looking at the following code:
+el3021.rs , AnalogInputDevice
+
+El3021 implements a so called AnalogInputDevice, which acts like an interface.
+This allows us to use AnalogInputDevice instead of having to always specify which device should be used.
+In Essence any Device that implements AnalogInputDevice can be used.
+
+AnalogInputDevice is then used for creating an AnalogInput, which is plug and play for machines.
+
+Then a further layer of Abstraction is used on top,
+where the data is interpreted and incorporated into a sort of control loop for certain functions, for example:
+
+```rust
+// ScrewSpeedController controlls the speed (frequency) and direction of the motor
+// AnalogInput is used to collect measurements from the pressure sensor.
+// screw_speed_controller.rs
+#[derive(Debug)]
+pub struct ScrewSpeedController {
+    pub pid: ClampingTimeagnosticPidController,
+    pub target_pressure: Pressure,
+    pub target_rpm: AngularVelocity,
+    pub inverter: MitsubishiCS80,
+    pressure_sensor: AnalogInput,
+    last_update: Instant,
+    uses_rpm: bool,
+    forward_rotation: bool,
+    transmission_converter: TransmissionConverter,
+    frequency: Frequency,
+    maximum_frequency: Frequency,
+    minimum_frequency: Frequency,
+    motor_on: bool,
+    nozzle_pressure_limit: Pressure,
+    nozzle_pressure_limit_enabled: bool,
+}
+
+// Under the hood for ExtruderV2 a El3021 is used:
+// (from new.rs of extruder)
+let pressure_sensor = AnalogInput::new(el3021, EL3021Port::AI1);
+
+// But the extruder does not directly use the AnalogInput, instead the logic is decoupled in the screw_speed_controller:
+let mut extruder: ExtruderV2 = Self {
+    namespace: ExtruderV2Namespace::new(params.socket_queue_tx.clone()),
+    last_measurement_emit: Instant::now(),
+    mode: ExtruderV2Mode::Standby,
+    temperature_controller_front: temperature_controller_front,
+    temperature_controller_middle: temperature_controller_middle,
+    temperature_controller_back: temperature_controller_back,
+    temperature_controller_nozzle: temperature_controller_nozzle,
+    screw_speed_controller: screw_speed_controller,
+    emitted_default_state: false,
+};
+
+// Then in act.rs
+// The extruder simply calls the update function of the screw_speed_controller,
+// which contains "all" of the logic needed to properly drive the motor
+self.screw_speed_controller.update(now_ts, true);
+
+
+```
+
+This is desired behaviour for all implemented devices, the machines should stay as modular as possible.
+
+# Representing physical Units (Volt,Ampere,Hz,RPM etc)
+
+To represent physical units like voltage ampere etc... we use uom (units of measurement), which acts as a wrapper for units and supplies all conversions between certain units.
+For example:
+
+```rust
+// Lets say a device measures voltage, you just got the raw value
+let volts : ElectricPotential = ElectricPotential::new::<volt>(raw_value_here);
+// Then you can do this to get milli_volts
+// In api responses we always use the RAW float value (64bit):
+let milli_volts : f64 = volts.get::<millivolt>();
+```
+
+# General Advice
+
+- Try to avoid duplicate code (DRY principle)
+- Try to avoid lifetimes if at all possible
+- Avoid excessive abstractions
+- Avoid async code unless it is required
+- Avoid taking Ownership of values, instead borrow the value
+- When implementing a Trait for a struct, do it in the same file as the struct definition
+- Split up large impl blocks into smaller impl blocks

docs/developer-docs/performance_stability.md

@@ -0,0 +1,128 @@
+# Performance/Stability Tweaks 
+## EtherCrab Config
+We set ethercrab to default settings for everything except for RetryBehaviour, so that one unlikely failure doesnt destroy the EtherCAT network.
+
+```rust
+    let maindevice = MainDevice::new(
+        pdu,
+        Timeouts {
+            // Default 5000ms
+            state_transition: Duration::from_millis(5000),
+            // Default 30_000us
+            pdu: Duration::from_micros(30_000),
+            // Default 10ms
+            eeprom: Duration::from_millis(10),
+            // Default 0ms
+            wait_loop_delay: Duration::from_millis(0),
+            // Default 100ms
+            mailbox_echo: Duration::from_millis(100),
+            // Default 1000ms
+            mailbox_response: Duration::from_millis(1000),
+        },
+        MainDeviceConfig {
+            // Default RetryBehaviour::None
+            retry_behaviour: RetryBehaviour::Count(5),
+            // Default 10_000
+            dc_static_sync_iterations: 10_000,
+        },
+    );
+
+```
+wait_loop_delay CAN in theory also decrease CPU usage if set exactly as the loop_delay we set, however this setting has caused us some issues, so we just leave it as is.
+
+## Realtime Kernel
+In our nixOs Config we use the latest realtime kernel and isolate TWO cores out of the Four available for the machines we use.
+
+```nix
+ #From configuration.nix
+ boot.loader.efi.canTouchEfiVariables = true;
+ boot.kernelPackages = pkgs.linuxPackages-rt_latest;
+ boot.kernelModules = [ "i915" ];
+```
+
+Notice how we hardcode the intel gpu kernel module. This is because only the GPU driver gets blacklisted for some reason. By specifying it manually it loads like before.
+
+One Core is used for the EtherCrab TXRX Thread and one is used for the machine Thread. 
+```
+    "isolcpus=2,3" # Isolate cpus 2 and 3 from scheduler for better latency, 2 runs ethercatthread and 3 runs server control-loop
+    "nohz_full=2,3" # In this mode, the periodic scheduler tick is stopped when only one task is running, reducing kernel interruptions on those CPUs.
+    "rcu_nocbs=2,3" # Moves RCU (Read-Copy Update) callback processing away from CPUs 2 and 3.
+```
+
+Essentially we completely disable acces from the operating system to these two cpus, which saves scheduler overhead, which would introduce noticable latency.
+Its not entirely clear yet if what we did here is overkill. Maybe we could use only one core and get away with that?
+Processor load normally hovers around 18% for one of the cores and like 9% for the other.
+
+We also have some minor cpu tweaks in configuration.nix
+```
+    # Graphical
+    "logo.nologo" # Remove kernel logo during boot
+
+    # Performance
+
+    # Specific Vulnerabilities Addressed by Mitigations:
+    # - Spectre variants (V1, V2, V4, SWAPGS, SpectreRSB, etc.)
+    # - Meltdown (Rogue Data Cache Load)
+    # - Foreshadow/L1TF (L1 Terminal Fault)
+    # - Microarchitectural Data Sampling (MDS, RIDL, Fallout, ZombieLoad)
+    # - SRBDS (Special Register Buffer Data Sampling)
+    # - TSX Asynchronous Abort (TAA)
+    # - iTLB Multihit
+    # - And others as they're discovered and mitigated
+    #
+    # With mitigations=off
+    # - PROS: Maximum performance, equivalent to pre-2018 behavior
+    # - CONS: Vulnerable to Spectre, Meltdown, Foreshadow, ZombieLoad, etc.
+    #         Should ONLY be used in completely trusted environments
+    # - Improves performance by 7-43%
+    "mitigation=off"
+    "intel_pstate=performance"    # Intel CPU-specific performance mode (if applicable)
+
+    # Memory Management
+    "transparent_hugepage=always" # Use larger memory pages for memory intense applications
+    "nmi_watchdog=0"              # Disable NMI watchdog for reduced CPU overhead and realtime execution
+
+    # High-throughput ethernet parameters
+    "pcie_aspm=off"         # Disable PCIe power management for NICs
+    "intel_iommu=off"       # Disable IOMMU (performance gain)
+
+    # Reliability
+    "panic=10"              # Auto-reboot 10 seconds after kernel panic
+    "oops=panic"            # Treat kernel oops as panic for auto-recovery
+    "usbcore.autosuspend=-1"     # Possibly fixes dre disconnect issue?
+```
+
+We should check if its really required to turn mitigations off as well.
+
+## Rust Code Optimizations
+
+In General we try to avoid memory allocations in our loop as much as possible, as it is not deterministic
+
+One problem we found, is that due to the realtime kernel our ethernet driver caused us quite large spikes in our tx_rx cycle time for EtherCAT.
+These spikes happen when CPU Load is very high on the two usable cores, causing the interrupt handler for Ethernet to stall.
+
+Which is why we reassign the interrupt handler on startup to the same core that the EtherCatTxRx Thread runs on:
+
+```rust
+#[cfg(target_os = "linux")]
+match set_irq_affinity(&interface, 3) {
+      Ok(_) => tracing::info!("ethernet interrupt handler now runs on cpu:{}", 3),
+      Err(e) => tracing::error!("set_irq_affinity failed: {:?}", e),
+}
+// Set core affinity to 4th core
+let _ = set_core_affinity(3);
+
+// Set the thread to real-time priority
+let _ = set_realtime_priority();
+```
+This means that the Interrupt Handler ALWAYS has enough ressources to cope with our demand for realtime communication with EtherCAT
+
+
+One Problem we have at the moment (we think) is the locking and async code blocking our server loop. 
+Note that this doesnt affect the EtherCAT communication at all.
+
+## Electron Optimizations (Not Yet Implemented)
+
+Currently we are struggling with the fact, that apparently Electron doesnt really have good support for HW acceleration on Linux.
+Electron runs with the software-renderer, which is VERY slow compared to a gpu. 
+This would eliminate the weird stuttering seen on Graphs and make them run buttery smooth, while also alleviating load off of the CPU.

docs/developer-docs/testing_memtest.md

@@ -0,0 +1,27 @@
+# Testing Ram and Cpu (Hardware)
+
+There were instability problems on one of the hmi panel pc's related to ram.
+
+To test Ram and Cpu for stability problems we use memtest86.
+
+You can download it here: https://www.memtest86.com/download.htm
+Then in the unzipped folder you have to flash the .img file to a USB drive with atleast 2GB of space.
+We already have USB-Sticks flashed with memtest though.
+
+1. When starting up the Pc mash Del (Entf in german) on an external keyboard and enter the bios
+
+2. Select the Memtest86 usb stick in the Bios
+
+3. Save changes and exit
+
+4. Now memtest boots up, just let it do its thing from here
+
+It works if the screen looks something like this:
+
+![](../assets/Memtest86_v83p.png)
+
+Simply let it do one Pass ~20 minutes and shutdown and unplug usb stick afterwards
+
+If it freezes completely -> unstable
+
+If it shows errors the ram should be swapped out and the test repeated

docs/devices.md

@@ -115,3 +115,130 @@ pub fn (
     }
 }
 ```
+
+
+# Device Implementation Guide
+
+This section describes how to implement EtherCAT devices in the framework used by the QiTech Control project (via `ethercat-hal`, `server`, etc.). We include a running example of a simple digital output device (EL2004) and discuss how it fits into the larger architecture.
+
+## Architecture & Context
+
+The QiTech Control system is built as:
+
+- `ethercat-hal` / `ethercat-hal-derive`: Hardware abstraction, PDO / CoE handling, device traits.  
+- `server`: Glue code that reads device identities, instantiates the correct device types, performs CoE configuration, and runs cyclic process data.  
+- The `docs` directory documents APIs and device patterns.  
+  :contentReference[oaicite:0]{index=0}  
+
+In this architecture:
+
+1. During initialization, subdevice identity tuples (Vendor ID, Product ID, Revision) are read.
+2. The `server` matches identity tuples to concrete `Device` types and constructs them (via `NewEthercatDevice`).
+3. The device instance then handles PDO exchange, and optional CoE (configuration) writes.
+4. Higher-level application code interacts with devices via traits like `DigitalOutputDevice`, `DigitalInputDevice`, etc.
+
+---
+
+## Example: Simple Digital Output Device (EL2004)
+
+Below is a minimal example of a digital-output-only EtherCAT device. It shows how to map PDOs, implement traits, and define identity constants.
+
+```rust
+use super::{EthercatDeviceProcessing, NewEthercatDevice, SubDeviceIdentityTuple};
+use crate::helpers::ethercrab_types::EthercrabSubDevicePreoperational;
+use crate::io::digital_output::{DigitalOutputDevice, DigitalOutputOutput};
+use crate::pdo::{RxPdo, basic::BoolPdoObject};
+use ethercat_hal_derive::{EthercatDevice, RxPdo};
+
+/// EL2004 4-channel digital output device — 24 V DC, 0.5 A per channel
+#[derive(EthercatDevice)]
+pub struct EL2004 {
+    /// The Rx PDO where output bits are written by the master
+    pub rxpdo: EL2004RxPdo,
+    is_used: bool,
+}
+
+impl EthercatDeviceProcessing for EL2004 {}
+
+impl std::fmt::Debug for EL2004 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "EL2004")
+    }
+}
+
+impl NewEthercatDevice for EL2004 {
+    fn new() -> Self {
+        Self {
+            rxpdo: EL2004RxPdo::default(),
+            is_used: false,
+        }
+    }
+}
+
+impl DigitalOutputDevice<EL2004Port> for EL2004 {
+    fn set_output(&mut self, port: EL2004Port, value: DigitalOutputOutput) {
+        let expect_text = "All channels should be Some(_)";
+        match port {
+            EL2004Port::DO1 => {
+                self.rxpdo.channel1.as_mut().expect(expect_text).value = value.into()
+            }
+            EL2004Port::DO2 => {
+                self.rxpdo.channel2.as_mut().expect(expect_text).value = value.into()
+            }
+            EL2004Port::DO3 => {
+                self.rxpdo.channel3.as_mut().expect(expect_text).value = value.into()
+            }
+            EL2004Port::DO4 => {
+                self.rxpdo.channel4.as_mut().expect(expect_text).value = value.into()
+            }
+        }
+    }
+
+    fn get_output(&self, port: EL2004Port) -> DigitalOutputOutput {
+        let expect_text = "All channels should be Some(_)";
+        DigitalOutputOutput(match port {
+            EL2004Port::DO1 => self.rxpdo.channel1.as_ref().expect(expect_text).value,
+            EL2004Port::DO2 => self.rxpdo.channel2.as_ref().expect(expect_text).value,
+            EL2004Port::DO3 => self.rxpdo.channel3.as_ref().expect(expect_text).value,
+            EL2004Port::DO4 => self.rxpdo.channel4.as_ref().expect(expect_text).value,
+        })
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum EL2004Port {
+    DO1,
+    DO2,
+    DO3,
+    DO4,
+}
+
+#[derive(Debug, Clone, RxPdo)]
+pub struct EL2004RxPdo {
+    #[pdo_object_index(0x1600)]
+    pub channel1: Option<BoolPdoObject>,
+    #[pdo_object_index(0x1601)]
+    pub channel2: Option<BoolPdoObject>,
+    #[pdo_object_index(0x1602)]
+    pub channel3: Option<BoolPdoObject>,
+    #[pdo_object_index(0x1603)]
+    pub channel4: Option<BoolPdoObject>,
+}
+
+impl Default for EL2004RxPdo {
+    fn default() -> Self {
+        Self {
+            channel1: Some(BoolPdoObject::default()),
+            channel2: Some(BoolPdoObject::default()),
+            channel3: Some(BoolPdoObject::default()),
+            channel4: Some(BoolPdoObject::default()),
+        }
+    }
+}
+
+/// Identity constants for EL2004
+pub const EL2004_VENDOR_ID: u32 = 0x2;
+pub const EL2004_PRODUCT_ID: u32 = 131346514;
+pub const EL2004_REVISION_A: u32 = 1179648;
+pub const EL2004_IDENTITY_A: SubDeviceIdentityTuple =
+    (EL2004_VENDOR_ID, EL2004_PRODUCT_ID, EL2004_REVISION_A);

docs/troubleshooting.md

@@ -0,0 +1,40 @@
+# Ethercat Tab shows no Ethercat Terminals!
+
+When the Ethercat page does not show any terminals, this can be due to multiple reasons
+
+## 1: Incorrect Connection of EK1100
+
+Check that the computers ethernet cable is properly connected to the EK1100 IN port
+
+Check the cabling if more than one EK1100 is used.
+When you have multiple EK the connection should be like this:
+
+Master (Your pc) -> Ethernet cable -> IN EK1100 (A)
+
+OUT EK1100 (A) -> Ethernet cable -> IN EK1100 (B)
+
+If you connected any part of this incorrectly the ethercat software will try to communicate but will fail, because the protocol works only if all devices are connect in series.
+
+## 2: Defective EtherCAT Terminal
+
+If a Terminal is somehow defective it can disrupt the communication flow expected by EtherCAT thus causing no devices to show up, as ethercat requires all terminals to work properly.
+
+To identify the defective terminal start unplugging terminals starting from the End terminal. Working your way backwards. Every time you unplug a terminal restart the backend process.
+
+You know that you have removed the defective terminal when the ethercat tab shows devices after your restart.
+
+Replace that terminal with an appropriate one and repeat this if the error persists.
+
+## 3: Corrupt Firmware on EtherCAT Terminal
+
+Another reason, that an Ethercat Terminal doesnt work properly, is that the firmware is corrupt. This could happen due to overvoltage,undervoltage or shorts, in some cases this is recoverable by reflashing the firmware.
+
+Our repository contains dumps for all of the EtherCAT Terminals, that we have used. To upload the firmware you can follow this guide: https://infosys.beckhoff.com/english.php?content=../content/1033/ethercatsystem/402909835.html&id=
+
+To follow this guide, you need to have TwinCat installed and a License.
+
+# Motor does not start!
+
+If the Motor does not start after trying to talk to the inverter, the most common reason is that the inverter's serial connection settings (baudrate,encoding ...) are incorrect.
+
+The correct settings can be found in mitsubishi_inverter.md under `All Settings needed for the Inverter Communication/Operation with Extruder`

electron/package-lock.json

@@ -11,20 +11,20 @@
         "@hookform/resolvers": "^4.1.2",
         "@icons-pack/react-simple-icons": "^11.2.0",
         "@jub3i/tree-kill": "^0.0.15",
-        "@radix-ui/react-collapsible": "^1.1.8",
+        "@radix-ui/react-collapsible": "^1.1.12",
         "@radix-ui/react-dialog": "^1.1.6",
         "@radix-ui/react-dropdown-menu": "^2.1.15",
         "@radix-ui/react-label": "^2.1.2",
-        "@radix-ui/react-navigation-menu": "^1.2.5",
+        "@radix-ui/react-navigation-menu": "^1.2.14",
         "@radix-ui/react-popover": "^1.1.7",
-        "@radix-ui/react-select": "^2.1.6",
+        "@radix-ui/react-select": "^2.2.6",
         "@radix-ui/react-separator": "^1.1.3",
         "@radix-ui/react-slider": "^1.2.3",
         "@radix-ui/react-slot": "^1.1.2",
         "@radix-ui/react-toggle": "^1.1.1",
         "@radix-ui/react-toggle-group": "^1.1.2",
         "@tanstack/react-query": "^5.84.2",
-        "@tanstack/react-router": "^1.105.0",
+        "@tanstack/react-router": "^1.130.17",
         "@tanstack/react-table": "^8.21.2",
         "@tanstack/router-devtools": "^1.105.0",
         "@tanstack/zod-adapter": "^1.116.0",
@@ -43,6 +43,7 @@
         "react-hook-form": "^7.57.0",
         "react-i18next": "^15.4.1",
         "react-markdown": "^10.1.0",
+        "react-virtualized": "^9.22.6",
         "rehype-raw": "^7.0.0",
         "remark-gfm": "^4.0.1",
         "socket.io-client": "^4.8.1",
@@ -54,7 +55,7 @@
         "xlsx": "^0.18.5",
         "zod": "^3.24.2",
         "zod-validation-error": "^3.4.0",
-        "zustand": "^5.0.3"
+        "zustand": "^5.0.8"
       },
       "devDependencies": {
         "@electron-forge/cli": "^7.6.1",
@@ -77,9 +78,10 @@
         "@types/electron-squirrel-startup": "^1.0.2",
         "@types/eslint-config-prettier": "^6.11.3",
         "@types/node": "^24.2.1",
-        "@types/react": "^19.0.10",
+        "@types/react": "^19.1.16",
         "@types/react-dom": "^19.0.4",
-        "electron": "^37.2.6",
+        "@types/react-virtualized": "^9.22.2",
+        "electron": "^37.3.1",
         "electron-playwright-helpers": "^1.7.1",
         "eslint": "^9.20.1",
         "eslint-config-prettier": "^10.1.2",
@@ -95,7 +97,7 @@
         "ts-node": "^10.9.2",
         "typescript": "^5.7.3",
         "typescript-eslint": "^8.24.1",
-        "vite": "^6.2.6",
+        "vite": "^6.3.6",
         "vitest": "^3.0.6"
       }
     },
@@ -2323,15 +2325,16 @@
       }
     },
     "node_modules/@radix-ui/react-collapsible": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-collapsible/-/react-collapsible-1.1.11.tgz",
-      "integrity": "sha512-2qrRsVGSCYasSz1RFOorXwl0H7g7J1frQtgpQgYrt+MOidtPAINHn9CPovQXb83r8ahapdx3Tu0fa/pdFFSdPg==",
+      "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-collapsible/-/react-collapsible-1.1.12.tgz",
+      "integrity": "sha512-Uu+mSh4agx2ib1uIGPP4/CKNULyajb3p92LsVXmH2EHVMTfZWpll88XJ0j4W0z3f8NK1eYl1+Mf/szHPmcHzyA==",
+      "license": "MIT",
       "dependencies": {
-        "@radix-ui/primitive": "1.1.2",
+        "@radix-ui/primitive": "1.1.3",
         "@radix-ui/react-compose-refs": "1.1.2",
         "@radix-ui/react-context": "1.1.2",
         "@radix-ui/react-id": "1.1.1",
-        "@radix-ui/react-presence": "1.1.4",
+        "@radix-ui/react-presence": "1.1.5",
         "@radix-ui/react-primitive": "2.1.3",
         "@radix-ui/react-use-controllable-state": "1.2.2",
         "@radix-ui/react-use-layout-effect": "1.1.1"
@@ -2351,6 +2354,36 @@
         }
       }
     },
+    "node_modules/@radix-ui/react-collapsible/node_modules/@radix-ui/primitive": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@radix-ui/primitive/-/primitive-1.1.3.tgz",
+      "integrity": "sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg==",
+      "license": "MIT"
+    },
+    "node_modules/@radix-ui/react-collapsible/node_modules/@radix-ui/react-presence": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-presence/-/react-presence-1.1.5.tgz",
+      "integrity": "sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@radix-ui/react-compose-refs": "1.1.2",
+        "@radix-ui/react-use-layout-effect": "1.1.1"
+      },
+      "peerDependencies": {
+        "@types/react": "*",
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/@radix-ui/react-collection": {
       "version": "1.1.7",
       "resolved": "https://registry.npmjs.org/@radix-ui/react-collection/-/react-collection-1.1.7.tgz",
@@ -2624,18 +2657,19 @@
       }
     },
     "node_modules/@radix-ui/react-navigation-menu": {
-      "version": "1.2.13",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-navigation-menu/-/react-navigation-menu-1.2.13.tgz",
-      "integrity": "sha512-WG8wWfDiJlSF5hELjwfjSGOXcBR/ZMhBFCGYe8vERpC39CQYZeq1PQ2kaYHdye3V95d06H89KGMsVCIE4LWo3g==",
+      "version": "1.2.14",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-navigation-menu/-/react-navigation-menu-1.2.14.tgz",
+      "integrity": "sha512-YB9mTFQvCOAQMHU+C/jVl96WmuWeltyUEpRJJky51huhds5W2FQr1J8D/16sQlf0ozxkPK8uF3niQMdUwZPv5w==",
+      "license": "MIT",
       "dependencies": {
-        "@radix-ui/primitive": "1.1.2",
+        "@radix-ui/primitive": "1.1.3",
         "@radix-ui/react-collection": "1.1.7",
         "@radix-ui/react-compose-refs": "1.1.2",
         "@radix-ui/react-context": "1.1.2",
         "@radix-ui/react-direction": "1.1.1",
-        "@radix-ui/react-dismissable-layer": "1.1.10",
+        "@radix-ui/react-dismissable-layer": "1.1.11",
         "@radix-ui/react-id": "1.1.1",
-        "@radix-ui/react-presence": "1.1.4",
+        "@radix-ui/react-presence": "1.1.5",
         "@radix-ui/react-primitive": "2.1.3",
         "@radix-ui/react-use-callback-ref": "1.1.1",
         "@radix-ui/react-use-controllable-state": "1.2.2",
@@ -2658,6 +2692,63 @@
         }
       }
     },
+    "node_modules/@radix-ui/react-navigation-menu/node_modules/@radix-ui/primitive": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@radix-ui/primitive/-/primitive-1.1.3.tgz",
+      "integrity": "sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg==",
+      "license": "MIT"
+    },
+    "node_modules/@radix-ui/react-navigation-menu/node_modules/@radix-ui/react-dismissable-layer": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-dismissable-layer/-/react-dismissable-layer-1.1.11.tgz",
+      "integrity": "sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==",
+      "license": "MIT",
+      "dependencies": {
+        "@radix-ui/primitive": "1.1.3",
+        "@radix-ui/react-compose-refs": "1.1.2",
+        "@radix-ui/react-primitive": "2.1.3",
+        "@radix-ui/react-use-callback-ref": "1.1.1",
+        "@radix-ui/react-use-escape-keydown": "1.1.1"
+      },
+      "peerDependencies": {
+        "@types/react": "*",
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@radix-ui/react-navigation-menu/node_modules/@radix-ui/react-presence": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-presence/-/react-presence-1.1.5.tgz",
+      "integrity": "sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@radix-ui/react-compose-refs": "1.1.2",
+        "@radix-ui/react-use-layout-effect": "1.1.1"
+      },
+      "peerDependencies": {
+        "@types/react": "*",
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/@radix-ui/react-popover": {
       "version": "1.1.14",
       "resolved": "https://registry.npmjs.org/@radix-ui/react-popover/-/react-popover-1.1.14.tgz",
@@ -2824,21 +2915,22 @@
       }
     },
     "node_modules/@radix-ui/react-select": {
-      "version": "2.2.5",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-select/-/react-select-2.2.5.tgz",
-      "integrity": "sha512-HnMTdXEVuuyzx63ME0ut4+sEMYW6oouHWNGUZc7ddvUWIcfCva/AMoqEW/3wnEllriMWBa0RHspCYnfCWJQYmA==",
+      "version": "2.2.6",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-select/-/react-select-2.2.6.tgz",
+      "integrity": "sha512-I30RydO+bnn2PQztvo25tswPH+wFBjehVGtmagkU78yMdwTwVf12wnAOF+AeP8S2N8xD+5UPbGhkUfPyvT+mwQ==",
+      "license": "MIT",
       "dependencies": {
         "@radix-ui/number": "1.1.1",
-        "@radix-ui/primitive": "1.1.2",
+        "@radix-ui/primitive": "1.1.3",
         "@radix-ui/react-collection": "1.1.7",
         "@radix-ui/react-compose-refs": "1.1.2",
         "@radix-ui/react-context": "1.1.2",
         "@radix-ui/react-direction": "1.1.1",
-        "@radix-ui/react-dismissable-layer": "1.1.10",
-        "@radix-ui/react-focus-guards": "1.1.2",
+        "@radix-ui/react-dismissable-layer": "1.1.11",
+        "@radix-ui/react-focus-guards": "1.1.3",
         "@radix-ui/react-focus-scope": "1.1.7",
         "@radix-ui/react-id": "1.1.1",
-        "@radix-ui/react-popper": "1.2.7",
+        "@radix-ui/react-popper": "1.2.8",
         "@radix-ui/react-portal": "1.1.9",
         "@radix-ui/react-primitive": "2.1.3",
         "@radix-ui/react-slot": "1.2.3",
@@ -2865,6 +2957,86 @@
         }
       }
     },
+    "node_modules/@radix-ui/react-select/node_modules/@radix-ui/primitive": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@radix-ui/primitive/-/primitive-1.1.3.tgz",
+      "integrity": "sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg==",
+      "license": "MIT"
+    },
+    "node_modules/@radix-ui/react-select/node_modules/@radix-ui/react-dismissable-layer": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-dismissable-layer/-/react-dismissable-layer-1.1.11.tgz",
+      "integrity": "sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==",
+      "license": "MIT",
+      "dependencies": {
+        "@radix-ui/primitive": "1.1.3",
+        "@radix-ui/react-compose-refs": "1.1.2",
+        "@radix-ui/react-primitive": "2.1.3",
+        "@radix-ui/react-use-callback-ref": "1.1.1",
+        "@radix-ui/react-use-escape-keydown": "1.1.1"
+      },
+      "peerDependencies": {
+        "@types/react": "*",
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@radix-ui/react-select/node_modules/@radix-ui/react-focus-guards": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-focus-guards/-/react-focus-guards-1.1.3.tgz",
+      "integrity": "sha512-0rFg/Rj2Q62NCm62jZw0QX7a3sz6QCQU0LpZdNrJX8byRGaGVTqbrW9jAoIAHyMQqsNpeZ81YgSizOt5WXq0Pw==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@radix-ui/react-select/node_modules/@radix-ui/react-popper": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-popper/-/react-popper-1.2.8.tgz",
+      "integrity": "sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==",
+      "license": "MIT",
+      "dependencies": {
+        "@floating-ui/react-dom": "^2.0.0",
+        "@radix-ui/react-arrow": "1.1.7",
+        "@radix-ui/react-compose-refs": "1.1.2",
+        "@radix-ui/react-context": "1.1.2",
+        "@radix-ui/react-primitive": "2.1.3",
+        "@radix-ui/react-use-callback-ref": "1.1.1",
+        "@radix-ui/react-use-layout-effect": "1.1.1",
+        "@radix-ui/react-use-rect": "1.1.1",
+        "@radix-ui/react-use-size": "1.1.1",
+        "@radix-ui/rect": "1.1.1"
+      },
+      "peerDependencies": {
+        "@types/react": "*",
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/@radix-ui/react-separator": {
       "version": "1.1.7",
       "resolved": "https://registry.npmjs.org/@radix-ui/react-separator/-/react-separator-1.1.7.tgz",
@@ -3852,13 +4024,14 @@
       }
     },
     "node_modules/@tanstack/react-router": {
-      "version": "1.130.12",
-      "resolved": "https://registry.npmjs.org/@tanstack/react-router/-/react-router-1.130.12.tgz",
-      "integrity": "sha512-7BYgOpGc1vK8MH1LIFLLBudGpH46GQy+hewnP7dNQJ4KHmkwPHv958L1IMA9jU/rs5g1ZH5n1f33BAMOBXUMYQ==",
+      "version": "1.130.17",
+      "resolved": "https://registry.npmjs.org/@tanstack/react-router/-/react-router-1.130.17.tgz",
+      "integrity": "sha512-F1tyMEbX7PJclnA25hAFXhLKq4jqeODvvaogsd0/NX02Kmz3QoT9GV+rgpv2TxamU6RwjRgihSH06Dn5hM6SOw==",
+      "license": "MIT",
       "dependencies": {
         "@tanstack/history": "1.130.12",
         "@tanstack/react-store": "^0.7.0",
-        "@tanstack/router-core": "1.130.12",
+        "@tanstack/router-core": "1.130.17",
         "isbot": "^5.1.22",
         "tiny-invariant": "^1.3.3",
         "tiny-warning": "^1.0.3"
@@ -3932,9 +4105,10 @@
       }
     },
     "node_modules/@tanstack/router-core": {
-      "version": "1.130.12",
-      "resolved": "https://registry.npmjs.org/@tanstack/router-core/-/router-core-1.130.12.tgz",
-      "integrity": "sha512-emq3cRU9Na1hnIToojzkfJcOZm/MG2bv9M+Kr/elUxEf83enGEwQXC1EKezTuwNgeJrOv8vPJdEhWM7IQodnHQ==",
+      "version": "1.130.17",
+      "resolved": "https://registry.npmjs.org/@tanstack/router-core/-/router-core-1.130.17.tgz",
+      "integrity": "sha512-0AH4s/52X2shYLifr9hR+6R6NpGsBp1M3LyjBTZm6Jlkud+nOhkkRxKxYS7l+JErRlffdxVHxMdoTnKcQ+duiQ==",
+      "license": "MIT",
       "dependencies": {
         "@tanstack/history": "1.130.12",
         "@tanstack/store": "^0.7.0",
@@ -4330,10 +4504,18 @@
         "undici-types": "~7.10.0"
       }
     },
+    "node_modules/@types/prop-types": {
+      "version": "15.7.15",
+      "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz",
+      "integrity": "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/react": {
-      "version": "19.1.9",
-      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.1.9.tgz",
-      "integrity": "sha512-WmdoynAX8Stew/36uTSVMcLJJ1KRh6L3IZRx1PZ7qJtBqT3dYTgyDTx8H1qoRghErydW7xw9mSJ3wS//tCRpFA==",
+      "version": "19.1.16",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.1.16.tgz",
+      "integrity": "sha512-WBM/nDbEZmDUORKnh5i1bTnAz6vTohUf9b8esSMu+b24+srbaxa04UbJgWx78CVfNXA20sNu0odEIluZDFdCog==",
+      "license": "MIT",
       "dependencies": {
         "csstype": "^3.0.2"
       }
@@ -4347,6 +4529,17 @@
         "@types/react": "^19.0.0"
       }
     },
+    "node_modules/@types/react-virtualized": {
+      "version": "9.22.2",
+      "resolved": "https://registry.npmjs.org/@types/react-virtualized/-/react-virtualized-9.22.2.tgz",
+      "integrity": "sha512-0Eg/ME3OHYWGxs+/n4VelfYrhXssireZaa1Uqj5SEkTpSaBu5ctFGOCVxcOqpGXRiEdrk/7uho9tlZaryCIjHA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/prop-types": "*",
+        "@types/react": "*"
+      }
+    },
     "node_modules/@types/responselike": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/@types/responselike/-/responselike-1.0.3.tgz",
@@ -6183,6 +6376,16 @@
       "dev": true,
       "peer": true
     },
+    "node_modules/dom-helpers": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/dom-helpers/-/dom-helpers-5.2.1.tgz",
+      "integrity": "sha512-nRCa7CK3VTrM2NmGkIy4cbK7IZlgBE/PYMn55rrXefr5xXDP0LdtfPnblFDoVdcAfslJ7or6iqAUnx0CCGIWQA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/runtime": "^7.8.7",
+        "csstype": "^3.0.2"
+      }
+    },
     "node_modules/dunder-proto": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
@@ -6204,9 +6407,9 @@
       "dev": true
     },
     "node_modules/electron": {
-      "version": "37.2.6",
-      "resolved": "https://registry.npmjs.org/electron/-/electron-37.2.6.tgz",
-      "integrity": "sha512-Ns6xyxE+hIK5UlujtRlw7w4e2Ju/ImCWXf1Q/PoOhc0N3/6SN6YW7+ujCarsHbxWnolbW+1RlkHtdklUJpjbPA==",
+      "version": "37.3.1",
+      "resolved": "https://registry.npmjs.org/electron/-/electron-37.3.1.tgz",
+      "integrity": "sha512-7DhktRLqhe6OJh/Bo75bTI0puUYEmIwSzMinocgO63mx3MVjtIn2tYMzLmAleNIlud2htkjpsMG2zT4PiTCloA==",
       "dev": true,
       "hasInstallScript": true,
       "license": "MIT",
@@ -9805,7 +10008,6 @@
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
       "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
-      "dev": true,
       "dependencies": {
         "js-tokens": "^3.0.0 || ^4.0.0"
       },
@@ -11189,7 +11391,6 @@
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
       "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
-      "dev": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -11975,7 +12176,6 @@
       "version": "15.8.1",
       "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
       "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==",
-      "dev": true,
       "dependencies": {
         "loose-envify": "^1.4.0",
         "object-assign": "^4.1.1",
@@ -11985,8 +12185,7 @@
     "node_modules/prop-types/node_modules/react-is": {
       "version": "16.13.1",
       "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
-      "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
-      "dev": true
+      "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ=="
     },
     "node_modules/property-information": {
       "version": "7.1.0",
@@ -12114,6 +12313,12 @@
       "dev": true,
       "peer": true
     },
+    "node_modules/react-lifecycles-compat": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/react-lifecycles-compat/-/react-lifecycles-compat-3.0.4.tgz",
+      "integrity": "sha512-fBASbA6LnOU9dOU2eW7aQ8xmYBSXUIWr+UmF9b1efZBazGNO+rcXT/icdKnYm2pTwcRylVUYwW7H1PHfLekVzA==",
+      "license": "MIT"
+    },
     "node_modules/react-markdown": {
       "version": "10.1.0",
       "resolved": "https://registry.npmjs.org/react-markdown/-/react-markdown-10.1.0.tgz",
@@ -12214,6 +12419,33 @@
         }
       }
     },
+    "node_modules/react-virtualized": {
+      "version": "9.22.6",
+      "resolved": "https://registry.npmjs.org/react-virtualized/-/react-virtualized-9.22.6.tgz",
+      "integrity": "sha512-U5j7KuUQt3AaMatlMJ0UJddqSiX+Km0YJxSqbAzIiGw5EmNz0khMyqP2hzgu4+QUtm+QPIrxzUX4raJxmVJnHg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/runtime": "^7.7.2",
+        "clsx": "^1.0.4",
+        "dom-helpers": "^5.1.3",
+        "loose-envify": "^1.4.0",
+        "prop-types": "^15.7.2",
+        "react-lifecycles-compat": "^3.0.4"
+      },
+      "peerDependencies": {
+        "react": "^16.3.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react-dom": "^16.3.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/react-virtualized/node_modules/clsx": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/clsx/-/clsx-1.2.1.tgz",
+      "integrity": "sha512-EcR6r5a8bj6pu3ycsa/E/cKVGuTgZJZdsyUYHOksG/UHIiKfjxzRxYJpyVBwYaQeOvghal9fcc4PidlgzugAQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/read-binary-file-arch": {
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/read-binary-file-arch/-/read-binary-file-arch-1.0.6.tgz",
@@ -14440,9 +14672,10 @@
       }
     },
     "node_modules/vite": {
-      "version": "6.3.5",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-6.3.5.tgz",
-      "integrity": "sha512-cZn6NDFE7wdTpINgs++ZJ4N49W2vRp8LCKrn3Ob1kYNtOo21vfDoaV5GzBfLU4MovSAB8uNRm4jgzVQZ+mBzPQ==",
+      "version": "6.3.6",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.3.6.tgz",
+      "integrity": "sha512-0msEVHJEScQbhkbVTb/4iHZdJ6SXp/AvxL2sjwYQFfBqleHtnCqv1J3sa9zbWz/6kW1m9Tfzn92vW+kZ1WV6QA==",
+      "license": "MIT",
       "dependencies": {
         "esbuild": "^0.25.0",
         "fdir": "^6.4.4",
@@ -15123,9 +15356,10 @@
       }
     },
     "node_modules/zustand": {
-      "version": "5.0.7",
-      "resolved": "https://registry.npmjs.org/zustand/-/zustand-5.0.7.tgz",
-      "integrity": "sha512-Ot6uqHDW/O2VdYsKLLU8GQu8sCOM1LcoE8RwvLv9uuRT9s6SOHCKs0ZEOhxg+I1Ld+A1Q5lwx+UlKXXUoCZITg==",
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/zustand/-/zustand-5.0.8.tgz",
+      "integrity": "sha512-gyPKpIaxY9XcO2vSMrLbiER7QMAMGOQZVRdJ6Zi782jkbzZygq5GI9nG8g+sMgitRtndwaBSl7uiqC49o1SSiw==",
+      "license": "MIT",
       "engines": {
         "node": ">=12.20.0"
       },

electron/package.json

@@ -42,9 +42,10 @@
     "@types/electron-squirrel-startup": "^1.0.2",
     "@types/eslint-config-prettier": "^6.11.3",
     "@types/node": "^24.2.1",
-    "@types/react": "^19.0.10",
+    "@types/react": "^19.1.16",
     "@types/react-dom": "^19.0.4",
-    "electron": "^37.2.6",
+    "@types/react-virtualized": "^9.22.2",
+    "electron": "^37.3.1",
     "electron-playwright-helpers": "^1.7.1",
     "eslint": "^9.20.1",
     "eslint-config-prettier": "^10.1.2",
@@ -60,27 +61,27 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.7.3",
     "typescript-eslint": "^8.24.1",
-    "vite": "^6.2.6",
+    "vite": "^6.3.6",
     "vitest": "^3.0.6"
   },
   "dependencies": {
     "@hookform/resolvers": "^4.1.2",
     "@icons-pack/react-simple-icons": "^11.2.0",
     "@jub3i/tree-kill": "^0.0.15",
-    "@radix-ui/react-collapsible": "^1.1.8",
+    "@radix-ui/react-collapsible": "^1.1.12",
     "@radix-ui/react-dialog": "^1.1.6",
     "@radix-ui/react-dropdown-menu": "^2.1.15",
     "@radix-ui/react-label": "^2.1.2",
-    "@radix-ui/react-navigation-menu": "^1.2.5",
+    "@radix-ui/react-navigation-menu": "^1.2.14",
     "@radix-ui/react-popover": "^1.1.7",
-    "@radix-ui/react-select": "^2.1.6",
+    "@radix-ui/react-select": "^2.2.6",
     "@radix-ui/react-separator": "^1.1.3",
     "@radix-ui/react-slider": "^1.2.3",
     "@radix-ui/react-slot": "^1.1.2",
     "@radix-ui/react-toggle": "^1.1.1",
     "@radix-ui/react-toggle-group": "^1.1.2",
     "@tanstack/react-query": "^5.84.2",
-    "@tanstack/react-router": "^1.105.0",
+    "@tanstack/react-router": "^1.130.17",
     "@tanstack/react-table": "^8.21.2",
     "@tanstack/router-devtools": "^1.105.0",
     "@tanstack/zod-adapter": "^1.116.0",
@@ -99,6 +100,7 @@
     "react-hook-form": "^7.57.0",
     "react-i18next": "^15.4.1",
     "react-markdown": "^10.1.0",
+    "react-virtualized": "^9.22.6",
     "rehype-raw": "^7.0.0",
     "remark-gfm": "^4.0.1",
     "socket.io-client": "^4.8.1",
@@ -110,6 +112,6 @@
     "xlsx": "^0.18.5",
     "zod": "^3.24.2",
     "zod-validation-error": "^3.4.0",
-    "zustand": "^5.0.3"
+    "zustand": "^5.0.8"
   }
 }