feat: robust pairing flow + motion v3 (Kalman) + debounced UI saves

Pairing flow (PR-A):
- mesh.c broadcasts MSG_PAIR every 1s while pairing window open
- Asymmetric pairing: receiving MSG_PAIR auto-opens own window — clicking
  Pair on either device pulls the other in (no need to tap both)
- mesh_identify(mac) unicasts MSG_IDENTIFY; recipient blinks status LED
  at 10 Hz for 5 s so users can physically locate which board is which
- Coordinator election now has 5 s hysteresis — prevents brief flap when
  a single heartbeat is dropped
- mesh_event_cb_t: peer-joined / pairing-opened/closed / identify-requested
  events surface to main.c which drives the status LED reactions
- POST /api/mesh/identify {mac} endpoint
- GET /api/mesh now returns pairing/pairing_ms_left/my_mac for live UI
  countdown and self-vs-peer card highlighting

Status LED:
- New STATUS_LED_PAIRING (5 Hz) and STATUS_LED_IDENTIFY (10 Hz) patterns
- status_led_oneshot(pattern, ms) — temporary pattern with auto-revert
  to last stable pattern; identify becomes one line in main.c

Button (new component):
- Polling-based long-press detector (50 Hz, 40 ms debounce)
- 3 s long-press → mesh_open_pairing(); 10 s reserved for v6.1 factory reset

Motion v3 (PR-B):
- New motion_kalman.{c,h}: 1-D Kalman over [position, velocity], energy-
  aware observation noise (R *= 4 when energy < 30), ±200 cm/s velocity
  clamp, 3-sample direction hysteresis
- motion.c integrates: motion.mode NVS string ("kalman" default | "pi"),
  motion.resp 0..100 (Calm⇄Snappy), motion.la_ms 0..500, motion.outl 0/1/2
  (Off / median-3 / median-7); legacy ps/vs/pf/pg/ig kept as advanced
- motion_reload() called by /api/settings POST so changes apply live

Frontend:
- ScreenMesh: SVG circular pairing countdown, per-peer Identify button
  with "Blinking…" 5 s cooldown, self-card highlight
- ScreenMotion: Algorithm picker (Kalman/Legacy PI), Response slider with
  context-aware hint text, Look-ahead-ms slider, Outlier segmented control,
  collapsible Advanced (5 PI knobs)
- New atoms icons: link, plus, search

Debounced saves (fixes ERR_CONNECTION_RESET):
- useDebouncedSave hook: 300 ms tail; coalesces multiple slider changes
  into one POST /api/settings batch. Fixes the C3-single-core httpd
  saturation when sliders fired ~30 POST/s during drag (verified with
  50× rapid POST stress test — all 200 OK)

Verified: idf.py build green; ambisense.bin 1.17 MB / 1.4 MB partition
(18% free); both C3s flashed; /api/mesh, /api/settings round-trip works.

Author: Ravi Singh

firmware/components/button/CMakeLists.txt

@@ -0,0 +1,5 @@
+idf_component_register(
+    SRCS "button.c"
+    INCLUDE_DIRS "include"
+    REQUIRES driver log freertos esp_timer
+)

firmware/components/button/button.c

@@ -0,0 +1,108 @@
+#include "button.h"
+
+#include "driver/gpio.h"
+#include "esp_log.h"
+#include "esp_timer.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+static const char *TAG = "button";
+
+#define POLL_MS         20
+#define DEBOUNCE_MS     40
+#define LONG_MS         3000
+#define VERYLONG_MS     10000
+
+static struct {
+    uint8_t           gpio;
+    bool              active_low;
+    button_event_cb_t cb;
+} s_b;
+
+static inline bool read_pressed(void) {
+    int level = gpio_get_level(s_b.gpio);
+    return s_b.active_low ? (level == 0) : (level != 0);
+}
+
+static void button_task(void *arg) {
+    (void)arg;
+    bool pressed = false;
+    uint64_t press_started_us = 0;
+    int debounce_ticks = 0;
+    bool fired_long = false;
+    bool fired_verylong = false;
+
+    while (1) {
+        bool now_pressed = read_pressed();
+
+        if (now_pressed != pressed) {
+            /* Edge detected — but don't trust it until DEBOUNCE_MS of
+             * matching reads have stacked up. Counter approach is simpler
+             * (and has identical effect to) a 40-ms blocking sleep. */
+            debounce_ticks += POLL_MS;
+            if (debounce_ticks >= DEBOUNCE_MS) {
+                pressed = now_pressed;
+                debounce_ticks = 0;
+                if (pressed) {
+                    press_started_us = (uint64_t)esp_timer_get_time();
+                    fired_long = false;
+                    fired_verylong = false;
+                    ESP_LOGD(TAG, "press start");
+                } else {
+                    /* Released — fire short if no long fired. */
+                    uint64_t held_ms = ((uint64_t)esp_timer_get_time() - press_started_us) / 1000ULL;
+                    ESP_LOGI(TAG, "press end after %llu ms", (unsigned long long)held_ms);
+                    if (!fired_long && !fired_verylong && held_ms < LONG_MS && held_ms >= 50) {
+                        if (s_b.cb) s_b.cb(BUTTON_PRESS_SHORT);
+                    }
+                }
+            }
+        } else {
+            debounce_ticks = 0;
+            /* While held, fire long/verylong on threshold crossing. */
+            if (pressed && !fired_long) {
+                uint64_t held_ms = ((uint64_t)esp_timer_get_time() - press_started_us) / 1000ULL;
+                if (held_ms >= LONG_MS) {
+                    fired_long = true;
+                    ESP_LOGI(TAG, "long press @ %llu ms", (unsigned long long)held_ms);
+                    if (s_b.cb) s_b.cb(BUTTON_PRESS_LONG);
+                }
+            }
+            if (pressed && fired_long && !fired_verylong) {
+                uint64_t held_ms = ((uint64_t)esp_timer_get_time() - press_started_us) / 1000ULL;
+                if (held_ms >= VERYLONG_MS) {
+                    fired_verylong = true;
+                    ESP_LOGI(TAG, "very-long press @ %llu ms", (unsigned long long)held_ms);
+                    if (s_b.cb) s_b.cb(BUTTON_PRESS_VERYLONG);
+                }
+            }
+        }
+
+        vTaskDelay(pdMS_TO_TICKS(POLL_MS));
+    }
+}
+
+esp_err_t button_init(uint8_t gpio_num, bool active_low, button_event_cb_t cb) {
+    s_b.gpio = gpio_num;
+    s_b.active_low = active_low;
+    s_b.cb = cb;
+
+    gpio_config_t cfg = {
+        .pin_bit_mask = 1ULL << gpio_num,
+        .mode = GPIO_MODE_INPUT,
+        .pull_up_en   = active_low ? GPIO_PULLUP_ENABLE   : GPIO_PULLUP_DISABLE,
+        .pull_down_en = active_low ? GPIO_PULLDOWN_DISABLE : GPIO_PULLDOWN_ENABLE,
+        .intr_type = GPIO_INTR_DISABLE,
+    };
+    esp_err_t err = gpio_config(&cfg);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "gpio_config(%u) failed: 0x%x", gpio_num, err);
+        return err;
+    }
+
+    BaseType_t ok = xTaskCreate(button_task, "button", 2048, NULL, 4, NULL);
+    if (ok != pdPASS) return ESP_ERR_NO_MEM;
+
+    ESP_LOGI(TAG, "button on GPIO %u (active_%s)", gpio_num, active_low ? "low" : "high");
+    return ESP_OK;
+}

firmware/components/button/include/button.h

@@ -0,0 +1,43 @@
+#pragma once
+
+/*
+ * AmbiSense v6 — physical button driver.
+ *
+ * Single-button polling driver designed for the C3 SuperMini's BOOT
+ * button (GPIO 9, active-low, internal pull-up). Drives three callbacks:
+ *
+ *   short  — press < 1 s. Could be used for "toggle LEDs" later; unused
+ *            in v6.0.
+ *   long   — press >= 3 s. Wired to mesh_open_pairing(): the standard
+ *            "physically pair this device" gesture.
+ *   verylong — press >= 10 s. Wired to factory reset (TODO; not in v6.0).
+ *
+ * Polled at 50 Hz from a tiny dedicated task. Polling beats GPIO ISRs for
+ * mechanical buttons because the state machine inherently debounces — a
+ * spurious 1 ms blip simply doesn't survive across two 20 ms samples.
+ */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "esp_err.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    BUTTON_PRESS_SHORT     = 1,
+    BUTTON_PRESS_LONG      = 2,    /* >= 3 s */
+    BUTTON_PRESS_VERYLONG  = 3,    /* >= 10 s */
+} button_event_t;
+
+typedef void (*button_event_cb_t)(button_event_t evt);
+
+/* Initialize and start the polling task. `gpio_num` is the button pin;
+ * `active_low` true means the button reads 0 when pressed (default for
+ * BOOT-style pull-up wiring). */
+esp_err_t button_init(uint8_t gpio_num, bool active_low, button_event_cb_t cb);
+
+#ifdef __cplusplus
+}
+#endif

firmware/components/mesh/include/mesh.h

@@ -52,9 +52,30 @@ typedef struct {
 esp_err_t mesh_init(void);
 
 /* Open a 30 s pairing window during which new peers' broadcasts are
- * accepted. */
+ * accepted. While the window is open this device also broadcasts a
+ * MSG_PAIR beacon every second; any peer that receives it auto-opens
+ * its own window (asymmetric pairing). */
 esp_err_t mesh_open_pairing(void);
 
+/* Window introspection — used by the UI to render a live countdown. */
+bool mesh_in_pairing(void);
+uint32_t mesh_pairing_remaining_ms(void);
+
+/* Send a unicast MSG_IDENTIFY to `mac`. The recipient blinks its status
+ * LED at 10 Hz for ~5 s so the user can physically locate it. */
+esp_err_t mesh_identify(const uint8_t mac[6]);
+
+/* Events the mesh layer emits to its consumer (main.c wires this so the
+ * status LED can react). Currently: peer joined, identify-me received. */
+typedef enum {
+    MESH_EVT_PEER_JOINED       = 1,
+    MESH_EVT_IDENTIFY_REQUESTED = 2,
+    MESH_EVT_PAIRING_OPENED    = 3,
+    MESH_EVT_PAIRING_CLOSED    = 4,
+} mesh_event_t;
+typedef void (*mesh_event_cb_t)(mesh_event_t evt, const uint8_t mac[6]);
+void mesh_set_event_cb(mesh_event_cb_t cb);
+
 /* Snapshot of currently-known peers (live + stale). Returns count. */
 size_t mesh_peers_snapshot(mesh_peer_t *out, size_t max);