waterfurnace_aurora 0.6.4 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa7915f9b848e8cea608787f628b077e7fc2d5904044581758099db9a3b26742
-  data.tar.gz: ecf97a652368c8ed73d6bffdea6d1961e1cbb85c0587e50ba5211735368fb7b3
+  metadata.gz: 022f7ed4808f1276a58c999584d2b4bd38dc756e85e018e41cb5e9c5a5535bcf
+  data.tar.gz: c428e4f7ef1c9bb3fb1a64d65be9ca76043305d250eaf434e453c0729bf3189e
 SHA512:
-  metadata.gz: a8b861192fcb395fbec9643840b9b91aaa3d42193d55efda03812d10114a3f4e076afc2eb79a6294bc89a0e340bd5c14f3f2e2fca25e6d1eefa32c9bff359a20
-  data.tar.gz: a35c95acd756183eb2bd2af220e65a182a2206b054453fb49c0e550d512831328d74f72df8e46aec118824efd581fd26e04374b67dbc7898b07f9a964d1123d8
+  metadata.gz: 6732c28063980999e4b5feffd59eaee3829ca5785d53028b0c659567dc35aae4c32ddcb7770b5e4a094b1f5d5219ae6d04659920c631cea881bd077977f7a63a
+  data.tar.gz: 2c866d3d0c628a6a4f814f1a1fd78d4cbe62140787a43585e56cb8d749b3f6421dde793839d67d83bba268037a6493578b47eae23c669ad72296eabf5a584226

data/exe/aurora_mock

@@ -38,7 +38,7 @@ r = slave1.holding_registers = slave2.holding_registers = slave255.holding_regis
 registers = YAML.safe_load(File.read(ARGV[2]))
 registers.each { |(k, v)| r[k] = v }
 
-server1.request_callback = lambda { |uid, func, req|
+server1.request_callback = lambda do |uid, func, req|
   if func == 68
     puts "===== no idea to #{uid}: #{req.inspect}"
   elsif func == 67
@@ -54,9 +54,9 @@ server1.request_callback = lambda { |uid, func, req|
   else
     puts "**** new func #{func}"
   end
-}
+end
 
-server1.response_callback = lambda { |uid, func, res, req|
+server1.response_callback = lambda do |uid, func, res, req|
   if func == 3 && res.is_a?(Array) && req
     unless req[:quant] == res.length
       puts "wrong number of results"
@@ -88,7 +88,7 @@ server1.response_callback = lambda { |uid, func, res, req|
   else
     puts "**** new func #{func}"
   end
-}
+end
 
 server2.start
 server1.send(:serve, server1.instance_variable_get(:@sp))

data/exe/aurora_monitor

@@ -79,7 +79,7 @@ diff_and_print = lambda do |registers|
   last_registers = new_registers
 end
 
-server.request_callback = lambda { |uid, func, req|
+server.request_callback = lambda do |uid, func, req|
   if func == 6
     puts "#{Time.now} ===== write register to #{uid}:"
     registers = { req[:addr] => req[:val] }
@@ -104,9 +104,9 @@ server.request_callback = lambda { |uid, func, req|
   else
     puts "#{Time.now} **** new func #{func}"
   end
-}
+end
 
-server.response_callback = lambda { |uid, func, res, req|
+server.response_callback = lambda do |uid, func, res, req|
   if func == 3 && res.is_a?(Array) && req
     unless req[:quant] == res.length
       puts "wrong number of results"
@@ -138,7 +138,7 @@ server.response_callback = lambda { |uid, func, res, req|
   else
     puts "#{Time.now} **** new func #{func}"
   end
-}
+end
 
 server.send(:serve, server.instance_variable_get(:@sp))
 loop { nil }

data/exe/aurora_mqtt_bridge

@@ -3,6 +3,7 @@
 
 require "aurora"
 require "homie-mqtt"
+require "mqtt/home_assistant"
 require "ccutrer-serialport"
 require "uri"
 require "optparse"
@@ -79,7 +80,7 @@ class MQTTBridge
           end
         end
       end
-    rescue StandardError => e
+    rescue => e
       warn "failed processing message: #{e}\n#{e.backtrace}"
     end
 
@@ -123,153 +124,363 @@ class MQTTBridge
   end
 
   def publish_basic_attributes
-    @homie_abc = @homie.node("abc", "Aurora Basic Control", "ABC") do |node|
+    @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.tr("_", " ").titleize, :integer,
-                      @abc.public_send(component), unit: "W")
+        node.property(component.tr("_", "-"),
+                      component.sub("_watts", " Power Usage").tr("_", " ").titleize,
+                      :integer,
+                      @abc.public_send(component),
+                      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 compressor speed", :integer, @abc.compressor.speed,
-                    format: @abc.compressor.speed_range)
-      node.property("watts", "Energy 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", "Compressor 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", "Blower is 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 blower 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", "Energy Usage", :integer, @abc.blower.watts, unit: "W") if @abc.energy_monitoring?
 
       next unless @abc.blower.is_a?(Aurora::Blower::ECM)
 
       presets = %w[blower-only aux-heat]
       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|
+        field = "#{setting.tr("-", "_")}_speed"
+        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", "Energy 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", "Pump is 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", "If manual control is enabled", :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", "Speed pump runs at compressor speed 0", :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", "Speed pump runs at compressor speed 12", :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", "DHW Pump is 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 is 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-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
-
-      next unless @abc.humidistat.dehumidifier?
-
-      node.property("dehumidifier-running", "Dehumidifier is running", :boolean, @abc.humidistat.dehumidifier_running?)
     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
 
@@ -278,39 +489,108 @@ 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-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
 
@@ -328,7 +608,7 @@ logger.level = log_level
 abc.modbus_slave.logger = logger
 
 device = "aurora-#{abc.serial_number}"
-homie = MQTT::Homie::Device.new(device, "Aurora MQTT Bridge", mqtt: mqtt_uri)
+homie = MQTT::Homie::Device.new(device, "WaterFurnace", mqtt: mqtt_uri)
 homie.logger = logger
 
 MQTTBridge.new(abc, homie)

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]
 
@@ -92,14 +94,14 @@ module Aurora
                 when 3 then Blower::FiveSpeed.new(self, registers[404])
                 else; Blower::PSC.new(self, registers[404])
                 end
-      @pump = if (3..5).include?(raw_registers[413])
+      @pump = if (3..5).cover?(raw_registers[413])
                 Pump::VSPump.new(self,
                                  registers[413])
               else
                 Pump::GenericPump.new(self,
                                       registers[413])
               end
-      @dhw = DHW.new(self) if (-999..999).include?(registers[1114])
+      @dhw = DHW.new(self) if (-999..999).cover?(registers[1114])
       @humidistat = Humidistat.new(self,
                                    @abc_dipswitches[:accessory_relay] == :humidifier,
                                    @axb_dipswitches[:accessory_relay2] == :dehumidifier)
@@ -171,7 +173,7 @@ module Aurora
       @fp2                        = registers[20]
       @locked_out                 = registers[25] & 0x8000
       @error                      = registers[25] & 0x7fff
-      @derated                    = (41..46).include?(@error)
+      @derated                    = (41..46).cover?(@error)
       @safe_mode                  = [47, 48, 49, 72, 74].include?(@error)
       @aux_heat_watts             = registers[1151]
       @total_watts                = registers[1153]
@@ -212,7 +214,7 @@ module Aurora
     end
 
     def line_voltage=(value)
-      raise ArgumentError unless (90..635).include?(value)
+      raise ArgumentError unless (90..635).cover?(value)
 
       @modbus_slave.holding_registers[112] = value
     end
@@ -227,13 +229,13 @@ module Aurora
                          pump_speed: :with_compressor,
                          aux_heat: false)
       raise ArgumentError, "mode must be :off, :heating, or :cooling" unless %i[off heating cooling].include?(mode)
-      raise ArgumentError, "compressor speed must be between 0 and 12" unless (0..12).include?(compressor_speed)
+      raise ArgumentError, "compressor speed must be between 0 and 12" unless (0..12).cover?(compressor_speed)
 
-      unless blower_speed == :with_compressor || (0..12).include?(blower_speed)
+      unless blower_speed == :with_compressor || (0..12).cover?(blower_speed)
         raise ArgumentError,
               "blower speed must be :with_compressor or between 0 and 12"
       end
-      unless pump_speed == :with_compressor || (0..100).include?(pump_speed)
+      unless pump_speed == :with_compressor || (0..100).cover?(pump_speed)
         raise ArgumentError,
               "pump speed must be :with_compressor or between 0 and 100"
       end
@@ -273,7 +275,7 @@ module Aurora
     def inspect
       "#<Aurora::ABCClient #{(instance_variables - [:@modbus_slave]).map do |iv|
                                "#{iv}=#{instance_variable_get(iv).inspect}"
-                             end.join(', ')}>"
+                             end.join(", ")}>"
     end
   end
 end

data/lib/aurora/blower.rb

@@ -6,7 +6,7 @@ module Aurora
   module Blower
     class PSC < Component
       attr_reader :type, :watts, :running
-      alias running? running
+      alias_method :running?, :running
 
       def initialize(abc, type)
         super(abc)

data/lib/aurora/component.rb

@@ -9,7 +9,7 @@ module Aurora
     def inspect
       "#<Aurora::#{self.class.name} #{(instance_variables - [:@abc]).map do |iv|
                                         "#{iv}=#{instance_variable_get(iv).inspect}"
-                                      end.join(', ')}>"
+                                      end.join(", ")}>"
     end
 
     private

data/lib/aurora/compressor.rb

@@ -13,7 +13,7 @@ module Aurora
       end
 
       def type
-        "#{@stages == 2 ? 'Dual' : 'Single'} Stage Compressor"
+        "#{@stages == 2 ? "Dual" : "Single"} Stage Compressor"
       end
 
       def speed_range

data/lib/aurora/dhw.rb

@@ -5,7 +5,7 @@ require "aurora/component"
 module Aurora
   class DHW < Component
     attr_reader :enabled, :running, :set_point, :water_temperature
-    alias running? running
+    alias_method :running?, :running
 
     def registers_to_read
       [400..401, 1114]
@@ -23,7 +23,7 @@ module Aurora
     end
 
     def set_point=(value) # rubocop:disable Naming/AccessorMethodName
-      raise ArgumentError unless (100..140).include?(value)
+      raise ArgumentError unless (100..140).cover?(value)
 
       raw_value = (value * 10).to_i
       holding_registers[401] = raw_value

data/lib/aurora/humidistat.rb

@@ -5,10 +5,9 @@ require "aurora/component"
 module Aurora
   class Humidistat < Component
     attr_reader :humidifier_running, :humidifier_mode, :humidification_target,
-                :dehumidifier_running, :dehumidifier_mode, :dehumidification_target,
+                :dehumidifier_mode, :dehumidification_target,
                 :relative_humidity
-    alias humidifier_running? humidifier_running
-    alias dehumidifer_running? dehumidifier_running
+    alias_method :humidifier_running?, :humidifier_running
 
     def initialize(abc, has_humidifier, has_dehumidifier)
       super(abc)
@@ -24,6 +23,11 @@ module Aurora
       @dehumidifier
     end
 
+    def dehumidifier_running
+      dehumidifier? ? @dehumidifier_running : abc.current_mode == :dehumidify
+    end
+    alias_method :dehumidifier_running?, :dehumidifier_running
+
     def registers_to_read
       result = [741]
       if humidifier? || dehumidifier? || abc.compressor.is_a?(Compressor::VSDrive)
@@ -82,8 +86,8 @@ module Aurora
     end
 
     def set_humidistat_targets(humidification_target, dehumidification_target)
-      raise ArgumentError unless (15..50).include?(humidification_target)
-      raise ArgumentError unless (35..65).include?(dehumidification_target)
+      raise ArgumentError unless (15..50).cover?(humidification_target)
+      raise ArgumentError unless (35..65).cover?(dehumidification_target)
 
       holding_registers[abc.iz2? ? 21_115 : 12_310] = (humidification_target << 8) + dehumidification_target
       @humidification_target = humidification_target

data/lib/aurora/iz2_zone.rb

@@ -15,18 +15,18 @@ module Aurora
     end
 
     def registers_to_read
-      base1 = 21_203 + (zone_number - 1) * 9
-      base2 = 31_007 + (zone_number - 1) * 3
-      base3 = 31_200 + (zone_number - 1) * 3
+      base1 = 21_203 + ((zone_number - 1) * 9)
+      base2 = 31_007 + ((zone_number - 1) * 3)
+      base3 = 31_200 + ((zone_number - 1) * 3)
       [base1..(base1 + 1), base2..(base2 + 2), base3]
     end
 
     def refresh(registers)
-      @ambient_temperature = registers[31_007 + (zone_number - 1) * 3]
+      @ambient_temperature = registers[31_007 + ((zone_number - 1) * 3)]
 
-      config1 = registers[31_008 + (zone_number - 1) * 3]
-      config2 = registers[31_009 + (zone_number - 1) * 3]
-      config3 = registers[31_200 + (zone_number - 1) * 3]
+      config1 = registers[31_008 + ((zone_number - 1) * 3)]
+      config2 = registers[31_009 + ((zone_number - 1) * 3)]
+      config3 = registers[31_200 + ((zone_number - 1) * 3)]
 
       @target_fan_mode = config1[:fan]
       @fan_intermittent_on = config1[:on_time]
@@ -45,28 +45,28 @@ module Aurora
     def target_mode=(value)
       return unless (raw_value = Aurora::HEATING_MODE.invert[value])
 
-      holding_registers[21_202 + (zone_number - 1) * 9] = raw_value
+      holding_registers[21_202 + ((zone_number - 1) * 9)] = raw_value
       @target_mode = value
     end
 
     def target_fan_mode=(value)
       return unless (raw_value = Aurora::FAN_MODE.invert[value])
 
-      holding_registers[21_205 + (zone_number - 1) * 9] = raw_value
+      holding_registers[21_205 + ((zone_number - 1) * 9)] = raw_value
       @target_fan_mode = value
     end
 
     def fan_intermittent_on=(value)
       return unless value >= 0 && value <= 25 && (value % 5).zero?
 
-      holding_registers[21_206 + (zone_number - 1) * 9] = value
+      holding_registers[21_206 + ((zone_number - 1) * 9)] = value
       @fan_intermittent_on = value
     end
 
     def fan_intermittent_off=(value)
       return unless value >= 0 && value <= 40 && (value % 5).zero?
 
-      holding_registers[21_207 + (zone_number - 1) * 9] = value
+      holding_registers[21_207 + ((zone_number - 1) * 9)] = value
       @fan_intermittent_off = value
     end
 
@@ -74,7 +74,7 @@ module Aurora
       return unless value >= 40 && value <= 90
 
       raw_value = (value * 10).to_i
-      holding_registers[21_203 + (zone_number - 1) * 9] = raw_value
+      holding_registers[21_203 + ((zone_number - 1) * 9)] = raw_value
       @heating_target_temperature = value
     end
 
@@ -82,7 +82,7 @@ module Aurora
       return unless value >= 54 && value <= 99
 
       raw_value = (value * 10).to_i
-      holding_registers[21_204 + (zone_number - 1) * 9] = raw_value
+      holding_registers[21_204 + ((zone_number - 1) * 9)] = raw_value
       @cooling_target_temperature = value
     end
   end

data/lib/aurora/mock_abc.rb

@@ -44,6 +44,6 @@ module Aurora
     def write_holding_register(addr, value)
       @registers[addr] = value
     end
-    alias []= write_holding_register
+    alias_method :[]=, :write_holding_register
   end
 end

data/lib/aurora/modbus/slave.rb

@@ -4,14 +4,14 @@ module Aurora
   module ModBus
     module Slave
       def read_multiple_holding_registers(*ranges)
-        values = if ranges.any? { |r| r.is_a?(Range) }
+        values = if ranges.any?(Range)
                    addrs_and_lengths = ranges.map do |r|
                      r = Array(r)
                      [r.first, r.last - r.first + 1]
                    end.flatten
-                   query("A#{addrs_and_lengths.pack('n*')}").unpack("n*")
+                   query("A#{addrs_and_lengths.pack("n*")}").unpack("n*")
                  else
-                   query("B#{ranges.pack('n*')}").unpack("n*")
+                   query("B#{ranges.pack("n*")}").unpack("n*")
                  end
         ranges.map { |r| Array(r) }.flatten.zip(values).to_h
       end

data/lib/aurora/pump.rb

@@ -6,7 +6,7 @@ module Aurora
   module Pump
     class GenericPump < Component
       attr_reader :type, :watts, :waterflow, :running
-      alias running? running
+      alias_method :running?, :running
 
       def initialize(abc, type)
         super(abc)
@@ -28,7 +28,7 @@ module Aurora
 
     class VSPump < GenericPump
       attr_reader :speed, :minimum_speed, :maximum_speed, :manual_control
-      alias manual_control? manual_control
+      alias_method :manual_control?, :manual_control
 
       def registers_to_read
         super + [321..325]

data/lib/aurora/registers.rb

@@ -108,7 +108,7 @@ module Aurora
     48 => "EEV OD Comm Error", # Com with EEV is interupted EEV has gone independent mode
     49 => "Cabinet Temperature Sensor", # Ambient Temperature (Tamb) is <-76 or > 212 F and out of range or invalid
     51 => "Discharge Temp Sensor", # Discharge Sensor (Sd) is > 280 F or invalid (-76 to 392 F)
-    52 => "Suction Presure Sensor", # Suction Pressure (P0) is invalid (0 to 232 psi)
+    52 => "Suction Pressure Sensor", # Suction Pressure (P0) is invalid (0 to 232 psi)
     53 => "Condensing Pressure Sensor", # Low condensing pressure (PD) or invalid (0 to 870 psi) Retry 10x.
     54 => "Low Supply Voltage", # Supply Voltage is <180 V (190V to reset) or powered off/on too quickly (<30 sec.).
     55 => "Out of Envelope", # Comp Operating out of envelope (P0) more than 90 sec. Retry 10x.
@@ -550,7 +550,7 @@ module Aurora
   REGISTER_FORMATS = {
     "%ds" => [1, 6, 9, 15, 84, 85, 110],
     "%dV" => [16, 112, 3331, 3424, 3523],
-    "%0.1fºF" => [19, 20, 401, 501, 502, 567, 740, 745, 746, 747, 900, 903,
+    "%0.1f°F" => [19, 20, 401, 501, 502, 567, 740, 745, 746, 747, 900, 903,
                   1109, 1110, 1111, 1112, 1113, 1114, 1124, 1125, 1134, 1135, 1136,
                   3325, 3326, 3327, 3330, 3522, 3903, 3905, 3906,
                   12_619, 12_620,
@@ -587,9 +587,9 @@ module Aurora
 
   def zone_registers
     (1..6).map do |i|
-      base1 = 21_202 + (i - 1) * 9
-      base2 = 31_007 + (i - 1) * 3
-      base3 = 31_200 + (i - 1) * 3
+      base1 = 21_202 + ((i - 1) * 9)
+      base2 = 31_007 + ((i - 1) * 3)
+      base3 = 31_200 + ((i - 1) * 3)
       {
         base1 => "Zone #{i} Heating Mode (write)",
         (base1 + 1) => "Zone #{i} Heating Setpoint (write)",

data/lib/aurora/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aurora
-  VERSION = "0.6.4"
+  VERSION = "0.7.3"
 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.6.4
+  version: 0.7.3
 platform: ruby
 authors:
 - Cody Cutrer
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-09-08 00:00:00.000000000 Z
+date: 2021-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ccutrer-serialport
@@ -25,25 +25,25 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.0.0
 - !ruby/object:Gem::Dependency
-  name: homie-mqtt
+  name: mqtt-homeassistant
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '0.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.5
+        version: 0.1.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '0.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.5
+        version: 0.1.2
 - !ruby/object:Gem::Dependency
   name: net-telnet-rfc2217
   requirement: !ruby/object:Gem::Requirement
@@ -98,28 +98,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '9.0'
+        version: '11.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '9.0'
+        version: '11.0'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.19'
+        version: '1.23'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.19'
+        version: '1.23'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
 description: 
 email: cody@cutrer.com'
 executables:
@@ -157,7 +185,8 @@ files:
 homepage: https://github.com/ccutrer/waterfurnace_aurora
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths: