Merge branch 'fix/33' into dev2

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,40 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: 'BUG: '
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Navigate to '...'
-2. Select/Press '....'
-3. Execute operation '....'
-4. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots/Photos**
-If applicable, add screenshots from the HMI display or photos of the machine screen to help explain your problem.
-
-**Machine Information (please complete the following):**
- - Machine Type: [Winder2, Laser, Aquapath...]
- - Control Software Version: [e.g. 2.4.1]
- - Settings: [e.g. Different Gear Ratios, PID Settings, …]
-
-**Device Information (if issue occurs on external device):**
- - Device Type: [e.g. Tablet, PLC, Remote Control Panel]
- - OS: [e.g. Windows 10, Linux, etc.]
- - Connection Type: [e.g. Ethernet, USB]
-
-**Error Messages/Codes**
-If applicable, provide exact error codes or messages displayed or found in the troubleshooting terminal.
-
-**Additional context**
-Add any other context about the problem here (e.g., recent software updates, environmental factors).

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,33 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: 'Feat: '
-labels: ''
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. During operation, I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions, workarounds, or features you've considered.
-
-**Use Case/Application:**
- - Machine Type(s): [e.g. All machines, Winder, Aquapath, ...]
- - Frequency of Use: [e.g. Daily, During setup, Occasionally]
-
-**Expected Benefits:**
- - Efficiency Improvement: [e.g. Reduces setup time by X minutes, Eliminates manual steps]
- - Safety Enhancement: [e.g. Prevents operator error, Adds safety checks]
- - Production Impact: [e.g. Increases throughput, Reduces downtime, Improves quality]
- - User Experience: [e.g. Simplifies workflow, Reduces training time]
-
-**Mockups/Sketches**
-If applicable, add sketches, mockups, or photos showing how the feature would appear on the HMI display or integrate with the machine.
-
-**Additional context**
-Add any other context, industry standards, or examples from other control systems about the feature request here.

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,14 +0,0 @@
-## What does this PR do / add / change?
-
-<!-- Describe the purpose of this PR. What problem does it solve or what feature does it add? -->
-
-## Screenshots
-
-<!-- Include screenshots for any UI changes. Remove this section if not applicable. -->
-
-## Checklist before opening the pr
-
-- [ ] Tested locally
-- [ ] Tested on the machine (if hardware interaction is involved)
-- [ ] No format errors (`cargo fmt` / `npm run format`)
-- [ ] No build errors (`cargo build` / `npm run build`)

.github/copilot-instructions.md

@@ -1,29 +0,0 @@
-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

.github/dependabot.yml

@@ -1,19 +1,16 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
 version: 2
 updates:
-  - package-ecosystem: "npm"
-    directory: "/electron"
+  - package-ecosystem: "npm" # See documentation for possible values
+    directory: "/electron" # Location of package manifests
     schedule:
-      interval: "monthly"
-    ignore:
-    - dependency-name: "*"
-      update-types:
-        - "version-update:semver-minor"
+      interval: "weekly"
 
-  - package-ecosystem: "cargo"
-    directory: "/"
+  - package-ecosystem: "cargo" # See documentation for possible values
+    directory: "/" # Location of package manifests
     schedule:
-      interval: "monthly"
-    ignore:
-      - dependency-name: "*"
-        update-types:
-          - "version-update:semver-minor"
+      interval: "weekly"

.github/workflows/electron.yml

@@ -3,76 +3,44 @@ name: Electron
 on:
   push:
     branches:
-      - master
+      - "**"
   pull_request:
     branches:
-      - master
-
-permissions:
-  contents: read
-
-defaults:
-  run:
-    working-directory: electron
+      - "*"
 
 jobs:
-  build:
+  build-electron:
     runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: electron
 
     steps:
-      - &checkout
-        name: Checkout
-        uses: actions/checkout@v4
-
-      - &setup-node
-        name: Setup Node.js
+      - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: 20
-          cache: "npm"
-          cache-dependency-path: |
-            electron/package-lock.json
+          node-version: "18" # or '20' for latest LTS
 
-      - &install
-        name: Install dependencies
-        run: npm ci
+      - uses: actions/checkout@v4
 
-      - name: Compile
-        run: tsc
+      - name: Cache NPM dependencies
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.npm
+            node_modules/
+          key: ${{ runner.os }}-npm-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-npm-
 
-      - name: Build
-        run: npm run build
+      - name: Install
+        run: npm i
 
-  test:
-    runs-on: ubuntu-latest
-    needs: build
-
-    steps:
-      - *checkout
-      - *setup-node
-      - *install
+      - name: Lint
+        run: npm run lint
 
       - name: Test
         run: npm run test
 
-  format:
-    runs-on: ubuntu-latest
-
-    steps:
-      - *checkout
-      - *setup-node
-      - *install
-
-      - name: Format
-        run: npm run format
-
-  lint:
-    runs-on: ubuntu-latest
-
-    steps:
-      - *checkout
-      - *setup-node
-      - *install
-
-      - name: Lint
-        run: npm run lint
+      - name: Build
+        run: npm run package

.github/workflows/issue-status-check.yml

@@ -1,213 +0,0 @@
-name: Stale Assigned Issue Check
-
-on:
-  schedule:
-    # Run every Sunday at 9:00 AM UTC
-    - cron: '0 9 * * 0'
-  workflow_dispatch: # Allow manual triggering for testing
-
-jobs:
-  check-stale-issues:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      issues: write
-      pull-requests: read
-    
-    steps:
-      - name: Check assigned issues for status updates
-        uses: actions/github-script@v7
-        with:
-          script: |
-            const ONE_WEEK_MS = 7 * 24 * 60 * 60 * 1000;
-            const now = new Date();
-            
-            // Helper function to check rate limits
-            async function checkRateLimit() {
-              try {
-                const { data: rateLimit } = await github.rest.rateLimit.get();
-                const remaining = rateLimit.resources.core.remaining;
-                const reset = new Date(rateLimit.resources.core.reset * 1000);
-                console.log(`Rate limit: ${remaining} requests remaining (resets at ${reset.toISOString()})`);
-                return remaining > 10; // Stop if fewer than 10 requests remaining
-              } catch (error) {
-                console.log(`Could not check rate limit: ${error.message}`);
-                return true; // Continue on error
-              }
-            }
-            
-            // Get all open issues
-            const issues = await github.paginate(github.rest.issues.listForRepo, {
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              state: 'open',
-              per_page: 100
-            });
-            
-            console.log(`Found ${issues.length} open issues`);
-            
-            // Helper function to check if issue has linked PRs using GraphQL
-            async function hasLinkedPRs(issueNumber) {
-              try {
-                const query = `
-                  query($owner: String!, $repo: String!, $issueNumber: Int!) {
-                    repository(owner: $owner, name: $repo) {
-                      issue(number: $issueNumber) {
-                        timelineItems(first: 100, itemTypes: CONNECTED_EVENT) {
-                          nodes {
-                            ... on ConnectedEvent {
-                              subject {
-                                ... on PullRequest {
-                                  number
-                                  state
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                `;
-                
-                const result = await github.graphql(query, {
-                  owner: context.repo.owner,
-                  repo: context.repo.repo,
-                  issueNumber: issueNumber
-                });
-                
-                const linkedPRs = result.repository.issue.timelineItems.nodes
-                  .filter(node => node.subject && node.subject.state === 'OPEN')
-                  .map(node => node.subject.number);
-                
-                return linkedPRs.length > 0;
-              } catch (error) {
-                console.log(`Could not check linked PRs for issue #${issueNumber}: ${error.message}`);
-                return false; // Assume no linked PRs on error to avoid false positives
-              }
-            }
-            
-            let processedCount = 0;
-            let commentedCount = 0;
-            let errorCount = 0;
-            
-            for (const issue of issues) {
-              try {
-                // Check rate limit periodically
-                if (processedCount % 10 === 0 && !(await checkRateLimit())) {
-                  console.log('Rate limit nearly exhausted, stopping to avoid hitting limit');
-                  break;
-                }
-                
-                // Skip pull requests (they appear in issues list too)
-                if (issue.pull_request) {
-                  continue;
-                }
-                
-                // Skip if not assigned
-                if (!issue.assignees || issue.assignees.length === 0) {
-                  console.log(`Issue #${issue.number}: Not assigned, skipping`);
-                  continue;
-                }
-                
-                console.log(`Checking issue #${issue.number}: ${issue.title}`);
-                processedCount++;
-                
-                // Check if issue has linked PRs
-                const hasOpenLinkedPR = await hasLinkedPRs(issue.number);
-                
-                if (hasOpenLinkedPR) {
-                  console.log(`Issue #${issue.number}: Has linked open PR, skipping`);
-                  continue;
-                }
-                
-                // Get all comments on the issue
-                let comments = [];
-                try {
-                  comments = await github.paginate(github.rest.issues.listComments, {
-                    owner: context.repo.owner,
-                    repo: context.repo.repo,
-                    issue_number: issue.number,
-                    per_page: 100
-                  });
-                } catch (commentError) {
-                  console.error(`Issue #${issue.number}: Could not fetch comments - ${commentError.message}`);
-                  errorCount++;
-                  continue;
-                }
-                
-                // Find the most recent comment or update
-                let lastActivity = new Date(issue.created_at);
-                
-                if (issue.updated_at) {
-                  lastActivity = new Date(issue.updated_at);
-                }
-                
-                if (comments.length > 0) {
-                  const lastComment = comments[comments.length - 1];
-                  const lastCommentDate = new Date(lastComment.created_at);
-                  if (lastCommentDate > lastActivity) {
-                    lastActivity = lastCommentDate;
-                  }
-                }
-                
-                // Check if last activity was more than a week ago
-                const daysSinceActivity = Math.floor((now - lastActivity) / (1000 * 60 * 60 * 24));
-                
-                if (daysSinceActivity >= 7) {
-                  console.log(`Issue #${issue.number}: No activity for ${daysSinceActivity} days`);
-                  
-                  // Check if we already posted a status request in the last 7 days
-                  const recentComments = comments.filter(comment => {
-                    const commentDate = new Date(comment.created_at);
-                    return (now - commentDate) < ONE_WEEK_MS;
-                  });
-                  
-                  const alreadyAsked = recentComments.some(comment => 
-                    comment.user.type === 'Bot' && 
-                    comment.body.includes('status update')
-                  );
-                  
-                  if (alreadyAsked) {
-                    console.log(`Issue #${issue.number}: Already requested status this week, skipping`);
-                    continue;
-                  }
-                  
-                  // Post a status request comment
-                  try {
-                    const assigneeNames = issue.assignees.map(a => `@${a.login}`).join(', ');
-                    await github.rest.issues.createComment({
-                      owner: context.repo.owner,
-                      repo: context.repo.repo,
-                      issue_number: issue.number,
-                      body: `Hi ${assigneeNames}! 👋\n\n` +
-                            `This issue has been assigned to you for ${daysSinceActivity} days with no recent activity or linked pull requests.\n\n` +
-                            `Could you please provide a status update? If you're:\n` +
-                            `- ✅ Working on it: Let us know your progress\n` +
-                            `- 🔄 Need help: Tag someone or describe what's blocking you\n` +
-                            `- 🚫 No longer working on it: Let us know so we can reassign\n\n` +
-                            `Thank you!`
-                    });
-                    
-                    console.log(`Issue #${issue.number}: Posted status request comment`);
-                    commentedCount++;
-                  } catch (commentError) {
-                    console.error(`Issue #${issue.number}: Could not post comment - ${commentError.message}`);
-                    errorCount++;
-                    // Continue to next issue
-                  }
-                } else {
-                  console.log(`Issue #${issue.number}: Activity ${daysSinceActivity} days ago, still fresh`);
-                }
-              } catch (error) {
-                console.error(`Issue #${issue.number}: Error processing - ${error.message}`);
-                errorCount++;
-                // Continue to next issue instead of failing the entire workflow
-                continue;
-              }
-            }
-            
-            console.log(`\nStale issue check complete!`);
-            console.log(`Processed: ${processedCount} issues`);
-            console.log(`Commented on: ${commentedCount} issues`);
-            console.log(`Errors: ${errorCount}`);

.github/workflows/nix.yml

@@ -1,99 +0,0 @@
-name: Nix CI
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-permissions:
-  contents: read
-
-env:
-  NIX_PATH: nixpkgs=channel:nixos-25.05
-
-jobs:
-  electron:
-    runs-on: ubuntu-latest
-
-    steps:
-      - &checkout
-        name: Check out repository
-        uses: actions/checkout@v4
-
-      - &nix-install
-        uses: nixbuild/nix-quick-install-action@v34
-        with:
-          nix_conf: |
-            keep-env-derivations = true
-            keep-outputs = true
-
-      - uses: nix-community/cache-nix-action@v6
-        with:
-          primary-key: nix-electron-${{ runner.os }}-${{ hashFiles('**/*.nix', '**/flake.lock', './electron/package-lock.json') }}
-          restore-prefixes-first-match: nix-${{ runner.os }}-
-          purge: true
-          purge-prefixes: nix-electron-${{ runner.os }}-
-
-      - name: Build Electron in Nix
-        run: nix build ".#packages.x86_64-linux.electron"
-
-  rust:
-    runs-on: ubuntu-latest
-
-    steps:
-      - *checkout
-      - *nix-install
-
-      - uses: nix-community/cache-nix-action@v6
-        with:
-          primary-key: nix-server-${{ runner.os }}-${{ hashFiles('**/*.nix', '**/flake.lock', './Cargo.lock') }}
-          restore-prefixes-first-match: nix-${{ runner.os }}-
-          purge: true
-          purge-prefixes: nix-server-${{ runner.os }}-
-
-      - name: Build Server in Nix
-        run: nix build ".#packages.x86_64-linux.server"
-
-  build:
-    runs-on: ubuntu-latest
-    needs: [electron, rust]
-
-    steps:
-      - *checkout
-      - *nix-install
-
-      - name: Use both Electron and Server Nix Store
-        uses: nix-community/cache-nix-action@v6
-        with:
-          primary-key: nix-${{ runner.os }}-${{ hashFiles('**/*.nix', '**/flake.lock', './Cargo.lock', './electron/package-lock.json') }}
-
-          # if no hit on the primary key, merge individual caches
-          restore-prefixes-all-matches: |
-            nix-electron-${{ runner.os }}-
-            nix-server-${{ runner.os }}-
-
-      - name: Build Flake and System Configuration
-        run: nix build ".#nixosConfigurations.nixos.config.system.build.toplevel" --impure
-
-  format:
-    runs-on: ubuntu-latest
-
-    steps:
-      - *checkout
-      - *nix-install
-
-      - name: Format
-        run: nix run 'nixpkgs#nixfmt-classic' $(find . nixos -name '*.nix')
-
-  check:
-    runs-on: ubuntu-latest
-
-    steps:
-      - *checkout
-      - *nix-install
-
-      - name: Build Flake and Configuration.nix
-        run: nix flake check "." --impure

.github/workflows/rust.yml

@@ -3,41 +3,25 @@ name: Rust
 on:
   push:
     branches:
-      - master
+      - "**"
   pull_request:
-    branches:
-      - master
+    branches: "*"
 
 env:
   CARGO_TERM_COLOR: always
   RUST_VERSION: "1.86"
 
-permissions:
-  contents: read
-
 jobs:
   build:
     runs-on: ubuntu-latest
 
     steps:
-      - &udev-install
-        name: Install libudev development package
+      - name: Install libudev development package
         run: sudo apt-get update && sudo apt-get install -y libudev-dev
-
-      - &checkout
-        uses: actions/checkout@v4
-
-      - &setup-rust
-        name: Install Rust toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.RUST_VERSION }}
-          profile: minimal
-          override: true
-          components: rustfmt
-
-      - &cargo-cache
-        name: Cache Rust dependencies
+      - uses: actions/checkout@v4
+      - name: Set Rust version
+        run: rustup override set ${{ env.RUST_VERSION }}
+      - name: Cache Rust dependencies
         uses: actions/cache@v3
         with:
           path: |
@@ -51,40 +35,7 @@ jobs:
             ${{ runner.os }}-${{ env.RUST_VERSION }}-cargo-
 
       - name: Build
-        env:
-          RUSTFLAGS: "-D warnings"
         run: cargo build --verbose
 
-  format:
-    runs-on: ubuntu-latest
-
-    steps:
-      - *checkout
-      - *setup-rust
-
-      - name: Format
-        run: cargo fmt --check --verbose
-
-  test:
-    runs-on: ubuntu-latest
-
-    steps:
-      - *udev-install
-      - *checkout
-      - *setup-rust
-      - *cargo-cache
-
       - name: Run tests
         run: cargo test --verbose
-
-  mock:
-    runs-on: ubuntu-latest
-
-    steps:
-      - *udev-install
-      - *checkout
-      - *setup-rust
-      - *cargo-cache
-
-      - name: Mock Machine
-        run: cargo build --features "development-build,mock-machine"

.github/workflows/update-npm-hash.yml

@@ -1,80 +0,0 @@
-name: Update npm deps hash
-
-on:
-  pull_request:
-    paths:
-      - 'electron/package-lock.json'
-      - 'electron/package.json'
-  workflow_dispatch:
-
-env:
-  NIX_PATH: nixpkgs=channel:nixos-25.05
-
-permissions:
-  contents: write
-  pull-requests: write
-  actions: write
-
-jobs:
-  update-hash:
-    runs-on: ubuntu-latest
-    if: github.event.pull_request.head.repo.full_name == github.repository
-
-    steps:
-      - name: Check out repository
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ github.head_ref }}
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Install Nix
-        uses: nixbuild/nix-quick-install-action@v34
-        with:
-          nix_conf: |
-            keep-env-derivations = true
-            keep-outputs = true
-
-      - name: Calculate new npm deps hash
-        id: calc-hash
-        run: |
-          # Calculate the hash using nix run with nixpkgs
-          NEW_HASH=$(nix run 'nixpkgs#prefetch-npm-deps' electron/package-lock.json)
-          echo "hash=$NEW_HASH" >> $GITHUB_OUTPUT
-          echo "Calculated hash: $NEW_HASH"
-
-      - name: Update npmDepsHash in electron.nix
-        run: |
-          NEW_HASH="${{ steps.calc-hash.outputs.hash }}"
-          sed -i "s|npmDepsHash = \".*\";|npmDepsHash = \"$NEW_HASH\";|" nixos/packages/electron.nix
-          
-      - name: Check if hash changed
-        id: check-changes
-        run: |
-          if git diff --quiet nixos/packages/electron.nix; then
-            echo "changed=false" >> $GITHUB_OUTPUT
-            echo "No changes needed - hash is already correct"
-          else
-            echo "changed=true" >> $GITHUB_OUTPUT
-            echo "Hash updated in electron.nix"
-          fi
-
-      - name: Commit and push if changed
-        if: steps.check-changes.outputs.changed == 'true'
-        run: |
-          git config --local user.email "github-actions[bot]@users.noreply.github.com"
-          git config --local user.name "github-actions[bot]"
-          git add nixos/packages/electron.nix
-          git commit -m "chore: update npmDepsHash to ${{ steps.calc-hash.outputs.hash }}"
-          git push
-
-      - name: Comment on PR
-        if: steps.check-changes.outputs.changed == 'true'
-        uses: actions/github-script@v7
-        with:
-          script: |
-            github.rest.issues.createComment({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: 'Automatically updated `npmDepsHash` to `${{ steps.calc-hash.outputs.hash }}`\n\n**Next step:** Trigger the checks by pushing an empty commit:\n```bash\ngit commit --allow-empty -m "trigger ci" && git push\n```'
-            })

.gitignore

@@ -1,11 +1,5 @@
 target/
 dist/
 .DS_Store
+Cargo.lock
 dhat-heap.json
-build.sh
-shell.nix
-node_modules/
-runtime_metrics.csv
-compile_metrics.csv
-.idea/
-electron/dist-electron/

.mailmap

@@ -1,49 +0,0 @@
-# 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,6 +1,5 @@
 {
     "typescript.inlayHints.enumMemberValues.enabled": false,
-    "git.detectSubmodules": true,
-    "git.detectSubmodulesLimit": 10,
-    "rust-analyzer.check.command": "clippy",
+     "git.detectSubmodules": true,
+     "git.detectSubmodulesLimit": 10,
 }

CHANGELOG.md

@@ -1,277 +1 @@
-# `2.14.1`
-_26.01.2026_
-
-## Laser
--[#1079](https://github.com/qitechgmbh/control/pull/1079) Fixed Overflowing of buffer for Graphs causing crashes
-
-# `2.14.0`
-_22.01.2026_
-
-## General 
-- [#1040](https://github.com/qitechgmbh/control/pull/1040) Added API for reading Machine Data
-
-# `2.13.0`
-_07.01.2026_
-
-## General
-- [#925](https://github.com/qitechgmbh/control/pull/925) Switch to Setup when selected machine is disconnected
-- [#937](https://github.com/qitechgmbh/control/pull/937) Added minimal Support for WAGO 
-- [#945](https://github.com/qitechgmbh/control/pull/945) Improvements for On-Screen Keyboard usage in Ethercat Setup Page
-
-## Extruder V3
-- [#930](https://github.com/qitechgmbh/control/pull/930) Added Extruder V3
-
-## Laser
-- [#924](https://github.com/qitechgmbh/control/pull/924) Roundness is now displayed as a percentage
-- [#885](https://github.com/qitechgmbh/control/pull/885) Added Min and Max Diameter
-- [#849](https://github.com/qitechgmbh/control/pull/849) Added a Warning if Filament is out of Spec
-
-## Aquapath
-- [#976](https://github.com/qitechgmbh/control/pull/976) Improved Stability
-
-
-# `2.12.0`
-_17.11.2025_
-
-## General
-- [#847](https://github.com/qitechgmbh/control/pull/847) Improved discovery and initialization 
-- [#859](https://github.com/qitechgmbh/control/pull/859) Improved update speed
-- [#897](https://github.com/qitechgmbh/control/pull/897), [#899](https://github.com/qitechgmbh/control/pull/899), [#852](https://github.com/qitechgmbh/control/pull/852)  Improved system stability
-- [#817](https://github.com/qitechgmbh/control/pull/817) Added an update bar
-
-## Laser
-- [#857](https://github.com/qitechgmbh/control/pull/857) Fixed potential issues with 2 Axis Laser
-
-## Extruder V2
-- [#881](https://github.com/qitechgmbh/control/pull/881) Extended Temperature PID Configuration
-
-
-# `2.11.0`
-_21.10.2025_
-
-## General 
-- [#829](https://github.com/qitechgmbh/control/pull/829), [#834](https://github.com/qitechgmbh/control/pull/834), Improved overall system stability
-
-## Winder V2 
-- [#840](https://github.com/qitechgmbh/control/pull/840) Added XL Winder option
-- [#827](https://github.com/qitechgmbh/control/pull/827) Spool can now be run in reverse
-
-## Extruder V2
-- [#826](https://github.com/qitechgmbh/control/pull/826) Fine grained Temperature-PID configuration now possible
-
-
-# `2.10.0`
-_16.10.2025_
-
-## Winder V2
-- [#776](https://github.com/qitechgmbh/control/pull/776) Added explanation for padding in winder manual
-- [#804](https://github.com/qitechgmbh/control/pull/804) Added gearbox conversion
-
-## General 
-- [#717](https://github.com/qitechgmbh/control/pull/717) Show from option for graphs added
-- [#805](https://github.com/qitechgmbh/control/pull/805) Graphs run better now
-
-
-
-# `2.9.1`
-_10.10.2025_
-
-## Winder V2
-- [#796](https://github.com/qitechgmbh/control/pull/796) Winding in adaptive mode, while puller is in reverse mode is now possible
-
-## General
-- [#780](https://github.com/qitechgmbh/control/pull/780) Updates are faster now
-- [#746](https://github.com/qitechgmbh/control/pull/746) Improved scrollbar styling for manuals
-
-# `2.9.0`
-_06.10.2025_
-
-## 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
-
-- [#550](https://github.com/qitechgmbh/control/pull/551) Can now reset wound distance while winding
-
-## General
-
-- [#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
-
-- [#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_
-
-## Extruder V2
-
-- [#455](https://github.com/qitechgmbh/control/pull/458), Greatly improved stability and precision of pressure-based regulation for the motor
-- [#467](https://github.com/qitechgmbh/control/pull/468), [#448](https://github.com/qitechgmbh/control/pull/449), [#485](https://github.com/qitechgmbh/control/pull/486) Improved the Responsiveness for motor control and monitoring
-- [#138](https://github.com/qitechgmbh/control/pull/495), Added a Warning in case the Pressure sensor is disconnected or incorrectly wired
-- [#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
-
-- [#121](https://github.com/qitechgmbh/control/pull/121), Use Linux realtime threads for EtherCAT and control loop (PREEMPT_RT)
-- [#138](https://github.com/qitechgmbh/control/pull/495), Updated Quick Start Guide
-
-# `2.1.0`
-
-_30.06.2025_
-
-## Extruder V2
-
-- Intial Stable Release of **Extruder V2**
-
-## Winder V2
-
-- [#420](https://github.com/qitechgmbh/control/pull/429), [#401](https://github.com/qitechgmbh/control/pull/401) Add _Adaptive_ spool speed algorithm, the old algorithm is now called _Minmax_ ans tillavailable.
-- [#427](https://github.com/qitechgmbh/control/pull/427) Add _Estimated Spool Diameter_ graph
-- [#419](https://github.com/qitechgmbh/control/pull/419) Fix Issue where traverse won't work at low spool speed
-
-## Laser V1
-
-- Initial Stable Release of **Laser V1**
-
-## HMI Panel
-
-- [#339](https://github.com/qitechgmbh/control/pull/338) Don't go into sleep Mmde
-- [#410](https://github.com/qitechgmbh/control/pull/410) Ship with Wireshark
-- [#424](https://github.com/qitechgmbh/control/pull/424) Updates can be canceled
-
-## General
-
-- [#269](https://github.com/qitechgmbh/control/pull/269), [#370](https://github.com/qitechgmbh/control/pull/370) Improved performace of live values
-- [#358](https://github.com/qitechgmbh/control/pull/358), [#343](https://github.com/qitechgmbh/control/pull/343), [#324](https://github.com/qitechgmbh/control/pull/324), [#390](https://github.com/qitechgmbh/control/pull/390), [#299](https://github.com/qitechgmbh/control/pull/299) Improved functionality for graphs
-- [#405](https://github.com/qitechgmbh/control/pull/405) Remove weird color behaviour on tocuhscreens
-- [#369](https://github.com/qitechgmbh/control/pull/369) More failsafe EtherCAT loop
-
-# `2.0.1`
-
-_10.06.2025_
-
-# `2.0.0`
-
-_10.06.2025_
-
-## General
-
-- Initial stable release of QiTech Control.
-
-## Winder V2
-
-- Initial stable release of **Winder V2**
-
-## Features
-
-- Stabilized **Winder V2**
+# Unreleased

Cargo.toml

@@ -4,27 +4,7 @@ members = [
     "ethercat-hal",
     "ethercat-hal-derive",
     "control-core",
-    "machines",
-    #"ethercat-eeprom-dump",
-    "control-core-derive",
-    "units",
-    "utils",
+    "ethercat-eeprom-dump",
 ]
 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

@@ -2,76 +2,144 @@
 
 # QiTech Control
 
-QiTech Control is an open-source framework designed to bring modern software development practices to certified industrial hardware.
+QiTech Control is an industrial control panel software for the next generation of QiTech recycling machines built on top of Beckhoff Automation hardware.
 
-It frees developers from proprietary, license-heavy PLC ecosystems and rigid "point-and-click" workflows that are no longer adequate for today's complex automation challenges.
+# Repo Structure
 
-QiTech Control combines the modularity and reliability of standard EtherCAT terminals (e.g., WAGO, Beckhoff) with the power of a modern Rust & React stack.
+Frontend
 
-## Documentation
+- `/electron`: Frontend code for the control software built with React and Electron.
 
-**[View Full Documentation Wiki](https://github.com/qitechgmbh/control/wiki)**
+Backend
 
-- [Getting Started](https://github.com/qitechgmbh/control/wiki/Getting-Started)
-- [Architecture Overview](https://github.com/qitechgmbh/control/wiki/Architecture-Overview)
-- [EtherCAT Basics](https://github.com/qitechgmbh/control/wiki/Ethercat-Basics)
-- [Device Examples](https://github.com/qitechgmbh/control/wiki/Hardware-Examples)
-- [REST API Reference](https://github.com/qitechgmbh/control/wiki/Rest-Api)
+- `/server`: Glue between Beckhoff and Electron. Implements machine logic.
+- `/ethercat-hal`: Hardware abstraction layer for Beckhoff (and possibly other EtherCat) devices and protocols.
+- `/ethercat-hal-derive`: Macros for `ethercat-hal`
+- `/control-core`: Core control logic for the server.
 
-## Videos
+Operating System
 
-| Software Demo | Full Explainer |
-|---------------|----------------|
-| [![](https://img.youtube.com/vi/KI3YeBwfV-s/maxresdefault.jpg)](https://www.youtube.com/watch?v=KI3YeBwfV-s)<br/>*Watch a demo of the control software in action* | [![](https://img.youtube.com/vi/55egCAkQgyM/maxresdefault.jpg)](https://youtu.be/55egCAkQgyM)<br/>*Watch a complete overview of QiTech Control* |
+- `/nixos`: Custom Linux with realtime kernel & preconfigured for touchscreens.
 
-## Repository Structure
+Other
 
-- **`/electron`** - React + Electron frontend
-- **`/server`** - Rust backend implementing machine logic
-- **`/ethercat-hal`** - Hardware abstraction layer for EtherCAT devices
-- **`/control-core`** - Core control logic
-- **`/nixos`** - Custom Linux OS with realtime kernel
+- `/docs`: Documentation for the project.
 
-## Technology Stack
+# Technology Choices
 
-**Backend:** Rust with [Ethercrab](https://github.com/ethercrab-rs/ethercrab) for EtherCAT, [SocketIO](https://socket.io/) for real-time communication, [axum](https://docs.rs/axum/latest/axum/) for REST API
+## Backend
 
-**Frontend:** [Electron](https://www.electronjs.org/) + [React](https://react.dev/) with [Shadcn](https://ui.shadcn.com/) components and [Tailwind](https://tailwindcss.com/) styling
+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.
+
+[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.
+
+We use [Smol](https://github.com/smol-rs/smol) for EtherCAT IO in the control loop for it's performance and [Tokio](https://tokio.rs/) for server IO because of it's ecosystem and maturity.
+
+## Frontend
+
+We could combine the code of the frontend and backend using [Doxius](https://dioxuslabs.com/) but it lacks good Linux support. We chose [Electron](https://www.electronjs.org/) with [React](https://react.dev/) for it's maturity and ecosystem. For the UI we use [Shadcn](https://ui.shadcn.com/) components and [Tailwind](https://tailwindcss.com/) for styling. For routing we use [TanStack Router](https://tanstack.com/router/v1).
+
+# Dev Setup
+
+## Backend
+
+- Rust stable 1.86^ toolchain (install via [rustup](https://rustup.rs/))
+- `rust-analyzer` extension for VSCode
+- Set your interface in `server/src/ethercat/init.rs` like `en10`
+- Connect a Beckhoff EK1100 to your interface
+- run `cd server && cargo run` to start the server (localhost:3001)
+
+## Frontend
+
+- nodejs and npm installed
+- run `cd electron && npm i && npm run start` to start the frontend
+
+# Machines
+
+| 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) |
+| 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     |                                 |
+| DRE          | V1      | ???          | Diameter Measuring Laser    | -                                                      | 1 (Qitech Industries GmbH) | 6          | Not Yet     |                                 |
+| Mock         | -       | ???          | Mock Machine for Testing    | -                                                      | 1 (Qitech Industries GmbH) | 7          | Not Yet     | -                               |
 
 
-## Hardware Examples
+# More Docs
 
-QiTech Control supports a wide range of EtherCAT hardware from WAGO and Beckhoff. We provide complete step-by-step tutorials with wiring diagrams and software configuration for many common modules.
+- [x] [Architecture & Data Flow](./docs/architecture-overview.md)
 
-**[View all hardware examples and tutorials on the wiki](https://github.com/qitechgmbh/control/wiki/Hardware-Examples)**
+  - [x] Example Winder V2
 
-Quick links to popular examples:
-- [EL2004 - LED Control](https://github.com/qitechgmbh/control/wiki/Minimal-Example-El2004) (simplest setup for beginners)
-- [EL3021 - Analog Input](https://github.com/qitechgmbh/control/wiki/Minimal-Example-El3021)
-- [EL7031 - Stepper Motor Control](https://github.com/qitechgmbh/control/wiki/Minimal-Example-El7031-Motor)
-- [WAGO 750-402 - Digital Input](https://github.com/qitechgmbh/control/wiki/Minimal-Example-Wago750-402)
-- [WAGO 750-455 - Analog Input](https://github.com/qitechgmbh/control/wiki/Minimal-Example-Wago-750-455)
+- [ ] Electron
 
-## QiTech Machines
+  - Folder Structure
+  - Routing with TanStack Router
+  - Design with Tailwind & Shadcn
+  - ...
 
-QiTech Control powers 10+ production machines for filament extrusion, winding, measurement, and material processing.
+- [ ] Interfacing with Electron/Server
 
-**[View complete machine catalog on the wiki](https://github.com/qitechgmbh/control/wiki/QiTech-Machines)**
+  - [ ] SocketIO
+    - Machine Namespace
+    - Main Namespace
+  - [ ] REST
+    - Machine Mutations
+    - Write Device Identification
 
+- Server
+  - [X] [Threading](./docs/control-loop.md)
+  - [ ] Control Loop Setup
+    - Control Loop Thread
+      - [ ] realtime
+    - Maindevice
+    - Group
+    - Extracting Device Identifications
+    - Identifying Groups
+    - Validating Machines
+    - Run Control Loop
+  - [x] [Control Loop](./docs/control-loop.md)
+  - [x] [Machine/Device Identification](./docs/identification.md)
+  - [ ] Machines
+    - When to create a new Machine?
+      - Versioning
+      - Code sharing
+    - Creating/Validating a Machine
+      - Validation
+      - Configuration
+  - [ ] Machine Implementation Guide
+    - Link: How to create a Device
+    - Link: How to create an Actor
+    - Link: How to create a Machine
+      - API (SocketIO + REST)
+      - Creation/Validation Logic
+        - Optional/Mandatory Devices
+        - Validate Devices
+      - Business Logic
+    - Link: How to create Machine Abstraction (Like Traverse/Puller/...)
+    - Forward `act` in winder.
 
-## Contributing
+- [ ] Control Core
 
-This is an open-source project. Contributions are welcome! Please see the [wiki](https://github.com/qitechgmbh/control/wiki) for development guidelines.
+  - [x] [Actors](./docs/actors.md)
+  - [ ] SocketIO
+    - Namespaces & Caching
+    - Joining leaving namespaces
+    - NamespaceId
+    - Caching
+      - Serverside Caching
+      - Clientside Caching
+  - [ ] REST
 
+- [x] Ethercat HAL
 
+  - [x] [Devices](./docs/devices.md)
+  - [x] [Configuration (CoE)](./docs/coe.md)
+  - [x] [IO](./docs/io.md)
+  - [x] [PDO](./docs/pdo.md)
 
-## Additional Videos
+- [x] [Ethercat Basics](./docs/ethercat-basics.md)
 
-| Episode Highlights |  |
-|--------------------|--------------------|
-| [![](https://img.youtube.com/vi/U2wNN6sF4to/maxresdefault.jpg)](https://www.youtube.com/watch?v=U2wNN6sF4to&t=163s)<br/>**Day in the Software Team**<br/>*Behind the scenes with Robin and how the team ships control software.* | [![](https://img.youtube.com/vi/R5WGAY3WRWA/maxresdefault.jpg)](https://www.youtube.com/watch?v=R5WGAY3WRWA&t=1s)<br/>**Software Stack Day**<br/>*A fast tour through the tools, stack, and daily workflow.* |
-| [![](https://img.youtube.com/vi/xyaHwxXguw4/maxresdefault.jpg)](https://www.youtube.com/watch?v=xyaHwxXguw4&t=32s)<br/>**First Client**<br/>*A milestone week building the first real client project.* | [![](https://img.youtube.com/vi/moI7z2PVdF4/maxresdefault.jpg)](https://www.youtube.com/watch?v=moI7z2PVdF4)<br/>**Steelworks Week**<br/>*A deep-dive week on a demanding steelworks order.* |
-
-## License
-
-See [LICENSE](LICENSE) file for details.
+- [x] [NixOS Operating System](./docs/nixos/README.md)

cargo_run_linux.sh

@@ -1,33 +1,13 @@
 #!/bin/bash
 
-set -e
-
-FEATURE=""
-
-# Check if "mock-machine" was passed as an argument
-if [[ "$1" == "mock-machine" ]]; then
-    echo "Building Debug Code with mock-machine feature"
-    FEATURE="--features mock-machine"
-fi
-
-if [[ "$1" == "release" ]]; then
+if [ $1 == "release" ]; then
     echo "building Release Code"
     cargo build --release
 else
-    echo "Building Debug Code"
-    cargo build $FEATURE --features development-build
+    echo "building Debug Code"
+    cargo build
 fi
-
-# Only setcap if not building with mock-machine
-if [ "$1" != "mock-machine" ]; then
-    echo "Setting capabilities for server executable"
-    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
-
+# set cap for server executable
+sudo setcap cap_net_raw=eip ./target/debug/server
 # run
 ./target/debug/server

compile_metrics.sh

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

compile_nix_pkgs.sh

@@ -1,43 +0,0 @@
-#!/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

@@ -1,15 +0,0 @@
-[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

@@ -1,65 +0,0 @@
-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,43 +3,21 @@ name = "control_core"
 version = "0.1.0"
 edition = "2024"
 
-[lints]
-workspace = true
-
 [dependencies]
-anyhow = "1.0.100"
-
-axum = "0.8.8"
-
+anyhow = "1.0.98"
+axum = "0.8.4"
 ethercat_hal = { path = "../ethercat-hal" }
-units = { path = "../units" }
-ethercrab = { git = "https://github.com/v-morlock/ethercrab", branch = "main" }
+ethercrab = "0.6"
 interfaces = "0.0.9"
+log = "0.4.27"
 serde = "1.0.219"
-serialport = "4.7.3"
+serde_json = "1.0.140"
+serialport = "4.7.1"
 smol = "2.0.2"
-socketioxide = "0.17.2"
+socketioxide = "0.17.0"
+uom = "0.36.0"
 bitvec = { version = "1.0.1", features = ["alloc"] }
-crc = "3.3.0"
-tracing = "0.1.44"
-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.176"
-
+crc = "3.2.1"
+serial = "0.4.0"
 [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/actors/analog_function_generator.rs

@@ -0,0 +1,91 @@
+use super::Actor;
+use ethercat_hal::io::analog_output::AnalogOutput;
+use std::{
+    f64::consts::PI,
+    future::Future,
+    pin::Pin,
+    time::{Duration, Instant},
+};
+use uom::si::{angle::radian, f64::Angle, ratio::ratio};
+pub type AnalogFunction = Box<dyn Fn(Duration) -> f64 + Send + Sync>;
+
+/// Can module analog output with a function
+pub struct AnalogFunctionGenerator {
+    output: AnalogOutput,
+    function: AnalogFunction,
+    start_ts: Instant,
+}
+
+impl AnalogFunctionGenerator {
+    pub fn new(output: AnalogOutput, function: AnalogFunction) -> Self {
+        Self {
+            output,
+            function,
+            start_ts: Instant::now(),
+        }
+    }
+}
+
+impl Actor for AnalogFunctionGenerator {
+    fn act(&mut self, now: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
+        Box::pin(async move {
+            let diff = now - self.start_ts;
+            let value = (self.function)(diff);
+            (self.output.write)((value as f32).into()).await;
+        })
+    }
+}
+
+pub fn analog_sine(amplitude: f64, normal: f64, period: Duration) -> AnalogFunction {
+    Box::new(move |dt: Duration| {
+        // Convert to seconds as f64 for calculation
+        let dt_secs = dt.as_secs_f64();
+        let period_secs = period.as_secs_f64();
+        let phase_secs = dt_secs % period_secs;
+        let angle = Angle::new::<radian>(2.0 * PI * phase_secs / period_secs);
+        let value = angle.sin().get::<ratio>();
+        value * (amplitude / 2.0) + normal + (amplitude / 2.0)
+    })
+}
+
+pub fn analog_multiply<const N: usize>(functions: [AnalogFunction; N]) -> AnalogFunction {
+    Box::new(move |dt: Duration| functions.iter().fold(1.0, |acc, func| acc * func(dt)))
+}
+
+pub fn analog_sawtooth(amplitude: f64, normal: f64, period: Duration) -> AnalogFunction {
+    Box::new(move |dt: Duration| {
+        let dt_secs = dt.as_secs_f64();
+        let period_secs = period.as_secs_f64();
+        let phase_secs = dt_secs % period_secs;
+        let value = phase_secs / period_secs;
+        value * amplitude + normal
+    })
+}
+
+pub fn analog_square(amplitude: f64, normal: f64, period: Duration) -> AnalogFunction {
+    Box::new(move |dt: Duration| {
+        let dt_secs = dt.as_secs_f64();
+        let period_secs = period.as_secs_f64();
+        let phase_secs = dt_secs % period_secs;
+        let value = if phase_secs < period_secs / 2.0 {
+            1.0
+        } else {
+            -1.0
+        };
+        value * amplitude + normal
+    })
+}
+
+pub fn analog_triangle(amplitude: f64, normal: f64, period: Duration) -> AnalogFunction {
+    Box::new(move |dt: Duration| {
+        let dt_secs = dt.as_secs_f64();
+        let period_secs = period.as_secs_f64();
+        let phase_secs = dt_secs % period_secs;
+        let value = if phase_secs < period_secs / 2.0 {
+            phase_secs / period_secs * 2.0
+        } else {
+            2.0 - phase_secs / period_secs * 2.0
+        };
+        value * amplitude + normal
+    })
+}

control-core/src/actors/analog_input_getter.rs

@@ -0,0 +1,40 @@
+use super::Actor;
+use ethercat_hal::io::analog_input::{AnalogInput, physical::AnalogInputValue};
+use std::{future::Future, pin::Pin, time::Instant};
+
+/// Log the state of a analog input
+#[derive(Debug)]
+pub struct AnalogInputGetter {
+    input: AnalogInput,
+    normalized: Option<f32>,
+}
+
+impl AnalogInputGetter {
+    pub fn new(input: AnalogInput) -> Self {
+        Self {
+            input,
+            normalized: None,
+        }
+    }
+
+    /// Value from -1.0 to 1.0
+    pub fn get_normalized(&self) -> Option<f32> {
+        self.normalized
+    }
+
+    pub fn get_physical(&self) -> Option<AnalogInputValue> {
+        match self.get_normalized() {
+            Some(normalized) => Some(self.input.range.normalized_to_physical(normalized)),
+            None => return None,
+        }
+    }
+}
+
+impl Actor for AnalogInputGetter {
+    fn act(&mut self, _now: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
+        Box::pin(async move {
+            let state = (self.input.state)().await;
+            self.normalized = Some(state.input.normalized);
+        })
+    }
+}

control-core/src/actors/digital_input_getter.rs

@@ -0,0 +1,35 @@
+use super::Actor;
+use ethercat_hal::io::digital_input::DigitalInput;
+use std::{future::Future, pin::Pin, time::Instant};
+
+/// Log the state of a digital input
+#[derive(Debug)]
+pub struct DigitalInputGetter {
+    input: DigitalInput,
+    value: bool,
+}
+
+impl DigitalInputGetter {
+    pub fn new(input: DigitalInput) -> Self {
+        Self {
+            input,
+            value: false,
+        }
+    }
+
+    /// Get the current value of the digital input
+    pub fn value(&self) -> bool {
+        self.value
+    }
+}
+
+impl Actor for DigitalInputGetter {
+    fn act(&mut self, _now: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
+        Box::pin(async move {
+            let state = (self.input.state)()
+                .await
+                .expect("Failed to get digital input state");
+            self.value = state.input.value;
+        })
+    }
+}

control-core/src/actors/digital_input_logger.rs

@@ -0,0 +1,25 @@
+use super::Actor;
+use ethercat_hal::io::digital_input::DigitalInput;
+use std::{future::Future, pin::Pin, time::Instant};
+
+/// Log the state of a digital input
+pub struct DigitalInputLogger {
+    input: DigitalInput,
+}
+
+impl DigitalInputLogger {
+    pub fn new(input: DigitalInput) -> Self {
+        Self { input }
+    }
+}
+
+impl Actor for DigitalInputLogger {
+    fn act(&mut self, _now: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
+        Box::pin(async move {
+            let state = (self.input.state)()
+                .await
+                .expect("Failed to get digital input state");
+            println!("DigitalInputLogger: {}", state.input.value);
+        })
+    }
+}

control-core/src/actors/digital_output_blinker.rs

@@ -0,0 +1,51 @@
+use super::Actor;
+use ethercat_hal::io::digital_output::DigitalOutput;
+use std::{
+    future::Future,
+    pin::Pin,
+    time::{Duration, Instant},
+};
+
+/// Set a digital output high and low with a given interval
+#[derive(Debug)]
+pub struct DigitalOutputBlinker {
+    last_toggle: Instant,
+    output: DigitalOutput,
+    interval: Duration,
+    enabled: bool,
+}
+
+impl DigitalOutputBlinker {
+    pub fn new(output: DigitalOutput, interval: Duration) -> Self {
+        Self {
+            last_toggle: Instant::now(),
+            output,
+            interval,
+            enabled: true,
+        }
+    }
+    pub fn set_interval(&mut self, interval: Duration) {
+        self.interval = interval;
+    }
+
+    pub fn set_enabled(&mut self, enabled: bool) {
+        self.enabled = enabled;
+    }
+}
+
+impl Actor for DigitalOutputBlinker {
+    fn act(&mut self, now: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
+        Box::pin(async move {
+            {
+                let state = (self.output.state)().await;
+                if now - self.last_toggle > self.interval {
+                    match state.output.into() {
+                        true => (self.output.write)(false.into()).await,
+                        false => (self.output.write)(true.into()).await,
+                    }
+                    self.last_toggle = now;
+                }
+            }
+        })
+    }
+}

control-core/src/actors/digital_output_blinkers.rs

@@ -0,0 +1,57 @@
+use super::Actor;
+use ethercat_hal::io::digital_output::DigitalOutput;
+use std::{
+    future::Future,
+    pin::Pin,
+    time::{Duration, Instant},
+};
+
+/// Set a series of digital outputs high in sequence with a given interval
+pub struct DigitalOutputBlinkers {
+    last_toggle: Instant,
+    outputs: Vec<Option<DigitalOutput>>,
+    index: usize,
+    interval: Duration,
+    enabled: bool,
+    amount: usize,
+}
+
+impl DigitalOutputBlinkers {
+    pub fn new(outputs: Vec<Option<DigitalOutput>>, interval: Duration, amount: usize) -> Self {
+        Self {
+            last_toggle: Instant::now(),
+            outputs,
+            interval,
+            enabled: true,
+            index: 0,
+            amount,
+        }
+    }
+
+    pub fn set_interval(&mut self, interval: Duration) {
+        self.interval = interval;
+    }
+
+    pub fn set_enabled(&mut self, enabled: bool) {
+        self.enabled = enabled;
+    }
+}
+
+impl Actor for DigitalOutputBlinkers {
+    fn act(&mut self, now: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
+        Box::pin(async move {
+            if now - self.last_toggle > self.interval {
+                if let Some(output) = &self.outputs[self.index] {
+                    (output.write)(true.into()).await;
+                }
+                let index_end =
+                    (self.index + self.outputs.len() - self.amount) % self.outputs.len();
+                if let Some(output) = &self.outputs[index_end] {
+                    (output.write)(false.into()).await;
+                }
+                self.last_toggle = now;
+                self.index = (self.index + 1) % self.outputs.len();
+            }
+        })
+    }
+}

control-core/src/actors/digital_output_setter.rs

@@ -0,0 +1,38 @@
+use super::Actor;
+use ethercat_hal::io::digital_output::DigitalOutput;
+use std::{future::Future, pin::Pin, time::Instant};
+
+/// Set a digital output high and low with a given interval
+#[derive(Debug)]
+pub struct DigitalOutputSetter {
+    output: DigitalOutput,
+    enabled: bool,
+}
+
+impl DigitalOutputSetter {
+    pub fn new(output: DigitalOutput) -> Self {
+        Self {
+            output,
+            enabled: false,
+        }
+    }
+    pub fn set(&mut self, enabled: bool) {
+        self.enabled = enabled;
+    }
+    pub fn get(&self) -> bool {
+        self.enabled
+    }
+    pub fn toggle(&mut self) {
+        self.enabled = !self.enabled;
+    }
+}
+
+impl Actor for DigitalOutputSetter {
+    fn act(&mut self, _now: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
+        Box::pin(async move {
+            {
+                (self.output.write)(self.enabled.into()).await;
+            }
+        })
+    }
+}

control-core/src/actors/mitsubishi_inverter_rs485/mod.rs

@@ -0,0 +1,525 @@
+use super::Actor;
+use crate::modbus::{
+    ModbusFunctionCode, ModbusRequest, ModbusResponse, calculate_modbus_rtu_timeout,
+};
+use ethercat_hal::io::serial_interface::{SerialEncoding, SerialInterface};
+use std::{
+    collections::VecDeque,
+    pin::Pin,
+    time::{Duration, Instant},
+};
+use uom::{
+    ConstZero,
+    si::{f64::Frequency, frequency::centihertz},
+};
+
+#[derive(Debug)]
+pub enum State {
+    /// WaitingForResponse is set after sending a request through the serial_interface
+    WaitingForResponse,
+    /// After Sending a Resuest we need to wait atleast one ethercat cycle
+    /// After one Cycle we check if el6021 status has transmit accepted toggled
+    /// Then we can set state = ReadyToSend
+    WaitingForRequestAccept,
+    /// After Receiving a Response we need to wait atleast one ethercat cycle
+    /// After one Cycle we check if el6021 status has received accepted toggled
+    WaitingForReceiveAccept,
+    /// ReadyToSend is set after receiving the response from the serial_interface
+    ReadyToSend,
+    /// Initial State
+    Uninitialized,
+}
+
+#[derive(Debug)]
+pub enum OperationMode {
+    PU,
+    EXT,
+    NET,
+}
+
+impl MitsubishiInverterRS485Actor {
+    pub fn convert_hz_float_to_word(&mut self, value: Frequency) -> u16 {
+        let scaled = value.get::<centihertz>(); // Convert Hz to 0.01 Hz units
+        scaled.round() as u16
+    }
+
+    pub fn set_frequency_target(&mut self, frequency: Frequency) {
+        let mut request: MitsubishiModbusRequest =
+            MitsubishiControlRequests::WriteRunningFrequency.into();
+        let result: u16 = self.convert_hz_float_to_word(frequency); // convert hz float to short
+        request.request.data[2] = result.to_le_bytes()[1];
+        request.request.data[3] = result.to_le_bytes()[0];
+        self.add_request(request);
+    }
+
+    pub fn read_running_frequency() {
+        // Check if the current element pushed to front is freq event
+    }
+
+    pub fn switch_operation_mode() {}
+}
+
+/// Specifies all System environmet Variables
+/// Register addresses are calculated as follows: Register-value 40002 -> address: 40002-40001 -> address:0x1
+enum MitsubishiSystemRegister {
+    /// Register 40002
+    InverterReset,
+    /// Register 40003
+    ParameterClear,
+    /// Register 40004
+    AllParameterClear,
+    /// Register 40006
+    ParamClearNonCommunication,
+    /// Register 40007
+    AllParameterClearNonCommunication,
+    /// Register 40009
+    InverterStatusAndControl,
+    /// Register 40010
+    OperationModeAndSetting,
+    /// Register 40014
+    RunningFrequencyRAM,
+    /// Register 40015
+    RunningFrequencyEEPROM,
+    /// Register 40201
+    MotorFrequency,
+}
+
+impl MitsubishiControlRequests {
+    fn get_system_register(value: MitsubishiSystemRegister) -> u16 {
+        match value {
+            MitsubishiSystemRegister::InverterReset => 0x1,
+            MitsubishiSystemRegister::ParameterClear => 0x2,
+            MitsubishiSystemRegister::AllParameterClear => 0x3,
+            MitsubishiSystemRegister::ParamClearNonCommunication => 0x5,
+            MitsubishiSystemRegister::AllParameterClearNonCommunication => 0x6,
+            MitsubishiSystemRegister::InverterStatusAndControl => 0x8,
+            MitsubishiSystemRegister::OperationModeAndSetting => 0x9,
+            MitsubishiSystemRegister::RunningFrequencyRAM => 0x0d,
+            MitsubishiSystemRegister::RunningFrequencyEEPROM => 0x0e,
+            MitsubishiSystemRegister::MotorFrequency => 0x00C8,
+        }
+    }
+}
+
+impl From<MitsubishiControlRequests> for MitsubishiModbusRequest {
+    fn from(request: MitsubishiControlRequests) -> Self {
+        match request {
+            MitsubishiControlRequests::WriteRunningFrequency => {
+                let reg: u16 = MitsubishiControlRequests::get_system_register(
+                    MitsubishiSystemRegister::RunningFrequencyRAM,
+                );
+                let reg_bytes = reg.to_be_bytes();
+                MitsubishiModbusRequest {
+                    request: ModbusRequest {
+                        slave_id: 1,
+                        function_code: ModbusFunctionCode::PresetHoldingRegister,
+                        data: vec![reg_bytes[0], reg_bytes[1], 0x0, 0x0],
+                    },
+                    request_type: RequestType::OperationCommand,
+                    expected_response_type: ResponseType::WriteFrequency,
+                }
+            }
+            MitsubishiControlRequests::ReadInverterStatus => {
+                let reg: u16 = MitsubishiControlRequests::get_system_register(
+                    MitsubishiSystemRegister::InverterStatusAndControl,
+                );
+                let reg_bytes = reg.to_be_bytes();
+                MitsubishiModbusRequest {
+                    request: ModbusRequest {
+                        slave_id: 1,
+                        function_code: ModbusFunctionCode::ReadHoldingRegister,
+                        data: vec![reg_bytes[0], reg_bytes[1], 0x00, 0x01], // Read 1 register
+                    },
+                    request_type: RequestType::OperationCommand,
+                    expected_response_type: ResponseType::InverterStatus,
+                }
+            }
+            MitsubishiControlRequests::StopMotor => {
+                let reg: u16 = MitsubishiControlRequests::get_system_register(
+                    MitsubishiSystemRegister::InverterStatusAndControl,
+                );
+                let reg_bytes = reg.to_be_bytes();
+                MitsubishiModbusRequest {
+                    request: ModbusRequest {
+                        slave_id: 1,
+                        function_code: ModbusFunctionCode::PresetHoldingRegister,
+                        data: vec![reg_bytes[0], reg_bytes[1], 0x00, 0x01], // Value 1 to stop
+                    },
+                    request_type: RequestType::OperationCommand,
+                    expected_response_type: ResponseType::InverterControl,
+                }
+            }
+            MitsubishiControlRequests::StartForwardRotation => {
+                let reg: u16 = MitsubishiControlRequests::get_system_register(
+                    MitsubishiSystemRegister::InverterStatusAndControl,
+                );
+                let reg_bytes = reg.to_be_bytes();
+                MitsubishiModbusRequest {
+                    request: ModbusRequest {
+                        slave_id: 1,
+                        function_code: ModbusFunctionCode::PresetHoldingRegister,
+                        data: vec![reg_bytes[0], reg_bytes[1], 0, 0b00000010], // Value 2 for forward rotation
+                    },
+                    request_type: RequestType::OperationCommand,
+                    expected_response_type: ResponseType::InverterControl,
+                }
+            }
+            MitsubishiControlRequests::StartReverseRotation => {
+                let reg: u16 = MitsubishiControlRequests::get_system_register(
+                    MitsubishiSystemRegister::InverterStatusAndControl,
+                );
+                let reg_bytes = reg.to_be_bytes();
+                MitsubishiModbusRequest {
+                    request: ModbusRequest {
+                        slave_id: 1,
+                        function_code: ModbusFunctionCode::PresetHoldingRegister,
+                        data: vec![reg_bytes[0], reg_bytes[1], 0, 0b00000100], // Value 4 for reverse rotation
+                    },
+                    request_type: RequestType::OperationCommand,
+                    expected_response_type: ResponseType::InverterControl,
+                }
+            }
+            MitsubishiControlRequests::ReadRunningFrequency => {
+                let reg: u16 = MitsubishiControlRequests::get_system_register(
+                    MitsubishiSystemRegister::RunningFrequencyRAM,
+                );
+                let reg_bytes = reg.to_be_bytes();
+                MitsubishiModbusRequest {
+                    request: ModbusRequest {
+                        slave_id: 1,
+                        function_code: ModbusFunctionCode::ReadHoldingRegister,
+                        data: vec![reg_bytes[0], reg_bytes[1], 0x00, 0x01], // Read 1 register
+                    },
+                    request_type: RequestType::OperationCommand,
+                    expected_response_type: ResponseType::ReadFrequency,
+                }
+            }
+            MitsubishiControlRequests::ReadMotorFrequency => {
+                let reg: u16 = MitsubishiControlRequests::get_system_register(
+                    MitsubishiSystemRegister::MotorFrequency,
+                );
+                let reg_bytes = reg.to_be_bytes();
+                MitsubishiModbusRequest {
+                    request: ModbusRequest {
+                        slave_id: 1,
+                        function_code: ModbusFunctionCode::ReadHoldingRegister,
+                        data: vec![reg_bytes[0], reg_bytes[1], 0x0, 0x1],
+                    },
+                    request_type: RequestType::OperationCommand,
+                    expected_response_type: ResponseType::ReadMotorFrequency,
+                }
+            }
+            MitsubishiControlRequests::ResetInverter => {
+                let reg: u16 = MitsubishiControlRequests::get_system_register(
+                    MitsubishiSystemRegister::InverterReset,
+                );
+                let reg_bytes = reg.to_be_bytes();
+                MitsubishiModbusRequest {
+                    request: ModbusRequest {
+                        slave_id: 1,
+                        function_code: ModbusFunctionCode::PresetHoldingRegister,
+                        data: vec![reg_bytes[0], reg_bytes[1], 0x0, 0b00000001],
+                    },
+                    request_type: RequestType::OperationCommand,
+                    expected_response_type: ResponseType::NoResponse,
+                }
+            }
+            MitsubishiControlRequests::ClearAllParameters => todo!(),
+            MitsubishiControlRequests::ClearNonCommunicationParameter => todo!(),
+            MitsubishiControlRequests::ClearNonCommunicationParameters => todo!(),
+        }
+    }
+}
+
+/// These Requests Serve as Templates for controling the inverter
+#[derive(Debug)]
+pub enum MitsubishiControlRequests {
+    /// Register 40002, Reset/Restart the Inverter
+    ResetInverter,
+    /// Register 40004, Clear ALL parameters
+    ClearAllParameters,
+    /// Register 40006, Clear a non communication parameter
+    ClearNonCommunicationParameter,
+    /// Register 40007, Clear all Non Communication related Parameters
+    ClearNonCommunicationParameters,
+    /// Register 40009, Read Inverter Status
+    ReadInverterStatus,
+    /// Register 40009, Stops the Motor
+    StopMotor,
+    /// Register 40009, Starts the Motor in Forward Rotation
+    StartForwardRotation,
+    /// Register 40009, Starts the Motor in Reverse Rotation
+    StartReverseRotation,
+    /// Register 40014, Read the current frequency the motor runs at (RAM)
+    ReadRunningFrequency,
+    /// Register 40014, Write the frequency
+    WriteRunningFrequency,
+    /// Read Register 40201, This contains the actual output frequency
+    ReadMotorFrequency,
+}
+
+// We need to know from the request queue which events are of what operation type, so that the correct timeout can be used
+#[derive(Debug)]
+pub struct MitsubishiModbusRequest {
+    request: ModbusRequest,
+    request_type: RequestType,
+    expected_response_type: ResponseType,
+}
+
+#[derive(Debug)]
+pub enum RotationDirection {
+    Forward,
+    Backwards,
+    Stopped,
+}
+
+#[derive(Debug)]
+pub enum ResponseType {
+    NoResponse,
+    ReadFrequency,
+    ReadMotorFrequency, // Motor Frequency is the actual frequency, that the motor is running at right now
+    ReadInverterStatus,
+    WriteFrequency,
+    InverterStatus,
+    InverterControl,
+}
+
+#[derive(Debug)]
+pub struct MitsubishiInverterRS485Actor {
+    // Communication
+    pub serial_interface: SerialInterface,
+    pub baudrate: Option<u32>,
+    pub encoding: Option<SerialEncoding>,
+    pub request_queue: VecDeque<MitsubishiModbusRequest>,
+    pub response_queue: VecDeque<ModbusResponse>,
+
+    // State
+    pub last_ts: Instant,
+    pub last_message_size: usize,
+    pub last_request_type: RequestType,
+    pub state: State,
+    pub next_response_type: ResponseType,
+    pub frequency: Frequency,
+}
+
+impl MitsubishiInverterRS485Actor {
+    pub fn new(serial_interface: SerialInterface) -> Self {
+        Self {
+            serial_interface,
+            last_ts: Instant::now(),
+            state: State::Uninitialized,
+            request_queue: VecDeque::new(),
+            response_queue: VecDeque::new(),
+            next_response_type: ResponseType::ReadMotorFrequency,
+            last_request_type: RequestType::OperationCommand,
+            last_message_size: 0,
+            baudrate: None,
+            encoding: None,
+            frequency: Frequency::ZERO,
+        }
+    }
+
+    /// This would get called by the api to add a new request to the inverter
+    pub fn add_request(&mut self, request: MitsubishiModbusRequest) {
+        self.request_queue.push_front(request);
+    }
+
+    /// This is used by the Api to pop off the Response of our Request
+    pub fn get_response(&mut self) -> Option<ModbusResponse> {
+        if self.response_queue.len() == 0 {
+            return None;
+        }
+        self.response_queue.pop_back()
+    }
+
+    /// This is used internally to read the receive buffer of the el6021
+    fn read_modbus_response(
+        &mut self,
+    ) -> Pin<Box<dyn Future<Output = Result<ModbusResponse, anyhow::Error>> + Send + '_>> {
+        Box::pin(async move {
+            if !(self.serial_interface.has_message)().await {
+                //   return;
+            }
+
+            let res: Option<Vec<u8>> = (self.serial_interface.read_message)().await;
+            let raw_response = match res {
+                Some(res) => res,
+                None => {
+                    vec![]
+                }
+            };
+
+            let response: Result<ModbusResponse, _> =
+                ModbusResponse::try_from(raw_response.clone());
+
+            match response {
+                Ok(result) => {
+                    self.last_message_size = result.clone().data.len() + 4;
+                    self.state = State::ReadyToSend;
+                    Ok(result)
+                }
+                Err(_) => {
+                    log::error!("Error Parsing ModbusResponse!");
+                    self.state = State::ReadyToSend;
+                    Err(anyhow::anyhow!("error"))
+                }
+            }
+        })
+    }
+
+    /// This is used internally to fill the write buffer of the el6021
+    fn send_modbus_request(&mut self) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
+        Box::pin(async move {
+            if self.request_queue.len() == 0 {
+                return;
+            };
+            let request: MitsubishiModbusRequest = self.request_queue.pop_back().unwrap();
+            self.next_response_type = request.expected_response_type;
+            self.last_request_type = self.last_request_type;
+            let modbus_request: Vec<u8> = request.request.into();
+            let res = (self.serial_interface.write_message)(modbus_request.clone()).await;
+            match res {
+                Ok(_) => (),
+                Err(_) => log::error!("ERROR: serial_interface.write_message has failed"),
+            }
+            self.state = State::WaitingForRequestAccept;
+            self.last_message_size = modbus_request.len();
+        })
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum RequestType {
+    /// Monitoring, Operation (start,stop etc) command, frequency setting (RAM), less than 12 milliseconds timeout for Response
+    OperationCommand,
+    /// Parameter Read/Write and Frequency (EEPROM), Less than 30 milliseconds timeout for Response
+    ReadWrite,
+    /// Less than 5 seconds timeout for Response
+    ParamClear,
+    /// no Timeout for Response
+    Reset,
+}
+
+impl RequestType {
+    fn timeout_duration(self) -> Duration {
+        match self {
+            RequestType::OperationCommand => Duration::from_millis(12),
+            RequestType::ReadWrite => Duration::from_millis(30),
+            RequestType::ParamClear => Duration::from_millis(5000),
+            RequestType::Reset => Duration::from_millis(30),
+        }
+    }
+}
+
+pub enum MitsubishiModbusExceptionCode {
+    IllegalFunction,
+    IllegalDataAddress,
+    IllegalDataValue,
+    None,
+}
+
+impl From<MitsubishiModbusExceptionCode> for u8 {
+    fn from(value: MitsubishiModbusExceptionCode) -> Self {
+        match value {
+            MitsubishiModbusExceptionCode::None => 0,
+            MitsubishiModbusExceptionCode::IllegalFunction => 1,
+            MitsubishiModbusExceptionCode::IllegalDataAddress => 2,
+            MitsubishiModbusExceptionCode::IllegalDataValue => 3,
+        }
+    }
+}
+
+impl From<u8> for MitsubishiModbusExceptionCode {
+    fn from(value: u8) -> Self {
+        match value {
+            1 => MitsubishiModbusExceptionCode::IllegalFunction,
+            2 => MitsubishiModbusExceptionCode::IllegalDataAddress,
+            3 => MitsubishiModbusExceptionCode::IllegalDataValue,
+            _ => MitsubishiModbusExceptionCode::None,
+        }
+    }
+}
+
+// Handle different Response types
+impl MitsubishiInverterRS485Actor {
+    // When we get respone from Pr. 40014 (Running Frequency) Convert to rpm and save it
+    fn handle_motor_frequency(&mut self, resp: ModbusResponse) {
+        let freq_bytes = &resp.data[1..3]; // bytes 1 and 2 are needed
+        let raw_frequency = u16::from_be_bytes([freq_bytes[0], freq_bytes[1]]) as f64;
+        self.frequency = Frequency::new::<centihertz>(raw_frequency);
+    }
+
+    // Technically we could verify that every request also was successful with this match and return an Error, or not
+    fn handle_response(&mut self, resp: ModbusResponse) {
+        match self.next_response_type {
+            ResponseType::ReadFrequency => (),
+            ResponseType::ReadInverterStatus => (),
+            ResponseType::WriteFrequency => (),
+            ResponseType::ReadMotorFrequency => self.handle_motor_frequency(resp),
+            ResponseType::InverterStatus => (),
+            ResponseType::InverterControl => (),
+            ResponseType::NoResponse => (),
+        }
+    }
+}
+
+impl Actor for MitsubishiInverterRS485Actor {
+    fn act(&mut self, now_ts: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
+        Box::pin(async move {
+            let elapsed: Duration = now_ts.duration_since(self.last_ts);
+            // State is uninitialized until serial interface init returns true, which takes a few cycles on the el6021
+            if let State::Uninitialized = self.state {
+                let res = (self.serial_interface.initialize)().await;
+                if res == true {
+                    self.state = State::ReadyToSend;
+                    // every time when our inverter is "Uninitialzed" reset it first to clear any error states it may have
+                    self.add_request(MitsubishiControlRequests::ResetInverter.into());
+                    self.baudrate = (self.serial_interface.get_baudrate)().await;
+                    self.encoding = (self.serial_interface.get_serial_encoding)().await;
+                }
+                return;
+            }
+
+            let encoding = match self.encoding {
+                Some(encoding) => encoding,
+                None => return,
+            };
+
+            let baudrate = match self.baudrate {
+                Some(baudrate) => baudrate,
+                None => return,
+            };
+
+            let timeout = calculate_modbus_rtu_timeout(
+                encoding.total_bits(),
+                self.last_request_type.timeout_duration(),
+                baudrate,
+                self.last_message_size,
+            );
+
+            // if we have no requests add ReadMotorFrequency
+            if self.request_queue.is_empty() {
+                self.add_request(MitsubishiControlRequests::ReadMotorFrequency.into());
+            }
+
+            if elapsed < timeout {
+                return;
+            }
+
+            self.last_ts = now_ts;
+            match self.state {
+                State::WaitingForResponse => {
+                    let ret = self.read_modbus_response().await;
+                    match ret {
+                        Ok(ret) => self.handle_response(ret),
+                        Err(_) => (), // Do nothing for now
+                    }
+                }
+                State::ReadyToSend => self.send_modbus_request().await,
+                State::WaitingForReceiveAccept => self.state = State::ReadyToSend,
+                State::WaitingForRequestAccept => self.state = State::WaitingForResponse,
+                _ => (),
+            }
+        })
+    }
+}

control-core/src/actors/mod.rs

@@ -0,0 +1,19 @@
+pub mod analog_function_generator;
+pub mod analog_input_getter;
+pub mod digital_input_getter;
+pub mod digital_input_logger;
+pub mod digital_output_blinker;
+pub mod digital_output_blinkers;
+pub mod digital_output_setter;
+pub mod mitsubishi_inverter_rs485;
+pub mod stepper_driver_el70x1;
+pub mod stepper_driver_max_speed;
+pub mod stepper_driver_pulse_train;
+pub mod temperature_input_getter;
+pub mod temperature_input_logger;
+
+use std::{pin::Pin, time::Instant};
+
+pub trait Actor: Send + Sync {
+    fn act(&mut self, now: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>>;
+}

control-core/src/actors/stepper_driver_el70x1/mod.rs

@@ -0,0 +1,91 @@
+use super::Actor;
+use core::panic;
+use ethercat_hal::{
+    helpers::el70xx_velocity_converter::EL70x1VelocityConverter,
+    io::stepper_velocity_el70x1::StepperVelocityEL70x1, shared_config::el70x1::EL70x1SpeedRange,
+};
+use std::{future::Future, pin::Pin, time::Instant};
+
+/// Set a digital output high and low with a given interval
+#[derive(Debug)]
+pub struct StepperDriverEL70x1 {
+    stepper: StepperVelocityEL70x1,
+    enabled: bool,
+    velocity: i16,
+    position: i128,
+    set_position: Option<i128>,
+    pub converter: EL70x1VelocityConverter,
+}
+
+impl StepperDriverEL70x1 {
+    pub fn new(stepper: StepperVelocityEL70x1, speed_range: &EL70x1SpeedRange) -> Self {
+        Self {
+            stepper,
+            enabled: false,
+            velocity: 0,
+            converter: EL70x1VelocityConverter::new(speed_range),
+            position: 0,
+            set_position: None,
+        }
+    }
+
+    /// Set the speed in steps per second
+    pub fn set_speed(&mut self, steps_per_second: i32) {
+        self.velocity = self.converter.steps_to_velocity(steps_per_second, true)
+    }
+
+    /// Get the speed in steps per second
+    pub fn get_speed(&self) -> i32 {
+        self.converter.velocity_to_steps(self.velocity, true) as i32
+    }
+
+    /// Enable or disable the stepper
+    pub fn set_enabled(&mut self, enabled: bool) {
+        self.enabled = enabled;
+    }
+
+    /// Get the enabled state of the stepper
+    pub fn is_enabled(&self) -> bool {
+        self.enabled
+    }
+
+    /// Get the current position of the stepper
+    pub fn get_position(&self) -> i128 {
+        self.position
+    }
+
+    /// Set the position of the stepper
+    pub fn set_position(&mut self, position: i128) {
+        self.set_position = Some(position);
+    }
+}
+
+impl Actor for StepperDriverEL70x1 {
+    fn act(&mut self, _now: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
+        Box::pin(async move {
+            let state = match (self.stepper.state)().await {
+                Ok(state) => state,
+                Err(e) => {
+                    panic!("Error while reading StepperVelocity {:?}", e);
+                }
+            };
+            // set the input
+            self.position = state.input.counter_value;
+
+            let mut output = state.output.clone();
+
+            // set the output
+            output.enable = self.enabled;
+            output.velocity = self.velocity;
+            output.set_counter = self.set_position.take();
+
+            // write the output
+            match (self.stepper.write)(output).await {
+                Ok(_) => {}
+                Err(e) => {
+                    panic!("Error while writing StepperVelocity {:?}", e);
+                }
+            }
+        })
+    }
+}

control-core/src/actors/stepper_driver_max_speed.rs

@@ -0,0 +1,37 @@
+use super::Actor;
+use ethercat_hal::io::digital_output::DigitalOutput;
+use std::{
+    future::Future,
+    pin::Pin,
+    sync::{Arc, RwLock},
+    time::Instant,
+};
+
+/// Set a digital output high and low with a given interval
+pub struct StepperDriverMaxSpeed {
+    pulse: DigitalOutput,
+}
+
+impl StepperDriverMaxSpeed {
+    pub fn new(output: DigitalOutput) -> Self {
+        Self { pulse: output }
+    }
+}
+
+impl Actor for StepperDriverMaxSpeed {
+    fn act(&mut self, _now: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
+        Box::pin(async move {
+            let state = (self.pulse.state)().await;
+            match state.output.into() {
+                true => (self.pulse.write)(false.into()).await,
+                false => (self.pulse.write)(true.into()).await,
+            }
+        })
+    }
+}
+
+impl From<StepperDriverMaxSpeed> for Arc<RwLock<StepperDriverMaxSpeed>> {
+    fn from(actor: StepperDriverMaxSpeed) -> Self {
+        Arc::new(RwLock::new(actor))
+    }
+}

control-core/src/actors/stepper_driver_pulse_train/encoder.rs

@@ -0,0 +1,222 @@
+/// Translates the encoder value to a larger space and handle underflow/overflow situations
+#[derive(Debug)]
+pub struct Encoder {
+    pub position: i64,
+    pub last_encoder_position: u32,
+}
+
+impl Encoder {
+    pub fn new() -> Self {
+        Self {
+            position: 0,
+            last_encoder_position: 0,
+        }
+    }
+
+    pub fn update(&mut self, counter_value: u32, counter_overflow: bool, counter_underflow: bool) {
+        // Handle overflow case
+        if counter_overflow {
+            // When overflow occurs, the counter wraps from MAX to 0
+            // Calculate how much it moved past MAX
+            let delta = counter_value as i64;
+            // Add the remaining distance from last position to MAX, plus the overflow amount
+            self.position += (u32::MAX - self.last_encoder_position) as i64 + 1 + delta;
+        }
+        // Handle underflow case
+        else if counter_underflow {
+            // When underflow occurs, the counter wraps from 0 to MAX
+            // Calculate how much it moved below 0
+            let delta = (u32::MAX - counter_value) as i64;
+            // Subtract the distance from last position to 0, plus the underflow amount
+            self.position -= self.last_encoder_position as i64 + 1 + delta;
+        }
+        // Normal case - no overflow/underflow
+        else {
+            // Calculate the signed difference between current and last position
+            let delta = counter_value as i64 - self.last_encoder_position as i64;
+            // Update the position
+            self.position += delta;
+        }
+
+        // Update the last encoder position for next time
+        self.last_encoder_position = counter_value;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Tests that the position tracker correctly handles normal forward movement
+    /// without any overflow conditions.
+    ///
+    /// This test verifies:
+    /// 1. Initial state is zeroed
+    /// 2. Moving forward updates both position and last_encoder_position
+    /// 3. Consecutive forward movements accumulate correctly
+    #[test]
+    fn test_normal_forward_movement() {
+        let mut tracker = Encoder::new();
+
+        // Initial state
+        assert_eq!(tracker.position, 0);
+        assert_eq!(tracker.last_encoder_position, 0);
+
+        // Move forward by 100
+        tracker.update(100, false, false);
+        assert_eq!(tracker.position, 100);
+        assert_eq!(tracker.last_encoder_position, 100);
+
+        // Move forward by another 50
+        tracker.update(150, false, false);
+        assert_eq!(tracker.position, 150);
+        assert_eq!(tracker.last_encoder_position, 150);
+    }
+
+    /// Tests that the position tracker correctly handles normal backward movement
+    /// without any underflow conditions.
+    ///
+    /// This test verifies:
+    /// 1. Starting from a non-zero position
+    /// 2. Moving backward updates both position and last_encoder_position
+    /// 3. Consecutive backward movements accumulate correctly
+    #[test]
+    fn test_normal_backward_movement() {
+        let mut tracker = Encoder::new();
+
+        // Start at position 1000
+        tracker.position = 1000;
+        tracker.last_encoder_position = 1000;
+
+        // Move backward by 100
+        tracker.update(900, false, false);
+        assert_eq!(tracker.position, 900);
+        assert_eq!(tracker.last_encoder_position, 900);
+
+        // Move backward by another 50
+        tracker.update(850, false, false);
+        assert_eq!(tracker.position, 850);
+        assert_eq!(tracker.last_encoder_position, 850);
+    }
+
+    /// Tests that the position tracker correctly handles overflow conditions
+    /// where the encoder counter wraps from near its maximum value to a small value.
+    ///
+    /// This test verifies:
+    /// 1. When overflow flag is set, the tracker correctly calculates the true movement
+    /// 2. Position is updated to account for the full distance traveled
+    /// 3. last_encoder_position is updated to the new counter value
+    #[test]
+    fn test_overflow() {
+        let mut tracker = Encoder::new();
+
+        // Set position near the maximum u32 value
+        tracker.position = 100;
+        tracker.last_encoder_position = u32::MAX - 10;
+
+        // Overflow: counter goes from (MAX-10) to 5
+        // This means we moved forward by 10 steps to MAX, then 1 step to overflow,
+        // then 5 more steps to reach the current position
+        tracker.update(5, true, false);
+
+        // Expected: position += (10 + 1 + 5) = position += 16
+        assert_eq!(tracker.position, 116);
+        assert_eq!(tracker.last_encoder_position, 5);
+    }
+
+    /// Tests that the position tracker correctly handles underflow conditions
+    /// where the encoder counter wraps from near zero to a value near its maximum.
+    ///
+    /// This test verifies:
+    /// 1. When underflow flag is set, the tracker correctly calculates the true movement
+    /// 2. Position is updated to account for the full distance traveled (in negative direction)
+    /// 3. last_encoder_position is updated to the new counter value
+    #[test]
+    fn test_underflow() {
+        let mut tracker = Encoder::new();
+
+        // Set position near zero
+        tracker.position = 100;
+        tracker.last_encoder_position = 10;
+
+        // Underflow: counter goes from 10 to (MAX-5)
+        // This means we moved backward by 10 steps to 0, then 1 step to underflow,
+        // then 5 more steps to reach the current position
+        tracker.update(u32::MAX - 5, false, true);
+
+        // Expected: position -= (10 + 1 + 5) = position -= 16
+        assert_eq!(tracker.position, 84);
+        assert_eq!(tracker.last_encoder_position, u32::MAX - 5);
+    }
+
+    /// Tests that the position tracker maintains correct behavior across
+    /// a sequence of different operations including normal movement,
+    /// overflow, and underflow.
+    ///
+    /// This test verifies:
+    /// 1. The tracker maintains state correctly between operations
+    /// 2. Different types of movements can be handled in sequence
+    /// 3. Position calculations remain accurate throughout various scenarios
+    #[test]
+    fn test_multiple_operations() {
+        let mut tracker = Encoder::new();
+
+        // Normal forward
+        tracker.update(100, false, false);
+        assert_eq!(tracker.position, 100);
+
+        // Normal backward
+        tracker.update(50, false, false);
+        assert_eq!(tracker.position, 50);
+
+        // Overflow
+        tracker.last_encoder_position = u32::MAX - 5;
+        tracker.position = 50; // Reset for clarity
+        tracker.update(10, true, false);
+        assert_eq!(tracker.position, 66); // 50 + (5 + 1 + 10)
+
+        // Underflow
+        tracker.last_encoder_position = 5;
+        tracker.position = 100; // Reset for clarity
+        tracker.update(u32::MAX - 10, false, true);
+        assert_eq!(tracker.position, 84); // 100 - (5 + 1 + 10)
+    }
+
+    /// Tests that the position tracker can handle multiple overflow and underflow
+    /// events, maintaining an accurate position count that exceeds the u32 range.
+    ///
+    /// This test verifies:
+    /// 1. Multiple overflow events accumulate correctly in the i64 position
+    /// 2. Multiple underflow events correctly subtract from the position
+    /// 3. The i64 position field properly extends the range beyond u32 limits
+    #[test]
+    fn test_large_movements() {
+        let mut tracker = Encoder::new();
+
+        // Test tracking beyond u32 limits with multiple overflows
+        for _ in 0..5 {
+            // Simulate overflow: move from (MAX-100) to 100
+            tracker.last_encoder_position = u32::MAX - 100;
+            tracker.update(100, true, false);
+
+            // Each iteration adds (100 + 1 + 100) = 201 to position
+            // We move 100 steps to MAX, 1 step to overflow, and 100 more steps to reach 100
+        }
+
+        // After 5 iterations, position should be 5 * 201 = 1005
+        assert_eq!(tracker.position, 1005);
+
+        // Test tracking with multiple underflows
+        for _ in 0..3 {
+            // Simulate underflow: move from 100 to (MAX-100)
+            tracker.last_encoder_position = 100;
+            tracker.update(u32::MAX - 100, false, true);
+
+            // Each iteration subtracts (100 + 1 + 100) = 201 from position
+            // We move 100 steps to 0, 1 step to underflow, and 100 more steps to reach MAX-100
+        }
+
+        // Final position: 1005 - (3 * 201) = 1005 - 603 = 402
+        assert_eq!(tracker.position, 402);
+    }
+}

control-core/src/actors/stepper_driver_pulse_train/mod.rs

@@ -0,0 +1,51 @@
+use super::Actor;
+use encoder::Encoder;
+use ethercat_hal::io::pulse_train_output::PulseTrainOutput;
+use std::{future::Future, pin::Pin, time::Instant};
+
+pub mod encoder;
+
+/// Set a digital output high and low with a given interval
+#[derive(Debug)]
+pub struct StepperDriverPulseTrain {
+    pulse: PulseTrainOutput,
+    encoder: Encoder,
+    frequency: i32,
+}
+
+impl<'ptodevice> StepperDriverPulseTrain {
+    pub fn new(output: PulseTrainOutput) -> Self {
+        Self {
+            pulse: output,
+            encoder: Encoder::new(),
+            frequency: 0,
+        }
+    }
+}
+
+impl<'ptodevice> Actor for StepperDriverPulseTrain {
+    fn act(&mut self, _now: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
+        Box::pin(async move {
+            let state = (self.pulse.state)().await;
+            let mut output = state.output.clone();
+
+            // sync the counter to the encoder
+            self.encoder.update(
+                state.input.counter_value,
+                state.input.counter_overflow,
+                state.input.counter_underflow,
+            );
+
+            // write frequency
+            output.frequency_value = self.frequency;
+
+            (self.pulse.write)(output).await;
+        })
+    }
+}
+
+impl<'ptodevice> StepperDriverPulseTrain {
+    pub fn set_frequency(&mut self, frequency: i32) {
+        self.frequency = frequency;
+    }
+}

control-core/src/actors/temperature_input_getter.rs

@@ -0,0 +1,43 @@
+use std::{pin::Pin, time::Instant};
+
+use ethercat_hal::io::temperature_input::TemperatureInput;
+
+use super::Actor;
+
+#[derive(Debug)]
+pub struct TemperatureInputGetter {
+    input: TemperatureInput,
+    temperature: f64,
+    wiring_error: bool,
+}
+
+impl TemperatureInputGetter {
+    pub fn new(input: TemperatureInput) -> Self {
+        Self {
+            input,
+            temperature: 0.0,
+            wiring_error: false,
+        }
+    }
+
+    pub fn get_temperature(&self) -> f64 {
+        self.temperature
+    }
+
+    pub fn get_wiring_error(&self) -> bool {
+        self.wiring_error
+    }
+}
+
+impl Actor for TemperatureInputGetter {
+    fn act(&mut self, _now: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
+        Box::pin(async move {
+            let input = (self.input.state)().await.input;
+            self.temperature = input.temperature as f64;
+            self.wiring_error = input.overvoltage | input.undervoltage;
+            if self.wiring_error {
+                self.temperature = 0.0;
+            }
+        })
+    }
+}

control-core/src/actors/temperature_input_logger.rs

@@ -0,0 +1,23 @@
+use super::Actor;
+use ethercat_hal::io::temperature_input::TemperatureInput;
+use std::{future::Future, pin::Pin, time::Instant};
+
+/// Log the state of a temperature input
+pub struct TemperatureInputLogger {
+    input: TemperatureInput,
+}
+
+impl TemperatureInputLogger {
+    pub fn new(input: TemperatureInput) -> Self {
+        Self { input }
+    }
+}
+
+impl Actor for TemperatureInputLogger {
+    fn act(&mut self, _now: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
+        Box::pin(async move {
+            let state = (self.input.state)().await;
+            println!("TemperatureInputLogger: {:?}C", state.input.temperature);
+        })
+    }
+}

control-core/src/controllers/clamping_timeagnostic_pid.rs

@@ -1,218 +0,0 @@
-use std::time::Instant;
-
-#[derive(Debug)]
-pub struct ClampingTimeagnosticPidController {
-    // Params
-    /// Proportional gain
-    kp: f64,
-    /// Integral gain
-    ki: f64,
-    /// Derivative gain
-    kd: f64,
-    // State
-    /// Proportional error
-    ep: f64,
-    /// Integral error
-    ei: f64,
-    /// Derivative error
-    ed: f64,
-
-    min_ep: Option<f64>,
-    max_ep: Option<f64>,
-
-    min_ei: Option<f64>,
-    max_ei: Option<f64>,
-
-    min_ed: Option<f64>,
-    max_ed: Option<f64>,
-
-    min_signal: Option<f64>,
-    max_signal: Option<f64>,
-
-    last: Option<Instant>,
-}
-
-impl ClampingTimeagnosticPidController {
-    pub const fn new(
-        kp: f64,
-        ki: f64,
-        kd: f64,
-        min_ep: Option<f64>,
-        max_ep: Option<f64>,
-        min_ei: Option<f64>,
-        max_ei: Option<f64>,
-        min_ed: Option<f64>,
-        max_ed: Option<f64>,
-        min_signal: Option<f64>,
-        max_signal: Option<f64>,
-    ) -> Self {
-        Self {
-            kp,
-            ki,
-            kd,
-            ep: 0.0,
-            ei: 0.0,
-            ed: 0.0,
-            last: None,
-            min_ep,
-            max_ep,
-            min_ei,
-            max_ei,
-            min_ed,
-            max_ed,
-            min_signal,
-            max_signal,
-        }
-    }
-
-    pub const fn simple_new(kp: f64, ki: f64, kd: f64) -> Self {
-        Self {
-            kp,
-            ki,
-            kd,
-            ep: 0.0,
-            ei: 0.0,
-            ed: 0.0,
-            min_ep: None,
-            max_ep: None,
-            min_ei: None,
-            max_ei: None,
-            min_ed: None,
-            max_ed: None,
-            last: None,
-            min_signal: None,
-            max_signal: None,
-        }
-    }
-
-    pub const fn get_kp(&self) -> f64 {
-        self.kp
-    }
-
-    pub const fn get_ki(&self) -> f64 {
-        self.ki
-    }
-
-    pub const fn get_kd(&self) -> f64 {
-        self.kd
-    }
-
-    pub const fn configure(&mut self, ki: f64, kp: f64, kd: f64) {
-        self.reset();
-        self.kp = kp;
-        self.ki = ki;
-        self.kd = kd;
-    }
-
-    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),
-            (None, Some(max)) => value.min(max),
-            (None, None) => value,
-        }
-    }
-
-    pub fn update(&mut self, error: f64, t: Instant) -> f64 {
-        match self.last {
-            // First update
-            None => {
-                // Calculate error
-                let ep = error;
-
-                // Calculate signal
-                let signal = self.kp * ep;
-                let clamped_signal = Self::optional_clamp(signal, self.min_signal, self.max_signal);
-
-                // Set values
-                self.ep = Self::optional_clamp(ep, self.min_ep, self.max_ep);
-                self.ei = 0.0;
-                self.ed = 0.0;
-                self.last = Some(t);
-
-                clamped_signal
-            }
-            // Subsequent updates
-            Some(last) => {
-                // Calculate the time delta in seconds
-                let dt = t.duration_since(last).as_secs_f64();
-
-                // Calculate errors
-                let ep = Self::optional_clamp(error, self.min_ep, self.max_ep);
-
-                let ei = Self::optional_clamp(ep.mul_add(dt, self.ei), self.min_ei, self.max_ei);
-
-                let ed = Self::optional_clamp((ep - self.ep) / dt, self.min_ed, self.max_ed);
-
-                // Make factors timeagnostic
-                let kp = self.kp * dt;
-                let ki = self.ki * dt;
-                let kd = self.kd * dt;
-
-                // Calculate 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;
-                self.ei = ei;
-                self.ed = ed;
-                self.last = Some(t);
-
-                clamped_signal
-            }
-        }
-    }
-
-    pub const fn reset(&mut self) {
-        self.ep = 0.0;
-        self.ei = 0.0;
-        self.ed = 0.0;
-        self.last = None;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::controllers::clamping_timeagnostic_pid::ClampingTimeagnosticPidController;
-
-    #[test]
-    fn test_optional_clamp_with_both_bounds() {
-        let val = 5.0;
-        let clamped = ClampingTimeagnosticPidController::optional_clamp(val, Some(1.0), Some(4.0));
-        assert_eq!(clamped, 4.0);
-
-        let clamped = ClampingTimeagnosticPidController::optional_clamp(val, Some(6.0), Some(10.0));
-        assert_eq!(clamped, 6.0);
-
-        let clamped = ClampingTimeagnosticPidController::optional_clamp(val, Some(2.0), Some(6.0));
-        assert_eq!(clamped, 5.0);
-    }
-
-    #[test]
-    fn test_optional_clamp_with_only_min() {
-        let val = 3.0;
-        let clamped = ClampingTimeagnosticPidController::optional_clamp(val, Some(5.0), None);
-        assert_eq!(clamped, 5.0);
-
-        let clamped = ClampingTimeagnosticPidController::optional_clamp(val, Some(2.0), None);
-        assert_eq!(clamped, 3.0);
-    }
-
-    #[test]
-    fn test_optional_clamp_with_only_max() {
-        let val = 7.0;
-        let clamped = ClampingTimeagnosticPidController::optional_clamp(val, None, Some(6.0));
-        assert_eq!(clamped, 6.0);
-
-        let clamped = ClampingTimeagnosticPidController::optional_clamp(val, None, Some(8.0));
-        assert_eq!(clamped, 7.0);
-    }
-
-    #[test]
-    fn test_optional_clamp_with_no_bounds() {
-        let val = 42.0;
-        let clamped = ClampingTimeagnosticPidController::optional_clamp(val, None, None);
-        assert_eq!(clamped, 42.0);
-    }
-}

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

@@ -2,17 +2,11 @@ use std::time::Instant;
 
 #[derive(Debug)]
 pub struct AccelerationSpeedController {
-    /// Maximum deceleration in units per second (positive value)
-    max_acceleration: f64,
+    /// Maximum acceleration in units per second (positive value)
+    acceleration: f64,
 
-    /// Maximum acceleratoin in units per second (negative value)
-    min_acceleration: f64,
-
-    /// Minimum speed limit (None for no limit)
-    min_speed: Option<f64>,
-
-    /// Maximum speed limit (None for no limit)
-    max_speed: Option<f64>,
+    /// Maximum deceleration in units per second (negative value)
+    deceleration: f64,
 
     /// Calculated speed at the last update
     last_speed: f64,
@@ -22,36 +16,15 @@ pub struct AccelerationSpeedController {
 }
 
 impl AccelerationSpeedController {
-    pub const fn new(
-        min_speed: Option<f64>,
-        max_speed: Option<f64>,
-        min_acceleration: f64,
-        max_acceleration: f64,
-        initial_speed: f64,
-    ) -> Self {
+    pub fn new(acceleration: f64, deceleration: f64, initial_speed: f64) -> Self {
         Self {
-            min_acceleration,
-            max_acceleration,
-            min_speed,
-            max_speed,
+            acceleration,
+            deceleration,
             last_speed: initial_speed,
             last_t: None,
         }
     }
 
-    /// Creates a new acceleration speed controller with simplified parameters.
-    /// Sets min_acceleration to -max_acceleration for symmetric behavior.
-    /// No speed limits are applied.
-    pub fn new_simple(max_acceleration: f64, initial_speed: f64) -> Self {
-        Self::new(
-            None,              // min_speed
-            None,              // max_speed
-            -max_acceleration, // min_acceleration (deceleration)
-            max_acceleration,  // max_acceleration
-            initial_speed,
-        )
-    }
-
     pub fn update(&mut self, target_speed: f64, t: Instant) -> f64 {
         // Calculate time delta
         let dt = match self.last_t {
@@ -68,10 +41,10 @@ impl AccelerationSpeedController {
         // Get acceleration
         let acceleration = if target_speed > self.last_speed {
             // We are accelerating
-            self.max_acceleration
+            self.acceleration
         } else if target_speed < self.last_speed {
             // We are decelerating
-            self.min_acceleration
+            self.deceleration
         } else {
             0.0
         };
@@ -90,55 +63,22 @@ impl AccelerationSpeedController {
             new_speed
         };
 
-        // Apply speed limits
-        let new_speed = self.apply_speed_limits(new_speed);
-
         self.last_speed = new_speed;
 
         new_speed
     }
 
-    pub const fn reset(&mut self, initial_speed: f64) {
+    pub fn reset(&mut self, initial_speed: f64) {
         self.last_speed = initial_speed;
         self.last_t = None; // Reset the last update time
     }
 
-    pub const fn set_max_acceleration(&mut self, acceleration: f64) {
-        self.max_acceleration = acceleration;
+    pub fn set_acceleration(&mut self, acceleration: f64) {
+        self.acceleration = acceleration;
     }
 
-    const fn apply_speed_limits(&self, speed: f64) -> f64 {
-        let mut limited_speed = speed;
-
-        if let Some(min) = self.min_speed {
-            limited_speed = limited_speed.max(min);
-        }
-
-        if let Some(max) = self.max_speed {
-            limited_speed = limited_speed.min(max);
-        }
-
-        limited_speed
-    }
-
-    pub const fn get_min_speed(&self) -> Option<f64> {
-        self.min_speed
-    }
-
-    pub const fn get_max_speed(&self) -> Option<f64> {
-        self.max_speed
-    }
-
-    pub const fn set_min_speed(&mut self, min_speed: Option<f64>) {
-        self.min_speed = min_speed;
-    }
-
-    pub const fn set_max_speed(&mut self, max_speed: Option<f64>) {
-        self.max_speed = max_speed;
-    }
-
-    pub const fn set_min_acceleration(&mut self, deceleration: f64) {
-        self.min_acceleration = deceleration;
+    pub fn set_deceleration(&mut self, deceleration: f64) {
+        self.deceleration = deceleration;
     }
 }
 
@@ -157,16 +97,16 @@ mod tests {
 
     #[test]
     fn test_initialization() {
-        let controller = AccelerationSpeedController::new(None, None, -15.0, 10.0, 5.0);
-        assert_relative_eq!(controller.max_acceleration, 10.0, epsilon = EPSILON);
-        assert_relative_eq!(controller.min_acceleration, -15.0, epsilon = EPSILON);
+        let controller = AccelerationSpeedController::new(10.0, -15.0, 5.0);
+        assert_relative_eq!(controller.acceleration, 10.0, epsilon = EPSILON);
+        assert_relative_eq!(controller.deceleration, -15.0, epsilon = EPSILON);
         assert_relative_eq!(controller.last_speed, 5.0, epsilon = EPSILON);
         assert!(controller.last_t.is_none());
     }
 
     #[test]
     fn test_first_update() {
-        let mut controller = AccelerationSpeedController::new(None, None, -15.0, 10.0, 5.0);
+        let mut controller = AccelerationSpeedController::new(10.0, -15.0, 5.0);
         let now = Instant::now();
 
         let speed = controller.update(5.0, now);
@@ -178,7 +118,7 @@ mod tests {
 
     #[test]
     fn test_acceleration() {
-        let mut controller = AccelerationSpeedController::new(None, None, -15.0, 10.0, 0.0);
+        let mut controller = AccelerationSpeedController::new(10.0, -15.0, 0.0);
         let t1 = Instant::now();
         controller.update(0.0, t1); // Initialize last_t
 
@@ -197,7 +137,7 @@ mod tests {
 
     #[test]
     fn test_deceleration() {
-        let mut controller = AccelerationSpeedController::new(None, None, -15.0, 10.0, 10.0);
+        let mut controller = AccelerationSpeedController::new(10.0, -15.0, 10.0);
         let t1 = Instant::now();
         controller.update(10.0, t1); // Initialize last_t
 
@@ -216,7 +156,7 @@ mod tests {
 
     #[test]
     fn test_constant_speed() {
-        let mut controller = AccelerationSpeedController::new(None, None, -15.0, 10.0, 7.0);
+        let mut controller = AccelerationSpeedController::new(10.0, -15.0, 7.0);
         let t1 = Instant::now();
         controller.update(7.0, t1); // Initialize last_t
 
@@ -229,7 +169,7 @@ mod tests {
 
     #[test]
     fn test_acceleration_limit() {
-        let mut controller = AccelerationSpeedController::new(None, None, -15.0, 10.0, 0.0);
+        let mut controller = AccelerationSpeedController::new(10.0, -15.0, 0.0);
         let t1 = Instant::now();
         controller.update(0.0, t1); // Initialize last_t
 
@@ -246,7 +186,7 @@ mod tests {
 
     #[test]
     fn test_deceleration_limit() {
-        let mut controller = AccelerationSpeedController::new(None, None, -15.0, 10.0, 20.0);
+        let mut controller = AccelerationSpeedController::new(10.0, -15.0, 20.0);
         let t1 = Instant::now();
         controller.update(20.0, t1); // Initialize last_t
 
@@ -263,7 +203,7 @@ mod tests {
 
     #[test]
     fn test_zero_time_delta() {
-        let mut controller = AccelerationSpeedController::new(None, None, -15.0, 10.0, 5.0);
+        let mut controller = AccelerationSpeedController::new(10.0, -15.0, 5.0);
         let now = Instant::now();
 
         controller.update(5.0, now); // Initialize last_t
@@ -276,7 +216,7 @@ mod tests {
 
     #[test]
     fn test_acceleration_capped_at_target() {
-        let mut controller = AccelerationSpeedController::new(None, None, -15.0, 100.0, 3.0);
+        let mut controller = AccelerationSpeedController::new(100.0, -15.0, 3.0);
         let t1 = Instant::now();
         controller.update(3.0, t1); // Initialize last_t
 
@@ -294,7 +234,7 @@ mod tests {
 
     #[test]
     fn test_deceleration_capped_at_target() {
-        let mut controller = AccelerationSpeedController::new(None, None, -100.0, 10.0, 8.0);
+        let mut controller = AccelerationSpeedController::new(10.0, -100.0, 8.0);
         let t1 = Instant::now();
         controller.update(8.0, t1); // Initialize last_t
 
@@ -312,7 +252,7 @@ mod tests {
 
     #[test]
     fn test_exact_acceleration_to_target() {
-        let mut controller = AccelerationSpeedController::new(None, None, -15.0, 20.0, 3.0);
+        let mut controller = AccelerationSpeedController::new(20.0, -15.0, 3.0);
         let t1 = Instant::now();
         controller.update(3.0, t1); // Initialize last_t
 
@@ -329,7 +269,7 @@ mod tests {
 
     #[test]
     fn test_exact_deceleration_to_target() {
-        let mut controller = AccelerationSpeedController::new(None, None, -30.0, 10.0, 8.0);
+        let mut controller = AccelerationSpeedController::new(10.0, -30.0, 8.0);
         let t1 = Instant::now();
         controller.update(8.0, t1); // Initialize last_t
 
@@ -343,92 +283,4 @@ mod tests {
 
         assert_relative_eq!(speed, 5.0, epsilon = EPSILON);
     }
-
-    #[test]
-    fn test_speed_limits_initialization() {
-        let controller =
-            AccelerationSpeedController::new(Some(-50.0), Some(100.0), -10.0, 20.0, 5.0);
-        assert_eq!(controller.get_min_speed(), Some(-50.0));
-        assert_eq!(controller.get_max_speed(), Some(100.0));
-    }
-
-    #[test]
-    fn test_max_speed_limit() {
-        let mut controller = AccelerationSpeedController::new(None, Some(50.0), -10.0, 100.0, 0.0);
-        let t1 = Instant::now();
-        controller.update(0.0, t1); // Initialize last_t
-
-        let dt = 1.0; // 1 second
-        let t2 = future_instant(t1, dt);
-
-        // Try to reach 80.0, but should be limited to 50.0
-        let speed = controller.update(80.0, t2);
-        assert_eq!(speed, 50.0);
-    }
-
-    #[test]
-    fn test_min_speed_limit() {
-        let mut controller = AccelerationSpeedController::new(Some(-30.0), None, -100.0, 10.0, 0.0);
-        let t1 = Instant::now();
-        controller.update(0.0, t1); // Initialize last_t
-
-        let dt = 1.0; // 1 second
-        let t2 = future_instant(t1, dt);
-
-        // Try to reach -50.0, but should be limited to -30.0
-        let speed = controller.update(-50.0, t2);
-        assert_eq!(speed, -30.0);
-    }
-
-    #[test]
-    fn test_speed_within_limits() {
-        let mut controller =
-            AccelerationSpeedController::new(Some(-50.0), Some(50.0), -20.0, 20.0, 0.0);
-        let t1 = Instant::now();
-        controller.update(0.0, t1); // Initialize last_t
-
-        let dt = 0.5; // 0.5 seconds
-        let t2 = future_instant(t1, dt);
-
-        // Target 10.0, with acceleration 20.0, should reach 10.0 in 0.5s
-        let speed = controller.update(10.0, t2);
-        assert_relative_eq!(speed, 10.0, epsilon = EPSILON);
-    }
-
-    #[test]
-    fn test_speed_limit_setters() {
-        let mut controller = AccelerationSpeedController::new(None, None, -15.0, 10.0, 5.0);
-
-        // Initially no limits
-        assert_eq!(controller.get_min_speed(), None);
-        assert_eq!(controller.get_max_speed(), None);
-
-        // Set limits
-        controller.set_min_speed(Some(-100.0));
-        controller.set_max_speed(Some(100.0));
-
-        assert_eq!(controller.get_min_speed(), Some(-100.0));
-        assert_eq!(controller.get_max_speed(), Some(100.0));
-
-        // Remove limits
-        controller.set_min_speed(None);
-        controller.set_max_speed(None);
-
-        assert_eq!(controller.get_min_speed(), None);
-        assert_eq!(controller.get_max_speed(), None);
-    }
-
-    #[test]
-    fn test_new_simple_constructor() {
-        let controller = AccelerationSpeedController::new_simple(20.0, 5.0);
-
-        // Check that acceleration values are symmetric
-        assert_eq!(controller.min_acceleration, -20.0);
-        assert_eq!(controller.max_acceleration, 20.0);
-        assert_eq!(controller.last_speed, 5.0);
-
-        // Check that speed limits are None
-        assert_eq!(controller.get_min_speed(), None);
-        assert_eq!(controller.get_max_speed(), None);
-    }
 }

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

@@ -1,6 +1,6 @@
 use std::time::Instant;
 
-use units::{
+use uom::si::{
     angular_acceleration::radian_per_second_squared,
     angular_velocity::radian_per_second,
     f64::{AngularAcceleration, AngularVelocity},
@@ -17,43 +17,23 @@ pub struct AngularAccelerationSpeedController {
 
 impl AngularAccelerationSpeedController {
     pub fn new(
-        min_speed: Option<AngularVelocity>,
-        max_speed: Option<AngularVelocity>,
-        min_acceleration: AngularAcceleration,
-        max_acceleration: AngularAcceleration,
+        acceleration: AngularAcceleration,
+        deceleration: AngularAcceleration,
         initial_speed: AngularVelocity,
     ) -> Self {
         Self {
             controller: AccelerationSpeedController::new(
-                min_speed.map(|s| s.get::<radian_per_second>()),
-                max_speed.map(|s| s.get::<radian_per_second>()),
-                min_acceleration.get::<radian_per_second_squared>(),
-                max_acceleration.get::<radian_per_second_squared>(),
+                acceleration.get::<radian_per_second_squared>(),
+                deceleration.get::<radian_per_second_squared>(),
                 initial_speed.get::<radian_per_second>(),
             ),
         }
     }
 
-    /// Creates a new angular acceleration speed controller with simplified parameters.
-    /// Sets min_acceleration to -max_acceleration for symmetric behavior.
-    /// No speed limits are applied.
-    pub fn new_simple(
-        max_acceleration: AngularAcceleration,
-        initial_speed: AngularVelocity,
-    ) -> Self {
-        Self::new(
-            None,              // min_speed
-            None,              // max_speed
-            -max_acceleration, // min_acceleration (deceleration)
-            max_acceleration,  // max_acceleration
-            initial_speed,
-        )
-    }
-
     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);
-        AngularVelocity::new::<radian_per_second>(new_speed)
+        return AngularVelocity::new::<radian_per_second>(new_speed);
     }
 
     pub fn reset(&mut self, initial_speed: AngularVelocity) {
@@ -61,34 +41,12 @@ impl AngularAccelerationSpeedController {
         self.controller.reset(initial_speed);
     }
 
-    pub fn set_max_acceleration(&mut self, acceleration: AngularAcceleration) {
+    pub fn set_acceleration(&mut self, acceleration: AngularAcceleration) {
         self.controller
-            .set_max_acceleration(acceleration.get::<radian_per_second_squared>());
+            .set_acceleration(acceleration.get::<radian_per_second_squared>());
     }
-    pub fn set_min_acceleration(&mut self, deceleration: AngularAcceleration) {
+    pub fn set_deceleration(&mut self, deceleration: AngularAcceleration) {
         self.controller
-            .set_min_acceleration(deceleration.get::<radian_per_second_squared>());
-    }
-
-    pub fn get_min_speed(&self) -> Option<AngularVelocity> {
-        self.controller
-            .get_min_speed()
-            .map(AngularVelocity::new::<radian_per_second>)
-    }
-
-    pub fn get_max_speed(&self) -> Option<AngularVelocity> {
-        self.controller
-            .get_max_speed()
-            .map(AngularVelocity::new::<radian_per_second>)
-    }
-
-    pub fn set_min_speed(&mut self, min_speed: Option<AngularVelocity>) {
-        self.controller
-            .set_min_speed(min_speed.map(|s| s.get::<radian_per_second>()));
-    }
-
-    pub fn set_max_speed(&mut self, max_speed: Option<AngularVelocity>) {
-        self.controller
-            .set_max_speed(max_speed.map(|s| s.get::<radian_per_second>()));
+            .set_deceleration(deceleration.get::<radian_per_second_squared>());
     }
 }

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

@@ -1,6 +1,6 @@
 use std::time::Instant;
 
-use units::{
+use uom::si::{
     acceleration::meter_per_second_squared,
     f64::{Acceleration, Velocity},
     velocity::meter_per_second,
@@ -17,38 +17,22 @@ pub struct LinearAccelerationLimitingController {
 
 impl LinearAccelerationLimitingController {
     pub fn new(
-        min_speed: Option<Velocity>,
-        max_speed: Option<Velocity>,
         acceleration: Acceleration,
         deceleration: Acceleration,
         initial_speed: Velocity,
     ) -> Self {
         Self {
             controller: AccelerationSpeedController::new(
-                min_speed.map(|s| s.get::<meter_per_second>()),
-                max_speed.map(|s| s.get::<meter_per_second>()),
                 acceleration.get::<meter_per_second_squared>(),
                 deceleration.get::<meter_per_second_squared>(),
                 initial_speed.get::<meter_per_second>(),
             ),
         }
     }
-    /// Creates a new linear acceleration speed controller with simplified parameters.
-    /// Sets deceleration to -acceleration for symmetric behavior.
-    /// No speed limits are applied.
-    pub fn new_simple(acceleration: Acceleration, initial_speed: Velocity) -> Self {
-        Self::new(
-            None,          // min_speed
-            None,          // max_speed
-            acceleration,  // acceleration
-            -acceleration, // deceleration (negative for deceleration)
-            initial_speed,
-        )
-    }
     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);
-        Velocity::new::<meter_per_second>(new_speed)
+        return Velocity::new::<meter_per_second>(new_speed);
     }
     pub fn reset(&mut self, initial_speed: Velocity) {
         let initial_speed = initial_speed.get::<meter_per_second>();
@@ -56,28 +40,10 @@ impl LinearAccelerationLimitingController {
     }
     pub fn set_acceleration(&mut self, acceleration: Acceleration) {
         self.controller
-            .set_max_acceleration(acceleration.get::<meter_per_second_squared>());
+            .set_acceleration(acceleration.get::<meter_per_second_squared>());
     }
     pub fn set_deceleration(&mut self, deceleration: Acceleration) {
         self.controller
-            .set_min_acceleration(deceleration.get::<meter_per_second_squared>());
-    }
-    pub fn get_min_speed(&self) -> Option<Velocity> {
-        self.controller
-            .get_min_speed()
-            .map(Velocity::new::<meter_per_second>)
-    }
-    pub fn get_max_speed(&self) -> Option<Velocity> {
-        self.controller
-            .get_max_speed()
-            .map(Velocity::new::<meter_per_second>)
-    }
-    pub fn set_min_speed(&mut self, min_speed: Option<Velocity>) {
-        self.controller
-            .set_min_speed(min_speed.map(|s| s.get::<meter_per_second>()));
-    }
-    pub fn set_max_speed(&mut self, max_speed: Option<Velocity>) {
-        self.controller
-            .set_max_speed(max_speed.map(|s| s.get::<meter_per_second>()));
+            .set_deceleration(deceleration.get::<meter_per_second_squared>());
     }
 }

control-core/src/controllers/mod.rs

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

control-core/src/controllers/pid.rs

@@ -9,6 +9,7 @@ pub struct PidController {
     ki: f64,
     /// Derivative gain
     kd: f64,
+
     // State
     /// Proportional error
     ep: f64,
@@ -21,7 +22,7 @@ pub struct PidController {
 }
 
 impl PidController {
-    pub const fn new(kp: f64, ki: f64, kd: f64) -> Self {
+    pub fn new(kp: f64, ki: f64, kd: f64) -> Self {
         Self {
             kp,
             ki,
@@ -33,27 +34,8 @@ impl PidController {
         }
     }
 
-    pub const fn configure(&mut self, ki: f64, kp: f64, kd: f64) {
-        self.reset();
-        self.kp = kp;
-        self.ki = ki;
-        self.kd = kd;
-    }
-
-    pub const fn get_kp(&self) -> f64 {
-        self.kp
-    }
-
-    pub const fn get_ki(&self) -> f64 {
-        self.ki
-    }
-
-    pub const fn get_kd(&self) -> f64 {
-        self.kd
-    }
-
     pub fn update(&mut self, error: f64, t: Instant) -> f64 {
-        match self.last {
+        let signal = match self.last {
             // First update
             None => {
                 // Calculate error
@@ -65,7 +47,6 @@ impl PidController {
                 // Set values
                 self.ep = ep;
                 self.ei = 0.0;
-
                 self.ed = 0.0;
                 self.last = Some(t);
 
@@ -78,11 +59,11 @@ impl PidController {
 
                 // Calculate errors
                 let ep = error;
-                let ei = ep.mul_add(dt, self.ei);
+                let ei = self.ei + ep * dt;
                 let ed = (ep - self.ep) / dt;
 
                 // Calculate signal
-                let signal = self.kd.mul_add(ed, self.kp.mul_add(ep, self.ki * ei));
+                let signal = self.kp * ep + self.ki * ei + self.kd * ed;
 
                 // Set values
                 self.ep = ep;
@@ -92,10 +73,12 @@ impl PidController {
 
                 signal
             }
-        }
+        };
+
+        signal
     }
 
-    pub const fn reset(&mut self) {
+    pub 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, Eq)]
+#[derive(Debug, Clone, PartialEq)]
 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 {
-            Self::InvalidSpeedLimits => {
+            MotionControllerError::InvalidSpeedLimits => {
                 write!(
                     f,
                     "Invalid speed limits: min_speed must be ≤ 0 and max_speed must be ≥ 0"
                 )
             }
-            Self::InvalidAccelerationLimits => {
+            MotionControllerError::InvalidAccelerationLimits => {
                 write!(
                     f,
                     "Invalid acceleration limits: min_acceleration must be < 0 and max_acceleration must be > 0"
                 )
             }
-            Self::InvalidPositionLimits => {
+            MotionControllerError::InvalidPositionLimits => {
                 write!(
                     f,
                     "Invalid position limits: min_position must be ≤ max_position"
                 )
             }
-            Self::ZeroDeceleration => {
+            MotionControllerError::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, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum MotionPhase {
     Idle,
     IncreasingSpeed,
@@ -170,7 +170,7 @@ pub struct ControllerBuilder {
 
 impl ControllerBuilder {
     /// Create a new builder
-    pub const fn new() -> Self {
+    pub fn new() -> Self {
         Self {
             min_speed: None,
             max_speed: None,
@@ -184,36 +184,28 @@ impl ControllerBuilder {
     }
 
     /// Set speed limits (min_speed ≤ 0, max_speed ≥ 0)
-    pub const fn speed_limits(mut self, min_speed: f64, max_speed: f64) -> Self {
+    pub 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 const fn acceleration_limits(
-        mut self,
-        min_acceleration: f64,
-        max_acceleration: f64,
-    ) -> Self {
+    pub 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 const fn position_limits(
-        mut self,
-        min_position: Option<f64>,
-        max_position: Option<f64>,
-    ) -> Self {
+    pub 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 const fn tolerances(mut self, position_tolerance: f64, speed_tolerance: f64) -> Self {
+    pub fn tolerances(mut self, position_tolerance: f64, speed_tolerance: f64) -> Self {
         self.position_tolerance = position_tolerance;
         self.speed_tolerance = speed_tolerance;
         self
@@ -330,7 +322,7 @@ impl AccelerationPositionController {
 
         let motion_constants = Self::calculate_motion_constants(&config);
 
-        Ok(Self {
+        Ok(AccelerationPositionController {
             config,
             current_position: 0.0,
             current_speed: 0.0,
@@ -374,19 +366,19 @@ impl AccelerationPositionController {
         }
 
         Self::new(
-            -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)
+            -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)
         )
     }
 
     /// Create a new builder for the controller
-    pub const fn builder() -> ControllerBuilder {
+    pub fn builder() -> ControllerBuilder {
         ControllerBuilder::new()
     }
 
@@ -572,10 +564,8 @@ impl AccelerationPositionController {
 
         // Calculate distance needed to reach cruise speed from current speed
         let speed_change_distance = if current_speed_in_direction < cruise_speed.abs() {
-            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)
+            (cruise_speed.abs().powi(2) - current_speed_in_direction.max(0.0).powi(2))
+                / (2.0 * acceleration_rate)
         } else {
             0.0
         };
@@ -589,10 +579,8 @@ 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).mul_add(
-                current_speed_in_direction.max(0.0),
-                2.0 * abs_position_change * accel_decel_factor,
-            );
+            let discriminant = current_speed_in_direction.max(0.0).powi(2)
+                + 2.0 * abs_position_change * accel_decel_factor;
 
             if discriminant >= 0.0 {
                 self.peak_speed = discriminant.sqrt() * cruise_speed.signum();
@@ -646,7 +634,7 @@ impl AccelerationPositionController {
                 self.current_acceleration = self.config.max_acceleration * self.direction as f64;
 
                 // Update speed
-                let new_speed = self.current_acceleration.mul_add(dt, self.current_speed);
+                let new_speed = self.current_speed + self.current_acceleration * dt;
 
                 // Check if we've reached peak speed
                 if (self.direction > 0 && new_speed >= self.peak_speed)
@@ -677,7 +665,7 @@ impl AccelerationPositionController {
                 self.current_acceleration = self.config.min_acceleration * self.direction as f64;
 
                 // Update speed
-                let new_speed = self.current_acceleration.mul_add(dt, self.current_speed);
+                let new_speed = self.current_speed + self.current_acceleration * dt;
 
                 // Check if we've reached zero speed or target
                 if (self.current_speed > 0.0 && new_speed <= 0.0)
@@ -701,7 +689,7 @@ impl AccelerationPositionController {
         }
 
         // Update position based on current speed
-        let new_position = self.current_speed.mul_add(dt, self.current_position);
+        let new_position = self.current_position + self.current_speed * dt;
 
         // Check position limits and handle violations
         let mut position_limited = false;
@@ -754,7 +742,7 @@ impl AccelerationPositionController {
     ///
     /// Returns the current position of the controlled object.
     /// This value is updated with each call to `update()`.
-    pub const fn get_position(&self) -> f64 {
+    pub fn get_position(&self) -> f64 {
         self.current_position
     }
 
@@ -763,7 +751,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 const fn get_speed(&self) -> f64 {
+    pub fn get_speed(&self) -> f64 {
         self.current_speed
     }
 
@@ -771,32 +759,32 @@ impl AccelerationPositionController {
     ///
     /// Returns the current acceleration of the controlled object.
     /// Positive values indicate increasing speed, negative values indicate decreasing speed.
-    pub const fn get_acceleration(&self) -> f64 {
+    pub fn get_acceleration(&self) -> f64 {
         self.current_acceleration
     }
 
     /// Get the target position
-    pub const fn get_target_position(&self) -> f64 {
+    pub fn get_target_position(&self) -> f64 {
         self.target_position
     }
 
     /// Get the current motion phase
-    pub const fn get_motion_phase(&self) -> MotionPhase {
+    pub fn get_motion_phase(&self) -> MotionPhase {
         self.motion_phase
     }
 
     /// Get the direction of motion
-    pub const fn get_direction(&self) -> i8 {
+    pub fn get_direction(&self) -> i8 {
         self.direction
     }
 
     /// Get the calculated peak speed for current motion
-    pub const fn get_peak_speed(&self) -> f64 {
+    pub fn get_peak_speed(&self) -> f64 {
         self.peak_speed
     }
 
     /// Get the position at which deceleration will begin
-    pub const fn get_deceleration_position(&self) -> f64 {
+    pub fn get_deceleration_position(&self) -> f64 {
         self.deceleration_position
     }
 
@@ -849,7 +837,7 @@ impl AccelerationPositionController {
     }
 
     /// Force the controller to stop at current position
-    pub const fn emergency_stop(&mut self) {
+    pub fn emergency_stop(&mut self) {
         self.target_position = self.current_position;
         self.current_speed = 0.0;
         self.current_acceleration = 0.0;
@@ -1018,32 +1006,32 @@ impl AccelerationPositionController {
     }
 
     /// Get the minimum speed limit
-    pub const fn get_min_speed(&self) -> f64 {
+    pub fn get_min_speed(&self) -> f64 {
         self.config.min_speed
     }
 
     /// Get the maximum speed limit
-    pub const fn get_max_speed(&self) -> f64 {
+    pub fn get_max_speed(&self) -> f64 {
         self.config.max_speed
     }
 
     /// Get the minimum acceleration limit
-    pub const fn get_min_acceleration(&self) -> f64 {
+    pub fn get_min_acceleration(&self) -> f64 {
         self.config.min_acceleration
     }
 
     /// Get the maximum acceleration limit
-    pub const fn get_max_acceleration(&self) -> f64 {
+    pub fn get_max_acceleration(&self) -> f64 {
         self.config.max_acceleration
     }
 
     /// Get the minimum position limit
-    pub const fn get_min_position(&self) -> Option<f64> {
+    pub fn get_min_position(&self) -> Option<f64> {
         self.config.min_position
     }
 
     /// Get the maximum position limit
-    pub const fn get_max_position(&self) -> Option<f64> {
+    pub fn get_max_position(&self) -> Option<f64> {
         self.config.max_position
     }
 
@@ -1080,17 +1068,17 @@ impl AccelerationPositionController {
     }
 
     /// Get the position tolerance
-    pub const fn get_position_tolerance(&self) -> f64 {
+    pub fn get_position_tolerance(&self) -> f64 {
         self.config.position_tolerance
     }
 
     /// Get the speed tolerance
-    pub const fn get_speed_tolerance(&self) -> f64 {
+    pub fn get_speed_tolerance(&self) -> f64 {
         self.config.speed_tolerance
     }
 
     /// Set tolerances for position and speed comparisons
-    pub const fn set_tolerances(&mut self, position_tolerance: f64, speed_tolerance: f64) {
+    pub 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

@@ -1,6 +1,6 @@
 use std::time::Instant;
 
-use units::{
+use uom::si::{
     angle::radian,
     angular_acceleration::radian_per_second_squared,
     angular_velocity::radian_per_second,
@@ -102,12 +102,16 @@ impl AngularAccelerationPositionController {
 
     /// Get the minimum angle position limit
     pub fn get_min_position(&self) -> Option<Angle> {
-        self.controller.get_min_position().map(Angle::new::<radian>)
+        self.controller
+            .get_min_position()
+            .map(|angle| Angle::new::<radian>(angle))
     }
 
     /// Get the maximum angle position limit
     pub fn get_max_position(&self) -> Option<Angle> {
-        self.controller.get_max_position().map(Angle::new::<radian>)
+        self.controller
+            .get_max_position()
+            .map(|angle| Angle::new::<radian>(angle))
     }
 
     /// Set the minimum angle position limit
@@ -199,8 +203,8 @@ impl AngularAccelerationPositionController {
     /// # Example
     /// ```ignore
     /// use control_core::controllers::second_degree_motion::angular_acceleration_position_controller::AngularAccelerationPositionController;
-    /// use units::f64::Angle;
-    /// use units::angle::degree;
+    /// use uom::si::f64::Angle;
+    /// use uom::si::angle::degree;
     ///
     /// let mut controller = AngularAccelerationPositionController::new_simple(
     ///     Some(Angle::new::<degree>(180.0)),

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

@@ -1,6 +1,6 @@
 use std::time::Instant;
 
-use units::{
+use uom::si::{
     angular_acceleration::radian_per_second_squared,
     angular_jerk::radian_per_second_cubed,
     angular_velocity::radian_per_second,
@@ -23,7 +23,7 @@ use super::jerk_speed_controller::JerkSpeedController;
 ///
 /// # Example
 /// ```ignore
-/// use units::{
+/// use uom::si::{
 ///     angular_velocity::revolution_per_minute,
 ///     angular_acceleration::revolution_per_minute_per_second,
 ///     angular_jerk::revolution_per_minute_per_second_squared,
@@ -65,7 +65,7 @@ impl AngularJerkSpeedController {
     ///
     /// # Example
     /// ```ignore
-    /// use units::{
+    /// use uom::si::{
     ///     angular_velocity::revolution_per_minute,
     ///     angular_acceleration::revolution_per_minute_per_second,
     ///     angular_jerk::revolution_per_minute_per_second_squared,
@@ -127,7 +127,7 @@ impl AngularJerkSpeedController {
     ///
     /// # Example
     /// ```ignore
-    /// use units::{
+    /// use uom::si::{
     ///     angular_velocity::revolution_per_minute,
     ///     angular_acceleration::revolution_per_minute_per_second,
     ///     angular_jerk::revolution_per_minute_per_second_squared,
@@ -185,7 +185,7 @@ impl AngularJerkSpeedController {
     /// # Example
     /// ```ignore
     /// use std::time::Instant;
-    /// use units::{angular_velocity::revolution_per_minute, f64::AngularVelocity};
+    /// use uom::si::{angular_velocity::revolution_per_minute, f64::AngularVelocity};
     ///
     /// let mut controller = AngularJerkSpeedController::new_simple(/* ... */);
     /// let target = AngularVelocity::new::<revolution_per_minute>(1500.0);
@@ -236,7 +236,7 @@ impl AngularJerkSpeedController {
     pub fn get_min_speed(&self) -> Option<AngularVelocity> {
         self.controller
             .get_min_speed()
-            .map(AngularVelocity::new::<radian_per_second>)
+            .map(|speed| AngularVelocity::new::<radian_per_second>(speed))
     }
 
     /// 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(AngularVelocity::new::<radian_per_second>)
+            .map(|speed| AngularVelocity::new::<radian_per_second>(speed))
     }
 
     /// 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");
 
-        Self { base_controller }
+        JerkSpeedController { 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 const fn get_speed(&self) -> f64 {
+    pub 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 const fn get_acceleration(&self) -> f64 {
+    pub 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 const fn get_jerk(&self) -> f64 {
+    pub 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 const fn get_target_speed(&self) -> f64 {
+    pub 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 const fn get_min_speed(&self) -> Option<f64> {
+    pub 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 const fn get_max_speed(&self) -> Option<f64> {
+    pub 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

@@ -1,6 +1,6 @@
 use std::time::Instant;
 
-use units::{
+use uom::si::{
     acceleration::meter_per_second_squared,
     f64::{Acceleration, Length, Velocity},
     length::meter,
@@ -22,8 +22,8 @@ use super::acceleration_position_controller::{
 ///
 /// # Example
 /// ```ignore
-/// use units::{length::meter, velocity::meter_per_second, acceleration::meter_per_second_squared};
-/// use units::f64::{Length, Velocity, Acceleration};
+/// use uom::si::{length::meter, velocity::meter_per_second, acceleration::meter_per_second_squared};
+/// use uom::si::f64::{Length, Velocity, Acceleration};
 ///
 /// let position_limit = Length::new::<meter>(10.0);
 /// let max_speed = Velocity::new::<meter_per_second>(2.0);
@@ -101,8 +101,8 @@ impl LinearAccelerationPositionController {
     ///
     /// # Example
     /// ```ignore
-    /// use units::{length::meter, velocity::meter_per_second, acceleration::meter_per_second_squared};
-    /// use units::f64::{Length, Velocity, Acceleration};
+    /// use uom::si::{length::meter, velocity::meter_per_second, acceleration::meter_per_second_squared};
+    /// use uom::si::f64::{Length, Velocity, Acceleration};
     ///
     /// let position_limit = Length::new::<meter>(5.0);  // Creates [-5.0, +5.0] meter range
     /// let max_speed = Velocity::new::<meter_per_second>(1.0);  // Creates [-1.0, +1.0] m/s range
@@ -150,7 +150,7 @@ impl LinearAccelerationPositionController {
     /// # Example
     /// ```ignore
     /// use std::time::Instant;
-    /// use units::{length::meter, f64::Length};
+    /// use uom::si::{length::meter, f64::Length};
     ///
     /// let mut controller = LinearAccelerationPositionController::new_simple(
     ///     Some(Length::new::<meter>(10.0)),
@@ -205,7 +205,9 @@ 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::new::<meter>)
+        self.controller
+            .get_min_position()
+            .map(|length| Length::new::<meter>(length))
     }
 
     /// Get the maximum position limit
@@ -215,7 +217,9 @@ 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::new::<meter>)
+        self.controller
+            .get_max_position()
+            .map(|length| Length::new::<meter>(length))
     }
 
     /// Set the minimum position limit
@@ -375,7 +379,7 @@ impl LinearAccelerationPositionController {
     ///
     /// # Example
     /// ```ignore
-    /// use units::{length::meter, velocity::meter_per_second, f64::{Length, Velocity}};
+    /// use uom::si::{length::meter, velocity::meter_per_second, f64::{Length, Velocity}};
     ///
     /// let new_position = Length::new::<meter>(0.0);
     ///

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

@@ -1,6 +1,6 @@
 use std::time::Instant;
 
-use units::{
+use uom::si::{
     acceleration::meter_per_second_squared,
     f64::{Acceleration, Jerk, Velocity},
     jerk::meter_per_second_cubed,
@@ -23,7 +23,7 @@ use super::jerk_speed_controller::JerkSpeedController;
 ///
 /// # Example
 /// ```ignore
-/// use units::{
+/// use uom::si::{
 ///     velocity::meter_per_second,
 ///     acceleration::meter_per_second_squared,
 ///     jerk::meter_per_second_cubed,
@@ -65,7 +65,7 @@ impl LinearJerkSpeedController {
     ///
     /// # Example
     /// ```ignore
-    /// use units::{
+    /// use uom::si::{
     ///     velocity::meter_per_second,
     ///     acceleration::meter_per_second_squared,
     ///     jerk::meter_per_second_cubed,
@@ -127,7 +127,7 @@ impl LinearJerkSpeedController {
     ///
     /// # Example
     /// ```ignore
-    /// use units::{
+    /// use uom::si::{
     ///     velocity::meter_per_second,
     ///     acceleration::meter_per_second_squared,
     ///     jerk::meter_per_second_cubed,
@@ -195,14 +195,14 @@ impl LinearJerkSpeedController {
     pub fn get_min_speed(&self) -> Option<Velocity> {
         self.controller
             .get_min_speed()
-            .map(Velocity::new::<meter_per_second>)
+            .map(|speed| Velocity::new::<meter_per_second>(speed))
     }
 
     /// Get the maximum velocity limit
     pub fn get_max_speed(&self) -> Option<Velocity> {
         self.controller
             .get_max_speed()
-            .map(Velocity::new::<meter_per_second>)
+            .map(|speed| Velocity::new::<meter_per_second>(speed))
     }
 
     /// Set the minimum velocity limit

control-core/src/converters/angle_converter.rs

@@ -1,297 +0,0 @@
-use units::{angle::radian, f64::Angle};
-
-#[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)
-    pub is_cw: bool,  // true for clockwise, false for counter-clockwise
-}
-
-impl AngleConverter {
-    /// Create a custom coordinate system
-    pub const fn new(flip_x: bool, flip_y: bool, is_cw: bool) -> Self {
-        Self {
-            flip_x,
-            flip_y,
-            is_cw,
-        }
-    }
-
-    /// Standard mathematical coordinate system (CCW positive, 0° at positive X)
-    pub const fn mathematical() -> Self {
-        Self::new(false, false, false)
-    }
-
-    /// Screen/graphics coordinate system (CW positive, 0° at positive X, Y-flipped)
-    pub const fn screen() -> Self {
-        Self::new(false, true, false)
-    }
-
-    /// System where 0° points up, clockwise positive
-    pub const fn y_up_cw() -> Self {
-        Self::new(false, false, true)
-    }
-
-    /// System where 0° points down, counter-clockwise positive
-    pub const fn y_down_ccw() -> Self {
-        Self::new(false, true, true)
-    }
-
-    /// System where 0° points left, clockwise positive
-    pub const fn x_left_cw() -> Self {
-        Self::new(true, false, false)
-    }
-
-    /// System where 0° points right, counter-clockwise positive (same as mathematical)
-    pub const fn x_right_ccw() -> Self {
-        Self::mathematical()
-    }
-
-    /// System where 0° points up, counter-clockwise positive
-    pub const fn y_up_ccw() -> Self {
-        Self::new(false, false, false)
-    }
-
-    /// System where 0° points down, clockwise positive
-    pub const fn y_down_cw() -> Self {
-        Self::new(false, true, false)
-    }
-
-    /// System where 0° points left, counter-clockwise positive
-    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: f64) -> f64 {
-        let normalized_input = self.normalize_angle(math_angle_degrees);
-
-        let mut result = normalized_input;
-
-        // Apply axis flips
-        match (self.flip_x, self.flip_y) {
-            (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,          // Both flips: 180° rotation
-        }
-
-        // Handle rotation direction
-        if self.is_cw {
-            result = -result;
-        }
-
-        self.normalize_angle(result)
-    }
-
-    /// Convert angle from this system to mathematical system (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;
-
-        // Handle rotation direction
-        if self.is_cw {
-            result = -result;
-        }
-
-        // Apply inverse axis flips
-        match (self.flip_x, self.flip_y) {
-            (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,          // 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: f64) -> f64 {
-        let degrees = math_angle_radians.to_degrees();
-        let converted_degrees = self.degrees_encode(degrees);
-        converted_degrees.to_radians()
-    }
-
-    /// Convert angle in radians from this system to mathematical system (f32)
-    pub fn radians_decode(&self, system_angle_radians: f64) -> f64 {
-        let degrees = system_angle_radians.to_degrees();
-        let converted_degrees = self.degrees_decode(degrees);
-        converted_degrees.to_radians()
-    }
-
-    /// Convert angle from mathematical system to this system (f64)
-    pub fn degrees_encode_f64(&self, math_angle_degrees: f64) -> f64 {
-        let normalized_input = self.normalize_angle_f64(math_angle_degrees);
-
-        let mut result = normalized_input;
-
-        // Apply axis flips
-        match (self.flip_x, self.flip_y) {
-            (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,          // Both flips: 180° rotation
-        }
-
-        // Handle rotation direction
-        if self.is_cw {
-            result = -result;
-        }
-
-        self.normalize_angle_f64(result)
-    }
-
-    /// Convert angle from this system to mathematical system (f64)
-    pub fn degrees_decode_f64(&self, system_angle_degrees: f64) -> f64 {
-        let normalized_input = self.normalize_angle_f64(system_angle_degrees);
-
-        let mut result = normalized_input;
-
-        // Handle rotation direction
-        if self.is_cw {
-            result = -result;
-        }
-
-        // Apply inverse axis flips
-        match (self.flip_x, self.flip_y) {
-            (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,          // Both flips: inverse 180° rotation
-        }
-
-        self.normalize_angle_f64(result)
-    }
-
-    /// 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.to_degrees();
-        let converted_degrees = self.degrees_encode_f64(degrees);
-        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.to_degrees();
-        let converted_degrees = self.degrees_decode_f64(degrees);
-        converted_degrees.to_radians()
-    }
-
-    /// Normalize angle to [0, 360) range (f32)
-    fn normalize_angle(&self, angle: f64) -> f64 {
-        let mut normalized = angle % 360.0;
-        if normalized < 0.0 {
-            normalized += 360.0;
-        }
-        normalized
-    }
-
-    /// Normalize angle to [0, 360) range (f64)
-    fn normalize_angle_f64(&self, angle: f64) -> f64 {
-        let mut normalized = angle % 360.0;
-        if normalized < 0.0 {
-            normalized += 360.0;
-        }
-        normalized
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct AngleConverterUom {
-    angle_converter: AngleConverter,
-}
-
-impl AngleConverterUom {
-    pub const fn new(angle_converter: AngleConverter) -> Self {
-        Self { angle_converter }
-    }
-
-    pub fn encode(&self, angle: Angle) -> Angle {
-        Angle::new::<radian>(self.angle_converter.radians_encode(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]
-    fn test_constructors() {
-        let math = AngleConverter::mathematical();
-        assert_eq!(math.flip_x, false);
-        assert_eq!(math.flip_y, false);
-        assert_eq!(math.is_cw, false);
-
-        let screen = AngleConverter::screen();
-        assert_eq!(screen.flip_x, false);
-        assert_eq!(screen.flip_y, true);
-        assert_eq!(screen.is_cw, false);
-    }
-
-    #[test]
-    fn test_screen_converter_bidirectional() {
-        let converter = AngleConverter::screen();
-
-        // Math to screen (Y-flip only)
-        assert_eq!(converter.degrees_encode(0.0), 0.0); // Right stays right
-        assert_eq!(converter.degrees_encode(90.0), 270.0); // Up becomes down
-        assert_eq!(converter.degrees_encode(270.0), 90.0); // Down becomes up
-        assert_eq!(converter.degrees_encode(180.0), 180.0); // Left stays left
-
-        // Screen to math (should be inverse)
-        assert_eq!(converter.degrees_decode(0.0), 0.0); // Right stays right
-        assert_eq!(converter.degrees_decode(270.0), 90.0); // Down becomes up
-        assert_eq!(converter.degrees_decode(90.0), 270.0); // Up becomes down
-        assert_eq!(converter.degrees_decode(180.0), 180.0); // Left stays left
-    }
-
-    #[test]
-    fn test_x_flip_converter() {
-        let converter = AngleConverter::x_left_cw();
-
-        // Math to x-flipped system
-        assert_eq!(converter.degrees_encode(0.0), 180.0); // Right becomes left
-        assert_eq!(converter.degrees_encode(90.0), 90.0); // Up stays up
-        assert_eq!(converter.degrees_encode(180.0), 0.0); // Left becomes right
-        assert_eq!(converter.degrees_encode(270.0), 270.0); // Down stays down
-    }
-
-    #[test]
-    fn test_both_flips_converter() {
-        let converter = AngleConverter::new(true, true, false);
-
-        // Math to both-flipped system (180° rotation)
-        assert_eq!(converter.degrees_encode(0.0), 180.0); // Right becomes left
-        assert_eq!(converter.degrees_encode(90.0), 270.0); // Up becomes down
-        assert_eq!(converter.degrees_encode(180.0), 0.0); // Left becomes right
-        assert_eq!(converter.degrees_encode(270.0), 90.0); // Down becomes up
-    }
-
-    #[test]
-    fn test_radians_conversion() {
-        let converter = AngleConverter::screen();
-
-        // Test radians_encode
-        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);
-    }
-
-    #[test]
-    fn test_roundtrip_conversion() {
-        let converter = AngleConverter::new(true, false, true); // X-flip + CW
-
-        let original = 75.0_f64;
-        let converted = converter.degrees_encode(original);
-        let roundtrip = converter.degrees_decode(converted);
-
-        assert!((original - roundtrip as f64).abs() < 1e-6);
-    }
-}

control-core/src/converters/angular_step_converter.rs

@@ -1,4 +1,4 @@
-use units::{
+use uom::si::{
     angle::revolution,
     angular_acceleration::radian_per_second_squared,
     angular_velocity::revolution_per_second,
@@ -18,7 +18,7 @@ pub struct AngularStepConverter {
 
 impl AngularStepConverter {
     /// Create a new converter with the specified steps per revolution
-    pub const fn new(steps_per_revolution: i16) -> Self {
+    pub fn new(steps_per_revolution: i16) -> Self {
         Self {
             steps_per_revolution,
         }
@@ -90,7 +90,7 @@ mod tests {
     use super::*;
     use approx::assert_relative_eq;
     use std::f64::EPSILON;
-    use units::{
+    use uom::si::{
         angle::degree, angular_acceleration::degree_per_second_squared,
         angular_velocity::degree_per_second,
     };

control-core/src/converters/circular_converter.rs

@@ -1,279 +0,0 @@
-//! # 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 units::{f64::{Length, Velocity}, length::meter, velocity::meter_per_second};
-//!
-//! let converter = CircularConverter::from_radius(Length::new::<meter>(0.1));
-//! let velocity = Velocity::new::<meter_per_second>(1.0);
-//! let angular_velocity = converter.linear_to_angular_velocity(velocity);
-//! ```
-
-use units::{
-    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 units::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,11 +1,14 @@
-use units::{
+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
 ///
@@ -15,52 +18,57 @@ use super::circular_converter::CircularConverter;
 #[derive(Debug, Clone)]
 pub struct LinearStepConverter {
     angular_step_converter: AngularStepConverter,
-    circular_converter: CircularConverter,
+    radius: Length,
+    circumference: Length,
 }
 
 // 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),
-            circular_converter: CircularConverter::from_radius(radius),
+            radius,
+            circumference,
         }
     }
 
     /// Create a new converter from diameter and steps per revolution
     pub fn from_diameter(steps_per_revolution: i16, diameter: Length) -> Self {
-        Self {
-            angular_step_converter: AngularStepConverter::new(steps_per_revolution),
-            circular_converter: CircularConverter::from_diameter(diameter),
-        }
+        let radius = diameter / 2.0;
+        Self::from_radius(steps_per_revolution, radius)
     }
 
     /// 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),
-            circular_converter: CircularConverter::from_circumference(circumference),
+            radius,
+            circumference,
         }
     }
 
     /// Get the radius used by the converter
     pub fn radius(&self) -> Length {
-        self.circular_converter.radius()
+        self.radius
     }
 
     /// Get the diameter of the system
     pub fn diameter(&self) -> Length {
-        self.circular_converter.diameter()
+        self.radius * 2.0
     }
 
     /// Get the circumference of the system
     pub fn circumference(&self) -> Length {
-        self.circular_converter.circumference()
+        self.circumference
     }
 
     /// Get the steps per revolution
-    pub const fn steps_per_revolution(&self) -> i16 {
+    pub fn steps_per_revolution(&self) -> i16 {
         self.angular_step_converter.steps_per_revolution
     }
 }
@@ -71,10 +79,8 @@ impl LinearStepConverter {
     ///
     /// Formula: steps = (distance / circumference) * steps_per_revolution
     pub fn distance_to_steps(&self, distance: Length) -> f64 {
-        // Convert distance to revolutions using CircularConverter
-        let revolutions = self
-            .circular_converter
-            .linear_distance_to_revolutions(distance);
+        // Convert distance to angle: angle = distance/circumference (in revolutions)
+        let revolutions = distance.get::<meter>() / self.circumference.get::<meter>();
         let angle = Angle::new::<revolution>(revolutions);
 
         // Convert angle to steps
@@ -88,19 +94,21 @@ impl LinearStepConverter {
         // Convert steps to angle
         let angle = self.angular_step_converter.steps_to_angle(steps);
 
-        // Convert angle to distance using CircularConverter
+        // Convert angle to distance: distance = angle * circumference
         let revolutions = angle.get::<revolution>();
-        self.circular_converter
-            .revolutions_to_linear_distance(revolutions)
+        let distance = revolutions * self.circumference.get::<meter>();
+
+        Length::new::<meter>(distance)
     }
 
     /// 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 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 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 angular velocity to steps/second
         self.angular_step_converter
@@ -116,19 +124,23 @@ impl LinearStepConverter {
             .angular_step_converter
             .steps_to_angular_velocity(steps_per_second);
 
-        // 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 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 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 using CircularConverter
-        let angular_acceleration = self
-            .circular_converter
-            .linear_to_angular_acceleration(acceleration);
+        // 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 angular acceleration to steps/second²
         self.angular_step_converter
@@ -144,9 +156,12 @@ impl LinearStepConverter {
             .angular_step_converter
             .steps_to_angular_acceleration(steps_per_second_squared);
 
-        // Convert angular acceleration to linear acceleration using CircularConverter
-        self.circular_converter
-            .angular_to_linear_acceleration(angular_acceleration)
+        // 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)
     }
 }
 
@@ -156,9 +171,7 @@ impl LinearStepConverter {
     ///
     /// Formula: angle (in revolutions) = distance / circumference
     pub fn distance_to_angle(&self, distance: Length) -> Angle {
-        let revolutions = self
-            .circular_converter
-            .linear_distance_to_revolutions(distance);
+        let revolutions = distance.get::<meter>() / self.circumference.get::<meter>();
         Angle::new::<revolution>(revolutions)
     }
 
@@ -167,24 +180,26 @@ impl LinearStepConverter {
     /// Formula: distance = angle (in revolutions) * circumference
     pub fn angle_to_distance(&self, angle: Angle) -> Length {
         let revolutions = angle.get::<revolution>();
-        self.circular_converter
-            .revolutions_to_linear_distance(revolutions)
+        let distance = revolutions * self.circumference.get::<meter>();
+        Length::new::<meter>(distance)
     }
 
     /// 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 rps = self.circular_converter.linear_velocity_to_rps(velocity);
-        AngularVelocity::new::<revolution_per_second>(rps)
+        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)
     }
 
     /// 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 rps = angular_velocity.get::<revolution_per_second>();
-        self.circular_converter.rps_to_linear_velocity(rps)
+        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 linear acceleration to angular acceleration
@@ -194,8 +209,9 @@ impl LinearStepConverter {
         &self,
         acceleration: Acceleration,
     ) -> AngularAcceleration {
-        self.circular_converter
-            .linear_to_angular_acceleration(acceleration)
+        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)
     }
 
     /// Convert angular acceleration to linear acceleration
@@ -205,8 +221,10 @@ impl LinearStepConverter {
         &self,
         angular_acceleration: AngularAcceleration,
     ) -> Acceleration {
-        self.circular_converter
-            .angular_to_linear_acceleration(angular_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)
     }
 }
 
@@ -251,10 +269,6 @@ mod tests {
     use super::*;
     use approx::assert_relative_eq;
     use std::f64::EPSILON;
-    use units::{
-        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,4 @@
-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

@@ -0,0 +1,22 @@
+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

@@ -1,36 +0,0 @@
-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

@@ -0,0 +1,309 @@
+use anyhow::Error;
+use anyhow::anyhow;
+use ethercat_hal::devices::ek1100::EK1100_IDENTITY_A;
+use ethercat_hal::devices::el1002::EL1002_IDENTITY_A;
+use ethercat_hal::devices::el1008::EL1008_IDENTITY_A;
+use ethercat_hal::devices::el2002::EL2002_IDENTITY_A;
+use ethercat_hal::devices::el2004::EL2004_IDENTITY_A;
+use ethercat_hal::devices::el2008::EL2008_IDENTITY_A;
+use ethercat_hal::devices::el2521::{
+    EL2521_IDENTITY_0000_A, EL2521_IDENTITY_0000_B, EL2521_IDENTITY_0024_A,
+};
+use ethercat_hal::devices::el2522::EL2522_IDENTITY_A;
+use ethercat_hal::devices::el3001::EL3001_IDENTITY_A;
+use ethercat_hal::devices::el3021::EL3021_IDENTITY_A;
+use ethercat_hal::devices::el3024::EL3024_IDENTITY_A;
+use ethercat_hal::devices::el3204::EL3204_IDENTITY_A;
+use ethercat_hal::devices::el6021::EL6021_IDENTITY_A;
+use ethercat_hal::devices::el6021::EL6021_IDENTITY_B;
+
+use ethercat_hal::devices::el3204::EL3204_IDENTITY_B;
+
+use ethercat_hal::devices::el6021::EL6021_IDENTITY_C;
+use ethercat_hal::devices::el7031::{EL7031_IDENTITY_A, EL7031_IDENTITY_B};
+use ethercat_hal::devices::el7031_0030::EL7031_0030_IDENTITY_A;
+use ethercat_hal::devices::el7041_0052::EL7041_0052_IDENTITY_A;
+use ethercat_hal::devices::subdevice_identity_to_tuple;
+use ethercat_hal::helpers::ethercrab_types::{
+    EthercrabSubDeviceOperational,
+    EthercrabSubDevicePreoperational,
+};
+use ethercrab::MainDevice;
+use ethercrab::SubDeviceIdentity;
+
+use crate::machines::identification::DeviceMachineIdentification;
+use crate::machines::identification::MachineIdentification;
+use crate::machines::identification::MachineIdentificationUnique;
+
+#[derive(Debug)]
+pub struct MachineIdentificationAddresses {
+    pub vendor_word: u16,
+    pub serial_word: u16,
+    pub machine_word: u16,
+    pub role_word: u16,
+}
+
+impl MachineIdentificationAddresses {
+    pub fn new(vendor_word: u16, serial_word: u16, machine_word: u16, device_word: u16) -> Self {
+        Self {
+            vendor_word,
+            serial_word,
+            machine_word,
+            role_word: device_word,
+        }
+    }
+}
+
+impl Default for MachineIdentificationAddresses {
+    fn default() -> Self {
+        Self {
+            vendor_word: 0x0028,
+            serial_word: 0x0029,
+            machine_word: 0x002a,
+            role_word: 0x002b,
+        }
+    }
+}
+
+/// Reads the EEPROM of all subdevices to get their machine device identifications
+///
+/// Returns a vector of MachineDeviceIdentification for all subdevices
+pub async fn read_device_identifications<
+    'maindevice,
+>(
+    subdevices: &Vec<EthercrabSubDevicePreoperational<'maindevice>>,
+    maindevice: &MainDevice<'maindevice>,
+) -> Vec<Result<DeviceMachineIdentification, Error>> {
+    let mut result = Vec::new();
+    for subdevice in subdevices.iter() {
+        let identification = machine_device_identification(&subdevice, maindevice).await;
+        result.push(identification);
+    }
+    result
+}
+
+/// Reads the machine device identification from the EEPROM
+pub async fn machine_device_identification<'maindevice>(
+    subdevice: &'maindevice EthercrabSubDevicePreoperational<'maindevice>,
+    maindevice: &MainDevice<'_>,
+) -> Result<DeviceMachineIdentification, Error> {
+    let addresses = match get_identification_addresses(&subdevice.identity(), subdevice.name()) {
+        Ok(x) => x,
+        Err(e) => {
+            u16dump(subdevice, maindevice, 0, 128).await?;
+            return Err(e);
+        }
+    };
+
+    let mdi = DeviceMachineIdentification {
+        machine_identification_unique: MachineIdentificationUnique {
+            machine_identification: MachineIdentification {
+                vendor: subdevice
+                .eeprom_read::<u16>(maindevice, addresses.vendor_word)
+                .await
+                .or(Err(anyhow!(
+                    "[{}::machine_device_identification] Failed to read vendor from EEPROM for device {}",
+                    module_path!(),
+                    subdevice.name()
+                )))?,
+                machine: subdevice
+                .eeprom_read::<u16>(maindevice, addresses.machine_word)
+                .await
+                .or(Err(anyhow!(
+                    "[{}::machine_device_identification] Failed to read machine from EEPROM for device {}",
+                    module_path!(),
+                    subdevice.name()
+                )))?,
+            },
+            serial: subdevice
+                .eeprom_read::<u16>(maindevice, addresses.serial_word)
+                .await
+                .or(Err(anyhow!(
+                    "[{}::machine_device_identification] Failed to read serial from EEPROM for device {}",
+                    module_path!(),
+                    subdevice.name()
+                )))?,
+           
+        },
+        role: subdevice
+            .eeprom_read::<u16>(maindevice, addresses.role_word)
+            .await
+            .or(Err(anyhow!(
+                "[{}::machine_device_identification] Failed to read role from EEPROM for device {}",
+                module_path!(),
+                subdevice.name()
+            )))?,
+    };
+
+    log::debug!(
+        "[{}::machine_device_identification] Read MDI from EEPROM for device {}\nVendor:  0x{:08x} at 0x{:04x}-0x{:04x}\nSerial:  0x{:08x} at 0x{:04x}-0x{:04x}\nMachine: 0x{:08x} at 0x{:04x}-0x{:04x}\nRole:    0x{:08x} at 0x{:04x}-0x{:04x}",
+        module_path!(),
+        subdevice.name(),
+        mdi.machine_identification_unique.machine_identification.vendor,
+        addresses.vendor_word,
+        addresses.vendor_word + 1,
+        mdi.machine_identification_unique.serial,
+        addresses.serial_word,
+        addresses.serial_word + 1,
+        mdi.machine_identification_unique.machine_identification.machine,
+        addresses.machine_word,
+        addresses.machine_word + 1,
+        mdi.role,
+        addresses.role_word,
+        addresses.role_word + 1,
+    );
+
+    Ok(mdi)
+}
+
+/// Writes the machine device identification to the EEPROM
+pub async fn write_machine_device_identification<'maindevice, const MAX_PDI: usize>(
+    subdevice: &EthercrabSubDeviceOperational<'maindevice, MAX_PDI>,
+    maindevice: &MainDevice<'_>,
+    device_identification: &DeviceMachineIdentification,
+) -> Result<(), Error> {
+    let addresses = get_identification_addresses(&subdevice.identity(), subdevice.name())?;
+    log::debug!(
+        "[{}::write_machine_device_identification] Writing MDI to EEPROM for device {}\nVendor:  0x{:08x} at 0x{:04x}-0x{:04x}\nSerial:  0x{:08x} at 0x{:04x}-0x{:04x}\nMachine: 0x{:08x} at 0x{:04x}-0x{:04x}\nRole:    0x{:08x} at 0x{:04x}-0x{:04x}",
+        module_path!(),
+        subdevice.name(),
+        device_identification.machine_identification_unique.machine_identification.vendor,
+        addresses.vendor_word,
+        addresses.vendor_word + 1,
+        device_identification.machine_identification_unique.serial,
+        addresses.serial_word,
+        addresses.serial_word + 1,
+        device_identification.machine_identification_unique.machine_identification.machine,
+        addresses.machine_word,
+        addresses.machine_word + 1,
+        device_identification.role,
+        addresses.role_word,
+        addresses.role_word + 1,
+    );
+
+    subdevice
+        .eeprom_write_dangerously(
+            maindevice,
+            addresses.vendor_word,
+            device_identification.machine_identification_unique.machine_identification.vendor,
+        )
+        .await?;
+    subdevice
+        .eeprom_write_dangerously(
+            maindevice,
+            addresses.serial_word,
+            device_identification.machine_identification_unique.serial,
+        )
+        .await?;
+    subdevice
+        .eeprom_write_dangerously(
+            maindevice,
+            addresses.machine_word,
+            device_identification.machine_identification_unique.machine_identification.machine,
+        )
+        .await?;
+    subdevice
+        .eeprom_write_dangerously(maindevice, addresses.role_word, device_identification.role)
+        .await?;
+    Ok(())
+}
+
+/// Returns the EEPROM addresses for the machine device identification
+/// based on the subdevice's identity
+pub fn get_identification_addresses<'maindevice>(
+    subdevice_identity: &SubDeviceIdentity,
+    subdevice_name: &str,
+) -> Result<MachineIdentificationAddresses, Error> {
+    let identity_tuple = subdevice_identity_to_tuple(&subdevice_identity);
+
+    Ok(match identity_tuple {
+        EK1100_IDENTITY_A => MachineIdentificationAddresses::default(),
+        EL1002_IDENTITY_A => MachineIdentificationAddresses::default(),
+        EL1008_IDENTITY_A => MachineIdentificationAddresses::default(),
+        EL2002_IDENTITY_A => 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(),
+        EL2521_IDENTITY_0000_A | EL2521_IDENTITY_0000_B | EL2521_IDENTITY_0024_A => {
+            MachineIdentificationAddresses::default()
+        }
+        EL2522_IDENTITY_A => MachineIdentificationAddresses::default(),
+        EL3024_IDENTITY_A => MachineIdentificationAddresses::default(),
+        EL3021_IDENTITY_A => MachineIdentificationAddresses::default(),
+        EL7031_IDENTITY_A | EL7031_IDENTITY_B => MachineIdentificationAddresses::default(),
+        EL7031_0030_IDENTITY_A => MachineIdentificationAddresses::default(),
+        EL7041_0052_IDENTITY_A => MachineIdentificationAddresses::default(),
+        EL6021_IDENTITY_A | EL6021_IDENTITY_B | EL6021_IDENTITY_C => MachineIdentificationAddresses::default(),
+        _ => {
+            // block_on(u16dump(&subdevice, maindevice, 0x00, 0xff))?;
+            Err(anyhow!(
+                "[{}::get_identification_addresses] Unknown MDI addresses for device {:?} vendor: 0x{:08x} product: 0x{:08x} revision: 0x{:08x}",
+                module_path!(),
+                subdevice_name,
+                subdevice_identity.vendor_id,
+                subdevice_identity.product_id,
+                subdevice_identity.revision
+            ))?
+        }
+    })
+}
+
+async fn u16dump<'maindevice>(
+    subdevice: &'maindevice EthercrabSubDevicePreoperational<'maindevice>,
+    maindevice: &MainDevice<'maindevice>,
+    start_byte: u16,
+    end_byte: u16,
+) -> Result<(), Error> {
+    let mut words: Vec<u16> = Vec::new();
+    for word in start_byte..end_byte {
+        words.push(subdevice.eeprom_read(maindevice, word).await?);
+    }
+
+    print!(
+        "EEPROM dump for {} from 0x{:04x} to 0x{:04x}\n",
+        subdevice.name(),
+        start_byte / 2,
+        end_byte / 2
+    );
+
+    u16print(start_byte, end_byte, words);
+
+    Ok(())
+}
+
+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;
+
+    for row in 0..rows {
+        print!("0x{:04x} | ", (table_start_word + row * 0x10) / 2);
+        for word in 0..8 {
+            let word_address = row * 8 + word;
+            if word_address < start_byte {
+                print!("     ");
+            } else {
+                let i = (word_address - start_byte) as usize;
+                if i > data.len() - 1 {
+                    print!("     ");
+                } else {
+                    print!("{:04x} ", data[i]);
+                }
+            }
+        }
+        print!("\n");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_hexprint() {
+        let data = vec![0x0000, 0x1ced];
+        u16print(0x01, 0x40, data);
+    }
+}

control-core/src/ethercat/interface_discovery.rs

@@ -1,9 +1,10 @@
+use std::{sync::Arc, time::Duration};
+
 use ethercrab::{
     MainDevice, MainDeviceConfig, PduStorage, Timeouts,
     std::{ethercat_now, tx_rx_task},
 };
 use interfaces::Interface;
-use std::{process::Command, sync::Arc, time::Duration};
 
 // Constants for EtherCAT configuration
 const IFACE_DISCOVERY_MAX_SUBDEVICES: usize = 16; // Must be power of 2 > 1
@@ -11,115 +12,94 @@ 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;
 
-/// 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);
-}
-
+/// 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"),
+/// }
+/// ```
 pub async fn discover_ethercat_interface() -> Result<String, anyhow::Error> {
-    tracing::info!("Discovering EtherCAT interface...");
+    log::info!("Discovering EtherCAT interface...");
 
     // Set up a custom panic hook that suppresses panic output
     let default_hook = std::panic::take_hook();
     std::panic::set_hook(Box::new(move |panic_info| {
         // Optional: log the panic in a controlled way
         if let Some(location) = panic_info.location() {
-            tracing::debug!(
+            log::debug!(
                 "Suppressed panic in interface test: {} (at {}:{})",
                 panic_info,
                 location.file(),
                 location.line()
             );
         } else {
-            tracing::debug!("Suppressed panic in interface test: {}", panic_info);
+            log::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()
-        .map_err(|e| anyhow::anyhow!("Failed to get network interfaces: {}", e))?
+        .or_else(|e| Err(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
-                && !iface.name.starts_with("anpi")   // Exclude Apple Network Privacy Interface
-                && !iface.name.starts_with("llw") // Exclude Apple low-latency WLAN
         })
         .collect::<Vec<_>>();
 
+    // Sort interfaces by name
     interfaces.sort_by(|a, b| a.name.cmp(&b.name));
-    let mut interface: Option<&str> = None;
 
-    for i in 0..interfaces.len() {
-        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(_) => (),
-        }
-    }
+    // Try all interfaces concurrently
+    let tasks = interfaces
+        .iter()
+        .map(|iface| {
+            let name = iface.name.clone();
+            std::thread::spawn(move || {
+                std::panic::catch_unwind(|| {
+                    smol::block_on(async {
+                        match test_interface(&name) {
+                            Ok(_) => {
+                                log::debug!("Found working EtherCAT interface: {}", name);
+                                Some(name.clone())
+                            }
+                            Err(e) => {
+                                log::debug!("Interface {} failed: {}", name, e);
+                                None
+                            }
+                        }
+                    })
+                })
+                .unwrap_or(None)
+            })
+        })
+        .collect::<Vec<_>>();
 
-    for i in 0..interfaces.len() {
-        if interface.is_some() && interface.unwrap() == &interfaces[i].name {
-            set_interface_managed(&interfaces[i].name, false);
-        } else {
-            set_interface_managed(&interfaces[i].name, true);
-        }
-    }
+    // Return first successful interface
+    let result =
+        tasks
+            .into_iter()
+            .find_map(|task| match task.join().expect("Should join thread") {
+                Some(name) => Some(name),
+                None => None,
+            });
 
     // Restore the default panic hook
     std::panic::set_hook(default_hook);
 
-    match interface {
-        Some(interface) => return Ok(interface.to_string()),
-        None => return Err(anyhow::anyhow!("No suitable EtherCAT interface found")),
+    match result {
+        Some(name) => Ok(name),
+        None => Err(anyhow::anyhow!("No suitable EtherCAT interface found")),
     }
 }
 
 fn test_interface(interface: &str) -> Result<(), anyhow::Error> {
-    tracing::info!("Testing interface: {}", interface);
+    log::debug!("Testing interface: {}", interface);
 
     let pdu_storage = Box::leak(Box::new(PduStorage::<
         IFACE_DISCOVERY_MAX_FRAMES,
@@ -153,12 +133,7 @@ fn test_interface(interface: &str) -> Result<(), anyhow::Error> {
                 // Default 1000ms
                 mailbox_response: Duration::from_millis(1000),
             },
-            MainDeviceConfig {
-                // Default 10000
-                dc_static_sync_iterations: 10000,
-                // Default None
-                retry_behaviour: ethercrab::RetryBehaviour::Count(3),
-            },
+            MainDeviceConfig::default(),
         ));
 
         let result = maindevice

control-core/src/ethercat/mod.rs

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

control-core/src/ethernet/mod.rs

@@ -1,65 +0,0 @@
-use std::process::Command;
-
-use anyhow::Result;
-use interfaces::Interface;
-
-pub mod modbus_tcp_discovery;
-
-/// 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");
-        Ok(reports_as_ethernet && !actually_wifi)
-    }
-    #[cfg(not(target_os = "linux"))]
-    return Ok(true);
-}
-
-pub fn get_interfaces() -> Result<Vec<Interface>> {
-    let vec = Interface::get_all()
-        .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
-                && !iface.name.starts_with("anpi")   // Exclude Apple Network Privacy Interface
-                && !iface.name.starts_with("llw") // Exclude Apple low-latency WLAN
-        })
-        .collect::<Vec<_>>();
-    Ok(vec)
-}
-
-/// 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())
-}

control-core/src/ethernet/modbus_tcp_discovery.rs

@@ -1,78 +0,0 @@
-use crate::ethernet::get_interfaces;
-use crate::{futures::FutureIteratorExt, modbus::tcp::ModbusTcpDevice};
-use anyhow::{Result, bail};
-use interfaces::Interface;
-use std::cmp::min;
-use std::net::{IpAddr, Ipv4Addr, SocketAddr};
-
-pub struct ModbusTcpProbe {
-    pub addr: SocketAddr,
-    pub serial: u16,
-}
-
-pub async fn probe_modbus_tcp() -> Vec<ModbusTcpProbe> {
-    let interfaces = match get_interfaces() {
-        Ok(x) => x,
-        Err(_) => return vec![],
-    };
-
-    interfaces
-        .into_iter()
-        .map(probe_modbus_tcp_addresses)
-        .join_all()
-        .await
-        .into_iter()
-        .flatten()
-        .collect()
-}
-
-async fn probe_modbus_tcp_addresses(interface: Interface) -> Vec<ModbusTcpProbe> {
-    let out: Vec<ModbusTcpProbe> = interface
-        .addresses
-        .iter()
-        .filter_map(|addr| {
-            let a = addr.addr.map(|a| a.ip());
-            let m = addr.mask.map(|a| a.ip());
-
-            match (a, m) {
-                (Some(IpAddr::V4(addr)), Some(IpAddr::V4(mask))) => Some((addr, mask)),
-                _ => None,
-            }
-        })
-        .flat_map(|(addr, mask)| {
-            let a = u32::from(addr);
-            let m = u32::from(mask);
-            let network = a & m;
-
-            let prefix = min(24, m.count_ones()); // mask → prefix length
-            let size = 1u32 << (32 - prefix); // number of addresses
-
-            (0..size).map(move |i| SocketAddr::new(Ipv4Addr::from(network + i).into(), 502))
-        })
-        .map(|addr| smol::spawn(ping_modbus_device(addr)))
-        .join_all()
-        .await
-        .into_iter()
-        .filter_map(|x| x.ok())
-        .collect();
-
-    out
-}
-
-async fn ping_modbus_device(addr: SocketAddr) -> Result<ModbusTcpProbe> {
-    let mut device = ModbusTcpDevice::new(addr).await?;
-
-    let module_number1 = device.get_u32(0x2).await?;
-    let module_number2 = device.get_u32(0x4).await?;
-
-    if module_number1 != 0x2787_2144 || module_number2 != 0x0000_0000 {
-        bail!("Unknown modbus tcp device!");
-    }
-
-    let serial = device.get_u32(0x000A).await?;
-
-    Ok(ModbusTcpProbe {
-        addr,
-        serial: serial as u16,
-    })
-}

control-core/src/futures.rs

@@ -1,26 +0,0 @@
-use core::future::Future;
-
-// Extension trait for iterators of futures
-pub trait FutureIteratorExt<F>: Iterator<Item = F> + Sized
-where
-    F: Future,
-{
-    /// Await all futures and return their outputs
-    fn join_all(self) -> impl Future<Output = Vec<F::Output>>;
-}
-
-impl<I, F> FutureIteratorExt<F> for I
-where
-    I: Iterator<Item = F> + Sized,
-    F: Future,
-{
-    async fn join_all(self) -> Vec<F::Output> {
-        let mut out = Vec::new();
-
-        for fut in self {
-            out.push(fut.await);
-        }
-
-        out
-    }
-}

control-core/src/helpers/hasher_serializer.rs

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

@@ -1,108 +1,40 @@
-/// Folds bytes using XOR to produce a u128 value.
-///
-/// Takes a slice of bytes and XORs them together in chunks to produce a u128.
-/// If there are fewer than 16 bytes, the remaining bytes are padded with zeros.
-pub fn byte_folding_u128(bytes: &[u8]) -> u128 {
-    let mut result = 0u128;
-    for (i, &byte) in bytes.iter().enumerate() {
-        let shift = (i % 16) * 8;
-        result ^= (byte as u128) << shift;
-    }
-    result
+pub fn xor_u128_to_u64(value: u128) -> u64 {
+    (value as u64) ^ ((value >> 64) as u64)
 }
 
-/// Folds bytes using XOR to produce a u64 value.
-///
-/// Takes a slice of bytes and XORs them together in chunks to produce a u64.
-/// If there are fewer than 8 bytes, the remaining bytes are padded with zeros.
-pub fn byte_folding_u64(bytes: &[u8]) -> u64 {
-    let mut result = 0u64;
-    for (i, &byte) in bytes.iter().enumerate() {
-        let shift = (i % 8) * 8;
-        result ^= (byte as u64) << shift;
-    }
-    result
+pub fn xor_u128_to_u32(value: u128) -> u32 {
+    (value as u32) ^ ((value >> 32) as u32) ^ ((value >> 64) as u32) ^ ((value >> 96) as u32)
 }
 
-/// Folds bytes using XOR to produce a u32 value.
-///
-/// Takes a slice of bytes and XORs them together in chunks to produce a u32.
-/// If there are fewer than 4 bytes, the remaining bytes are padded with zeros.
-pub fn byte_folding_u32(bytes: &[u8]) -> u32 {
-    let mut result = 0u32;
-    for (i, &byte) in bytes.iter().enumerate() {
-        let shift = (i % 4) * 8;
-        result ^= (byte as u32) << shift;
-    }
-    result
+pub fn xor_u128_to_u16(value: u128) -> u16 {
+    value
+        .to_le_bytes()
+        .iter()
+        .fold(0, |buf, &byte| buf ^ byte as u16)
 }
 
-/// Folds bytes using XOR to produce a u16 value.
-///
-/// Takes a slice of bytes and XORs them together in chunks to produce a u16.
-/// If there are fewer than 2 bytes, the remaining bytes are padded with zeros.
-pub fn byte_folding_u16(bytes: &[u8]) -> u16 {
-    let mut result = 0u16;
-    for (i, &byte) in bytes.iter().enumerate() {
-        let shift = (i % 2) * 8;
-        result ^= (byte as u16) << shift;
-    }
-    result
+pub fn xor_u128_to_u8(value: u128) -> u8 {
+    value.to_le_bytes().iter().fold(0, |buf, &byte| buf ^ byte)
 }
 
-/// Folds bytes using XOR to produce a u8 value.
-///
-/// Takes a slice of bytes and XORs them all together to produce a u8.
-pub fn byte_folding_u8(bytes: &[u8]) -> u8 {
-    bytes.iter().fold(0u8, |acc, &byte| acc ^ byte)
-}
+// hash algorithm djb2
+pub fn hashing(input_to_hash: &str) -> u128 {
+    let mut hash: u128 = 5381;
+    let chars = input_to_hash.chars();
 
-/// Computes a djb2 hash of the input bytes.
-///
-/// The djb2 algorithm is a simple non-cryptographic hash function created by
-/// Daniel J. Bernstein. It uses the formula: `hash = hash * 33 + byte` for each byte.
-///
-/// This implementation uses the traditional 32-bit hash value and uses wrapping
-/// arithmetic to handle potential overflows gracefully.
-///
-/// # Arguments
-///
-/// * `bytes` - A slice of bytes to hash
-///
-/// # Returns
-///
-/// A 32-bit hash value as a `u32`
-///
-/// # Examples
-///
-/// ```
-/// use control_core::helpers::hashing::hash_djb2;
-///
-/// let hash = hash_djb2(b"hello world");
-/// assert_ne!(hash, 0);
-/// ```
-///
-/// # Algorithm Details
-///
-/// - Initial hash value: 5381 (djb2 magic number)
-/// - For each byte: `hash = hash * 33 + byte`
-/// - Uses wrapping arithmetic to prevent overflow panics
-pub fn hash_djb2(bytes: &[u8]) -> u32 {
-    let mut hash: u32 = 5381;
-
-    for byte in bytes {
-        hash = hash.wrapping_mul(33).wrapping_add(*byte as u32);
+    for ch in chars {
+        hash = ((hash << 5) + hash) + (ch as u128);
     }
     hash
 }
-
 #[test]
 fn test_hash() {
     let test_case = "/dev/ttyUSB1";
-    let hash_u32 = hash_djb2(test_case.as_bytes());
-    let hash_u16 = byte_folding_u16(&hash_u32.to_le_bytes());
-    tracing::info!("{}", test_case);
+    let hash = hashing(test_case);
+    let hash_2bytes = xor_u128_to_u16(hash);
+    log::info!("{}", test_case);
     assert_eq!(test_case, "/dev/ttyUSB1");
-    assert_eq!(hash_u32, 266121182);
-    assert_eq!(hash_u16, 40962);
+    assert!(hash == 8977446972540388683742);
+    assert!(hash_2bytes == 165);
+    println!("{:?}", hash);
 }

control-core/src/helpers/interpolation.rs

@@ -1,26 +1,4 @@
 /// Normalizes a value from a given range [min, max] to the range [0, 1].
-///
-/// This function maps a value from an arbitrary range to the standard
-/// normalized range [0, 1]. Values o/// Plot for Steepness = -1:ge are clamped
-/// to the boundaries (0.0 or 1.0).
-///
-/// # Arguments
-/// * `value` - The input value to normalize
-/// * `min` - The minimum value of the input range
-/// * `max` - The maximum value of the input range
-///
-/// # Returns
-/// * Normalized value in range [0.0, 1.0]
-///
-/// # Panics
-/// * Panics if `min >= max`
-///
-/// # Example
-/// ```rust
-/// use control_core::helpers::interpolation::normalize;
-/// let normalized = normalize(5.0, 0.0, 10.0); // Returns 0.5
-/// let clamped = normalize(-2.0, 0.0, 10.0);   // Returns 0.0 (clamped)
-/// ```
 pub fn normalize<T>(value: T, min: T, max: T) -> f64
 where
     T: Into<f64>,
@@ -41,425 +19,36 @@ where
 }
 
 /// Scales a normalized value from the range [0, 1] to a new range [new_min, new_max].
-///
-/// This function takes a normalized value (typically from 0 to 1) and maps it
-/// to a new target range. It's the inverse operation of normalization.
-///
-/// # Arguments
-/// * `normalized_value` - Input value in range [0.0, 1.0]
-/// * `new_min` - The minimum value of the target range
-/// * `new_max` - The maximum value of the target range
-///
-/// # Returns
-/// * Scaled value in the range [new_min, new_max]
-///
-/// # Example
-/// ```rust
-/// use control_core::helpers::interpolation::scale;
-/// let scaled = scale(0.5, 0.0, 100.0); // Returns 50.0
-/// let negative_range = scale(0.25, -10.0, 10.0); // Returns -5.0
-/// ```
 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;
+    let normalized_value: f64 = normalized_value.into();
     let new_min: f64 = new_min.into();
     let new_max: f64 = new_max.into();
 
-    let result = normalized_value.mul_add(new_max - new_min, new_min);
+    let result = normalized_value * (new_max - new_min) + new_min;
     T::from(result)
 }
 
-/// Performs hinge interpolation creating a piecewise linear function.
-///
-/// This function creates a piecewise linear curve that:
-/// - For values < x: linearly interpolates from (0, 0) to (x, y)
-/// - For values > x: linearly interpolates from (x, y) to (1, 1)
-/// - For value == x: returns y
-///
-/// The function assumes the input value is normalized to the range [0, 1],
-/// and creates a "hinge" or "elbow" shape at the point (x, y).
-///
-/// # Arguments
-/// * `value` - The input value (typically in range [0, 1])
-/// * `x` - The x-coordinate of the hinge point (typically in range [0, 1])
-/// * `y` - The y-coordinate of the hinge point (typically in range [0, 1])
-///
-/// # Returns
-/// * Interpolated value based on the hinge function
-///
-/// # Example
-/// ```rust
-/// use control_core::helpers::interpolation::interpolate_hinge;
-/// // Create a hinge at (0.3, 0.7)
-/// let result1 = interpolate_hinge(0.15, 0.3, 0.7); // Returns 0.35 (halfway to hinge)
-/// let result2 = interpolate_hinge(0.3, 0.3, 0.7);  // Returns 0.7 (at hinge)
-/// let result3 = interpolate_hinge(0.65, 0.3, 0.7); // Returns 0.85 (halfway from hinge to 1)
-/// ```
-/// ```ignore
-/// Hinge at (0.8, 0.2)
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠁ 1.0
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡜⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠇⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠎⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠁⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡜⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠇⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠎⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⠤⠤⠒⠒⠊⠁⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⡠⠤⠒⠒⠉⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⣀⣀⠤⠤⠔⠒⠉⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠉⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁ 0.0
-/// 0.0                        1.0
-/// ```
-pub fn interpolate_hinge<T>(value: T, x: T, y: T) -> f64
-where
-    T: Into<f64>,
-{
-    let value_f64: f64 = value.into();
-    let x_f64: f64 = x.into();
-    let y_f64: f64 = y.into();
-
-    // 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 {
-        normalize(value_f64, 0.0, x_f64) * y_f64
-    } else if value_f64 > x_f64 {
-        normalize(value_f64, x_f64, 1.0).mul_add(1.0 - y_f64, y_f64)
-    } else {
-        y_f64
-    }
-}
-
-/// Transforms a normalized value from the range [0, 1] to a [0, 1] range using a normalized exponential function.
-///
-/// This function creates smooth curves that are either convex (fast start, slow end)
-/// or concave (slow start, fast end) depending on the steepness parameter sign.
-/// The curve always passes through (0,0) and (1,1).
-///
-/// # Arguments
-/// * `normalized_value` - Input value in range [0.0, 1.0]
-/// * `steepness` - Controls the curve shape:
-///   - `steepness = 0.0`: Linear interpolation (y = x)
-///   - `steepness > 0.0`: Convex curve (slow start → fast end)
-///   - `steepness < 0.0`: Concave curve (fast start → slow end)
-///   - Typical range: -5.0 to 5.0 for most applications
-///
-/// # Returns
-/// * Transformed value in range [0.0, 1.0]
-///
-/// # Example
-/// ```rust
-/// use control_core::helpers::interpolation::interpolate_exponential;
-/// let convex = interpolate_exponential(0.5, 2.0);   // Slow start, fast end
-/// let concave = interpolate_exponential(0.5, -2.0); // Fast start, slow end
-/// let linear = interpolate_exponential(0.5, 0.0);   // Linear (returns 0.5)
-/// ```
-///
-/// # Plots
-/// Steepness = -3
-/// Steepness = -3
-/// ```ignore
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⡠⠤⠔⠒⠒⠉⠁ 1.0
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠤⠔⠊⠉⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠒⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠤⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⡔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⢀⠎⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⡔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⡰⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⢀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⡜⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⢰⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⢀⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⢤⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡎⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁ -0.0
-/// 0.0                        1.0
-/// ```
-///
-/// Steepness = -1
-/// ```ignore
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠤⠒⠁ 1.0
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠤⠊⠁⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠤⠒⠁⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡰⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠤⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⢀⠜⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⡔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⢀⠎⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⡔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⢀⠜⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡲⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁ -0.0
-/// 0.0                        1.0
-/// ```
-///
-/// Steepness = 0
-/// ```ignore
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁ 1.0
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⢀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⢀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⢀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⢂⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁ 0.0
-/// 0.0                        1.0
-/// ```
-///
-/// Steepness = 1
-/// ```ignore
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡰⠁ 1.0
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠃⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠊⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠜⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠒⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⢀⠤⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⢀⣀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⣀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⢂⣀⠔⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁ 0.0
-/// 0.0                        1.0
-/// ```
-///
-/// Steepness = 3
-/// ```ignore
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠁ 1.0
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡎⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠎⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡜⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠁⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠇⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡰⠁⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠁⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⣀⠤⠔⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⣀⣀⠤⠤⠒⠒⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠉⠉⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁ 0.0
-/// 0.0                        1.0
-/// ```
-pub fn interpolate_exponential(normalized_value: f64, steepness: f64) -> f64 {
-    if steepness.abs() < 1e-10 {
+/// Transforma normalized value from the range [0, 1] to a [0, 1] range using an normalized exponential function.
+pub fn interpolate_exponential(normalized_value: f64, a: f64) -> f64 {
+    if a.abs() < 1e-10 {
         // When a is very close to zero, the function becomes linear
         return normalized_value;
     }
-    let numerator = steepness.exp().powf(normalized_value) - 1.0;
-    let denominator = steepness.exp_m1();
+    let numerator = a.exp().powf(normalized_value) - 1.0;
+    let denominator = a.exp() - 1.0;
 
     clip(numerator / denominator)
 }
 
-/// A piecewise exponential interpolation function that creates smooth S-curves
-/// through the points (0,0), (0.5,0.5), and (1,1).
-///
-/// The function combines two normalized exponential segments:
-/// - First half (0 to 0.5): inverted exponential (concave, fast start → slow end)
-/// - Second half (0.5 to 1): standard exponential (convex, slow start → fast end)
-///
-/// This creates an S-like curve that's concave then convex, similar to
-/// a smoothed step function or sigmoid-like transition.
-///
-/// # Arguments
-/// * `x` - Input value, should be in range [0.0, 1.0]
-/// * `steepness` - Controls how steep the S-curve is
-///   - `steepness = 0.0`: Linear interpolation (y = x)
-///   - `steepness > 0.0`: More pronounced S-curve
-///   - Higher values create sharper transitions at the boundaries
-///   - Typical range: 0.5 to 5.0 for most applications
-///
-/// # Returns
-/// * Interpolated y value in range [0.0, 1.0]
-///
-/// # Example
-/// ```rust
-/// use control_core::helpers::interpolation::interpolate_inflected_exponential;
-/// let y = interpolate_inflected_exponential(0.25, 2.0); // Gentle S-curve
-/// let y = interpolate_inflected_exponential(0.75, 5.0); // Sharp S-curve
-/// ```
-///
-/// # Plots
-/// Steepness = 0.5
-/// ```ignore
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡰⠁ 1.0
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡰⠉⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠜⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠜⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠒⠁⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠒⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⢀⠤⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⡔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⢀⠔⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⢀⠤⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⡠⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡢⠒⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁ 0.0
-/// 0.0                        1.0
-/// ```
-///
-/// Steepness = 1
-/// ```ignore
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡰⠁ 1.0
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠒⠁⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠃⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠒⠁⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠔⠁⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠔⠒⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⡠⠒⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⢀⠤⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⡰⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⡰⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⡜⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡲⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁ 0.0
-/// 0.0                        1.0
-/// ```
-///
-/// Steepness = 2
-/// ```ignore
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠁ 1.0
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠃⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡸⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡜⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡰⠉⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠤⠊⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠤⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⡠⠤⠒⠊⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⢀⠤⠔⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⣀⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⢠⠒⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⡠⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⡠⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡞⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁ 0.0
-/// 0.0                        1.0
-/// ```
-///
-/// Steepness = 5
-/// ```ignore
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠁ 1.0
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡜⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠇⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠎⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡜⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡜⠀⠀⠀⠀
-/// ⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠔⠉⠀⠀⠀⠀⠀
-/// ⠄⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⡠⠤⠤⠤⠤⠤⠤⠤⠒⠒⠊⠉⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⠀⠀⠀⠀⢀⠔⠒⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡁⠀⠀⢠⠒⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠄⠀⢠⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠂⢀⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⣁⠎⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⢼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-/// ⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁⠈⠀⠁ 0.0
-/// 0.0                        1.0
-/// ```
-pub fn interpolate_inflected_exponential(x: f64, steepness: f64) -> f64 {
-    debug_assert!((0.0..=1.0).contains(&x), "x must be in range [0.0, 1.0]");
-    debug_assert!(steepness >= 0.0, "steepness must be non-negative");
-
-    if steepness == 0.0 {
-        // Linear case
-        return x;
-    }
-
-    if x <= 0.5 {
-        // First segment: inverted exponential (concave)
-        // Maps [0, 0.5] → [0, 0.5] with concave shape
-        let x_norm = 2.0 * x; // Scale to [0, 1]
-
-        // Use inverted exponential interpolation
-        let result = 1.0 - interpolate_exponential(1.0 - x_norm, steepness);
-        0.5 * result
-    } else {
-        // Second segment: standard exponential (convex)
-        // Maps [0.5, 1] → [0.5, 1] with convex shape
-        let x_norm = 2.0 * (x - 0.5); // Scale to [0, 1]
-
-        // Use standard exponential interpolation
-        let result = interpolate_exponential(x_norm, steepness);
-        0.5f64.mul_add(result, 0.5)
-    }
-}
-
 /// Inverts a value from the range [0, 1] to [1, 0].
-///
-/// This function flips a normalized value, where 0 becomes 1 and 1 becomes 0.
-/// Values outside [0, 1] are first clamped to this range before inversion.
-///
-/// # Arguments
-/// * `value` - Input value (will be clamped to [0.0, 1.0])
-///
-/// # Returns
-/// * Inverted value in range [0.0, 1.0]
-///
-/// # Example
-/// ```rust
-/// use control_core::helpers::interpolation::invert;
-/// let inverted = invert(0.3); // Returns 0.7
-/// let boundary = invert(0.0); // Returns 1.0
-/// let clamped = invert(1.5);  // Returns 0.0 (input clamped to 1.0 first)
-/// ```
 pub fn invert(value: f64) -> f64 {
     let value = clip(value);
     1.0 - value
 }
 
-/// Clips a value to the range [0, 1].
-///
-/// This function ensures that any input value is constrained to the
-/// normalized range [0, 1] by clamping values below 0 to 0 and
-/// values above 1 to 1.
-///
-/// # Arguments
-/// * `value` - Input value to clip
-///
-/// # Returns
-/// * Clipped value in range [0.0, 1.0]
-///
-/// # Example
-/// ```rust
-/// use control_core::helpers::interpolation::clip;
-/// let normal = clip(0.5);  // Returns 0.5
-/// let low = clip(-0.3);    // Returns 0.0
-/// let high = clip(1.7);    // Returns 1.0
-/// ```
 pub fn clip(value: f64) -> f64 {
     if value < 0.0 {
         return 0.0;
@@ -589,289 +178,6 @@ mod tests {
         assert_relative_eq!(clip(1.5), 1.0, epsilon = EPSILON);
     }
 
-    #[test]
-    fn test_interpolate_inflected_exponential() {
-        // Test boundary points (0,0), (0.5,0.5), and (1,1) for various steepness values
-        for steepness in [0.0, 0.5, 1.0, 2.0, 5.0].iter() {
-            assert_relative_eq!(
-                interpolate_inflected_exponential(0.0, *steepness),
-                0.0,
-                epsilon = EPSILON
-            );
-            assert_relative_eq!(
-                interpolate_inflected_exponential(0.5, *steepness),
-                0.5,
-                epsilon = EPSILON
-            );
-            assert_relative_eq!(
-                interpolate_inflected_exponential(1.0, *steepness),
-                1.0,
-                epsilon = EPSILON
-            );
-        }
-
-        // Test linear case (steepness = 0)
-        for x in [0.0, 0.25, 0.5, 0.75, 1.0].iter() {
-            assert_relative_eq!(
-                interpolate_inflected_exponential(*x, 0.0),
-                *x,
-                epsilon = EPSILON
-            );
-        }
-
-        // Test monotonicity - function should be strictly increasing
-        for steepness in [0.5, 1.0, 2.0, 5.0].iter() {
-            let mut prev = interpolate_inflected_exponential(0.0, *steepness);
-            for i in 1..=20 {
-                let x = i as f64 / 20.0;
-                let current = interpolate_inflected_exponential(x, *steepness);
-                assert!(
-                    current >= prev,
-                    "Failed monotonicity test at x={}, steepness={}, prev={}, current={}",
-                    x,
-                    steepness,
-                    prev,
-                    current
-                );
-                prev = current;
-            }
-        }
-
-        // Test S-curve property: first half should be concave, second half convex
-        let steepness = 2.0;
-
-        // First half: check concave property (derivative decreasing)
-        let x1 = 0.1;
-        let x2 = 0.2;
-        let x3 = 0.3;
-        let y1 = interpolate_inflected_exponential(x1, steepness);
-        let y2 = interpolate_inflected_exponential(x2, steepness);
-        let y3 = interpolate_inflected_exponential(x3, steepness);
-
-        let slope1 = (y2 - y1) / (x2 - x1);
-        let slope2 = (y3 - y2) / (x3 - x2);
-        assert!(
-            slope1 > slope2,
-            "First half should be concave (decreasing slope)"
-        );
-
-        // Second half: check convex property (derivative increasing)
-        let x1 = 0.7;
-        let x2 = 0.8;
-        let x3 = 0.9;
-        let y1 = interpolate_inflected_exponential(x1, steepness);
-        let y2 = interpolate_inflected_exponential(x2, steepness);
-        let y3 = interpolate_inflected_exponential(x3, steepness);
-
-        let slope1 = (y2 - y1) / (x2 - x1);
-        let slope2 = (y3 - y2) / (x3 - x2);
-        assert!(
-            slope1 < slope2,
-            "Second half should be convex (increasing slope)"
-        );
-
-        // Test that output is always in [0, 1] range
-        for steepness in [0.0, 1.0, 5.0, 10.0].iter() {
-            for i in 0..=100 {
-                let x = i as f64 / 100.0;
-                let y = interpolate_inflected_exponential(x, *steepness);
-                assert!(
-                    y >= 0.0 && y <= 1.0,
-                    "Output {} out of range [0,1] for x={}, steepness={}",
-                    y,
-                    x,
-                    steepness
-                );
-            }
-        }
-    }
-
-    #[test]
-    fn test_interpolate_hinge() {
-        // Test basic functionality with hinge at (0.3, 0.7)
-        let x_hinge = 0.3;
-        let y_hinge = 0.7;
-
-        // Test exact hinge point
-        assert_relative_eq!(
-            interpolate_hinge(x_hinge, x_hinge, y_hinge),
-            y_hinge,
-            epsilon = EPSILON
-        );
-
-        // Test left segment (value < x): should interpolate from (0,0) to (x,y)
-        assert_relative_eq!(
-            interpolate_hinge(0.0, x_hinge, y_hinge),
-            0.0,
-            epsilon = EPSILON
-        );
-        assert_relative_eq!(
-            interpolate_hinge(0.15, x_hinge, y_hinge),
-            0.35, // 0.15/0.3 * 0.7 = 0.5 * 0.7 = 0.35
-            epsilon = EPSILON
-        );
-
-        // Test right segment (value > x): should interpolate from (x,y) to (1,1)
-        assert_relative_eq!(
-            interpolate_hinge(1.0, x_hinge, y_hinge),
-            1.0,
-            epsilon = EPSILON
-        );
-        assert_relative_eq!(
-            interpolate_hinge(0.65, x_hinge, y_hinge),
-            0.85, // y + ((0.65-0.3)/(1.0-0.3)) * (1.0-0.7) = 0.7 + 0.5 * 0.3 = 0.85
-            epsilon = EPSILON
-        );
-
-        // Test with different hinge points
-        // Hinge at (0.5, 0.5) - should be linear
-        assert_relative_eq!(interpolate_hinge(0.25, 0.5, 0.5), 0.25, epsilon = EPSILON);
-        assert_relative_eq!(interpolate_hinge(0.75, 0.5, 0.5), 0.75, epsilon = EPSILON);
-
-        // Hinge at (0.2, 0.9) - steep left, shallow right
-        assert_relative_eq!(
-            interpolate_hinge(0.1, 0.2, 0.9),
-            0.45, // 0.1/0.2 * 0.9 = 0.5 * 0.9 = 0.45
-            epsilon = EPSILON
-        );
-        assert_relative_eq!(
-            interpolate_hinge(0.6, 0.2, 0.9),
-            0.95, // 0.9 + ((0.6-0.2)/(1.0-0.2)) * (1.0-0.9) = 0.9 + 0.5 * 0.1 = 0.95
-            epsilon = EPSILON
-        );
-
-        // Test edge cases
-        // Hinge at (0, 0)
-        assert_relative_eq!(interpolate_hinge(0.0, 0.0, 0.0), 0.0, epsilon = EPSILON);
-        assert_relative_eq!(
-            interpolate_hinge(0.5, 0.0, 0.0),
-            0.5, // Should interpolate from (0,0) to (1,1)
-            epsilon = EPSILON
-        );
-
-        // Hinge at (1, 1)
-        assert_relative_eq!(
-            interpolate_hinge(0.5, 1.0, 1.0),
-            0.5, // Should interpolate from (0,0) to (1,1)
-            epsilon = EPSILON
-        );
-        assert_relative_eq!(interpolate_hinge(1.0, 1.0, 1.0), 1.0, epsilon = EPSILON);
-
-        // Test with different numeric types
-        assert_relative_eq!(
-            interpolate_hinge(0.5f32, 0.3f32, 0.7f32),
-            0.7857142857142857, // 0.7 + ((0.5-0.3)/(1.0-0.3)) * (1.0-0.7) = 0.7 + (2/7) * 0.3
-            epsilon = 1e-7      // Relaxed epsilon for f32 precision
-        );
-        assert_relative_eq!(
-            interpolate_hinge(1u8, 0u8, 1u8), // 1.0, 0.0, 1.0 - should return 1.0
-            1.0,
-            epsilon = EPSILON
-        );
-
-        // Test monotonicity - function should be non-decreasing
-        let test_x = 0.4;
-        let test_y = 0.6;
-        let mut prev = interpolate_hinge(0.0, test_x, test_y);
-
-        for i in 1..=20 {
-            let value = i as f64 / 20.0;
-            let current = interpolate_hinge(value, test_x, test_y);
-            assert!(
-                current >= prev,
-                "Failed monotonicity test at value={}, x={}, y={}, prev={}, current={}",
-                value,
-                test_x,
-                test_y,
-                prev,
-                current
-            );
-            prev = current;
-        }
-    }
-
-    #[test]
-    fn test_interpolate_exponential_graph() {
-        use textplots::{Chart, Plot, Shape};
-
-        println!("\n=== Exponential Interpolation Examples ===");
-
-        // Test different steepness values (both positive and negative)
-        let steepness_values = [-3.0, -1.0, 0.0, 1.0, 3.0];
-
-        for steepness in steepness_values.iter() {
-            println!("\nSteepness = {}", steepness);
-
-            // Generate data points
-            let points: Vec<(f32, f32)> = (0..=50)
-                .map(|i| {
-                    let x = i as f64 / 50.0;
-                    let y = interpolate_exponential(x, *steepness);
-                    (x as f32, y as f32)
-                })
-                .collect();
-
-            // Create and display chart
-            Chart::new(60, 60, 0.0, 1.0)
-                .lineplot(&Shape::Lines(&points))
-                .display();
-        }
-    }
-
-    #[test]
-    fn test_interpolate_hinge_graph() {
-        use textplots::{Chart, Plot, Shape};
-
-        println!("\n=== hinge Interpolation Examples ===");
-
-        // Test different hinge points
-        let hinges = [(0.3, 0.7), (0.5, 0.5), (0.2, 0.9), (0.8, 0.2)];
-
-        for &(x_hinge, y_hinge) in hinges.iter() {
-            println!("\nHinge at ({}, {})", x_hinge, y_hinge);
-
-            // Generate data points
-            let points: Vec<(f32, f32)> = (0..=50)
-                .map(|i| {
-                    let x = i as f64 / 50.0;
-                    let y = interpolate_hinge(x, x_hinge, y_hinge);
-                    (x as f32, y as f32)
-                })
-                .collect();
-
-            // Create and display chart
-            Chart::new(60, 60, 0.0, 1.0)
-                .lineplot(&Shape::Lines(&points))
-                .display();
-        }
-    }
-
-    #[test]
-    fn test_interpolate_inflected_exponential_graph() {
-        use textplots::{Chart, Plot, Shape};
-
-        // Test different steepness values
-        let steepness_values = [0.5, 1.0, 2.0, 5.0];
-
-        for steepness in steepness_values.iter() {
-            println!("\nSteepness = {}", steepness);
-
-            // Generate data points
-            let points: Vec<(f32, f32)> = (0..=50)
-                .map(|i| {
-                    let x = i as f64 / 50.0;
-                    let y = interpolate_inflected_exponential(x, *steepness);
-                    (x as f32, y as f32)
-                })
-                .collect();
-
-            // Create and display chart
-            Chart::new(60, 60, 0.0, 1.0)
-                .lineplot(&Shape::Lines(&points))
-                .display();
-        }
-    }
-
     #[test]
     #[should_panic]
     fn test_normalize_invalid_range() {

control-core/src/helpers/loop_trottle.rs

@@ -0,0 +1,188 @@
+use smol::Timer;
+use std::time::{Duration, Instant};
+
+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,
+        }
+    }
+
+    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,5 @@
+pub mod loop_trottle;
 pub mod compare_lists;
-pub mod hasher_serializer;
 pub mod hashing;
 pub mod interpolation;
-pub mod moving_time_window;
 pub mod retry;

control-core/src/helpers/moving_time_window.rs

@@ -1,243 +0,0 @@
-use std::{
-    collections::VecDeque,
-    iter::Sum,
-    time::{Duration, Instant},
-};
-
-/// A helper trait to handle division for averaging
-pub trait DivideByCount {
-    fn divide_by_count(self, count: usize) -> Self;
-}
-
-impl DivideByCount for f64 {
-    fn divide_by_count(self, count: usize) -> Self {
-        self / (count as Self)
-    }
-}
-
-impl DivideByCount for f32 {
-    fn divide_by_count(self, count: usize) -> Self {
-        self / (count as Self)
-    }
-}
-
-impl DivideByCount for i32 {
-    fn divide_by_count(self, count: usize) -> Self {
-        self / (count as Self)
-    }
-}
-
-impl DivideByCount for i64 {
-    fn divide_by_count(self, count: usize) -> Self {
-        self / (count as Self)
-    }
-}
-
-impl DivideByCount for u32 {
-    fn divide_by_count(self, count: usize) -> Self {
-        self / (count as Self)
-    }
-}
-
-impl DivideByCount for u64 {
-    fn divide_by_count(self, count: usize) -> Self {
-        self / (count as Self)
-    }
-}
-
-// Type aliases for common use cases
-pub type F64Window = MovingTimeWindow<f64>;
-pub type F32Window = MovingTimeWindow<f32>;
-pub type I32Window = MovingTimeWindow<i32>;
-pub type I64Window = MovingTimeWindow<i64>;
-
-#[derive(Debug)]
-pub struct MovingTimeWindow<T>
-where
-    T: Copy + PartialOrd + Sum + DivideByCount + std::fmt::Debug + Default,
-{
-    max_samples: usize,
-    samples: VecDeque<(T, Instant)>,
-    last_sample: Option<(T, Instant)>,
-    sample_time: Duration,
-    cached_average: Option<T>,
-    cached_max: Option<T>,
-    cached_min: Option<T>,
-}
-
-/// A time-based moving window that maintains samples within a specified duration and count limit.
-///
-/// This structure efficiently tracks values over time, automatically removing samples that fall
-/// outside the configured time window or exceed the maximum sample count. It provides cached
-/// average calculation to avoid redundant computations.
-impl<T> MovingTimeWindow<T>
-where
-    T: Copy + PartialOrd + Sum + DivideByCount + std::fmt::Debug + Default,
-{
-    /// Creates a new moving time window with the specified duration and maximum sample count.
-    ///
-    /// # Arguments
-    ///
-    /// * `duration` - The time window duration; samples older than this will be automatically removed
-    /// * `samples` - Maximum number of samples to retain, regardless of their age
-    ///
-    /// # Returns
-    ///
-    /// A new `MovingTimeWindow` instance with empty sample collection and initialized cache
-    pub fn new(duration: Duration, max_samples: usize) -> Self {
-        Self {
-            max_samples,
-            samples: VecDeque::with_capacity(max_samples),
-            last_sample: None,
-            sample_time: duration / (max_samples as u32),
-            cached_average: None,
-            cached_max: None,
-            cached_min: None,
-        }
-    }
-
-    /// Updates the window with a new sample value at the given timestamp.
-    ///
-    /// This method adds the new sample to the window and automatically removes samples that:
-    /// - Are older than the configured duration from the current timestamp
-    /// - Exceed the maximum sample count limit
-    ///
-    /// The cached average is invalidated after this operation.
-    ///
-    /// # Arguments
-    ///
-    /// * `value` - The numeric value to add to the window
-    /// * `timestamp` - The time at which this sample was taken
-    pub fn update(&mut self, value: T, timestamp: Instant) {
-        // Chekc if we should add a new sample based on the sample time and the last sample
-        if let Some((_, last_timestamp)) = self.last_sample {
-            if timestamp.duration_since(last_timestamp) < self.sample_time {
-                // If the new sample is too close to the last one, we skip adding it
-                return;
-            }
-        }
-
-        // If we have reached the maximum sample count, remove the oldest sample
-        if self.samples.len() >= self.max_samples {
-            self.samples.pop_back();
-        }
-
-        // Add the new sample
-        self.samples.push_front((value, timestamp));
-        self.last_sample = Some((value, timestamp));
-
-        // Invalidate all cached values since we added a new sample
-        self.cached_average = None;
-        self.cached_max = None;
-        self.cached_min = None;
-    }
-
-    /// Calculates and returns the average of all samples currently in the window.
-    ///
-    /// This method uses caching to avoid redundant calculations. The average is only
-    /// recalculated when the window contents have changed since the last call.
-    ///
-    /// # Returns
-    ///
-    /// The arithmetic mean of all current samples, or T::default() if the window is empty
-    pub fn average(&mut self) -> T {
-        // Return cached value if available
-        if let Some(cached) = self.cached_average {
-            return cached;
-        }
-
-        let sum: T = self.samples.iter().map(|(v, _)| *v).sum();
-        let count = self.samples.len();
-
-        let avg = if count > 0 {
-            sum.divide_by_count(count)
-        } else {
-            T::default()
-        };
-
-        // Cache the calculated value
-        self.cached_average = Some(avg);
-        avg
-    }
-
-    /// Calculates and returns the maximum value of all samples currently in the window.
-    ///
-    /// This method uses caching to avoid redundant calculations. The maximum is only
-    /// recalculated when the window contents have changed since the last call.
-    ///
-    /// # Returns
-    ///
-    /// The maximum value of all current samples, or T::default() if the window is empty
-    pub fn max(&mut self) -> T {
-        // Return cached value if available
-        if let Some(cached) = self.cached_max {
-            return cached;
-        }
-
-        let result = self
-            .samples
-            .iter()
-            .map(|(v, _)| *v)
-            .fold(None, |acc, val| {
-                acc.map_or(Some(val), |current_max| {
-                    if val > current_max {
-                        Some(val)
-                    } else {
-                        Some(current_max)
-                    }
-                })
-            })
-            .unwrap_or_default();
-
-        // Cache the calculated value
-        self.cached_max = Some(result);
-        result
-    }
-
-    /// Calculates and returns the minimum value of all samples currently in the window.
-    ///
-    /// This method uses caching to avoid redundant calculations. The minimum is only
-    /// recalculated when the window contents have changed since the last call.
-    ///
-    /// # Returns
-    ///
-    /// The minimum value of all current samples, or T::default() if the window is empty
-    pub fn min(&mut self) -> T {
-        // Return cached value if available
-        if let Some(cached) = self.cached_min {
-            return cached;
-        }
-
-        let result = self
-            .samples
-            .iter()
-            .map(|(v, _)| *v)
-            .fold(None, |acc, val| {
-                acc.map_or(Some(val), |current_min| {
-                    if val < current_min {
-                        Some(val)
-                    } else {
-                        Some(current_min)
-                    }
-                })
-            })
-            .unwrap_or_default();
-
-        // Cache the calculated value
-        self.cached_min = Some(result);
-        result
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_generic() {
-        // Test that the struct compiles with basic numeric types
-        let _: MovingTimeWindow<f64> = MovingTimeWindow::new(Duration::from_secs(1), 1);
-        let _: MovingTimeWindow<f32> = MovingTimeWindow::new(Duration::from_secs(1), 1);
-        let _: MovingTimeWindow<i32> = MovingTimeWindow::new(Duration::from_secs(1), 1);
-    }
-}

control-core/src/helpers/retry.rs

@@ -1,38 +1,4 @@
-use std::future::Future;
-
-/// Retries a fallible operation up to `n` times synchronously.
-///
-/// This function executes the provided closure `f` repeatedly until either:
-/// - The operation succeeds (returns `Ok(T)`)
-/// - All retry attempts are exhausted
-///
-/// # Arguments
-///
-/// * `n` - The maximum number of retry attempts (0 means only one attempt)
-/// * `f` - A mutable closure that returns a `Result<T, E>`
-///
-/// # Returns
-///
-/// Returns `Ok(T)` if any attempt succeeds, or `Err(E)` containing the error
-/// from the last failed attempt if all retries are exhausted.
-///
-/// # Examples
-///
-/// ```rust
-/// use control_core::helpers::retry::retry_n_times;
-///
-/// let mut attempt = 0;
-/// let result = retry_n_times(3, || {
-///     attempt += 1;
-///     if attempt < 3 {
-///         Err("failed")
-///     } else {
-///         Ok("success")
-///     }
-/// });
-/// assert_eq!(result, Ok("success"));
-/// ```
-pub fn retry_n_times<T, E, F>(n: usize, mut f: F) -> Result<T, E>
+pub fn retry<T, E, F>(n: usize, mut f: F) -> Result<T, E>
 where
     F: FnMut() -> Result<T, E>,
 {
@@ -45,383 +11,3 @@ where
     }
     Err(last_err.unwrap())
 }
-
-/// Retries a fallible async operation up to `n` times.
-///
-/// This function executes the provided async closure `f` repeatedly until either:
-/// - The operation succeeds (returns `Ok(T)`)
-/// - All retry attempts are exhausted
-///
-/// Each attempt is awaited before proceeding to the next retry or returning.
-///
-/// # Arguments
-///
-/// * `n` - The maximum number of retry attempts (0 means only one attempt)
-/// * `f` - A mutable closure that returns a `Future<Output = Result<T, E>>`
-///
-/// # Returns
-///
-/// Returns `Ok(T)` if any attempt succeeds, or `Err(E)` containing the error
-/// from the last failed attempt if all retries are exhausted.
-///
-/// # Examples
-///
-/// ```rust
-/// use control_core::helpers::retry::retry_n_times_async;
-/// use std::sync::Arc;
-/// use std::sync::atomic::{AtomicUsize, Ordering};
-///
-/// async fn example() {
-///     let attempt = Arc::new(AtomicUsize::new(0));
-///     let attempt_clone = attempt.clone();
-///     let result = retry_n_times_async(3, move || {
-///         let attempt = attempt_clone.clone();
-///         async move {
-///             let current = attempt.fetch_add(1, Ordering::SeqCst) + 1;
-///             if current < 3 {
-///                 Err("failed")
-///             } else {
-///                 Ok("success")
-///             }
-///         }
-///     }).await;
-///     assert_eq!(result, Ok("success"));
-/// }
-/// ```
-pub async fn retry_n_times_async<T, E, F, Fut>(n: usize, mut f: F) -> Result<T, E>
-where
-    F: FnMut() -> Fut,
-    Fut: Future<Output = Result<T, E>>,
-{
-    let mut last_err: Option<E> = None;
-    for _ in 0..=n {
-        match f().await {
-            Ok(value) => return Ok(value),
-            Err(err) => last_err = Some(err),
-        }
-    }
-    Err(last_err.unwrap())
-}
-
-/// Retries a fallible operation until a closure decides to stop retrying.
-///
-/// This function executes the provided closure `f` repeatedly until either:
-/// - The operation succeeds (returns `Ok(T)`)
-/// - The retry condition returns false
-///
-/// # Arguments
-///
-/// * `f` - A mutable closure that returns a `Result<T, E>`
-/// * `should_retry` - A closure that takes `&E` and returns `bool` to decide if retry should continue
-///
-/// # Returns
-///
-/// Returns `Ok(T)` if any attempt succeeds, or `Err(E)` containing the error
-/// from the last failed attempt when retries stop.
-///
-/// # Examples
-///
-/// ```rust
-/// use control_core::helpers::retry::retry_conditionally;
-///
-/// let mut attempt = 0;
-/// let result = retry_conditionally(
-///     || {
-///         attempt += 1;
-///         if attempt < 3 {
-///             Err(format!("failed attempt {}", attempt))
-///         } else {
-///             Ok("success")
-///         }
-///     },
-///     |err| {
-///         // Retry up to 3 times
-///         !err.contains("attempt 3")
-///     }
-/// );
-/// assert_eq!(result, Ok("success"));
-/// ```
-pub fn retry_conditionally<T, E, F, R>(mut f: F, mut should_retry: R) -> Result<T, E>
-where
-    F: FnMut() -> Result<T, E>,
-    R: FnMut(&E) -> bool,
-{
-    loop {
-        match f() {
-            Ok(value) => return Ok(value),
-            Err(err) => {
-                if !should_retry(&err) {
-                    return Err(err);
-                }
-            }
-        }
-    }
-}
-
-/// Retries a fallible async operation until a closure decides to stop retrying.
-///
-/// This function executes the provided async closure `f` repeatedly until either:
-/// - The operation succeeds (returns `Ok(T)`)
-/// - The retry condition returns false
-///
-/// # Arguments
-///
-/// * `f` - A mutable closure that returns a `Future<Output = Result<T, E>>`
-/// * `should_retry` - A closure that takes `&E` and returns `bool` to decide if retry should continue
-///
-/// # Returns
-///
-/// Returns `Ok(T)` if any attempt succeeds, or `Err(E)` containing the error
-/// from the last failed attempt when retries stop.
-///
-/// # Examples
-///
-/// ```rust
-/// use control_core::helpers::retry::retry_conditionally_async;
-/// use std::sync::Arc;
-/// use std::sync::atomic::{AtomicUsize, Ordering};
-///
-/// async fn example() {
-///     let attempt = Arc::new(AtomicUsize::new(0));
-///     let attempt_clone = attempt.clone();
-///     let result = retry_conditionally_async(
-///         move || {
-///             let attempt = attempt_clone.clone();
-///             async move {
-///                 let current = attempt.fetch_add(1, Ordering::SeqCst) + 1;
-///                 if current < 3 {
-///                     Err(format!("failed attempt {}", current))
-///                 } else {
-///                     Ok("success")
-///                 }
-///             }
-///         },
-///         |err| {
-///             // Retry up to 3 times
-///             !err.contains("attempt 3")
-///         }
-///     ).await;
-///     assert_eq!(result, Ok("success"));
-/// }
-/// ```
-pub async fn retry_conditionally_async<T, E, F, Fut, R>(
-    mut f: F,
-    mut should_retry: R,
-) -> Result<T, E>
-where
-    F: FnMut() -> Fut,
-    Fut: Future<Output = Result<T, E>>,
-    R: FnMut(&E) -> bool,
-{
-    loop {
-        match f().await {
-            Ok(value) => return Ok(value),
-            Err(err) => {
-                if !should_retry(&err) {
-                    return Err(err);
-                }
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::cell::RefCell;
-    use std::rc::Rc;
-
-    // Simple blocking executor for async functions in tests
-    fn block_on<F: std::future::Future>(future: F) -> F::Output {
-        use std::sync::Arc;
-        use std::task::{Context, Poll, Waker};
-        use std::thread;
-
-        struct DummyWaker;
-        impl std::task::Wake for DummyWaker {
-            fn wake(self: Arc<Self>) {}
-        }
-
-        let waker = Waker::from(Arc::new(DummyWaker));
-        let mut context = Context::from_waker(&waker);
-        let mut future = Box::pin(future);
-
-        loop {
-            match future.as_mut().poll(&mut context) {
-                Poll::Ready(result) => return result,
-                Poll::Pending => {
-                    thread::yield_now();
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn test_retry_success_first_attempt() {
-        let result = retry_n_times(3, || Ok::<i32, &str>(42));
-        assert_eq!(result, Ok(42));
-    }
-
-    #[test]
-    fn test_retry_success_after_failures() {
-        let mut attempt = 0;
-        let result = retry_n_times(3, || {
-            attempt += 1;
-            if attempt < 3 { Err("failed") } else { Ok(42) }
-        });
-        assert_eq!(result, Ok(42));
-        assert_eq!(attempt, 3);
-    }
-
-    #[test]
-    fn test_retry_all_attempts_fail() {
-        let mut attempt = 0;
-        let result: Result<i32, &str> = retry_n_times(2, || {
-            attempt += 1;
-            Err("always fails")
-        });
-        assert_eq!(result, Err("always fails"));
-        assert_eq!(attempt, 3); // 0..=2 means 3 attempts
-    }
-
-    #[test]
-    fn test_retry_zero_retries() {
-        let mut attempt = 0;
-        let result: Result<i32, &str> = retry_n_times(0, || {
-            attempt += 1;
-            Err("failed")
-        });
-        assert_eq!(result, Err("failed"));
-        assert_eq!(attempt, 1); // Only one attempt
-    }
-
-    #[test]
-    fn test_retry_async_success_first_attempt() {
-        let result = block_on(retry_n_times_async(3, || async { Ok::<i32, &str>(42) }));
-        assert_eq!(result, Ok(42));
-    }
-
-    #[test]
-    fn test_retry_async_success_after_failures() {
-        let attempt = Rc::new(RefCell::new(0));
-        let attempt_clone = attempt.clone();
-        let result = block_on(retry_n_times_async(3, move || {
-            let attempt = attempt_clone.clone();
-            async move {
-                let mut a = attempt.borrow_mut();
-                *a += 1;
-                if *a < 3 { Err("failed") } else { Ok(42) }
-            }
-        }));
-        assert_eq!(result, Ok(42));
-        assert_eq!(*attempt.borrow(), 3);
-    }
-
-    #[test]
-    fn test_retry_async_all_attempts_fail() {
-        let attempt = Rc::new(RefCell::new(0));
-        let attempt_clone = attempt.clone();
-        let result: Result<i32, &str> = block_on(retry_n_times_async(2, move || {
-            let attempt = attempt_clone.clone();
-            async move {
-                let mut a = attempt.borrow_mut();
-                *a += 1;
-                Err("always fails")
-            }
-        }));
-        assert_eq!(result, Err("always fails"));
-        assert_eq!(*attempt.borrow(), 3); // 0..=2 means 3 attempts
-    }
-
-    #[test]
-    fn test_retry_and_success_with_condition() {
-        let mut attempt = 0;
-        let result: Result<i32, String> = retry_conditionally(
-            || {
-                attempt += 1;
-                if attempt < 3 {
-                    Err(format!("failed attempt {}", attempt))
-                } else {
-                    Ok(42)
-                }
-            },
-            |err| {
-                // Retry as long as it's not the 3rd attempt
-                !err.contains("attempt 3")
-            },
-        );
-
-        assert_eq!(result, Ok(42));
-        assert_eq!(attempt, 3);
-    }
-
-    #[test]
-    fn test_retry_and_stop_early() {
-        let mut attempt = 0;
-        let result: Result<i32, String> = retry_conditionally(
-            || {
-                attempt += 1;
-                Err(format!("failed attempt {}", attempt))
-            },
-            |_err| {
-                // Stop after first failure
-                false
-            },
-        );
-
-        assert!(result.is_err());
-        assert_eq!(attempt, 1);
-        assert_eq!(result.unwrap_err(), "failed attempt 1");
-    }
-
-    #[test]
-    fn test_retry_async_success_with_condition() {
-        let attempt = Rc::new(RefCell::new(0));
-        let attempt_clone = attempt.clone();
-        let result: Result<i32, String> = block_on(retry_conditionally_async(
-            move || {
-                let attempt = attempt_clone.clone();
-                async move {
-                    let mut a = attempt.borrow_mut();
-                    *a += 1;
-                    if *a < 3 {
-                        Err(format!("failed attempt {}", *a))
-                    } else {
-                        Ok(42)
-                    }
-                }
-            },
-            |err| {
-                // Retry as long as it's not the 3rd attempt
-                !err.contains("attempt 3")
-            },
-        ));
-
-        assert_eq!(result, Ok(42));
-        assert_eq!(*attempt.borrow(), 3);
-    }
-
-    #[test]
-    fn test_retry_async_stop_early() {
-        let attempt = Rc::new(RefCell::new(0));
-        let attempt_clone = attempt.clone();
-        let result: Result<i32, String> = block_on(retry_conditionally_async(
-            move || {
-                let attempt = attempt_clone.clone();
-                async move {
-                    let mut a = attempt.borrow_mut();
-                    *a += 1;
-                    Err(format!("failed attempt {}", *a))
-                }
-            },
-            |_err| {
-                // Stop after first failure
-                false
-            },
-        ));
-
-        assert!(result.is_err());
-        assert_eq!(*attempt.borrow(), 1);
-        assert_eq!(result.unwrap_err(), "failed attempt 1");
-    }
-}

control-core/src/irq_handling.rs

@@ -1,113 +0,0 @@
-#[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,16 +1,14 @@
+pub mod actors;
 pub mod controllers;
 pub mod converters;
-pub mod downcast;
 pub mod ethercat;
-pub mod ethernet;
-pub mod futures;
 pub mod helpers;
-pub mod irq_handling;
+pub mod machines;
 pub mod modbus;
-pub mod realtime;
+pub mod rest;
 pub mod serial;
 pub mod socketio;
-pub mod transmission;
+pub mod uom_extensions;
 
-#[cfg(feature = "video-streaming")]
-pub mod video_streaming;
+#[macro_use]
+extern crate uom;

control-core/src/machines/api.rs

@@ -0,0 +1,7 @@
+use crate::socketio::namespace::NamespaceInterface;
+use serde_json::Value;
+
+pub trait MachineApi {
+    fn api_mutate(&mut self, value: Value) -> Result<(), anyhow::Error>;
+    fn api_event_namespace(&mut self) -> &mut dyn NamespaceInterface;
+}

control-core/src/machines/identification.rs

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

control-core/src/machines/manager.rs

@@ -0,0 +1,211 @@
+use smol::lock::{Mutex, RwLock};
+
+use crate::{
+    machines::{
+        identification::MachineIdentificationUnique,
+        new::{MachineNewHardware, MachineNewHardwareEthercat, MachineNewParams},
+    },
+    serial::SerialDevice,
+};
+use std::{collections::HashMap, sync::Arc};
+
+use super::{
+    Machine,
+    identification::{DeviceIdentification, DeviceIdentificationIdentified},
+    new::MachineNewHardwareSerial,
+    registry::MachineRegistry,
+};
+#[derive(Debug)]
+pub struct MachineManager {
+    pub ethercat_machines:
+        HashMap<MachineIdentificationUnique, Result<Box<Mutex<dyn Machine>>, anyhow::Error>>,
+    pub serial_machines:
+        HashMap<MachineIdentificationUnique, Result<Box<Mutex<dyn Machine>>, anyhow::Error>>,
+}
+
+impl MachineManager {
+    pub fn new() -> Self {
+        Self {
+            ethercat_machines: HashMap::new(),
+            serial_machines: HashMap::new(),
+        }
+    }
+
+    pub fn set_ethercat_devices<const MAX_SUBDEVICES: usize, const MAX_PDI: usize>(
+        &mut self,
+        device_identifications: &Vec<DeviceIdentification>,
+        machine_registry: &MachineRegistry,
+        hardware: &MachineNewHardwareEthercat,
+    ) {
+        // empty ethercat machines
+        self.ethercat_machines.clear();
+
+        // group devices by machine device identification
+        let device_grouping_result = group_devices_by_identification(device_identifications);
+
+        log::info!(
+            "[{}::set_ethercat_devices] Device Groups {:?}",
+            module_path!(),
+            device_grouping_result.device_groups.len()
+        );
+
+        let machine_new_hardware = MachineNewHardware::Ethercat(hardware);
+
+        // iterate over all identified device groups but ignore unaffected machines
+        for device_group in device_grouping_result.device_groups.iter() {
+            // get the machine identification
+            let machine_identification = match device_group.first() {
+                Some(device_identification) => &device_identification.device_machine_identification,
+                None => continue, // Skip this group if empty
+            };
+
+            // create the machine
+            let new_machine = machine_registry.new_machine(&MachineNewParams {
+                device_group,
+                hardware: &machine_new_hardware,
+            });
+
+            // insert the machine into the ethercat machines map
+            self.ethercat_machines.insert(
+                machine_identification.machine_identification_unique.clone(),
+                new_machine,
+            );
+        }
+    }
+
+    pub fn get(
+        &self,
+        machine_identification: &MachineIdentificationUnique,
+    ) -> Option<&Result<Box<Mutex<dyn Machine>>, anyhow::Error>> {
+        self.ethercat_machines
+            .get(machine_identification)
+            .or_else(|| self.serial_machines.get(machine_identification))
+    }
+
+    pub fn add_serial_device(
+        &mut self,
+        device_identification: &DeviceIdentification,
+        device: Arc<RwLock<dyn SerialDevice>>,
+        machine_registry: &MachineRegistry,
+    ) {
+        let hardware = MachineNewHardwareSerial { device };
+
+        let device_identification_identified: DeviceIdentificationIdentified =
+            device_identification
+                .clone()
+                .try_into()
+                .expect("Serial devices always have machine identification");
+
+        let new_machine = machine_registry.new_machine(&MachineNewParams {
+            device_group: &vec![device_identification_identified.clone()],
+            hardware: &MachineNewHardware::Serial(&hardware),
+        });
+
+        log::info!(
+            "[{}::add_serial_device] Adding serial machine {:?}",
+            module_path!(),
+            new_machine
+        );
+
+        self.serial_machines.insert(
+            device_identification_identified
+                .device_machine_identification
+                .machine_identification_unique,
+            new_machine,
+        );
+    }
+
+    pub fn remove_serial_device(&mut self, device_identification: &DeviceIdentification) {
+        let device_identification_identified: DeviceIdentificationIdentified =
+            device_identification
+                .clone()
+                .try_into()
+                .expect("Serial devices always have machine identification");
+
+        self.serial_machines.remove(
+            &device_identification_identified
+                .device_machine_identification
+                .machine_identification_unique,
+        );
+    }
+}
+
+/// Groups devices by machine identification
+///
+/// Returns a DeviceGroupingResult containing:
+/// - device_groups: a vector of devices grouped by machine identification
+/// - unidentified_devices: a vector of devices that could not be identified
+pub fn group_devices_by_identification(
+    device_identifications: &Vec<DeviceIdentification>,
+) -> DeviceGroupingResult {
+    let mut device_groups: Vec<Vec<DeviceIdentificationIdentified>> = Vec::new();
+    let mut unidentified_devices: Vec<DeviceIdentification> = Vec::new();
+
+    for device_identification in device_identifications {
+        // if vendor or serial or machine is 0, it is not a valid machine device
+        if let Some(device_machine_identification) =
+            device_identification.device_machine_identification.as_ref()
+        {
+            if !device_machine_identification.is_valid() {
+                unidentified_devices.push(device_identification.clone());
+
+                continue;
+            }
+        } else {
+            unidentified_devices.push(device_identification.clone());
+            continue;
+        }
+
+        // scan over all deice groups
+        // get the first DeviceMachineIdentification
+        // compare and append to the group
+        let mut found = false;
+        for check_group in device_groups.iter_mut() {
+            // get first device in group
+            let first_device = check_group.first().expect("group to not be empty");
+            let first_device_machine_identification = &first_device
+                .device_machine_identification
+                .machine_identification_unique;
+
+            // chek if it has machine identification
+            if let Some(device_machine_identification) =
+                device_identification.device_machine_identification.as_ref()
+            {
+                // compare with the current device
+                if first_device_machine_identification
+                    == &device_machine_identification.machine_identification_unique
+                {
+                    let device_identification_identified = device_identification
+                        .clone()
+                        .try_into()
+                        .expect("should have Some(DeviceMachineIdentification)");
+                    check_group.push(device_identification_identified);
+                    found = true;
+                    break;
+                }
+            }
+        }
+
+        if !found {
+            let device_identification_identified = device_identification
+                .clone()
+                .try_into()
+                .expect("should have Some(DeviceMachineIdentification)");
+            device_groups.push(vec![device_identification_identified]);
+        }
+    }
+
+    DeviceGroupingResult {
+        device_groups,
+        unidentified_devices,
+    }
+}
+
+/// Structure to hold the result of grouping devices by identification
+#[derive(Debug)]
+pub struct DeviceGroupingResult {
+    /// Devices grouped by machine identification
+    pub device_groups: Vec<Vec<DeviceIdentificationIdentified>>,
+    /// Devices that could not be identified
+    pub unidentified_devices: Vec<DeviceIdentification>,
+}

control-core/src/machines/manager_iter.rs

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

control-core/src/machines/mod.rs

@@ -0,0 +1,13 @@
+use crate::actors::Actor;
+use api::MachineApi;
+use new::MachineNewTrait;
+use std::any::Any;
+use std::fmt::Debug;
+pub mod api;
+pub mod identification;
+pub mod manager;
+pub mod manager_iter;
+pub mod new;
+pub mod registry;
+
+pub trait Machine: MachineNewTrait + MachineApi + Actor + Any + Debug {}

control-core/src/machines/new.rs

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

control-core/src/machines/registry.rs

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

control-core/src/modbus/mod.rs

@@ -1,11 +1,7 @@
-pub mod modbus_serial_interface;
-pub mod tcp;
-
 use anyhow::Error;
 use crc::{CRC_16_MODBUS, Crc};
-use serialport::SerialPort;
+use serial;
 use std::time::Duration;
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ParityType {
     Even,
@@ -26,58 +22,6 @@ pub enum ModbusFunctionCode {
     DiagnoseFunction,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[repr(u8)]
-pub enum ModbusExceptionCode {
-    None = 0,
-    IllegalFunction = 1,
-    IllegalDataAddress = 2,
-    IllegalDataValue = 3,
-    SlaveDeviceFailure = 4,
-    Acknowledge = 5,
-    SlaveDeviceBusy = 6,
-    MemoryParityError = 8,
-    GatewayPathUnavailable = 10,
-    GatewayTargetDeviceFailedToRespond = 11,
-    Unknown(u8), // For any unknown exception codes
-}
-
-impl From<ModbusExceptionCode> for u8 {
-    fn from(code: ModbusExceptionCode) -> Self {
-        match code {
-            ModbusExceptionCode::None => 0,
-            ModbusExceptionCode::IllegalFunction => 1,
-            ModbusExceptionCode::IllegalDataAddress => 2,
-            ModbusExceptionCode::IllegalDataValue => 3,
-            ModbusExceptionCode::SlaveDeviceFailure => 4,
-            ModbusExceptionCode::Acknowledge => 5,
-            ModbusExceptionCode::SlaveDeviceBusy => 6,
-            ModbusExceptionCode::MemoryParityError => 8,
-            ModbusExceptionCode::GatewayPathUnavailable => 10,
-            ModbusExceptionCode::GatewayTargetDeviceFailedToRespond => 11,
-            ModbusExceptionCode::Unknown(code) => code,
-        }
-    }
-}
-
-impl From<u8> for ModbusExceptionCode {
-    fn from(value: u8) -> Self {
-        match value {
-            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),
-        }
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ModbusRequest {
     pub slave_id: u8,
@@ -98,10 +42,10 @@ impl TryFrom<u8> for ModbusFunctionCode {
 
     fn try_from(value: u8) -> Result<Self, Self::Error> {
         match value {
-            0x03 => Ok(Self::ReadHoldingRegister),
-            0x04 => Ok(Self::ReadInputRegister),
-            0x06 => Ok(Self::PresetHoldingRegister),
-            0x08 => Ok(Self::DiagnoseFunction),
+            0x03 => Ok(ModbusFunctionCode::ReadHoldingRegister),
+            0x04 => Ok(ModbusFunctionCode::ReadInputRegister),
+            0x06 => Ok(ModbusFunctionCode::PresetHoldingRegister),
+            0x08 => Ok(ModbusFunctionCode::DiagnoseFunction),
             _ => Err(anyhow::anyhow!("Error: Modbus Function Code doesnt exist!")),
         }
     }
@@ -120,7 +64,7 @@ impl From<ModbusFunctionCode> for u8 {
 
 impl From<ModbusRequest> for Vec<u8> {
     fn from(request: ModbusRequest) -> Self {
-        let mut buffer = Self::new();
+        let mut buffer = Vec::new();
 
         buffer.push(request.slave_id);
         buffer.push(request.function_code.into()); // convert functioncode into u8 and push it
@@ -133,7 +77,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());
 
-        buffer
+        return buffer;
     }
 }
 /// Reads data from a Modbus device via a serial port.
@@ -144,7 +88,9 @@ 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 SerialPort) -> Result<Option<Vec<u8>>, anyhow::Error> {
+pub fn receive_data_modbus(
+    port: &mut dyn serial::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 {
@@ -154,7 +100,7 @@ pub fn receive_data_modbus(port: &mut dyn SerialPort) -> Result<Option<Vec<u8>>,
 }
 
 /// Computes Modbus CRC-16 using `crc` crate.
-pub const fn modbus_crc16(data: &[u8]) -> u16 {
+pub fn modbus_crc16(data: &[u8]) -> u16 {
     let modbus: Crc<u16> = Crc::<u16>::new(&CRC_16_MODBUS);
     modbus.checksum(data)
 }
@@ -193,7 +139,7 @@ fn validate_modbus_response(raw_data: Vec<u8>) -> Result<Vec<u8>, Error> {
 
 // expects to be given the entire raw message
 fn extract_crc(raw_data: &Vec<u8>) -> Result<u16, Error> {
-    if raw_data.len() < 5 {
+    if raw_data.len() < 2 {
         return Err(anyhow::anyhow!("Not enough data to extract CRC"));
     }
 
@@ -205,17 +151,23 @@ 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<Self, Error> {
-        let crc = extract_crc(&value)?;
+    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),
+        };
 
         let function_code_res = ModbusFunctionCode::try_from(value[1]);
-        let function_code = function_code_res?;
+        let function_code = match function_code_res {
+            Ok(code) => code,
+            Err(err) => return Err(err),
+        };
 
-        Ok(Self {
+        Ok(ModbusResponse {
             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,
         })
     }
 }
@@ -227,23 +179,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 const fn calculate_modbus_rtu_timeout(
+pub 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;
+    let nanoseconds_per_byte: u64 = bits as u64 * nanoseconds_per_bit as u64;
 
     let transmission_timeout: u64 = nanoseconds_per_byte * message_size as u64;
-    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 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 mut full_timeout: u64 = transmission_timeout;
     full_timeout += machine_operation_delay_nano.as_nanos() as u64;
     full_timeout += silent_time;
 
-    Duration::from_nanos(full_timeout)
+    return Duration::from_nanos(full_timeout);
 }
 
 #[cfg(test)]

control-core/src/modbus/modbus_serial_interface.rs

@@ -1,268 +0,0 @@
-use crate::modbus::{ModbusRequest, ModbusResponse};
-use ethercat_hal::io::serial_interface::{SerialEncoding, SerialInterface};
-use std::{
-    collections::HashMap,
-    time::{Duration, Instant},
-};
-
-#[derive(Debug, Clone)]
-struct RequestMetaData {
-    priority: u32,
-    ignored_times: u32,
-    /// This is used when a machine for example takes 4ms to process the request
-    /// and is added ontop of the standard waiting time for a serial transfer
-    extra_delay: Option<u32>,
-    no_response_expected: bool,
-}
-
-#[derive(Debug)]
-pub enum State {
-    /// WaitingForResponse is set after sending a request through the serial_interface
-    WaitingForResponse,
-    /// After Sending a Request we need to wait atleast one ethercat cycle
-    /// After one Cycle we check if el6021 status has transmit accepted toggled
-    /// Then we can set state = ReadyToSend
-    WaitingForRequestAccept,
-    /// After Receiving a Response we need to wait atleast one ethercat cycle
-    /// After one Cycle we check if el6021 status has received accepted toggled
-    WaitingForReceiveAccept,
-    /// ReadyToSend is set after receiving the response from the serial_interface
-    ReadyToSend,
-    /// Initial State
-    Uninitialized,
-}
-
-#[derive(Debug)]
-pub struct ModbusSerialInterface {
-    serial_interface: SerialInterface,
-    baudrate: Option<u32>,
-    encoding: Option<SerialEncoding>,
-    response: Option<ModbusResponse>,
-    state: State,
-    last_message_size: usize,
-    last_message_delay: u32,
-    pub last_message_id: u32,
-    no_response_expected: bool,
-    request_map: HashMap<u32, ModbusRequest>,
-    request_metadata_map: HashMap<u32, RequestMetaData>,
-    last_ts: Instant,
-}
-
-impl ModbusSerialInterface {
-    pub fn new(serial_interface: SerialInterface) -> Self {
-        Self {
-            serial_interface,
-            baudrate: None,
-            encoding: None,
-            request_map: HashMap::new(),
-            request_metadata_map: HashMap::new(),
-            response: None,
-            last_message_size: 0,
-            last_message_delay: 0,
-            state: State::Uninitialized,
-            last_ts: Instant::now(),
-            last_message_id: 0,
-            no_response_expected: false,
-        }
-    }
-
-    pub const fn is_initialized(&self) -> bool {
-        !matches!(self.state, State::Uninitialized)
-    }
-
-    pub fn add_request(
-        &mut self,
-        request_id: u32,
-        priority: u32,
-        request: ModbusRequest,
-        no_response_expected: bool,
-        delay: Option<u32>,
-    ) {
-        self.request_map.insert(request_id, request);
-        self.request_metadata_map
-            .entry(request_id)
-            .or_insert_with(|| RequestMetaData {
-                priority,
-                ignored_times: 0,
-                extra_delay: delay,
-                no_response_expected,
-            });
-    }
-
-    /// This is used internally to read the receive buffer of the el6021
-    async fn read_modbus_response(&mut self) -> Result<ModbusResponse, anyhow::Error> {
-        let raw_response = (self.serial_interface.read_message)()
-            .await
-            .unwrap_or_default();
-
-        let response = ModbusResponse::try_from(raw_response)?;
-        self.last_message_size = response.data.len() + 4;
-        self.state = State::WaitingForReceiveAccept;
-        Ok(response)
-    }
-
-    /// This is used internally to fill the write buffer of the el6021 with the modbus request
-    /// Decides what requests to send first by finding the one with the highest priority
-    /// For example Highest Priority requests: ResetInverter StopMotor
-    async fn send_modbus_request(&mut self) {
-        if self.request_map.is_empty() {
-            return;
-        }
-
-        let (highest_id, delay, no_response_expected) = self
-            .request_metadata_map
-            .iter_mut()
-            .map(|(key, value)| {
-                let effective_priority = value.priority + value.ignored_times;
-                (
-                    *key,
-                    effective_priority,
-                    value.extra_delay.unwrap_or(0),
-                    value.no_response_expected,
-                )
-            })
-            .max_by_key(|(_, priority, _, _)| *priority)
-            .map(|(key, _, delay, no_response)| (key, delay, no_response))
-            .unwrap(); // Safe because we checked is_empty() above
-
-        let request = &self.request_map[&highest_id];
-        let modbus_request: Vec<u8> = request.clone().into();
-
-        if let Err(_) = (self.serial_interface.write_message)(modbus_request.clone()).await {
-            tracing::error!("ERROR: serial_interface.write_message has failed");
-        } else {
-            self.last_message_delay = delay;
-            self.last_message_id = highest_id;
-            self.no_response_expected = no_response_expected;
-        }
-
-        self.state = State::WaitingForRequestAccept;
-        self.last_message_size = modbus_request.len();
-    }
-
-    pub async fn initialize_communication_settings(&mut self) -> bool {
-        let baudrate = (self.serial_interface.get_baudrate)().await;
-        let encoding = (self.serial_interface.get_serial_encoding)().await;
-
-        match (baudrate, encoding) {
-            (Some(b), Some(e)) => {
-                self.baudrate = Some(b);
-                self.encoding = Some(e);
-                true
-            }
-            _ => false,
-        }
-    }
-
-    pub async fn initialize(&mut self) -> bool {
-        if matches!(self.state, State::Uninitialized) {
-            let success = (self.serial_interface.initialize)().await;
-            if success {
-                self.state = State::ReadyToSend;
-                self.initialize_communication_settings().await;
-            }
-            success
-        } else {
-            false
-        }
-    }
-
-    fn increment_ignored_times(&mut self) {
-        for metadata in self.request_metadata_map.values_mut() {
-            metadata.ignored_times += 1;
-        }
-    }
-
-    /// Modbus RTU has silent time between frames that needs to be adhered to, if you send before silent_time is over between frames, then there will be lost frames
-    /// This silent time is needed to identify the start and end of messages
-    /// This function also takes into account the time that the slave we are talking to needs to process our request
-    /// bits: amount of bits sent per byte -> for a 8n1 coding: 8 data bits, 0 parity, 1 stop bit (1 start,1 stop) -> 10 bits
-    /// 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(
-        &self,
-        machine_operation_delay: Duration,
-        message_size: usize,
-    ) -> Option<Duration> {
-        let baudrate = self.baudrate?;
-        let encoding = self.encoding?;
-
-        let nanoseconds_per_bit = 1_000_000_000 / baudrate as u64;
-        let nanoseconds_per_byte = encoding.total_bits() as u64 * nanoseconds_per_bit;
-
-        let transmission_timeout = nanoseconds_per_byte * message_size as u64;
-        let silent_time = (nanoseconds_per_byte * 35) / 10; // silent_time is 3.5x of character length
-
-        let total_timeout =
-            transmission_timeout + machine_operation_delay.as_nanos() as u64 + silent_time;
-        Some(Duration::from_nanos(total_timeout))
-    }
-
-    pub const fn get_response(&self) -> Option<&ModbusResponse> {
-        self.response.as_ref()
-    }
-
-    pub async fn act(&mut self, now_ts: Instant) {
-        let elapsed = now_ts.duration_since(self.last_ts);
-
-        let timeout = self.calculate_modbus_rtu_timeout(
-            Duration::from_nanos(self.last_message_delay as u64),
-            self.last_message_size,
-        );
-
-        let Some(timeout) = timeout else { return };
-
-        // Check if we need to wait for timeout (except for specific states)
-        if !matches!(
-            self.state,
-            State::Uninitialized | State::WaitingForReceiveAccept | State::WaitingForRequestAccept
-        ) && elapsed < timeout
-        {
-            return;
-        }
-
-        self.last_ts = now_ts;
-        self.response = None;
-
-        match self.state {
-            State::WaitingForResponse => match self.read_modbus_response().await {
-                Ok(response) => {
-                    self.response = Some(response);
-                }
-                Err(_) => {
-                    self.response = None;
-                    if self.no_response_expected {
-                        self.state = State::ReadyToSend;
-                    }
-                }
-            },
-            State::ReadyToSend => {
-                self.send_modbus_request().await;
-
-                // Remove the sent request
-                self.request_map.remove(&self.last_message_id);
-                self.request_metadata_map.remove(&self.last_message_id);
-                self.increment_ignored_times();
-            }
-            State::WaitingForReceiveAccept => {
-                // Waste at least one Ethercat Cycle here to ensure that request/response stay in sync
-                self.state = State::ReadyToSend;
-            }
-            State::WaitingForRequestAccept => {
-                // An empty vec is used to check if we are finished with writing the message
-                // This is to keep the Serialinterface more simple
-                match (self.serial_interface.write_message)(vec![]).await {
-                    Ok(finished) if finished => {
-                        self.state = State::WaitingForResponse;
-                    }
-                    Err(_) => {
-                        self.state = State::ReadyToSend;
-                    }
-                    _ => {} // Still waiting
-                }
-            }
-            State::Uninitialized => {}
-        }
-    }
-}

control-core/src/modbus/tcp.rs

@@ -1,263 +0,0 @@
-use std::fmt::Debug;
-use std::io::ErrorKind;
-use std::net::SocketAddr;
-use std::time::Duration;
-
-use anyhow::Context;
-use anyhow::Result;
-use anyhow::bail;
-use smol::Timer;
-use smol::future::FutureExt;
-use smol::io;
-use smol::io::AsyncReadExt;
-use smol::io::AsyncWriteExt;
-use smol::net::TcpStream;
-
-const PROTOCOL_ID: u16 = 0;
-const UNIT_ID: u8 = 0;
-const READ_HOLDING_FUNCTION_CODE: u8 = 3;
-const WRITE_HOLDING_FUNCTION_CODE: u8 = 16;
-const READ_HOLDING_LENGTH: u16 = 6; // Unit ID 00 + Func Code 03 + Start Address XXXX + Quantity XXXX = 6 bytes
-const WRITE_HOLDING_LENGTH_WITHOUT_DATA: u16 = 7; // Unit ID 00 + Func Code 16 + Start Address XXXX + Quantity XXXX + Num Data Bytes XX = 7 bytes
-
-struct Packet {
-    buf: Vec<u8>,
-}
-
-impl Packet {
-    pub const fn new() -> Self {
-        Self { buf: Vec::new() }
-    }
-
-    pub fn add_u8(&mut self, x: u8) {
-        self.buf.push(x);
-    }
-
-    pub fn add_u16(&mut self, x: u16) {
-        let buf = x.to_be_bytes();
-        self.buf.push(buf[0]);
-        self.buf.push(buf[1]);
-    }
-
-    pub fn as_bytes(&self) -> &[u8] {
-        &self.buf
-    }
-}
-
-pub struct ModbusTcpDevice {
-    stream: TcpStream,
-    transactions: u16,
-}
-
-impl Debug for ModbusTcpDevice {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self.stream.peer_addr() {
-            Ok(addr) => write!(f, "ModbusTcpDevice({:?})", addr),
-            Err(_) => std::fmt::Result::Err(std::fmt::Error),
-        }
-    }
-}
-
-impl ModbusTcpDevice {
-    pub async fn new(addr: SocketAddr) -> Result<Self> {
-        let timeout = async {
-            Timer::after(Duration::from_millis(10)).await;
-            Err(io::Error::from(ErrorKind::TimedOut))
-        };
-
-        let stream = TcpStream::connect(addr)
-            .or(timeout)
-            .await
-            .context("Could not connect to modbus device!")?;
-
-        Ok(Self {
-            stream,
-            transactions: 0,
-        })
-    }
-
-    async fn read_and_check_responce_header(&mut self, func_code: u8) -> Result<()> {
-        if self.read_u16().await? != self.transactions {
-            bail!("Modbus device sent unexpected transaction id!");
-        }
-
-        if self.read_u16().await? != PROTOCOL_ID {
-            bail!("Modbus device sent unexpected protocol id!");
-        }
-
-        let length = self.read_u16().await?;
-        if length < 2 {
-            bail!("Modbus device will send too few bytes to understand the response!");
-        }
-
-        if self.read_u8().await? != UNIT_ID {
-            bail!("Modbus device sent unexpected unit id!");
-        }
-
-        let func_code_res = self.read_u8().await?;
-        if func_code != func_code_res {
-            let error_code = self.read_u8().await?;
-            bail!(
-                "Modbus device sent unexpected function code 0x{:x}! It probably encountered an error. Error code: 0x{:x}",
-                func_code_res,
-                error_code
-            );
-        }
-
-        Ok(())
-    }
-
-    async fn send_read_holding_request(&mut self, addr: u16, count: u16) -> Result<u16> {
-        let mut packet = Packet::new();
-
-        self.transactions += 1;
-        packet.add_u16(self.transactions);
-        packet.add_u16(PROTOCOL_ID);
-        packet.add_u16(READ_HOLDING_LENGTH);
-
-        packet.add_u8(UNIT_ID);
-        packet.add_u8(READ_HOLDING_FUNCTION_CODE);
-
-        packet.add_u16(addr);
-        packet.add_u16(count);
-
-        self.send(packet).await?;
-        self.read_and_check_responce_header(READ_HOLDING_FUNCTION_CODE)
-            .await?;
-
-        let num_data_bytes = self.read_u8().await? as u16;
-        if count * 2 != num_data_bytes {
-            bail!(
-                "Modbus device wants to send only a portion of the requested range - UNIMPLEMENTED!"
-            );
-        }
-
-        Ok(num_data_bytes)
-    }
-
-    pub async fn get_holding_registers(&mut self, addr: u16, count: u16) -> Result<Vec<u16>> {
-        self.send_read_holding_request(addr, count).await?;
-
-        let mut res: Vec<u16> = Vec::new();
-        while res.len() < count as usize {
-            res.push(self.read_u16().await?);
-        }
-
-        Ok(res)
-    }
-
-    pub async fn set_holding_registers(&mut self, addr: u16, values: &[u16]) -> Result<()> {
-        let count = values.len();
-        let num_bytes = count * 2;
-        assert!(
-            count <= 128,
-            "Cannot send that many bytes to modbus device in one go! Trying to send {} bytes of data.",
-            num_bytes
-        );
-
-        let mut packet = Packet::new();
-
-        self.transactions += 1;
-        packet.add_u16(self.transactions);
-        packet.add_u16(PROTOCOL_ID);
-        packet.add_u16(WRITE_HOLDING_LENGTH_WITHOUT_DATA + num_bytes as u16);
-
-        packet.add_u8(UNIT_ID);
-        packet.add_u8(WRITE_HOLDING_FUNCTION_CODE);
-
-        packet.add_u16(addr);
-        packet.add_u16(count as u16);
-
-        packet.add_u8(num_bytes as u8);
-
-        for value in values {
-            packet.add_u16(value.to_owned());
-        }
-
-        self.send(packet).await?;
-        self.read_and_check_responce_header(WRITE_HOLDING_FUNCTION_CODE)
-            .await?;
-
-        if self.read_u16().await? != addr {
-            bail!("Modbus device wrote to wrong register address!");
-        }
-
-        if self.read_u16().await? != count as u16 {
-            bail!("Modbus device wrote wrong number of registers!");
-        }
-
-        Ok(())
-    }
-
-    pub async fn get_string<const N: usize>(&mut self, addr: u16) -> Result<String> {
-        assert!(N % 2 == 0, "Strings are always of even length!");
-        assert!(N <= 256, "Cannot read long strings in a single swoop!");
-        let count = N / 2;
-
-        self.send_read_holding_request(addr, count as u16).await?;
-        let buf = self.read_bytes::<N>().await?;
-
-        let s = String::from_utf8_lossy(&buf);
-        let s = match s.split_once('\0') {
-            None => s.to_string(),
-            Some((l, _)) => l.to_string(),
-        };
-
-        Ok(s)
-    }
-
-    pub async fn set_string<const N: usize>(&mut self, _addr: u16, s: &str) -> Result<()> {
-        assert!(s.len() <= N, "String is too long to fit!");
-
-        todo!()
-    }
-
-    pub async fn get_u16(&mut self, addr: u16) -> Result<u16> {
-        let length = self.send_read_holding_request(addr, 1).await?;
-        assert_eq!(
-            length, 2,
-            "Expected modbus device to send exactly 2 bytes of data!"
-        );
-
-        self.read_u16().await
-    }
-
-    pub async fn get_u32(&mut self, addr: u16) -> Result<u32> {
-        let length = self.send_read_holding_request(addr, 2).await?;
-        assert_eq!(
-            length, 4,
-            "Expected modbus device to send exactly 4 bytes of data!"
-        );
-
-        let buf = self.read_bytes::<4>().await?;
-        Ok(u32::from_be_bytes(buf))
-    }
-
-    // We have to send the request in a single packet,
-    // otherwise the device may fail to respond correctly.
-    async fn send(&mut self, packet: Packet) -> Result<()> {
-        self.stream
-            .write_all(packet.as_bytes())
-            .await
-            .context("Could write to modbus device!")
-    }
-
-    async fn read_u8(&mut self) -> Result<u8> {
-        let buf = self.read_bytes::<1>().await?;
-        Ok(u8::from_be_bytes(buf))
-    }
-
-    async fn read_u16(&mut self) -> Result<u16> {
-        let buf = self.read_bytes::<2>().await?;
-        Ok(u16::from_be_bytes(buf))
-    }
-
-    async fn read_bytes<const N: usize>(&mut self) -> Result<[u8; N]> {
-        let mut buf = [0; N];
-        self.stream
-            .read_exact(&mut buf)
-            .await
-            .context("Could not read from modbus device!")?;
-        Ok(buf)
-    }
-}

control-core/src/realtime.rs

@@ -1,178 +0,0 @@
-use tracing::debug;
-use tracing::error;
-
-#[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:
-///
-/// 1. Setting the scheduling policy to SCHED_FIFO (First-In-First-Out), which is a real-time
-///    scheduling policy that allows the thread to run until it voluntarily yields, blocks on I/O,
-///    or is preempted by a higher-priority real-time thread.
-///
-/// 2. Setting the real-time priority to 80 (on a scale of 1-99, where higher values indicate
-///    higher priority). This priority level is chosen to be higher than most IRQ handlers
-///    (typically priority 50) but lower than critical kernel tasks (priority 99).
-///
-/// When running on a PREEMPT_RT patched Linux kernel, this combination provides deterministic
-/// scheduling with minimal latency, which is essential for real-time applications.
-///
-/// # Requirements
-///
-/// - The program must run with appropriate permissions to set real-time priorities.
-///   This typically means either:
-///   - Running as root
-///   - Configuring `/etc/security/limits.conf` to allow the user to set real-time priorities
-///
-/// - The system should be running a Linux kernel with PREEMPT_RT patch applied for
-///   optimal real-time performance.
-///
-/// # Example
-///
-/// ```ignore
-/// fn main() {
-///     // Lock memory to prevent page faults
-///     lock_memory();
-///     
-///     // Create a thread and make it real-time
-///     std::thread::spawn(|| {
-///         set_realtime_priority();
-///         
-///         // Real-time code here
-///     });
-/// }
-/// ```
-///
-/// # Returns
-///
-/// - `Ok(())` if the real-time priority was successfully set
-/// - `Err` with the error message if setting the priority failed
-#[cfg(target_os = "linux")]
-pub fn set_realtime_priority() -> Result<(), anyhow::Error> {
-    use anyhow::anyhow;
-    use libc::{SCHED_FIFO, pthread_setschedparam, sched_param};
-    use std::mem;
-
-    unsafe {
-        // Get the pthread_t of the current thread using pthread_self()
-        let pthread_self = libc::pthread_self();
-
-        // Set up the scheduling parameters
-        let mut param: sched_param = mem::zeroed();
-        param.sched_priority = 95;
-
-        // Set the thread to use SCHED_FIFO scheduling policy with our priority
-        let result = pthread_setschedparam(pthread_self, SCHED_FIFO, &param);
-
-        if result != 0 {
-            error!(
-                "Failed to set real-time scheduling policy for thread \"{:?}\": {}",
-                std::thread::current().name().unwrap_or("unknown"),
-                std::io::Error::last_os_error()
-            );
-            return Err(anyhow!(
-                "Failed to set real-time priority: {}",
-                std::io::Error::last_os_error()
-            ));
-        } else {
-            debug!(
-                "Successfully set real-time priority for the thread \"{:?}\"",
-                std::thread::current().name().unwrap_or("unknown")
-            );
-        }
-    }
-    Ok(())
-}
-
-#[cfg(not(target_os = "linux"))]
-pub fn set_realtime_priority() -> Result<(), anyhow::Error> {
-    tracing::error!("This platform does not support realtime threads");
-    Ok(())
-}
-
-/// Locks all current and future memory pages of the process into RAM to prevent page faults.
-///
-/// # When to call this function
-///
-/// This function should be called from the main thread, as early as possible in your program's
-/// execution, ideally before creating any threads and before allocating large amounts of memory.
-///
-/// Important: You only need to call this function ONCE per process, not in each thread.
-/// The memory locking applies to the entire process, including:
-/// - The main thread
-/// - All threads created after the call
-///
-/// This happens because all threads in a process share the same virtual memory space, and
-/// `mlockall()` operates on the entire process's memory space, not just the calling thread.
-///
-/// # Example: Correct usage
-///
-/// ```ignore
-/// fn main() -> Result<(), Box<dyn std::error::Error>> {
-///     // Call early in main, before creating threads
-///     lock_memory()?;
-///     
-///     // Now create real-time threads...
-///     std::thread::spawn(|| {
-///         set_realtime_priority();
-///         // Real-time code here
-///     });
-///     
-///     Ok(())
-/// }
-/// ```
-///
-/// # Example: Incorrect usage
-///
-/// ```ignore
-/// fn main() {
-///     // Don't do this - calling in each thread is unnecessary
-///     std::thread::spawn(|| {
-///         lock_memory().unwrap(); // Redundant if already called in main
-///         set_realtime_priority();
-///     });
-/// }
-/// ```
-///
-/// # How it works
-///
-/// [Rest of documentation as before...]
-#[cfg(target_os = "linux")]
-pub fn lock_memory() -> Result<(), Box<dyn std::error::Error>> {
-    use libc::{MCL_FUTURE, mlockall};
-
-    unsafe {
-        if mlockall(MCL_FUTURE) != 0 {
-            error!("Failed to lock memory: {}", std::io::Error::last_os_error());
-            return Err(
-                format!("Failed to lock memory: {}", std::io::Error::last_os_error()).into(),
-            );
-        } else {
-            debug!("Successfully locked memory for the process");
-        }
-    }
-    Ok(())
-}
-
-#[cfg(not(target_os = "linux"))]
-pub fn lock_memory() -> Result<(), Box<dyn std::error::Error>> {
-    tracing::error!("This platform does not support memory locking");
-    Ok(())
-}
-
-pub fn set_core_affinity(core_id: usize) -> Result<(), anyhow::Error> {
-    let cores = core_affinity::get_core_ids().unwrap_or_default();
-    let core = cores.get(core_id);
-    if let Some(core) = core {
-        core_affinity::set_for_current(*core);
-        debug!(
-            "Set core affinity of thread \"{:?}\" to core {:?}",
-            std::thread::current().name().unwrap_or("unknown"),
-            core
-        );
-        Ok(())
-    } else {
-        error!("No cores available to set affinity");
-        Err(anyhow::anyhow!("No cores available to set affinity"))
-    }
-}

control-core/src/rest/mod.rs

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

control-core/src/rest/mutation.rs

@@ -0,0 +1,35 @@
+use std::fmt::Debug;
+
+use serde::Serialize;
+
+use crate::machines::identification::MachineIdentificationUnique;
+
+#[derive(Debug, Serialize, Clone)]
+pub struct MutationResponse {
+    pub success: bool,
+    pub error: Option<String>,
+}
+
+impl MutationResponse {
+    pub fn success() -> Self {
+        Self {
+            success: true,
+            error: None,
+        }
+    }
+    pub fn error(error: String) -> Self {
+        Self {
+            success: false,
+            error: Some(error),
+        }
+    }
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub struct MachineMutationBody<T>
+where
+    T: Debug,
+{
+    pub machine_identification_unique: MachineIdentificationUnique,
+    pub data: T,
+}

control-core/src/serial/mod.rs

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

control-core/src/serial/registry.rs

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

control-core/src/serial/serial_detection.rs

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

control-core/src/socketio/event.rs

@@ -1,34 +1,20 @@
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use erased_serde::Serialize as ErasedSerialize;
 use serde::Serialize;
+use serde_json::Value;
 
-#[derive(Serialize)]
+#[derive(Debug, Clone, Serialize)]
 pub struct GenericEvent {
     pub name: String,
-    pub data: Box<dyn ErasedSerialize + Send + Sync>,
+    pub data: Value,
     /// Timestamp in milliseconds
     pub ts: u64,
 }
 
-impl std::fmt::Debug for GenericEvent {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("GenericEvent")
-            .field("name", &self.name)
-            .field("data", &"[erased]")
-            .field("ts", &self.ts)
-            .finish()
-    }
-}
-
-pub trait BuildEvent: Serialize + Send + Sync + Clone {
-    fn build(&self) -> Event<Self>;
-}
-
 #[derive(Debug, Clone, Serialize)]
 pub struct Event<T>
 where
-    T: Serialize + Send + Sync + 'static,
+    T: Serialize,
 {
     pub name: String,
     pub data: T,
@@ -36,35 +22,39 @@ where
     pub ts: u64,
 }
 
-impl<T> From<Event<T>> for GenericEvent
+impl<T> TryFrom<Event<T>> for GenericEvent
 where
-    T: Serialize + Send + Sync + 'static,
+    T: Serialize,
 {
-    fn from(event: Event<T>) -> Self {
-        Self {
+    type Error = serde_json::Error;
+
+    fn try_from(event: Event<T>) -> Result<Self, Self::Error> {
+        Ok(Self {
             name: event.name,
-            data: Box::new(event.data),
+            data: serde_json::to_value(event.data)?,
             ts: event.ts,
-        }
+        })
     }
 }
 
-impl<T> From<&Event<T>> for GenericEvent
+impl<T> TryFrom<&Event<T>> for GenericEvent
 where
-    T: Serialize + Clone + Send + Sync + 'static,
+    T: Serialize,
 {
-    fn from(event: &Event<T>) -> Self {
-        Self {
+    type Error = serde_json::Error;
+
+    fn try_from(event: &Event<T>) -> Result<Self, Self::Error> {
+        Ok(Self {
             name: event.name.clone(),
-            data: Box::new(event.data.clone()),
+            data: serde_json::to_value(&event.data)?,
             ts: event.ts,
-        }
+        })
     }
 }
 
 impl<T> Event<T>
 where
-    T: Serialize + Clone + Send + Sync + 'static,
+    T: Serialize + Clone,
 {
     pub fn new(event: &str, data: T) -> Self {
         Self {

control-core/src/socketio/mod.rs

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

control-core/src/socketio/namespace.rs

@@ -1,64 +1,23 @@
 use crate::socketio::event::GenericEvent;
-use smol::channel::Sender;
-use socketioxide::extract::SocketRef;
-use std::{collections::HashMap, sync::Arc, time::Duration};
-use tracing::instrument;
+use socketioxide::{extract::SocketRef, socket::Sid};
+use std::{collections::HashMap, time::Duration};
 
-#[derive(Debug, Clone)]
-pub struct Namespace {
-    pub sockets: Vec<SocketRef>,
-    pub events: HashMap<String, Vec<Arc<GenericEvent>>>,
-    pub socket_queue_tx: Sender<(SocketRef, Arc<GenericEvent>)>,
-}
+use super::socket_queue::SocketQueue;
 
-impl Namespace {
-    pub fn new(socket_queue_tx: Sender<(SocketRef, Arc<GenericEvent>)>) -> Self {
-        Self {
-            sockets: vec![],
-            events: HashMap::new(),
-            socket_queue_tx,
-        }
-    }
-}
-
-impl Namespace {
+pub trait NamespaceInterface {
     /// Adds a socket to the namespace.
     ///
     /// # Arguments
     ///
     /// * `socket` - A reference to the socket to be added
-    #[instrument(skip_all)]
-    pub fn subscribe(&mut self, socket: SocketRef) {
-        // add the socket to the list
-        self.sockets.push(socket);
-    }
+    fn subscribe(&mut self, socket: SocketRef);
 
     /// Removes a socket from the namespace.
     ///
     /// # Arguments
     ///
     /// * `socket` - A reference to the socket to be removed
-    #[instrument(skip_all)]
-    pub fn unsubscribe(&mut self, socket: SocketRef) {
-        // remove the socket from the list
-        self.sockets.retain(|s| s.id != socket.id);
-    }
-
-    /// Disconnects all clients in the namespace.
-    ///
-    /// This will forcefully disconnect all sockets and clear the socket list.
-    #[instrument(skip_all)]
-    pub fn disconnect_all(&mut self) {
-        tracing::info!("Disconnecting {} sockets in namespace", self.sockets.len());
-
-        // Disconnect each socket
-        for socket in &self.sockets {
-            let _ = socket.clone().disconnect(); // Ignore errors if socket is already disconnected
-        }
-
-        // Clear the socket list
-        self.sockets.clear();
-    }
+    fn unsubscribe(&mut self, socket: SocketRef);
 
     /// Re-emits cached events to a specific socket.
     ///
@@ -68,23 +27,14 @@ impl Namespace {
     /// # Arguments
     ///
     /// * `socket` - A reference to the socket that will receive the cached events
-    #[instrument(skip_all)]
-    pub fn reemit(&mut self, socket: SocketRef) {
-        // Collect events grouped by name/kind with their counts for sorting
-        let mut event_groups: Vec<(&String, &Vec<Arc<GenericEvent>>)> =
-            self.events.iter().collect();
+    fn reemit(&mut self, socket: SocketRef);
 
-        // Sort by event count (ascending - lowest count first)
-        event_groups.sort_by(|a, b| a.1.len().cmp(&b.1.len()));
-
-        // Emit events in order of lowest count first
-        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");
-            }
-        }
-    }
+    /// Emits an event to all sockets in the namespace.
+    ///
+    /// # Arguments
+    ///
+    /// * `event` - The event to be emitted
+    fn emit(&mut self, event: &GenericEvent);
 
     /// Caches an event with a specific key for later retrieval.
     ///
@@ -93,81 +43,112 @@ impl Namespace {
     /// * `cache_key` - A string key to identify the cache
     /// * `event` - The event to be cached
     /// * `buffer_fn` - A function that defines how the event should be added to the cache buffer
-    #[instrument(skip_all)]
     fn cache(
         &mut self,
-        event: Arc<GenericEvent>,
-        buffer_fn: &Box<dyn Fn(&mut Vec<Arc<GenericEvent>>, &Arc<GenericEvent>)>,
-    ) {
-        let cached_events_for_key = self.events.entry(event.name.clone()).or_default();
-        buffer_fn(cached_events_for_key, &event);
-    }
+        event: &GenericEvent,
+        buffer_fn: &Box<dyn Fn(&mut Vec<GenericEvent>, &GenericEvent) -> ()>,
+    );
 
     /// Emits an event to all sockets in the namespace and caches it.
     ///
+    /// This is a convenience method that combines the functionality of
+    /// [`Namespace::emit`] and [`Namespace::cache`].
     ///
     /// # Arguments
     ///
     /// * `event` - The event to be emitted and cached
+    /// * `cache_key` - A string key to identify the cache
     /// * `buffer_fn` - A function that defines how the event should be added to the cache buffer
-    #[instrument(skip_all)]
-    pub fn emit(
+    fn emit_cached(
         &mut self,
-        event: Arc<GenericEvent>,
-        buffer_fn: &Box<dyn Fn(&mut Vec<Arc<GenericEvent>>, &Arc<GenericEvent>)>,
-    ) {
-        // cache the event
-        self.cache(event.clone(), buffer_fn);
-        // emit the event - inlined from emit function
-        // Send to global queue for each socket in the namespace
-        for socket in self.sockets.clone() {
-            self.send_to_queue(&socket, &event, "emit");
-        }
-    }
+        event: &GenericEvent,
+        buffer_fn: &Box<dyn Fn(&mut Vec<GenericEvent>, &GenericEvent) -> ()>,
+    );
+}
 
-    /// Sends an event to the global queue for a specific socket.
-    ///
-    /// # Arguments
-    ///
-    /// * `socket` - The socket to send the event to
-    /// * `event` - The event to be sent
-    /// * `operation` - A description of the operation for logging purposes (e.g., "reemit", "emit")
-    #[instrument(skip_all)]
-    fn send_to_queue(&self, socket: &SocketRef, event: &Arc<GenericEvent>, operation: &str) {
-        tracing::trace!(
-            socket_id = ?socket.id,
-            event = %event.name,
-            operation = %operation,
-            "Sending event to global queue"
-        );
-        match self
-            .socket_queue_tx
-            .try_send((socket.clone(), event.clone()))
-        {
-            Ok(_) => {
-                tracing::trace!(
-                    socket_id = ?socket.id,
-                    event = %event.name,
-                    operation = %operation,
-                    "Successfully sent event to global queue"
-                );
-            }
-            Err(e) => {
-                tracing::error!(
-                    socket_id = ?socket.id,
-                    event = %event.name,
-                    operation = %operation,
-                    error = %e,
-                    "Failed to send event to global queue"
-                );
-            }
+#[derive(Debug)]
+pub struct Namespace {
+    sockets: Vec<SocketRef>,
+    events: HashMap<String, Vec<GenericEvent>>,
+    socket_queues: HashMap<Sid, SocketQueue>,
+}
+
+impl Namespace {
+    pub fn new() -> Self {
+        Self {
+            sockets: vec![],
+            events: HashMap::new(),
+            socket_queues: HashMap::new(),
         }
     }
 }
 
-impl Drop for Namespace {
-    fn drop(&mut self) {
-        //self.disconnect_all();
+impl NamespaceInterface for Namespace {
+    fn subscribe(&mut self, socket: SocketRef) {
+        // add the socket to the list
+        self.sockets.push(socket.clone());
+        // create a new queue for this socket
+        self.socket_queues.insert(socket.id, SocketQueue::new());
+    }
+
+    fn unsubscribe(&mut self, socket: SocketRef) {
+        // remove the socket from the list
+        self.sockets.retain(|s| s.id != socket.id);
+        // remove the socket's queue
+        self.socket_queues.remove(&socket.id);
+    }
+
+    fn reemit(&mut self, socket: SocketRef) {
+        if let Some(queue) = self.socket_queues.get(&socket.id) {
+            // Collect events grouped by name/kind with their counts for sorting
+            let mut event_groups: Vec<(&String, &Vec<GenericEvent>)> = self.events.iter().collect();
+
+            // Sort by event count (ascending - lowest count first)
+            event_groups.sort_by(|a, b| a.1.len().cmp(&b.1.len()));
+
+            // Emit events in order of lowest count first
+            for (_event_name, events) in event_groups {
+                for event in events {
+                    queue.push(event.clone());
+                }
+            }
+            
+            queue.flush(socket.clone());
+        }
+    }
+
+    fn emit(&mut self, event: &GenericEvent) {
+        // Use the new emit function which combines push and flush
+        for socket in self.sockets.clone() {
+            if let Some(queue) = self.socket_queues.get(&socket.id) {
+                queue.push(event.clone());
+                queue.flush(socket.clone());
+            }
+        }
+    }
+
+    fn cache(
+        &mut self,
+        event: &GenericEvent,
+        buffer_fn: &Box<dyn Fn(&mut Vec<GenericEvent>, &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);
+    }
+
+    fn emit_cached(
+        &mut self,
+        event: &GenericEvent,
+        buffer_fn: &Box<dyn Fn(&mut Vec<GenericEvent>, &GenericEvent) -> ()>,
+    ) {
+        // cache the event
+        self.cache(event, buffer_fn);
+
+        // emit the event
+        self.emit(event);
     }
 }
 
@@ -179,17 +160,17 @@ pub trait NamespaceCacheingLogic<V>
 where
     V: CacheableEvents<V>,
 {
-    fn emit(&mut self, event: V);
+    fn emit_cached(&mut self, event: V);
 }
 
 pub trait CacheableEvents<Events> {
-    fn event_value(&self) -> GenericEvent;
+    fn event_value(&self) -> Result<GenericEvent, serde_json::Error>;
     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<GenericEvent>, &GenericEvent) -> ()>;
 
-/// [`BufferFn`] that stores the last n events
+/// [BufferFn] that stores the last n events
 pub fn cache_n_events(n: usize) -> CacheFn {
     Box::new(move |events, event| {
         if events.len() >= n {
@@ -199,41 +180,21 @@ pub fn cache_n_events(n: usize) -> CacheFn {
     })
 }
 
-/// [`BufferFn`] that stores only one event
+/// [BufferFn] that stores only one event
 pub fn cache_one_event() -> CacheFn {
     cache_n_events(1)
 }
 
-/// [`BufferFn`] that stores first and last event
-///
-/// The primary use case of this function is to cache both the default state of a machine, which should be emitted first,
-/// and the last event, which is the most recent state of the machine.
-pub fn cache_first_and_last_event() -> CacheFn {
-    Box::new(move |events, event| {
-        // if the events length 0 or 1, we just push the event
-        if events.is_empty() || events.len() == 1 {
-            events.push(event.clone());
-            return;
-        }
-        // if the event length is 2 we remove the last event and append a new one
-        if events.len() == 2 {
-            events.remove(1);
-            events.push(event.clone());
-        }
-    })
-}
-
-/// [`BufferFn`] that stores events for a certain duration
+/// [BufferFn] that stores events for a certain duration
 pub fn cache_duration(duration: Duration, bucket_size: Duration) -> CacheFn {
     Box::new(move |events, event| {
         // Use event.ts instead of system time
         let current_time = event.ts as u128;
 
         // calculate current bucket & last bucket
-        let bucket_size_ms = bucket_size.as_millis().max(1);
-        let bucket = current_time / bucket_size_ms; // Avoid division by zero
+        let bucket = current_time / bucket_size.as_millis();
         let last_bucket = match events.last() {
-            Some(last_event) => last_event.ts as u128 / bucket_size_ms,
+            Some(last_event) => last_event.ts as u128 / bucket_size.as_millis(),
             None => 0,
         };
 
@@ -263,32 +224,24 @@ pub fn cache_duration(duration: Duration, bucket_size: Duration) -> CacheFn {
 mod tests {
     use std::cmp::min;
 
-    use serde::Serialize;
-
     use super::*;
 
-    #[derive(Debug, Clone, Serialize)]
-    struct TestEventData {
-        value: usize,
-    }
-
     #[test]
     fn test_cache_n_events() {
         // Create a cache function that stores the last 2 events
         let cache_fn = cache_n_events(2);
 
-        // Create namespace with dummy queue_tx
-        let (queue_tx, _queue_rx) = smol::channel::unbounded();
-        let mut namespace = Namespace::new(queue_tx);
+        // Create namespace
+        let mut namespace = Namespace::new();
         assert!(namespace.events.is_empty());
 
         // Add event
-        let event1 = Arc::new(GenericEvent {
+        let event1 = GenericEvent {
             name: "test_event".to_string(),
-            data: Box::new(TestEventData { value: 1 }),
+            data: serde_json::json!({"value": 1}),
             ts: 0,
-        });
-        namespace.cache(event1, &cache_fn);
+        };
+        namespace.cache(&event1, &cache_fn);
 
         // Check that we have one event name in the map
         assert_eq!(namespace.events.len(), 1);
@@ -297,12 +250,12 @@ mod tests {
         assert_eq!(namespace.events.get("test_event").unwrap()[0].ts, 0);
 
         // Add another event
-        let event2 = Arc::new(GenericEvent {
+        let event2 = GenericEvent {
             name: "test_event".to_string(),
-            data: Box::new(TestEventData { value: 2 }),
+            data: serde_json::json!({"value": 2}),
             ts: 1,
-        });
-        namespace.cache(event2, &cache_fn);
+        };
+        namespace.cache(&event2, &cache_fn);
 
         // Still one event name
         assert_eq!(namespace.events.len(), 1);
@@ -312,12 +265,12 @@ mod tests {
         assert_eq!(namespace.events.get("test_event").unwrap()[1].ts, 1);
 
         // Add a third event, which should remove the first one
-        let event3 = Arc::new(GenericEvent {
+        let event3 = GenericEvent {
             name: "test_event".to_string(),
-            data: Box::new(TestEventData { value: 3 }),
+            data: serde_json::json!({"value": 3}),
             ts: 2,
-        });
-        namespace.cache(event3, &cache_fn);
+        };
+        namespace.cache(&event3, &cache_fn);
 
         // Still one event name
         assert_eq!(namespace.events.len(), 1);
@@ -336,20 +289,19 @@ mod tests {
         let duration = Duration::new(10, 0);
         let bucket_size = Duration::new(1, 0);
         let cache_fn = cache_duration(duration, bucket_size);
-        let (queue_tx, _queue_rx) = smol::channel::unbounded();
 
         // Create namespace
-        let mut namespace = Namespace::new(queue_tx);
+        let mut namespace = Namespace::new();
         assert!(namespace.events.is_empty());
 
         // Add events every 100ms for 20 seconds
         for i in 0..200 {
-            let event = Arc::new(GenericEvent {
+            let event = GenericEvent {
                 name: "test_event".to_string(),
-                data: Box::new(TestEventData { value: i }),
+                data: serde_json::json!({"value": i}),
                 ts: (i * 100) as u64,
-            });
-            namespace.cache(event, &cache_fn);
+            };
+            namespace.cache(&event, &cache_fn);
 
             let should_have_events = min(i / 10, 11);
             assert_eq!(

control-core/src/socketio/namespace_id.rs

@@ -3,7 +3,7 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt;
 use std::str::FromStr;
 
-use machines::machine_identification::{MachineIdentification, MachineIdentificationUnique};
+use crate::machines::identification::{MachineIdentification, MachineIdentificationUnique};
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
 pub enum NamespaceId {
@@ -17,8 +17,8 @@ impl Serialize for NamespaceId {
         S: Serializer,
     {
         match self {
-            Self::Main => serializer.serialize_str("/main"),
-            Self::Machine(id) => {
+            NamespaceId::Main => serializer.serialize_str("/main"),
+            NamespaceId::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 Visitor<'_> for NamespaceIdVisitor {
+        impl<'de> Visitor<'de> 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(Self::Main);
+            return Ok(NamespaceId::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(Self::Machine(MachineIdentificationUnique {
+                return Ok(NamespaceId::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 {
-            Self::Main => write!(f, "/main"),
-            Self::Machine(id) => {
+            NamespaceId::Main => write!(f, "/main"),
+            NamespaceId::Machine(id) => {
                 write!(
                     f,
                     "/machine/{}/{}/{}",

control-core/src/socketio/socket_queue.rs

@@ -0,0 +1,107 @@
+use std::{
+    collections::VecDeque,
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicBool, Ordering},
+    },
+    time::Duration,
+};
+
+use socketioxide::extract::SocketRef;
+
+use super::event::GenericEvent;
+
+/// A queue for managing events for a specific socket
+#[derive(Debug)]
+pub struct SocketQueue {
+    queue: Arc<Mutex<VecDeque<GenericEvent>>>,
+    is_flushing: Arc<AtomicBool>,
+}
+
+impl SocketQueue {
+    /// Create a new socket queue for the given socket ID
+    pub fn new() -> Self {
+        Self {
+            queue: Arc::new(Mutex::new(VecDeque::new())),
+            is_flushing: Arc::new(AtomicBool::new(false)),
+        }
+    }
+
+    /// Add an event to the queue
+    pub fn push(&self, event: GenericEvent) {
+        if let Ok(mut queue) = self.queue.lock() {
+            queue.push_back(event);
+        }
+    }
+
+    /// Force flush events asynchronously (assumes flushing flag is already set)
+    pub fn flush(&self, socket: SocketRef) {
+        // Check if we're already flushing
+        if self
+            .is_flushing
+            .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
+            .is_err()
+        {
+            // Already flushing, return early
+            return;
+        }
+
+        let queue = Arc::clone(&self.queue);
+        let is_flushing = Arc::clone(&self.is_flushing);
+
+        // Spawn a smol task to flush the queue
+        smol::spawn(async move {
+            // Process events directly from the queue without collecting first
+            loop {
+                let event = {
+                    if let Ok(mut queue_guard) = queue.lock() {
+                        queue_guard.pop_front()
+                    } else {
+                        break; // Exit if we can't lock the queue
+                    }
+                };
+
+                let Some(event) = event else {
+                    break; // No more events in queue
+                };
+
+                // retry loop for each event
+                loop {
+                    // check if socket is still connected
+                    if !socket.connected() {
+                        break; // Exit the loop if the socket is not connected
+                    }
+
+                    match socket.emit("event", &event) {
+                        Ok(_) => break, // Successfully emitted, exit loop
+                        Err(e) => match e {
+                            socketioxide::SendError::Serialize(_) => {
+                                // no reason in retrying serialization errors
+                                break;
+                            }
+                            socketioxide::SendError::Socket(socket_error) => match socket_error {
+                                socketioxide::SocketError::InternalChannelFull => {
+                                    // wait 10ms before retrying
+                                    log::warn!(
+                                        "Socket {} internal channel full, retrying in 10ms",
+                                        socket.id,
+                                    );
+                                    smol::Timer::after(Duration::from_millis(10)).await;
+                                    continue; // Retry sending the event
+                                }
+                                socketioxide::SocketError::Closed => {
+                                    // Socket is closed, no point in retrying
+                                    break;
+                                }
+                            },
+                        },
+                    }
+                }
+            }
+
+            // Reset the flushing flag
+            is_flushing.store(false, Ordering::SeqCst);
+        })
+        .detach();
+    }
+}

control-core/src/transmission/fixed.rs

@@ -1,27 +0,0 @@
-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

@@ -1,95 +0,0 @@
-use units::{
-    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/uom_extensions/acceleration.rs

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

control-core/src/uom_extensions/angular_acceleration.rs

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

control-core/src/uom_extensions/angular_jerk.rs

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