substitutions:
  # --- Device identity ---
  device_name: gaugecontroller
  device_friendly_name: Selsyn Multi
  device_area: Control Panels

  # --- WiFi ---
  wifi_ssid: !secret wifi_ssid
  wifi_password: !secret wifi_password

  # --- Arduino UART bridge ---
  arduino_tx_pin: GPIO4
  arduino_rx_pin: GPIO5
  arduino_baud: "38400"

  # --- Gauge 1 ---
  gauge0_name: Selsyn 1
  gauge0_entity_name: Selsyn 1 Power
  gauge0_min: "0.0"
  gauge0_max: "7612.0"
  gauge0_max_steps: "3780"
  gauge0_unit: W
  gauge0_step: "1.0"
  gauge0_speed_step: "1"
  gauge0_accel_step: "1"
  gauge0_default_speed: "5000"
  gauge0_default_accel: "6000"

  # --- Gauge 2 ---
  gauge1_name: Selsyn 2
  gauge1_entity_name: Selsyn 2 Temperature
  gauge1_min: "0.0"
  gauge1_max: "76.0"
  gauge1_max_steps: "3780"
  gauge1_unit: Deg
  gauge1_step: "1.0"
  gauge1_speed_step: "100"
  gauge1_accel_step: "100"
  gauge1_default_speed: "5000"
  gauge1_default_accel: "6000"

  # --- Gauge 3 ---
  gauge2_name: Selsyn 3
  gauge2_entity_name: Selsyn 3 Power
  gauge2_min: "0.0"
  gauge2_max: "7612.0"
  gauge2_max_steps: "3780"
  gauge2_unit: W
  gauge2_step: "1.0"
  gauge2_speed_step: "100"
  gauge2_accel_step: "100"
  gauge2_default_speed: "5000"
  gauge2_default_accel: "6000"

  # --- Gauge 4 ---
  gauge3_name: Selsyn 4
  gauge3_entity_name: Selsyn 4 Power
  gauge3_min: "0.0"
  gauge3_max: "7612.0"
  gauge3_max_steps: "3780"
  gauge3_unit: W
  gauge3_step: "1.0"
  gauge3_speed_step: "100"
  gauge3_accel_step: "100"
  gauge3_default_speed: "5000"
  gauge3_default_accel: "6000"

  # --- Timing ---
  rezero_interval: 3600s

# ---------------------------------------------------------------------------
# Core ESPHome identity
# ---------------------------------------------------------------------------

esphome:
  name: ${device_name}
  friendly_name: ${device_friendly_name}
  on_boot:
    priority: -100
    then:
      - delay: 2s
      - uart.write:
          id: arduino_uart
          data: "HOMEALL\n"
      - logger.log: "Boot: HOMEALL sent to Arduino"
      - delay: 15s
      - uart.write:
          id: arduino_uart
          data: "POS?\n"
      - logger.log: "Boot: POS? sent to Arduino"
      - uart.write:
          id: arduino_uart
          data: "CFG?\n"
      - logger.log: "Boot: CFG? sent to Arduino"

esp32:
  board: esp32-c3-devkitm-1
  variant: ESP32C3
  framework:
    type: esp-idf
    version: recommended

# ---------------------------------------------------------------------------
# Logging  (set level: NONE in production)
# ---------------------------------------------------------------------------

logger:
  level: DEBUG

# ---------------------------------------------------------------------------
# Native HA API — handles all entity registration, state sync, and commands.
# No manual discovery payloads needed.
# ---------------------------------------------------------------------------

api:

# ---------------------------------------------------------------------------
# OTA — replaces ota.py / Gitea updater; managed from HA or esphome CLI
# ---------------------------------------------------------------------------

ota:
  - platform: esphome

# ---------------------------------------------------------------------------
# WiFi — replaces connect_wifi() + check_wifi() + all reconnect logic
# ---------------------------------------------------------------------------

wifi:
  ssid: ${wifi_ssid}
  password: ${wifi_password}
  output_power: 15
  ap:
    ssid: "${device_name} Fallback"
    password: !secret fallbackpassword

captive_portal:
  
# ---------------------------------------------------------------------------
# Arduino UART bridge
# ---------------------------------------------------------------------------

uart:
  id: arduino_uart
  tx_pin: ${arduino_tx_pin}
  rx_pin: ${arduino_rx_pin}
  baud_rate: ${arduino_baud}
  # Uncomment to log raw Arduino traffic:
  # debug:
  #   direction: BOTH

# ---------------------------------------------------------------------------
# Connectivity diagnostics
# ---------------------------------------------------------------------------

sensor:
  - platform: wifi_signal
    name: WiFi Signal
    update_interval: 60s
    entity_category: diagnostic

  - platform: uptime
    name: Uptime
    entity_category: diagnostic

  - platform: template
    name: "${gauge0_name} Target"
    lambda: |-
      return id(gauge0_target_value);
    unit_of_measurement: "${gauge0_unit}"
    accuracy_decimals: 1
    update_interval: 5s

  - platform: template
    name: "${gauge1_name} Target"
    lambda: |-
      return id(gauge1_target_value);
    unit_of_measurement: "${gauge1_unit}"
    accuracy_decimals: 1
    update_interval: 5s

  - platform: template
    name: "${gauge2_name} Target"
    lambda: |-
      return id(gauge2_target_value);
    unit_of_measurement: "${gauge2_unit}"
    accuracy_decimals: 1
    update_interval: 5s

  - platform: template
    name: "${gauge3_name} Target"
    lambda: |-
      return id(gauge3_target_value);
    unit_of_measurement: "${gauge3_unit}"
    accuracy_decimals: 1
    update_interval: 5s

    entity_category: diagnostic

text_sensor:
  - platform: wifi_info
    ip_address:
      name: IP Address
      entity_category: diagnostic
    ssid:
      name: SSID
      entity_category: diagnostic

  - platform: template
    id: arduino_last_message
    name: Arduino Last Message
    entity_category: diagnostic

# ---------------------------------------------------------------------------
# Gauge target numbers
# ---------------------------------------------------------------------------

number:
  - platform: template
    id: gauge0_target_number
    name: "${gauge0_entity_name}"
    unit_of_measurement: "${gauge0_unit}"
    min_value: ${gauge0_min}
    max_value: ${gauge0_max}
    step: ${gauge0_step}
    mode: slider
    optimistic: true
    restore_value: false
    initial_value: ${gauge0_min}
    set_action:
      - lambda: |-
          const float min_value = ${gauge0_min};
          const float max_value = ${gauge0_max};
          const int max_steps = ${gauge0_max_steps};
          const float clamped = std::max(min_value, std::min(max_value, x));
          int steps = 0;
          if (max_value > min_value) {
            const float fraction = (clamped - min_value) / (max_value - min_value);
            steps = static_cast<int>(lroundf(fraction * max_steps));
          }
          id(gauge0_target_value) = clamped;
          char cmd[24];
          snprintf(cmd, sizeof(cmd), "SET 0 %d\n", steps);
          ESP_LOGI("uart_tx", "TX: %s", cmd);
          id(arduino_uart).write_str(cmd);

  - platform: template
    id: gauge1_target_number
    name: "${gauge1_entity_name}"
    unit_of_measurement: "${gauge1_unit}"
    min_value: ${gauge1_min}
    max_value: ${gauge1_max}
    step: ${gauge1_step}
    mode: slider
    optimistic: true
    restore_value: false
    initial_value: ${gauge1_min}
    set_action:
      - lambda: |-
          const float min_value = ${gauge1_min};
          const float max_value = ${gauge1_max};
          const int max_steps = ${gauge1_max_steps};
          const float clamped = std::max(min_value, std::min(max_value, x));
          int steps = 0;
          if (max_value > min_value) {
            const float fraction = (clamped - min_value) / (max_value - min_value);
            steps = static_cast<int>(lroundf(fraction * max_steps));
          }
          id(gauge1_target_value) = clamped;
          char cmd[24];
          snprintf(cmd, sizeof(cmd), "SET 1 %d\n", steps);
          ESP_LOGI("uart_tx", "TX: %s", cmd);
          id(arduino_uart).write_str(cmd);

  - platform: template
    id: gauge2_target_number
    name: "${gauge2_entity_name}"
    unit_of_measurement: "${gauge2_unit}"
    min_value: ${gauge2_min}
    max_value: ${gauge2_max}
    step: ${gauge2_step}
    mode: slider
    optimistic: true
    restore_value: false
    initial_value: ${gauge2_min}
    set_action:
      - lambda: |-
          const float min_value = ${gauge2_min};
          const float max_value = ${gauge2_max};
          const int max_steps = ${gauge2_max_steps};
          const float clamped = std::max(min_value, std::min(max_value, x));
          int steps = 0;
          if (max_value > min_value) {
            const float fraction = (clamped - min_value) / (max_value - min_value);
            steps = static_cast<int>(lroundf(fraction * max_steps));
          }
          id(gauge2_target_value) = clamped;
          char cmd[24];
          snprintf(cmd, sizeof(cmd), "SET 2 %d\n", steps);
          ESP_LOGI("uart_tx", "TX: %s", cmd);
          id(arduino_uart).write_str(cmd);

  - platform: template
    id: gauge3_target_number
    name: "${gauge3_entity_name}"
    unit_of_measurement: "${gauge3_unit}"
    min_value: ${gauge3_min}
    max_value: ${gauge3_max}
    step: ${gauge3_step}
    mode: slider
    optimistic: true
    restore_value: false
    initial_value: ${gauge3_min}
    set_action:
      - lambda: |-
          const float min_value = ${gauge3_min};
          const float max_value = ${gauge3_max};
          const int max_steps = ${gauge3_max_steps};
          const float clamped = std::max(min_value, std::min(max_value, x));
          int steps = 0;
          if (max_value > min_value) {
            const float fraction = (clamped - min_value) / (max_value - min_value);
            steps = static_cast<int>(lroundf(fraction * max_steps));
          }
          id(gauge3_target_value) = clamped;
          char cmd[24];
          snprintf(cmd, sizeof(cmd), "SET 3 %d\n", steps);
          ESP_LOGI("uart_tx", "TX: %s", cmd);
          id(arduino_uart).write_str(cmd);

  - platform: template
    id: gauge0_speed_number
    name: "${gauge0_name} Speed"
    entity_category: diagnostic
    unit_of_measurement: "steps/s"
    min_value: 1
    max_value: 20000
    step: ${gauge0_speed_step}
    mode: box
    optimistic: true
    restore_value: false
    initial_value: ${gauge0_default_speed}
    set_action:
      - lambda: |-
          const int clamped = std::max(1, static_cast<int>(lroundf(x)));
          id(gauge0_speed_value) = clamped;
          char cmd[24];
          snprintf(cmd, sizeof(cmd), "SPEED 0 %d\n", clamped);
          ESP_LOGI("uart_tx", "TX: %s", cmd);
          id(arduino_uart).write_str(cmd);

  - platform: template
    id: gauge0_accel_number
    name: "${gauge0_name} Acceleration"
    entity_category: diagnostic
    unit_of_measurement: "steps/s^2"
    min_value: 1
    max_value: 50000
    step: ${gauge0_accel_step}
    mode: box
    optimistic: true
    restore_value: false
    initial_value: ${gauge0_default_accel}
    set_action:
      - lambda: |-
          const int clamped = std::max(1, static_cast<int>(lroundf(x)));
          id(gauge0_accel_value) = clamped;
          char cmd[24];
          snprintf(cmd, sizeof(cmd), "ACCEL 0 %d\n", clamped);
          ESP_LOGI("uart_tx", "TX: %s", cmd);
          id(arduino_uart).write_str(cmd);

  - platform: template
    id: gauge1_speed_number
    name: "${gauge1_name} Speed"
    entity_category: diagnostic
    unit_of_measurement: "steps/s"
    min_value: 1
    max_value: 20000
    step: ${gauge1_speed_step}
    mode: box
    optimistic: true
    restore_value: false
    initial_value: ${gauge1_default_speed}
    set_action:
      - lambda: |-
          const int clamped = std::max(1, static_cast<int>(lroundf(x)));
          id(gauge1_speed_value) = clamped;
          char cmd[24];
          snprintf(cmd, sizeof(cmd), "SPEED 1 %d\n", clamped);
          ESP_LOGI("uart_tx", "TX: %s", cmd);
          id(arduino_uart).write_str(cmd);

  - platform: template
    id: gauge1_accel_number
    name: "${gauge1_name} Acceleration"
    entity_category: diagnostic
    unit_of_measurement: "steps/s^2"
    min_value: 1
    max_value: 50000
    step: ${gauge1_accel_step}
    mode: box
    optimistic: true
    restore_value: false
    initial_value: ${gauge1_default_accel}
    set_action:
      - lambda: |-
          const int clamped = std::max(1, static_cast<int>(lroundf(x)));
          id(gauge1_accel_value) = clamped;
          char cmd[24];
          snprintf(cmd, sizeof(cmd), "ACCEL 1 %d\n", clamped);
          ESP_LOGI("uart_tx", "TX: %s", cmd);
          id(arduino_uart).write_str(cmd);

  - platform: template
    id: gauge2_speed_number
    name: "${gauge2_name} Speed"
    entity_category: diagnostic
    unit_of_measurement: "steps/s"
    min_value: 1
    max_value: 20000
    step: ${gauge2_speed_step}
    mode: box
    optimistic: true
    restore_value: false
    initial_value: ${gauge2_default_speed}
    set_action:
      - lambda: |-
          const int clamped = std::max(1, static_cast<int>(lroundf(x)));
          id(gauge2_speed_value) = clamped;
          char cmd[24];
          snprintf(cmd, sizeof(cmd), "SPEED 2 %d\n", clamped);
          ESP_LOGI("uart_tx", "TX: %s", cmd);
          id(arduino_uart).write_str(cmd);

  - platform: template
    id: gauge2_accel_number
    name: "${gauge2_name} Acceleration"
    entity_category: diagnostic
    unit_of_measurement: "steps/s^2"
    min_value: 1
    max_value: 50000
    step: ${gauge2_accel_step}
    mode: box
    optimistic: true
    restore_value: false
    initial_value: ${gauge2_default_accel}
    set_action:
      - lambda: |-
          const int clamped = std::max(1, static_cast<int>(lroundf(x)));
          id(gauge2_accel_value) = clamped;
          char cmd[24];
          snprintf(cmd, sizeof(cmd), "ACCEL 2 %d\n", clamped);
          ESP_LOGI("uart_tx", "TX: %s", cmd);
          id(arduino_uart).write_str(cmd);

  - platform: template
    id: gauge3_speed_number
    name: "${gauge3_name} Speed"
    entity_category: diagnostic
    unit_of_measurement: "steps/s"
    min_value: 1
    max_value: 20000
    step: ${gauge3_speed_step}
    mode: box
    optimistic: true
    restore_value: false
    initial_value: ${gauge3_default_speed}
    set_action:
      - lambda: |-
          const int clamped = std::max(1, static_cast<int>(lroundf(x)));
          id(gauge3_speed_value) = clamped;
          char cmd[24];
          snprintf(cmd, sizeof(cmd), "SPEED 3 %d\n", clamped);
          ESP_LOGI("uart_tx", "TX: %s", cmd);
          id(arduino_uart).write_str(cmd);

  - platform: template
    id: gauge3_accel_number
    name: "${gauge3_name} Acceleration"
    entity_category: diagnostic
    unit_of_measurement: "steps/s^2"
    min_value: 1
    max_value: 50000
    step: ${gauge3_accel_step}
    mode: box
    optimistic: true
    restore_value: false
    initial_value: ${gauge3_default_accel}
    set_action:
      - lambda: |-
          const int clamped = std::max(1, static_cast<int>(lroundf(x)));
          id(gauge3_accel_value) = clamped;
          char cmd[24];
          snprintf(cmd, sizeof(cmd), "ACCEL 3 %d\n", clamped);
          ESP_LOGI("uart_tx", "TX: %s", cmd);
          id(arduino_uart).write_str(cmd);

# ---------------------------------------------------------------------------
# VFD controls
# ---------------------------------------------------------------------------

text:
  - platform: template
    id: vfd_display
    name: VFD Display
    mode: text
    optimistic: true
    restore_value: false
    min_length: 0
    max_length: 4
    initial_value: ""
    set_action:
      - lambda: |-
          std::string sanitized;
          sanitized.reserve(4);
          for (char c : x) {
            const char uc = static_cast<char>(toupper(static_cast<unsigned char>(c)));
            if ((uc >= '0' && uc <= '9') || (uc >= 'A' && uc <= 'F') || uc == '-') {
              sanitized.push_back(uc);
              if (sanitized.size() >= 4) {
                break;
              }
            }
          }

          id(vfd_text_value) = sanitized;

          std::string cmd = "VFD";
          std::string suffix;
          if (id(vfd_decimal_point_on)) {
            suffix += ".";
          }
          if (id(vfd_alarm_on)) {
            suffix += "!";
          }

          if (!sanitized.empty()) {
            cmd += " " + sanitized + suffix;
          } else if (!suffix.empty()) {
            cmd += " 0" + suffix;
          }
          cmd += "\n";
          ESP_LOGI("uart_tx", "TX: %s", cmd.c_str());
          id(arduino_uart).write_str(cmd.c_str());

switch:
  - platform: template
    id: vfd_decimal_point
    name: VFD Decimal Point
    optimistic: true
    restore_mode: ALWAYS_OFF
    lambda: |-
      return id(vfd_decimal_point_on);
    turn_on_action:
      - lambda: |-
          id(vfd_decimal_point_on) = true;
          std::string cmd = "VFD";
          std::string suffix = ".";
          if (id(vfd_alarm_on)) {
            suffix += "!";
          }
          if (!id(vfd_text_value).empty()) {
            cmd += " " + id(vfd_text_value) + suffix;
          } else {
            cmd += " 0" + suffix;
          }
          cmd += "\n";
          ESP_LOGI("uart_tx", "TX: %s", cmd.c_str());
          id(arduino_uart).write_str(cmd.c_str());
    turn_off_action:
      - lambda: |-
          id(vfd_decimal_point_on) = false;
          std::string cmd = "VFD";
          std::string suffix;
          if (id(vfd_alarm_on)) {
            suffix += "!";
          }
          if (!id(vfd_text_value).empty()) {
            cmd += " " + id(vfd_text_value) + suffix;
          } else if (!suffix.empty()) {
            cmd += " 0" + suffix;
          }
          cmd += "\n";
          ESP_LOGI("uart_tx", "TX: %s", cmd.c_str());
          id(arduino_uart).write_str(cmd.c_str());

  - platform: template
    id: vfd_alarm
    name: VFD Alarm
    optimistic: true
    restore_mode: ALWAYS_OFF
    lambda: |-
      return id(vfd_alarm_on);
    turn_on_action:
      - lambda: |-
          id(vfd_alarm_on) = true;
          std::string cmd = "VFD";
          std::string suffix;
          if (id(vfd_decimal_point_on)) {
            suffix += ".";
          }
          suffix += "!";
          if (!id(vfd_text_value).empty()) {
            cmd += " " + id(vfd_text_value) + suffix;
          } else {
            cmd += " 0" + suffix;
          }
          cmd += "\n";
          ESP_LOGI("uart_tx", "TX: %s", cmd.c_str());
          id(arduino_uart).write_str(cmd.c_str());
    turn_off_action:
      - lambda: |-
          id(vfd_alarm_on) = false;
          std::string cmd = "VFD";
          std::string suffix;
          if (id(vfd_decimal_point_on)) {
            suffix += ".";
          }
          if (!id(vfd_text_value).empty()) {
            cmd += " " + id(vfd_text_value) + suffix;
          } else if (!suffix.empty()) {
            cmd += " 0" + suffix;
          }
          cmd += "\n";
          ESP_LOGI("uart_tx", "TX: %s", cmd.c_str());
          id(arduino_uart).write_str(cmd.c_str());

# ---------------------------------------------------------------------------
# Gauge homing buttons
# ---------------------------------------------------------------------------

button:
  - platform: template
    name: "${gauge0_name} Rezero"
    entity_category: diagnostic
    on_press:
      - uart.write:
          id: arduino_uart
          data: "HOME 0\n"

  - platform: template
    name: "${gauge1_name} Rezero"
    entity_category: diagnostic
    on_press:
      - uart.write:
          id: arduino_uart
          data: "HOME 1\n"

  - platform: template
    name: "${gauge2_name} Rezero"
    entity_category: diagnostic
    on_press:
      - uart.write:
          id: arduino_uart
          data: "HOME 2\n"

  - platform: template
    name: "${gauge3_name} Rezero"
    entity_category: diagnostic
    on_press:
      - uart.write:
          id: arduino_uart
          data: "HOME 3\n"

  - platform: template
    name: Rezero All Gauges
    entity_category: diagnostic
    on_press:
      - uart.write:
          id: arduino_uart
          data: "HOMEALL\n"

# ---------------------------------------------------------------------------
# Periodic auto-rezero
# ---------------------------------------------------------------------------

interval:
  - interval: 10ms
    then:
      - lambda: |-
          while (id(arduino_uart).available()) {
            uint8_t b;
            id(arduino_uart).read_byte(&b);
            if (b == '\n') {
              std::string &buf = id(uart_rx_buf);
              if (!buf.empty() && buf.back() == '\r') buf.pop_back();
              if (!buf.empty()) ESP_LOGI("uart_rx", "RX: %s", buf.c_str());
              if (!buf.empty() && buf != "OK" && buf != "PONG") {
                if (buf.rfind("POS ", 0) == 0) {
                  int gid, cur, tgt, homed, hstate, sweep;
                  if (sscanf(buf.c_str(), "POS %d %d %d %d %d %d",
                             &gid, &cur, &tgt, &homed, &hstate, &sweep) == 6) {
                    float value = 0.0f;
                    if (gid == 0) {
                      value = ${gauge0_min} + (tgt / (float)${gauge0_max_steps}) * (${gauge0_max} - ${gauge0_min});
                      id(gauge0_target_value) = value;
                      id(gauge0_target_number).publish_state(value);
                    } else if (gid == 1) {
                      value = ${gauge1_min} + (tgt / (float)${gauge1_max_steps}) * (${gauge1_max} - ${gauge1_min});
                      id(gauge1_target_value) = value;
                      id(gauge1_target_number).publish_state(value);
                    } else if (gid == 2) {
                      value = ${gauge2_min} + (tgt / (float)${gauge2_max_steps}) * (${gauge2_max} - ${gauge2_min});
                      id(gauge2_target_value) = value;
                      id(gauge2_target_number).publish_state(value);
                    } else if (gid == 3) {
                      value = ${gauge3_min} + (tgt / (float)${gauge3_max_steps}) * (${gauge3_max} - ${gauge3_min});
                      id(gauge3_target_value) = value;
                      id(gauge3_target_number).publish_state(value);
                    }
                  }
                } else if (buf.rfind("CFG ", 0) == 0) {
                  int gid, spd, acc;
                  if (sscanf(buf.c_str(), "CFG %d %d %d", &gid, &spd, &acc) == 3) {
                    if (gid == 0) {
                      id(gauge0_speed_value) = spd;
                      id(gauge0_accel_value) = acc;
                      id(gauge0_speed_number).publish_state(spd);
                      id(gauge0_accel_number).publish_state(acc);
                    } else if (gid == 1) {
                      id(gauge1_speed_value) = spd;
                      id(gauge1_accel_value) = acc;
                      id(gauge1_speed_number).publish_state(spd);
                      id(gauge1_accel_number).publish_state(acc);
                    } else if (gid == 2) {
                      id(gauge2_speed_value) = spd;
                      id(gauge2_accel_value) = acc;
                      id(gauge2_speed_number).publish_state(spd);
                      id(gauge2_accel_number).publish_state(acc);
                    } else if (gid == 3) {
                      id(gauge3_speed_value) = spd;
                      id(gauge3_accel_value) = acc;
                      id(gauge3_speed_number).publish_state(spd);
                      id(gauge3_accel_number).publish_state(acc);
                    }
                  }
                } else {
                  id(arduino_last_message).publish_state(buf);
                }
              }
              buf.clear();
            } else if (id(uart_rx_buf).size() < 128) {
              id(uart_rx_buf) += static_cast<char>(b);
            }
          }
  - interval: 30s
    then:
      - uart.write:
          id: arduino_uart
          data: "POS?\n"
      - uart.write:
          id: arduino_uart
          data: "CFG?\n"
  - interval: ${rezero_interval}
    then:
      - uart.write:
          id: arduino_uart
          data: "HOMEALL\n"

# ---------------------------------------------------------------------------
# Gauge light state cache
# ---------------------------------------------------------------------------

globals:
  - id: uart_rx_buf
    type: std::string
    restore_value: no
    initial_value: '""'
  - id: vfd_text_value
    type: std::string
    restore_value: no
    initial_value: '""'
  - id: vfd_decimal_point_on
    type: bool
    restore_value: no
    initial_value: "false"
  - id: vfd_alarm_on
    type: bool
    restore_value: no
    initial_value: "false"
  - id: gauge0_target_value
    type: float
    restore_value: no
    initial_value: ${gauge0_min}
  - id: gauge1_target_value
    type: float
    restore_value: no
    initial_value: ${gauge1_min}
  - id: gauge2_target_value
    type: float
    restore_value: no
    initial_value: ${gauge2_min}
  - id: gauge3_target_value
    type: float
    restore_value: no
    initial_value: ${gauge3_min}
  - id: gauge0_speed_value
    type: int
    restore_value: no
    initial_value: ${gauge0_default_speed}
  - id: gauge0_accel_value
    type: int
    restore_value: no
    initial_value: ${gauge0_default_accel}
  - id: gauge1_speed_value
    type: int
    restore_value: no
    initial_value: ${gauge1_default_speed}
  - id: gauge1_accel_value
    type: int
    restore_value: no
    initial_value: ${gauge1_default_accel}
  - id: gauge2_speed_value
    type: int
    restore_value: no
    initial_value: ${gauge2_default_speed}
  - id: gauge2_accel_value
    type: int
    restore_value: no
    initial_value: ${gauge2_default_accel}
  - id: gauge3_speed_value
    type: int
    restore_value: no
    initial_value: ${gauge3_default_speed}
  - id: gauge3_accel_value
    type: int
    restore_value: no
    initial_value: ${gauge3_default_accel}
  - id: gauge0_bl_r
    type: int
    restore_value: no
    initial_value: "0"
  - id: gauge0_bl_g
    type: int
    restore_value: no
    initial_value: "0"
  - id: gauge0_bl_b
    type: int
    restore_value: no
    initial_value: "0"
  - id: gauge1_bl_r
    type: int
    restore_value: no
    initial_value: "0"
  - id: gauge1_bl_g
    type: int
    restore_value: no
    initial_value: "0"
  - id: gauge1_bl_b
    type: int
    restore_value: no
    initial_value: "0"
  - id: gauge2_bl_r
    type: int
    restore_value: no
    initial_value: "0"
  - id: gauge2_bl_g
    type: int
    restore_value: no
    initial_value: "0"
  - id: gauge2_bl_b
    type: int
    restore_value: no
    initial_value: "0"
  - id: gauge3_bl_r
    type: int
    restore_value: no
    initial_value: "0"
  - id: gauge3_bl_g
    type: int
    restore_value: no
    initial_value: "0"
  - id: gauge3_bl_b
    type: int
    restore_value: no
    initial_value: "0"
  - id: gauge0_red_on
    type: bool
    restore_value: no
    initial_value: "false"
  - id: gauge0_green_on
    type: bool
    restore_value: no
    initial_value: "false"
  - id: gauge0_status_red_on
    type: bool
    restore_value: no
    initial_value: "false"
  - id: gauge0_status_green_on
    type: bool
    restore_value: no
    initial_value: "false"
  - id: gauge1_red_on
    type: bool
    restore_value: no
    initial_value: "false"
  - id: gauge1_green_on
    type: bool
    restore_value: no
    initial_value: "false"
  - id: gauge1_status_red_on
    type: bool
    restore_value: no
    initial_value: "false"
  - id: gauge1_status_green_on
    type: bool
    restore_value: no
    initial_value: "false"
  - id: gauge2_red_on
    type: bool
    restore_value: no
    initial_value: "false"
  - id: gauge2_green_on
    type: bool
    restore_value: no
    initial_value: "false"
  - id: gauge2_status_red_on
    type: bool
    restore_value: no
    initial_value: "false"
  - id: gauge2_status_green_on
    type: bool
    restore_value: no
    initial_value: "false"
  - id: gauge3_red_on
    type: bool
    restore_value: no
    initial_value: "false"
  - id: gauge3_green_on
    type: bool
    restore_value: no
    initial_value: "false"
  - id: gauge3_status_red_on
    type: bool
    restore_value: no
    initial_value: "false"
  - id: gauge3_status_green_on
    type: bool
    restore_value: no
    initial_value: "false"

# ---------------------------------------------------------------------------
# Light outputs
# ---------------------------------------------------------------------------

output:
  - platform: template
    id: gauge0_backlight_red_output
    type: float
    write_action:
      - lambda: |-
          id(gauge0_bl_r) = static_cast<int>(state * 255.0f + 0.5f);

  - platform: template
    id: gauge0_backlight_green_output
    type: float
    write_action:
      - lambda: |-
          id(gauge0_bl_g) = static_cast<int>(state * 255.0f + 0.5f);

  - platform: template
    id: gauge0_backlight_blue_output
    type: float
    write_action:
      - lambda: |-
          id(gauge0_bl_b) = static_cast<int>(state * 255.0f + 0.5f);

  - platform: template
    id: gauge1_backlight_red_output
    type: float
    write_action:
      - lambda: |-
          id(gauge1_bl_r) = static_cast<int>(state * 255.0f + 0.5f);

  - platform: template
    id: gauge1_backlight_green_output
    type: float
    write_action:
      - lambda: |-
          id(gauge1_bl_g) = static_cast<int>(state * 255.0f + 0.5f);

  - platform: template
    id: gauge1_backlight_blue_output
    type: float
    write_action:
      - lambda: |-
          id(gauge1_bl_b) = static_cast<int>(state * 255.0f + 0.5f);

  - platform: template
    id: gauge2_backlight_red_output
    type: float
    write_action:
      - lambda: |-
          id(gauge2_bl_r) = static_cast<int>(state * 255.0f + 0.5f);

  - platform: template
    id: gauge2_backlight_green_output
    type: float
    write_action:
      - lambda: |-
          id(gauge2_bl_g) = static_cast<int>(state * 255.0f + 0.5f);

  - platform: template
    id: gauge2_backlight_blue_output
    type: float
    write_action:
      - lambda: |-
          id(gauge2_bl_b) = static_cast<int>(state * 255.0f + 0.5f);

  - platform: template
    id: gauge3_backlight_red_output
    type: float
    write_action:
      - lambda: |-
          id(gauge3_bl_r) = static_cast<int>(state * 255.0f + 0.5f);

  - platform: template
    id: gauge3_backlight_green_output
    type: float
    write_action:
      - lambda: |-
          id(gauge3_bl_g) = static_cast<int>(state * 255.0f + 0.5f);

  - platform: template
    id: gauge3_backlight_blue_output
    type: float
    write_action:
      - lambda: |-
          id(gauge3_bl_b) = static_cast<int>(state * 255.0f + 0.5f);

  - platform: template
    id: gauge0_red_indicator_output
    type: binary
    write_action:
      - lambda: |-
          id(gauge0_red_on) = state;

  - platform: template
    id: gauge0_green_indicator_output
    type: binary
    write_action:
      - lambda: |-
          id(gauge0_green_on) = state;

  - platform: template
    id: gauge0_status_red_output
    type: binary
    write_action:
      - lambda: |-
          id(gauge0_status_red_on) = state;

  - platform: template
    id: gauge0_status_green_output
    type: binary
    write_action:
      - lambda: |-
          id(gauge0_status_green_on) = state;

  - platform: template
    id: gauge1_red_indicator_output
    type: binary
    write_action:
      - lambda: |-
          id(gauge1_red_on) = state;

  - platform: template
    id: gauge1_green_indicator_output
    type: binary
    write_action:
      - lambda: |-
          id(gauge1_green_on) = state;

  - platform: template
    id: gauge1_status_red_output
    type: binary
    write_action:
      - lambda: |-
          id(gauge1_status_red_on) = state;

  - platform: template
    id: gauge1_status_green_output
    type: binary
    write_action:
      - lambda: |-
          id(gauge1_status_green_on) = state;

  - platform: template
    id: gauge2_red_indicator_output
    type: binary
    write_action:
      - lambda: |-
          id(gauge2_red_on) = state;

  - platform: template
    id: gauge2_green_indicator_output
    type: binary
    write_action:
      - lambda: |-
          id(gauge2_green_on) = state;

  - platform: template
    id: gauge2_status_red_output
    type: binary
    write_action:
      - lambda: |-
          id(gauge2_status_red_on) = state;

  - platform: template
    id: gauge2_status_green_output
    type: binary
    write_action:
      - lambda: |-
          id(gauge2_status_green_on) = state;

  - platform: template
    id: gauge3_red_indicator_output
    type: binary
    write_action:
      - lambda: |-
          id(gauge3_red_on) = state;

  - platform: template
    id: gauge3_green_indicator_output
    type: binary
    write_action:
      - lambda: |-
          id(gauge3_green_on) = state;

  - platform: template
    id: gauge3_status_red_output
    type: binary
    write_action:
      - lambda: |-
          id(gauge3_status_red_on) = state;

  - platform: template
    id: gauge3_status_green_output
    type: binary
    write_action:
      - lambda: |-
          id(gauge3_status_green_on) = state;

# ---------------------------------------------------------------------------
# Native HA lights
# ---------------------------------------------------------------------------

light:
  - platform: rgb
    id: gauge0_backlight
    name: "${gauge0_name} Backlight"
    red: gauge0_backlight_red_output
    green: gauge0_backlight_green_output
    blue: gauge0_backlight_blue_output
    default_transition_length: 0s
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            char cmd[36];
            snprintf(cmd, sizeof(cmd), "BLINK 0 0-2 800 800 %d %d %d\n",
                     id(gauge0_bl_r), id(gauge0_bl_g), id(gauge0_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            char cmd[36];
            snprintf(cmd, sizeof(cmd), "BLINK 0 0-2 150 150 %d %d %d\n",
                     id(gauge0_bl_r), id(gauge0_bl_g), id(gauge0_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            char cmd[36];
            snprintf(cmd, sizeof(cmd), "BLINK 0 0-2 100 400 %d %d %d\n",
                     id(gauge0_bl_r), id(gauge0_bl_g), id(gauge0_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            char cmd[34];
            snprintf(cmd, sizeof(cmd), "BREATHE 0 0-2 3000 %d %d %d\n",
                     id(gauge0_bl_r), id(gauge0_bl_g), id(gauge0_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            char cmd[34];
            snprintf(cmd, sizeof(cmd), "BREATHE 0 0-2 1200 %d %d %d\n",
                     id(gauge0_bl_r), id(gauge0_bl_g), id(gauge0_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            char cmd[32];
            snprintf(cmd, sizeof(cmd), "DFLASH 0 0-2 %d %d %d\n",
                     id(gauge0_bl_r), id(gauge0_bl_g), id(gauge0_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
    on_state:
      - lambda: |-
          auto effect = id(gauge0_backlight).get_effect_name();
          if (effect != "None" && !effect.empty()) return;
          auto& rv = id(gauge0_backlight).remote_values;
          char cmd[32];
          snprintf(cmd, sizeof(cmd), "LED 0 0-2 %d %d %d\n",
                   rv.is_on() ? static_cast<int>(rv.get_red() * rv.get_brightness() * 255.0f + 0.5f) : 0,
                   rv.is_on() ? static_cast<int>(rv.get_green() * rv.get_brightness() * 255.0f + 0.5f) : 0,
                   rv.is_on() ? static_cast<int>(rv.get_blue() * rv.get_brightness() * 255.0f + 0.5f) : 0);
          ESP_LOGI("uart_tx", "TX: %s", cmd);
          id(arduino_uart).write_str(cmd);

  - platform: binary
    id: gauge0_red_indicator
    name: "${gauge0_name} Red Indicator"
    output: gauge0_red_indicator_output
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 0 3 800 800 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 0 3 150 150 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 0 3 100 400 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 0 3 3000 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 0 3 1200 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "DFLASH 0 3 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
    on_state:
      - lambda: |-
          if (!id(gauge0_red_indicator).remote_values.is_on()) {
            { const char* cmd = "LED 0 3 0 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
            return;
          }
          auto effect = id(gauge0_red_indicator).get_effect_name();
          if (effect == "Blink Slow") {
            { const char* cmd = "BLINK 0 3 800 800 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Fast") {
            { const char* cmd = "BLINK 0 3 150 150 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Alert") {
            { const char* cmd = "BLINK 0 3 100 400 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Slow") {
            { const char* cmd = "BREATHE 0 3 3000 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Fast") {
            { const char* cmd = "BREATHE 0 3 1200 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Double Flash") {
            { const char* cmd = "DFLASH 0 3 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else {
            { const char* cmd = "LED 0 3 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          }

  - platform: binary
    id: gauge0_green_indicator
    name: "${gauge0_name} Green Indicator"
    output: gauge0_green_indicator_output
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 0 4 800 800 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 0 4 150 150 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 0 4 100 400 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 0 4 3000 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 0 4 1200 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "DFLASH 0 4 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
    on_state:
      - lambda: |-
          if (!id(gauge0_green_indicator).remote_values.is_on()) {
            { const char* cmd = "LED 0 4 0 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
            return;
          }
          auto effect = id(gauge0_green_indicator).get_effect_name();
          if (effect == "Blink Slow") {
            { const char* cmd = "BLINK 0 4 800 800 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Fast") {
            { const char* cmd = "BLINK 0 4 150 150 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Alert") {
            { const char* cmd = "BLINK 0 4 100 400 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Slow") {
            { const char* cmd = "BREATHE 0 4 3000 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Fast") {
            { const char* cmd = "BREATHE 0 4 1200 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Double Flash") {
            { const char* cmd = "DFLASH 0 4 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else {
            { const char* cmd = "LED 0 4 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          }

  - platform: binary
    id: gauge0_status_red
    name: "${gauge0_name} Status Red"
    output: gauge0_status_red_output
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 0 5 800 800 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 0 5 150 150 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 0 5 100 400 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 0 5 3000 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 0 5 1200 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "DFLASH 0 5 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
    on_state:
      - lambda: |-
          if (!id(gauge0_status_red).remote_values.is_on()) {
            { const char* cmd = "LED 0 5 0 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
            return;
          }
          auto effect = id(gauge0_status_red).get_effect_name();
          if (effect == "Blink Slow") {
            { const char* cmd = "BLINK 0 5 800 800 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Fast") {
            { const char* cmd = "BLINK 0 5 150 150 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Alert") {
            { const char* cmd = "BLINK 0 5 100 400 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Slow") {
            { const char* cmd = "BREATHE 0 5 3000 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Fast") {
            { const char* cmd = "BREATHE 0 5 1200 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Double Flash") {
            { const char* cmd = "DFLASH 0 5 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else {
            { const char* cmd = "LED 0 5 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          }

  - platform: binary
    id: gauge0_status_green
    name: "${gauge0_name} Status Green"
    output: gauge0_status_green_output
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 0 6 800 800 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 0 6 150 150 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 0 6 100 400 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 0 6 3000 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 0 6 1200 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "DFLASH 0 6 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
    on_state:
      - lambda: |-
          if (!id(gauge0_status_green).remote_values.is_on()) {
            { const char* cmd = "LED 0 6 0 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
            return;
          }
          auto effect = id(gauge0_status_green).get_effect_name();
          if (effect == "Blink Slow") {
            { const char* cmd = "BLINK 0 6 800 800 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Fast") {
            { const char* cmd = "BLINK 0 6 150 150 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Alert") {
            { const char* cmd = "BLINK 0 6 100 400 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Slow") {
            { const char* cmd = "BREATHE 0 6 3000 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Fast") {
            { const char* cmd = "BREATHE 0 6 1200 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Double Flash") {
            { const char* cmd = "DFLASH 0 6 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else {
            { const char* cmd = "LED 0 6 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          }

  - platform: rgb
    id: gauge1_backlight
    name: "${gauge1_name} Backlight"
    red: gauge1_backlight_red_output
    green: gauge1_backlight_green_output
    blue: gauge1_backlight_blue_output
    default_transition_length: 0s
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            char cmd[36];
            snprintf(cmd, sizeof(cmd), "BLINK 1 0-2 800 800 %d %d %d\n",
                     id(gauge1_bl_r), id(gauge1_bl_g), id(gauge1_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            char cmd[36];
            snprintf(cmd, sizeof(cmd), "BLINK 1 0-2 150 150 %d %d %d\n",
                     id(gauge1_bl_r), id(gauge1_bl_g), id(gauge1_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            char cmd[36];
            snprintf(cmd, sizeof(cmd), "BLINK 1 0-2 100 400 %d %d %d\n",
                     id(gauge1_bl_r), id(gauge1_bl_g), id(gauge1_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            char cmd[34];
            snprintf(cmd, sizeof(cmd), "BREATHE 1 0-2 3000 %d %d %d\n",
                     id(gauge1_bl_r), id(gauge1_bl_g), id(gauge1_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            char cmd[34];
            snprintf(cmd, sizeof(cmd), "BREATHE 1 0-2 1200 %d %d %d\n",
                     id(gauge1_bl_r), id(gauge1_bl_g), id(gauge1_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            char cmd[32];
            snprintf(cmd, sizeof(cmd), "DFLASH 1 0-2 %d %d %d\n",
                     id(gauge1_bl_r), id(gauge1_bl_g), id(gauge1_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
    on_state:
      - lambda: |-
          auto effect = id(gauge1_backlight).get_effect_name();
          if (effect != "None" && !effect.empty()) return;
          auto& rv = id(gauge1_backlight).remote_values;
          char cmd[32];
          snprintf(cmd, sizeof(cmd), "LED 1 0-2 %d %d %d\n",
                   rv.is_on() ? static_cast<int>(rv.get_red() * rv.get_brightness() * 255.0f + 0.5f) : 0,
                   rv.is_on() ? static_cast<int>(rv.get_green() * rv.get_brightness() * 255.0f + 0.5f) : 0,
                   rv.is_on() ? static_cast<int>(rv.get_blue() * rv.get_brightness() * 255.0f + 0.5f) : 0);
          ESP_LOGI("uart_tx", "TX: %s", cmd);
          id(arduino_uart).write_str(cmd);

  - platform: binary
    id: gauge1_red_indicator
    name: "${gauge1_name} Red Indicator"
    output: gauge1_red_indicator_output
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 1 3 800 800 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 1 3 150 150 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 1 3 100 400 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 1 3 3000 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 1 3 1200 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "DFLASH 1 3 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
    on_state:
      - lambda: |-
          if (!id(gauge1_red_indicator).remote_values.is_on()) {
            { const char* cmd = "LED 1 3 0 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
            return;
          }
          auto effect = id(gauge1_red_indicator).get_effect_name();
          if (effect == "Blink Slow") {
            { const char* cmd = "BLINK 1 3 800 800 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Fast") {
            { const char* cmd = "BLINK 1 3 150 150 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Alert") {
            { const char* cmd = "BLINK 1 3 100 400 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Slow") {
            { const char* cmd = "BREATHE 1 3 3000 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Fast") {
            { const char* cmd = "BREATHE 1 3 1200 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Double Flash") {
            { const char* cmd = "DFLASH 1 3 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else {
            { const char* cmd = "LED 1 3 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          }

  - platform: binary
    id: gauge1_green_indicator
    name: "${gauge1_name} Green Indicator"
    output: gauge1_green_indicator_output
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 1 4 800 800 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 1 4 150 150 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 1 4 100 400 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 1 4 3000 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 1 4 1200 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "DFLASH 1 4 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
    on_state:
      - lambda: |-
          if (!id(gauge1_green_indicator).remote_values.is_on()) {
            { const char* cmd = "LED 1 4 0 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
            return;
          }
          auto effect = id(gauge1_green_indicator).get_effect_name();
          if (effect == "Blink Slow") {
            { const char* cmd = "BLINK 1 4 800 800 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Fast") {
            { const char* cmd = "BLINK 1 4 150 150 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Alert") {
            { const char* cmd = "BLINK 1 4 100 400 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Slow") {
            { const char* cmd = "BREATHE 1 4 3000 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Fast") {
            { const char* cmd = "BREATHE 1 4 1200 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Double Flash") {
            { const char* cmd = "DFLASH 1 4 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else {
            { const char* cmd = "LED 1 4 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          }

  - platform: binary
    id: gauge1_status_red
    name: "${gauge1_name} Status Red"
    output: gauge1_status_red_output
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 1 5 800 800 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 1 5 150 150 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 1 5 100 400 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 1 5 3000 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 1 5 1200 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "DFLASH 1 5 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
    on_state:
      - lambda: |-
          if (!id(gauge1_status_red).remote_values.is_on()) {
            { const char* cmd = "LED 1 5 0 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
            return;
          }
          auto effect = id(gauge1_status_red).get_effect_name();
          if (effect == "Blink Slow") {
            { const char* cmd = "BLINK 1 5 800 800 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Fast") {
            { const char* cmd = "BLINK 1 5 150 150 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Alert") {
            { const char* cmd = "BLINK 1 5 100 400 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Slow") {
            { const char* cmd = "BREATHE 1 5 3000 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Fast") {
            { const char* cmd = "BREATHE 1 5 1200 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Double Flash") {
            { const char* cmd = "DFLASH 1 5 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else {
            { const char* cmd = "LED 1 5 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          }

  - platform: binary
    id: gauge1_status_green
    name: "${gauge1_name} Status Green"
    output: gauge1_status_green_output
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 1 6 800 800 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 1 6 150 150 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 1 6 100 400 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 1 6 3000 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 1 6 1200 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "DFLASH 1 6 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
    on_state:
      - lambda: |-
          if (!id(gauge1_status_green).remote_values.is_on()) {
            { const char* cmd = "LED 1 6 0 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
            return;
          }
          auto effect = id(gauge1_status_green).get_effect_name();
          if (effect == "Blink Slow") {
            { const char* cmd = "BLINK 1 6 800 800 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Fast") {
            { const char* cmd = "BLINK 1 6 150 150 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Alert") {
            { const char* cmd = "BLINK 1 6 100 400 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Slow") {
            { const char* cmd = "BREATHE 1 6 3000 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Fast") {
            { const char* cmd = "BREATHE 1 6 1200 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Double Flash") {
            { const char* cmd = "DFLASH 1 6 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else {
            { const char* cmd = "LED 1 6 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          }

  - platform: rgb
    id: gauge2_backlight
    name: "${gauge2_name} Backlight"
    red: gauge2_backlight_red_output
    green: gauge2_backlight_green_output
    blue: gauge2_backlight_blue_output
    default_transition_length: 0s
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            char cmd[36];
            snprintf(cmd, sizeof(cmd), "BLINK 2 0-2 800 800 %d %d %d\n",
                     id(gauge2_bl_r), id(gauge2_bl_g), id(gauge2_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            char cmd[36];
            snprintf(cmd, sizeof(cmd), "BLINK 2 0-2 150 150 %d %d %d\n",
                     id(gauge2_bl_r), id(gauge2_bl_g), id(gauge2_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            char cmd[36];
            snprintf(cmd, sizeof(cmd), "BLINK 2 0-2 100 400 %d %d %d\n",
                     id(gauge2_bl_r), id(gauge2_bl_g), id(gauge2_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            char cmd[34];
            snprintf(cmd, sizeof(cmd), "BREATHE 2 0-2 3000 %d %d %d\n",
                     id(gauge2_bl_r), id(gauge2_bl_g), id(gauge2_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            char cmd[34];
            snprintf(cmd, sizeof(cmd), "BREATHE 2 0-2 1200 %d %d %d\n",
                     id(gauge2_bl_r), id(gauge2_bl_g), id(gauge2_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            char cmd[32];
            snprintf(cmd, sizeof(cmd), "DFLASH 2 0-2 %d %d %d\n",
                     id(gauge2_bl_r), id(gauge2_bl_g), id(gauge2_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
    on_state:
      - lambda: |-
          auto effect = id(gauge2_backlight).get_effect_name();
          if (effect != "None" && !effect.empty()) return;
          auto& rv = id(gauge2_backlight).remote_values;
          char cmd[32];
          snprintf(cmd, sizeof(cmd), "LED 2 0-2 %d %d %d\n",
                   rv.is_on() ? static_cast<int>(rv.get_red() * rv.get_brightness() * 255.0f + 0.5f) : 0,
                   rv.is_on() ? static_cast<int>(rv.get_green() * rv.get_brightness() * 255.0f + 0.5f) : 0,
                   rv.is_on() ? static_cast<int>(rv.get_blue() * rv.get_brightness() * 255.0f + 0.5f) : 0);
          ESP_LOGI("uart_tx", "TX: %s", cmd);
          id(arduino_uart).write_str(cmd);

  - platform: binary
    id: gauge2_red_indicator
    name: "${gauge2_name} Red Indicator"
    output: gauge2_red_indicator_output
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 2 3 800 800 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 2 3 150 150 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 2 3 100 400 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 2 3 3000 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 2 3 1200 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "DFLASH 2 3 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
    on_state:
      - lambda: |-
          if (!id(gauge2_red_indicator).remote_values.is_on()) {
            { const char* cmd = "LED 2 3 0 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
            return;
          }
          auto effect = id(gauge2_red_indicator).get_effect_name();
          if (effect == "Blink Slow") {
            { const char* cmd = "BLINK 2 3 800 800 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Fast") {
            { const char* cmd = "BLINK 2 3 150 150 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Alert") {
            { const char* cmd = "BLINK 2 3 100 400 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Slow") {
            { const char* cmd = "BREATHE 2 3 3000 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Fast") {
            { const char* cmd = "BREATHE 2 3 1200 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Double Flash") {
            { const char* cmd = "DFLASH 2 3 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else {
            { const char* cmd = "LED 2 3 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          }

  - platform: binary
    id: gauge2_green_indicator
    name: "${gauge2_name} Green Indicator"
    output: gauge2_green_indicator_output
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 2 4 800 800 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 2 4 150 150 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 2 4 100 400 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 2 4 3000 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 2 4 1200 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "DFLASH 2 4 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
    on_state:
      - lambda: |-
          if (!id(gauge2_green_indicator).remote_values.is_on()) {
            { const char* cmd = "LED 2 4 0 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
            return;
          }
          auto effect = id(gauge2_green_indicator).get_effect_name();
          if (effect == "Blink Slow") {
            { const char* cmd = "BLINK 2 4 800 800 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Fast") {
            { const char* cmd = "BLINK 2 4 150 150 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Alert") {
            { const char* cmd = "BLINK 2 4 100 400 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Slow") {
            { const char* cmd = "BREATHE 2 4 3000 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Fast") {
            { const char* cmd = "BREATHE 2 4 1200 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Double Flash") {
            { const char* cmd = "DFLASH 2 4 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else {
            { const char* cmd = "LED 2 4 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          }

  - platform: binary
    id: gauge2_status_red
    name: "${gauge2_name} Status Red"
    output: gauge2_status_red_output
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 2 5 800 800 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 2 5 150 150 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 2 5 100 400 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 2 5 3000 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 2 5 1200 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "DFLASH 2 5 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
    on_state:
      - lambda: |-
          if (!id(gauge2_status_red).remote_values.is_on()) {
            { const char* cmd = "LED 2 5 0 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
            return;
          }
          auto effect = id(gauge2_status_red).get_effect_name();
          if (effect == "Blink Slow") {
            { const char* cmd = "BLINK 2 5 800 800 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Fast") {
            { const char* cmd = "BLINK 2 5 150 150 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Alert") {
            { const char* cmd = "BLINK 2 5 100 400 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Slow") {
            { const char* cmd = "BREATHE 2 5 3000 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Fast") {
            { const char* cmd = "BREATHE 2 5 1200 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Double Flash") {
            { const char* cmd = "DFLASH 2 5 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else {
            { const char* cmd = "LED 2 5 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          }

  - platform: binary
    id: gauge2_status_green
    name: "${gauge2_name} Status Green"
    output: gauge2_status_green_output
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 2 6 800 800 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 2 6 150 150 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 2 6 100 400 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 2 6 3000 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 2 6 1200 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "DFLASH 2 6 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
    on_state:
      - lambda: |-
          if (!id(gauge2_status_green).remote_values.is_on()) {
            { const char* cmd = "LED 2 6 0 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
            return;
          }
          auto effect = id(gauge2_status_green).get_effect_name();
          if (effect == "Blink Slow") {
            { const char* cmd = "BLINK 2 6 800 800 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Fast") {
            { const char* cmd = "BLINK 2 6 150 150 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Alert") {
            { const char* cmd = "BLINK 2 6 100 400 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Slow") {
            { const char* cmd = "BREATHE 2 6 3000 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Fast") {
            { const char* cmd = "BREATHE 2 6 1200 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Double Flash") {
            { const char* cmd = "DFLASH 2 6 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else {
            { const char* cmd = "LED 2 6 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          }

  - platform: rgb
    id: gauge3_backlight
    name: "${gauge3_name} Backlight"
    red: gauge3_backlight_red_output
    green: gauge3_backlight_green_output
    blue: gauge3_backlight_blue_output
    default_transition_length: 0s
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            char cmd[36];
            snprintf(cmd, sizeof(cmd), "BLINK 3 0-2 800 800 %d %d %d\n",
                     id(gauge3_bl_r), id(gauge3_bl_g), id(gauge3_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            char cmd[36];
            snprintf(cmd, sizeof(cmd), "BLINK 3 0-2 150 150 %d %d %d\n",
                     id(gauge3_bl_r), id(gauge3_bl_g), id(gauge3_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            char cmd[36];
            snprintf(cmd, sizeof(cmd), "BLINK 3 0-2 100 400 %d %d %d\n",
                     id(gauge3_bl_r), id(gauge3_bl_g), id(gauge3_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            char cmd[34];
            snprintf(cmd, sizeof(cmd), "BREATHE 3 0-2 3000 %d %d %d\n",
                     id(gauge3_bl_r), id(gauge3_bl_g), id(gauge3_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            char cmd[34];
            snprintf(cmd, sizeof(cmd), "BREATHE 3 0-2 1200 %d %d %d\n",
                     id(gauge3_bl_r), id(gauge3_bl_g), id(gauge3_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            char cmd[32];
            snprintf(cmd, sizeof(cmd), "DFLASH 3 0-2 %d %d %d\n",
                     id(gauge3_bl_r), id(gauge3_bl_g), id(gauge3_bl_b));
            ESP_LOGI("uart_tx", "TX: %s", cmd);
            id(arduino_uart).write_str(cmd);
    on_state:
      - lambda: |-
          auto effect = id(gauge3_backlight).get_effect_name();
          if (effect != "None" && !effect.empty()) return;
          auto& rv = id(gauge3_backlight).remote_values;
          char cmd[32];
          snprintf(cmd, sizeof(cmd), "LED 3 0-2 %d %d %d\n",
                   rv.is_on() ? static_cast<int>(rv.get_red() * rv.get_brightness() * 255.0f + 0.5f) : 0,
                   rv.is_on() ? static_cast<int>(rv.get_green() * rv.get_brightness() * 255.0f + 0.5f) : 0,
                   rv.is_on() ? static_cast<int>(rv.get_blue() * rv.get_brightness() * 255.0f + 0.5f) : 0);
          ESP_LOGI("uart_tx", "TX: %s", cmd);
          id(arduino_uart).write_str(cmd);

  - platform: binary
    id: gauge3_red_indicator
    name: "${gauge3_name} Red Indicator"
    output: gauge3_red_indicator_output
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 3 3 800 800 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 3 3 150 150 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 3 3 100 400 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 3 3 3000 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 3 3 1200 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "DFLASH 3 3 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
    on_state:
      - lambda: |-
          if (!id(gauge3_red_indicator).remote_values.is_on()) {
            { const char* cmd = "LED 3 3 0 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
            return;
          }
          auto effect = id(gauge3_red_indicator).get_effect_name();
          if (effect == "Blink Slow") {
            { const char* cmd = "BLINK 3 3 800 800 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Fast") {
            { const char* cmd = "BLINK 3 3 150 150 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Alert") {
            { const char* cmd = "BLINK 3 3 100 400 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Slow") {
            { const char* cmd = "BREATHE 3 3 3000 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Fast") {
            { const char* cmd = "BREATHE 3 3 1200 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Double Flash") {
            { const char* cmd = "DFLASH 3 3 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else {
            { const char* cmd = "LED 3 3 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          }

  - platform: binary
    id: gauge3_green_indicator
    name: "${gauge3_name} Green Indicator"
    output: gauge3_green_indicator_output
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 3 4 800 800 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 3 4 150 150 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 3 4 100 400 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 3 4 3000 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 3 4 1200 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "DFLASH 3 4 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
    on_state:
      - lambda: |-
          if (!id(gauge3_green_indicator).remote_values.is_on()) {
            { const char* cmd = "LED 3 4 0 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
            return;
          }
          auto effect = id(gauge3_green_indicator).get_effect_name();
          if (effect == "Blink Slow") {
            { const char* cmd = "BLINK 3 4 800 800 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Fast") {
            { const char* cmd = "BLINK 3 4 150 150 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Alert") {
            { const char* cmd = "BLINK 3 4 100 400 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Slow") {
            { const char* cmd = "BREATHE 3 4 3000 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Fast") {
            { const char* cmd = "BREATHE 3 4 1200 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Double Flash") {
            { const char* cmd = "DFLASH 3 4 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else {
            { const char* cmd = "LED 3 4 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          }

  - platform: binary
    id: gauge3_status_red
    name: "${gauge3_name} Status Red"
    output: gauge3_status_red_output
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 3 5 800 800 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 3 5 150 150 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 3 5 100 400 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 3 5 3000 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 3 5 1200 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "DFLASH 3 5 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
    on_state:
      - lambda: |-
          if (!id(gauge3_status_red).remote_values.is_on()) {
            { const char* cmd = "LED 3 5 0 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
            return;
          }
          auto effect = id(gauge3_status_red).get_effect_name();
          if (effect == "Blink Slow") {
            { const char* cmd = "BLINK 3 5 800 800 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Fast") {
            { const char* cmd = "BLINK 3 5 150 150 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Alert") {
            { const char* cmd = "BLINK 3 5 100 400 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Slow") {
            { const char* cmd = "BREATHE 3 5 3000 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Fast") {
            { const char* cmd = "BREATHE 3 5 1200 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Double Flash") {
            { const char* cmd = "DFLASH 3 5 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else {
            { const char* cmd = "LED 3 5 255 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          }

  - platform: binary
    id: gauge3_status_green
    name: "${gauge3_name} Status Green"
    output: gauge3_status_green_output
    restore_mode: ALWAYS_OFF
    effects:
      - lambda:
          name: Blink Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 3 6 800 800 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 3 6 150 150 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Blink Alert
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BLINK 3 6 100 400 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Slow
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 3 6 3000 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Breathe Fast
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "BREATHE 3 6 1200 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
      - lambda:
          name: Double Flash
          update_interval: 3600s
          lambda: |-
            { const char* cmd = "DFLASH 3 6 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
    on_state:
      - lambda: |-
          if (!id(gauge3_status_green).remote_values.is_on()) {
            { const char* cmd = "LED 3 6 0 0 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
            return;
          }
          auto effect = id(gauge3_status_green).get_effect_name();
          if (effect == "Blink Slow") {
            { const char* cmd = "BLINK 3 6 800 800 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Fast") {
            { const char* cmd = "BLINK 3 6 150 150 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Blink Alert") {
            { const char* cmd = "BLINK 3 6 100 400 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Slow") {
            { const char* cmd = "BREATHE 3 6 3000 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Breathe Fast") {
            { const char* cmd = "BREATHE 3 6 1200 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else if (effect == "Double Flash") {
            { const char* cmd = "DFLASH 3 6 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          } else {
            { const char* cmd = "LED 3 6 0 255 0\n"; ESP_LOGI("uart_tx", "TX: %s", cmd); id(arduino_uart).write_str(cmd); }
          }