diff --git a/drive/arduino-sketch/arduino-sketch-live.ino b/drive/arduino-sketch/arduino-sketch-live.ino
index 0dd243b..090354a 100644
--- a/drive/arduino-sketch/arduino-sketch-live.ino
+++ b/drive/arduino-sketch/arduino-sketch-live.ino
@@ -1,303 +1,163 @@
 /*
-  4WD Robot Motor Control (2x BTS7960: Left + Right)
-  - Soft start/stop via ramping (slew-rate limiter)
-  - Differential drive mixing: throttle + turn
-  - Serial control (USB): f/b/l/r/s or m <throttle> <turn>
-  - Watchdog: stops if no command received in time
-
-  Wiring (per BTS7960 module):
-    - LPWM  -> Arduino PWM pin
-    - RPWM  -> Arduino PWM pin
-    - LEN/REN (or L_EN/R_EN) -> Arduino digital pins (or permanently HIGH to 5V)
-    - VCC   -> 5V (logic)
-    - GND   -> GND common with Arduino and motor supply
-    - B+ / B- -> motor supply (e.g. 12V)
-    - M+ / M- -> motor output
-
-  NOTE:
-    Each side is one BTS7960 module driving two motors in parallel (front+rear) on that side.
+  Arduino Drive "Safe Executor"
+  - Receives:  L <int> R <int>   (-255..255)
+  - Outputs PWM immediately (no ramping here)
+  - Safety: watchdog stop if no command
+  - Deadzone + Min PWM mapping to avoid motor buzzing at low PWM
+  - Optional direction-change protection (short stop)
 */
 
-#include <Arduino.h>
-#include <PS2X_lib.h>
-PS2X ps2x;
+// ===== Left BTS7960 pins =====
+const uint8_t L_RPWM = 5;
+const uint8_t L_LPWM = 6;
+const uint8_t L_REN  = 7;
+const uint8_t L_LEN  = 8;
 
-// ------ PS2 Controller Pins -------------
-const uint8_t PS2_CLK = 2;
-const uint8_t PS2_ATT = 3;
-const uint8_t PS2_CMD = 4;
-const uint8_t PS2_DAT = 12;
+// ===== Right BTS7960 pins =====
+const uint8_t R_RPWM = 9;
+const uint8_t R_LPWM = 10;
+const uint8_t R_REN  = 11;
+const uint8_t R_LEN  = 12;
 
-// ------- USE PS2 Controller or Serial Input --------------
-#define USE_PS2 1
+// ===== Safety / feel =====
+const uint16_t CMD_TIMEOUT_MS = 600;  // Web sendet regelmäßig; 600ms ist entspannt
+const uint8_t  DEADZONE = 10;         // kleine Werte -> 0
+const uint8_t  MIN_PWM  = 70;         // anpassen: 60..110 typisch (gegen "brummen")
 
-// ----------------------------- Pins (ANPASSEN) -----------------------------
-// LEFT BTS7960
-const uint8_t L_LPWM = 5;    // PWM pin
-const uint8_t L_RPWM = 6;    // PWM pin
-const uint8_t L_LEN  = 7;    // enable pin (LEN)
-const uint8_t L_REN  = 8;    // enable pin (REN)
+// Optional: beim Richtungswechsel kurz stoppen (schont Treiber/Getriebe)
+const bool     PROTECT_DIR_CHANGE = true;
+const uint16_t DIR_CHANGE_STOP_MS = 60;
 
-// RIGHT BTS7960
-const uint8_t R_LPWM = 9;    // PWM pin
-const uint8_t R_RPWM = 10;   // PWM pin
-const uint8_t R_LEN  = 11;   // enable pin (LEN)
-const uint8_t R_REN  = 12;   // enable pin (REN)
+int targetL = 0, targetR = 0;
+unsigned long lastCmdMs = 0;
 
-// --------------------------- Tuning / Limits -------------------------------
-// PWM range: 0..255
-const int PWM_MAX = 255;
+int lastOutL = 0, lastOutR = 0;
 
-// Ramp speed: PWM units per second (z.B. 300 => ~0.85s von 0 auf 255)
-const float RAMP_UP_PER_SEC   = 320.0f;
-const float RAMP_DOWN_PER_SEC = 520.0f; // meist darf bremsen/stoppen schneller sein
-
-// Deadband: kleine Werte ignorieren (gegen "Zittern")
-const int INPUT_DEADBAND = 10;
-
-// Watchdog: wenn so lange kein Command kommt -> STOP
-const uint32_t COMMAND_TIMEOUT_MS = 600;
-
-// Loop interval (Ramping arbeitet zeitbasiert; häufig genug aufrufen)
-const uint32_t CONTROL_INTERVAL_MS = 10;
-
-// ---------------------------- State ----------------------------------------
-volatile int targetLeft  = 0;   // -255..255
-volatile int targetRight = 0;   // -255..255
-
-float currentLeft  = 0.0f;      // ramped output -255..255
-float currentRight = 0.0f;
-
-uint32_t lastCmdMs = 0;
-uint32_t lastControlMs = 0;
-
-// ------------------------- Helpers -----------------------------------------
-static int clampInt(int v, int lo, int hi) {
-  if (v < lo) return lo;
-  if (v > hi) return hi;
+static int clamp255(int v) {
+  if (v > 255) return 255;
+  if (v < -255) return -255;
   return v;
 }
 
-static int applyDeadband(int v, int db) {
-  if (abs(v) < db) return 0;
-  return v;
+int applyMinPwm(int v) {
+  v = clamp255(v);
+  int a = abs(v);
+  if (a <= DEADZONE) return 0;
+
+  int s = (v >= 0) ? 1 : -1;
+
+  // map: DEADZONE..255 -> MIN_PWM..255
+  long mapped = MIN_PWM + (long)(a - DEADZONE) * (255 - MIN_PWM) / (255 - DEADZONE);
+  if (mapped > 255) mapped = 255;
+
+  return s * (int)mapped;
 }
 
-// Ramp current towards target based on dt
-static float rampTo(float current, float target, float dtSec) {
-  float diff = target - current;
-  if (diff == 0.0f) return current;
-
-  const float rate = (abs(target) > abs(current)) ? RAMP_UP_PER_SEC : RAMP_DOWN_PER_SEC;
-  float step = rate * dtSec;
-
-  if (abs(diff) <= step) return target;
-  return current + (diff > 0 ? step : -step);
-}
-
-// Send signed speed (-255..255) to one BTS7960
-static void driveBTS7960(uint8_t lpwm, uint8_t rpwm, uint8_t len, uint8_t ren, int speed) {
-  speed = clampInt(speed, -PWM_MAX, PWM_MAX);
-
-  // Enable driver
-  digitalWrite(len, HIGH);
-  digitalWrite(ren, HIGH);
-
-  int pwm = abs(speed);
-
-  // IMPORTANT: never drive both PWM pins at the same time
+void setBTS7960(int speed, uint8_t rpwm, uint8_t lpwm) {
+  speed = clamp255(speed);
   if (speed > 0) {
-    analogWrite(lpwm, pwm);
-    analogWrite(rpwm, 0);
+    analogWrite(rpwm, (uint8_t)speed);
+    analogWrite(lpwm, 0);
   } else if (speed < 0) {
-    analogWrite(lpwm, 0);
-    analogWrite(rpwm, pwm);
-  } else {
-    analogWrite(lpwm, 0);
     analogWrite(rpwm, 0);
+    analogWrite(lpwm, (uint8_t)(-speed));
+  } else {
+    analogWrite(rpwm, 0);
+    analogWrite(lpwm, 0);
   }
 }
 
-static void stopAll() {
-  targetLeft = 0;
-  targetRight = 0;
+bool parseLine(const String& line, int &outL, int &outR) {
+  int idxL = line.indexOf('L');
+  int idxR = line.indexOf('R');
+  if (idxL < 0 || idxR < 0) return false;
+
+  String partL = line.substring(idxL + 1, idxR);
+  String partR = line.substring(idxR + 1);
+  partL.trim(); partR.trim();
+
+  outL = clamp255(partL.toInt());
+  outR = clamp255(partR.toInt());
+  return true;
 }
 
-// Differential drive mixing:
-// throttle: -255..255, turn: -255..255
-static void setMix(int throttle, int turn) {
-  throttle = clampInt(throttle, -PWM_MAX, PWM_MAX);
-  turn     = clampInt(turn,     -PWM_MAX, PWM_MAX);
+void setupPins() {
+  pinMode(L_RPWM, OUTPUT); pinMode(L_LPWM, OUTPUT);
+  pinMode(L_REN, OUTPUT);  pinMode(L_LEN, OUTPUT);
 
-  throttle = applyDeadband(throttle, INPUT_DEADBAND);
-  turn     = applyDeadband(turn,     INPUT_DEADBAND);
+  pinMode(R_RPWM, OUTPUT); pinMode(R_LPWM, OUTPUT);
+  pinMode(R_REN, OUTPUT);  pinMode(R_LEN, OUTPUT);
 
-  // Classic mix
-  int left  = throttle + turn;
-  int right = throttle - turn;
+  digitalWrite(L_REN, HIGH); digitalWrite(L_LEN, HIGH);
+  digitalWrite(R_REN, HIGH); digitalWrite(R_LEN, HIGH);
 
-  // Normalize if exceeds range
-  int maxMag = max(abs(left), abs(right));
-  if (maxMag > PWM_MAX) {
-    // scale down proportionally
-    left  = (int)((float)left  * ((float)PWM_MAX / (float)maxMag));
-    right = (int)((float)right * ((float)PWM_MAX / (float)maxMag));
-  }
-
-  targetLeft = left;
-  targetRight = right;
+  setBTS7960(0, L_RPWM, L_LPWM);
+  setBTS7960(0, R_RPWM, R_LPWM);
 }
 
-// ------------------------- Serial command parser ---------------------------
-// Commands:
-//   f <pwm>   -> forward
-//   b <pwm>   -> backward
-//   l <pwm>   -> turn left (in place)
-//   r <pwm>   -> turn right (in place)
-//   s         -> stop
-//   m <throttle> <turn>  -> mix mode (-255..255 each)
-// Examples:
-//   f 140
-//   m 120 -40
-//   s
-static void handleSerialLine(String line) {
-  line.trim();
-  if (line.length() == 0) return;
+void outputLR(int l, int r) {
+  l = applyMinPwm(l);
+  r = applyMinPwm(r);
 
-  char cmd = tolower(line.charAt(0));
+  if (PROTECT_DIR_CHANGE) {
+    // if sign changes across 0 while moving -> brief stop
+    auto sign = [](int v) -> int { return (v > 0) - (v < 0); };
 
-  // Update watchdog timestamp on any valid-looking input
-  lastCmdMs = millis();
+    bool lFlip = (sign(lastOutL) != 0) && (sign(l) != 0) && (sign(lastOutL) != sign(l));
+    bool rFlip = (sign(lastOutR) != 0) && (sign(r) != 0) && (sign(lastOutR) != sign(r));
 
-  if (cmd == 's') {
-    stopAll();
-    return;
-  }
-
-  // Split by spaces
-  // Simple parsing:
-  // cmd + integers
-  int a = 0, b = 0;
-  int n = 0;
-
-  // Try parse "m a b"
-  if (cmd == 'm') {
-    n = sscanf(line.c_str(), "m %d %d", &a, &b);
-    if (n == 2) {
-      setMix(a, b);
+    if (lFlip || rFlip) {
+      setBTS7960(0, L_RPWM, L_LPWM);
+      setBTS7960(0, R_RPWM, R_LPWM);
+      delay(DIR_CHANGE_STOP_MS);
     }
-    return;
   }
 
-  // Parse "f a" / "b a" / "l a" / "r a"
-  n = sscanf(line.c_str(), "%c %d", &cmd, &a);
-  if (n < 2) return;
+  setBTS7960(l, L_RPWM, L_LPWM);
+  setBTS7960(r, R_RPWM, R_LPWM);
 
-  a = clampInt(a, 0, PWM_MAX);
-
-  switch (tolower(cmd)) {
-    case 'f': setMix(+a, 0); break;
-    case 'b': setMix(-a, 0); break;
-    case 'l': setMix(0, +a); break; // left turn in place
-    case 'r': setMix(0, -a); break; // right turn in place
-    default: break;
-  }
+  lastOutL = l;
+  lastOutR = r;
 }
 
-// ------------------------------ Arduino ------------------------------------
 void setup() {
-  int err = ps2x.config_gamepad(PS2_CLK, PS2_CMD, PS2_ATT, PS2_DAT, false, false);
-  Serial.print("PS2 init: "); Serial.println(err);
-
-  pinMode(L_LPWM, OUTPUT);
-  pinMode(L_RPWM, OUTPUT);
-  pinMode(L_LEN, OUTPUT);
-  pinMode(L_REN, OUTPUT);
-
-  pinMode(R_LPWM, OUTPUT);
-  pinMode(R_RPWM, OUTPUT);
-  pinMode(R_LEN, OUTPUT);
-  pinMode(R_REN, OUTPUT);
-
-  // Init: disabled PWM = 0, enables on
-  analogWrite(L_LPWM, 0); analogWrite(L_RPWM, 0);
-  analogWrite(R_LPWM, 0); analogWrite(R_RPWM, 0);
-
-  digitalWrite(L_LEN, HIGH); digitalWrite(L_REN, HIGH);
-  digitalWrite(R_LEN, HIGH); digitalWrite(R_REN, HIGH);
-
   Serial.begin(115200);
-  Serial.println(F("BTS7960 Robot Control ready."));
-  Serial.println(F("Commands: f/b/l/r <0..255>, m <throttle -255..255> <turn -255..255>, s"));
+  setupPins();
+  delay(200);
+
+  Serial.println(F("Drive Ready. Send: L <val> R <val>  (-255..255)"));
+  Serial.print(F("DEADZONE=")); Serial.print(DEADZONE);
+  Serial.print(F(" MIN_PWM=")); Serial.println(MIN_PWM);
 
   lastCmdMs = millis();
-  lastControlMs = millis();
 }
 
 void loop() {
-  #if USE_PS2
-    // -------- PS2 Controller Input -------
-    ps2x.read_gamepad(false, 0);
-
-    // Not-Stop z.B. START
-    if (ps2x.ButtonPressed(PSB_START)) {
-      stopAll();
-      lastCmdMs = millis();     // watchdog “füttern”
-    }
-
-    // Sticks lesen
-    int ly = ps2x.Analog(PSS_LY);   // 0..255
-    int rx = ps2x.Analog(PSS_RX);   // 0..255
-
-    // 0..255 -> -255..255
-    auto stickToSigned = [](int v) {
-      int x = (v - 128) * 2;
-      if (x > 255) x = 255;
-      if (x < -255) x = -255;
-      return x;
-    };
-
-    // Mapping: LY nach oben = vorwärts (invertieren)
-    int throttle = -stickToSigned(ly);
-    int turn     =  stickToSigned(rx);
-
-    lastCmdMs = millis();       // watchdog “füttern”
-    setMix(throttle, turn);     // das ist dein Original-Mixer
-
-  #else
-  // -------- Serial input (line based) --------
-  static String buf;
   while (Serial.available()) {
-    char c = (char)Serial.read();
-    if (c == '\n' || c == '\r') {
-      if (buf.length() > 0) {
-        handleSerialLine(buf);
-        buf = "";
-      }
+    String line = Serial.readStringUntil('\n');
+    line.trim();
+    if (line.length() == 0) continue;
+
+    int l, r;
+    if (parseLine(line, l, r)) {
+      targetL = l;
+      targetR = r;
+      lastCmdMs = millis();
+
+      outputLR(targetL, targetR);
+
+      Serial.print(F("RX/OUT L=")); Serial.print(lastOutL);
+      Serial.print(F(" R=")); Serial.println(lastOutR);
     } else {
-      // avoid huge line
-      if (buf.length() < 80) buf += c;
+      Serial.println(F("Parse error -> STOP"));
+      targetL = 0; targetR = 0;
+      lastCmdMs = millis();
+      outputLR(0, 0);
     }
   }
-  #ENDIF
 
-  // -------- Watchdog --------
-  if (millis() - lastCmdMs > COMMAND_TIMEOUT_MS) {
-    stopAll();
-  }
-
-  // -------- Control update (ramping + output) --------
-  uint32_t now = millis();
-  if (now - lastControlMs >= CONTROL_INTERVAL_MS) {
-    float dt = (now - lastControlMs) / 1000.0f;
-    lastControlMs = now;
-
-    // ramp current values towards target
-    currentLeft  = rampTo(currentLeft,  (float)targetLeft,  dt);
-    currentRight = rampTo(currentRight, (float)targetRight, dt);
-
-    // apply to drivers
-    driveBTS7960(L_LPWM, L_RPWM, L_LEN, L_REN, (int)round(currentLeft));
-    driveBTS7960(R_LPWM, R_RPWM, R_LEN, R_REN, (int)round(currentRight));
+  // Watchdog stop
+   if (millis() - lastCmdMs > CMD_TIMEOUT_MS) {
+    outputLR(0, 0);
   }
 }
diff --git a/drive/arduino-sketch/arduino-sketch-ps2-controller.ino/arduino-sketch-ps2-controller.ino.ino b/drive/arduino-sketch/arduino-sketch-ps2-controller.ino/arduino-sketch-ps2-controller.ino.ino
deleted file mode 100644
index d54efad..0000000
--- a/drive/arduino-sketch/arduino-sketch-ps2-controller.ino/arduino-sketch-ps2-controller.ino.ino
+++ /dev/null
@@ -1,132 +0,0 @@
-// ===== Arduino UNO: Differential Drive über 2x BTS7960 =====
-// Serial command format: "L <int> R <int>\n"  where int in [-255..255]
-// Soft-start ramping + watchdog stop
-
-// --- Left BTS7960 pins ---
-const uint8_t L_RPWM = 5;   // PWM
-const uint8_t L_LPWM = 6;   // PWM
-const uint8_t L_REN  = 7;   // enable
-const uint8_t L_LEN  = 8;   // enable
-
-// --- Right BTS7960 pins ---
-const uint8_t R_RPWM = 9;   // PWM
-const uint8_t R_LPWM = 10;  // PWM
-const uint8_t R_REN  = 11;  // enable
-const uint8_t R_LEN  = 12;  // enable
-
-// Ramping
-const uint8_t RAMP_STEP = 6;        // speed change per loop (0..255)
-const uint16_t LOOP_MS  = 15;       // ramp update interval
-const uint16_t CMD_TIMEOUT_MS = 300; // stop if no command within x ms
-
-int targetL = 0, targetR = 0;
-int currentL = 0, currentR = 0;
-
-unsigned long lastCmdMs = 0;
-unsigned long lastLoopMs = 0;
-
-void setupPins() {
-  pinMode(L_RPWM, OUTPUT); pinMode(L_LPWM, OUTPUT);
-  pinMode(L_REN, OUTPUT);  pinMode(L_LEN, OUTPUT);
-
-  pinMode(R_RPWM, OUTPUT); pinMode(R_LPWM, OUTPUT);
-  pinMode(R_REN, OUTPUT);  pinMode(R_LEN, OUTPUT);
-
-  digitalWrite(L_REN, HIGH); digitalWrite(L_LEN, HIGH);
-  digitalWrite(R_REN, HIGH); digitalWrite(R_LEN, HIGH);
-
-  analogWrite(L_RPWM, 0); analogWrite(L_LPWM, 0);
-  analogWrite(R_RPWM, 0); analogWrite(R_LPWM, 0);
-}
-
-static int clamp255(int v) {
-  if (v > 255) return 255;
-  if (v < -255) return -255;
-  return v;
-}
-
-void driveOne(int speed, uint8_t rpwm, uint8_t lpwm) {
-  speed = clamp255(speed);
-  if (speed > 0) {
-    analogWrite(rpwm, (uint8_t)speed);
-    analogWrite(lpwm, 0);
-  } else if (speed < 0) {
-    analogWrite(rpwm, 0);
-    analogWrite(lpwm, (uint8_t)(-speed));
-  } else {
-    analogWrite(rpwm, 0);
-    analogWrite(lpwm, 0);
-  }
-}
-
-static int rampTowards(int current, int target, uint8_t step) {
-  if (current < target) {
-    int n = current + step;
-    return (n > target) ? target : n;
-  }
-  if (current > target) {
-    int n = current - step;
-    return (n < target) ? target : n;
-  }
-  return current;
-}
-
-bool parseLine(const String& line, int &outL, int &outR) {
-  // expected: "L <int> R <int>"
-  int idxL = line.indexOf('L');
-  int idxR = line.indexOf('R');
-  if (idxL < 0 || idxR < 0) return false;
-
-  // crude parse; robust enough for our simple format
-  String partL = line.substring(idxL + 1, idxR);
-  String partR = line.substring(idxR + 1);
-
-  partL.trim();
-  partR.trim();
-
-  outL = partL.toInt();
-  outR = partR.toInt();
-  outL = clamp255(outL);
-  outR = clamp255(outR);
-  return true;
-}
-
-void setup() {
-  Serial.begin(115200);
-  setupPins();
-  lastCmdMs = millis();
-  lastLoopMs = millis();
-}
-
-void loop() {
-  // --- read serial lines ---
-  while (Serial.available()) {
-    String line = Serial.readStringUntil('\n');
-    line.trim();
-    if (line.length() == 0) continue;
-
-    int l, r;
-    if (parseLine(line, l, r)) {
-      targetL = l;
-      targetR = r;
-      lastCmdMs = millis();
-    }
-  }
-
-  // --- watchdog stop ---
-  if (millis() - lastCmdMs > CMD_TIMEOUT_MS) {
-    targetL = 0;
-    targetR = 0;
-  }
-
-  // --- ramp update ---
-  if (millis() - lastLoopMs >= LOOP_MS) {
-    lastLoopMs = millis();
-
-    currentL = rampTowards(currentL, targetL, RAMP_STEP);
-    currentR = rampTowards(currentR, targetR, RAMP_STEP);
-
-    driveOne(currentL, L_RPWM, L_LPWM);
-    driveOne(currentR, R_RPWM, R_LPWM);
-  }
-}
diff --git a/drive/var/www/drive/index.html b/drive/var/www/drive/index.html
index 62607f0..98ed111 100644
--- a/drive/var/www/drive/index.html
+++ b/drive/var/www/drive/index.html
@@ -3,12 +3,12 @@
 <head>
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
-  <title>Robot Dual Stick</title>
+  <title>Robot Dual Stick (Ramping)</title>
   <style>
     html, body { height: 100%; margin: 0; background: #0b0f14; color: #e8eef6; font-family: system-ui, -apple-system, Segoe UI, Roboto, Arial; }
-    .wrap { height: 100%; display: grid; grid-template-rows: auto 1fr auto; padding: 14px; gap: 12px; }
+    .wrap { height: 100%; display: grid; grid-template-rows: auto 1fr auto auto; padding: 14px; gap: 12px; }
     .top { display:flex; align-items:center; justify-content:space-between; gap: 10px; }
-    .badge { padding: 8px 12px; border-radius: 999px; background: #152033; font-weight: 700; }
+    .badge { padding: 8px 12px; border-radius: 999px; background: #152033; font-weight: 800; }
     .status { font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; }
 
     .panel { background:#101826; border-radius: 18px; padding: 12px; }
@@ -22,17 +22,22 @@
       user-select: none;
     }
     .stickBox { width: min(46vw, 340px); aspect-ratio: 1/1; }
-    canvas { width: 100%; height: 100%; background:#0f1726; border-radius: 22px; }
+    canvas { width: 100%; height: 100%; background:#0f1726; border-radius: 22px; touch-action: none; }
 
     .row { display:flex; gap: 12px; align-items:center; justify-content:space-between; flex-wrap: wrap; }
-    .btn { padding: 14px 16px; border-radius: 14px; border: 0; background:#1e2b44; color:#fff; font-weight: 800; font-size: 16px; }
+    .btn { padding: 14px 16px; border-radius: 14px; border: 0; background:#1e2b44; color:#fff; font-weight: 900; font-size: 16px; }
     .btn:active { transform: scale(0.98); }
     .btnStop { background:#7a1f2a; }
+    .btnOn { outline: 3px solid rgba(59,130,246,0.7); }
 
-    input[type="range"]{ width: 220px; }
-    .small { opacity: 0.85; font-size: 14px; }
+    input[type="range"]{ width: 240px; }
+    .small { opacity: 0.86; font-size: 14px; }
     .mono { font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; }
     .hint { margin-top: 8px; opacity: 0.85; font-size: 14px; text-align: center; }
+
+    .grid2 { display:grid; grid-template-columns: 1fr 1fr; gap: 10px; }
+    .kv { display:flex; gap:10px; align-items:center; justify-content:space-between; }
+    .kv label { font-weight:800; }
   </style>
 </head>
 <body>
@@ -56,46 +61,180 @@
   </div>
 
   <div class="panel row">
-    <div>
-      <div style="font-weight:900">Max Speed: <span id="maxv">180</span></div>
+    <div style="min-width: 320px;">
+      <div class="kv">
+        <label>Max Speed:</label>
+        <span class="mono"><span id="maxv">180</span></span>
+      </div>
       <input id="max" type="range" min="60" max="255" value="180">
-      <div class="small mono" id="readout">T 0 | Turn 0  →  L 0 | R 0</div>
+
+      <div class="grid2" style="margin-top:12px">
+        <div class="kv">
+          <label>Accel:</label>
+          <span class="mono"><span id="accv">2.2</span>/s</span>
+        </div>
+        <input id="acc" type="range" min="0.8" max="6.0" step="0.1" value="2.2">
+
+        <div class="kv">
+          <label>Decel:</label>
+          <span class="mono"><span id="decv">3.6</span>/s</span>
+        </div>
+        <input id="dec" type="range" min="0.8" max="8.0" step="0.1" value="3.6">
+
+        <div class="kv">
+          <label>Turn:</label>
+          <span class="mono"><span id="turnv">6.0</span>/s</span>
+        </div>
+        <input id="turn" type="range" min="1.0" max="12.0" step="0.1" value="6.0">
+
+        <div class="kv">
+          <label>Expo:</label>
+          <span class="mono"><span id="expov">0.35</span></span>
+        </div>
+        <input id="expo" type="range" min="0.0" max="0.8" step="0.05" value="0.35">
+      </div>
     </div>
-    <div style="display:flex; gap:10px">
+
+    <div style="display:flex; gap:10px; align-items:center; flex-wrap:wrap;">
       <button class="btn" id="btnConnect">Connect</button>
+      <button class="btn" id="btnSlow">SLOW</button>
       <button class="btn btnStop" id="btnStop">STOP</button>
     </div>
   </div>
 
+  <div class="panel small mono" id="readout">
+    target: T 0.00 | Turn 0.00  ||  smooth: T 0.00 | Turn 0.00  ||  L 0 | R 0
+  </div>
+
   <div class="small" style="text-align:center; opacity:0.8">
-    Loslassen = STOP. Wenn Verbindung/Tab weg: STOP (Watchdog).
+    Loslassen = STOP. Tab/Verbindung weg = STOP. (Web sendet laufend, damit Arduino-Watchdog nicht stoppt.)
   </div>
 </div>
 
 <script>
 (() => {
+  // ===== UI refs =====
   const statusEl = document.getElementById('status');
+  const readoutEl = document.getElementById('readout');
+
   const maxEl = document.getElementById('max');
   const maxvEl = document.getElementById('maxv');
-  const readoutEl = document.getElementById('readout');
+
+  const accEl = document.getElementById('acc');
+  const accvEl = document.getElementById('accv');
+
+  const decEl = document.getElementById('dec');
+  const decvEl = document.getElementById('decv');
+
+  const turnRateEl = document.getElementById('turn');
+  const turnvEl = document.getElementById('turnv');
+
+  const expoEl = document.getElementById('expo');
+  const expovEl = document.getElementById('expov');
+
   const btnConnect = document.getElementById('btnConnect');
   const btnStop = document.getElementById('btnStop');
+  const btnSlow = document.getElementById('btnSlow');
 
   const cL = document.getElementById('leftStick');
   const cR = document.getElementById('rightStick');
-  const gL = cL.getContext('2d');
-  const gR = cR.getContext('2d');
 
+  // ===== WebSocket =====
   let ws = null;
   let connected = false;
 
-  // Stick states (normalized)
-  // Left stick: throttle in [-1..1] (up = +1)
-  // Right stick: turn in [-1..1] (right = +1)
+  function setStatus(txt, ok=false){
+    statusEl.textContent = txt;
+    statusEl.style.background = ok ? "#16331d" : "#3a1a1a";
+  }
+
+  function connect(){
+    if (connected) return;
+    const proto = (location.protocol === "https:") ? "wss" : "ws";
+    const url = `${proto}://${location.host}/drive-ws`; // <— NGINX path
+    ws = new WebSocket(url);
+
+    ws.onopen = () => { connected = true; setStatus("online", true); };
+    ws.onclose = () => { connected = false; setStatus("offline", false); hardStop(); };
+    ws.onerror = () => { connected = false; setStatus("error", false); hardStop(); };
+    ws.onmessage = () => {};
+  }
+
+  btnConnect.addEventListener('click', connect);
+
+  // ===== Control state =====
+  // Targets come directly from sticks
+  let throttleTarget = 0; // -1..+1 (up = +)
+  let turnTarget = 0;     // -1..+1 (right = +)
+
+  // Smoothed (ramped) values
   let throttle = 0;
   let turn = 0;
 
-  // For touch handling
+  // last motor outputs
+  let lastL = 0, lastR = 0;
+
+  // slow mode
+  let slowMode = false;
+  btnSlow.addEventListener('click', () => {
+    slowMode = !slowMode;
+    btnSlow.classList.toggle('btnOn', slowMode);
+  });
+
+  // ===== Helpers =====
+  function clamp(v, a, b){ return Math.max(a, Math.min(b, v)); }
+
+  // Expo curve: 0 = linear, higher = finer around center
+  // Returns in [-1..1]
+  function expo(v, e){
+    v = clamp(v, -1, 1);
+    e = clamp(e, 0, 0.95);
+    // cubic blend
+    return (1 - e) * v + e * v * v * v;
+  }
+
+  // Differential mix: throttle + turn -> left/right in [-1..1]
+  function mix(th, tr){
+    let l = th + tr;
+    let r = th - tr;
+    const m = Math.max(1, Math.abs(l), Math.abs(r));
+    return { l: l / m, r: r / m };
+  }
+
+  function stepTowards(cur, target, maxDelta){
+    const d = target - cur;
+    if (Math.abs(d) <= maxDelta) return target;
+    return cur + Math.sign(d) * maxDelta;
+  }
+
+  // Send helper with simple rate limit (force bypasses)
+  let lastSendMs = 0;
+  function sendLR(l, r, force=false){
+    if (!connected) return;
+    const now = performance.now();
+    if (!force && (now - lastSendMs < 35)) return; // ~28Hz max
+    lastSendMs = now;
+
+    try { ws.send(JSON.stringify({ l, r })); } catch(e) {}
+  }
+
+  function hardStop(){
+    throttleTarget = 0; turnTarget = 0;
+    throttle = 0; turn = 0;
+    lastL = 0; lastR = 0;
+    sendLR(0, 0, true);
+    leftStick.reset();
+    rightStick.reset();
+    renderReadout();
+  }
+
+  btnStop.addEventListener('click', hardStop);
+
+  document.addEventListener("visibilitychange", () => {
+    if (document.hidden) hardStop();
+  });
+
+  // ===== Stick widgets =====
   function makeStick(canvas, mode /* 'throttle' or 'turn' */) {
     const ctx = canvas.getContext('2d');
     const cx = canvas.width / 2;
@@ -105,8 +244,6 @@
     let active = false;
     let px = cx, py = cy;
 
-    function clamp(v, a, b){ return Math.max(a, Math.min(b, v)); }
-
     function pointerPos(evt){
       const r = canvas.getBoundingClientRect();
       return {
@@ -115,23 +252,61 @@
       };
     }
 
-    function apply(nx, ny) {
-      // nx, ny in [-1..1] where ny is +down
+    function draw(){
+      ctx.clearRect(0,0,canvas.width,canvas.height);
+
+      // base circle
+      ctx.lineWidth = 10;
+      ctx.strokeStyle = "#24324d";
+      ctx.beginPath();
+      ctx.arc(cx, cy, radius, 0, Math.PI*2);
+      ctx.stroke();
+
+      // crosshair
+      ctx.lineWidth = 4;
+      ctx.strokeStyle = "#1c263b";
+      ctx.beginPath();
+      ctx.moveTo(cx, cy - radius); ctx.lineTo(cx, cy + radius);
+      ctx.moveTo(cx - radius, cy); ctx.lineTo(cx + radius, cy);
+      ctx.stroke();
+
+      // mode line
+      ctx.lineWidth = 6;
+      ctx.strokeStyle = "#152033";
+      ctx.beginPath();
       if (mode === 'throttle') {
-        // Up should be +throttle, so invert ny
-        throttle = clamp(-ny, -1, 1);
+        ctx.moveTo(cx, cy - radius); ctx.lineTo(cx, cy + radius);
       } else {
-        turn = clamp(nx, -1, 1);
+        ctx.moveTo(cx - radius, cy); ctx.lineTo(cx + radius, cy);
+      }
+      ctx.stroke();
+
+      // knob
+      ctx.fillStyle = "#3b82f6";
+      ctx.beginPath();
+      ctx.arc(px, py, canvas.width*0.065, 0, Math.PI*2);
+      ctx.fill();
+
+      // inner dot
+      ctx.fillStyle = "#0b0f14";
+      ctx.beginPath();
+      ctx.arc(px, py, canvas.width*0.03, 0, Math.PI*2);
+      ctx.fill();
+    }
+
+    function apply(nx, ny){
+      // nx,ny in [-1..1], ny is +down
+      if (mode === 'throttle') {
+        throttleTarget = clamp(-ny, -1, 1); // up = +
+      } else {
+        turnTarget = clamp(nx, -1, 1);      // right = +
       }
     }
 
-    function stopSelf() {
+    function reset(){
       active = false;
       px = cx; py = cy;
-      if (mode === 'throttle') throttle = 0;
-      if (mode === 'turn') turn = 0;
       draw();
-      updateAndSend(true);
     }
 
     function onDown(evt){
@@ -144,9 +319,11 @@
     function onMove(evt){
       if (!active) return;
       evt.preventDefault();
+
       const p = pointerPos(evt);
       const dx = p.x - cx;
       const dy = p.y - cy;
+
       const dist = Math.hypot(dx, dy);
       const k = dist > radius ? (radius / dist) : 1;
 
@@ -158,12 +335,16 @@
 
       apply(nx, ny);
       draw();
-      updateAndSend(false);
     }
 
     function onUp(evt){
       evt.preventDefault();
-      stopSelf();
+      active = false;
+      px = cx; py = cy;
+      // Release = target back to 0 for that axis
+      if (mode === 'throttle') throttleTarget = 0;
+      if (mode === 'turn') turnTarget = 0;
+      draw();
     }
 
     canvas.addEventListener('pointerdown', onDown);
@@ -172,157 +353,77 @@
     canvas.addEventListener('pointercancel', onUp);
     canvas.addEventListener('contextmenu', e => e.preventDefault());
 
-    function drawBase() {
-      ctx.clearRect(0,0,canvas.width,canvas.height);
-
-      // Outer circle
-      ctx.lineWidth = 10;
-      ctx.strokeStyle = "#24324d";
-      ctx.beginPath();
-      ctx.arc(cx, cy, radius, 0, Math.PI*2);
-      ctx.stroke();
-
-      // Crosshair
-      ctx.lineWidth = 4;
-      ctx.strokeStyle = "#1c263b";
-      ctx.beginPath();
-      ctx.moveTo(cx, cy - radius); ctx.lineTo(cx, cy + radius);
-      ctx.moveTo(cx - radius, cy); ctx.lineTo(cx + radius, cy);
-      ctx.stroke();
-
-      // Mode hint line
-      ctx.lineWidth = 6;
-      ctx.strokeStyle = "#152033";
-      ctx.beginPath();
-      if (mode === 'throttle') {
-        ctx.moveTo(cx, cy - radius); ctx.lineTo(cx, cy + radius);
-      } else {
-        ctx.moveTo(cx - radius, cy); ctx.lineTo(cx + radius, cy);
-      }
-      ctx.stroke();
-    }
-
-    function drawKnob() {
-      // Knob
-      ctx.fillStyle = "#3b82f6";
-      ctx.beginPath();
-      ctx.arc(px, py, canvas.width*0.065, 0, Math.PI*2);
-      ctx.fill();
-
-      // Inner dot
-      ctx.fillStyle = "#0b0f14";
-      ctx.beginPath();
-      ctx.arc(px, py, canvas.width*0.03, 0, Math.PI*2);
-      ctx.fill();
-    }
-
-    function draw(){
-      drawBase();
-      drawKnob();
-    }
-
     draw();
-    return { draw, stopSelf };
+    return { reset };
   }
 
-  function setStatus(txt, ok=false){
-    statusEl.textContent = txt;
-    statusEl.style.background = ok ? "#16331d" : "#3a1a1a";
+  const leftStick = makeStick(cL, 'throttle');
+  const rightStick = makeStick(cR, 'turn');
+
+  // ===== UI sliders text =====
+  function refreshLabels(){
+    maxvEl.textContent = maxEl.value;
+    accvEl.textContent = accEl.value;
+    decvEl.textContent = decEl.value;
+    turnvEl.textContent = turnRateEl.value;
+    expovEl.textContent = expoEl.value;
+  }
+  [maxEl, accEl, decEl, turnRateEl, expoEl].forEach(el => el.addEventListener('input', refreshLabels));
+  refreshLabels();
+
+  // ===== Main control loop (RAMPING happens HERE) =====
+  function renderReadout(){
+    readoutEl.textContent =
+      `target: T ${throttleTarget.toFixed(2)} | Turn ${turnTarget.toFixed(2)}  ||  ` +
+      `smooth: T ${throttle.toFixed(2)} | Turn ${turn.toFixed(2)}  ||  ` +
+      `L ${lastL} | R ${lastR}`;
   }
 
-  function clamp(v, a, b){ return Math.max(a, Math.min(b, v)); }
+  let lastTick = performance.now();
 
-  // Mix throttle + turn to left/right [-1..1]
-  function mix(throttle, turn) {
-    let l = throttle + turn;
-    let r = throttle - turn;
-
-    // normalize to keep within [-1..1]
-    const m = Math.max(1, Math.abs(l), Math.abs(r));
-    l /= m; r /= m;
-    return { l, r };
-  }
-
-  let lastSend = 0;
-  let lastL = 0, lastR = 0;
-
-  function sendLR(l, r, force=false){
+  setInterval(() => {
     const now = performance.now();
-    if (!connected) return;
-    if (!force && (now - lastSend < 35)) return; // ~28Hz
-    lastSend = now;
+    const dt = Math.max(0.001, (now - lastTick) / 1000);
+    lastTick = now;
 
-    try { ws.send(JSON.stringify({l, r})); } catch(e) {}
-  }
+    // rates from UI
+    const ACCEL_PER_SEC = parseFloat(accEl.value);
+    const DECEL_PER_SEC = parseFloat(decEl.value);
+    const TURN_PER_SEC  = parseFloat(turnRateEl.value);
+    const EXPO          = parseFloat(expoEl.value);
 
-  function updateAndSend(force) {
-    const maxSpeed = parseInt(maxEl.value, 10);
-    const m = mix(throttle, turn);
+    // ramp throttle
+    const rateT = (Math.abs(throttleTarget) > Math.abs(throttle)) ? ACCEL_PER_SEC : DECEL_PER_SEC;
+    throttle = stepTowards(throttle, throttleTarget, rateT * dt);
 
-    const L = Math.round(clamp(m.l, -1, 1) * maxSpeed);
-    const R = Math.round(clamp(m.r, -1, 1) * maxSpeed);
+    // ramp turn
+    turn = stepTowards(turn, turnTarget, TURN_PER_SEC * dt);
+
+    // apply expo AFTER ramp (feels nicer)
+    const th = expo(throttle, EXPO);
+    const tr = expo(turn, EXPO);
+
+    // mix
+    let { l, r } = mix(th, tr);
+
+    // scale
+    let maxSpeed = parseInt(maxEl.value, 10);
+    if (slowMode) maxSpeed = Math.round(maxSpeed * 0.45);
+
+    const L = Math.round(clamp(l, -1, 1) * maxSpeed);
+    const R = Math.round(clamp(r, -1, 1) * maxSpeed);
 
     lastL = L; lastR = R;
-    readoutEl.textContent = `T ${throttle.toFixed(2)} | Turn ${turn.toFixed(2)}  →  L ${L} | R ${R}`;
+    renderReadout();
 
-    // sendLR(L, R, force);
+    // always send with a gentle cap (force keeps Arduino alive)
+    // This is both "control output" and heartbeat.
+    sendLR(L, R, true);
+  }, 20); // 50 Hz smoothing + sending
 
-    // ---- Heartbeat: keep sending current values while driving ----
-    setInterval(() => {
-      // wenn nicht verbunden -> nix
-      if (!connected) return;
-
-      // Wenn du NUR beim aktiven Fahren senden willst:
-      const driving = (Math.abs(throttle) > 0.02) || (Math.abs(turn) > 0.02);
-
-      if (driving) {
-        // erzwinge Senden auch wenn sich nichts geändert hat
-        sendLR(lastL, lastR, true);
-      }
-}, 400); // 40 Hz
-
-  }
-
-  function hardStop() {
-    throttle = 0; turn = 0;
-    updateAndSend(true);
-    left.stopSelf();
-    right.stopSelf();
-  }
-
-  function connect(){
-    if (connected) return;
-    const proto = (location.protocol === "https:") ? "wss" : "ws";
-    const url = `${proto}://${location.host}/drive-ws`;
-    ws = new WebSocket(url);
-
-    ws.onopen = () => { connected = true; setStatus("online", true); updateAndSend(true); };
-    ws.onclose = () => { connected = false; setStatus("offline", false); hardStop(); };
-    ws.onerror = () => { connected = false; setStatus("error", false); hardStop(); };
-    ws.onmessage = () => {};
-  }
-
-  btnConnect.addEventListener('click', connect);
-  btnStop.addEventListener('click', hardStop);
-
-  maxEl.addEventListener('input', () => {
-    maxvEl.textContent = maxEl.value;
-    updateAndSend(true);
-  });
-
-  // Create sticks
-  const left = makeStick(cL, 'throttle');
-  const right = makeStick(cR, 'turn');
-
-  // Auto-connect
+  // ===== Start =====
   connect();
   setStatus("connecting...", false);
-
-  // Safety: stop when page hidden
-  document.addEventListener("visibilitychange", () => {
-    if (document.hidden) hardStop();
-  });
-
 })();
 </script>
 </body>