glasscalibur-product.yaml

# =============================================================================
# Glasscalibur — ESPHome firmware
# =============================================================================
#
# A Wi-Fi connected window-cover controller that drives a NEMA stepper motor
# via a TMC2209 driver, with physical end-stop limit switches at both ends of
# travel for absolute position calibration. Control it via a browser at
# http://glasscalibur-XXXXXX.local (where XXXXXX is the last 3 bytes of the
# device's MAC, printed on the serial log at boot). No Home Assistant
# required. Can also pair with Home Assistant over the native ESPHome API.
#
# -----------------------------------------------------------------------------
# Hardware
# -----------------------------------------------------------------------------
#   MCU       : ESP32-C6-MINI-1 (esp-idf framework, USB-Serial-JTAG console)
#   Driver    : TMC2209 stepper driver, single-wire UART control (PDN_UART)
#   Motor     : NEMA stepper, 8x microstepping = 1600 steps/rev
#   End stops : two physical limit switches (one at each end of travel)
#   Sensors   : TMP1075 motor temperature (I2C 0x49) — auto-stops at >80 °C
#               LIS2DH12 accelerometer (I2C 0x19) — anti-tamper + vib stall
#   Buzzer    : passive piezo on a ledc PWM output (tamper alarm)
#
# -----------------------------------------------------------------------------
# GPIO wiring
# -----------------------------------------------------------------------------
#   GPIO0  : UART RX   <- TMC2209 PDN_UART
#   GPIO1  : UART TX   -> TMC2209 PDN_UART
#   GPIO3  : Close-end limit switch (active low, polled)
#   GPIO5  : Buzzer (ledc output)
#   GPIO6  : INDEX     (TMC2209 step-counter output, informational)
#   GPIO8  : ENN       (TMC2209 enable, active low)
#   GPIO14 : DIAG      (TMC2209 StallGuard / fault output -> on_stall)
#   GPIO15 : Open-end limit switch (active low, polled)
#   GPIO21 : Calibration / Wi-Fi Reset button (active low; 7 quick presses =
#            auto-calibrate, hold 3-10 s to clear Wi-Fi creds — the timings
#            must never overlap)
#   GPIO19 : I2C SDA
#   GPIO20 : I2C SCL
#   GPIO23 : Button 1 (active low; single/double click)
#
# -----------------------------------------------------------------------------
# Position / motion model
# -----------------------------------------------------------------------------
#   Steps are the canonical position unit. The cover entity reports position
#   as a 0..1 ratio of current_position / max_distance_steps:
#
#       position = current_position / max_distance_steps     (0.0 .. 1.0)
#
#   max_distance_steps is a compile-time substitution (see `substitutions:`
#   below) that defines the full travel between limits. Hitting a limit
#   switch re-calibrates the stepper to a known absolute position (0 at the
#   close end, max_distance_steps at the open end), correcting any drift.
#   Position is persisted to flash at every IDLE transition so the cover
#   survives reboots without re-homing.
#
# -----------------------------------------------------------------------------
# State machine (global_state, mirrored to the "State" text_sensor)
# -----------------------------------------------------------------------------
#   0 = IDLE      no motion in progress
#   1 = OPENING   driving toward max_distance_steps
#   2 = CLOSING   driving toward 0
#   3 = TAMPERED  tamper detected; alarm active or pending acknowledgement
#
#   OPENING/CLOSING return to IDLE via the 200 ms motion-completion poll,
#   any cover stop_action (limit switch, temperature cutoff, manual stop),
#   or the TMC2209 on_stall handler. TAMPERED is a *soft indicator* —
#   subsequent motion commands override it; it only returns to IDLE on
#   explicit acknowledgement (Button 1 single-click, "Clear Tamper Alert",
#   or "Set Tamper Baseline").
#
# -----------------------------------------------------------------------------
# Buttons (physical, on the device)
# -----------------------------------------------------------------------------
#   Button 1 (GPIO23):
#     - Single click  : CALIBRATING     -> abort calibration (works even with
#                                          Child Lock on — stopping an
#                                          autonomous sequence is a safety
#                                          control, never lockable)
#                       TAMPERED        -> silence alarm + return to IDLE
#                       OPENING/CLOSING -> stop motor
#                       IDLE            -> close the cover
#     - Double click  : open the cover (ignored while calibrating)
#   Calibration / WiFi Reset (GPIO21):
#     - 7 quick clicks: start auto-calibration (see the auto_calibrate script)
#     - Hold 3-10 s   : clear saved Wi-Fi credentials and reboot into setup
#
# -----------------------------------------------------------------------------
# Anti-tamper (accelerometer-based)
# -----------------------------------------------------------------------------
#   The LIS2DH12 establishes a "rest orientation" baseline (stored in g;
#   live m/s² readings are normalized before comparing). While IDLE, a
#   1 s interval compares live x/y/z to the baseline; if Euclidean distance
#   exceeds the Tamper Threshold, the device enters TAMPERED state, latches
#   "Tamper Detected", and pulses the buzzer for 60 s. The alarm dismisses
#   via Button 1 single-click, "Clear Tamper Alert", or "Set Tamper Baseline"
#   (which also captures a new baseline at the current position).
#
#   Off by default. Turning the "Tamper Detection" switch ON auto-captures
#   the current accel reading as the baseline — no separate Set Baseline
#   press needed.
#
# -----------------------------------------------------------------------------
# Vibration-based stall (secondary to TMC2209 StallGuard)
# -----------------------------------------------------------------------------
#   While OPENING/CLOSING, a 200 ms interval samples
#       vibration = |sqrt(x² + y² + z²)/9.80665 - 1|   [g]
#   from the accelerometer — an orientation-independent measure of non-gravity
#   acceleration. UNITS MATTER: the LIS2DH12 sensors publish m/s² (ESPHome
#   convention) while every threshold in this config is in g — each consumer
#   divides by 9.80665 before comparing. If vibration exceeds Vibration
#   Threshold for Vibration Stall Samples distinct sensor samples, the same
#   stop+IDLE+save-position path runs as on_stall. Auto-calibration tunes the
#   threshold; or tune by watching the Accel X/Y/Z sensors during a clean
#   move vs. a deliberately stalled one.
#
# -----------------------------------------------------------------------------
# Daily schedule (browser-editable, no Home Assistant required)
# -----------------------------------------------------------------------------
#   Web UI fields:
#     - "Open Time" / "Close Time" : daily times to open / close
#     - "Schedule Enabled"         : master on/off (default OFF)
#     - "Timezone"                 : POSIX TZ string (default UTC0)
#   With the schedule enabled, the cover opens at Open Time and closes at
#   Close Time every day. All four settings persist across reboots. Requires
#   a network connection for SNTP time.
#
# -----------------------------------------------------------------------------
# Wi-Fi provisioning (no secrets required)
# -----------------------------------------------------------------------------
#   This firmware ships without hardcoded Wi-Fi credentials. On a fresh flash
#   (or after a Wi-Fi reset via the GPIO21 button), the device broadcasts a
#   "glasscalibur-XXXXXX" hotspot and the captive portal prompts for your
#   network. Improv over USB-Serial-JTAG also works (e.g. web.esphome.io).
#   Credentials are saved to flash and survive reboots and OTA updates.
#
#   secrets.yaml is only needed if you enable the optional native-API
#   encryption key — see the Home Assistant pairing note below.
#
#   Non-HA users: open http://glasscalibur-XXXXXX.local in a browser to
#   control the device (replace XXXXXX with the MAC suffix from the boot log).
#
# -----------------------------------------------------------------------------
# Home Assistant pairing note
# -----------------------------------------------------------------------------
#   The native API runs without encryption by default. Home Assistant will
#   show a warning when you first add the device ("Communication not
#   encrypted"). The device works normally despite this warning. To silence
#   it, generate a key and add it to secrets.yaml, then uncomment the
#   encryption block in the `api:` section below:
#
#     api:
#       encryption:
#         key: !secret api_key          # 32-byte base64 string
#
#   Generate a key with:
#     python3 -c "import secrets,base64; print(base64.b64encode(secrets.token_bytes(32)).decode())"
# =============================================================================

# External components.
# - slimcdk: TMC2209 driver + custom stepper component with on_stall trigger,
#   StallGuard configuration, register-level UART access.
# - valar-systems: Valar fork of latonita's draft LIS2DH12 PR (esphome#14788)
#   with four fixes — stale-sample guard, throttled loop() reads, optional
#   data-ready interrupt pin, and on-chip high-pass filter support.
external_components:
  - source: github://slimcdk/esphome-custom-components
    components: [tmc2209_hub, tmc2209, stepper]

  - source: github://Valar-Systems/esphome-lis2dh12
    components: [lis2dh12_base, lis2dh12_i2c]

globals:
  # The tuning globals (global_speed, global_acceleration, global_irun,
  # global_sgthrs, global_tcoolthrs) now come from valar-core, and the
  # sun-schedule globals (global_latitude, global_longitude, global_sun_*) from
  # the scheduling mixin — both are defined there, not here. This product's
  # former global_max_speed is now core's global_speed (renamed throughout).
  # irun stays ≤ 19 via num_irun's lowered max_value and the on_boot clamp.

  # Cover state machine. Not persisted — every reboot starts IDLE, since the
  # motor is not actually moving at that point.
  #   0 = IDLE     no motion in progress
  #   1 = OPENING  driving toward max_distance_steps
  #   2 = CLOSING  driving toward 0
  #   3 = TAMPERED tamper detected; cleared by "Clear Tamper Alert" or
  #                "Set Tamper Baseline" buttons. Tracks tamper_detected.
  # Mirrored to HA via the "State" text_sensor. Transitions back to IDLE
  # happen on stop_action (which the limit switches and the temperature cutoff
  # both fan into) and on the stepper's on_stall handler.
  - id: global_state
    type: int
    restore_value: no
    initial_value: '0'

  # Last known stepper position in steps. Persisted so the cover entity
  # survives reboots without re-homing. Saved at IDLE-transition points only
  # (stop_action, on_stall, natural target arrival) to minimize flash writes —
  # not in the 200 ms poll, despite Ropener doing so, since we don't need a
  # per-tick checkpoint.
  - id: global_current_position
    type: int
    restore_value: yes
    initial_value: '0'

  # --- Anti-tamper baseline ---
  # Captured by the "Set Tamper Baseline" button when the device is at rest in
  # its mounted orientation. The interval-driven check compares live accel to
  # these and flags tamper if Euclidean distance > tamper_threshold.
  - id: tamper_baseline_x
    type: float
    restore_value: yes
    initial_value: '0.0'
  - id: tamper_baseline_y
    type: float
    restore_value: yes
    initial_value: '0.0'
  - id: tamper_baseline_z
    type: float
    restore_value: yes
    initial_value: '-1.0'  # accelerometer is on the bottom of the PCB facing
                           # down, so at rest Z reads -1g (gravity). Overwritten
                           # by "Set Tamper Baseline" on first calibration.
  # Latched tamper state. Cleared only by the "Clear Tamper Alert" button so a
  # bumped-then-replaced device doesn't silently un-flag itself.
  - id: tamper_detected
    type: bool
    restore_value: no
    initial_value: 'false'

  # --- Vibration-based stall (secondary to StallGuard) ---
  # A stalled stepper shakes the device hard. While the motor is commanded to
  # move, we run a leaky counter on vibration-above-threshold samples; crossing
  # vib_stall_samples declares a stall. Leaky (rather than consecutive-reset)
  # so a single quiet sample mid-stall doesn't restart the count from zero.
  - id: vib_loud_count
    type: int
    restore_value: no
    initial_value: '0'

  # Timestamp (millis()) at which the current motion command started. Used by
  # the vib-stall check to skip its first ~500 ms after launch — initial motor
  # torque can spike the accelerometer hard enough to false-trip before the
  # mechanism reaches steady-state. Set in open_action / close_action /
  # position_action; not persisted (only meaningful while motion is active).
  - id: motion_start_ms
    type: uint32_t
    restore_value: no
    initial_value: '0'

  # --- Lifetime diagnostic counters (persisted) ---
  # Incremented each time the respective event fires. Useful for spotting a
  # unit that's stalling more than its peers, or detecting tamper attempts
  # that happened while the owner wasn't watching HA. Written to flash via
  # NVS batching so they're not free-running flash writers.
  - id: stallguard_count
    type: int
    restore_value: yes
    initial_value: '0'
  - id: vib_stall_count
    type: int
    restore_value: yes
    initial_value: '0'
  - id: tamper_count
    type: int
    restore_value: yes
    initial_value: '0'

  # (Sun-schedule globals — latitude/longitude/offsets/last-desired — are now
  # provided by the scheduling mixin.)

  # --- Auto-calibration + stall-release state (v1.3.0) ---
  # Live calibration state (not persisted — a reboot mid-cal starts clean).
  - id: cal_active
    type: bool
    restore_value: no
    initial_value: 'false'
  - id: cal_sg_min
    type: int
    restore_value: no
    initial_value: '510'
  - id: cal_vib_max
    type: float
    restore_value: no
    initial_value: '0.0'
  - id: cal_irun_index
    type: int
    restore_value: no
    initial_value: '0'
  - id: cal_done
    type: bool
    restore_value: no
    initial_value: 'false'
  - id: cal_travel_ok
    type: bool
    restore_value: no
    initial_value: 'false'
  # Per-travel deadline: armed immediately before each calibration travel from
  # the LIVE speed (max_distance_steps / global_speed × 1.5 + 10 s). A
  # fixed timeout cannot work here — travel time ranges from ~34 s (speed
  # 10000) to ~57 min (speed 100) — and the wait_until conditions below always
  # exit on software target arrival anyway (open-loop stepper: the 200 ms
  # completion poll drops global_state to 0), so the deadline is a backstop.
  - id: cal_t0_ms
    type: uint32_t
    restore_value: no
    initial_value: '0'
  - id: cal_budget_ms
    type: uint32_t
    restore_value: no
    initial_value: '0'
  # The user's Vibration Threshold as it was when calibration started, so a
  # failed/aborted run can put it back after probing with the raised
  # ${cal_vib_backstop}. Volatile: if the device reboots mid-calibration the
  # raised backstop persists in the number entity — still a working (just
  # laxer) detector; recalibrate to retune.
  - id: cal_vib_prev
    type: float
    restore_value: no
    initial_value: '0.30'
  # Escalation handshake between the 100 ms calibration sampler and cal_leg:
  # sustained SG_RESULT below ${cal_sg_floor} (torque margin starving) sets
  # cal_escalate so the leg bumps to the next current BEFORE a violent stall
  # develops. Reset at the start of every attempt.
  - id: cal_escalate
    type: bool
    restore_value: no
    initial_value: 'false'
  - id: cal_sg_low_count
    type: int
    restore_value: no
    initial_value: '0'
  # Largest (= slowest) TSTEP seen at cruise during the validation leg.
  # Feeds TCOOLTHRS = 1.5 × cruise TSTEP on success: the TMC2209 only
  # asserts stalls while TSTEP < TCOOLTHRS, and the shipped default (100)
  # sat BELOW the ~150 cruise TSTEP at speed 2500 — StallGuard was
  # velocity-gated inert in normal operation until calibration derives
  # this properly.
  - id: cal_tstep_max
    type: int
    restore_value: no
    initial_value: '0'

  # Which calibration phase is running, so the status text can tell a
  # bystander that the homing close is deliberate (field 2026-07-10: a user
  # watching the window close right after starting calibration read it as a
  # malfunction and hit the abort button). 0 = none/generic, 1 = homing
  # close, 2 = open leg, 3 = close leg. Display-only; gated on cal_active.
  - id: cal_phase
    type: int
    restore_value: no
    initial_value: '0'

  # Persisted results (survive reboot, feed the "Calibration Status" sensor).
  # cal_result: 0 = never run, 1 = OK, 2 = OK w/ sticky-window warning,
  #             3 = FAILED (travel never reached both limits), 4 = thermal
  #             abort (motor exceeded 55 °C mid-run — see cal_thermal_guard),
  #             5 = aborted by user (Button 1)
  - id: cal_result
    type: int
    restore_value: yes
    initial_value: '0'
  - id: cal_irun_chosen
    type: int
    restore_value: yes
    initial_value: '0'
  - id: cal_sgthrs_chosen
    type: int
    restore_value: yes
    initial_value: '0'
  - id: cal_sgmin_seen
    type: int
    restore_value: yes
    initial_value: '0'
  - id: cal_vibmax_x100
    type: int
    restore_value: yes
    initial_value: '0'
  - id: cal_speed_at
    type: int
    restore_value: yes
    initial_value: '0'

  # Stall auto-release handshake. One back-off per stall event: set when a
  # release starts, cleared by stall_release_clear 5 s later. A second stall
  # while the flag is set just stops (jammed solid — don't oscillate).
  - id: stall_release_active
    type: bool
    restore_value: no
    initial_value: 'false'

  # --- StallGuard auto-tune (self-healing SGTHRS) state ---
  # Peak vibration (g) seen during the current travel; reset at motion start,
  # maxed in the vibration interval. It is the cross-check for whether a StallGuard
  # trip was a real (shaky) stall or a quiet false trip.
  - id: vib_run_peak
    type: float
    restore_value: no
    initial_value: '0.0'
  # Set true when the StallGuard handler fires during the current travel; reset at
  # motion start. Lets the vibration detector tell "StallGuard also caught this"
  # from "StallGuard missed a real stall".
  - id: sg_fired_this_move
    type: bool
    restore_value: no
    initial_value: 'false'
  # Consecutive quiet mid-travel StallGuard trips. A single quiet trip is weak
  # evidence (the accelerometer can miss a fast stall), so auto-tune only lowers
  # SGTHRS after a run of them. Reset by vibration agreement or a clean full
  # travel. Not persisted — a fresh boot re-earns the evidence.
  - id: sg_quiet_streak
    type: int
    restore_value: no
    initial_value: '0'
  # Lifetime count of auto-tune adjustments (persisted, surfaced as a diagnostic).
  - id: sg_autotune_count
    type: int
    restore_value: yes
    initial_value: '0'

# -----------------------------------------------------------------------------
# Product-layer overrides of shared infrastructure
# -----------------------------------------------------------------------------
# Substitutions (mechanical + OTA identity) moved to the board wrapper. api, ota,
# http_request, safe_mode, wifi, captive_portal, improv_serial, time and sun all
# come from valar-core / the scheduling mixin. Only the product-specific slivers
# of logger and web_server remain here; package merge folds them into core's.

# Add the LIS2DH12 i2c-poll log silencing to core's logger. Package merge folds
# this logs map into core's (core owns the console uart + base level).
logger:
  logs:
    # Silence the LIS2DH12 status-poll chatter (~50 i2c.idf lines per sample).
    i2c.idf: INFO
    lis2dh12: INFO

# Web UI groups. Control / Schedule / Diagnostics come from core + the scheduling
# mixin. Everything else is defined here so the page reads top-to-bottom as:
# Control, Motion Tuning, Calibration, Stall Detection, Schedule, Security,
# Diagnostics, StallGuard (advanced).
#
# A product can't re-weight a core group (redefining its id errors), so — as on
# the Ropener — we define NEW groups and move the relevant entities into them,
# leaving core's group_motion / group_stallguard / group_setup empty (empty groups
# don't render). Motion Tuning sits above Schedule (25); the accelerometer-based
# Stall Detection is its own first-class group (it is NOT a StallGuard feature),
# while the TMC2209 StallGuard registers drop to an advanced group at the bottom.
web_server:
  sorting_groups:
    - { id: group_tuning,   name: "Motion Tuning",         sorting_weight: 12 }
    - { id: group_cal,      name: "Calibration",           sorting_weight: 22 }
    - { id: group_stall,    name: "Stall Detection",       sorting_weight: 24 }
    - { id: group_security, name: "Security / Tamper",     sorting_weight: 45 }
    - { id: group_sg_adv,   name: "StallGuard (advanced)", sorting_weight: 70 }

# -----------------------------------------------------------------------------
# Device identity + boot-time motor configuration
# -----------------------------------------------------------------------------
# on_boot:
#   1. Restore last saved position so HA cover state is accurate.
#   2. Override with limit-switch ground truth if either is currently pressed.
#   3. Apply persisted speed / acceleration to the stepper.
#   4. Configure TMC2209: direction, microsteps, TCOOLTHRS, StallGuard, currents.
#   5. Re-apply the user's saved timezone (restore doesn't re-fire set_action).
esphome:
  # name / friendly_name / project come from the board wrapper and core. The
  # motor configure/stallguard/currents, speed/accel, and firmware-version publish
  # are all done by core's priority-600 on_boot (direction = COUNTERCLOCKWISE via
  # the board's motor_direction_default). Timezone / lat-long re-apply is done by
  # the scheduling mixin's priority -100 on_boot. This product adds only what core
  # can't know about: the current clamp and limit-switch homing.
  on_boot:
    # BEFORE core configures the driver (core boots at priority 600): clamp the
    # restored motor current. Units upgraded from firmware that allowed irun up to
    # 31 restore the old value from flash; core's currents would otherwise push it
    # straight to the driver. 19 = rated 0.6 A; the motor's 60 °C case limit leaves
    # no headroom above that. num_irun's lowered max_value caps new entries too.
    - priority: 650
      then:
        - lambda: 'if (id(global_irun) > 19) id(global_irun) = 19;'
    # AFTER core has configured the driver and applied speed/accel (priority 600):
    # establish the true position. Restore the last saved position, then let a
    # currently-pressed limit switch override it with mechanical ground truth.
    # (Position counter vs. driver registers are independent, so running this
    # after core's configure is equivalent to the pre-rewire single-trigger boot.)
    - priority: 500
      then:
        - stepper.report_position:
            id: driver
            position: !lambda "return id(global_current_position);"
        - stepper.set_target:
            id: driver
            target: !lambda "return id(global_current_position);"
        - logger.log: "CHECKING LIMIT SWITCHES"
        - if:
            condition:
              binary_sensor.is_on: limit_switch_1
            then:
              - logger.log: "SETTING LIMIT 1"
              - stepper.report_position:
                  id: driver
                  position: ${max_distance_steps}
              - stepper.set_target:
                  id: driver
                  target: ${max_distance_steps}
        - if:
            condition:
              binary_sensor.is_on: limit_switch_2
            then:
              - logger.log: "SETTING LIMIT 2"
              - stepper.report_position:
                  id: driver
                  position: 0
              - stepper.set_target:
                  id: driver
                  target: 0

# -----------------------------------------------------------------------------
# Buzzer (passive piezo on GPIO5, driven by ledc PWM)
# -----------------------------------------------------------------------------
# Used by the tamper_alarm script. Frequency and duty are set per-pulse from
# the script (2700 Hz / 50 % gives a clear, audible square wave).
output:
  - platform: ledc
    pin: GPIO5
    id: buzzer

# -----------------------------------------------------------------------------
# Stepper driver — product on_stall override
# -----------------------------------------------------------------------------
# The driver (id: driver), its UART, and all hardware params (rsense 220 mOhm,
# vsense off, deceleration inf, config_dump off, enn/index/diag pins) come from
# core, fed by the board wrapper's stepper_* substitutions. Only the stall
# response is product-specific. Replace core's default on_stall: because package
# !extend APPENDS to action lists (it does not replace), first !remove core's
# handler — otherwise core's stop + report_position(0) would still run and zero
# the position, which limit-switch homing (not stalls) owns here — then re-add
# the Glasscalibur handler.
stepper:
  - id: !extend driver
    on_stall: !remove
  - id: !extend driver
    on_stall:
      # Software gate on the "StallGuard Enabled" switch — the chip itself
      # always flags stalls; we only react when the user has opted in. When
      # the switch is off, the trigger fires harmlessly with no effect.
      # (During auto-calibration the switch is off, so calibration probes
      # never enter this handler — the script does its own recovery.)
      - if:
          condition:
            lambda: 'return id(stallguard_enabled).state;'
          then:
            - stepper.stop: driver
            - lambda: 'id(stallguard_count) += 1;'
            - logger.log: "MOTOR STALLED - backing off"
            # Stall auto-release: the leadscrew is not backdrivable, so a
            # stall against an obstruction HOLDS whatever clamp force it
            # reached until the motor reverses. Back off ~8 mm so "stops
            # while still clamping" becomes genuine auto-reverse. Must run
            # BEFORE global_state is zeroed below — the stall direction is
            # what decides which way to back off. One release per event:
            # a second stall while stall_release_active is set (jammed
            # solid) just stops.
            - if:
                condition:
                  lambda: 'return !id(stall_release_active);'
                then:
                  - globals.set:
                      id: stall_release_active
                      value: 'true'
                  - lambda: |-
                      int32_t pos = id(driver)->current_position;
                      int32_t rel = ${stall_release_steps};
                      // Stalled while CLOSING (state 2): back off toward open.
                      // Stalled while OPENING: back off toward close.
                      int32_t tgt = (id(global_state) == 2) ? pos + rel : pos - rel;
                      if (tgt < 0) tgt = 0;
                      id(driver)->set_target(tgt);
                  - script.execute: stall_release_clear
            - globals.set:
                id: global_state
                value: "0"
            - cover.template.publish:
                id: glasscalibur_cover
                current_operation: IDLE
            - globals.set:
                id: global_current_position
                value: !lambda "return id(driver)->current_position;"
            # Record the fire and, if auto-tune is on, cross-check vibration to
            # decide whether this was a real stall or a false trip (see the
            # sg_autotune_eval script). Runs last so global_state/position are set.
            - script.execute: sg_autotune_eval

# -----------------------------------------------------------------------------
# Physical buttons + end-stop limit switches
# -----------------------------------------------------------------------------
# Button 1 (GPIO23): single click cycles between dismiss-alarm / stop-motor
#   / close-cover based on global_state; double click opens the cover.
# Limit switches (GPIO15 open, GPIO3 close): when triggered, report the known
#   absolute position to the stepper (correcting drift), stop the cover, and
#   inherit IDLE-state cleanup through stop_action. Presses are direction-
#   gated: a switch acts only when travel is toward it (or idle) — a press
#   while moving AWAY is a mechanical blip and is logged then ignored, never
#   allowed to stop motion or rewrite position. Both are polled rather
#   than interrupt-driven because polling proved more reliable in testing.
# WiFi Reset (GPIO21): long press wipes saved credentials and reboots into
#   captive-portal setup mode.
# Tamper / accel-interrupt sensors live at the end of this block.
binary_sensor:
  # Core defines btn1/btn2/btn3 as bare inputs. Glasscalibur has only two
  # buttons, so drop core's phantom Button 2 and its Wi-Fi button — this product
  # keeps its own "WiFi Reset" entity (btn_wifi_reset, below). btn1 keeps core's
  # pin/name/filters (identical: GPIO ${pin_btn1}, INPUT, inverted, delayed_on
  # 10ms) and just gains the product's click behaviour.
  - id: !remove btn2
  - id: !remove btn3
  - id: !extend btn1
    web_server:
      sorting_weight: 3
      sorting_group_id: group_control
    on_multi_click:

      # --- Single Click ---
      # CALIBRATING             -> abort the calibration sequence. This check
      #                            deliberately PRECEDES Child Lock: stopping
      #                            an autonomous multi-travel sequence is a
      #                            safety control and must never be lockable.
      # TAMPERED                -> silence the alarm + return to IDLE.
      # OPENING or CLOSING      -> stop (stop_action sets state to IDLE).
      # Otherwise (IDLE)        -> close (close_action sets state to CLOSING).
      - timing:
          - ON for at most 1.0s
          - OFF for at least 0.5s
        then:
          - if:
              condition:
                lambda: 'return id(cal_active);'
              then:
                - script.stop: auto_calibrate
                - script.stop: cal_leg
                - cover.stop: glasscalibur_cover
                - switch.turn_on: stallguard_enabled
                - switch.turn_on: vib_enabled
                # Put back the vibration threshold the user had before the
                # script raised it to the calibration backstop.
                - number.set:
                    id: vib_threshold
                    value: !lambda 'return id(cal_vib_prev);'
                - globals.set:
                    id: cal_active
                    value: 'false'
                - globals.set:
                    id: cal_result
                    value: '5'
                # The aborted probe may have left a mid-search candidate
                # (e.g. 12) in the driver — restore the rated current.
                - globals.set:
                    id: global_irun
                    value: '19'
                - tmc2209.currents:
                    irun: !lambda 'return id(global_irun);'
                - logger.log: "CAL: aborted by user"
                - script.execute: cal_beep_fail
                - component.update: cal_status
                # Swallow the click — don't fall through to stop/close.
              else:
                - if:
                    condition:
                      lambda: 'return id(child_lock).state;'
                    then:
                      - logger.log: "Child lock on — single click ignored"
                    else:
                      - if:
                          condition:
                            lambda: 'return id(global_state) == 3;'
                          then:
                            - script.stop: tamper_alarm
                            - output.turn_off: buzzer
                            - globals.set:
                                id: tamper_detected
                                value: "false"
                            - globals.set:
                                id: global_state
                                value: "0"
                            - logger.log: "Tamper alarm dismissed via button"
                          else:
                            - if:
                                condition:
                                  lambda: 'return id(global_state) == 1 || id(global_state) == 2;'
                                then:
                                  - cover.stop: glasscalibur_cover
                                else:
                                  - cover.close: glasscalibur_cover
          # - if:
          #     condition: ## If moving, then stop
          #       lambda: return (id(glasscalibur_cover).current_operation != COVER_OPERATION_IDLE); # Should evaluate to TRUE if moving
          #     then:
          #       - cover.stop: glasscalibur_cover
          #     else: ## If not moving, then close
          #       - cover.close: glasscalibur_cover

          # - output.turn_on: buzzer
          # - output.ledc.set_frequency:
          #     id: buzzer
          #     frequency: "2700Hz"
          # - output.set_level:
          #     id: buzzer
          #     level: "50%"
          # - delay: 1s
          # - output.turn_off: buzzer

      # --- Double Click ---
      # Ignored while calibrating: launching a new motion mid-sequence would
      # corrupt the probe in progress (single-click aborts instead).
      - timing:
          - ON for at most 1.0s
          - OFF for at most 0.3s
          - ON for at most 1.0s
          - OFF for at least 0.5s
        then:
          - if:
              condition:
                lambda: 'return id(cal_active);'
              then:
                - logger.log: "Calibrating — double click ignored (single click aborts)"
              else:
                - if:
                    condition:
                      lambda: 'return id(child_lock).state;'
                    then:
                      - logger.log: "Child lock on — double click ignored"
                    else:
                      - cover.open: glasscalibur_cover

          # - output.turn_on: buzzer
          # - output.ledc.set_frequency:
          #     id: buzzer
          #     frequency: "2700Hz"
          # - output.set_level:
          #     id: buzzer
          #     level: "50%"
          # - delay: 1s
          # - output.turn_off: buzzer

  - platform: gpio
    name: Open Limit Switch
    id: limit_switch_1
    web_server:
      sorting_weight: 4
      sorting_group_id: group_diagnostics
    pin:
      number: GPIO15
      mode: INPUT
      inverted: true
    # Interrupts are not reliable, they constatnly miss. Use polling
    use_interrupt: false
    #interrupt_type: FALLING
    filters:
      - delayed_on: 10ms
      # Debounce the RELEASE edge too: calibration re-reads the switch
      # right after its wait exits, and a micro-bounce (seen on the bench
      # with the tube loose) read "released" 9 ms after the press and
      # false-failed homing.
      - delayed_off: 30ms
    on_press:
      then:
        # Direction-gated: act only when travel is toward this switch
        # (opening) or idle (sash hand-moved onto the stop -> re-sync).
        # While CLOSING away from the fully-open stop, drive-force
        # build-up can rack the sash and re-flick this switch for
        # ~150 ms (field 2026-07-10: three calibration close legs in a
        # row killed ~1 s in, each blip also re-claiming position as
        # fully open mid-close). A 150 ms contact is real, so debounce
        # can't filter it; ignoring wrong-direction presses can.
        - if:
            condition:
              lambda: 'return id(global_state) != 2;'
            then:
              - stepper.report_position:
                  id: driver
                  position: ${max_distance_steps}
              - stepper.set_target:
                  id: driver
                  target: ${max_distance_steps}
              - cover.stop: glasscalibur_cover
              - logger.log: "LIMIT 1 PRESSED"
              # A full travel reached its end stop -> the StallGuard tune is fine;
              # clear any accumulated quiet-trip evidence (auto-tune).
              - lambda: 'id(sg_quiet_streak) = 0;'
            else:
              - logger.log: "LIMIT 1 blip while closing - ignored"
          

  - platform: gpio
    name: Close Limit Switch
    id: limit_switch_2
    web_server:
      sorting_weight: 5
      sorting_group_id: group_diagnostics
    pin:
      number: GPIO3
      mode: INPUT
      inverted: true
    # Interrupts are not reliable, they constatnly miss. Use polling
    use_interrupt: false
    #interrupt_type: FALLING
    # Optional: filters to prevent noise from triggering the sensor
    filters:
      - delayed_on: 10ms
      # See the open-limit note: release-edge debounce for the calibration
      # homing re-check.
      - delayed_off: 30ms
    on_press:
      then:
        # Direction-gated like the open switch: ignore presses while
        # OPENING away from the closed stop (see limit_switch_1 note).
        - if:
            condition:
              lambda: 'return id(global_state) != 1;'
            then:
              - stepper.report_position:
                  id: driver
                  position: 0
              - stepper.set_target:
                  id: driver
                  target: 0
              - cover.stop: glasscalibur_cover
              - logger.log: "LIMIT 2 PRESSED"
              - lambda: 'id(sg_quiet_streak) = 0;'   # clean full travel -> tune OK (auto-tune)
            else:
              - logger.log: "LIMIT 2 blip while opening - ignored"

  # Calibration / WiFi Reset (GPIO21) — two gestures, non-overlapping timings:
  #   * 7 quick presses (each ≤ 0.6 s) -> start auto-calibration. Seven is
  #     deliberate: calibration drives the window through its full travel, so
  #     the trigger must be impossible to hit accidentally (a stray
  #     double-tap used to be enough). The script still announces itself
  #     (3 beeps + 2 s) before any motion and refuses if the device is busy,
  #     tampered, or the motor is hot.
  #   * Hold 3-10 s -> erase saved Wi-Fi credentials and reboot into setup
  #     mode. A long hold is required (not a quick tap) so the device can't
  #     be knocked offline by an accidental press. On reboot the device
  #     re-runs Wi-Fi setup: with no credentials saved (and none compiled
  #     into the firmware), it broadcasts the "glasscalibur-XXXXXX" hotspot /
  #     captive portal so a new network can be entered (Improv over USB
  #     serial works too).
  # A calibration press can never satisfy the 3 s minimum hold, so the two
  # gestures cannot both fire from one input.
  - platform: gpio
    name: WiFi Reset
    id: btn_wifi_reset
    web_server:
      sorting_weight: 6
      sorting_group_id: group_diagnostics
    pin:
      number: GPIO21
      mode: INPUT
      inverted: true
    filters:
      - delayed_on: 10ms
    on_multi_click:
      - timing:
          - ON for at most 0.6s
          - OFF for at most 0.4s
          - ON for at most 0.6s
          - OFF for at most 0.4s
          - ON for at most 0.6s
          - OFF for at most 0.4s
          - ON for at most 0.6s
          - OFF for at most 0.4s
          - ON for at most 0.6s
          - OFF for at most 0.4s
          - ON for at most 0.6s
          - OFF for at most 0.4s
          - ON for at most 0.6s
          - OFF for at least 0.3s
        then:
          - logger.log: "CAL: requested via calibration button (7 presses)"
          - script.execute: auto_calibrate
    on_click:
      - min_length: 3000ms
        max_length: 10000ms
        then:
          - logger.log: "Clearing saved Wi-Fi credentials and rebooting into setup"
          - lambda: |-
              // Overwrite the persisted credentials in flash with empty values,
              // then drop the in-memory copy so nothing is re-saved on teardown.
              esphome::wifi::global_wifi_component->save_wifi_sta("", "");
              esphome::wifi::global_wifi_component->clear_sta();
          - delay: 1s                          # let the log flush before we restart
          - lambda: "App.safe_reboot();"

  # Anti-tamper status. Set by the 1 s tamper-check interval; latched until
  # the "Clear Tamper Alert" button is pressed.
  - platform: template
    name: "Tamper Detected"
    id: tamper_sensor
    entity_category: DIAGNOSTIC
    web_server:
      sorting_weight: 5
      sorting_group_id: group_security
    lambda: 'return id(tamper_detected);'

# -----------------------------------------------------------------------------
# The cover entity (Home Assistant)
# -----------------------------------------------------------------------------
# Template cover backed by the TMC2209 stepper. Position is reported live as a
# 0..1 ratio of current_position / max_distance_steps.
#   - open_action     : drive to the configured travel limit (position 1.0)
#   - close_action    : drive to step 0 (position 0.0)
#   - position_action : drive to an arbitrary fraction set from HA — direction
#                       is inferred by comparing the new target to current_position
#   - stop_action     : halt + flip state to IDLE + persist position
#
# Each motion action also updates global_state so the "State" text_sensor and
# automations follow along. The motion-completion poll (interval block at the
# bottom of this file) flips current_operation back to IDLE once the stepper
# reaches its target.
cover:
  - platform: template
    id: glasscalibur_cover
    name: Glasscalibur
    web_server:
      sorting_weight: 1
      sorting_group_id: group_control
    has_position: true
    lambda: "return (float(id(driver)->current_position) / float(${max_distance_steps}));"

    stop_action:
      - logger.log: "COVER stop_action"
      - stepper.stop: driver
      - globals.set:
          id: global_state
          value: "0"
      - cover.template.publish:
          id: glasscalibur_cover
          current_operation: IDLE
      - globals.set:
          id: global_current_position
          value: !lambda "return id(driver)->current_position;"

    open_action:
      - logger.log: "COVER open_action"
      - lambda: |-
          id(motion_start_ms) = millis();
          id(vib_run_peak) = 0.0f;          // reset per-travel stall cross-check state
          id(sg_fired_this_move) = false;
      - globals.set:
          id: global_state
          value: "1"
      - stepper.set_target:
          id: driver
          target: ${max_distance_steps}
      - cover.template.publish:
          id: glasscalibur_cover
          current_operation: OPENING

    close_action:
      - logger.log: "COVER close_action"
      - lambda: |-
          id(motion_start_ms) = millis();
          id(vib_run_peak) = 0.0f;          // reset per-travel stall cross-check state
          id(sg_fired_this_move) = false;
      - globals.set:
          id: global_state
          value: "2"
      - stepper.set_target:
          id: driver
          target: 0
      - cover.template.publish:
          id: glasscalibur_cover
          current_operation: CLOSING

    position_action:
      - logger.log: "COVER position_action"
      - lambda: |-
          id(motion_start_ms) = millis();
          id(vib_run_peak) = 0.0f;          // reset per-travel stall cross-check state
          id(sg_fired_this_move) = false;
      # Direction is inferred by comparing the new target to current_position.
      - if:
          condition:
            lambda: 'return (pos * ${max_distance_steps}) >= id(driver)->current_position;'
          then:
            - globals.set:
                id: global_state
                value: "1"
            - cover.template.publish:
                id: glasscalibur_cover
                current_operation: OPENING
          else:
            - globals.set:
                id: global_state
                value: "2"
            - cover.template.publish:
                id: glasscalibur_cover
                current_operation: CLOSING
      - stepper.set_target:
          id: driver
          target: !lambda return pos * ${max_distance_steps};

    # NOTE: on_opening / on_opened / on_closing / on_closed used to be wired
    # here, each re-publishing the same current_operation they fired on. That
    # made the trigger recurse into itself indefinitely and stack-overflow
    # within milliseconds of a cover.open / cover.close. The open_action /
    # close_action / position_action / stop_action above already publish
    # OPENING / CLOSING / IDLE, and the 200 ms motion-completion poll flips
    # back to IDLE on target arrival, so these handlers are not needed at all.

# -----------------------------------------------------------------------------
# Tunable number entities
# -----------------------------------------------------------------------------
# Each entity below is bound to a global (or directly to a chip register) and
# pushes its value into the driver / system when the user changes it from the
# web UI or Home Assistant. The `lambda` reads the value back live (every
# update_interval) so the UI reflects the actual state, not just the last
# value we wrote.
number:
  # Speed, Acceleration, TCOOLTHRS and SGTHRS come from core; Latitude/Longitude
  # and the sun offsets from the scheduling mixin. This product retargets those
  # core numbers into the reorganized groups, tightens the current cap, and adds
  # its own tamper/vibration tuning numbers.

  # Acceleration lives in Motion Tuning. The raw Speed slider is driven by the
  # friendly Slow/Medium/Fast preset select (below) and moves to the advanced
  # group for power users; core's own group_motion is left empty and doesn't render.
  - id: !extend num_speed
    web_server: { sorting_weight: 8, sorting_group_id: group_sg_adv }
  - id: !extend num_accel
    web_server: { sorting_weight: 2, sorting_group_id: group_tuning }

  # Friendly motor current in milliamps (Motion Tuning). The driver knows this
  # board's Rsense (220 mOhm) and Vsense, so read_run_current_mA / write_run_current_mA
  # do the register conversion — no formula here. IRUN 19 (this motor's thermal
  # ceiling, rated 0.6 A) is ~600 mA on this board, so max_value caps there: the
  # motor's 60 °C case limit leaves no headroom above it. Values snap to the
  # nearest of the 32 register steps (~30 mA). Keeps global_irun (persisted,
  # reapplied on boot) in sync with the register the driver just derived.
  - platform: template
    name: "Motor Current"
    id: num_motor_current
    unit_of_measurement: "mA"
    icon: "mdi:current-dc"
    web_server: { sorting_weight: 3, sorting_group_id: group_tuning }
    min_value: 100
    max_value: 600
    step: 10
    mode: BOX
    entity_category: CONFIG
    lambda: "return id(driver)->read_run_current_mA();"
    update_interval: 5s
    set_action:
      - lambda: "id(driver)->write_run_current_mA((uint16_t) x);"
      - globals.set:
          id: global_irun
          value: !lambda "return id(driver)->read_field(IRUN_FIELD);"

  # Raw IRUN register (1-19) is meaningless to most users — the friendly Motor
  # Current above drives it in mA. Keep the raw register in the advanced group for
  # power users, still capped at 19.
  - id: !extend num_irun
    name: "IRUN value"
    max_value: 19
    web_server:
      sorting_weight: 6
      sorting_group_id: group_sg_adv

  # TCOOLTHRS + SGTHRS are TMC2209 StallGuard registers -> the advanced group at
  # the bottom of the page (they are tuning knobs for StallGuard, not everyday
  # controls). Core defines them in its group_stallguard, which is left empty.
  - id: !extend num_tcoolthrs
    web_server: { sorting_weight: 3, sorting_group_id: group_sg_adv }
  - id: !extend num_sgthrs
    web_server: { sorting_weight: 2, sorting_group_id: group_sg_adv }


# --- Anti-tamper threshold (g) ---
# Euclidean distance between current accel and baseline that triggers a
# tamper alert. 0.30g ≈ 17° tilt or a moderate bump. Tune downward if you
# want more sensitivity, upward if you see false positives.
  - platform: template
    name: "Tamper Threshold"
    id: tamper_threshold
    web_server:
      sorting_weight: 2
      sorting_group_id: group_security
    step: 0.05
    min_value: 0.05
    max_value: 2.0
    mode: BOX
    entity_category: CONFIG
    unit_of_measurement: "g"
    optimistic: true
    restore_value: true
    initial_value: 0.30

# --- Vibration stall threshold (g) ---
# |magnitude - 1g| above which a sample is counted as "loud". A stalled stepper
# shakes the device hard (well above smooth running). Tune by watching the
# accel sensors during a normal move vs. a deliberately stalled one and pick
# a value comfortably between the two.
  - platform: template
    name: "Vibration Threshold"
    id: vib_threshold
    web_server:
      sorting_weight: 2
      sorting_group_id: group_stall
    step: 0.05
    min_value: 0.05
    max_value: 4.0
    mode: BOX
    entity_category: CONFIG
    unit_of_measurement: "g"
    optimistic: true
    restore_value: true
    initial_value: 0.30

# --- Vibration stall debounce (distinct accelerometer samples) ---
# Number of net "loud" samples before declaring a stall. The detector counts
# each fresh LIS2DH12 reading once (the sensor publishes every 500 ms), so
# 5 samples ≈ 2.5 s of sustained strong vibration. A single jolt or one noisy
# bump doesn't trip; sustained motor judder does.
  - platform: template
    name: "Vibration Stall Samples"
    id: vib_stall_samples
    web_server:
      sorting_weight: 3
      sorting_group_id: group_stall
    step: 1
    min_value: 2
    max_value: 60
    mode: BOX
    entity_category: CONFIG
    optimistic: true
    restore_value: true
    initial_value: 5

  # (Latitude / Longitude / Sun Open Offset / Sun Close Offset come from the
  # scheduling mixin.)

# -----------------------------------------------------------------------------
# Child lock
# -----------------------------------------------------------------------------
# When ON, the physical Button 1 (single + double click) is ignored so the
# cover can't be opened, closed, or stopped from the on-device button — e.g. to
# keep a child from operating it. Remote control is intentionally unaffected:
# the web UI, Home Assistant, and the open/close schedule all keep working, so
# you can still operate the cover and toggle this lock from your phone. The
# WiFi-reset button (GPIO21) is also left active so the device can always be
# recovered. Persists across reboots; default OFF so a fresh unit is never
# locked.
switch:
  - platform: template
    name: "Child Lock"
    id: child_lock
    entity_category: CONFIG
    web_server:
      sorting_weight: 4
      sorting_group_id: group_control
    optimistic: true
    restore_mode: RESTORE_DEFAULT_OFF
    turn_on_action:
      - logger.log: "Child lock enabled — physical button disabled"
    turn_off_action:
      - logger.log: "Child lock disabled — physical button active"

  # (Schedule Enabled + Sun Schedule switches come from the scheduling mixin.)

  # Master enable for tamper detection. When OFF the 1 s tamper-check interval
  # is skipped entirely. Turning OFF also silences any active alarm and clears
  # the TAMPERED state so the device doesn't keep beeping with detection
  # "disabled". Turning ON auto-captures the current accel as the new baseline
  # so the first check after enabling can't false-trip against a stale baseline
  # taken from a different mounting position. Default OFF — user opts in.
  - platform: template
    name: "Tamper Detection"
    id: tamper_enabled
    entity_category: CONFIG
    web_server:
      sorting_weight: 1
      sorting_group_id: group_security
    optimistic: true
    restore_mode: RESTORE_DEFAULT_OFF
    turn_on_action:
      # Baselines are stored in g (sensor states are m/s² — ESPHome
      # convention) so they compare directly against Tamper Threshold.
      - globals.set:
          id: tamper_baseline_x
          value: !lambda "return id(accel_x).state / 9.80665f;"
      - globals.set:
          id: tamper_baseline_y
          value: !lambda "return id(accel_y).state / 9.80665f;"
      - globals.set:
          id: tamper_baseline_z
          value: !lambda "return id(accel_z).state / 9.80665f;"
      - globals.set:
          id: tamper_detected
          value: "false"
      - logger.log:
          format: "Tamper detection enabled — baseline captured: x=%.3fg y=%.3fg z=%.3fg"
          args: ['id(accel_x).state / 9.80665f', 'id(accel_y).state / 9.80665f', 'id(accel_z).state / 9.80665f']
    turn_off_action:
      - script.stop: tamper_alarm
      - output.turn_off: buzzer
      - globals.set:
          id: tamper_detected
          value: "false"
      - if:
          condition:
            lambda: 'return id(global_state) == 3;'
          then:
            - globals.set:
                id: global_state
                value: "0"
      - logger.log: "Tamper detection disabled"

  # Master enable for the accelerometer-based vibration stall check. When OFF
  # the 200 ms vibration interval short-circuits — only TMC2209 StallGuard
  # remains as a stall safeguard. Defaults OFF because the thresholds need
  # tuning per installation and a misconfigured detector trips spurious stops.
  # Turning OFF resets the loud-sample counter so a future re-enable starts
  # fresh.
  - platform: template
    name: "Vibration Stall Detection"
    id: vib_enabled
    entity_category: CONFIG
    web_server:
      sorting_weight: 1
      sorting_group_id: group_stall
    optimistic: true
    restore_mode: RESTORE_DEFAULT_OFF
    turn_off_action:
      - globals.set:
          id: vib_loud_count
          value: "0"
      - logger.log: "Vibration stall detection disabled"

  # Master enable for the TMC2209 StallGuard *handler*. The chip's SGTHRS is
  # always set to the user's chosen value (via the SGTHRS number entity), so
  # the chip detects stalls regardless of this switch. The on_stall handler
  # on the stepper is what's gated by this switch — when OFF, stall events
  # fire but are ignored, so a misconfigured threshold can't spuriously stop
  # the motor. Defaults OFF because SGTHRS needs per-installation tuning
  # before stall response can be trusted.
  - platform: template
    name: "StallGuard Enabled"
    id: stallguard_enabled
    entity_category: CONFIG
    web_server:
      sorting_weight: 1
      sorting_group_id: group_sg_adv
    optimistic: true
    restore_mode: RESTORE_DEFAULT_OFF
    turn_on_action:
      - logger.log: "StallGuard handler enabled"
    turn_off_action:
      - logger.log: "StallGuard handler disabled"

  # Self-healing StallGuard tune. When ON (and StallGuard + Vibration Stall
  # Detection are both on), the firmware cross-checks every StallGuard trip against
  # the accelerometer: it RAISES SGTHRS when vibration catches a stall StallGuard
  # missed, and LOWERS it after a run of quiet mid-travel trips that look like false
  # positives. Adjustments are ±1 register step at a time and clamped to a safe
  # band; each is logged and counted. Advanced/opt-in (default OFF) — it slowly
  # drifts a safety threshold, so enable it only once a baseline calibration is
  # trusted. A fresh Auto-Calibrate always overrides whatever it has drifted to.
  - platform: template
    name: "StallGuard Auto-Tune"
    id: sg_autotune
    entity_category: CONFIG
    web_server:
      sorting_weight: 7
      sorting_group_id: group_sg_adv
    optimistic: true
    restore_mode: RESTORE_DEFAULT_OFF
    turn_on_action:
      - logger.log: "StallGuard auto-tune enabled"
    turn_off_action:
      - logger.log: "StallGuard auto-tune disabled"

# -----------------------------------------------------------------------------
# Removed core entity
# -----------------------------------------------------------------------------
# Glasscalibur's motor direction is fixed counter-clockwise (set via the board's
# motor_direction_default substitution) and there is no runtime direction
# control, so drop core's "Motor Direction" select.
select:
  # Friendly speed presets. Values were chosen from an accelerometer resonance
  # sweep of this mechanism: there is a violent drivetrain resonance at ~2900-3300
  # (worst 3000-3100) that all three presets stay clear of. Slow 1200 is silent;
  # Medium 2600 sits just below the band; Fast 5500 is well above it (ramps only
  # cross the band transiently, which is harmless). Like Motor Direction on other
  # boards this holds no state of its own — it reads/writes global_speed (the
  # single source of truth, restored on boot). The raw Speed slider lives in the
  # advanced group. Changing speed re-flags the StallGuard calibration as stale
  # automatically (SG_RESULT is speed-dependent; see Calibration Status).
  - platform: template
    name: "Speed"
    id: sel_speed
    icon: "mdi:speedometer"
    entity_category: CONFIG
    web_server: { sorting_weight: 1, sorting_group_id: group_tuning }
    update_interval: 1s
    options: ["Slow", "Medium", "Fast"]
    lambda: |-
      const int sp = id(global_speed);
      if (sp <= 1900) return std::string("Slow");     // 1200
      if (sp <= 4050) return std::string("Medium");   // 2600
      return std::string("Fast");                     // 5500
    set_action:
      - lambda: |-
          int s = 5500;                               // Fast
          if (x.find("Slow") != std::string::npos) s = 1200;
          else if (x.find("Medium") != std::string::npos) s = 2600;
          id(global_speed) = s;
      - stepper.set_speed: { id: driver, speed: !lambda "return id(global_speed);" }
      - lambda: |-
          // Persist immediately so the choice survives an unplug seconds later.
          global_speed->update();
          global_preferences->sync();

  - id: !remove sel_direction

# -----------------------------------------------------------------------------
# Anti-tamper calibration / acknowledgement
# -----------------------------------------------------------------------------
# Press "Set Tamper Baseline" once the device is mounted in its final position
# and at rest — this captures the current X/Y/Z reading as the "untampered"
# reference. Any subsequent orientation change beyond Tamper Threshold (g)
# while IDLE flags Tamper Detected. The alert is latched so a bumped-then-
# replaced device doesn't silently un-flag; press "Clear Tamper Alert" to
# acknowledge.
button:
  - platform: template
    name: "Set Tamper Baseline"
    entity_category: CONFIG
    web_server:
      sorting_weight: 3
      sorting_group_id: group_security
    on_press:
      # Stored in g — see the note on the Tamper Detection switch.
      - globals.set:
          id: tamper_baseline_x
          value: !lambda "return id(accel_x).state / 9.80665f;"
      - globals.set:
          id: tamper_baseline_y
          value: !lambda "return id(accel_y).state / 9.80665f;"
      - globals.set:
          id: tamper_baseline_z
          value: !lambda "return id(accel_z).state / 9.80665f;"
      - script.stop: tamper_alarm
      - output.turn_off: buzzer
      - globals.set:
          id: tamper_detected
          value: "false"
      - if:
          condition:
            lambda: 'return id(global_state) == 3;'
          then:
            - globals.set:
                id: global_state
                value: "0"
      - logger.log:
          format: "Tamper baseline captured: x=%.3fg y=%.3fg z=%.3fg"
          args: ['id(accel_x).state / 9.80665f', 'id(accel_y).state / 9.80665f', 'id(accel_z).state / 9.80665f']

  - platform: template
    name: "Clear Tamper Alert"
    entity_category: CONFIG
    web_server:
      sorting_weight: 4
      sorting_group_id: group_security
    on_press:
      - script.stop: tamper_alarm
      - output.turn_off: buzzer
      - globals.set:
          id: tamper_detected
          value: "false"
      - if:
          condition:
            lambda: 'return id(global_state) == 3;'
          then:
            - globals.set:
                id: global_state
                value: "0"
      - logger.log: "Tamper alert cleared"

  # --- Lifetime counter resets ---
  - platform: template
    name: "Reset StallGuard Trips"
    entity_category: DIAGNOSTIC
    web_server:
      sorting_weight: 14
      sorting_group_id: group_diagnostics
    on_press:
      - globals.set:
          id: stallguard_count
          value: "0"
      - logger.log: "StallGuard trip counter reset"

  - platform: template
    name: "Reset Vibration Stall Trips"
    entity_category: DIAGNOSTIC
    web_server:
      sorting_weight: 15
      sorting_group_id: group_diagnostics
    on_press:
      - globals.set:
          id: vib_stall_count
          value: "0"
      - logger.log: "Vibration stall trip counter reset"

  - platform: template
    name: "Reset Tamper Trips"
    entity_category: DIAGNOSTIC
    web_server:
      sorting_weight: 16
      sorting_group_id: group_diagnostics
    on_press:
      - globals.set:
          id: tamper_count
          value: "0"
      - logger.log: "Tamper trip counter reset"

  # ("Update Firmware (GitHub)" and "Restart" come from core — core's GitHub-OTA
  # button already targets ${ota_repo}/${ota_asset} = Valar-Systems/Glasscalibur,
  # so the field OTA URL is byte-for-byte identical to what shipped.)

  # Start auto-calibration from the web UI / Home Assistant. Same entry point
  # as the GPIO21 double-click; all preconditions live in the script.
  - platform: template
    name: "Auto-Calibrate"
    entity_category: CONFIG
    web_server:
      sorting_weight: 1
      sorting_group_id: group_cal
    on_press:
      - script.execute: auto_calibrate

# (Open Time / Close Time datetime pickers and the Timezone text entity come from
# the scheduling mixin. The mixin's fixed-time and sun triggers call this product's
# schedule_open / schedule_close scripts, which carry the !cal_active guard — see
# the script block below.)

# -----------------------------------------------------------------------------
# I2C bus (shared by TMP1075 temperature sensor + LIS2DH12 accelerometer)
# -----------------------------------------------------------------------------
# scan: true prints all detected device addresses on boot — useful if the
# LIS2DH12 ends up at 0x18 instead of 0x19 on a particular board, or if the
# accel block fails to initialize.
i2c:
  sda: GPIO19
  scl: GPIO20
  scan: true
  id: i2c_bus

# -----------------------------------------------------------------------------
# LIS2DH12 accelerometer
# -----------------------------------------------------------------------------
# 3-axis MEMS accelerometer on the PCB. Used for two things:
#   1. Anti-tamper detection (checks orientation while IDLE).
#   2. Vibration-based stall detection (backstops StallGuard).
# SA0 is grounded on this board, so the I2C address is 0x18 (would be 0x19
# if SA0 were pulled to VDD).
lis2dh12_i2c:
  id: accelerometer
  i2c_id: i2c_bus
  address: 0x18
  range: 4G                  # ±4g — plenty for orientation + motor vibration
  resolution: high           # 12-bit reads
  output_data_rate: 100Hz    # chip samples 100x/sec
  # 500 ms keeps the draft PR's status-poll cost manageable (its sync DRDY
  # loop is what triggers "took a long time" warnings). The 1 s tamper check
  # and 200 ms vib-stall check read the cached value, so vib detection latency
  # is bounded by this — ~2.5 s worst case at the default 5-sample threshold,
  # acceptable for a window cover. Tighten if you want snappier stall reaction.
  update_interval: 500ms

# -----------------------------------------------------------------------------
# Diagnostic / live sensors
# -----------------------------------------------------------------------------
# Accelerometer x/y/z feed the anti-tamper and vibration-stall logic in the
# intervals at the bottom of the file. TSTEP / SG_RESULT are useful for tuning
# StallGuard sensitivity (drive the motor under load, watch SG_RESULT, set
# SGTHRS to about half of it). Motor temperature is hard-cut at 80 °C.
sensor:
  # Core's SG_RESULT / TSTEP readouts are StallGuard-tuning diagnostics; move them
  # from core's Diagnostics group down into the advanced StallGuard group with the
  # SGTHRS/TCOOLTHRS registers they help tune.
  - id: !extend sen_sgresult
    web_server: { sorting_weight: 4, sorting_group_id: group_sg_adv }
  - id: !extend sen_tstep
    web_server: { sorting_weight: 5, sorting_group_id: group_sg_adv }

  - platform: lis2dh12_base
    lis2dh12_id: accelerometer
    acceleration_x:
      name: "Accel X"
      id: accel_x
      entity_category: DIAGNOSTIC
      web_server:
        sorting_weight: 20
        sorting_group_id: group_diagnostics
    acceleration_y:
      name: "Accel Y"
      id: accel_y
      entity_category: DIAGNOSTIC
      web_server:
        sorting_weight: 21
        sorting_group_id: group_diagnostics
    acceleration_z:
      name: "Accel Z"
      id: accel_z
      entity_category: DIAGNOSTIC
      web_server:
        sorting_weight: 22
        sorting_group_id: group_diagnostics

  # (SG_RESULT and TSTEP diagnostic sensors come from core — sen_sgresult /
  # sen_tstep. Scripts read the registers directly, so nothing here depends on
  # the product's former "… Sensor" copies.)

  - platform: tmp1075
    name: "Motor Temperature"
    id: motor_temp     # referenced by the auto_calibrate temperature gate
    update_interval: 3s
    entity_category: DIAGNOSTIC
    web_server:
      sorting_weight: 7
      sorting_group_id: group_diagnostics
    i2c_id: i2c_bus
    address: 0x49
    accuracy_decimals: 2
    # --- ACTION ON TEMPERATURE EXAMPLE ---
    on_value_range:
      - above: 80
        then:
          - cover.stop: glasscalibur_cover
          - logger.log: "TOO HOT!"

    # USE ALERT PIN IN FUTURE instead of polling

  # (WiFi Signal, Uptime and ESP Internal Temperature come from core.)

  # --- Lifetime event counters (persisted in flash) ---
  # Bump on each respective event; survive reboots. To zero them, you'd need
  # to add reset buttons or temporarily flip restore_value: no and reflash.
  - platform: template
    name: "StallGuard Trips"
    lambda: 'return id(stallguard_count);'
    update_interval: 30s
    entity_category: DIAGNOSTIC
    accuracy_decimals: 0
    web_server:
      sorting_weight: 11
      sorting_group_id: group_diagnostics
  - platform: template
    name: "Vibration Stall Trips"
    lambda: 'return id(vib_stall_count);'
    update_interval: 30s
    entity_category: DIAGNOSTIC
    accuracy_decimals: 0
    web_server:
      sorting_weight: 12
      sorting_group_id: group_diagnostics
  - platform: template
    name: "Tamper Trips"
    lambda: 'return id(tamper_count);'
    update_interval: 30s
    entity_category: DIAGNOSTIC
    accuracy_decimals: 0
    web_server:
      sorting_weight: 13
      sorting_group_id: group_diagnostics
  - platform: template
    name: "Auto-Tune Adjustments"
    lambda: 'return id(sg_autotune_count);'
    update_interval: 30s
    entity_category: DIAGNOSTIC
    accuracy_decimals: 0
    web_server:
      sorting_weight: 6
      sorting_group_id: group_sg_adv

# -----------------------------------------------------------------------------
# State exposure (HA)
# -----------------------------------------------------------------------------
# Mirrors global_state to Home Assistant as a string. Polled rather than
# event-driven because transitions happen in many places; one poll is simpler
# than wiring publish() into every site.
# -----------------------------------------------------------------------------
# State exposure (HA / web UI)
# -----------------------------------------------------------------------------
# Mirrors global_state to a string. Polled at 500 ms rather than event-driven
# because state transitions happen in many places; one poll is simpler than
# wiring publish() into every transition site.
text_sensor:
  - platform: template
    name: "State"
    id: cover_state
    web_server:
      sorting_weight: 2
      sorting_group_id: group_control
    update_interval: 500ms
    lambda: |-
      switch (id(global_state)) {
        case 1: return {"OPENING"};
        case 2: return {"CLOSING"};
        case 3: return {"TAMPERED"};
        default: return {"IDLE"};
      }

  # (Firmware Version, Board, and the IP/SSID/MAC wifi_info sensors come from
  # core — core owns firmware_version_text and publishes it in on_boot.)

  # Calibration result, persisted across reboots. Appends STALE if Speed has
  # changed since calibration — SG_RESULT is speed-dependent, so a speed
  # change invalidates the StallGuard tune.
  - platform: template
    name: "Calibration Status"
    id: cal_status
    entity_category: DIAGNOSTIC
    web_server:
      sorting_weight: 2
      sorting_group_id: group_cal
    update_interval: 30s
    lambda: |-
      if (id(cal_active)) {
        switch (id(cal_phase)) {
          case 1: return {"Calibrating 1/3: closing to home position (normal)"};
          case 2: return {"Calibrating 2/3: opening - finding minimum current"};
          case 3: return {"Calibrating 3/3: closing - verifying"};
          default: return {"Calibrating - keep the window path clear"};
        }
      }
      char buf[120];
      switch (id(cal_result)) {
        case 1:
          snprintf(buf, sizeof(buf), "OK: irun=%d SGTHRS=%d (SGmin=%d, vib=%.2fg)",
                   id(cal_irun_chosen), id(cal_sgthrs_chosen),
                   id(cal_sgmin_seen), id(cal_vibmax_x100) / 100.0f);
          break;
        case 2:
          snprintf(buf, sizeof(buf), "OK (STICKY WINDOW): irun=%d SGTHRS=%d (SGmin=%d)",
                   id(cal_irun_chosen), id(cal_sgthrs_chosen), id(cal_sgmin_seen));
          break;
        case 3:
          return {"FAILED - window did not reach limits. Check track."};
        case 4:
          return {"FAILED - motor overheated mid-run. Cool 15 min, re-run."};
        case 5:
          return {"Aborted by user - run calibration again"};
        default:
          return {"Not calibrated"};
      }
      std::string s = buf;
      if (id(cal_speed_at) != 0 && id(cal_speed_at) != id(global_speed)) {
        s += " | STALE - speed changed, recalibrate";
      }
      return {s};

# -----------------------------------------------------------------------------
# Tamper alarm
# -----------------------------------------------------------------------------
# Pulses the buzzer for 60 seconds when tamper is first detected. 500 ms on /
# 500 ms off at 2700 Hz — more attention-grabbing than a steady tone. Stopped
# early by a Button 1 single-press, "Clear Tamper Alert", or "Set Tamper
# Baseline". mode: restart means a fresh tamper trip during an active alarm
# restarts the 60 s timer.
script:
  # Scheduling-mixin contract: the shared scheduling.yaml calls these on the
  # fixed Open/Close times and on sun transitions. It has already checked
  # "Schedule Enabled" (and sun mode); this product adds only its own guard —
  # never drive the cover into a calibration probe in progress (a scheduled move
  # mid-cal would re-target the stepper and corrupt it; it reconciles on the next
  # tick after calibration ends).
  - id: schedule_open
    then:
      - if:
          condition:
            lambda: 'return !id(cal_active);'
          then:
            - logger.log: "Schedule: opening cover"
            - cover.open: glasscalibur_cover
  - id: schedule_close
    then:
      - if:
          condition:
            lambda: 'return !id(cal_active);'
          then:
            - logger.log: "Schedule: closing cover"
            - cover.close: glasscalibur_cover

  - id: tamper_alarm
    mode: restart
    then:
      - repeat:
          count: 60
          then:
            - output.turn_on: buzzer
            - output.ledc.set_frequency:
                id: buzzer
                frequency: "2700Hz"
            - output.set_level:
                id: buzzer
                level: "50%"
            - delay: 500ms
            - output.turn_off: buzzer
            - delay: 500ms
      - output.turn_off: buzzer       # belt-and-suspenders if loop exits early

  # ===========================================================================
  # Auto-calibration (v1.3.0)
  # ===========================================================================
  # Finds the lowest reliable motor current and tunes both stall detectors to
  # this specific window, using the physical limit switches as ground truth.
  #
  #   1. Refuse when busy, tampered, already calibrating, or the motor is hot
  #      (>50 °C) or its temperature is NAN — sensor absent means thermal
  #      protection absent; refuse, never ignore.
  #   2. Announce: 3 beeps + 2 s stand-clear pause before ANY motion.
  #   3. Detector posture: StallGuard REACTION off (SGTHRS is the thing being
  #      tuned — a stale threshold would false-abort every probe). The
  #      vibration detector is forced ON as the backstop — it defaults OFF
  #      from the factory, so without the explicit turn-on a fresh unit would
  #      probe with no stall protection at all — and its threshold is raised
  #      to at least ${cal_vib_backstop} g for the duration (the user's value
  #      may itself be mistuned; it is one of calibration's outputs). A truly
  #      stalled probe still shakes far harder than that and fails in
  #      seconds instead of riding out the travel deadline.
  #   4. Home to the close limit at irun 19 (rated 0.6 A). The saved position
  #      can lie (skipped steps, stale flash), so homing first claims
  #      position = full-open: the close command then always covers the whole
  #      travel and the limit switch re-syncs position to 0 on arrival.
  #   5. Single-pass search (see cal_leg): ONE open travel escalating in
  #      place up the ladder {12, 15, 17, 19} — on vibration stall, SG
  #      margin starvation, silent step loss, or deadline, bump to the next
  #      current and resume from where it stopped — then ONE close travel
  #      validating the settled current over the full distance (escalating
  #      further if friction is direction-dependent). Success oracle = the
  #      LIMIT SWITCHES, never the step counter: an open-loop stepper that
  #      skipped steps still "arrives" at its software target, so every
  #      attempt re-claims a full travel of commanded distance. Each
  #      attempt gets a deadline computed from the LIVE speed
  #      (max_distance_steps / global_speed × 1.5 + 10 s); a fixed
  #      timeout cannot work — a full travel is ≈228 s at the default
  #      1500 steps/s and speed is user-tunable 100..10000. A spot that
  #      still stalls at 19 exhausts the ladder and fails the run: never
  #      muscle through what might be an obstruction.
  #   6. Outcome: SGTHRS = SGmin/4 — trip level (2×SGTHRS) = half the worst
  #      legitimate reading. NEVER SGmin/2: that puts the trip level AT the
  #      worst legitimate load and false-stalls instantly (the original
  #      tuning bug). Vibration Threshold = 3 × free-run max, clamped
  #      [0.15, 0.45] g.
  #   7. EVERY exit path (success, fail, homing bail-out, user abort in
  #      Button 1) re-enables BOTH detectors — ship-safe posture.
  #
  # Abort: Button 1 single-click (checked BEFORE Child Lock — stopping an
  # autonomous multi-travel sequence is a safety control, never lockable).
  # ===========================================================================
  - id: auto_calibrate
    mode: single
    then:
      # ---- 1. Preconditions ------------------------------------------------
      - if:
          condition:
            lambda: 'return id(global_state) != 0 || id(tamper_detected) || id(cal_active);'
          then:
            - logger.log: "CAL: refused - busy, tampered, or already calibrating"
            - script.stop: auto_calibrate
      - if:
          condition:
            lambda: 'return isnan(id(motor_temp).state) || id(motor_temp).state > 50.0f;'
          then:
            - logger.log:
                level: WARN
                format: "CAL: refused - motor temp %.1f degC (limit 50, NAN = sensor absent)"
                args: ['id(motor_temp).state']
            - script.stop: auto_calibrate

      - logger.log: "CAL: starting - keep the window path clear"
      - globals.set:
          id: cal_active
          value: 'true'
      - globals.set:
          id: cal_done
          value: 'false'
      - globals.set:
          id: cal_irun_index
          value: '0'
      - globals.set:
          id: cal_result
          value: '0'
      - globals.set:
          id: cal_phase
          value: '0'
      - component.update: cal_status

      # ---- 2. Announce: 3 beeps + 2 s stand-clear, before any motion -------
      - repeat:
          count: 3
          then:
            - output.ledc.set_frequency:
                id: buzzer
                frequency: "2700Hz"
            - output.set_level:
                id: buzzer
                level: "50%"
            - delay: 120ms
            - output.turn_off: buzzer
            - delay: 120ms
      - delay: 2s

      # ---- 3. Detector posture ---------------------------------------------
      - switch.turn_off: stallguard_enabled
      - switch.turn_on: vib_enabled
      - lambda: 'id(cal_vib_prev) = id(vib_threshold).state;'
      - number.set:
          id: vib_threshold
          value: !lambda |-
            float v = id(vib_threshold).state;
            float b = ${cal_vib_backstop};
            return (v > b) ? v : b;

      # ---- 4. Home to the close limit at full allowed current --------------
      - globals.set:
          id: cal_phase
          value: '1'
      - component.update: cal_status
      - globals.set:
          id: global_irun
          value: '19'
      - tmc2209.currents:
          irun: !lambda 'return id(global_irun);'
      - if:
          condition:
            binary_sensor.is_off: limit_switch_2
          then:
            - stepper.report_position:
                id: driver
                position: ${max_distance_steps}
            - lambda: |-
                int spd = id(global_speed);
                if (spd < 100) spd = 100;
                id(cal_budget_ms) = (uint32_t)(1000.0f * ${max_distance_steps} / (float)spd * 1.5f) + 10000;
                id(cal_t0_ms) = millis();
            - cover.close: glasscalibur_cover
            - wait_until:
                condition:
                  lambda: |-
                    return id(limit_switch_2).state || id(global_state) == 0 ||
                           (millis() - id(cal_t0_ms)) > id(cal_budget_ms);
      - if:
          condition:
            binary_sensor.is_off: limit_switch_2
          then:
            # Could not even home — bail out safe.
            - cover.stop: glasscalibur_cover
            - globals.set:
                id: cal_result
                value: '3'
            - number.set:
                id: vib_threshold
                value: !lambda 'return id(cal_vib_prev);'
            - switch.turn_on: stallguard_enabled
            - switch.turn_on: vib_enabled
            - globals.set:
                id: cal_active
                value: 'false'
            - logger.log:
                level: WARN
                format: "CAL: FAILED - could not reach the close limit"
            - script.execute: cal_beep_fail
            - component.update: cal_status
            - script.stop: auto_calibrate

      # ---- 5. Single-pass search: escalate in place up {12, 15, 17, 19} ---
      # One open travel + one close travel total. The open leg starts at the
      # lowest candidate and, on trouble (vibration stall, SG margin
      # starvation, silent step loss, deadline), bumps to the next current
      # and RESUMES from where it stopped — the limit switches remain the
      # only success oracle. The close leg then validates the settled
      # current over a full travel (friction can be direction-dependent),
      # escalating further if it must. Replaces the 4-probe × full-travel
      # search: ~2 travels instead of up to 11, which matters on an 80 g
      # motor that reached 61.5 °C mid-search in field testing.
      - globals.set:
          id: cal_irun_index
          value: '0'
      - script.execute:
          id: cal_leg
          opening: true
      - script.wait: cal_leg
      - if:
          condition:
            lambda: 'return id(cal_travel_ok);'
          then:
            # cal_irun_index deliberately carries over: the close leg starts
            # at the current the open leg settled on.
            - script.execute:
                id: cal_leg
                opening: false
            - script.wait: cal_leg
      - lambda: |-
          // cal_travel_ok now reflects the close leg (or stayed false if
          // the open leg exhausted the ladder). SG starvation escalates
          // DURING a leg, so completing at a sub-cap current implies
          // margin by construction; only a run that needed the full 19
          // with a thin observed minimum is flagged sticky (nothing higher
          // is allowed: 19 = rated 0.6 A against a 60 °C case limit).
          if (id(cal_travel_ok)) {
            id(cal_done) = true;
            id(cal_result) =
                (id(global_irun) == 19 && id(cal_sg_min) < ${cal_sg_floor}) ? 2 : 1;
          }

      # ---- 6. Outcome -------------------------------------------------------
      - if:
          condition:
            lambda: 'return id(cal_done);'
          then:
            - lambda: |-
                // SGTHRS = SGmin/4 -> trip level (2*SGTHRS) = half the worst
                // legitimate reading. NEVER SGmin/2 (trip level AT the worst
                // legitimate load = instant false stalls). Clamp to a sane
                // register range. SGmin==510 means the leg somehow gathered
                // no samples — keep the previous threshold rather than
                // tuning from an empty bucket (belt-and-braces; leg-level
                // accumulators make this near-impossible).
                int sgthrs = id(global_sgthrs);
                if (id(cal_sg_min) < 510) {
                  sgthrs = id(cal_sg_min) / 4;
                  if (sgthrs < 4)   sgthrs = 4;
                  if (sgthrs > 120) sgthrs = 120;
                }
                id(global_sgthrs)     = sgthrs;
                id(cal_sgthrs_chosen) = sgthrs;
                id(cal_irun_chosen)   = id(global_irun);
                id(cal_sgmin_seen)    = id(cal_sg_min);
                id(cal_vibmax_x100)   = (int)(id(cal_vib_max) * 100.0f);
                id(cal_speed_at)      = id(global_speed);
                // Arm StallGuard at the operating speed: the chip only
                // asserts stalls while TSTEP < TCOOLTHRS, so derive the
                // threshold from measured cruise TSTEP (×1.5 keeps the
                // acceleration ramp gated off, where SG readings false-
                // trip). The old fixed default (100) was BELOW cruise
                // TSTEP — StallGuard never fired in normal operation.
                if (id(cal_tstep_max) > 0) {
                  int tc = (id(cal_tstep_max) * 3) / 2;
                  if (tc > 1048575) tc = 1048575;
                  id(global_tcoolthrs) = tc;
                }
            - lambda: 'id(driver)->write_register(TCOOLTHRS, id(global_tcoolthrs));'
            - tmc2209.stallguard:
                threshold: !lambda 'return id(global_sgthrs);'
            # Vibration threshold = 3x the free-run maximum seen during the
            # winning probe, clamped [0.15, 0.45] g. Replaces the raised
            # calibration backstop AND whatever the user had before.
            - number.set:
                id: vib_threshold
                value: !lambda |-
                  float v = 3.0f * id(cal_vib_max);
                  if (v < 0.15f) v = 0.15f;
                  if (v > 0.45f) v = 0.45f;
                  return v;
            - logger.log:
                format: "CAL: done. irun=%d SGTHRS=%d SGmin=%d vib_free=%.2fg TCOOLTHRS=%d"
                args: ['id(cal_irun_chosen)', 'id(cal_sgthrs_chosen)',
                       'id(cal_sgmin_seen)', 'id(cal_vib_max)', 'id(global_tcoolthrs)']
            - script.execute: cal_beep_ok
          else:
            - globals.set:
                id: cal_result
                value: '3'
            # Failed: put the user's vibration threshold back (a successful
            # run replaces it with the tuned value instead).
            - number.set:
                id: vib_threshold
                value: !lambda 'return id(cal_vib_prev);'
            - logger.log:
                level: WARN
                format: "CAL: FAILED - window never reached both limits"
            - script.execute: cal_beep_fail

      # ---- 7. Always: ship-safe posture -------------------------------------
      - switch.turn_on: stallguard_enabled
      - switch.turn_on: vib_enabled
      - globals.set:
          id: cal_active
          value: 'false'
      - component.update: cal_status

  - id: cal_beep_ok
    mode: single
    then:
      - output.ledc.set_frequency:
          id: buzzer
          frequency: "2700Hz"
      - output.set_level:
          id: buzzer
          level: "50%"
      - delay: 120ms
      - output.turn_off: buzzer
      - delay: 120ms
      - output.set_level:
          id: buzzer
          level: "50%"
      - delay: 120ms
      - output.turn_off: buzzer

  - id: cal_beep_fail
    mode: single
    then:
      - repeat:
          count: 3
          then:
            - output.ledc.set_frequency:
                id: buzzer
                frequency: "1400Hz"
            - output.set_level:
                id: buzzer
                level: "50%"
            - delay: 400ms
            - output.turn_off: buzzer
            - delay: 150ms

  # Mid-run thermal guard for auto_calibrate. The 50 °C precondition only
  # runs once at start; a full search is up to ~11 travels and field testing
  # showed 49 °C at start → 55.9 °C three probes in. Called before every
  # calibration travel: above 55 °C (or NAN — no sensor means no protection)
  # it stops the whole sequence with the same ship-safe cleanup as every
  # other exit path. 55 = FW-2's derate level: 5 °C of margin under the
  # motor's 60 °C datasheet case limit.
  - id: cal_thermal_guard
    mode: single
    then:
      - if:
          condition:
            lambda: |-
              return id(cal_active) &&
                     (isnan(id(motor_temp).state) || id(motor_temp).state > 55.0f);
          then:
            - logger.log:
                level: WARN
                format: "CAL: thermal stop - motor %.1f degC (limit 55). Cool down, then re-run."
                args: ['id(motor_temp).state']
            - cover.stop: glasscalibur_cover
            - globals.set:
                id: cal_result
                value: '4'
            - number.set:
                id: vib_threshold
                value: !lambda 'return id(cal_vib_prev);'
            - switch.turn_on: stallguard_enabled
            - switch.turn_on: vib_enabled
            - globals.set:
                id: cal_active
                value: 'false'
            - script.execute: cal_beep_fail
            - component.update: cal_status
            # Must be last: kill the running leg, then the main sequence
            # (auto_calibrate is parked in script.wait: cal_leg).
            - script.stop: cal_leg
            - script.stop: auto_calibrate

  # One calibration travel ("leg") with in-place current escalation.
  # opening=true drives close→open (success oracle: limit_switch_1);
  # opening=false drives open→close (oracle: limit_switch_2). Each attempt
  # runs at CANDIDATES[cal_irun_index] and the leg climbs the ladder when:
  #   * the vibration detector declares a stall (it stops the motor and
  #     drops global_state to 0; its auto-release also backs the mechanism
  #     off ~8 mm, giving the next attempt a run-up at the sticky spot),
  #   * the sampler reports SG margin starvation (cal_escalate — escalates
  #     while still moving, before a violent stall develops),
  #   * the software step count "arrives" without the switch (silent step
  #     loss — vibration alone misses this), or
  #   * the per-attempt deadline expires.
  # Every attempt re-claims a FULL travel of commanded distance, so a lying
  # step counter can never end a leg — only the physical switch can.
  # Exhausting the ladder leaves cal_travel_ok false; the caller decides
  # what that means. Only ever executed from auto_calibrate.
  - id: cal_leg
    mode: single
    parameters:
      opening: bool
    then:
      - globals.set:
          id: cal_travel_ok
          value: 'false'
      - globals.set:
          id: cal_phase
          value: !lambda 'return opening ? 2 : 3;'
      - component.update: cal_status
      - lambda: |-
          // LEG-level tune accumulators. SGTHRS / vibration threshold /
          // TCOOLTHRS are tuned from the close (validation) leg's stats,
          // which resets them here and owns them for its whole travel.
          // They must NOT reset per attempt: a leg that escalates moments
          // before the switch leaves zero unmasked samples at the final
          // current — that shipped SGmin=510 -> SGTHRS=120 (trip level
          // above normal cruise readings) in field testing. Sub-final-
          // current samples in the mix only bias SGTHRS low = fewer false
          // trips, never more.
          id(cal_sg_min) = 510;
          id(cal_vib_max) = 0.0f;
          id(cal_tstep_max) = 0;
      - while:
          condition:
            lambda: |-
              bool sw = opening ? id(limit_switch_1).state : id(limit_switch_2).state;
              return !sw && id(cal_irun_index) < 4;
          then:
            - script.execute: cal_thermal_guard
            - lambda: |-
                static const int CANDIDATES[4] = {12, 15, 17, 19};
                id(global_irun) = CANDIDATES[id(cal_irun_index)];
                id(cal_escalate) = false;
                id(cal_sg_low_count) = 0;
            - tmc2209.currents:
                irun: !lambda 'return id(global_irun);'
            - logger.log:
                format: "CAL: %s leg at irun=%d"
                args: ['opening ? "open" : "close"', 'id(global_irun)']
            # Re-claim a full travel of commanded distance (the step counter
            # lies after a stall) and arm the speed-derived deadline.
            - lambda: |-
                id(driver)->report_position(opening ? 0 : ${max_distance_steps});
                int spd = id(global_speed);
                if (spd < 100) spd = 100;
                id(cal_budget_ms) = (uint32_t)(1000.0f * ${max_distance_steps} / (float)spd * 1.5f) + 10000;
                id(cal_t0_ms) = millis();
            - if:
                condition:
                  lambda: 'return opening;'
                then:
                  - cover.open: glasscalibur_cover
                else:
                  - cover.close: glasscalibur_cover
            - wait_until:
                condition:
                  lambda: |-
                    bool sw = opening ? id(limit_switch_1).state : id(limit_switch_2).state;
                    return sw || id(global_state) == 0 || id(cal_escalate) ||
                           (millis() - id(cal_t0_ms)) > id(cal_budget_ms);
            - if:
                condition:
                  lambda: 'return !(opening ? id(limit_switch_1).state : id(limit_switch_2).state);'
                then:
                  # No switch: stalled, starved, silently lost steps, or out
                  # of time. Stop (a starvation exit arrives here still
                  # moving) and climb to the next current. At the top of the
                  # ladder the while-condition ends the leg instead — a spot
                  # that still stalls at 19 is an obstruction or jam, never
                  # something to muscle through.
                  - cover.stop: glasscalibur_cover
                  - lambda: 'id(cal_irun_index) += 1;'
                  - delay: 300ms
      - lambda: |-
          id(cal_travel_ok) =
              opening ? id(limit_switch_1).state : id(limit_switch_2).state;

  # Second half of the stall auto-release handshake (see on_stall and the
  # vibration-stall interval). mode: restart so a second stall re-arms the
  # 5 s window instead of leaving the flag set forever: if this logic lived
  # inline in on_stall, a re-trigger during the delay would cancel the
  # pending clear and stall_release_active would stay latched until reboot,
  # silently disabling every future release.
  - id: stall_release_clear
    mode: restart
    then:
      - delay: 5s
      - globals.set:
          id: stall_release_active
          value: 'false'
      - globals.set:
          id: global_current_position
          value: !lambda 'return id(driver)->current_position;'

  # StallGuard auto-tune — lower-direction cross-check, run from the on_stall
  # handler. Records that StallGuard fired this move, then (only when the
  # "StallGuard Auto-Tune" switch is on and vibration detection is available)
  # decides whether the trip was real:
  #   - vibration agreed (peak >= half the Vibration Threshold)  -> real stall,
  #     the tune is fine; clear the quiet streak.
  #   - vibration stayed at free-run levels AND the trip was mid-travel (not near
  #     an end stop, where a decel/limit trip is expected) -> a probable false
  #     trip; bump the quiet streak. Only after THREE consecutive such trips —
  #     strong evidence of chronic over-sensitivity, since the accelerometer can
  #     miss a single fast stall — lower SGTHRS one step (harder to trip) and
  #     reset. Clamped to a safe floor. The raise direction lives in the vibration
  #     interval (it has the high-confidence signal). Small, bounded, opt-in, and
  #     every change is logged and counted.
  - id: sg_autotune_eval
    then:
      - lambda: |-
          id(sg_fired_this_move) = true;
          if (!id(sg_autotune).state || !id(vib_enabled).state) return;
          // Ignore trips near either end stop — a StallGuard trip as the sash
          // seats against a limit is expected, not a false positive.
          int32_t pos = id(driver)->current_position;
          float frac = (float)pos / (float)${max_distance_steps};
          if (frac < 0.05f || frac > 0.95f) return;
          float bar = 0.5f * id(vib_threshold).state;
          if (id(vib_run_peak) >= bar) {           // vibration agreed -> real stall
            id(sg_quiet_streak) = 0;
            return;
          }
          // Quiet mid-travel trip -> weak evidence of over-sensitivity.
          id(sg_quiet_streak) += 1;
          ESP_LOGI("sg_autotune", "quiet mid-travel StallGuard trip (%d/3), peak=%.3fg bar=%.3fg",
                   id(sg_quiet_streak), id(vib_run_peak), bar);
          if (id(sg_quiet_streak) >= 3) {
            int v = id(global_sgthrs) - 2;          // lower = less sensitive
            if (v < 2) v = 2;                       // safe floor
            if (v != id(global_sgthrs)) {
              id(global_sgthrs) = v;
              global_sgthrs->update();              // persist (restore_value global)
              id(driver)->write_register(SGTHRS, v);
              id(sg_autotune_count) += 1;
              ESP_LOGW("sg_autotune", "3 quiet trips -> lowering SGTHRS to %d (less sensitive)", v);
            }
            id(sg_quiet_streak) = 0;
          }

# -----------------------------------------------------------------------------
# Motion-completion poll
# -----------------------------------------------------------------------------
# The stepper has no "target reached" event, so we poll: if we're in
# OPENING/CLOSING and current_position has caught up to target_position, flip
# back to IDLE, tell the cover entity, and persist the final position. The
# limit-switch and on_stall paths already save inside their own handlers — this
# block only covers natural mid-travel arrivals (e.g. HA position-slider drags).
# -----------------------------------------------------------------------------
# Periodic intervals — motion completion, tamper check, vibration stall
# -----------------------------------------------------------------------------
# Three interval blocks run independently:
#   1. 200 ms — detects natural OPENING/CLOSING -> IDLE transitions (target
#               reached) and persists the final position to flash.
#   2. 1 s   — anti-tamper check; only runs while IDLE and tamper detection
#               is enabled. Latches tamper_detected, flips state to TAMPERED,
#               and fires the buzzer alarm script.
#   3. 200 ms — vibration-based stall check; only runs while OPENING/CLOSING.
#               Counts consecutive "loud" samples and runs the same stop+IDLE
#               path as on_stall if the threshold is crossed.
interval:
  - interval: 200ms
    then:
      - if:
          condition:
            lambda: |-
              int s = id(global_state);
              return (s == 1 || s == 2) &&
                     id(driver)->current_position == id(driver)->target_position;
          then:
            - globals.set:
                id: global_state
                value: "0"
            - cover.template.publish:
                id: glasscalibur_cover
                current_operation: IDLE
            - globals.set:
                id: global_current_position
                value: !lambda "return id(driver)->current_position;"

  # --- Anti-tamper check (only runs while IDLE so motion vibration can't
  #     trip it). Latches tamper_detected = true on first trip; the binary
  #     sensor follows the global; the "Clear Tamper Alert" button clears.
  - interval: 1s
    then:
      - if:
          condition:
            lambda: |-
              if (!id(tamper_enabled).state) return false;
              if (id(global_state) != 0) return false;
              // Calibration shakes the device between travels (state is
              // briefly 0 at each limit) — don't count that as tampering.
              if (id(cal_active)) return false;
              // Sensor states are m/s²; baselines and Tamper Threshold are
              // in g — normalize the live readings before comparing.
              constexpr float G_MS2 = 9.80665f;
              float dx = id(accel_x).state / G_MS2 - id(tamper_baseline_x);
              float dy = id(accel_y).state / G_MS2 - id(tamper_baseline_y);
              float dz = id(accel_z).state / G_MS2 - id(tamper_baseline_z);
              float dist = sqrtf(dx*dx + dy*dy + dz*dz);
              return dist > id(tamper_threshold).state;
          then:
            - globals.set:
                id: tamper_detected
                value: "true"
            - globals.set:
                id: global_state
                value: "3"
            - lambda: 'id(tamper_count) += 1;'
            - script.execute: tamper_alarm
            - logger.log:
                level: WARN
                format: "TAMPER DETECTED (deviation > %.2fg)"
                args: ['id(tamper_threshold).state']

  # --- Vibration-based stall check. Only active while OPENING/CLOSING.
  #     A stalled stepper shakes the device hard. We measure
  #     |sqrt(x^2+y^2+z^2) - 1g| (orientation-independent vibration amplitude
  #     — gravity always has magnitude 1g regardless of how the device is
  #     mounted, so subtracting 1g leaves only the non-gravity component).
  #     If that exceeds vib_threshold for vib_stall_samples consecutive ticks,
  #     run the same stop+IDLE path as the TMC2209 on_stall handler.
  - interval: 200ms
    then:
      - if:
          condition:
            lambda: |-
              // Launch mask: the acceleration ramp shakes the device hard —
              // steppers pass through their resonance band at low step rates,
              // and the leadscrew takes up slack — so vibration there reads
              // like a stall on a perfectly healthy travel. A fixed 500 ms
              // was shorter than the ramp itself (speed/accel = 1 s at the
              // 1500/1500 defaults), which false-tripped ~2 s into every
              // move. Mask 500 ms + the time to reach cruise speed, capped
              // at 3 s so extreme speed/accel settings can't blind the
              // detector for a whole travel.
              if (!id(vib_enabled).state) return false;
              if (id(global_state) != 1 && id(global_state) != 2) return false;
              int acc = id(global_acceleration);
              if (acc < 1) acc = 1;
              uint32_t mask_ms = 500 + (uint32_t)(1000.0f * id(global_speed) / (float)acc);
              if (mask_ms > 3000) mask_ms = 3000;
              return (millis() - id(motion_start_ms)) >= mask_ms;
          then:
            - lambda: |-
                // The LIS2DH12 publishes every 500 ms but this interval ticks
                // every 200 ms, so the same cached sample used to be counted
                // 2-3 times — "5 consecutive samples" tripped on only ~2
                // distinct readings (~1 s), not the ~2.5 s of sustained
                // judder the debounce was designed for. Count each fresh
                // sensor sample exactly once; an unchanged x/y/z triple is
                // the same cached reading, not new evidence.
                static float last_x = 1e9f, last_y = 1e9f, last_z = 1e9f;
                float x = id(accel_x).state;
                float y = id(accel_y).state;
                float z = id(accel_z).state;
                if (x == last_x && y == last_y && z == last_z) return;
                last_x = x; last_y = y; last_z = z;
                // UNITS: the LIS2DH12 publishes m/s² (ESPHome convention);
                // every threshold in this config is in g. Normalize BEFORE
                // subtracting the 1 g gravity magnitude — without the
                // division this computes ≈9 "g" of vibration at rest, every
                // sample counts as loud, and any move is killed as soon as
                // the launch mask expires (this false-failed calibration).
                constexpr float G_MS2 = 9.80665f;
                float mag_g = sqrtf(x*x + y*y + z*z) / G_MS2;
                float vibration = fabsf(mag_g - 1.0f);
                // Track the peak vibration this travel for the StallGuard
                // auto-tune cross-check (see sg_autotune_eval).
                if (vibration > id(vib_run_peak)) id(vib_run_peak) = vibration;
                // Asymmetric leaky counter: +2 on loud, -1 on quiet
                // (floored at 0). A skipping stall's judder alternates
                // violent and quiet readings at this 500 ms sample cadence;
                // the old symmetric ±1 dithered near zero through a real
                // multi-second field stall and never tripped. With +2/-1,
                // loud-dominant sampling reaches the 5-sample default in
                // ~2 s while an isolated jolt (+2, then decay) still
                // cannot trip it.
                if (vibration > id(vib_threshold).state) {
                  id(vib_loud_count) += 2;
                } else if (id(vib_loud_count) > 0) {
                  id(vib_loud_count) -= 1;
                }
            - if:
                condition:
                  lambda: 'return id(vib_loud_count) >= (int)id(vib_stall_samples).state;'
                then:
                  - logger.log:
                      level: WARN
                      format: "VIBRATION STALL — strong vibration for %d samples"
                      args: ['id(vib_loud_count)']
                  - stepper.stop: driver
                  - lambda: 'id(vib_stall_count) += 1;'
                  # StallGuard auto-tune — RAISE direction (high confidence). The
                  # vibration detector needed sustained judder to trip, so this is
                  # a real stall. If StallGuard was armed but did NOT fire during
                  # this travel, it was too insensitive and missed it -> raise
                  # SGTHRS one step (easier to trip), clamped to a safe ceiling.
                  - if:
                      condition:
                        lambda: 'return id(sg_autotune).state && id(stallguard_enabled).state && !id(sg_fired_this_move);'
                      then:
                        - lambda: |-
                            int v = id(global_sgthrs) + 2;   // higher = more sensitive
                            if (v > 60) v = 60;              // safe ceiling for this device
                            if (v != id(global_sgthrs)) {
                              id(global_sgthrs) = v;
                              global_sgthrs->update();
                              id(driver)->write_register(SGTHRS, v);
                              id(sg_autotune_count) += 1;
                              id(sg_quiet_streak) = 0;
                              ESP_LOGW("sg_autotune", "vibration caught a stall StallGuard missed -> raising SGTHRS to %d", v);
                            }
                  # Stall auto-release — same behavior as the StallGuard
                  # on_stall path (the leadscrew holds clamp force until
                  # reversed). Runs BEFORE global_state is zeroed: the stall
                  # direction decides which way to back off. One release per
                  # event via stall_release_active. This path stays live
                  # during calibration (it is the calibration backstop); the
                  # cal script's own cover.stop may truncate the back-off,
                  # which is fine — the probe has already failed safe.
                  - if:
                      condition:
                        lambda: 'return !id(stall_release_active);'
                      then:
                        - globals.set:
                            id: stall_release_active
                            value: 'true'
                        - lambda: |-
                            int32_t pos = id(driver)->current_position;
                            int32_t rel = ${stall_release_steps};
                            int32_t tgt = (id(global_state) == 2) ? pos + rel : pos - rel;
                            if (tgt < 0) tgt = 0;
                            id(driver)->set_target(tgt);
                        - script.execute: stall_release_clear
                  - globals.set:
                      id: global_state
                      value: "0"
                  - cover.template.publish:
                      id: glasscalibur_cover
                      current_operation: IDLE
                  - globals.set:
                      id: global_current_position
                      value: !lambda "return id(driver)->current_position;"
                  - globals.set:
                      id: vib_loud_count
                      value: "0"
          else:
            # Reset the counter whenever we're not commanded to move so the
            # next move starts fresh.
            - globals.set:
                id: vib_loud_count
                value: "0"

  # (The sun-schedule poll now lives in the scheduling mixin's own 60 s interval,
  # which calls this product's schedule_open / schedule_close scripts.)

  # ---------------------------------------------------------------------------
  # Auto-calibration sampler
  # ---------------------------------------------------------------------------
  # Fast SG_RESULT / vibration sampler feeding the auto_calibrate script. Runs
  # only while calibrating, only while a travel is in progress, and only after
  # the launch mask (same ramp-aware mask as the vibration-stall detector,
  # +100 ms so the free-run baseline never includes ramp shake — a polluted
  # baseline would inflate the tuned Vibration Threshold toward its clamp).
  # cal_vib_max takes a running max, so the accelerometer's 500 ms cadence
  # only limits how often it can rise, not its correctness.
  - interval: 100ms
    then:
      - if:
          condition:
            lambda: |-
              if (!id(cal_active)) return false;
              if (id(global_state) != 1 && id(global_state) != 2) return false;
              // Only while actually driving toward the target. At software
              // arrival there is a ≤200 ms window before the completion
              // poll zeroes global_state, in which the motor has already
              // stopped: TSTEP decays toward its 1048575 idle ceiling and
              // SG_RESULT reads near zero. One tick inside that window
              // shipped TCOOLTHRS=37098 (mid-decay TSTEP × 1.5) and a fake
              // SGmin in field testing.
              if (id(driver)->current_position == id(driver)->target_position) return false;
              int acc = id(global_acceleration);
              if (acc < 1) acc = 1;
              uint32_t mask_ms = 600 + (uint32_t)(1000.0f * id(global_speed) / (float)acc);
              if (mask_ms > 3100) mask_ms = 3100;
              return (millis() - id(motion_start_ms)) > mask_ms;
          then:
            - lambda: |-
                // Cruise TSTEP (slowest sample survives) -> TCOOLTHRS on
                // success. 1048575 is the register's "stopped" value.
                int ts = id(driver)->read_register(TSTEP);
                if (ts > 0 && ts < 1048575 && ts > id(cal_tstep_max)) {
                  id(cal_tstep_max) = ts;
                }
                int sg = id(driver)->read_register(SG_RESULT);
                if (sg >= 0 && sg <= 510) {
                  if (sg < id(cal_sg_min)) id(cal_sg_min) = sg;
                  // Margin starvation -> escalate: net 8 low ticks below the
                  // floor asks cal_leg for the next current while the motor
                  // is still moving — earlier and quieter than a full
                  // vibration stall, and it bakes the margin requirement
                  // into the search itself. LEAKY counter (+1 low / -1
                  // high), NOT reset-on-good: a skipping stall oscillates
                  // SG_RESULT wildly sample-to-sample, and consecutive
                  // counting never accumulated during a real field stall —
                  // the motor ground at the jam until the step counter ran
                  // out instead.
                  if (sg < ${cal_sg_floor}) {
                    id(cal_sg_low_count) += 1;
                    if (id(cal_sg_low_count) >= 8) id(cal_escalate) = true;
                  } else if (id(cal_sg_low_count) > 0) {
                    id(cal_sg_low_count) -= 1;
                  }
                }
                float x = id(accel_x).state;
                float y = id(accel_y).state;
                float z = id(accel_z).state;
                if (!isnan(x) && !isnan(y) && !isnan(z)) {
                  // Sensor publishes m/s²; cal math (and the Vibration
                  // Threshold this feeds) is in g — normalize first.
                  constexpr float G_MS2 = 9.80665f;
                  float vib = fabsf(sqrtf(x*x + y*y + z*z) / G_MS2 - 1.0f);
                  if (vib > id(cal_vib_max)) id(cal_vib_max) = vib;
                }