waterfurnace_aurora 0.7.1 → 0.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cb9189b26a420442c7cb7208ac5c955d6be8ed9296a73f62df320eec5ca69b4
-  data.tar.gz: da661eea9277eef4f927e7714bf384f4377930a5e49df52632d7ed457df10fb5
+  metadata.gz: 037ee3ea9f7274fbc12400840c5f174a70e42361c686753728b31ef8c4c6faaf
+  data.tar.gz: 4ce5ddc17e4212d8a73f1c2f9255608d9d9a933da8d74e84af3552acd8bf7021
 SHA512:
-  metadata.gz: 7a80d7049be630d2531e6acfa4d0a56693377555f46a102cb742e1c9e947454f67756ae0f8ca9c146a99e8bbf9acc32db821eae65aa57d4186ca9a5bdfe5280f
-  data.tar.gz: 6fcc21eea70ab2a9a8d7169c68528b01635a2e16acdff5601feed205c80b816f398323cb24c77ec7d3df1193c121247302cedd4fd844312015f26be1959a2c81
+  metadata.gz: d21f026be0e2d578b0a12064b5f90c71e039636d6fa7c21cb2a30c87fae2f2a0cc9eb9ffc65ca025cf415800abab3c32185a52ecc1e86ed5c15b93fe9516391c
+  data.tar.gz: 2dc36c52c465c776f95e6581f60c20816b06c76d392d485c5c14b7c85a82c16b141b68da569eda8bfce1ddfed60bf1027166951b9bbf17383fe8f410506c3e39

data/exe/aurora_mqtt_bridge

@@ -124,57 +124,153 @@ class MQTTBridge
   end
 
   def publish_basic_attributes
+    @homie.home_assistant_device = {
+      manufacturer: "WaterFurnace",
+      sw_version: Aurora::VERSION,
+      model: @abc.model
+    }
+
     @homie_abc = @homie.node("abc", "Heat Pump", "ABC") do |node|
       allowed_modes = %w[lockout standby blower heating cooling eh1 eh2 emergency waiting]
       allowed_modes << "dehumidify" if @abc.compressor.is_a?(Aurora::Compressor::VSDrive)
-      node.property("current-mode", "Current Heating/Cooling Mode", :enum, @abc.current_mode,
-                    format: allowed_modes)
-      node.property("entering-air-temperature", "Entering Air Temperature", :float, @abc.entering_air_temperature,
-                    unit: "°F")
-      node.property("entering-water-temperature", "Entering Water Temperature", :float,
-                    @abc.entering_water_temperature, unit: "°F")
-      node.property("leaving-air-temperature", "Leaving Air Temperature", :float, @abc.leaving_air_temperature,
-                    unit: "°F")
-      node.property("leaving-water-temperature", "Leaving Water Temperature", :float, @abc.leaving_water_temperature,
-                    unit: "°F")
+      node.property("current-mode",
+                    "Current Heating/Cooling Mode",
+                    :enum,
+                    @abc.current_mode,
+                    format: allowed_modes,
+                    hass: { sensor: { state_class: :measurement } })
+      node.property("entering-air-temperature",
+                    "Entering Air Temperature",
+                    :float,
+                    @abc.entering_air_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("entering-water-temperature",
+                    "Entering Water Temperature",
+                    :float,
+                    @abc.entering_water_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("leaving-air-temperature",
+                    "Leaving Air Temperature",
+                    :float,
+                    @abc.leaving_air_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("leaving-water-temperature",
+                    "Leaving Water Temperature",
+                    :float,
+                    @abc.leaving_water_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
       unless @abc.outdoor_temperature.zero? # TODO: figure out the config if this actually exists
-        node.property("outdoor-temperature", "Outdoor Temperature", :float, @abc.outdoor_temperature, unit: "°F")
+        node.property("outdoor-temperature",
+                      "Outdoor Temperature",
+                      :float,
+                      @abc.outdoor_temperature,
+                      unit: "°F",
+                      hass: { sensor: { device_class: :temperature,
+                                        state_class: :measurement } })
       end
 
-      node.property("fp1", "FP1 Sensor", :float, @abc.fp1, unit: "°F")
-      node.property("fp2", "FP2 Sensor", :float, @abc.fp2, unit: "°F")
+      node.property("fp1",
+                    "FP1 Sensor",
+                    :float,
+                    @abc.fp1,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("fp2",
+                    "FP2 Sensor",
+                    :float,
+                    @abc.fp2,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
       %i[aux_heat total].each do |component|
         component = "#{component}_watts"
         node.property(component.tr("_", "-"),
                       component.sub("_watts", " Power Usage").tr("_", " ").titleize,
                       :integer,
                       @abc.public_send(component),
-                      unit: "W")
+                      unit: "W",
+                      hass: { sensor: { device_class: :power,
+                                        state_class: :measurement } })
       end
     end
 
     @compressor = @homie.node("compressor", "Compressor", @abc.compressor.type) do |node|
-      node.property("speed", "Current Speed", :integer, @abc.compressor.speed,
-                    format: @abc.compressor.speed_range)
-      node.property("watts", "Power Usage", :integer, @abc.compressor.watts, unit: "W") if @abc.energy_monitoring?
+      node.property("speed",
+                    "Current Speed",
+                    :integer,
+                    @abc.compressor.speed,
+                    format: @abc.compressor.speed_range,
+                    hass: { sensor: { state_class: :measurement } })
+      if @abc.energy_monitoring?
+        node.property("watts",
+                      "Power Usage",
+                      :integer,
+                      @abc.compressor.watts,
+                      unit: "W",
+                      hass: { sensor: { device_class: :power,
+                                        state_class: :measurement } })
+      end
 
       next unless @abc.compressor.is_a?(Aurora::Compressor::VSDrive)
 
-      node.property("ambient-temperature", "Ambient Temperature", :float,
-                    @abc.compressor.ambient_temperature, unit: "°F")
+      node.property("ambient-temperature",
+                    "Ambient Temperature",
+                    :float,
+                    @abc.compressor.ambient_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
 
       next unless @abc.iz2?
 
-      node.property("iz2-desired-speed", "IZ2 Desired Speed", :integer, @abc.compressor.iz2_desired_speed,
-                    format: 0..12)
+      node.property("iz2-desired-speed",
+                    "IZ2 Desired Speed",
+                    :integer,
+                    @abc.compressor.iz2_desired_speed,
+                    format: 0..12,
+                    hass: { sensor: { state_class: :measurement,
+                                      entity_category: :diagnostic } })
     end
 
     @blower = @homie.node("blower", "Blower", @abc.blower.type) do |node|
-      node.property("running", "Running", :boolean, @abc.blower.running?)
+      node.property("running",
+                    "Running",
+                    :boolean,
+                    @abc.blower.running?,
+                    hass: { binary_sensor: { device_class: :running } })
       if @abc.blower.respond_to?(:speed)
-        node.property("speed", "Current Speed", :integer, @abc.blower.speed, format: @abc.blower.speed_range)
+        node.property("speed",
+                      "Current Speed",
+                      :integer,
+                      @abc.blower.speed,
+                      format: @abc.blower.speed_range,
+                      hass: { sensor: { state_class: :measurement } })
+      end
+      if @abc.energy_monitoring?
+        node.property("watts",
+                      "Power Usage",
+                      :integer,
+                      @abc.blower.watts,
+                      unit: "W",
+                      hass: { sensor: { device_class: :power,
+                                        state_class: :measurement } })
       end
-      node.property("watts", "Power Usage", :integer, @abc.blower.watts, unit: "W") if @abc.energy_monitoring?
 
       next unless @abc.blower.is_a?(Aurora::Blower::ECM)
 
@@ -182,95 +278,209 @@ class MQTTBridge
       presets.concat %w[low-compressor high-compressor] unless @abc.iz2?
       presets.each do |setting|
         field = "#{setting.tr("-", "_")}_speed"
-        node.property("#{setting}-speed", "#{setting.tr("-", " ").titleize} Preset Speed", :integer,
-                      @abc.blower.public_send(field), format: 1..12) do |value, property|
+        node.property("#{setting}-speed",
+                      "#{setting.tr("-", " ").titleize} Preset Speed",
+                      :integer,
+                      @abc.blower.public_send(field),
+                      format: 1..12,
+                      hass: { number: { entity_category: :config } }) do |value, property|
           @mutex.synchronize { property.value = @abc.blower.public_send("#{field}=", value) }
         end
       end
 
       next unless @abc.iz2?
 
-      node.property("iz2-desired-speed", "IZ2 Desired Speed", :integer, @abc.blower.iz2_desired_speed,
-                    format: 0..100, unit: "%")
+      node.property("iz2-desired-speed",
+                    "IZ2 Desired Speed",
+                    :integer,
+                    @abc.blower.iz2_desired_speed,
+                    format: 0..100,
+                    unit: "%",
+                    hass: { sensor: { state_class: :measurement,
+                                      entity_category: :diagnostic } })
     end
 
     @pump = @homie.node("pump", "Loop Pump", @abc.pump.type) do |node|
-      node.property("waterflow", "Waterflow", :float, @abc.pump.waterflow, unit: "gpm")
-      node.property("watts", "Power Usage", :integer, @abc.pump.watts, unit: "W") if @abc.energy_monitoring?
+      node.property("waterflow",
+                    "Waterflow",
+                    :float,
+                    @abc.pump.waterflow,
+                    unit: "gpm",
+                    hass: { sensor: { state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      if @abc.energy_monitoring?
+        node.property("watts",
+                      "Power Usage",
+                      :integer,
+                      @abc.pump.watts,
+                      unit: "W",
+                      hass: { sensor: { device_class: :power,
+                                        state_class: :measurement } })
+      end
 
       next unless @abc.pump.is_a?(Aurora::Pump::VSPump)
 
-      node.property("running", "Running", :boolean, @abc.pump.running)
-      node.property("speed", "Speed", :integer, @abc.pump.speed, format: 0..100, unit: "%") do |value, property|
+      node.property("running",
+                    "Running",
+                    :boolean,
+                    @abc.pump.running,
+                    hass: { binary_sensor: { device_class: :running } })
+      node.property("speed",
+                    "Speed",
+                    :integer,
+                    @abc.pump.speed,
+                    format: 0..100,
+                    unit: "%",
+                    hass: { number: { entity_category: :diagnostic } }) do |value, property|
         @mutex.synchronize { property.value = @abc.pump.speed = value }
       end
-      node.property("manual-control", "Manual Control", :boolean,
-                    @abc.pump.manual_control?) do |value, property|
+      node.property("manual-control",
+                    "Manual Control",
+                    :boolean,
+                    @abc.pump.manual_control?,
+                    hass: { switch: { entity_category: :diagnostic } }) do |value, property|
         @mutex.synchronize { property.value = @abc.pump.manual_control = value }
       end
-      node.property("minimum-speed", "Actual Minimum Speed", :integer, @abc.pump.minimum_speed,
-                    format: 0..100, unit: "%") do |value, property|
+      node.property("minimum-speed",
+                    "Actual Minimum Speed",
+                    :integer,
+                    @abc.pump.minimum_speed,
+                    format: 0..100,
+                    unit: "%",
+                    hass: { number: { entity_category: :config } }) do |value, property|
         @mutex.synchronize { property.value = @abc.pump.minimum_speed = value }
       end
-      node.property("maximum-speed", "Actual Maximum Speed", :integer, @abc.pump.minimum_speed,
-                    format: 0..100, unit: "%") do |value, property|
+      node.property("maximum-speed",
+                    "Actual Maximum Speed",
+                    :integer,
+                    @abc.pump.minimum_speed,
+                    format: 0..100,
+                    unit: "%",
+                    hass: { number: { entity_category: :config } }) do |value, property|
         @mutex.synchronize { property.value = @abc.pump.maximum_speed = value }
       end
     end
 
     if @abc.dhw
       @dhw = @homie.node("dhw", "Domestic Hot Water Generator", "DHW") do |node|
-        node.property("enabled", "Enabled", :boolean, @abc.dhw.enabled) do |value, property|
+        node.property("enabled",
+                      "Enabled",
+                      :boolean,
+                      @abc.dhw.enabled,
+                      hass: { switch: { icon: "mdi:water-boiler" } }) do |value, property|
           @mutex.synchronize { property.value = @abc.dhw.enabled = value }
         end
-        node.property("running", "Pump Running", :boolean, @abc.dhw.running?)
-        node.property("water-temperature", "Water Temperature", :float,
-                      @abc.dhw.water_temperature, unit: "°F")
-        node.property("set-point", "Set Point", :float, @abc.dhw.set_point, format: 100..140,
-                                                                            unit: "°F") do |value, property|
+        node.property("running",
+                      "Pump Running",
+                      :boolean,
+                      @abc.dhw.running?,
+                      hass: { binary_sensor: { device_class: :running } })
+        node.property("water-temperature",
+                      "Water Temperature",
+                      :float,
+                      @abc.dhw.water_temperature,
+                      unit: "°F",
+                      hass: { sensor: { device_class: :temperature,
+                                        state_class: :measurement } })
+        node.property("set-point",
+                      "Set Point",
+                      :float,
+                      @abc.dhw.set_point,
+                      format: 100..140,
+                      unit: "°F",
+                      hass: :number) do |value, property|
           @mutex.synchronize { property.value = @abc.dhw.set_point = value }
         end
       end
     end
 
     @humidistat = @homie.node("humidistat", "Humidistat", "Humidistat") do |node|
-      node.property("relative-humidity", "Relative Humidity", :integer, @abc.humidistat.relative_humidity,
-                    unit: "%", format: 0..100)
+      node.property("relative-humidity",
+                    "Relative Humidity",
+                    :integer,
+                    @abc.humidistat.relative_humidity,
+                    unit: "%",
+                    format: 0..100,
+                    hass: { sensor: { device_class: :humidity,
+                                      state_class: :measurement } })
       if @abc.humidistat.humidifier?
-        node.property("humidifier-running", "Humidifier Running", :boolean, @abc.humidistat.humidifier_running?)
-        node.property("humidifier-mode", "Humidifier Mode", :enum, @abc.humidistat.humidifier_mode,
+        node.property("humidifier-running",
+                      "Humidifier Running",
+                      :boolean,
+                      @abc.humidistat.humidifier_running?)
+        node.property("humidifier-mode",
+                      "Humidifier Mode",
+                      :enum,
+                      @abc.humidistat.humidifier_mode,
                       format: %i[auto manual]) do |value, property|
           @mutex.synchronize { property.value = @abc.humidistat.humidifier_mode = value.to_sym }
         end
-        node.property("humidification-target", "Humidification Target Relative Humidity", :integer,
-                      @abc.humidistat.humidification_target, unit: "%", format: 15..50) do |value, property|
+        node.property("humidification-target",
+                      "Humidification Target Relative Humidity",
+                      :integer,
+                      @abc.humidistat.humidification_target,
+                      unit: "%",
+                      format: 15..50) do |value, property|
           @mutex.synchronize { property.value = @abc.humidistat.humidification_target = value }
         end
+        node.hass_humidifier("humidifier-running",
+                             target_property: "humidification-target",
+                             mode_property: "humidifier-mode",
+                             id: "humidifier",
+                             name: "Humidifier",
+                             device_class: :humidifier)
       end
 
       # VSDrive can perform active dehumidification, even without a dedicated dehumidifier
-      if @abc.humidistat.dehumidifier? || @abc.compressor.is_a?(Aurora::Compressor::VSDrive)
-        node.property("dehumidifier-running", "Dehumidifier Running", :boolean, @abc.humidistat.dehumidifier_running?)
-        node.property("dehumidifier-mode", "Dehumidifier Mode", :enum, @abc.humidistat.dehumidifier_mode,
+      if @abc.humidistat.dehumidifier? ||
+         @abc.compressor.is_a?(Aurora::Compressor::VSDrive)
+        node.property("dehumidifier-running",
+                      "Dehumidifier Running",
+                      :boolean,
+                      @abc.humidistat.dehumidifier_running?)
+        node.property("dehumidifier-mode",
+                      "Dehumidifier Mode",
+                      :enum,
+                      @abc.humidistat.dehumidifier_mode,
                       format: %i[auto manual]) do |value, property|
           @mutex.synchronize { property.value = @abc.humidistat.dehumidifier_mode = value.to_sym }
         end
-        node.property("dehumidification-target", "Dehumidification Target Relative Humidity", :integer,
-                      @abc.humidistat.dehumidification_target, unit: "%", format: 35..65) do |value, property|
+        node.property("dehumidification-target",
+                      "Dehumidification Target Relative Humidity",
+                      :integer,
+                      @abc.humidistat.dehumidification_target,
+                      unit: "%",
+                      format: 35..65) do |value, property|
           @mutex.synchronize { property.value = @abc.humidistat.dehumidification_target = value }
         end
+        node.hass_humidifier("dehumidifier-running",
+                             target_property: "dehumidification-target",
+                             mode_property: "dehumidifier-mode",
+                             id: "dehumidifier",
+                             name: "Dehumidifier",
+                             device_class: :dehumidifier)
       end
     end
 
     @faults = @homie.node("faults", "Fault History", "ABC") do |node|
-      node.property("clear-history", "Reset Fault Counts", :enum, retained: false, format: "clear") do |_|
+      node.property("clear-history",
+                    "Reset Fault Counts",
+                    :enum,
+                    retained: false,
+                    format: "clear",
+                    hass: :scene) do |_|
         @mutex.synchronize { @abc.clear_fault_history }
       end
       @abc.faults.each_with_index do |count, i|
         next if count == 0xffff
 
         name = Aurora::FAULTS[i + 1]
-        node.property("e#{i + 1}", name || "E#{i + 1}", :integer, count)
+        node.property("e#{i + 1}",
+                      name || "E#{i + 1}",
+                      :integer,
+                      count,
+                      hass: { sensor: { state_class: :total_increasing,
+                                        entity_category: :diagnostic } })
       end
     end
 
@@ -279,39 +489,109 @@ class MQTTBridge
       @homie.node("zone#{i + 1}", "Zone #{i + 1}", type) do |node|
         allowed_modes = %w[off auto cool heat]
         allowed_modes << "eheat" if i.zero?
-        node.property("target-mode", "Target Heating/Cooling Mode", :enum, zone.target_mode,
+        node.property("target-mode",
+                      "Target Heating/Cooling Mode",
+                      :enum,
+                      zone.target_mode,
                       format: allowed_modes) do |value, property|
           @mutex.synchronize { property.value = zone.target_mode = value.to_sym }
         end
-        node.property("current-mode", "Current Heating/Cooling Mode Requested", :enum, zone.current_mode,
+        node.property("current-mode",
+                      "Current Heating/Cooling Mode Requested",
+                      :enum,
+                      zone.current_mode,
                       format: %w[standby h1 h2 h3 c1 c2])
-        node.property("target-fan-mode", "Target Fan Mode", :enum, zone.target_fan_mode,
+        node.property("target-fan-mode",
+                      "Target Fan Mode",
+                      :enum,
+                      zone.target_fan_mode,
                       format: %w[auto continuous intermittent]) do |value, property|
           @mutex.synchronize { property.value = zone.target_fan_mode = value.to_sym }
         end
-        node.property("fan-intermittent-on", "Fan Intermittent Mode On Duration", :enum, zone.fan_intermittent_on,
-                      unit: "M", format: %w[0 5 10 15 20]) do |value, property|
+        node.property("fan-intermittent-on",
+                      "Fan Intermittent Mode On Duration",
+                      :enum,
+                      zone.fan_intermittent_on,
+                      unit: "M",
+                      format: %w[0 5 10 15 20],
+                      hass: { select: { entity_category: :config } }) do |value, property|
           @mutex.synchronize { property.value = zone.fan_intermittent_on = value.to_i }
         end
-        node.property("fan-intermittent-off", "Fan Intermittent Mode Off Duration", :enum, zone.fan_intermittent_on,
-                      unit: "M", format: %w[0 5 10 15 20 25 30 35 40]) do |value, property|
+        node.property("fan-intermittent-off",
+                      "Fan Intermittent Mode Off Duration",
+                      :enum,
+                      zone.fan_intermittent_on,
+                      unit: "M",
+                      format: %w[0 5 10 15 20 25 30 35 40],
+                      hass: { select: { entity_category: :config } }) do |value, property|
           @mutex.synchronize { property.value = zone.fan_intermittent_on = value.to_i }
         end
-        node.property("current-fan-mode", "Current Fan Status", :boolean, zone.current_fan_mode)
+        node.property("current-fan-mode",
+                      "Current Fan Status",
+                      :boolean,
+                      zone.current_fan_mode,
+                      hass: { binary_sensor: { device_class: :running } })
         if zone.is_a?(Aurora::IZ2Zone)
-          node.property("priority", "Zone Priority", :enum, zone.priority, format: %w[economy comfort])
-          node.property("size", "Size", :enum, zone.size, format: %w[0 25 45 70])
-          node.property("normalized-size", "Normalized Size", :integer, zone.normalized_size, unit: "%", format: 0..100)
+          node.property("priority",
+                        "Zone Priority",
+                        :enum,
+                        zone.priority,
+                        format: %w[economy comfort],
+                        hass: { sensor: { state_class: :measurement,
+                                          entity_category: :diagnostic } })
+          node.property("size",
+                        "Size",
+                        :enum,
+                        zone.size,
+                        format: %w[0 25 45 70],
+                        hass: { sensor: { state_class: :measurement,
+                                          entity_category: :diagnostic } })
+          node.property("normalized-size",
+                        "Normalized Size",
+                        :integer,
+                        zone.normalized_size,
+                        unit: "%",
+                        format: 0..100,
+                        hass: { sensor: { state_class: :measurement,
+                                          entity_category: :diagnostic } })
         end
-        node.property("ambient-temperature", "Ambient Temperature", :float, zone.ambient_temperature, unit: "°F")
-        node.property("heating-target-temperature", "Heating Target Temperature", :integer,
-                      zone.heating_target_temperature, unit: "°F", format: 40..90) do |value, property|
+        node.property("ambient-temperature",
+                      "Ambient Temperature",
+                      :float,
+                      zone.ambient_temperature,
+                      unit: "°F")
+        node.property("heating-target-temperature",
+                      "Heating Target Temperature",
+                      :integer,
+                      zone.heating_target_temperature,
+                      unit: "°F",
+                      format: 40..90) do |value, property|
           @mutex.synchronize { property.value = zone.heating_target_temperature = value }
         end
-        node.property("cooling-target-temperature", "Cooling Target Temperature", :integer,
-                      zone.cooling_target_temperature, unit: "°F", format: 54..99) do |value, property|
+        node.property("cooling-target-temperature",
+                      "Cooling Target Temperature", :integer,
+                      zone.cooling_target_temperature,
+                      unit: "°F",
+                      format: 54..99) do |value, property|
           @mutex.synchronize { property.value = zone.cooling_target_temperature = value }
         end
+        node.hass_climate(action_property: "current-mode",
+                          current_temperature_property: "ambient-temperature",
+                          fan_mode_property: "target-fan-mode",
+                          mode_property: "target-mode",
+                          temperature_high_property: "cooling-target-temperature",
+                          temperature_low_property: "heating-target-temperature",
+                          templates: {
+                            action_template: <<~JINJA
+                              {% if value.startswith('h') %}
+                                heating
+                              {% elif value.startswith('c') %}
+                                cooling
+                              {% elif value == 'standby' %}
+                                idle
+                              {% endif %}
+                            JINJA
+                          })
       end
     end
 
@@ -319,169 +599,7 @@ class MQTTBridge
     @homie.mqtt.subscribe("#{@homie.topic}/$modbus")
     @homie.mqtt.subscribe("#{@homie.topic}/$modbus/getregs")
     @homie.mqtt.subscribe("#{@homie.topic}/$modbus/+/set")
-    @homie.publish do
-      # do HASS publishes in this block so they're done in bulk
-
-      MQTT::HomeAssistant.publish_sensor(@homie["abc"]["current-mode"],
-                                         device_class: :power)
-      MQTT::HomeAssistant.publish_sensor(@homie["abc"]["entering-air-temperature"],
-                                         device_class: :temperature,
-                                         entity_category: :diagnostic)
-      MQTT::HomeAssistant.publish_sensor(@homie["abc"]["entering-water-temperature"],
-                                         device_class: :temperature,
-                                         entity_category: :diagnostic)
-      MQTT::HomeAssistant.publish_sensor(@homie["abc"]["leaving-air-temperature"],
-                                         device_class: :temperature,
-                                         entity_category: :diagnostic)
-      MQTT::HomeAssistant.publish_sensor(@homie["abc"]["leaving-water-temperature"],
-                                         device_class: :temperature,
-                                         entity_category: :diagnostic)
-      unless @abc.outdoor_temperature.zero?
-        MQTT::HomeAssistant.publish_sensor(@homie["abc"]["outdoor-temperature"],
-                                           device_class: :temperature)
-      end
-      MQTT::HomeAssistant.publish_sensor(@homie["abc"]["fp1"],
-                                         device_class: :temperature,
-                                         entity_category: :diagnostic)
-      MQTT::HomeAssistant.publish_sensor(@homie["abc"]["fp2"],
-                                         device_class: :temperature,
-                                         entity_category: :diagnostic)
-      MQTT::HomeAssistant.publish_sensor(@homie["abc"]["aux-heat-watts"],
-                                         device_class: :power)
-      MQTT::HomeAssistant.publish_sensor(@homie["abc"]["total-watts"],
-                                         device_class: :power)
-
-      MQTT::HomeAssistant.publish_sensor(@homie["compressor"]["speed"])
-      MQTT::HomeAssistant.publish_sensor(@homie["compressor"]["watts"],
-                                         device_class: :power)
-
-      if @abc.compressor.is_a?(Aurora::Compressor::VSDrive)
-        MQTT::HomeAssistant.publish_sensor(@homie["compressor"]["ambient-temperature"],
-                                           device_class: :temperature,
-                                           entity_category: :diagnostic)
-
-        if @abc.iz2?
-          MQTT::HomeAssistant.publish_sensor(@homie["compressor"]["iz2-desired-speed"],
-                                             entity_category: :diagnostic)
-        end
-      end
-
-      MQTT::HomeAssistant.publish_binary_sensor(@homie["blower"]["running"],
-                                                device_class: :running)
-      MQTT::HomeAssistant.publish_sensor(@homie["blower"]["speed"]) if @abc.blower.respond_to?(:speed)
-      MQTT::HomeAssistant.publish_sensor(@homie["blower"]["watts"],
-                                         device_class: :power)
-      MQTT::HomeAssistant.publish_number(@homie["blower"]["blower-only-speed"],
-                                         entity_category: :config)
-      MQTT::HomeAssistant.publish_number(@homie["blower"]["aux-heat-speed"],
-                                         entity_category: :config)
-      if @abc.iz2?
-        MQTT::HomeAssistant.publish_sensor(@homie["blower"]["iz2-desired-speed"])
-      else
-        MQTT::HomeAssistant.publish_number(@homie["blower"]["low-compressor-speed"],
-                                           entity_category: :config)
-        MQTT::HomeAssistant.publish_number(@homie["blower"]["high-compressor-speed"],
-                                           entity_category: :config)
-      end
-
-      MQTT::HomeAssistant.publish_sensor(@homie["pump"]["waterflow"],
-                                         entity_category: :diagnostic)
-      MQTT::HomeAssistant.publish_sensor(@homie["pump"]["watts"],
-                                         device_class: :power)
-
-      if @abc.pump.is_a?(Aurora::Pump::VSPump)
-        MQTT::HomeAssistant.publish_binary_sensor(@homie["pump"]["running"],
-                                                  device_class: :running)
-        MQTT::HomeAssistant.publish_number(@homie["pump"]["speed"],
-                                           entity_category: :diagnostic)
-
-        MQTT::HomeAssistant.publish_switch(@homie["pump"]["manual-control"],
-                                           entity_category: :diagnostic)
-        MQTT::HomeAssistant.publish_number(@homie["pump"]["minimum-speed"],
-                                           entity_category: :config)
-        MQTT::HomeAssistant.publish_number(@homie["pump"]["maximum-speed"],
-                                           entity_category: :config)
-      end
-
-      MQTT::HomeAssistant.publish_scene(@homie["faults"]["clear-history"])
-      @homie["faults"].each do |property|
-        next if property.id == "clear-history"
-
-        MQTT::HomeAssistant.publish_sensor(property,
-                                           entity_category: :diagnostic)
-      end
-
-      if @abc.dhw
-        MQTT::HomeAssistant.publish_switch(@homie["dhw"]["enabled"],
-                                           icon: "mdi:water-boiler")
-        MQTT::HomeAssistant.publish_binary_sensor(@homie["dhw"]["running"],
-                                                  device_class: :running)
-        MQTT::HomeAssistant.publish_sensor(@homie["dhw"]["water-temperature"],
-                                           device_class: :temperature)
-        MQTT::HomeAssistant.publish_number(@homie["dhw"]["set-point"])
-      end
-
-      MQTT::HomeAssistant.publish_sensor(@homie["humidistat"]["relative-humidity"],
-                                         device_class: :humidity)
-      if @abc.humidistat.humidifier?
-        MQTT::HomeAssistant.publish_humidifier(
-          @homie["humidistat"]["humidifier-running"],
-          device_class: :humidifier,
-          name: "Humidifier",
-          id: "humidifier",
-          target_property: @homie["humidistat"]["humidification-target"],
-          mode_property: @homie["humidistat"]["humidifier-mode"]
-        )
-      end
-      if @abc.humidistat.dehumidifier? || @abc.compressor.is_a?(Aurora::Compressor::VSDrive)
-        MQTT::HomeAssistant.publish_humidifier(
-          @homie["humidistat"]["dehumidifier-running"],
-          device_class: :dehumidifier,
-          name: "Dehumidifier",
-          id: "dehumidifier",
-          target_property: @homie["humidistat"]["dehumidification-target"],
-          mode_property: @homie["humidistat"]["dehumidifier-mode"]
-        )
-      end
-
-      @abc.zones.each_with_index do |zone, i|
-        homie_zone = @homie["zone#{i + 1}"]
-        MQTT::HomeAssistant.publish_climate(
-          action_property: homie_zone["current-mode"],
-          current_temperature_property: homie_zone["ambient-temperature"],
-          fan_mode_property: homie_zone["target-fan-mode"],
-          mode_property: homie_zone["target-mode"],
-          temperature_high_property: homie_zone["cooling-target-temperature"],
-          temperature_low_property: homie_zone["heating-target-temperature"],
-          templates: {
-            action_template: <<~JINJA
-              {% if value.startswith('h') %}
-                heating
-              {% elif value.startswith('c') %}
-                cooling
-              {% elif value == 'standby' %}
-                idle
-              {% endif %}
-            JINJA
-          }
-        )
-        MQTT::HomeAssistant.publish_binary_sensor(homie_zone["current-fan-mode"],
-                                                  device_class: :running)
-        MQTT::HomeAssistant.publish_select(homie_zone["fan-intermittent-on"],
-                                           entity_category: :config)
-        MQTT::HomeAssistant.publish_select(homie_zone["fan-intermittent-off"],
-                                           entity_category: :config)
-
-        next unless zone.is_a?(Aurora::IZ2Zone)
-
-        MQTT::HomeAssistant.publish_sensor(homie_zone["priority"],
-                                           entity_category: :diagnostic)
-        MQTT::HomeAssistant.publish_sensor(homie_zone["size"],
-                                           entity_category: :diagnostic)
-        MQTT::HomeAssistant.publish_sensor(homie_zone["normalized-size"],
-                                           entity_category: :diagnostic)
-      end
-    end
+    @homie.publish
   end
 end
 

data/lib/aurora/abc_client.rb

@@ -43,6 +43,7 @@ module Aurora
     end
 
     attr_reader :modbus_slave,
+                :model,
                 :serial_number,
                 :zones,
                 :compressor,
@@ -66,9 +67,10 @@ module Aurora
       @modbus_slave = self.class.open_modbus_slave(uri)
       @modbus_slave.read_retry_timeout = 15
       @modbus_slave.read_retries = 2
-      raw_registers = @modbus_slave.holding_registers[33, 88..91, 105...110, 404, 412..413, 1103, 1114]
+      raw_registers = @modbus_slave.holding_registers[33, 88...110, 404, 412..413, 1103, 1114]
       registers = Aurora.transform_registers(raw_registers.dup)
       @program = registers[88]
+      @model = registers[92]
       @serial_number = registers[105]
       @energy_monitor = raw_registers[412]
 

data/lib/aurora/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aurora
-  VERSION = "0.7.1"
+  VERSION = "0.7.5"
 end

data/lib/aurora.rb

@@ -7,6 +7,7 @@ require "aurora/mock_abc"
 require "aurora/modbus/server"
 require "aurora/modbus/slave"
 require "aurora/registers"
+require "aurora/version"
 
 # extend ModBus for WaterFurnace's custom functions
 ModBus::RTUServer.include(Aurora::ModBus::Server)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: waterfurnace_aurora
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.5
 platform: ruby
 authors:
 - Cody Cutrer
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-12-09 00:00:00.000000000 Z
+date: 2021-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ccutrer-serialport
@@ -16,34 +16,34 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: mqtt-homeassistant
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.2
+        version: 0.1.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.2
+        version: 0.1.3
 - !ruby/object:Gem::Dependency
   name: net-telnet-rfc2217
   requirement: !ruby/object:Gem::Requirement