Удаленное управление питанием внешнего жесткого диска

import mqtt
import string
import gpio

# Глобальная ссылка на экземпляр для колбэков
var g_HDD = nil

class HDDCtrl
  # --- поля ---
  var TOPIC
  var REL1_IDX
  var REL2_IDX
  var BLOCK_MS
  var DELAY_MS

  var WAVE_PIN
  var HIGH_MS
  var LOW_MS

  var blocked
  var wave_active
  var wave_level
  var ledlink_taken
  var log_level

  # публикация/кэш
  var _last_payload          # последний УСПЕШНО опубликованный payload
  var _pending_payload       # то, что нужно доставить при первой возможности

  # цикл стартовой/отложенной синхронизации MQTT
  var SYNC_PERIOD_MS
  var SYNC_MAX_TRIES
  var _sync_active
  var _sync_tries

  def init()
    # --- настройки ---
    self.TOPIC        = "hdd_switch"
    self.REL1_IDX     = 0
    self.REL2_IDX     = 1
    self.BLOCK_MS     = 30000       # Задержка между переключением статуса реле (мс)
    self.DELAY_MS     = 1000         # Задержка между подачей и снятием 5В и 12В (мс)

    self.WAVE_PIN     = 6           # Пин для индикации
    self.HIGH_MS      = 250         # Период вкл индикатора при записи (мс)
    self.LOW_MS       = 250         # Период выкл индикатора при записи (мс)

    self.blocked       = false
    self.wave_active   = false
    self.wave_level    = 0
    self.ledlink_taken = false
    self.log_level     = 0

    self._last_payload    = ""
    self._pending_payload = ""

    self.SYNC_PERIOD_MS = 2000  # раз в 2 секунды
    self.SYNC_MAX_TRIES  = 15  # до 30 сек макс
    self._sync_active    = false
    self._sync_tries     = 0

    tasmota.add_driver(self)
    g_HDD = self

    # безопасный старт реле
    tasmota.cmd("PowerOnState 0", true)
    self.set_power_safe(self.REL1_IDX, false)
    self.set_power_safe(self.REL2_IDX, false)

    # вернуть GPIO6 системе (LedLink_i)
    tasmota.cmd("LedLink 1")

    # Команда HDD и подписки MQTT
    tasmota.remove_cmd("HDD")
    tasmota.add_cmd("HDD", /cmd, idx, payload -> g_HDD.cmd_hdd(cmd, idx, payload))

    mqtt.subscribe("cmnd/"+self.TOPIC+"/POWER1",
      /topic, idx, data, databytes -> g_HDD.on_cmnd_p1(topic, idx, data, databytes))
    mqtt.subscribe("cmnd/"+self.TOPIC+"/POWER2",
      /topic, idx, data, databytes -> g_HDD.on_cmnd_p2(topic, idx, data, databytes))

    # --- НОВОЕ: стартовая синхронизация до успешной публикации ---
    self.request_state_delivery(self.build_state_payload())
  end

  # ===== утилиты =====
  def log(msg, lvl)
    if self.log_level >= lvl tasmota.log(msg, lvl) end
  end

  def set_power_safe(idx, on)
    var s = tasmota.get_power()
    if s[idx] != on tasmota.set_power(idx, on) end
  end

  def build_state_payload()
    var p = tasmota.get_power()
    var overall = p[self.REL1_IDX] && p[self.REL2_IDX]
    return "{\"state\":\"" + (overall ? "ON" : "OFF") +
      "\",\"r1\":" + (p[self.REL1_IDX] ? "true":"false") +
      ",\"r2\":" + (p[self.REL2_IDX] ? "true":"false") +
      ",\"blocked\":" + (self.blocked ? "true":"false") + "}"
  end

  # ===== надёжная доставка состояния =====
  def try_publish(payload)
    # Пытаемся отправить. Возвращает true при успехе.
    return mqtt.publish("stat/"+self.TOPIC+"/HDDSTATE", payload, true)
  end

  def request_state_delivery(payload)
    # Если новое состояние такое же, как уже успешно опубликованное — ничего не делаем
    if payload == self._last_payload
      return
    end
    # Сразу пробуем отправить
    if self.try_publish(payload)
      self._last_payload = payload
      self._pending_payload = ""
      self._sync_active = false
      self._sync_tries  = 0
      self.log("HDDCtrl: state published immediately", 4)
    else
      # MQTT не готов → запомним и запустим цикл синхронизации
      self._pending_payload = payload
      if !self._sync_active
        self._sync_active = true
        self._sync_tries  = 0
        tasmota.set_timer(self.SYNC_PERIOD_MS, /-> g_HDD.sync_tick())
      end
    end
  end

  def sync_tick()
    if !self._sync_active return end
    # Нечего отправлять — выключаемся
    if self._pending_payload == ""
      self._sync_active = false
      self._sync_tries  = 0
      return
    end
    # Пытаемся ещё раз
    var ok = self.try_publish(self._pending_payload)
    if ok
      self._last_payload = self._pending_payload
      self._pending_payload = ""
      self._sync_active = false
      self._sync_tries  = 0
      self.log("HDDCtrl: state published after wait", 2)
    else
      self._sync_tries += 1
      if self._sync_tries < self.SYNC_MAX_TRIES
        tasmota.set_timer(self.SYNC_PERIOD_MS, /-> g_HDD.sync_tick())
      else
        # Дальше не мучаем устройство, но цикл можно будет перезапустить новой request_state_delivery()
        self._sync_active = false
        self.log("HDDCtrl: giving up MQTT sync for now", 2)
      end
    end
  end

  # Публичные интерфейсы публикации
  def publish_state_if_changed()
    self.request_state_delivery(self.build_state_payload())
  end
  def publish_state_force()
    # Принудительно шлём вне зависимости от кэша
    var payload = self.build_state_payload()
    # Сбрасываем кэш, чтобы гарантированно ушло при первой возможности
    self._last_payload = ""
    self.request_state_delivery(payload)
  end
  def publish_state()
    self.publish_state_if_changed()
  end

  # ===== блокировка =====
  def block_start()
    self.blocked = true
    self.publish_state_if_changed()
    tasmota.set_timer(self.BLOCK_MS, /-> g_HDD.block_end())
  end
  def block_end()
    self.blocked = false
    self.publish_state_if_changed()
  end

  # ===== программный меандр на GPIO6 =====
  def wave_tick()
    if !self.wave_active return end
    self.wave_level = 1 - self.wave_level
    gpio.digital_write(self.WAVE_PIN, self.wave_level)
    self.log(string.format("HDDCtrl: GPIO%d=%d", self.WAVE_PIN, self.wave_level), 4)
    var next_ms = (self.wave_level == 1) ? self.HIGH_MS : self.LOW_MS
    tasmota.set_timer(next_ms, /-> g_HDD.wave_tick())
  end

  def ledlink_take()
    if !self.ledlink_taken
      tasmota.cmd("LedLink 0")
      self.ledlink_taken = true
    end
  end
  def ledlink_release()
    if self.ledlink_taken
      tasmota.cmd("LedLink 1")
      self.ledlink_taken = false
    end
  end

  def wave_start()
    if self.wave_active return end
    self.wave_active = true
    self.ledlink_take()
    gpio.pin_mode(self.WAVE_PIN, gpio.OUTPUT)
    self.wave_level = 0
    gpio.digital_write(self.WAVE_PIN, 0)
    self.log(string.format("HDDCtrl: start blink 1Hz on GPIO%d", self.WAVE_PIN), 2)
    self.wave_tick()
  end

  def wave_stop()
    if !self.wave_active
      self.ledlink_release()
      return
    end
    self.wave_active = false
    self.wave_level = 0
    gpio.digital_write(self.WAVE_PIN, 0)
    self.ledlink_release()
    self.log(string.format("HDDCtrl: stop blink on GPIO%d", self.WAVE_PIN), 2)
  end

  # ===== последовательности HDD =====
  def start_on_seq()
    if self.blocked return end
    self.set_power_safe(self.REL1_IDX, true)
    self.wave_start()
    self.block_start()
    tasmota.set_timer(self.DELAY_MS, /-> g_HDD.set_power_safe(self.REL2_IDX, true))
    self.publish_state_if_changed()
  end

  def start_off_seq()
    if self.blocked return end
    self.set_power_safe(self.REL2_IDX, false)
    self.block_start()
    tasmota.set_timer(self.DELAY_MS, /-> g_HDD.finish_off_seq())
    self.publish_state_if_changed()
  end

  def finish_off_seq()
    self.set_power_safe(self.REL1_IDX, false)
    self.wave_stop()
    self.publish_state_if_changed()
  end

  # ===== команда HDD =====
  def cmd_hdd(cmd, idx, payload)
    var p = payload
    if p == nil p = "" end

    if self.blocked
      self.publish_state_if_changed()
      tasmota.resp_cmnd_error()
      return
    end

    if p == "ON" || p == "1" || p == "on"
      self.start_on_seq()
      tasmota.resp_cmnd_done()
    elif p == "OFF" || p == "0" || p == "off"
      self.start_off_seq()
      tasmota.resp_cmnd_done()
    elif p == "TOGGLE" || p == "toggle"
      var s = tasmota.get_power()
      if !s[self.REL1_IDX] && !s[self.REL2_IDX] self.start_on_seq() else self.start_off_seq() end
      tasmota.resp_cmnd_done()
    else
      tasmota.resp_cmnd_error()
    end
  end

  # ===== перехваты POWER1/2 =====
  def on_cmnd_p1(topic, idx, data, databytes)
    if self.blocked return true end
    var p = (data == nil) ? "" : data
    if p == "ON" || p == "1" || p == "on" || p == "TOGGLE" || p == "toggle"
      self.start_on_seq()
    elif p == "OFF" || p == "0" || p == "off"
      self.start_off_seq()
    end
    return true
  end

  def on_cmnd_p2(topic, idx, data, databytes)
    if self.blocked return true end
    var p = (data == nil) ? "" : data
    if p == "OFF" || p == "0" || p == "off" || p == "TOGGLE" || p == "toggle"
      self.start_off_seq()
    end
    return true
  end

  # ===== кнопка =====
  def any_key(cmd, idx)
    var state  = (idx >> 8) & 0xFF    # 10 = SINGLE (SetOption73 1)
    var device = idx & 0xFF           # 1 = Button1
    if device == 1 && state == 10
      if self.blocked return true end
      var s = tasmota.get_power()
      if !s[self.REL1_IDX] && !s[self.REL2_IDX] self.start_on_seq() else self.start_off_seq() end
      return true
    end
    return nil
  end

  # ===== синхронизация питания (внешние изменения) =====
  def set_power_handler(cmd, idx)
    self.publish_state_if_changed()
    var p = tasmota.get_power()
    if p[self.REL1_IDX] self.wave_start() else self.wave_stop() end
    return nil
  end
end

HDDCtrl()

mqtt:
  switch:
    - name: "HDD Switch"
      unique_id: hdd_switch_main
      command_topic: "cmnd/hdd_switch/HDD"
      state_topic: "stat/hdd_switch/HDDSTATE"
      value_template: "{{ value_json.state }}"
      payload_on: "ON"
      payload_off: "OFF"
      availability_topic: "tele/hdd_switch/LWT"
      payload_available: "Online"
      payload_not_available: "Offline"
      qos: 1
      retain: false
      optimistic: false
      icon: mdi:harddisk
      device:
        identifiers: ["hdd_switch_device"]         # общий ID устройства
        name: "HDD Switch Controller"
        manufacturer: "Tasmota"
        model: "ESP32-C3 (Tasmota 15.01)"
        # suggested_area: "Название вашей области"  # опционально

  binary_sensor:
    - name: "HDD Switch Locked"
      unique_id: hdd_switch_locked
      state_topic: "stat/hdd_switch/HDDSTATE"
      value_template: "{{ 'ON' if value_json.blocked else 'OFF' }}"
      device_class: lock
      device:
        identifiers: ["hdd_switch_device"]         # тот же идентификатор

До чего дошёл прогресс — труд физический исчез,
Да и умственный заменит механический процесс.
Позабыты хлопоты, остановлен бег,
Вкалывают роботы, а не человек.