fix(motion): debounce direction chip — 10 cm/s threshold, 200 ms commit

The Live tab's direction chip (still / closer → / away →) was flipping
every 200 ms or so even when the target was stationary. Cause: the
Kalman direction logic used a 4 cm/s velocity threshold + a 3-tick
(60 ms) hysteresis, which is far below the LD2450's noise floor.
Breathing-level sway easily crossed 4 cm/s, the chip flipped, layout
felt twitchy.

- Velocity threshold raised 4 → 10 cm/s. Whatever the radar's noise
  floor is, the velocity threshold needs a healthy multiple over it;
  10 cm/s gives ~5x headroom over LD2450's ±5–10 cm position noise
  amplified to velocity by the Kalman filter.
- Direction commit count raised 3 → 10 ticks (motion task @ 50 Hz, so
  60 ms → 200 ms). 200 ms feels deliberate, doesn't lag for genuine
  movement, but rejects breathing/sway-level blips.
- PI mode threshold also bumped 4 → 10 cm/s. PI has no agreement-count
  hysteresis (legacy v5 path), so threshold is the only knob there.

Bench-tested on the same C3 + LD2450: chip now sits stably on "still"
during normal standing-around behaviour, flips to "closer →" / "away →"
within ~200 ms of a deliberate step.

Author: Ravi Singh

firmware/components/motion/motion.c

@@ -133,8 +133,8 @@ static void run_pi(float filtered_raw, float dt, target_t *t) {
     t->distance_cm = (int16_t)final_d;
     /* PI mode reports raw sensor direction; smoothed velocity sign is
      * noisy near zero, so users get cleaner direction in Kalman mode. */
-    if (s_m.velocity > 4.f) t->direction = 1;
-    else if (s_m.velocity < -4.f) t->direction = -1;
+    if (s_m.velocity > 10.f) t->direction = 1;
+    else if (s_m.velocity < -10.f) t->direction = -1;
 }
 
 static void run_kalman(float filtered_raw, uint8_t energy, float dt, target_t *t) {
@@ -144,9 +144,13 @@ static void run_kalman(float filtered_raw, uint8_t energy, float dt, target_t *t
     if (predicted < s_m.min_cm) predicted = s_m.min_cm;
     if (predicted > s_m.max_cm) predicted = s_m.max_cm;
     t->distance_cm = (int16_t)predicted;
-    /* Direction with hysteresis. 4 cm/s threshold: below this we treat the
-     * target as stationary (returns 0). */
-    t->direction = kalman_direction(&s_m.kf, vel, 4.f);
+    /* Direction with hysteresis. 10 cm/s threshold: below this we treat the
+     * target as stationary. Bumped from 4 cm/s on 2026-05-07 — at 4 cm/s,
+     * a stationary person's breathing-level sway easily crossed the
+     * threshold and the chip flipped between still/closer/away every
+     * ~200 ms. 10 cm/s requires actual deliberate movement to register,
+     * which is what users perceive as "moving" anyway. */
+    t->direction = kalman_direction(&s_m.kf, vel, 10.f);
 }
 
 static void motion_task(void *arg) {

firmware/components/motion/motion_kalman.c

@@ -93,16 +93,21 @@ int8_t kalman_direction(kalman_t *k, float vel, float vel_threshold_cm_s) {
         k->dir_agree = 0;
         return k->dir_committed;
     }
-    /* Different from committed → require 3 in a row to flip. This kills
-     * the per-tick direction jitter that radar produces near zero
-     * crossings (where the smoothed velocity oscillates around 0). */
+    /* Different from committed → require N consecutive ticks to flip.
+     * The motion task ticks at ~50 Hz, so each agree count is ~20 ms.
+     * Bumped from 3 (60 ms) to 10 (200 ms) on 2026-05-07 — at 3, a
+     * brief velocity blip from breathing or jitter would flip the
+     * chip; 200 ms requires the user to be genuinely moving for ~⅕ s
+     * before the indicator commits. Combined with the 10 cm/s
+     * velocity threshold (raised from 4 cm/s), this kills the rapid
+     * still ↔ closer ↔ away oscillation users were seeing. */
     if (sign == k->dir_pending) {
         if (k->dir_agree < 255) k->dir_agree++;
     } else {
         k->dir_pending = sign;
         k->dir_agree = 1;
     }
-    if (k->dir_agree >= 3) {
+    if (k->dir_agree >= 10) {
         k->dir_committed = k->dir_pending;
         k->dir_agree = 0;
     }