supersensor.yaml

---

###############################################################################
# SuperSensor v3.0 ESPHome configuration
###############################################################################
#
#    Copyright (C) 2025 Joshua M. Boniface <joshua@boniface.me>
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, version 3.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see <https://www.gnu.org/licenses/>.
#
###############################################################################

esphome:
  name: supersensor
  name_add_mac_suffix: true
  friendly_name: "Supersensor"
  project:
    name: joshuaboniface.supersensor
    version: "3.0"
  min_version: 2026.3.0
  on_boot:
    - priority: 600
      then:
        - light.turn_on:
            id: output_led
        - delay: 0.25s
        - light.turn_off:
            id: output_led
        - delay: 0.25s
        - light.turn_on:
            id: output_led
        - delay: 0.25s
        - light.turn_off:
            id: output_led
        - lambda: |-
            id(supersensor_occupancy).publish_state(false);
            id(pir_presence).publish_state(false);
            id(light_presence).publish_state(false);
            id(radar_presence).publish_state(false);
            id(ld2410c_calibration_status).publish_state("Idle");
    - priority: -100
      then:
        - if:
            condition:
              - switch.is_on: enable_voice_support
            then:
              - micro_wake_word.start:

preferences:
  flash_write_interval: 15sec

dashboard_import:
  package_import_url: github://joshuaboniface/supersensor/supersensor.yaml@v3.x

esp32:
  variant: esp32s3
  flash_size: 8MB
  cpu_frequency: 240MHz
  framework:
    type: esp-idf

psram:
  # We use an ESP32-S3-N8R2 as reference
  mode: quad
  speed: 80MHz

globals:
  #
  # SHT45 offsets
  #
  - id: temperature_offset
    type: float
    restore_value: true
    initial_value: "-2.0"

  - id: humidity_offset
    type: float
    restore_value: true
    initial_value: "0.0"

  #
  # Room Health settings
  #
  - id: room_health_temperature_min
    type: float
    restore_value: true
    initial_value: "21.0"

  - id: room_health_temperature_max
    type: float
    restore_value: true
    initial_value: "24.0"

  - id: room_health_temperature_penalty
    type: float
    restore_value: true
    initial_value: "10.0"

  - id: room_health_humidity_min
    type: float
    restore_value: true
    initial_value: "40.0"

  - id: room_health_humidity_max
    type: float
    restore_value: true
    initial_value: "60.0"

  - id: room_health_humidity_penalty
    type: float
    restore_value: true
    initial_value: "5.0"

  - id: room_health_voc_weight
    type: float
    restore_value: true
    initial_value: "0.4"

  - id: room_health_temperature_weight
    type: float
    restore_value: true
    initial_value: "0.3"

  - id: room_health_humidity_weight
    type: float
    restore_value: true
    initial_value: "0.3"

  #
  # PIR settings
  #
  - id: pir_hold_time
    type: int
    restore_value: true
    initial_value: "15"

  #
  # Light settings
  #
  - id: light_presence_threshold
    type: int
    restore_value: true
    initial_value: "30"

  #
  # Occupancy settings
  #
  - id: occupancy_detect_mode
    type: int
    restore_value: true
    initial_value: "0"

  - id: occupancy_clear_mode
    type: int
    restore_value: true
    initial_value: "0"

  #
  # API connection tracker
  #
  - id: last_api_connected_time
    type: uint32_t
    restore_value: no
    initial_value: "0"

  #
  # LD2410C ACK tracking (for the calibration sequence)
  #
  - id: ld2410_last_ack_cmd
    type: int
    restore_value: no
    initial_value: "-1"

  - id: ld2410_last_ack_status
    type: int
    restore_value: no
    initial_value: "-1"

  #
  # Wake Word settings
  #
  - id: current_wake_word
    type: std::string
    restore_value: yes
    initial_value: '"mww_computer"'

  #
  # LED Brightness settings
  #
  - id: led_presence_brightness
    type: int
    restore_value: yes
    initial_value: '25'

  - id: led_listening_brightness
    type: int
    restore_value: yes
    initial_value: '100'

  - id: led_processing_brightness
    type: int
    restore_value: yes
    initial_value: '75'

  - id: led_responding_brightness
    type: int
    restore_value: yes
    initial_value: '100'

  #
  # LED State Machine (priority-based)
  #
  - id: led_state
    type: int
    restore_value: no
    initial_value: '0'      # 0=idle, 1=hold, 2=pipeline

  - id: led_substate
    type: int
    restore_value: no
    initial_value: '0'      # 0 idle, 1 listen, 2 stt, 3 success, 4 fail

  - id: led_hold_until
    type: uint32_t
    restore_value: no
    initial_value: '0'

script:
  #
  # LED State Machine (priority-based)
  #
  #  Idle -> VA Listening -> VA STT -> VA Responding -> 5s --|
  #  0,0     2,1             2,2       1,3/4            |    |
  #  ^       ^                                          v    |
  #  |       |------------------------------------------+    v
  #  --------------------------------------------------------+
  # 
  - id: led_start
    mode: queued
    then:
      - if:
          condition:
            lambda: 'return id(led_state)<2;'
          then:
            # If we're in idle or holding state, just re-render (triggered by holds themselves and idle LED updates)
            - script.execute: led_render
          else:
            # If we're in pipeline state, stop any existing holds and clear them, then re-render
            - script.stop: led_hold_timer
            - script.execute: led_clear_hold
            - script.execute: led_render

  - id: led_hold_timer
    mode: restart
    then:
      # Hold execution; delay for 5s, then clear the hold and re-render
      - delay: 5s
      - script.execute: led_clear_hold
      - script.execute: led_render

  - id: led_clear_hold
    then:
      # Clear an existing hold state if applicable
      - lambda: |-
          if (id(led_state)==1) {
            id(led_state)=0;
            id(led_substate)=0;
          }

  - id: led_render
    then:
      # Render LED colours based on current state and substate
      - if:
          condition:
            lambda: 'return id(led_state)==2 && id(led_substate)==1;'
          then:
            - script.execute: led_blue
      - if:
          condition:
            lambda: 'return id(led_state)==2 && id(led_substate)==2;'
          then:
            - script.execute: led_cyan
      - if:
          condition:
            lambda: 'return id(led_state)==1 && id(led_substate)==3;'
          then:
            - script.execute: led_green
      - if:
          condition:
            lambda: 'return id(led_state)==1 && id(led_substate)==4;'
          then:
            - script.execute: led_red
      - if:
          condition:
            lambda: 'return id(led_state)==0;'
          then:
            - if:
                condition:
                  - binary_sensor.is_on: supersensor_occupancy
                  - switch.is_on: enable_presence_led
                then:
                  - script.execute: led_dim_white
                else:
                  - script.execute: led_off

  - id: led_blue
    then:
      - light.turn_on:
          id: output_led
          red: 0
          green: 0
          blue: 1
          brightness: !lambda 'return id(led_listening_brightness) / 100.0;'

  - id: led_cyan
    then:
      - light.turn_on:
          id: output_led
          red: 0
          green: 1
          blue: 1
          brightness: !lambda 'return id(led_processing_brightness) / 100.0;'

  - id: led_green
    then:
      - light.turn_on:
          id: output_led
          red: 0
          green: 1
          blue: 0
          brightness: !lambda 'return id(led_responding_brightness) / 100.0;'

  - id: led_red
    then:
      - light.turn_on:
          id: output_led
          red: 1
          green: 0
          blue: 0
          brightness: !lambda 'return id(led_responding_brightness) / 100.0;'

  - id: led_dim_white
    then:
      - light.turn_on:
          id: output_led
          red: 1
          green: 1
          blue: 1
          brightness: !lambda 'return id(led_presence_brightness) / 100.0;'

  - id: led_off
    then:
      - light.turn_off:
          id: output_led

  #
  # Occupancy handlers
  #
  - id: pir_handler
    then:
      - lambda: |-
          id(pir_presence).publish_state(true);
      - while:
          condition:
            binary_sensor.is_on: pir_gpio
          then:
            - delay: !lambda 'return(id(pir_hold_time) * 1000);'
      - lambda: |-
          id(pir_presence).publish_state(false);

  - id: light_handler
    then:
      - lambda: |-
          if (id(tsl2591_lux).state >= id(light_presence_threshold)) {
            id(light_presence).publish_state(true);
          } else {
            id(light_presence).publish_state(false);
          }

  - id: occupancy_detect_handler
    then:
      - lambda: |-
          ESP_LOGD("occupancy_detect_handler", "Occupancy detect handler triggered");

          // Get the current values of our presence sensors
          bool pir = id(pir_presence).state;
          bool radar = id(radar_presence).state;
          bool light = id(light_presence).state;

          // Determine if PIR counts (2nd bit of presence_type)
          int pir_counts = (id(occupancy_detect_mode) & ( 1 << 2 )) >> 2;

          // Determine if Radar counts (1st bit of presence_type)
          int radar_counts = (id(occupancy_detect_mode) & ( 1 << 1 )) >> 1;

          // Determine if Light counts (0th bit of presence_type)
          int light_counts = (id(occupancy_detect_mode) & ( 1 << 0 )) >> 0;

          // Determine our results
          bool new_state = false;
          if (pir_counts & radar_counts & light_counts) {
            // Logical AND of pir & radar & light
            new_state = pir & radar & light;
          } else if (pir_counts & radar_counts) {
            // Logical AND of pir & radar
            new_state = pir & radar;
          } else if (pir_counts & light_counts) {
            // Logical AND of pir & light
            new_state = pir & light;
          } else if (radar_counts & light_counts) {
            // Logical AND of radar & light
            new_state = radar & light;
          } else if (pir_counts) {
            // Only pir
            new_state = pir;
          } else if (radar_counts) {
            // Only radar
            new_state = radar;
          } else if (light_counts) {
            // Only light
            new_state = light;
          }

          ESP_LOGD("occupancy_detect_handler", "New state: %s", new_state ? "true" : "false");

          // Force update even if state hasn't changed
          id(supersensor_occupancy).publish_state(new_state);

          // Add a delayed re-publish to ensure state propagation
          if (new_state) {
            id(supersensor_occupancy).publish_state(new_state);
          }

  - id: occupancy_clear_handler
    then:
      - lambda: |-
          ESP_LOGD("occupancy_clear_handler", "Occupancy clear handler triggered");

          // Get the current values of our presence sensors
          bool pir = id(pir_presence).state;
          bool radar = id(radar_presence).state;
          bool light = id(light_presence).state;

          // Determine if PIR counts (2nd bit of presence_type)
          int pir_counts = (id(occupancy_clear_mode) & ( 1 << 2 )) >> 2;

          // Determine if Radar counts (1st bit of presence_type)
          int radar_counts = (id(occupancy_clear_mode) & ( 1 << 1 )) >> 1;

          // Determine if Light counts (0th bit of presence_type)
          int light_counts = (id(occupancy_clear_mode) & ( 1 << 0 )) >> 0;

          // Determine our results
          bool new_state = false;
          if (pir_counts & radar_counts & light_counts) {
            // Logical AND of pir & radar & light
            new_state = pir & radar & light;
          } else if (pir_counts & radar_counts) {
            // Logical AND of pir & radar
            new_state = pir & radar;
          } else if (pir_counts & light_counts) {
            // Logical AND of pir & light
            new_state = pir & light;
          } else if (radar_counts & light_counts) {
            // Logical AND of radar & light
            new_state = radar & light;
          } else if (pir_counts) {
            // Only pir
            new_state = pir;
          } else if (radar_counts) {
            // Only radar
            new_state = radar;
          } else if (light_counts) {
            // Only light
            new_state = light;
          }

          ESP_LOGD("occupancy_clear_handler", "New state: %s", new_state ? "true" : "false");

          // Force update even if state hasn't changed
          id(supersensor_occupancy).publish_state(new_state);

          // Add a delayed re-publish to ensure state propagation
          if (!new_state) {
            id(supersensor_occupancy).publish_state(new_state);
          }

  #
  # LD2410C calibration handlers
  #
  # Runs the LD2410C's built-in auto-threshold (background noise) calibration
  # for 900 seconds, then adds +2 headroom to every gate threshold it found,
  # since the auto routine reports measured maximums and we want a safe margin.
  # Courtesy of esauvisky on https://community.home-assistant.io/t/ld2410-esphome-tips/477058/811
  #
  - id: ld2410_calibration
    mode: single
    then:
      # 1. Give the user 10 seconds to clear the room
      - logger.log: "INFO: Starting LD2410 calibration sequence... You have 10 seconds to clear the room!"
      - lambda: 'id(ld2410c_calibration_status).publish_state("Waiting");'
      - delay: 10s

      # 2. Enable Configuration Mode
      - logger.log: "DEBUG: Sending Enable Configuration command (0x00FF)"
      - lambda: 'id(ld2410_last_ack_cmd) = -1; id(ld2410_last_ack_status) = -1;'
      - uart.write:
          id: ld2410_uart
          # Data: HDR | LEN=4 | CMD=0xFF | VAL=0x01 | FTR
          data: [0xFD, 0xFC, 0xFB, 0xFA, 0x04, 0x00, 0xFF, 0x00, 0x01, 0x00, 0x04, 0x03, 0x02, 0x01]
      - delay: 1000ms
      - if:
          condition:
            lambda: 'return !(id(ld2410_last_ack_cmd) == 0xFF && id(ld2410_last_ack_status) == 0);'
          then:
            - script.execute: ld2410_calibration_fail
            - script.stop: ld2410_calibration

      # 3. Start the auto-calibration (900 seconds)
      - logger.log: "DEBUG: Sending Start Calibration command (0x000B, 900s)"
      - lambda: 'id(ld2410_last_ack_cmd) = -1; id(ld2410_last_ack_status) = -1;'
      - uart.write:
          id: ld2410_uart
          # Data: HDR | LEN=4 | CMD=0x0B | VAL=0x0384 (900, little-endian) | FTR
          data: [0xFD, 0xFC, 0xFB, 0xFA, 0x04, 0x00, 0x0B, 0x00, 0x84, 0x03, 0x04, 0x03, 0x02, 0x01]
      - delay: 1000ms
      - if:
          condition:
            lambda: 'return !(id(ld2410_last_ack_cmd) == 0x0B && id(ld2410_last_ack_status) == 0);'
          then:
            - script.execute: ld2410_calibration_fail
            - script.stop: ld2410_calibration

      # 4. Disable Configuration Mode
      - logger.log: "DEBUG: Sending End Configuration command (0x00FE)"
      - uart.write:
          id: ld2410_uart
          # Data: HDR | LEN=2 | CMD=0xFE | FTR (No value needed)
          data: [0xFD, 0xFC, 0xFB, 0xFA, 0x02, 0x00, 0xFE, 0x00, 0x04, 0x03, 0x02, 0x01]
      - logger.log: "INFO: LD2410 calibration sequence sent. Ensure room remains empty for 930+ seconds!"
      - lambda: 'id(ld2410c_calibration_status).publish_state("Calibrating");'

      # 5. Wait 930s (900s run + 30s of buffer) and then query parameters
      - delay: 930s
      - lambda: 'id(ld2410c_calibration_status).publish_state("Polling");'
      - button.press: ld2410c_query_params
      - delay: 5s

      # 6. Add +2 headroom to each gate threshold found by the auto-calibration
      - logger.log: "INFO: Adding +2 headroom to all LD2410 gate thresholds"
      - repeat:
          count: 9
          then:
            - lambda: |-
                number::Number *move_thresholds[9] = {
                  id(ld2410c_g0_move_threshold), id(ld2410c_g1_move_threshold),
                  id(ld2410c_g2_move_threshold), id(ld2410c_g3_move_threshold),
                  id(ld2410c_g4_move_threshold), id(ld2410c_g5_move_threshold),
                  id(ld2410c_g6_move_threshold), id(ld2410c_g7_move_threshold),
                  id(ld2410c_g8_move_threshold)
                };
                number::Number *still_thresholds[9] = {
                  id(ld2410c_g0_still_threshold), id(ld2410c_g1_still_threshold),
                  id(ld2410c_g2_still_threshold), id(ld2410c_g3_still_threshold),
                  id(ld2410c_g4_still_threshold), id(ld2410c_g5_still_threshold),
                  id(ld2410c_g6_still_threshold), id(ld2410c_g7_still_threshold),
                  id(ld2410c_g8_still_threshold)
                };
                auto bump = [](number::Number *threshold) {
                  if (isnan(threshold->state)) return;
                  float value = threshold->state + 2.0f;
                  if (value > 100.0f) value = 100.0f;
                  auto call = threshold->make_call();
                  call.set_value(value);
                  call.perform();
                };
                bump(move_thresholds[iteration]);
                bump(still_thresholds[iteration]);
            - delay: 500ms

      # 7. Re-query parameters to confirm the final values
      - button.press: ld2410c_query_params
      - delay: 5s
      - lambda: 'id(ld2410c_calibration_status).publish_state("Done");'
      - logger.log: "INFO: LD2410 calibration finished."

  - id: ld2410_calibration_fail
    then:
      - logger.log:
          level: ERROR
          format: "LD2410 calibration failed (last ACK command: %d, status: %d)"
          args: ['id(ld2410_last_ack_cmd)', 'id(ld2410_last_ack_status)']
      - lambda: 'id(ld2410c_calibration_status).publish_state("Failed");'
      # Try to leave Configuration Mode cleanly in case it was enabled
      - uart.write:
          id: ld2410_uart
          # Data: HDR | LEN=2 | CMD=0xFE | FTR (No value needed)
          data: [0xFD, 0xFC, 0xFB, 0xFA, 0x02, 0x00, 0xFE, 0x00, 0x04, 0x03, 0x02, 0x01]

interval:
  # Regular LD2410C state check every 30s (skipped while calibration is running)
  - interval: 30s
    then:
      - if:
          condition:
            - not:
                script.is_running: ld2410_calibration
          then:
            - lambda: |-
                if(isnan(id(ld2410c_presence_distance).state)) {
                  ESP_LOGI("radar_watchdog", "LD2410C not reporting stats; restarting");
                  id(ld2410c_restart).press();
                }

  # Regular MWW state check every 30s
  - interval: 30s
    then:
      - if:
          condition:
            - switch.is_on: enable_voice_support
            - not:
                micro_wake_word.is_running
          then:
            - micro_wake_word.start:

  # Regular occupancy state reporting to HASS every 30s
  - interval: 30s
    then:
      - lambda: |-
          bool current_state = id(supersensor_occupancy).state;
          ESP_LOGD("state_reporter", "Republishing occupancy state: %s", current_state ? "true" : "false");
          id(supersensor_occupancy).publish_state(current_state);

  # API watchdog every 5 minutes
  - interval: 300s
    then:
      - lambda: |-
          if (api::global_api_server->is_connected()) {
            id(last_api_connected_time) = millis();
          } else if (millis() - id(last_api_connected_time) > 300000) {
            ESP_LOGE("api_watchdog", "API disconnected for too long, rebooting...");
            App.safe_reboot();
          }

logger:
  level: DEBUG
  baud_rate: 115200
  # Log to COM output USB port
  hardware_uart: UART0
  # Ensure boot logs are captured when opening the port
  deassert_rts_dtr: true

api:
  reboot_timeout: 15min

ota:
  platform: esphome

web_server:
  port: 80

captive_portal:

mdns:
  disabled: false

wifi:
  ap: {}
  domain: ""
  output_power: 8.5dB
  reboot_timeout: 15min
  power_save_mode: none

time:
  - platform: homeassistant
    id: homeassistant_time
    on_time_sync:
      then:
        - logger.log: "Time synchronized with Home Assistant"

debug:
  update_interval: 15s

uart:
  id: ld2410_uart
  rx_pin: GPIO18
  tx_pin: GPIO17
  baud_rate: 256000
  data_bits: 8
  stop_bits: 1
  parity: NONE
  # Tap RX traffic to capture LD2410 command ACK frames for the calibration
  # sequence; this observes the data without consuming it from the ld2410
  # component, so normal operation is unaffected
  debug:
    direction: RX
    after:
      delimiter: [0x04, 0x03, 0x02, 0x01]
    sequence:
      - lambda: |-
          // Scan for LD2410 ACK frames:
          //   HDR (FD FC FB FA) | LEN | CMD|0x0100 | STATUS | ... | FTR (04 03 02 01)
          // Status 0 = success, 1 = failure
          for (size_t i = 0; i + 9 < bytes.size(); i++) {
            if (bytes[i] == 0xFD && bytes[i+1] == 0xFC && bytes[i+2] == 0xFB && bytes[i+3] == 0xFA) {
              uint16_t cmd = bytes[i+6] | (bytes[i+7] << 8);
              uint16_t status = bytes[i+8] | (bytes[i+9] << 8);
              if ((cmd & 0xFF00) == 0x0100) {
                id(ld2410_last_ack_cmd) = cmd & 0x00FF;
                id(ld2410_last_ack_status) = status;
                ESP_LOGD("ld2410_ack", "Got ACK for command 0x%02X with status %d", cmd & 0x00FF, status);
              }
            }
          }

i2c:
  sda: GPIO35
  scl: GPIO36
  scan: true

i2s_audio:
  - id: i2s_input
    i2s_lrclk_pin:
      number: GPIO5      # WS
    i2s_bclk_pin:
      number: GPIO6      # SCK

  # Dummy I2S audio pipeline for "speaker"
  - id: i2s_dummy
    i2s_lrclk_pin:
      number: GPIO12     # WS
    i2s_bclk_pin:
      number: GPIO14     # SCK

microphone:
  - platform: i2s_audio
    id: mic
    i2s_audio_id: i2s_input
    i2s_din_pin: GPIO4   # SD
    adc_type: external
    pdm: false
    channel: left

speaker:
  # Dummy speaker to fix home-assistant/core#142363
  - platform: i2s_audio
    id: dummy_speaker
    i2s_audio_id: i2s_dummy
    i2s_dout_pin: GPIO13
    dac_type: external
    bits_per_sample: 16bit
    sample_rate: 16000
    channel: mono
    buffer_duration: 60ms

micro_wake_word:
  id: mww
  microphone:
    microphone: mic
    gain_factor: 4
  stop_after_detection: false
  models:
    - model: github://joshuaboniface/Custom_V2_MicroWakeWords/models/computer/computer.json
      id: mww_computer
    - model: github://esphome/micro-wake-word-models/models/v2/hey_jarvis.json
      id: mww_hey_jarvis
    - model: github://esphome/micro-wake-word-models/models/v2/hey_mycroft.json
      id: mww_hey_mycroft
    - model: github://esphome/micro-wake-word-models/models/v2/okay_nabu.json
      id: mww_okay_nabu
    - model: github://esphome/micro-wake-word-models/models/v2/alexa.json
      id: mww_alexa
    - model: github://joshuaboniface/Custom_V2_MicroWakeWords/models/hey_friday/hey_friday.json
      id: mww_hey_friday
    - model: github://joshuaboniface/Custom_V2_MicroWakeWords/models/hey_wabi/hey_wabi.json
      id: mww_hey_wabi
    - model: github://joshuaboniface/Custom_V2_MicroWakeWords/models/wasabi/wasabi.json
      id: mww_wasabi
  vad:
  on_wake_word_detected:
    - logger.log: "A wake word was detected!"
    - if:
        condition:
          voice_assistant.is_running:
        then:
          voice_assistant.stop:
    - voice_assistant.start:
        wake_word: !lambda return wake_word;

voice_assistant:
  id: va
  microphone: mic
  speaker: dummy_speaker
  micro_wake_word: mww
  use_wake_word: false
  noise_suppression_level: 3
  auto_gain: 31 dbfs
  volume_multiplier: 4
  on_wake_word_detected:
    - logger.log: "Wake word detected in VA pipeline"
  on_listening:
    - logger.log: "Listening for commands"
    # Trigger LED state - pipeline, listen
    - lambda: 'id(led_state)=2; id(led_substate)=1;'
    - script.execute: led_start
  on_stt_vad_end:
    - logger.log: "Processing STT result"
    # Trigger LED state - pipeline, stt
    - lambda: 'id(led_state)=2; id(led_substate)=2;'
    - script.execute: led_start
  on_error:
    # Trigger LED state - off
    - lambda: 'id(led_state)=0; id(led_substate)=0;'
    - script.execute: led_start
  on_tts_start:
    - if:
        condition:
        - lambda: |-
            ESP_LOGI("tts_response", "%s", x.c_str());
            return x.rfind("Sorry", 0) == 0;
        then:
          - logger.log: "Command failed!"
          # Trigger LED state - hold, failure
          - lambda: 'id(led_state)=1; id(led_substate)=4;'
          - script.execute: led_start
          - script.execute: led_hold_timer
          - voice_assistant.stop:
        else:
          - logger.log: "Command successful!"
          # Trigger LED state - hold, success
          - lambda: 'id(led_state)=1; id(led_substate)=3;'
          - script.execute: led_start
          - script.execute: led_hold_timer
          - voice_assistant.stop:
  on_tts_end:
    - logger.log: "Finished STT result"
    - voice_assistant.stop:

light:
  - platform: rgb
    id: output_led
    red: rgb_r
    green: rgb_g
    blue: rgb_b
    default_transition_length: 0.15s
    flash_transition_length: 0.15s
    effects:
      - strobe:
          name: flash_white
          colors:
            - state: true
              brightness: 25%
              red: 100%
              green: 90%
              blue: 90%
              duration: 0.5s
            - state: false
              duration: 0.5s

output:
  - platform: ledc
    id: rgb_r
    pin: GPIO39
  - platform: ledc
    id: rgb_g
    pin: GPIO40
  - platform: ledc
    id: rgb_b
    pin: GPIO41

ld2410:
  id: ld2410_radar
  uart_id: ld2410_uart

sensor:
  - platform: uptime
    name: "ESP32 Uptime"
    icon: mdi:clock-alert
    update_interval: 5s
    entity_category: diagnostic

  - platform: wifi_signal
    name: "WiFi RSSI"
    icon: mdi:wifi-strength-2
    update_interval: 5s
    entity_category: diagnostic

  - platform: internal_temperature
    name: "ESP32 Temperature"
    icon: mdi:thermometer
    unit_of_measurement: °C
    device_class: TEMPERATURE
    update_interval: 5s
    entity_category: diagnostic

  - platform: template
    name: "ESP32 Free Memory"
    icon: mdi:memory
    unit_of_measurement: 'kB'
    state_class: measurement
    update_interval: 5s
    lambda: |-
      return heap_caps_get_free_size(MALLOC_CAP_INTERNAL) / 1024;
    entity_category: diagnostic

  - platform: debug
    free:
      name: "ESP32 Heap Free"
    block:
      name: "ESP32 Heap Max Block"
    psram:
      name: "ESP32 PSRAM Free"
    loop_time:
      name: "ESP32 Loop Time"
    cpu_frequency:
      name: "ESP32 CPU Frequency"

  - platform: sgp4x
    voc:
      name: "SGP41 VOC Index"
      id: sgp41_voc_index
      accuracy_decimals: 0
      icon: mdi:waves-arrow-up
      filters:
        - sliding_window_moving_average:          # We take a reading every 15 seconds, but calculate the sliding
            window_size: 12                       # average over 12 readings i.e. 60 seconds/1 minute to normalize
            send_every: 3                         # brief spikes while still sending a value every 15 seconds.
    nox:
      name: "SGP41 NOx Index"
      id: sgp41_nox_index
      accuracy_decimals: 0
      icon: mdi:waves-arrow-up
      filters:
        - sliding_window_moving_average:
            window_size: 12
            send_every: 3
    compensation:
      temperature_source: sht45_temperature
      humidity_source: sht45_humidity
    store_baseline: true
    update_interval: 5s

  - platform: template
    name: "SGP41 TVOC (µg⁄m³)"
    id: sgp41_tvoc_ugm3
    icon: mdi:molecule
    lambda: |-
      float i = id(sgp41_voc_index).state;
      if (i < 1) return NAN;
      float tvoc = (log(501.0 - i) - 6.24) * -878.53;
      return tvoc;
    unit_of_measurement: "µg⁄m³"
    accuracy_decimals: 0
    update_interval: 15s

  - platform: template
    name: "SGP41 TVOC (ppb)"
    id: sgp41_tvoc_ppb
    icon: mdi:molecule
    lambda: |-
      float tvoc_ugm3 = id(sgp41_tvoc_ugm3).state;
      float tvoc_ppm = tvoc_ugm3 * 0.436;  // ppb estimated using isobutylene MW (56.1 g/mol)
      return tvoc_ppm;
    unit_of_measurement: "ppb"
    accuracy_decimals: 0
    update_interval: 15s

  - platform: template
    name: "SGP41 eCO2 (appr.)"
    id: sgp41_eco2_appr
    icon: mdi:molecule-co2
    lambda: |-
      float tvoc_ppb = id(sgp41_tvoc_ppb).state;
      float eco2_ppm = 400.0 + 1.5 * tvoc_ppb;
      if (eco2_ppm > 2000) eco2_ppm = 2000;
      return eco2_ppm;
    unit_of_measurement: "ppm"
    accuracy_decimals: 0
    update_interval: 15s

  - platform: sht4x
    temperature:
      name: "SHT45 Temperature"
      id: sht45_temperature
      accuracy_decimals: 1
      filters:
        - offset: !lambda return id(temperature_offset);
        - sliding_window_moving_average:
            window_size: 4
            send_every: 1
    humidity:
      name: "SHT45 Relative Humidity"
      id: sht45_humidity
      accuracy_decimals: 1
      filters:
        - lambda: |-
            // Grab measured and corrected temperatures
            float t_meas = id(sht45_temperature).state - id(temperature_offset);
            float t_corr = id(sht45_temperature).state;
            float rh_meas = x;

            // Compute saturation vapor pressures (Magnus formula)
            auto es = [](float T) { return 6.112 * exp((17.62 * T) / (243.12 + T)); };
            float rh_corr = rh_meas * es(t_meas) / es(t_corr);

            // Clamp to 0–100 %
            if (rh_corr < 0) rh_corr = 0;
            if (rh_corr > 100) rh_corr = 100;
            return rh_corr;
        - offset: !lambda return id(humidity_offset);
        - sliding_window_moving_average:
            window_size: 4
            send_every: 1
    heater_max_duty: 0.0
    update_interval: 15s

  - platform: absolute_humidity
    name: "SHT45 Absolute Humidity"
    temperature: sht45_temperature
    humidity: sht45_humidity
    id: sht45_absolute_humidity

  - platform: dew_point
    name: "SHT45 Dew Point"
    icon: mdi:thermometer-water
    id: sht45_dew_point
    temperature: sht45_temperature
    humidity: sht45_humidity

  - platform: template
    name: "Room Health Score"
    id: room_health_score
    unit_of_measurement: "%"
    icon: mdi:home-heart
    lambda: |-
      float voc = id(sgp41_tvoc_ppb).state;
      if (isnan(voc) || voc < 1) voc = 1;
      float temp = id(sht45_temperature).state;
      float humidity = id(sht45_humidity).state;

      float temp_min = id(room_health_temperature_min);
      float temp_max = id(room_health_temperature_max);
      float temp_penalty = id(room_health_temperature_penalty);
      float humid_min = id(room_health_humidity_min);
      float humid_max = id(room_health_humidity_max);
      float humid_penalty = id(room_health_humidity_penalty);
      float voc_weight = id(room_health_voc_weight);
      float temp_weight = id(room_health_temperature_weight);
      float humid_weight = id(room_health_humidity_weight);

      // VOC score (0–100) mapped to categories from Chemical Pollution levels below
      float voc_score;
      if (voc <= 200) {
        voc_score = 100.0;
      } else if (voc <= 400) {
        // 200–400: 100 → 90
        voc_score = 100.0 - (voc - 200) * (10.0 / 200.0);
      } else if (voc <= 600) {
        // 400–600: 90 → 70
        voc_score = 90.0 - (voc - 400) * (20.0 / 200.0);
      } else if (voc <= 1500) {
        // 600–1500: 70 → 40
        voc_score = 70.0 - (voc - 600) * (30.0 / 900.0);
      } else if (voc <= 3000) {
        // 1500–3000: 40 → 0
        voc_score = 40.0 - (voc - 1500) * (40.0 / 1500.0);
      } else {
        voc_score = 0.0;
      }

      // Temperature score
      float temp_score = 100;
      if (temp < temp_min) temp_score = 100 - (temp_min - temp) * temp_penalty;
      else if (temp > temp_max) temp_score = 100 - (temp - temp_max) * temp_penalty;
      if (temp_score < 0) temp_score = 0;

      // Humidity score
      float humidity_score = 100;
      if (humidity < humid_min) humidity_score = 100 - (humid_min - humidity) * humid_penalty;
      else if (humidity > humid_max) humidity_score = 100 - (humidity - humid_max) * humid_penalty;
      if (humidity_score < 0) humidity_score = 0;

      // Weighted average
      float total_weights = voc_weight + temp_weight + humid_weight;
      if (total_weights <= 0) total_weights = 1.0;
      voc_weight /= total_weights;
      temp_weight /= total_weights;
      humid_weight /= total_weights;
      float overall_score = (voc_score * voc_weight + temp_score * temp_weight + humidity_score * humid_weight);

      return (int) round(overall_score);
    update_interval: 15s

  - platform: tsl2591
    address: 0x29
    update_interval: 2s
    integration_time: 600ms
    power_save_mode: no
    gain: auto
    device_factor: 53
    glass_attenuation_factor: 7.7
    visible:
      name: "TSL2591 Raw Visible"
    infrared:
      name: "TSL2591 Raw Infrared"
    full_spectrum:
      name: "TSL2591 Raw Full Spectrum"
    calculated_lux:
      id: tsl2591_lux
      name: "TSL2591 Illumination"
      unit_of_measurement: lx
      accuracy_decimals: 1
      on_value:
        - script.execute: light_handler
    actual_gain:
      id: "actual_gain"
      name: "TSL2591 Gain"

  - platform: ld2410
    ld2410_id: ld2410_radar
    moving_distance:
      name: "LD2410C Moving Distance"
      id: ld2410c_moving_distance
      icon: mdi:signal-distance-variant
    still_distance:
      name: "LD2410C Still Distance"
      id: ld2410c_still_distance
      icon: mdi:signal-distance-variant
    moving_energy:
      name: "LD2410C Move Energy"
      icon: mdi:flash
    still_energy:
      name: "LD2410C Still Energy"
      icon: mdi:flash
    detection_distance:
      name: "LD2410C Presence Distance"
      id: ld2410c_presence_distance
      icon: mdi:signal-distance-variant
    g0:
      move_energy:
        name: "LD2410C G0 Move Energy"
      still_energy:
        name: "LD2410C G0 Still Energy"
    g1:
      move_energy:
        name: "LD2410C G1 Move Energy"
      still_energy:
        name: "LD2410C G1 Still Energy"
    g2:
      move_energy:
        name: "LD2410C G2 Move Energy"
      still_energy:
        name: "LD2410C G2 Still Energy"
    g3:
      move_energy:
        name: "LD2410C G3 Move Energy"
      still_energy:
        name: "LD2410C G3 Still Energy"
    g4:
      move_energy:
        name: "LD2410C G4 Move Energy"
      still_energy:
        name: "LD2410C G4 Still Energy"
    g5:
      move_energy:
        name: "LD2410C G5 Move Energy"
      still_energy:
        name: "LD2410C G5 Still Energy"
    g6:
      move_energy:
        name: "LD2410C G6 Move Energy"
      still_energy:
        name: "LD2410C G6 Still Energy"
    g7:
      move_energy:
        name: "LD2410C G7 Move Energy"
      still_energy:
        name: "LD2410C G7 Still Energy"
    g8:
      move_energy:
        name: "LD2410C G8 Move Energy"
      still_energy:
        name: "LD2410C G8 Still Energy"

binary_sensor:
  - platform: template
    name: "SuperSensor Occupancy"
    id: supersensor_occupancy
    device_class: occupancy
    on_state:
      then:
          # Trigger LED state - do not change existing state or substate
        - script.execute: led_start

  - platform: gpio
    name: "PIR GPIO"
    id: pir_gpio
    pin:
      number: GPIO8
      mode:
        input: true
        pulldown: true
    internal: false
    device_class: motion
    on_press:
      - script.stop: pir_handler
      - script.execute: pir_handler

  - platform: template
    name: "PIR Presence"
    id: pir_presence
    device_class: motion
    on_press:
      - script.execute: occupancy_detect_handler
    on_release:
      - script.execute: occupancy_clear_handler

  - platform: template
    name: "Light Presence"
    id: light_presence
    device_class: motion
    on_press:
      - script.execute: occupancy_detect_handler
    on_release:
      - script.execute: occupancy_clear_handler

  - platform: ld2410
    ld2410_id: ld2410_radar
    has_target:
      name: "LD2410C Presence"
      id: radar_presence
      icon: mdi:motion-sensor
      device_class: motion
      on_press:
        - script.execute: occupancy_detect_handler
      on_release:
        - script.execute: occupancy_clear_handler
    has_moving_target:
      name: "LD2410C Moving Target"
    has_still_target:
      name: "LD2410C Still Target"

text_sensor:
  - platform: version
    name: "ESPHome Version"
    entity_category: diagnostic

  - platform: wifi_info
    ip_address:
      name: "WiFi IP Address"
    ssid:
      name: "WiFi SSID"
    bssid:
      name: "WiFi BSSID"
    mac_address:
      name: "WiFi MAC Address"

  - platform: debug
    device:
      name: "Device Info"
    reset_reason:
      name: "Reset Reason"

  - platform: ld2410
    version:
      name: "LD2410C Firmware Version"
    mac_address:
      name: "LD2410C MAC Address"

  # Calibration sequence progress: Idle, Waiting, Calibrating, Polling, Done, Failed
  - platform: template
    name: "LD2410C Calibration Status"
    id: ld2410c_calibration_status
    icon: mdi:progress-wrench
    entity_category: diagnostic
    update_interval: never

  - platform: template
    name: "Chemical Pollution"
    id: sgp41_chemical_pollution
    icon: mdi:molecule
    lambda: |-
      float voc = id(sgp41_tvoc_ppb).state;
      if (isnan(voc) || voc < 1) return {"Unknown"};
      else if (voc <= 200) return {"Excellent"};
      else if (voc <= 400) return {"Good"};
      else if (voc <= 600) return {"Moderate"};
      else if (voc <= 1500) return {"Unhealthy"};
      else return {"Hazardous"};
    update_interval: 15s

  - platform: template
    name: "Room Health"
    id: room_health_text
    icon: mdi:home-heart
    lambda: |-
      float score = id(room_health_score).state;
      if (score < 0) return {"Unknown"};
      else if (score >= 100.0) return {"Excellent"};
      else if (score >= 95.0) return {"Great"};
      else if (score >= 90.0) return {"Good"};
      else if (score >= 80.0) return {"Fair"};
      else if (score >= 60.0) return {"Poor"};
      else return {"Bad"};
    update_interval: 15s

button:
  - platform: ld2410
    restart:
      name: "LD2410C Restart"
      id: ld2410c_restart
      icon: mdi:power-cycle
      entity_category: diagnostic
    factory_reset:
      name: "LD2410C Factory Reset"
      icon: mdi:restart-alert
      entity_category: diagnostic
    query_params:
      name: "LD2410C Query Params"
      id: ld2410c_query_params
      entity_category: diagnostic

  - platform: template
    name: "LD2410C Calibration"
    id: calibrate_ld2410
    entity_category: diagnostic
    # See the ld2410_calibration script for the actual sequence; the script
    # uses mode "single" so repeated presses during a run are ignored
    on_press:
      then:
        - script.execute: ld2410_calibration

  - platform: restart
    name: "ESP32 Restart"
    icon: mdi:power-cycle
    entity_category: diagnostic

  - platform: factory_reset
    name: "ESP32 Factory Reset"
    icon: mdi:restart-alert
    entity_category: diagnostic

switch:
  # Global enable/disable for voice support
  - platform: template
    name: "Enable Voice Support"
    icon: mdi:account-voice
    id: enable_voice_support
    optimistic: true
    restore_mode: RESTORE_DEFAULT_OFF
    on_turn_on:
      - micro_wake_word.start:
    on_turn_off:
      - micro_wake_word.stop:

  # Global enable/disable for presence LED
  - platform: template
    name: "Enable Presence LED"
    icon: mdi:lightbulb-alert
    id: enable_presence_led
    optimistic: true
    restore_mode: RESTORE_DEFAULT_ON
    on_turn_on:
      # Trigger LED state - do not change existing state or substate
      - script.execute: led_start
    on_turn_off:
      # Trigger LED state - do not change existing state or substate
      - script.execute: led_start

  - platform: ld2410
    engineering_mode:
      name: "LD2410C Engineering Mode"
      entity_category: diagnostic
    bluetooth:
      name: "LD2410C Bluetooth"
      entity_category: diagnostic

number:
  # Temperature offset:
  # A calibration from -30 to +10 for the temperature sensor
  - platform: template
    name: "Temperature Offset"
    id: temperature_offset_setter
    min_value: -30
    max_value: 10
    step: 0.1
    lambda: |-
      return id(temperature_offset);
    set_action:
      then:
        - globals.set:
            id: temperature_offset
            value: !lambda 'return float(x);'

  # Humidity offset:
  # A calibration from -50 to +50 for the humidity sensor
  - platform: template
    name: "Humidity Offset"
    id: humidity_offset_setter
    min_value: -50
    max_value: 50
    step: 0.1
    lambda: |-
      return id(humidity_offset);
    set_action:
      then:
        - globals.set:
            id: humidity_offset
            value: !lambda 'return float(x);'

  # PIR Hold Time:
  # The number of seconds after motion detection for the PIR sensor to remain held on
  - platform: template
    name: "PIR Hold Time"
    id: pir_hold_time_setter
    min_value: 0
    max_value: 60
    step: 5
    lambda: |-
      return id(pir_hold_time);
    set_action:
      then:
        - globals.set:
            id: pir_hold_time
            value: !lambda 'return int(x);'

  # Light Presence Threshold
  # The minimum Lux value to consider presence based on the ambient light level
  - platform: template
    name: "Light Presence Threshold"
    id: light_presence_threshold_setter
    min_value: 0
    max_value: 200
    step: 5
    lambda: |-
      return id(light_presence_threshold);
    set_action:
      then:
        - globals.set:
            id: light_presence_threshold
            value: !lambda 'return int(x);'

  # Room Health Calibration Values
  # These values allow the user to tweak the values of the room health calculation
  - platform: template
    name: "Room Health Min Temperature"
    id: room_health_temperature_min_setter
    min_value: 15
    max_value: 30
    step: 0.5
    lambda: |-
      return id(room_health_temperature_min);
    set_action:
      then:
        - globals.set:
            id: room_health_temperature_min
            value: !lambda 'return float(x);'
  - platform: template
    name: "Room Health Max Temperature"
    id: room_health_temperature_max_setter
    min_value: 15
    max_value: 30
    step: 0.5
    lambda: |-
      return id(room_health_temperature_max);
    set_action:
      then:
        - globals.set:
            id: room_health_temperature_max
            value: !lambda 'return float(x);'
  - platform: template
    name: "Room Health Temperature Penalty"
    id: room_health_temperature_penalty_setter
    min_value: 1
    max_value: 20
    step: 1
    lambda: |-
      return int(id(room_health_temperature_penalty));
    set_action:
      then:
        - globals.set:
            id: room_health_temperature_penalty
            value: !lambda 'return float(x);'
  - platform: template
    name: "Room Health Min Humidity"
    id: room_health_humidity_min_setter
    min_value: 20
    max_value: 80
    step: 1.0
    lambda: |-
      return id(room_health_humidity_min);
    set_action:
      then:
        - globals.set:
            id: room_health_humidity_min
            value: !lambda 'return float(x);'
  - platform: template
    name: "Room Health Max Humidity"
    id: room_health_humidity_max_setter
    min_value: 20
    max_value: 80
    step: 1.0
    lambda: |-
      return id(room_health_humidity_max);
    set_action:
      then:
        - globals.set:
            id: room_health_humidity_max
            value: !lambda 'return float(x);'
  - platform: template
    name: "Room Health Humidity Penalty"
    id: room_health_humidity_penalty_setter
    min_value: 1
    max_value: 10
    step: 1
    lambda: |-
      return int(id(room_health_humidity_penalty));
    set_action:
      then:
        - globals.set:
            id: room_health_humidity_penalty
            value: !lambda 'return float(x);'
  - platform: template
    name: "Room Health VOC Weight"
    id: room_health_voc_weight_setter
    min_value: 0.00
    max_value: 1.00
    step: 0.01
    lambda: |-
      return id(room_health_voc_weight);
    set_action:
      - if:
          condition:
            lambda: |-
              float total = x + id(room_health_temperature_weight) + id(room_health_humidity_weight);
              return (total > 0.0) && (total <= 1.0);
          then:
            - globals.set:
                id: room_health_voc_weight
                value: !lambda 'return float(x);'
          else:
            - logger.log:
                format: "Rejected VOC weight %.2f (total would be out of range: must be > 0.0 and ≤ 1.0)"
                args: [ 'x' ]
  - platform: template
    name: "Room Health Temperature Weight"
    id: room_health_temperature_weight_setter
    min_value: 0.00
    max_value: 1.00
    step: 0.01
    lambda: |-
      return id(room_health_temperature_weight);
    set_action:
      - if:
          condition:
            lambda: |-
              float total = x + id(room_health_voc_weight) + id(room_health_humidity_weight);
              return (total > 0.0) && (total <= 1.0);
          then:
            - globals.set:
                id: room_health_temperature_weight
                value: !lambda 'return float(x);'
          else:
            - logger.log:
                format: "Rejected Temperature weight %.2f (total would be out of range: must be > 0.0 and ≤ 1.0)"
                args: [ 'x' ]
  - platform: template
    name: "Room Health Humidity Weight"
    id: room_health_humidity_weight_setter
    min_value: 0.00
    max_value: 1.00
    step: 0.01
    lambda: |-
      return id(room_health_humidity_weight);
    set_action:
      - if:
          condition:
            lambda: |-
              float total = x + id(room_health_temperature_weight) + id(room_health_voc_weight);
              return (total > 0.0) && (total <= 1.0);
          then:
            - globals.set:
                id: room_health_humidity_weight
                value: !lambda 'return float(x);'
          else:
            - logger.log:
                format: "Rejected Humidity weight %.2f (total would be out of range: must be > 0.0 and ≤ 1.0)"
                args: [ 'x' ]

  # LED Output brightness values
  # Controls the brightness of the LEDs through the various operations
  - platform: template
    name: "LED Brightness %: Presence"
    id: led_presence_brightness_setter
    min_value: 0
    max_value: 100
    step: 5
    lambda: |-
      return id(led_presence_brightness);
    set_action:
      then:
        - globals.set:
            id: led_presence_brightness
            value: !lambda 'return int(x);'
        # Trigger LED state - do not change existing state or substate
        - script.execute: led_start

  - platform: template
    name: "LED Brightness %: Listening"
    id: led_listening_brightness_setter
    min_value: 0
    max_value: 100
    step: 5
    lambda: |-
      return id(led_listening_brightness);
    set_action:
      then:
        - globals.set:
            id: led_listening_brightness
            value: !lambda 'return int(x);'
        # Trigger LED state - do not change existing state or substate
        - script.execute: led_start

  - platform: template
    name: "LED Brightness %: Processing"
    id: led_processing_brightness_setter
    min_value: 0
    max_value: 100
    step: 5
    lambda: |-
      return id(led_processing_brightness);
    set_action:
      then:
        - globals.set:
            id: led_processing_brightness
            value: !lambda 'return int(x);'
        # Trigger LED state - do not change existing state or substate
        - script.execute: led_start

  - platform: template
    name: "LED Brightness %: Responding"
    id: led_responding_brightness_setter
    min_value: 0
    max_value: 100
    step: 5
    lambda: |-
      return id(led_responding_brightness);
    set_action:
      then:
        - globals.set:
            id: led_responding_brightness
            value: !lambda 'return int(x);'
        # Trigger LED state - do not change existing state or substate
        - script.execute: led_start

  # LD2410c configuration values
  - platform: ld2410
    timeout:
      name: "LD2410C Timeout"
    light_threshold:
      name: "LD2410C Light Threshold"
    max_move_distance_gate:
      name: "LD2410C Max Move Distance Gate"
    max_still_distance_gate:
      name: "LD2410C Max Still Distance Gate"
    g0:
      move_threshold:
        name: "LD2410C G0 Move Threshold"
        id: ld2410c_g0_move_threshold
      still_threshold:
        name: "LD2410C G0 Still Threshold"
        id: ld2410c_g0_still_threshold
    g1:
      move_threshold:
        name: "LD2410C G1 Move Threshold"
        id: ld2410c_g1_move_threshold
      still_threshold:
        name: "LD2410C G1 Still Threshold"
        id: ld2410c_g1_still_threshold
    g2:
      move_threshold:
        name: "LD2410C G2 Move Threshold"
        id: ld2410c_g2_move_threshold
      still_threshold:
        name: "LD2410C G2 Still Threshold"
        id: ld2410c_g2_still_threshold
    g3:
      move_threshold:
        name: "LD2410C G3 Move Threshold"
        id: ld2410c_g3_move_threshold
      still_threshold:
        name: "LD2410C G3 Still Threshold"
        id: ld2410c_g3_still_threshold
    g4:
      move_threshold:
        name: "LD2410C G4 Move Threshold"
        id: ld2410c_g4_move_threshold
      still_threshold:
        name: "LD2410C G4 Still Threshold"
        id: ld2410c_g4_still_threshold
    g5:
      move_threshold:
        name: "LD2410C G5 Move Threshold"
        id: ld2410c_g5_move_threshold
      still_threshold:
        name: "LD2410C G5 Still Threshold"
        id: ld2410c_g5_still_threshold
    g6:
      move_threshold:
        name: "LD2410C G6 Move Threshold"
        id: ld2410c_g6_move_threshold
      still_threshold:
        name: "LD2410C G6 Still Threshold"
        id: ld2410c_g6_still_threshold
    g7:
      move_threshold:
        name: "LD2410C G7 Move Threshold"
        id: ld2410c_g7_move_threshold
      still_threshold:
        name: "LD2410C G7 Still Threshold"
        id: ld2410c_g7_still_threshold
    g8:
      move_threshold:
        name: "LD2410C G8 Move Threshold"
        id: ld2410c_g8_move_threshold
      still_threshold:
        name: "LD2410C G8 Still Threshold"
        id: ld2410c_g8_still_threshold

select:
  # Occupancy Detect Mode:
  # This selector defines the detection mode for the integrated occupancy sensor. Depending on the
  # selected option, only the given sensor(s) will be used to judge when occupancy begins (i.e.
  # when the given sensor(s) detect, occupancy detects).
  #  * PIR + Radar + Light:
  #    All 3 sensors reporting detection simultaneously will begin occupancy
  #  * PIR + Radar
  #    Both PIR and Radar sensors reporting detection simultaneously will begin occupancy
  #  * PIR + Light
  #    Both PIR and Light sensors reporting detection simultaneously will begin occupancy
  #  * Radar + Light
  #    Both Radar and Light sensors reporting detection simultaneously will begin occupancy
  #  * PIR Only
  #    PIR sensor reporting detection will begin occupancy
  #  * Radar Only
  #    Radar sensor reporting detection will begin occupancy
  #  * Light Only
  #    Light sensor reporting detection will begin occupancy
  #  * None
  #    No sensors will begin occupancy and the integrated occupancy functionality is disabled
  # Values are reported as integers using bitwise logic:
  #  Bit 2: PIR
  #  Bit 1: Radar
  #  Bit 0: Light
  - platform: template
    name: "Occupancy Detect Mode"
    id: occupancy_detect_mode_setter
    options:
      - "PIR + Radar + Light"   # 111 = 7
      - "PIR + Radar"           # 110 = 6
      - "PIR + Light"           # 101 = 5
      - "Radar + Light"         # 011 = 3
      - "PIR Only"              # 100 = 4
      - "Radar Only"            # 010 = 2
      - "Light Only"            # 001 = 1
      - "None"                  # 000 = 0
    initial_option: "None"
    optimistic: true
    restore_value: true
    set_action:
      - globals.set:
          id: occupancy_detect_mode
          value: !lambda |-
            ESP_LOGD("occupancy_detect_mode_setter", x.c_str());
            if (x == "PIR + Radar + Light") {
              return 7;
            } else if (x == "PIR + Radar") {
              return 6;
            } else if (x == "PIR + Light") {
              return 5;
            } else if (x == "Radar + Light") {
              return 3;
            } else if (x == "PIR Only") {
              return 4;
            } else if (x == "Radar Only") {
              return 2;
            } else if (x == "Light Only") {
              return 1;
            } else {
              return 0;
            }

  # Occupancy Clear Mode:
  # This selector defines the clear mode for the integrated occupancy sensor. Depending on the
  # selected option, only the given sensor(s) will be used to judge when occupancy ends (i.e.
  # when the given sensor(s) clear, occupancy clears).
  #  * PIR + Radar + Light:
  #    Any of the 3 sensors clearing will end occupancy
  #  * PIR + Radar:
  #    Either of the PIR or Radar sensors clearing will end occupancy
  #  * PIR + Light:
  #    Either of the PIR or Light sensors clearing will end occupancy
  #  * Radar + Light:
  #    Either of the Radar or Light sensors clearing will end occupancy
  #  * PIR Only
  #    PIR sensor clearing will end occupancy
  #  * Radar Only
  #    Radar sensor clearing will end occupancy
  #  * Light Only
  #    Light sensor clearing will end occupancy
  #  * None
  #    No sensors will end occupancy; state will persist indefinitely once triggered
  # Values are reported as integers using bitwise logic:
  #  Bit 0: PIR
  #  Bit 1: Radar
  #  Bit 2: Light
  - platform: template
    name: "Occupancy Clear Mode"
    id: occupancy_clear_mode_setter
    options:
      - "PIR + Radar + Light"   # 111 = 7
      - "PIR + Radar"           # 110 = 6
      - "PIR + Light"           # 101 = 5
      - "Radar + Light"         # 011 = 3
      - "PIR Only"              # 100 = 4
      - "Radar Only"            # 010 = 2
      - "Light Only"            # 001 = 1
      - "None"                  # 000 = 0
    initial_option: "None"
    optimistic: true
    restore_value: true
    set_action:
      - globals.set:
          id: occupancy_clear_mode
          value: !lambda |-
            ESP_LOGD("occupancy_detect_mode_setter", x.c_str());
            if (x == "PIR + Radar + Light") {
              return 7;
            } else if (x == "PIR + Radar") {
              return 6;
            } else if (x == "PIR + Light") {
              return 5;
            } else if (x == "Radar + Light") {
              return 3;
            } else if (x == "PIR Only") {
              return 4;
            } else if (x == "Radar Only") {
              return 2;
            } else if (x == "Light Only") {
              return 1;
            } else {
              return 0;
            }

  - platform: ld2410
    distance_resolution:
      name: "LD2410C Distance Resolution"

  - platform: template
    name: "Wake Word Selector"
    id: wake_word_selector
    options:
      - "Computer"
      - "Hey Jarvis"
      - "Hey Mycroft"
      - "Okay Nabu"
      - "Alexa"
      - "Hey Friday"
      - "Hey Wabi"
      - "Wasabi"
    initial_option: "Computer"
    optimistic: true
    restore_value: true
    set_action:
      # Disable models that aren't selected
      - if:
          condition:
            lambda: 'return x != "Computer";'
          then:
            - micro_wake_word.disable_model: mww_computer
      - if:
          condition:
            lambda: 'return x != "Hey Jarvis";'
          then:
            - micro_wake_word.disable_model: mww_hey_jarvis
      - if:
          condition:
            lambda: 'return x != "Hey Mycroft";'
          then:
            - micro_wake_word.disable_model: mww_hey_mycroft
      - if:
          condition:
            lambda: 'return x != "Okay Nabu";'
          then:
            - micro_wake_word.disable_model: mww_okay_nabu
      - if:
          condition:
            lambda: 'return x != "Alexa";'
          then:
            - micro_wake_word.disable_model: mww_alexa
      - if:
          condition:
            lambda: 'return x != "Hey Friday";'
          then:
            - micro_wake_word.disable_model: mww_hey_friday
      - if:
          condition:
            lambda: 'return x != "Hey Wabi";'
          then:
            - micro_wake_word.disable_model: mww_hey_wabi
      - if:
          condition:
            lambda: 'return x != "Wasabi";'
          then:
            - micro_wake_word.disable_model: mww_wasabi
      # Enable model we selected
      - if:
          condition:
            lambda: 'return x == "Computer";'
          then:
            - micro_wake_word.enable_model: mww_computer
      - if:
          condition:
            lambda: 'return x == "Hey Jarvis";'
          then:
            - micro_wake_word.enable_model: mww_hey_jarvis
      - if:
          condition:
            lambda: 'return x == "Hey Mycroft";'
          then:
            - micro_wake_word.enable_model: mww_hey_mycroft
      - if:
          condition:
            lambda: 'return x == "Okay Nabu";'
          then:
            - micro_wake_word.enable_model: mww_okay_nabu
      - if:
          condition:
            lambda: 'return x == "Alexa";'
          then:
            - micro_wake_word.enable_model: mww_alexa
      - if:
          condition:
            lambda: 'return x == "Hey Friday";'
          then:
            - micro_wake_word.enable_model: mww_hey_friday
      - if:
          condition:
            lambda: 'return x == "Hey Wabi";'
          then:
            - micro_wake_word.enable_model: mww_hey_wabi
      - if:
          condition:
            lambda: 'return x == "Wasabi";'
          then:
            - micro_wake_word.enable_model: mww_wasabi

  - platform: template
    name: "Wake Word Sensitivity"
    optimistic: true
    initial_option: Default
    restore_value: true
    options:
      - Default
      - More sensitive
      - Very sensitive
    set_action:
      # Sets specific wake word probabilities computed for each particular model
      # Note probability cutoffs are set as a quantized uint8 value, each comment has the corresponding floating point cutoff
      - lambda: |-
          if (x == "Default") {
            id(mww_computer).set_probability_cutoff(168);     // 0.66 (default)
            id(mww_hey_jarvis).set_probability_cutoff(247);   // 0.97 (default)
            id(mww_hey_mycroft).set_probability_cutoff(242);  // 0.95 (default)
            id(mww_okay_nabu).set_probability_cutoff(217);    // 0.85 (default)
            id(mww_alexa).set_probability_cutoff(217);        // 0.85 (default)
            id(mww_hey_friday).set_probability_cutoff(168);   // 0.66 (default)
            id(mww_hey_wabi).set_probability_cutoff(168);     // 0.66 (default)
            id(mww_wasabi).set_probability_cutoff(84);        // 0.33 (default)
          } else if (x == "More sensitive") {
            id(mww_computer).set_probability_cutoff(153);     // 0.60
            id(mww_hey_jarvis).set_probability_cutoff(235);   // 0.92
            id(mww_hey_mycroft).set_probability_cutoff(237);  // 0.93
            id(mww_okay_nabu).set_probability_cutoff(176);    // 0.69
            id(mww_alexa).set_probability_cutoff(176);        // 0.69
            id(mww_hey_friday).set_probability_cutoff(153);   // 0.60
            id(mww_hey_wabi).set_probability_cutoff(153);     // 0.60
            id(mww_wasabi).set_probability_cutoff(153);       // 0.60
            id(mww_wasabi).set_probability_cutoff(77);        // 0.30
          } else if (x == "Very sensitive") {
            id(mww_computer).set_probability_cutoff(138);     // 0.54
            id(mww_hey_jarvis).set_probability_cutoff(212);   // 0.83
            id(mww_hey_mycroft).set_probability_cutoff(230);  // 0.90
            id(mww_okay_nabu).set_probability_cutoff(143);    // 0.56
            id(mww_alexa).set_probability_cutoff(143);        // 0.56
            id(mww_hey_friday).set_probability_cutoff(138);   // 0.54
            id(mww_hey_wabi).set_probability_cutoff(138);     // 0.54
            id(mww_wasabi).set_probability_cutoff(69);        // 0.27
          }