first commit

app/simulator.py

@@ -0,0 +1,66 @@
+# simulator.py — Driveline & ECU-State
+from __future__ import annotations
+import threading
+import time
+from dataclasses import dataclass
+
+@dataclass
+class DrivelineModel:
+    idle_rpm: int = 1400
+    max_rpm: int = 9500
+    kmh_per_krpm: tuple = (0.0, 12.0, 19.0, 25.0, 32.0, 38.0, 45.0)
+    rpm_rise_per_s: int = 5000
+    rpm_fall_per_s: int = 3500
+
+    def target_rpm_from_throttle(self, throttle_pct: int) -> int:
+        t = max(0, min(100, throttle_pct)) / 100.0
+        return int(self.idle_rpm + t * (self.max_rpm - self.idle_rpm))
+
+    def speed_from_rpm_gear(self, rpm: int, gear: int) -> float:
+        if gear <= 0:
+            return 0.0
+        k = self.kmh_per_krpm[min(gear, len(self.kmh_per_krpm) - 1)]
+        return (rpm / 1000.0) * k
+
+class EcuState:
+    """Thread-sichere Zustandsmaschine (Gang, Gas, RPM, Speed)."""
+    def __init__(self, model: DrivelineModel | None = None) -> None:
+        self.model = model or DrivelineModel()
+        self._lock = threading.Lock()
+        self._gear = 0
+        self._throttle = 0
+        self._rpm = self.model.idle_rpm
+        self._speed = 0.0
+        self._last = time.monotonic()
+
+    def set_gear(self, gear: int) -> None:
+        with self._lock:
+            self._gear = max(0, min(6, int(gear)))
+
+    def set_throttle(self, thr: int) -> None:
+        with self._lock:
+            self._throttle = max(0, min(100, int(thr)))
+
+    def snapshot(self) -> tuple[int, int, int, float]:
+        with self._lock:
+            return self._gear, self._throttle, self._rpm, self._speed
+
+    def update(self) -> None:
+        now = time.monotonic()
+        dt = max(0.0, min(0.1, now - self._last))
+        self._last = now
+        with self._lock:
+            target = self.model.target_rpm_from_throttle(self._throttle)
+            if self._rpm < target:
+                self._rpm = min(self._rpm + int(self.model.rpm_rise_per_s * dt), target)
+            else:
+                self._rpm = max(self._rpm - int(self.model.rpm_fall_per_s * dt), target)
+            min_idle = 800 if self._gear == 0 and self._throttle == 0 else self.model.idle_rpm
+            self._rpm = max(min_idle, min(self._rpm, self.model.max_rpm))
+
+            target_speed = self.model.speed_from_rpm_gear(self._rpm, self._gear)
+            alpha = min(1.0, 4.0 * dt)
+            if self._gear == 0:
+                target_speed = 0.0
+            self._speed = (1 - alpha) * self._speed + alpha * target_speed
+            self._speed = max(0.0, min(self._speed, 299.0))