rack-assistant.yaml

# SPDX-License-Identifier: GPL-3.0-or-later

substitutions:
  device_name: rack-assistant
  friendly_name: Rack Assistant
  led_pin: GPIO3
  led_count: "300"
  rack_unit_count: "15"

  # Manual rack map. After installing the strip, adjust these LED ranges and recompile.
  # The current path starts at the rack bottom, goes up the left side, crosses the top,
  # then goes down the right side.
  rack_bottom_start: "0"
  rack_bottom_led_count: "35"
  # Left side maps U1 -> top U from low to high.
  rack_left_start: "35"
  # Number of LEDs used by each vertical side. U ranges are split proportionally.
  rack_side_led_count: "43"
  rack_top_start: "80"
  rack_top_led_count: "35"
  # Right side is mapped in reverse, so the first LED here belongs to the top U.
  rack_right_start: "117"

  rack_u_alert_fade_ms: "650"
  rack_u_alert_blink_ms: "900"
  rack_u_alert_slots: "8"

esphome:
  name: ${device_name}
  friendly_name: ${friendly_name}
  platformio_options:
    build_flags:
      - -DRACK_UNIT_COUNT=${rack_unit_count}
  includes:
    - rack_assistant_helpers.h
  on_boot:
    priority: -100
    then:
      - delay: 1s
      - script.execute: apply_first_install_default

esp32:
  board: esp32dev
  framework:
    type: esp-idf

logger:
  level: WARN
  baud_rate: 0

api:
  services:
    - service: rack_u_set_preset
      variables:
        slot: int
        u_start: int
        u_end: int
        effect: string
      then:
        - lambda: |-
            const std::string preset = std::string(effect.c_str(), effect.size());
            rack_fx::set_alert_slot_preset(
              id(u_alert_active),
              id(u_alert_first_u),
              id(u_alert_last_u),
              id(u_alert_modes),
              id(u_alert_starts),
              id(u_alert_reds),
              id(u_alert_greens),
              id(u_alert_blues),
              id(u_alert_whites),
              slot,
              u_start,
              u_end,
              preset
            );
            if (slot == 0) {
              id(rack_u_alert_effect).publish_state(rack_fx::canonical_alert_option(preset));
            }
        - script.execute: show_u_alert_layer

    - service: rack_u_set_custom
      variables:
        slot: int
        u_start: int
        u_end: int
        effect: string
        red: float
        green: float
        blue: float
        white: float
      then:
        - lambda: |-
            const std::string custom_effect = std::string(effect.c_str(), effect.size());
            rack_fx::set_alert_slot_custom(
              id(u_alert_active),
              id(u_alert_first_u),
              id(u_alert_last_u),
              id(u_alert_modes),
              id(u_alert_starts),
              id(u_alert_reds),
              id(u_alert_greens),
              id(u_alert_blues),
              id(u_alert_whites),
              slot,
              u_start,
              u_end,
              custom_effect,
              red,
              green,
              blue,
              white
            );
            if (slot == 0 && rack_fx::is_clear_alert_option(custom_effect)) {
              id(rack_u_alert_effect).publish_state("No alert");
            }
        - script.execute: show_u_alert_layer

    - service: rack_u_clear_slot
      variables:
        slot: int
      then:
        - lambda: |-
            rack_fx::clear_alert_slot(id(u_alert_active), id(u_alert_modes), slot);
            if (slot == 0) {
              id(rack_u_alert_effect).publish_state("No alert");
            }
        - script.execute: show_u_alert_layer

    - service: rack_u_clear_all
      then:
        - lambda: |-
            rack_fx::clear_all_alert_slots(id(u_alert_active), id(u_alert_modes));
            id(rack_u_alert_effect).publish_state("No alert");
        - script.execute: show_u_alert_layer

    - service: rack_u_red
      then:
        - lambda: |-
            rack_fx::set_alert_slot_preset(
              id(u_alert_active),
              id(u_alert_first_u),
              id(u_alert_last_u),
              id(u_alert_modes),
              id(u_alert_starts),
              id(u_alert_reds),
              id(u_alert_greens),
              id(u_alert_blues),
              id(u_alert_whites),
              0,
              int(roundf(id(rack_u_start).state)),
              int(roundf(id(rack_u_end).state)),
              "Red blink"
            );
            id(rack_u_alert_effect).publish_state("Red blink");
        - script.execute: show_u_alert_layer

    - service: rack_u_orange
      then:
        - lambda: |-
            rack_fx::set_alert_slot_preset(
              id(u_alert_active),
              id(u_alert_first_u),
              id(u_alert_last_u),
              id(u_alert_modes),
              id(u_alert_starts),
              id(u_alert_reds),
              id(u_alert_greens),
              id(u_alert_blues),
              id(u_alert_whites),
              0,
              int(roundf(id(rack_u_start).state)),
              int(roundf(id(rack_u_end).state)),
              "Orange blink"
            );
            id(rack_u_alert_effect).publish_state("Orange blink");
        - script.execute: show_u_alert_layer

    - service: rack_u_blue
      then:
        - lambda: |-
            rack_fx::set_alert_slot_preset(
              id(u_alert_active),
              id(u_alert_first_u),
              id(u_alert_last_u),
              id(u_alert_modes),
              id(u_alert_starts),
              id(u_alert_reds),
              id(u_alert_greens),
              id(u_alert_blues),
              id(u_alert_whites),
              0,
              int(roundf(id(rack_u_start).state)),
              int(roundf(id(rack_u_end).state)),
              "Blue blink"
            );
            id(rack_u_alert_effect).publish_state("Blue blink");
        - script.execute: show_u_alert_layer

    - service: rack_u_selected_color
      then:
        - lambda: |-
            rack_fx::set_alert_slot_preset(
              id(u_alert_active),
              id(u_alert_first_u),
              id(u_alert_last_u),
              id(u_alert_modes),
              id(u_alert_starts),
              id(u_alert_reds),
              id(u_alert_greens),
              id(u_alert_blues),
              id(u_alert_whites),
              0,
              int(roundf(id(rack_u_start).state)),
              int(roundf(id(rack_u_end).state)),
              "Selected color blink"
            );
            id(rack_u_alert_effect).publish_state("Selected color blink");
        - script.execute: show_u_alert_layer

    - service: rack_u_static_selected_color
      then:
        - lambda: |-
            rack_fx::set_alert_slot_preset(
              id(u_alert_active),
              id(u_alert_first_u),
              id(u_alert_last_u),
              id(u_alert_modes),
              id(u_alert_starts),
              id(u_alert_reds),
              id(u_alert_greens),
              id(u_alert_blues),
              id(u_alert_whites),
              0,
              int(roundf(id(rack_u_start).state)),
              int(roundf(id(rack_u_end).state)),
              "Selected color blink"
            );
            id(rack_u_alert_effect).publish_state("Selected color blink");
        - script.execute: show_u_alert_layer

    - service: rack_u_scan_red
      then:
        - lambda: |-
            const uint32_t internal_effect = id(rack_assistant).get_effect_index("Rack internal");
            id(last_rack_effect_index) = internal_effect;
            id(last_rack_internal_mode) = rack_fx::RACK_MODE_U_SCAN_RED;
            id(last_rack_active_zone_mode) = "Whole rack";
            id(last_rack_active_u_start) = 1;
            id(last_rack_active_u_end) = ${rack_unit_count};
            rack_fx::clear_all_alert_slots(id(u_alert_active), id(u_alert_modes));
            id(rack_u_alert_effect).publish_state("No alert");
            id(u_alert_layer_saved) = false;
            id(active_zone_mode) = "Whole rack";
            id(active_u_start) = 1;
            id(active_u_end) = ${rack_unit_count};
            id(rack_internal_mode) = rack_fx::RACK_MODE_U_SCAN_RED;
            id(rack_internal_generation) += 1;

            auto service_light = id(rack_assistant).make_call();
            service_light.set_state(true);
            service_light.set_brightness(1.0f);
            service_light.set_effect("Rack internal");
            service_light.set_save(false);
            service_light.perform();

    - service: rack_u_scan_selected_color
      then:
        - lambda: |-
            const uint32_t internal_effect = id(rack_assistant).get_effect_index("Rack internal");
            id(last_rack_effect_index) = internal_effect;
            id(last_rack_internal_mode) = rack_fx::RACK_MODE_U_SCAN_SELECTED;
            id(last_rack_active_zone_mode) = "Whole rack";
            id(last_rack_active_u_start) = 1;
            id(last_rack_active_u_end) = ${rack_unit_count};
            rack_fx::clear_all_alert_slots(id(u_alert_active), id(u_alert_modes));
            id(rack_u_alert_effect).publish_state("No alert");
            id(u_alert_layer_saved) = false;
            id(active_zone_mode) = "Whole rack";
            id(active_u_start) = 1;
            id(active_u_end) = ${rack_unit_count};
            id(rack_internal_mode) = rack_fx::RACK_MODE_U_SCAN_SELECTED;
            id(rack_internal_generation) += 1;

            auto service_light = id(rack_assistant).make_call();
            service_light.set_state(true);
            service_light.set_brightness(1.0f);
            service_light.set_effect("Rack internal");
            service_light.set_save(false);
            service_light.perform();

ota:
  - platform: esphome
    password: !secret rack_assistant_ota_password

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  ap:
    ssid: "${friendly_name} Setup"
    password: !secret fallback_ap_password

captive_portal:

web_server:
  port: 80
  version: 3
  auth:
    username: !secret rack_assistant_web_username
    password: !secret rack_assistant_web_password

globals:
  - id: door_override_active
    type: bool
    restore_value: false
    initial_value: "false"

  - id: saved_light_state
    type: esphome::light::LightColorValues
    restore_value: false

  - id: saved_effect_index
    type: uint32_t
    restore_value: false
    initial_value: "0"

  - id: active_zone_mode
    type: std::string
    restore_value: false
    initial_value: '"Whole rack"'

  - id: active_u_start
    type: int
    restore_value: false
    initial_value: "1"

  - id: active_u_end
    type: int
    restore_value: false
    initial_value: "${rack_unit_count}"

  - id: rack_internal_mode
    type: int
    restore_value: false
    initial_value: "0"

  - id: rack_internal_generation
    type: int
    restore_value: false
    initial_value: "0"

  - id: u_alert_active
    type: std::array<bool, ${rack_u_alert_slots}>
    restore_value: false
    initial_value: "{false, false, false, false, false, false, false, false}"

  - id: u_alert_first_u
    type: std::array<int, ${rack_u_alert_slots}>
    restore_value: false
    initial_value: "{1, 1, 1, 1, 1, 1, 1, 1}"

  - id: u_alert_last_u
    type: std::array<int, ${rack_u_alert_slots}>
    restore_value: false
    initial_value: "{1, 1, 1, 1, 1, 1, 1, 1}"

  - id: u_alert_modes
    type: std::array<int, ${rack_u_alert_slots}>
    restore_value: false
    initial_value: "{0, 0, 0, 0, 0, 0, 0, 0}"

  - id: u_alert_starts
    type: std::array<uint32_t, ${rack_u_alert_slots}>
    restore_value: false
    initial_value: "{0, 0, 0, 0, 0, 0, 0, 0}"

  - id: u_alert_reds
    type: std::array<float, ${rack_u_alert_slots}>
    restore_value: false
    initial_value: "{0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}"

  - id: u_alert_greens
    type: std::array<float, ${rack_u_alert_slots}>
    restore_value: false
    initial_value: "{0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}"

  - id: u_alert_blues
    type: std::array<float, ${rack_u_alert_slots}>
    restore_value: false
    initial_value: "{0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}"

  - id: u_alert_whites
    type: std::array<float, ${rack_u_alert_slots}>
    restore_value: false
    initial_value: "{0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}"

  - id: u_alert_layer_saved
    type: bool
    restore_value: false
    initial_value: "false"

  - id: u_alert_saved_light_state
    type: esphome::light::LightColorValues
    restore_value: false

  - id: u_alert_saved_effect_index
    type: uint32_t
    restore_value: false
    initial_value: "0"

  - id: u_alert_saved_internal_mode
    type: int
    restore_value: false
    initial_value: "0"

  - id: u_alert_saved_active_zone_mode
    type: std::string
    restore_value: false
    initial_value: '"Whole rack"'

  - id: u_alert_saved_active_u_start
    type: int
    restore_value: false
    initial_value: "1"

  - id: u_alert_saved_active_u_end
    type: int
    restore_value: false
    initial_value: "${rack_unit_count}"

  - id: saved_internal_mode
    type: int
    restore_value: false
    initial_value: "0"

  - id: saved_active_zone_mode
    type: std::string
    restore_value: false
    initial_value: '"Whole rack"'

  - id: saved_active_u_start
    type: int
    restore_value: false
    initial_value: "1"

  - id: saved_active_u_end
    type: int
    restore_value: false
    initial_value: "${rack_unit_count}"

  - id: last_rack_effect_index
    type: uint32_t
    restore_value: false
    initial_value: "0"

  - id: last_rack_internal_mode
    type: int
    restore_value: false
    initial_value: "0"

  - id: last_rack_active_zone_mode
    type: std::string
    restore_value: false
    initial_value: '"Whole rack"'

  - id: last_rack_active_u_start
    type: int
    restore_value: false
    initial_value: "1"

  - id: last_rack_active_u_end
    type: int
    restore_value: false
    initial_value: "${rack_unit_count}"

  - id: rack_light_restore_pending
    type: bool
    restore_value: false
    initial_value: "false"

  - id: rack_defaults_initialized
    type: bool
    restore_value: true
    initial_value: "false"

switch:
  - platform: template
    id: door_sensor_enabled
    name: "Door sensor"
    icon: "mdi:door-open"
    entity_category: config
    optimistic: true
    restore_mode: RESTORE_DEFAULT_ON
    turn_off_action:
      - if:
          condition:
            lambda: |-
              return id(door_override_active);
          then:
            - script.execute: door_close_sequence

number:
  - platform: template
    id: breathing_min_percent
    name: "Breathing min"
    icon: "mdi:brightness-6"
    entity_category: config
    optimistic: true
    restore_value: true
    initial_value: 18
    min_value: 5
    max_value: 60
    step: 1
    mode: slider
    unit_of_measurement: "%"
    on_value:
      then:
        - script.execute: normalize_firmware_effect_brightness

  - platform: template
    id: breathing_max_percent
    name: "Breathing max"
    icon: "mdi:brightness-7"
    entity_category: config
    optimistic: true
    restore_value: true
    initial_value: 60
    min_value: 20
    max_value: 100
    step: 1
    mode: slider
    unit_of_measurement: "%"
    on_value:
      then:
        - script.execute: normalize_firmware_effect_brightness

  - platform: template
    id: breathing_cycle_seconds
    name: "Breathing cycle"
    icon: "mdi:timer-outline"
    entity_category: config
    optimistic: true
    restore_value: true
    initial_value: 4.8
    min_value: 2
    max_value: 12
    step: 0.1
    mode: slider
    unit_of_measurement: "s"

  - platform: template
    id: calibration_start_led
    name: "Calibration start LED"
    internal: true
    optimistic: true
    restore_value: false
    initial_value: 0
    min_value: 0
    max_value: ${led_count}
    step: 1
    mode: box

  - platform: template
    id: calibration_start_led_2
    name: "Calibration start LED 2"
    internal: true
    optimistic: true
    restore_value: false
    initial_value: 0
    min_value: 0
    max_value: ${led_count}
    step: 1
    mode: box

  - platform: template
    id: calibration_led_count
    name: "Calibration LED count"
    internal: true
    optimistic: true
    restore_value: false
    initial_value: 6
    min_value: 1
    max_value: 50
    step: 1
    mode: box

  - platform: template
    id: calibration_led_count_2
    name: "Calibration LED count 2"
    internal: true
    optimistic: true
    restore_value: false
    initial_value: 0
    min_value: 0
    max_value: 50
    step: 1
    mode: box

  - platform: template
    id: calibration_brightness_percent
    name: "Calibration brightness"
    internal: true
    optimistic: true
    restore_value: false
    initial_value: 80
    min_value: 5
    max_value: 100
    step: 1
    mode: slider
    unit_of_measurement: "%"

  - platform: template
    id: rack_u_start
    name: "U start"
    icon: "mdi:server"
    entity_category: config
    optimistic: true
    restore_value: true
    initial_value: 1
    min_value: 1
    max_value: ${rack_unit_count}
    step: 1
    mode: slider
    on_value:
      then:
        - script.execute: refresh_u_alert_if_active

  - platform: template
    id: rack_u_end
    name: "U end"
    icon: "mdi:server"
    entity_category: config
    optimistic: true
    restore_value: true
    initial_value: 1
    min_value: 1
    max_value: ${rack_unit_count}
    step: 1
    mode: slider
    on_value:
      then:
        - script.execute: refresh_u_alert_if_active

  - platform: template
    id: rack_u_scan_seconds
    name: "U scan time"
    icon: "mdi:swap-vertical-bold"
    entity_category: config
    optimistic: true
    restore_value: true
    initial_value: 0.35
    min_value: 0.15
    max_value: 2
    step: 0.05
    mode: slider
    unit_of_measurement: "s"

select:
  - platform: template
    id: breathing_curve_select
    name: "Breathing curve"
    icon: "mdi:sine-wave"
    entity_category: config
    optimistic: true
    restore_value: true
    initial_option: "Smooth"
    options:
      - "Smooth"
      - "Dynamic"
      - "Natural"

  - platform: template
    id: rack_zone_select
    name: "Rack zone"
    icon: "mdi:select-place"
    entity_category: config
    optimistic: true
    restore_value: true
    initial_option: "Whole rack"
    options:
      - "Whole rack"
      - "Side rails"
      - "Top only"
      - "Bottom only"
    set_action:
      - lambda: |-
          const std::string zone = rack_fx::canonical_zone_option(std::string(x.c_str(), x.size()));

          if (id(door_override_active)) {
            id(saved_active_zone_mode) = zone;
            id(last_rack_active_zone_mode) = zone;
            id(rack_assistant_effect_select).update();
            return;
          }

          if (id(u_alert_layer_saved)) {
            id(u_alert_saved_active_zone_mode) = zone;
          }

          const uint32_t internal_effect = id(rack_assistant).get_effect_index("Rack internal");
          if (id(rack_assistant).get_current_effect_index() == internal_effect) {
            if (id(rack_internal_mode) == rack_fx::RACK_MODE_U_ALERTS) {
              id(last_rack_active_zone_mode) = zone;
              id(rack_assistant_effect_select).update();
              return;
            }

            id(active_zone_mode) = zone;
            id(active_u_start) = 1;
            id(active_u_end) = ${rack_unit_count};
            id(last_rack_active_zone_mode) = zone;
            id(last_rack_active_u_start) = 1;
            id(last_rack_active_u_end) = ${rack_unit_count};
            id(rack_internal_generation) += 1;
            return;
          }

          id(last_rack_active_zone_mode) = zone;

  - platform: template
    id: rack_u_alert_effect
    name: "U alert"
    icon: "mdi:alert-circle"
    entity_category: config
    optimistic: true
    restore_value: false
    initial_option: "No alert"
    options:
      - "No alert"
      - "White blink"
      - "Orange blink"
      - "Red blink"
      - "Blue blink"
      - "Selected color blink"
    set_action:
      - lambda: |-
          const std::string alert_option = std::string(x.c_str(), x.size());
          if (rack_fx::is_clear_alert_option(alert_option)) {
            rack_fx::clear_alert_slot(id(u_alert_active), id(u_alert_modes), 0);
            return;
          }

          rack_fx::set_alert_slot_preset(
            id(u_alert_active),
            id(u_alert_first_u),
            id(u_alert_last_u),
            id(u_alert_modes),
            id(u_alert_starts),
            id(u_alert_reds),
            id(u_alert_greens),
            id(u_alert_blues),
            id(u_alert_whites),
            0,
            int(roundf(id(rack_u_start).state)),
            int(roundf(id(rack_u_end).state)),
            alert_option
          );
      - script.execute: show_u_alert_layer

  - platform: template
    id: rack_assistant_effect_select
    name: "Rack mode"
    icon: "mdi:palette-swatch"
    update_interval: 60s
    options:
      - "Manual"
      - "White breathing"
      - "Selected color breathing"
      - "Orange breathing"
      - "Red breathing"
      - "Blue breathing"
      - "Internet down"
      - "Error"
      - "Success"
      - "U alerts"
      - "Red U scan"
      - "Selected color U scan"
      - "White wipe"
      - "Red wipe"
      - "White scan"
      - "Rainbow"
    lambda: |-
      const uint32_t effect = id(door_override_active)
        ? id(saved_effect_index)
        : id(rack_assistant).get_current_effect_index();
      const std::string name = id(rack_assistant).get_effect_name_by_index(effect);
      const int internal_mode = id(door_override_active)
        ? id(saved_internal_mode)
        : id(rack_internal_mode);

      if (!id(door_override_active) && !id(rack_assistant).remote_values.is_on()) {
        const uint32_t remembered_effect = id(last_rack_effect_index);
        const std::string remembered_name = id(rack_assistant).get_effect_name_by_index(remembered_effect);
        if (remembered_name == "Rack internal" && id(last_rack_internal_mode) == rack_fx::RACK_MODE_U_ALERTS) {
          return std::string("U alerts");
        }
        if (rack_fx::is_mode_select_effect(remembered_name)) {
          return rack_fx::canonical_mode_name(remembered_name);
        }
        return std::string("Manual");
      }

      if (name == "Rack internal" && !id(door_override_active) && internal_mode == rack_fx::RACK_MODE_RESTORE_TRANSITION) {
        const std::string restoring_name = id(rack_assistant).get_effect_name_by_index(id(saved_effect_index));
        if (restoring_name == "Rack internal") {
          const std::string internal_option = rack_fx::select_option_for_internal_mode(id(saved_internal_mode));
          if (!internal_option.empty()) {
            return internal_option;
          }
        }
        if (rack_fx::is_mode_select_effect(restoring_name)) {
          return rack_fx::canonical_mode_name(restoring_name);
        }
      }
      if (name == "Rack internal") {
        const std::string internal_option = rack_fx::select_option_for_internal_mode(internal_mode);
        if (!internal_option.empty()) {
          return internal_option;
        }
      }

      if (rack_fx::is_mode_select_effect(name)) {
        return rack_fx::canonical_mode_name(name);
      }
      return std::string("Manual");
    set_action:
      - lambda: |-
          const std::string mode = rack_fx::canonical_mode_name(std::string(x.c_str(), x.size()));
          if (rack_fx::is_manual_mode_option(mode)) {
            id(last_rack_effect_index) = 0;
            id(last_rack_internal_mode) = rack_fx::RACK_MODE_MANUAL;
            id(last_rack_active_zone_mode) = "Whole rack";
            id(last_rack_active_u_start) = 1;
            id(last_rack_active_u_end) = ${rack_unit_count};
            id(rack_light_restore_pending) = false;
            rack_fx::clear_all_alert_slots(id(u_alert_active), id(u_alert_modes));
            id(rack_u_alert_effect).publish_state("No alert");
            id(u_alert_layer_saved) = false;
            id(rack_internal_mode) = rack_fx::RACK_MODE_MANUAL;
            id(rack_internal_generation) += 1;

            if (id(door_override_active)) {
              id(saved_effect_index) = 0;
              id(saved_internal_mode) = rack_fx::RACK_MODE_MANUAL;
              id(rack_assistant_effect_select).update();
              return;
            }

            auto manual_light = id(rack_assistant).make_call();
            manual_light.set_effect(uint32_t{0});
            manual_light.set_save(false);
            manual_light.perform();
            return;
          }

          if (rack_fx::is_alert_layer_mode_option(mode)) {
            if (!id(door_override_active)) {
              const std::string alert_option = id(rack_u_alert_effect).current_option();
              if (rack_fx::is_clear_alert_option(alert_option)) {
                id(show_u_alert_layer).execute();
              } else {
                id(apply_u_alert).execute();
              }
            }
            return;
          }

          const int internal_mode = rack_fx::internal_mode_for_select_option(mode);
          if (internal_mode != rack_fx::RACK_MODE_MANUAL) {
            const std::string selected_zone = rack_fx::canonical_zone_option(id(rack_zone_select).current_option());
            const uint32_t internal_effect = id(rack_assistant).get_effect_index("Rack internal");
            id(last_rack_effect_index) = internal_effect;
            id(last_rack_internal_mode) = internal_mode;
            id(last_rack_active_zone_mode) = selected_zone;
            id(last_rack_active_u_start) = 1;
            id(last_rack_active_u_end) = ${rack_unit_count};
            id(rack_light_restore_pending) = false;

            if (id(door_override_active)) {
              id(saved_effect_index) = internal_effect;
              id(saved_internal_mode) = internal_mode;
              id(saved_active_zone_mode) = selected_zone;
              id(saved_active_u_start) = 1;
              id(saved_active_u_end) = ${rack_unit_count};
              id(rack_assistant_effect_select).update();
              return;
            }

            rack_fx::clear_all_alert_slots(id(u_alert_active), id(u_alert_modes));
            id(rack_u_alert_effect).publish_state("No alert");
            id(u_alert_layer_saved) = false;
            id(active_zone_mode) = selected_zone;
            id(active_u_start) = 1;
            id(active_u_end) = ${rack_unit_count};
            id(rack_internal_mode) = internal_mode;
            id(rack_internal_generation) += 1;

            auto internal_light = id(rack_assistant).make_call();
            internal_light.set_state(true);
            internal_light.set_brightness(1.0f);
            internal_light.set_effect("Rack internal");
            internal_light.set_save(false);
            internal_light.perform();
            return;
          }

          const uint32_t effect = id(rack_assistant).get_effect_index(mode.c_str(), mode.size());
          id(last_rack_effect_index) = effect;
          id(last_rack_internal_mode) = rack_fx::RACK_MODE_MANUAL;
          id(last_rack_active_zone_mode) = "Whole rack";
          id(last_rack_active_u_start) = 1;
          id(last_rack_active_u_end) = ${rack_unit_count};
          id(rack_light_restore_pending) = false;

          if (id(door_override_active)) {
            id(saved_effect_index) = effect;
            id(rack_assistant_effect_select).update();
            return;
          }

          rack_fx::clear_all_alert_slots(id(u_alert_active), id(u_alert_modes));
          id(rack_u_alert_effect).publish_state("No alert");
          id(u_alert_layer_saved) = false;
          id(rack_internal_mode) = rack_fx::RACK_MODE_MANUAL;
          id(rack_internal_generation) += 1;

          auto service_light = id(rack_assistant).make_call();
          if (effect != 0) {
            service_light.set_state(true);
          }
          if (rack_fx::uses_firmware_brightness(mode)) {
            service_light.set_brightness(1.0f);
            service_light.set_save(false);
          }
          service_light.set_effect(effect);
          service_light.perform();

button:
  - platform: template
    id: calibration_block_button
    name: "Calibration block"
    internal: true
    on_press:
      then:
        - lambda: |-
            id(rack_internal_mode) = rack_fx::RACK_MODE_CALIBRATION_BLOCK;
            id(rack_internal_generation) += 1;

            auto service_light = id(rack_assistant).make_call();
            service_light.set_state(true);
            service_light.set_brightness(1.0f);
            service_light.set_effect("Rack internal");
            service_light.set_save(false);
            service_light.perform();

script:
  - id: apply_first_install_default
    mode: single
    then:
      - lambda: |-
          if (id(rack_defaults_initialized)) {
            return;
          }

          id(rack_defaults_initialized) = true;

          if (id(rack_assistant).remote_values.is_on() && id(rack_assistant).get_current_effect_index() != 0) {
            return;
          }

          const uint32_t internal_effect = id(rack_assistant).get_effect_index("Rack internal");
          id(last_rack_effect_index) = internal_effect;
          id(last_rack_internal_mode) = rack_fx::RACK_MODE_ZONE_BREATHING_BLUE;
          id(last_rack_active_zone_mode) = "Whole rack";
          id(last_rack_active_u_start) = 1;
          id(last_rack_active_u_end) = ${rack_unit_count};
          id(active_zone_mode) = "Whole rack";
          id(active_u_start) = 1;
          id(active_u_end) = ${rack_unit_count};
          id(rack_internal_mode) = rack_fx::RACK_MODE_ZONE_BREATHING_BLUE;
          id(rack_internal_generation) += 1;
          id(rack_light_restore_pending) = false;
          rack_fx::clear_all_alert_slots(id(u_alert_active), id(u_alert_modes));
          id(rack_u_alert_effect).publish_state("No alert");

          auto default_light = id(rack_assistant).make_call();
          default_light.set_state(true);
          default_light.set_color_mode(esphome::light::ColorMode::RGB_WHITE);
          default_light.set_rgbw(85.0f / 255.0f, 170.0f / 255.0f, 1.0f, 0.0f);
          default_light.set_brightness(1.0f);
          default_light.set_effect("Rack internal");
          default_light.set_save(false);
          default_light.perform();

  - id: sync_direct_light_effect
    mode: restart
    then:
      - lambda: |-
          const uint32_t current_effect = id(rack_assistant).get_current_effect_index();
          const std::string effect_name =
            id(rack_assistant).get_effect_name_by_index(current_effect);

          if (!id(rack_assistant).remote_values.is_on()) {
            if (effect_name == "Rack internal") {
              id(last_rack_effect_index) = current_effect;
              id(last_rack_internal_mode) = id(rack_internal_mode);
              id(last_rack_active_zone_mode) = id(active_zone_mode);
              id(last_rack_active_u_start) = id(active_u_start);
              id(last_rack_active_u_end) = id(active_u_end);
            } else if (current_effect != 0 && rack_fx::is_mode_select_effect(effect_name)) {
              id(last_rack_effect_index) = current_effect;
              id(last_rack_internal_mode) = rack_fx::RACK_MODE_MANUAL;
              id(last_rack_active_zone_mode) = "Whole rack";
              id(last_rack_active_u_start) = 1;
              id(last_rack_active_u_end) = ${rack_unit_count};
            }
            id(rack_light_restore_pending) = true;
            return;
          }

          if (id(rack_light_restore_pending)) {
            id(rack_light_restore_pending) = false;
            if (current_effect == 0 && id(last_rack_effect_index) != 0) {
              const uint32_t internal_effect = id(rack_assistant).get_effect_index("Rack internal");
              auto restore_light = id(rack_assistant).make_call();
              restore_light.set_state(true);
              restore_light.set_brightness(1.0f);
              restore_light.set_save(false);
              if (id(last_rack_effect_index) == internal_effect) {
                id(rack_internal_mode) = id(last_rack_internal_mode);
                id(active_zone_mode) = id(last_rack_active_zone_mode);
                id(active_u_start) = id(last_rack_active_u_start);
                id(active_u_end) = id(last_rack_active_u_end);
                id(rack_internal_generation) += 1;
                restore_light.set_effect("Rack internal");
              } else {
                restore_light.set_effect(id(last_rack_effect_index));
              }
              restore_light.perform();
              return;
            }
          }

          if (effect_name == "Rack internal") {
            id(last_rack_effect_index) = current_effect;
            id(last_rack_internal_mode) = id(rack_internal_mode);
            id(last_rack_active_zone_mode) = id(active_zone_mode);
            id(last_rack_active_u_start) = id(active_u_start);
            id(last_rack_active_u_end) = id(active_u_end);
            return;
          }

          const int direct_internal_mode = rack_fx::internal_mode_for_select_option(effect_name);
          if (direct_internal_mode != rack_fx::RACK_MODE_MANUAL) {
            const std::string selected_zone = rack_fx::canonical_zone_option(id(rack_zone_select).current_option());
            const uint32_t internal_effect = id(rack_assistant).get_effect_index("Rack internal");
            id(last_rack_effect_index) = internal_effect;
            id(last_rack_internal_mode) = direct_internal_mode;
            id(last_rack_active_zone_mode) = selected_zone;
            id(last_rack_active_u_start) = 1;
            id(last_rack_active_u_end) = ${rack_unit_count};
            rack_fx::clear_all_alert_slots(id(u_alert_active), id(u_alert_modes));
            id(rack_u_alert_effect).publish_state("No alert");
            id(u_alert_layer_saved) = false;
            id(active_zone_mode) = selected_zone;
            id(active_u_start) = 1;
            id(active_u_end) = ${rack_unit_count};
            id(rack_internal_mode) = direct_internal_mode;
            id(rack_internal_generation) += 1;

            auto internal_light = id(rack_assistant).make_call();
            internal_light.set_state(true);
            internal_light.set_brightness(1.0f);
            internal_light.set_effect("Rack internal");
            internal_light.set_save(false);
            internal_light.perform();
            return;
          }

          if (id(rack_internal_mode) != rack_fx::RACK_MODE_MANUAL || rack_fx::has_active_alerts(id(u_alert_active), id(u_alert_modes))) {
            rack_fx::clear_all_alert_slots(id(u_alert_active), id(u_alert_modes));
            id(rack_u_alert_effect).publish_state("No alert");
            id(rack_internal_mode) = rack_fx::RACK_MODE_MANUAL;
            id(rack_internal_generation) += 1;
            id(u_alert_layer_saved) = false;
          }

          if (current_effect == 0) {
            id(last_rack_effect_index) = 0;
            id(last_rack_internal_mode) = rack_fx::RACK_MODE_MANUAL;
          } else if (rack_fx::is_mode_select_effect(effect_name)) {
            id(last_rack_effect_index) = current_effect;
            id(last_rack_internal_mode) = rack_fx::RACK_MODE_MANUAL;
            id(last_rack_active_zone_mode) = "Whole rack";
            id(last_rack_active_u_start) = 1;
            id(last_rack_active_u_end) = ${rack_unit_count};
          }

  - id: show_u_alert_layer
    mode: restart
    then:
      - lambda: |-
          const bool has_alerts = rack_fx::has_active_alerts(id(u_alert_active), id(u_alert_modes));
          const uint32_t internal_effect = id(rack_assistant).get_effect_index("Rack internal");

          if (id(door_override_active)) {
            if (has_alerts) {
              id(saved_effect_index) = internal_effect;
              id(saved_internal_mode) = rack_fx::RACK_MODE_U_ALERTS;
            } else if (id(u_alert_layer_saved)) {
              id(saved_light_state) = id(u_alert_saved_light_state);
              id(saved_effect_index) = id(u_alert_saved_effect_index);
              id(saved_internal_mode) = id(u_alert_saved_internal_mode);
              id(saved_active_zone_mode) = id(u_alert_saved_active_zone_mode);
              id(saved_active_u_start) = id(u_alert_saved_active_u_start);
              id(saved_active_u_end) = id(u_alert_saved_active_u_end);
              id(u_alert_layer_saved) = false;
            } else {
              id(saved_effect_index) = 0;
              id(saved_internal_mode) = rack_fx::RACK_MODE_MANUAL;
            }
            id(rack_assistant_effect_select).update();
            return;
          }

          if (!has_alerts) {
            if (
              id(rack_assistant).get_current_effect_index() == internal_effect &&
              id(rack_internal_mode) == rack_fx::RACK_MODE_U_ALERTS
            ) {
              if (id(u_alert_layer_saved)) {
                id(saved_light_state) = id(u_alert_saved_light_state);
                id(saved_effect_index) = id(u_alert_saved_effect_index);
                id(saved_internal_mode) = id(u_alert_saved_internal_mode);
                id(saved_active_zone_mode) = id(u_alert_saved_active_zone_mode);
                id(saved_active_u_start) = id(u_alert_saved_active_u_start);
                id(saved_active_u_end) = id(u_alert_saved_active_u_end);
                id(rack_internal_mode) = rack_fx::RACK_MODE_RESTORE_TRANSITION;
                id(rack_internal_generation) += 1;

                auto transition_light = id(rack_assistant).make_call();
                transition_light.set_state(true);
                transition_light.set_color_mode(esphome::light::ColorMode::RGB_WHITE);
                transition_light.set_brightness(1.0f);
                transition_light.set_rgbw(0.0f, 0.0f, 0.0f, 1.0f);
                transition_light.set_effect("Rack internal");
                transition_light.set_save(false);
                transition_light.perform();
                id(finish_u_alert_restore).execute();
              } else {
                id(rack_internal_mode) = rack_fx::RACK_MODE_MANUAL;
                id(rack_internal_generation) += 1;
                auto clear_light = id(rack_assistant).make_call();
                clear_light.set_state(false);
                clear_light.set_effect(uint32_t{0});
                clear_light.set_save(false);
                clear_light.perform();
              }
            }
            id(rack_assistant_effect_select).update();
            return;
          }

          if (!id(u_alert_layer_saved)) {
            id(u_alert_saved_light_state) = id(rack_assistant).remote_values;
            id(u_alert_saved_effect_index) = id(rack_assistant).get_current_effect_index();
            id(u_alert_saved_internal_mode) = id(rack_internal_mode);
            id(u_alert_saved_active_zone_mode) = id(active_zone_mode);
            id(u_alert_saved_active_u_start) = id(active_u_start);
            id(u_alert_saved_active_u_end) = id(active_u_end);
            id(u_alert_layer_saved) = true;
          }

          id(rack_internal_mode) = rack_fx::RACK_MODE_U_ALERTS;
          id(last_rack_effect_index) = internal_effect;
          id(last_rack_internal_mode) = rack_fx::RACK_MODE_U_ALERTS;
          id(last_rack_active_zone_mode) = id(active_zone_mode);
          id(last_rack_active_u_start) = id(active_u_start);
          id(last_rack_active_u_end) = id(active_u_end);
          id(rack_internal_generation) += 1;
          auto service_light = id(rack_assistant).make_call();
          service_light.set_state(true);
          service_light.set_brightness(1.0f);
          service_light.set_effect("Rack internal");
          service_light.set_save(false);
          service_light.perform();

  - id: finish_u_alert_restore
    mode: restart
    then:
      - delay: 900ms
      - lambda: |-
          if (
            id(door_override_active) ||
            rack_fx::has_active_alerts(id(u_alert_active), id(u_alert_modes)) ||
            !id(u_alert_layer_saved)
          ) {
            return;
          }

          id(rack_internal_mode) = id(u_alert_saved_internal_mode);
          id(active_zone_mode) = id(u_alert_saved_active_zone_mode);
          id(active_u_start) = id(u_alert_saved_active_u_start);
          id(active_u_end) = id(u_alert_saved_active_u_end);

          auto restore_light = id(rack_assistant).make_call();
          restore_light.from_light_color_values(id(u_alert_saved_light_state));
          if (id(u_alert_saved_light_state).is_on() && id(u_alert_saved_effect_index) != 0) {
            restore_light.set_effect(id(u_alert_saved_effect_index));
          } else {
            restore_light.set_effect(uint32_t{0});
          }
          restore_light.set_save(false);
          restore_light.perform();
          id(u_alert_layer_saved) = false;
          id(rack_assistant_effect_select).update();

  - id: normalize_firmware_effect_brightness
    mode: restart
    then:
      - lambda: |-
          const std::string effect_name =
            id(rack_assistant).get_effect_name_by_index(id(rack_assistant).get_current_effect_index());
          if (!id(rack_assistant).remote_values.is_on() || !rack_fx::uses_firmware_brightness(effect_name)) {
            return;
          }
          if (id(rack_assistant).remote_values.get_brightness() >= 0.995f) {
            return;
          }

          auto service_light = id(rack_assistant).make_call();
          service_light.set_state(true);
          service_light.set_brightness(1.0f);
          service_light.set_transition_length(0);
          service_light.set_save(false);
          service_light.perform();

  - id: separate_light_rgbw_channels
    mode: restart
    then:
      - lambda: |-
          if (!id(rack_assistant).remote_values.is_on()) {
            return;
          }

          float red = 0.0f;
          float green = 0.0f;
          float blue = 0.0f;
          float white = 0.0f;
          id(rack_assistant).remote_values.as_rgbw(&red, &green, &blue, &white);

          const bool has_rgb = red > 0.001f || green > 0.001f || blue > 0.001f;
          const bool has_white = white > 0.001f;
          if (!has_rgb || !has_white) {
            return;
          }

          rack_fx::separate_rgbw_unit(red, green, blue, white);
          auto service_light = id(rack_assistant).make_call();
          service_light.set_state(true);
          service_light.set_color_mode(esphome::light::ColorMode::RGB_WHITE);
          service_light.set_rgbw(red, green, blue, white);
          service_light.set_transition_length(0);
          service_light.set_save(false);
          service_light.perform();

  - id: apply_u_alert
    mode: restart
    then:
      - lambda: |-
          const std::string alert_option = id(rack_u_alert_effect).current_option();
          if (rack_fx::is_clear_alert_option(alert_option)) {
            rack_fx::clear_alert_slot(id(u_alert_active), id(u_alert_modes), 0);
            return;
          }
          rack_fx::set_alert_slot_preset(
            id(u_alert_active),
            id(u_alert_first_u),
            id(u_alert_last_u),
            id(u_alert_modes),
            id(u_alert_starts),
            id(u_alert_reds),
            id(u_alert_greens),
            id(u_alert_blues),
            id(u_alert_whites),
            0,
            int(roundf(id(rack_u_start).state)),
            int(roundf(id(rack_u_end).state)),
            alert_option
          );
      - script.execute: show_u_alert_layer

  - id: refresh_u_alert_if_active
    mode: restart
    then:
      - if:
          condition:
            lambda: |-
              const std::string alert_option = id(rack_u_alert_effect).current_option();
              return !id(door_override_active) &&
                     !rack_fx::is_clear_alert_option(alert_option) &&
                     id(rack_assistant).get_current_effect_index() == id(rack_assistant).get_effect_index("Rack internal") &&
                     id(rack_internal_mode) == rack_fx::RACK_MODE_U_ALERTS;
          then:
            - script.execute: apply_u_alert

  - id: door_open_sequence
    mode: restart
    then:
      - script.stop: door_close_sequence
      - lambda: |-
          if (!id(door_override_active)) {
            id(saved_light_state) = id(rack_assistant).remote_values;
            id(saved_effect_index) = id(rack_assistant).get_current_effect_index();
            id(saved_internal_mode) = id(rack_internal_mode);
            id(saved_active_zone_mode) = id(active_zone_mode);
            id(saved_active_u_start) = id(active_u_start);
            id(saved_active_u_end) = id(active_u_end);
            id(door_override_active) = true;
          }

          id(rack_internal_mode) = rack_fx::RACK_MODE_DOOR_OPEN;
          auto service_light = id(rack_assistant).make_call();
          service_light.set_state(true);
          service_light.set_color_mode(esphome::light::ColorMode::RGB_WHITE);
          service_light.set_brightness(1.0f);
          service_light.set_rgbw(0.0f, 0.0f, 0.0f, 1.0f);
          service_light.set_effect("Rack internal");
          service_light.set_save(false);
          service_light.perform();

  - id: door_close_sequence
    mode: restart
    then:
      - script.stop: door_open_sequence
      - if:
          condition:
            lambda: |-
              return id(door_override_active);
          then:
            - lambda: |-
                id(rack_internal_mode) = rack_fx::RACK_MODE_RESTORE_TRANSITION;
                auto restore_transition = id(rack_assistant).make_call();
                restore_transition.set_state(true);
                restore_transition.set_color_mode(esphome::light::ColorMode::RGB_WHITE);
                restore_transition.set_brightness(1.0f);
                restore_transition.set_rgbw(0.0f, 0.0f, 0.0f, 1.0f);
                restore_transition.set_effect("Rack internal");
                restore_transition.set_save(false);
                restore_transition.perform();
            - delay: 900ms
            - lambda: |-
                id(rack_internal_mode) = id(saved_internal_mode);
                id(active_zone_mode) = id(saved_active_zone_mode);
                id(active_u_start) = id(saved_active_u_start);
                id(active_u_end) = id(saved_active_u_end);

                auto restore_light = id(rack_assistant).make_call();
                restore_light.from_light_color_values(id(saved_light_state));
                if (id(saved_light_state).is_on() && id(saved_effect_index) != 0) {
                  restore_light.set_effect(id(saved_effect_index));
                } else {
                  restore_light.set_effect(uint32_t{0});
                }
                restore_light.perform();
                id(door_override_active) = false;

binary_sensor:
  - platform: homeassistant
    id: rack_door_contact
    entity_id: !secret door_contact_entity
    internal: true
    filters:
      - delayed_on: 80ms
      - delayed_off: 250ms
    on_press:
      then:
        - if:
            condition:
              switch.is_on: door_sensor_enabled
            then:
              - script.execute: door_open_sequence
    on_release:
      then:
        - if:
            condition:
              switch.is_on: door_sensor_enabled
            then:
              - script.execute: door_close_sequence

light:
  - platform: esp32_rmt_led_strip
    id: rack_assistant
    name: "Rack Assistant"
    pin: ${led_pin}
    num_leds: ${led_count}
    chipset: SK6812
    rgb_order: GRB
    is_rgbw: true
    restore_mode: RESTORE_DEFAULT_OFF
    default_transition_length: 700ms
    # The firmware already shapes/dithers low brightness levels. Extra ESPHome gamma
    # crushes those low PWM steps and makes breathing transitions visibly jump.
    gamma_correct: 1.0
    color_correct: [100%, 100%, 100%, 100%]
    on_state:
      then:
        - script.execute: separate_light_rgbw_channels
        - script.execute: sync_direct_light_effect
        - component.update: rack_assistant_effect_select
        - script.execute: normalize_firmware_effect_brightness
    effects:
      - addressable_lambda:
          name: "White breathing"
          update_interval: 16ms
          lambda: |-
            float min_brightness = id(breathing_min_percent).state / 100.0f;
            float max_brightness = id(breathing_max_percent).state / 100.0f;
            rack_fx::clamp_brightness_range(min_brightness, max_brightness);
            static uint32_t start_ms = 0;
            if (initial_run) {
              start_ms = millis();
            }
            const uint32_t cycle_ms = rack_fx::breathing_cycle_ms(id(breathing_cycle_seconds).state);
            const int curve_mode = rack_fx::breathing_curve_mode(id(breathing_curve_select).current_option());
            const float level = rack_fx::breathing_level(start_ms, cycle_ms, min_brightness, max_brightness, curve_mode);
            rack_fx::set_dithered_rgbw(it, 0.0f, 0.0f, 0.0f, level * 255.0f);

      - addressable_lambda:
          name: "Selected color breathing"
          update_interval: 16ms
          lambda: |-
            float min_brightness = id(breathing_min_percent).state / 100.0f;
            float max_brightness = id(breathing_max_percent).state / 100.0f;
            rack_fx::clamp_brightness_range(min_brightness, max_brightness);
            static uint32_t start_ms = 0;
            if (initial_run) {
              start_ms = millis();
            }
            const uint32_t cycle_ms = rack_fx::breathing_cycle_ms(id(breathing_cycle_seconds).state);
            const int curve_mode = rack_fx::breathing_curve_mode(id(breathing_curve_select).current_option());
            const float level = rack_fx::breathing_level(start_ms, cycle_ms, min_brightness, max_brightness, curve_mode);
            rack_fx::set_dithered_rgbw(
              it,
              current_color.r * level,
              current_color.g * level,
              current_color.b * level,
              0.0f
            );

      - addressable_lambda:
          name: "Blue breathing"
          update_interval: 16ms
          lambda: |-
            float min_brightness = id(breathing_min_percent).state / 100.0f;
            float max_brightness = id(breathing_max_percent).state / 100.0f;
            rack_fx::clamp_brightness_range(min_brightness, max_brightness);
            static uint32_t start_ms = 0;
            if (initial_run) {
              start_ms = millis();
            }
            const uint32_t cycle_ms = rack_fx::breathing_cycle_ms(id(breathing_cycle_seconds).state);
            const int curve_mode = rack_fx::breathing_curve_mode(id(breathing_curve_select).current_option());
            const float level = rack_fx::breathing_level(start_ms, cycle_ms, min_brightness, max_brightness, curve_mode);
            rack_fx::set_dithered_rgbw(it, 0.0f, level * 111.0f, level * 255.0f, 0.0f);

      - addressable_lambda:
          name: "Orange breathing"
          update_interval: 16ms
          lambda: |-
            float min_brightness = id(breathing_min_percent).state / 100.0f;
            float max_brightness = id(breathing_max_percent).state / 100.0f;
            rack_fx::clamp_brightness_range(min_brightness, max_brightness);
            static uint32_t start_ms = 0;
            if (initial_run) {
              start_ms = millis();
            }
            const uint32_t cycle_ms = rack_fx::breathing_cycle_ms(id(breathing_cycle_seconds).state);
            const int curve_mode = rack_fx::breathing_curve_mode(id(breathing_curve_select).current_option());
            const float level = rack_fx::breathing_level(start_ms, cycle_ms, min_brightness, max_brightness, curve_mode);
            rack_fx::set_dithered_rgbw(it, level * 255.0f, level * 82.0f, 0.0f, 0.0f);

      - addressable_lambda:
          name: "Red breathing"
          update_interval: 16ms
          lambda: |-
            float min_brightness = id(breathing_min_percent).state / 100.0f;
            float max_brightness = id(breathing_max_percent).state / 100.0f;
            rack_fx::clamp_brightness_range(min_brightness, max_brightness);
            static uint32_t start_ms = 0;
            if (initial_run) {
              start_ms = millis();
            }
            const uint32_t cycle_ms = rack_fx::breathing_cycle_ms(id(breathing_cycle_seconds).state);
            const int curve_mode = rack_fx::breathing_curve_mode(id(breathing_curve_select).current_option());
            const float level = rack_fx::breathing_level(start_ms, cycle_ms, min_brightness, max_brightness, curve_mode);
            rack_fx::set_dithered_rgbw(it, level * 255.0f, 0.0f, 0.0f, 0.0f);

      - addressable_lambda:
          name: "Internet down"
          update_interval: 16ms
          lambda: |-
            float min_brightness = id(breathing_min_percent).state / 100.0f;
            float max_brightness = id(breathing_max_percent).state / 100.0f;
            rack_fx::clamp_brightness_range(min_brightness, max_brightness);
            static uint32_t start_ms = 0;
            if (initial_run) {
              start_ms = millis();
            }
            const uint32_t cycle_ms = rack_fx::breathing_cycle_ms(id(breathing_cycle_seconds).state);
            const int curve_mode = rack_fx::breathing_curve_mode(id(breathing_curve_select).current_option());
            const float level = rack_fx::breathing_level(start_ms, cycle_ms, min_brightness, max_brightness, curve_mode);
            rack_fx::set_dithered_rgbw(it, level * 255.0f, 0.0f, 0.0f, 0.0f);

      - addressable_lambda:
          name: "Error"
          update_interval: 16ms
          lambda: |-
            static uint32_t start_ms = 0;
            if (initial_run) {
              start_ms = millis();
            }
            float max_brightness = id(breathing_max_percent).state / 100.0f;
            max_brightness = rack_fx::clamp01(max_brightness);
            rack_fx::render_center_burst_rgbw(
              it,
              millis() - start_ms,
              max_brightness,
              ${rack_left_start},
              ${rack_side_led_count},
              ${rack_right_start},
              255.0f,
              0.0f,
              0.0f,
              0.0f
            );

      - addressable_lambda:
          name: "Success"
          update_interval: 16ms
          lambda: |-
            static uint32_t start_ms = 0;
            if (initial_run) {
              start_ms = millis();
            }
            float max_brightness = id(breathing_max_percent).state / 100.0f;
            max_brightness = rack_fx::clamp01(max_brightness);
            rack_fx::render_center_burst_rgbw(
              it,
              millis() - start_ms,
              max_brightness,
              ${rack_left_start},
              ${rack_side_led_count},
              ${rack_right_start},
              0.0f,
              255.0f,
              70.0f,
              0.0f
            );

      - addressable_lambda:
          name: "Rack internal"
          update_interval: 16ms
          lambda: |-
            static std::vector<esphome::Color> transition_start;
            static uint32_t start_ms = 0;
            static int last_mode = -1;
            static int last_generation = -1;

            const int mode = id(rack_internal_mode);
            const int generation = id(rack_internal_generation);
            if (
              initial_run ||
              last_mode != mode ||
              last_generation != generation ||
              transition_start.size() != size_t(it.size())
            ) {
              rack_fx::capture_pixels(it, transition_start);
              start_ms = millis();
              last_mode = mode;
              last_generation = generation;
            }

            if (mode == rack_fx::RACK_MODE_ZONE_STATIC) {
              const float fade = rack_fx::transition_progress(start_ms, ${rack_u_alert_fade_ms}.0f);
              rack_fx::render_transition_to_zone_dithered_rgbw(
                it,
                transition_start,
                id(active_zone_mode),
                id(active_u_start),
                id(active_u_end),
                ${rack_bottom_start},
                ${rack_bottom_led_count},
                ${rack_left_start},
                ${rack_side_led_count},
                ${rack_top_start},
                ${rack_top_led_count},
                ${rack_right_start},
                current_color.r,
                current_color.g,
                current_color.b,
                0.0f,
                fade
              );
              return;
            }

            if (rack_fx::rack_mode_is_zone_breathing(mode)) {
              float min_brightness = id(breathing_min_percent).state / 100.0f;
              float max_brightness = id(breathing_max_percent).state / 100.0f;
              rack_fx::clamp_brightness_range(min_brightness, max_brightness);
              const uint32_t cycle_ms = rack_fx::breathing_cycle_ms(id(breathing_cycle_seconds).state);
              const int curve_mode = rack_fx::breathing_curve_mode(id(breathing_curve_select).current_option());
              const float fade = rack_fx::transition_progress(start_ms, ${rack_u_alert_fade_ms}.0f);
              const float level =
                rack_fx::breathing_level(start_ms, cycle_ms, min_brightness, max_brightness, curve_mode);

              const rack_fx::RgbwChannels channels =
                rack_fx::rack_mode_breathing_channels(mode, current_color, level);

              rack_fx::render_transition_to_zone_dithered_rgbw(
                it,
                transition_start,
                id(active_zone_mode),
                id(active_u_start),
                id(active_u_end),
                ${rack_bottom_start},
                ${rack_bottom_led_count},
                ${rack_left_start},
                ${rack_side_led_count},
                ${rack_top_start},
                ${rack_top_led_count},
                ${rack_right_start},
                channels.red,
                channels.green,
                channels.blue,
                channels.white,
                fade
              );
              return;
            }

            if (mode == rack_fx::RACK_MODE_U_ALERTS) {
              float min_brightness = id(breathing_min_percent).state / 100.0f;
              float max_brightness = id(breathing_max_percent).state / 100.0f;
              rack_fx::clamp_brightness_range(min_brightness, max_brightness);
              const uint32_t cycle_ms = rack_fx::breathing_cycle_ms(id(breathing_cycle_seconds).state);
              const int curve_mode = rack_fx::breathing_curve_mode(id(breathing_curve_select).current_option());
              const float progress = rack_fx::transition_progress(start_ms, ${rack_u_alert_fade_ms}.0f);
              if (progress < 0.999f) {
                rack_fx::render_transition_to_alert_slots(
                  it,
                  transition_start,
                  id(u_alert_active),
                  id(u_alert_first_u),
                  id(u_alert_last_u),
                  id(u_alert_modes),
                  id(u_alert_starts),
                  id(u_alert_reds),
                  id(u_alert_greens),
                  id(u_alert_blues),
                  id(u_alert_whites),
                  current_color,
                  min_brightness,
                  max_brightness,
                  cycle_ms,
                  curve_mode,
                  ${rack_u_alert_blink_ms},
                  0.0f,
                  progress,
                  ${rack_left_start},
                  ${rack_side_led_count},
                  ${rack_right_start}
                );
                return;
              }

              rack_fx::render_alert_slots(
                it,
                id(u_alert_active),
                id(u_alert_first_u),
                id(u_alert_last_u),
                id(u_alert_modes),
                id(u_alert_starts),
                id(u_alert_reds),
                id(u_alert_greens),
                id(u_alert_blues),
                id(u_alert_whites),
                current_color,
                min_brightness,
                max_brightness,
                cycle_ms,
                curve_mode,
                ${rack_u_alert_blink_ms},
                0.0f,
                ${rack_left_start},
                ${rack_side_led_count},
                ${rack_right_start}
              );
              return;
            }

            if (
              mode == rack_fx::RACK_MODE_CENTER_BURST_ERROR ||
              mode == rack_fx::RACK_MODE_CENTER_BURST_SUCCESS
            ) {
              float max_brightness = id(breathing_max_percent).state / 100.0f;
              max_brightness = rack_fx::clamp01(max_brightness);
              const float progress = rack_fx::transition_progress(start_ms, ${rack_u_alert_fade_ms}.0f);
              if (mode == rack_fx::RACK_MODE_CENTER_BURST_SUCCESS) {
                rack_fx::render_transition_to_center_burst_rgbw(
                  it,
                  transition_start,
                  millis() - start_ms,
                  max_brightness,
                  ${rack_left_start},
                  ${rack_side_led_count},
                  ${rack_right_start},
                  0.0f,
                  255.0f,
                  70.0f,
                  0.0f,
                  progress
                );
              } else {
                rack_fx::render_transition_to_center_burst_rgbw(
                  it,
                  transition_start,
                  millis() - start_ms,
                  max_brightness,
                  ${rack_left_start},
                  ${rack_side_led_count},
                  ${rack_right_start},
                  255.0f,
                  0.0f,
                  0.0f,
                  0.0f,
                  progress
                );
              }
              return;
            }

            if (
              mode == rack_fx::RACK_MODE_U_SCAN_RED ||
              mode == rack_fx::RACK_MODE_U_SCAN_SELECTED
            ) {
              uint32_t step_ms = uint32_t(id(rack_u_scan_seconds).state * 1000.0f);
              if (step_ms < 150) {
                step_ms = 150;
              }
              const uint32_t elapsed = millis() - start_ms;
              const uint32_t step_index = elapsed / step_ms;
              float max_brightness = id(breathing_max_percent).state / 100.0f;
              max_brightness = rack_fx::clamp01(max_brightness);
              const float level = max_brightness * rack_fx::scan_step_fade(elapsed, step_ms);
              const int u = rack_fx::ping_pong_u(step_index);
              float red = level;
              float green = 0.0f;
              float blue = 0.0f;
              float white = 0.0f;
              if (mode == rack_fx::RACK_MODE_U_SCAN_SELECTED) {
                red = (current_color.r / 255.0f) * level;
                green = (current_color.g / 255.0f) * level;
                blue = (current_color.b / 255.0f) * level;
              }
              const std::string zone_mode = "Selected U";
              const float progress = rack_fx::transition_progress(start_ms, ${rack_u_alert_fade_ms}.0f);
              rack_fx::render_transition_to_zone_dithered_rgbw(
                it,
                transition_start,
                zone_mode,
                u,
                u,
                0,
                0,
                ${rack_left_start},
                ${rack_side_led_count},
                0,
                0,
                ${rack_right_start},
                red * 255.0f,
                green * 255.0f,
                blue * 255.0f,
                white * 255.0f,
                progress
              );
              return;
            }

            if (mode == rack_fx::RACK_MODE_CALIBRATION_BLOCK) {
              int start = int(roundf(id(calibration_start_led).state));
              int width = int(roundf(id(calibration_led_count).state));
              int start_2 = int(roundf(id(calibration_start_led_2).state));
              int width_2 = int(roundf(id(calibration_led_count_2).state));
              const int total = it.size();

              rack_fx::clamp_segment(start, width, total);
              rack_fx::clamp_segment(start_2, width_2, total);

              const uint8_t red = rack_fx::scaled_channel(id(calibration_brightness_percent).state / 100.0f);
              for (int i = 0; i < total; i++) {
                it[i] = esphome::Color(0, 0, 0, 0);
              }
              for (int i = start; i < start + width; i++) {
                it[i] = esphome::Color(red, 0, 0, 0);
              }
              for (int i = start_2; i < start_2 + width_2; i++) {
                it[i] = esphome::Color(red, 0, 0, 0);
              }
              return;
            }

            if (mode == rack_fx::RACK_MODE_DOOR_OPEN) {
              const float progress = rack_fx::transition_progress(start_ms, 900.0f);
              float red = 0.0f;
              float green = 0.0f;
              float blue = 0.0f;
              float white = 0.0f;
              id(saved_light_state).as_rgbw(&red, &green, &blue, &white);

              float min_brightness = id(breathing_min_percent).state / 100.0f;
              float max_brightness = id(breathing_max_percent).state / 100.0f;
              rack_fx::clamp_brightness_range(min_brightness, max_brightness);
              const uint32_t cycle_ms = rack_fx::breathing_cycle_ms(id(breathing_cycle_seconds).state);
              const int curve_mode = rack_fx::breathing_curve_mode(id(breathing_curve_select).current_option());
              const esphome::Color selected_target = rack_fx::rgbw_color(red, green, blue, 0.0f);

              rack_fx::render_transition_to_door_open_alerts(
                it,
                transition_start,
                id(u_alert_active),
                id(u_alert_first_u),
                id(u_alert_last_u),
                id(u_alert_modes),
                id(u_alert_starts),
                id(u_alert_reds),
                id(u_alert_greens),
                id(u_alert_blues),
                id(u_alert_whites),
                selected_target,
                min_brightness,
                max_brightness,
                cycle_ms,
                curve_mode,
                ${rack_u_alert_blink_ms},
                ${rack_u_alert_fade_ms}.0f,
                rack_fx::rgbw_color(0.0f, 0.0f, 0.0f, 1.0f),
                progress,
                ${rack_left_start},
                ${rack_side_led_count},
                ${rack_right_start}
              );
              return;
            }

            if (mode == rack_fx::RACK_MODE_RESTORE_TRANSITION) {
              float red = 0.0f;
              float green = 0.0f;
              float blue = 0.0f;
              float white = 0.0f;
              id(saved_light_state).as_rgbw(&red, &green, &blue, &white);
              if (!id(saved_light_state).is_on()) {
                red = 0.0f;
                green = 0.0f;
                blue = 0.0f;
                white = 0.0f;
              }
              const uint32_t saved_effect = id(saved_effect_index);
              const float min_brightness = rack_fx::clamp01(id(breathing_min_percent).state / 100.0f);

              if (saved_effect == id(rack_assistant).get_effect_index("Rack internal")) {
                if (id(saved_internal_mode) == rack_fx::RACK_MODE_U_ALERTS) {
                  float max_brightness = id(breathing_max_percent).state / 100.0f;
                  float alert_min_brightness = min_brightness;
                  rack_fx::clamp_brightness_range(alert_min_brightness, max_brightness);
                  const uint32_t cycle_ms = rack_fx::breathing_cycle_ms(id(breathing_cycle_seconds).state);
                  const int curve_mode = rack_fx::breathing_curve_mode(id(breathing_curve_select).current_option());
                  const esphome::Color selected_target = rack_fx::rgbw_color(red, green, blue, 0.0f);
                  const float progress = rack_fx::transition_progress(start_ms, 900.0f);
                  rack_fx::render_transition_to_alert_slots(
                    it,
                    transition_start,
                    id(u_alert_active),
                    id(u_alert_first_u),
                    id(u_alert_last_u),
                    id(u_alert_modes),
                    id(u_alert_starts),
                    id(u_alert_reds),
                    id(u_alert_greens),
                    id(u_alert_blues),
                    id(u_alert_whites),
                    selected_target,
                    alert_min_brightness,
                    max_brightness,
                    cycle_ms,
                    curve_mode,
                    ${rack_u_alert_blink_ms},
                    ${rack_u_alert_fade_ms}.0f,
                    progress,
                    ${rack_left_start},
                    ${rack_side_led_count},
                    ${rack_right_start}
                  );
                  return;
                }

                if (rack_fx::rack_mode_is_zone_breathing(id(saved_internal_mode))) {
                  float max_brightness = id(breathing_max_percent).state / 100.0f;
                  float restore_min_brightness = min_brightness;
                  rack_fx::clamp_brightness_range(restore_min_brightness, max_brightness);
                  const rack_fx::RgbwChannels channels = rack_fx::rack_mode_breathing_channels(
                    id(saved_internal_mode),
                    rack_fx::rgbw_color(red, green, blue, 0.0f),
                    restore_min_brightness
                  );
                  const float progress = rack_fx::transition_progress(start_ms, 900.0f);
                  rack_fx::render_transition_to_zone_dithered_rgbw(
                    it,
                    transition_start,
                    id(saved_active_zone_mode),
                    id(saved_active_u_start),
                    id(saved_active_u_end),
                    ${rack_bottom_start},
                    ${rack_bottom_led_count},
                    ${rack_left_start},
                    ${rack_side_led_count},
                    ${rack_top_start},
                    ${rack_top_led_count},
                    ${rack_right_start},
                    channels.red,
                    channels.green,
                    channels.blue,
                    channels.white,
                    progress
                  );
                  return;
                }

                if (
                  id(saved_internal_mode) == rack_fx::RACK_MODE_CENTER_BURST_ERROR ||
                  id(saved_internal_mode) == rack_fx::RACK_MODE_CENTER_BURST_SUCCESS
                ) {
                  float max_brightness = id(breathing_max_percent).state / 100.0f;
                  max_brightness = rack_fx::clamp01(max_brightness);
                  const float progress = rack_fx::transition_progress(start_ms, 900.0f);
                  const bool success = id(saved_internal_mode) == rack_fx::RACK_MODE_CENTER_BURST_SUCCESS;
                  rack_fx::render_transition_to_center_burst_rgbw(
                    it,
                    transition_start,
                    millis() - start_ms,
                    max_brightness,
                    ${rack_left_start},
                    ${rack_side_led_count},
                    ${rack_right_start},
                    success ? 0.0f : 255.0f,
                    success ? 255.0f : 0.0f,
                    success ? 70.0f : 0.0f,
                    0.0f,
                    progress
                  );
                  return;
                }

                if (
                  id(saved_internal_mode) == rack_fx::RACK_MODE_U_SCAN_RED ||
                  id(saved_internal_mode) == rack_fx::RACK_MODE_U_SCAN_SELECTED
                ) {
                  uint32_t step_ms = uint32_t(id(rack_u_scan_seconds).state * 1000.0f);
                  if (step_ms < 150) {
                    step_ms = 150;
                  }
                  const uint32_t elapsed = millis() - start_ms;
                  const uint32_t step_index = elapsed / step_ms;
                  float max_brightness = id(breathing_max_percent).state / 100.0f;
                  max_brightness = rack_fx::clamp01(max_brightness);
                  const float level = max_brightness * rack_fx::scan_step_fade(elapsed, step_ms);
                  const int u = rack_fx::ping_pong_u(step_index);
                  float scan_red = level * 255.0f;
                  float scan_green = 0.0f;
                  float scan_blue = 0.0f;
                  if (id(saved_internal_mode) == rack_fx::RACK_MODE_U_SCAN_SELECTED) {
                    scan_red = red * level;
                    scan_green = green * level;
                    scan_blue = blue * level;
                  }
                  const std::string zone_mode = "Selected U";
                  const float progress = rack_fx::transition_progress(start_ms, 900.0f);
                  rack_fx::render_transition_to_zone_dithered_rgbw(
                    it,
                    transition_start,
                    zone_mode,
                    u,
                    u,
                    0,
                    0,
                    ${rack_left_start},
                    ${rack_side_led_count},
                    0,
                    0,
                    ${rack_right_start},
                    scan_red,
                    scan_green,
                    scan_blue,
                    0.0f,
                    progress
                  );
                  return;
                }
              }

              if (saved_effect == id(rack_assistant).get_effect_index("White breathing")) {
                red = 0.0f;
                green = 0.0f;
                blue = 0.0f;
                white = min_brightness;
              } else if (saved_effect == id(rack_assistant).get_effect_index("Selected color breathing")) {
                red *= min_brightness;
                green *= min_brightness;
                blue *= min_brightness;
                white = 0.0f;
              } else if (saved_effect == id(rack_assistant).get_effect_index("Blue breathing")) {
                red = 0.0f;
                green = min_brightness * (111.0f / 255.0f);
                blue = min_brightness;
                white = 0.0f;
              } else if (saved_effect == id(rack_assistant).get_effect_index("Orange breathing")) {
                red = min_brightness;
                green = min_brightness * (82.0f / 255.0f);
                blue = 0.0f;
                white = 0.0f;
              } else if (
                saved_effect == id(rack_assistant).get_effect_index("Red breathing") ||
                saved_effect == id(rack_assistant).get_effect_index("Internet down")
              ) {
                red = min_brightness;
                green = 0.0f;
                blue = 0.0f;
                white = 0.0f;
              }

              rack_fx::separate_rgbw_unit(red, green, blue, white);
              const esphome::Color target = rack_fx::rgbw_color(red, green, blue, white);
              const float progress = rack_fx::transition_progress(start_ms, 900.0f);
              rack_fx::render_transition(it, transition_start, target, progress);
              return;
            }

            float red = current_color.r;
            float green = current_color.g;
            float blue = current_color.b;
            float white = current_color.w;
            rack_fx::separate_rgbw_channels(red, green, blue, white);
            rack_fx::render_zone_dithered_rgbw(
              it,
              id(active_zone_mode),
              id(active_u_start),
              id(active_u_end),
              ${rack_bottom_start},
              ${rack_bottom_led_count},
              ${rack_left_start},
              ${rack_side_led_count},
              ${rack_top_start},
              ${rack_top_led_count},
              ${rack_right_start},
              red,
              green,
              blue,
              white
            );

      - addressable_lambda:
          name: "Red U scan"
          update_interval: 16ms
          lambda: |-
            static uint32_t start_ms = 0;
            if (initial_run) {
              start_ms = millis();
            }
            uint32_t step_ms = uint32_t(id(rack_u_scan_seconds).state * 1000.0f);
            if (step_ms < 150) {
              step_ms = 150;
            }
            const uint32_t elapsed = millis() - start_ms;
            const uint32_t step_index = elapsed / step_ms;
            float max_brightness = id(breathing_max_percent).state / 100.0f;
            max_brightness = rack_fx::clamp01(max_brightness);
            const float level = max_brightness * rack_fx::scan_step_fade(elapsed, step_ms);
            const int u = rack_fx::ping_pong_u(step_index);
            rack_fx::render_u_dithered_rgbw(
              it,
              u,
              ${rack_left_start},
              ${rack_side_led_count},
              ${rack_right_start},
              level * 255.0f,
              0.0f,
              0.0f,
              0.0f
            );

      - addressable_lambda:
          name: "Selected color U scan"
          update_interval: 16ms
          lambda: |-
            static uint32_t start_ms = 0;
            if (initial_run) {
              start_ms = millis();
            }
            uint32_t step_ms = uint32_t(id(rack_u_scan_seconds).state * 1000.0f);
            if (step_ms < 150) {
              step_ms = 150;
            }
            const uint32_t elapsed = millis() - start_ms;
            const uint32_t step_index = elapsed / step_ms;
            float max_brightness = id(breathing_max_percent).state / 100.0f;
            max_brightness = rack_fx::clamp01(max_brightness);
            const float level = max_brightness * rack_fx::scan_step_fade(elapsed, step_ms);
            const int u = rack_fx::ping_pong_u(step_index);
            rack_fx::render_u_dithered_rgbw(
              it,
              u,
              ${rack_left_start},
              ${rack_side_led_count},
              ${rack_right_start},
              current_color.r * level,
              current_color.g * level,
              current_color.b * level,
              0.0f
            );

      - addressable_color_wipe:
          name: "White wipe"
          add_led_interval: 30ms
          colors:
            - red: 0%
              green: 0%
              blue: 0%
              white: 100%
              num_leds: 1

      - addressable_color_wipe:
          name: "Red wipe"
          add_led_interval: 30ms
          colors:
            - red: 100%
              green: 0%
              blue: 0%
              white: 0%
              num_leds: 1

      - addressable_scan:
          name: "White scan"
          move_interval: 25ms
          scan_width: 4

      - addressable_rainbow:
          name: "Rainbow"
          speed: 10
          width: 50