waterfurnace_aurora 0.8.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 288c8dbc14788d26473f14dcfaf388f75c8aee92c2f3b4d388bfa8326cfd2842
-  data.tar.gz: c06f92936c81e402d08e01ae6b8c6c573acca46a85c9630914cb3c69f125a56a
+  metadata.gz: d9f0f7d0f0c846720df96f8889d1d5952ece7e0dbabea3431484f4efbff06f5a
+  data.tar.gz: e82bc4400c9543322debe51a21da1dea54d07a673f7302e5ec2a2910e8229714
 SHA512:
-  metadata.gz: 5e64658afee912c8188af6d88bc98e208427b8dc4ef2ce1ea6ff1efcaca15ea2042ed4eef08ccfd764ec59ce0bb82013b0abd82173ec00f9ec61cbde07a66634
-  data.tar.gz: 6deff29644f83c329f1727d0a568c87536618ae63c7a27e58e4054eff187496c6f04bf3b63e2c35e649b2a0eb5b6395d81450a68b0096d1cacee9137c2f53c31
+  metadata.gz: eddd8d24b22c6a1c1c64c8fdd29f79c00c76145252b5ddbcd08cf2c7edd0f03182439cb9cf511041bc1a789823b421eefcb3ac90d3f5c72e6fcb54fdf88dc60d
+  data.tar.gz: 76b06de5f2ff979a0c4eaaf05998d4856aa01f491f80fc224870920319d9abda0c89c800a221d532f3c2ccb850c01217570d3f72b447af221186da18ed81fa84

data/exe/aurora_fetch

@@ -8,20 +8,31 @@ require "optparse"
 require "uri"
 require "yaml"
 
-debug_modbus = yaml = false
+debug_modbus = yaml = ignore_missing_registers = false
 try_individual = nil
 
 options = OptionParser.new do |opts|
   opts.banner = "Usage: aurora_fetch /path/to/serial/port REGISTERS [options]"
 
   opts.separator("")
-  opts.separator("Use `known` to fetch all identified registers. Use `valid` to fetch all registers that will respond.")
+  opts.separator(<<~TEXT)
+    Use `known` to fetch all identified registers. Use `valid` to fetch all registers
+    that should respond. Use `all` to search the entire ModBus address space. Note that
+    logging of current progress is only periodic, and does not log every register it's
+    trying to fetch.
+  TEXT
   opts.separator("")
 
-  opts.on("--debug-modbus", "Print actual protocol bytes") { debug_modbus = true }
+  opts.on("--debug-modbus", "Print actual protocol bytes") do
+    debug_modbus = true
+  end
   opts.on("--[no-]try-individual",
           "Query registers one-by-one if a range has an illegal address. " \
           "Defaults to true for `valid` and `known` special registers, false otherwise.") { |v| try_individual = v }
+  opts.on("--ignore-missing-registers",
+          "For YAML input only, just log a warning when a register doesn't exist, instead of failing") do
+            ignore_missing_registers = true
+          end
   opts.on("-y", "--yaml", "Output raw values as YAML") { yaml = true }
   opts.on("-v", "--version", "Print version") do
     puts Aurora::VERSION
@@ -40,11 +51,11 @@ unless ARGV.length == 2
   exit 1
 end
 
-modbus_slave = Aurora::ABCClient.open_modbus_slave(ARGV[0])
+modbus_slave = Aurora::ABCClient.open_modbus_slave(ARGV[0], ignore_missing_registers: ignore_missing_registers)
 modbus_slave.read_retry_timeout = 15
 modbus_slave.read_retries = 2
-modbus_slave.logger = Logger.new($stdout)
-modbus_slave.logger.level = debug_modbus ? :debug : :warn
+Aurora.logger = modbus_slave.logger = Logger.new($stderr)
+modbus_slave.logger.level = debug_modbus ? :debug : :info
 
 registers = Aurora::ABCClient.query_registers(modbus_slave, ARGV[1], try_individual: try_individual)
 

data/exe/aurora_mqtt_bridge

@@ -90,29 +90,33 @@ class MQTTBridge
     loop do
       begin
         @mutex.synchronize do
-          @abc.refresh
-
-          components = { @homie_abc => @abc,
-                         @compressor => @abc.compressor,
-                         @blower => @abc.blower,
-                         @pump => @abc.pump,
-                         @dhw => @abc.dhw,
-                         @humidistat => @abc.humidistat }.compact
-          @abc.zones.each_with_index do |z, idx|
-            homie_zone = @homie["zone#{idx + 1}"]
-            components[homie_zone] = z
-          end
+          @homie.mqtt.batch_publish do
+            @abc.refresh
+
+            components = { @homie_abc => @abc,
+                           @aux_heat => @abc.aux_heat,
+                           @compressor => @abc.compressor,
+                           @blower => @abc.blower,
+                           @pump => @abc.pump,
+                           @dhw => @abc.dhw,
+                           @humidistat => @abc.humidistat }.compact
+            @abc.zones.each_with_index do |z, idx|
+              homie_zone = @homie["zone#{idx + 1}"]
+              components[homie_zone] = z
+            end
 
-          components.each do |(node, object)|
-            node.each do |property|
-              property.value = object.public_send(property.id.tr("-", "_"))
+            components.each do |(node, object)|
+              node.each do |property|
+                property.value = object.public_send(property.id.tr("-", "_"))
+              end
             end
-          end
 
-          @abc.faults.each_with_index do |fault_count, i|
-            next if fault_count == 0xffff
+            @faults["current"].value = @abc.current_fault
+            @abc.faults.each_with_index do |fault_count, i|
+              next if fault_count == 0xffff
 
-            @faults["e#{i + 1}"].value = fault_count
+              @faults["e#{i + 1}"].value = fault_count
+            end
           end
         end
       rescue => e
@@ -131,7 +135,7 @@ class MQTTBridge
     }
 
     @homie_abc = @homie.node("abc", "Heat Pump", "ABC") do |node|
-      allowed_modes = %w[lockout standby blower heating cooling eh1 eh2 emergency waiting]
+      allowed_modes = %w[lockout standby blower heating heating_with_aux emergency_heat cooling waiting]
       allowed_modes << "dehumidify" if @abc.compressor.is_a?(Aurora::Compressor::VSDrive)
       node.property("current-mode",
                     "Current Heating/Cooling Mode",
@@ -139,6 +143,31 @@ class MQTTBridge
                     @abc.current_mode,
                     format: allowed_modes,
                     hass: { sensor: { state_class: :measurement } })
+      node.property("emergency-shutdown",
+                    "Emergency Shutdown Requested",
+                    :boolean,
+                    @abc.emergency_shutdown?,
+                    hass: :binary_sensor)
+      node.property("load-shed",
+                    "Load Shed Requested",
+                    :boolean,
+                    @abc.load_shed?,
+                    hass: :binary_sensor)
+      node.property("locked-out",
+                    "Is the heat pump currently locked out?",
+                    :boolean,
+                    @abc.locked_out?,
+                    hass: :binary_sensor)
+      node.property("derated",
+                    "Is the compressor currently running at a derated level?",
+                    :boolean,
+                    @abc.derated?,
+                    hass: :binary_sensor)
+      node.property("safe-mode",
+                    "Is the heat pump currently in safe mode?",
+                    :boolean,
+                    @abc.safe_mode?,
+                    hass: :binary_sensor)
       node.property("entering-air-temperature",
                     "Entering Air Temperature",
                     :float,
@@ -155,6 +184,17 @@ class MQTTBridge
                     hass: { sensor: { device_class: :temperature,
                                       state_class: :measurement,
                                       entity_category: :diagnostic } })
+      node.property("low-pressure-switch",
+                    "Low Pressure Switch Status",
+                    :enum,
+                    @abc.low_pressure_switch,
+                    format: %w[open closed])
+      node.property("high-pressure-switch",
+                    "High Pressure Switch Status",
+                    :enum,
+                    @abc.high_pressure_switch,
+                    format: %w[open closed])
+
       if @abc.awl_communicating?
         node.property("leaving-air-temperature",
                       "Leaving Air Temperature",
@@ -189,31 +229,22 @@ class MQTTBridge
                     :integer,
                     @abc.line_voltage,
                     format: 90..635,
-                    unit: "V") do |value, property|
-                      @mutex.synchronize { property.value = @abc.line_voltage = value }
+                    unit: "V") do |value|
+                      @mutex.synchronize { @abc.line_voltage = value }
                     end
-      node.property("fp1",
-                    "FP1 Sensor",
+      node.property("air-coil-temperature",
+                    "Air Coil Temperature (FP2)",
                     :float,
-                    @abc.fp1,
+                    @abc.air_coil_temperature,
                     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,
+      if @abc.energy_monitoring?
+        node.property("watts",
+                      "Total Power Usage",
                       :integer,
-                      @abc.public_send(component),
+                      @abc.watts,
                       unit: "W",
                       hass: { sensor: { device_class: :power,
                                         state_class: :measurement } })
@@ -227,6 +258,22 @@ class MQTTBridge
                     @abc.compressor.speed,
                     format: @abc.compressor.speed_range,
                     hass: { sensor: { state_class: :measurement } })
+      node.property("cooling-liquid-line-temperature",
+                    "Cooling Liquid Line Temperature (FP1)",
+                    :float,
+                    @abc.compressor.cooling_liquid_line_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("saturated-condensor-discharge-temperature",
+                    "Saturated Condensor Discharge Temperature",
+                    :float,
+                    @abc.compressor.saturated_condensor_discharge_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
       if @abc.energy_monitoring?
         node.property("watts",
                       "Power Usage",
@@ -247,6 +294,86 @@ class MQTTBridge
                     hass: { sensor: { device_class: :temperature,
                                       state_class: :measurement,
                                       entity_category: :diagnostic } })
+      node.property("drive-temperature",
+                    "Drive Temperature",
+                    :float,
+                    @abc.compressor.drive_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("inverter-temperature",
+                    "Inverter Temperature",
+                    :float,
+                    @abc.compressor.inverter_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("fan-speed",
+                    "Fan Speed",
+                    :integer,
+                    @abc.compressor.fan_speed,
+                    unit: "%",
+                    format: 0..100,
+                    hass: { sensor: { state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("discharge-temperature",
+                    "Discharge Temperature",
+                    :float,
+                    @abc.compressor.discharge_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("discharge-pressure",
+                    "Discharge Pressure",
+                    :float,
+                    @abc.compressor.discharge_pressure,
+                    unit: "psi",
+                    hass: { sensor: { device_class: :pressure,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("suction-temperature",
+                    "Suction Temperature",
+                    :float,
+                    @abc.compressor.suction_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("suction-pressure",
+                    "Suction Pressure",
+                    :float,
+                    @abc.compressor.suction_pressure,
+                    unit: "psi",
+                    hass: { sensor: { device_class: :pressure,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("saturated-evaporator-discharge-temperature",
+                    "Saturated Evaporator Discharge Temperature",
+                    :float,
+                    @abc.compressor.saturated_evaporator_discharge_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("superheat-temperature",
+                    "SuperHeat Temperature",
+                    :float,
+                    @abc.compressor.superheat_temperature,
+                    unit: "°F",
+                    hass: { sensor: { device_class: :temperature,
+                                      state_class: :measurement,
+                                      entity_category: :diagnostic } })
+      node.property("superheat-percentage",
+                    "SuperHeat Percentage",
+                    :integer,
+                    @abc.compressor.superheat_percentage,
+                    unit: "%",
+                    format: 0..100,
+                    hass: { sensor: { state_class: :measurement,
+                                      entity_category: :diagnostic } })
 
       next unless @abc.iz2?
 
@@ -259,6 +386,25 @@ class MQTTBridge
                                       entity_category: :diagnostic } })
     end
 
+    @aux_heat = @homie.node("aux-heat", "Aux Heater", "Aux Heater") do |node|
+      node.property("stage",
+                    "Current Stage",
+                    :integer,
+                    @abc.aux_heat.stage,
+                    format: 0..2,
+                    hass: { sensor: { state_class: :measurement } })
+
+      if @abc.energy_monitoring?
+        node.property("watts",
+                      "Power Usage",
+                      :integer,
+                      @abc.aux_heat.watts,
+                      unit: "W",
+                      hass: { sensor: { device_class: :power,
+                                        state_class: :measurement } })
+      end
+    end
+
     @blower = @homie.node("blower", "Blower", @abc.blower.type) do |node|
       node.property("running",
                     "Running",
@@ -294,8 +440,8 @@ class MQTTBridge
                       :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) }
+                      hass: { number: { entity_category: :config } }) do |value|
+          @mutex.synchronize { @abc.blower.public_send("#{field}=", value) }
         end
       end
 
@@ -340,8 +486,8 @@ class MQTTBridge
                     "Manual Control",
                     :boolean,
                     @abc.pump.manual_control?,
-                    hass: { switch: { entity_category: :diagnostic } }) do |value, property|
-        @mutex.synchronize { property.value = @abc.pump.manual_control = value }
+                    hass: { switch: { entity_category: :diagnostic } }) do |value|
+        @mutex.synchronize { @abc.pump.manual_control = value }
       end
       node.property("minimum-speed",
                     "Actual Minimum Speed",
@@ -349,8 +495,8 @@ class MQTTBridge
                     @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 }
+                    hass: { number: { entity_category: :config } }) do |value|
+        @mutex.synchronize { @abc.pump.minimum_speed = value }
       end
       node.property("maximum-speed",
                     "Actual Maximum Speed",
@@ -358,8 +504,8 @@ class MQTTBridge
                     @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 }
+                    hass: { number: { entity_category: :config } }) do |value|
+        @mutex.synchronize { @abc.pump.maximum_speed = value }
       end
       next unless @abc.awl_axb?
 
@@ -369,8 +515,8 @@ class MQTTBridge
                     @abc.pump.speed,
                     format: 0..100,
                     unit: "%",
-                    hass: { number: { entity_category: :diagnostic } }) do |value, property|
-        @mutex.synchronize { property.value = @abc.pump.speed = value }
+                    hass: { number: { entity_category: :diagnostic } }) do |value|
+        @mutex.synchronize { @abc.pump.speed = value }
       end
     end
 
@@ -380,8 +526,8 @@ class MQTTBridge
                       "Enabled",
                       :boolean,
                       @abc.dhw.enabled,
-                      hass: { switch: { icon: "mdi:water-boiler" } }) do |value, property|
-          @mutex.synchronize { property.value = @abc.dhw.enabled = value }
+                      hass: { switch: { icon: "mdi:water-boiler" } }) do |value|
+          @mutex.synchronize { @abc.dhw.enabled = value }
         end
         node.property("running",
                       "Pump Running",
@@ -401,8 +547,8 @@ class MQTTBridge
                       @abc.dhw.set_point,
                       format: 100..140,
                       unit: "°F",
-                      hass: { number: { step: 5 } }) do |value, property|
-          @mutex.synchronize { property.value = @abc.dhw.set_point = value }
+                      hass: { number: { step: 5 } }) do |value|
+          @mutex.synchronize { @abc.dhw.set_point = value }
         end
       end
     end
@@ -418,16 +564,16 @@ class MQTTBridge
                         "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 }
+                        format: %i[auto manual]) do |value|
+            @mutex.synchronize { @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|
-            @mutex.synchronize { property.value = @abc.humidistat.humidification_target = value }
+                        format: 15..50) do |value|
+            @mutex.synchronize { @abc.humidistat.humidification_target = value }
           end
           node.hass_humidifier("humidifier-running",
                                target_property: "humidification-target",
@@ -450,16 +596,16 @@ class MQTTBridge
                         "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 }
+                        format: %i[auto manual]) do |value|
+            @mutex.synchronize { @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|
-            @mutex.synchronize { property.value = @abc.humidistat.dehumidification_target = value }
+                        format: 35..65) do |value|
+            @mutex.synchronize { @abc.humidistat.dehumidification_target = value }
           end
           node.hass_humidifier("dehumidifier-running",
                                target_property: "dehumidification-target",
@@ -482,6 +628,12 @@ class MQTTBridge
     end
 
     @faults = @homie.node("faults", "Fault History", "ABC") do |node|
+      node.property("current",
+                    "Current fault",
+                    :integer,
+                    @abc.current_fault,
+                    format: 0..99,
+                    hass: :sensor)
       node.property("clear-history",
                     "Reset Fault Counts",
                     :enum,
@@ -520,15 +672,15 @@ class MQTTBridge
                       "Target Heating/Cooling Mode",
                       :enum,
                       zone.target_mode,
-                      format: allowed_modes) do |value, property|
-          @mutex.synchronize { property.value = zone.target_mode = value.to_sym }
+                      format: allowed_modes) do |value|
+          @mutex.synchronize { zone.target_mode = value.to_sym }
         end
         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 }
+                      format: %w[auto continuous intermittent]) do |value|
+          @mutex.synchronize { zone.target_fan_mode = value.to_sym }
         end
         node.property("fan-intermittent-on",
                       "Fan Intermittent Mode On Duration",
@@ -536,8 +688,8 @@ class MQTTBridge
                       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 }
+                      hass: { select: { entity_category: :config } }) do |value|
+          @mutex.synchronize { zone.fan_intermittent_on = value.to_i }
         end
         node.property("fan-intermittent-off",
                       "Fan Intermittent Mode Off Duration",
@@ -545,8 +697,8 @@ class MQTTBridge
                       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 }
+                      hass: { select: { entity_category: :config } }) do |value|
+          @mutex.synchronize { zone.fan_intermittent_on = value.to_i }
         end
         node.property("current-fan-mode",
                       "Current Fan Status",
@@ -587,15 +739,15 @@ class MQTTBridge
                       :integer,
                       zone.heating_target_temperature,
                       unit: "°F",
-                      format: 40..90) do |value, property|
-          @mutex.synchronize { property.value = zone.heating_target_temperature = value }
+                      format: 40..90) do |value|
+          @mutex.synchronize { 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|
-          @mutex.synchronize { property.value = zone.cooling_target_temperature = value }
+                      format: 54..99) do |value|
+          @mutex.synchronize { zone.cooling_target_temperature = value }
         end
         node.hass_climate(action_property: "current-mode",
                           current_temperature_property: "ambient-temperature",
@@ -626,12 +778,12 @@ class MQTTBridge
 end
 
 log_level = ARGV.include?("--debug") ? :debug : :warn
-logger = Logger.new($stdout)
-logger.level = log_level
-abc.modbus_slave.logger = logger
+Aurora.logger = Logger.new($stdout)
+Aurora.logger.level = log_level
+abc.modbus_slave.logger = Aurora.logger
 
 device = "aurora-#{abc.serial_number}"
 homie = MQTT::Homie::Device.new(device, "WaterFurnace", mqtt: mqtt_uri)
-homie.logger = logger
+homie.logger = Aurora.logger
 
 MQTTBridge.new(abc, homie)

data/exe/web_aid_tool

@@ -7,13 +7,17 @@ require "logger"
 require "optparse"
 require "yaml"
 
-debug_modbus = monitor = false
+debug_modbus = monitor = ignore_missing_registers = false
 
 options = OptionParser.new do |opts|
   opts.banner = "Usage: web_aid_tool /path/to/serial/port [options]"
 
   opts.on("--debug-modbus", "Print actual protocol bytes") { debug_modbus = true }
   opts.on("--monitor", "Print interpreted registers as they are requested, like aurora_monitor") { monitor = true }
+  opts.on("--ignore-missing-registers",
+          "For YAML input only, just log a warning when a register doesn't exist, instead of failing") do
+    ignore_missing_registers = true
+  end
   opts.on("-v", "--version", "Print version") do
     puts Aurora::VERSION
     exit
@@ -31,7 +35,7 @@ unless ARGV.length == 1
   exit 1
 end
 
-slave = Aurora::ABCClient.open_modbus_slave(ARGV[0])
+slave = Aurora::ABCClient.open_modbus_slave(ARGV[0], ignore_missing_registers: ignore_missing_registers)
 slave.logger = Logger.new($stdout)
 slave.logger.level = debug_modbus ? :debug : :warn
 

data/lib/aurora/abc_client.rb

@@ -3,6 +3,7 @@
 require "yaml"
 require "uri"
 
+require "aurora/aux_heat"
 require "aurora/blower"
 require "aurora/compressor"
 require "aurora/dhw"
@@ -14,7 +15,7 @@ require "aurora/thermostat"
 module Aurora
   class ABCClient
     class << self
-      def open_modbus_slave(uri)
+      def open_modbus_slave(uri, ignore_missing_registers: false)
         uri = URI.parse(uri)
 
         io = case uri.scheme
@@ -31,7 +32,10 @@ module Aurora
                require "aurora/mqtt_modbus"
                return Aurora::MQTTModBus.new(uri)
              else
-               return Aurora::MockABC.new(YAML.load_file(uri.path)) if File.file?(uri.path)
+               if File.file?(uri.path)
+                 return Aurora::MockABC.new(YAML.load_file(uri.path),
+                                            ignore_missing_registers: ignore_missing_registers)
+               end
 
                require "ccutrer-serialport"
                CCutrer::SerialPort.new(uri.path, baud: 19_200, parity: :even)
@@ -53,6 +57,10 @@ module Aurora
             implicit = true
             try_individual = true if try_individual.nil?
             break Aurora::REGISTER_RANGES
+          when "all"
+            implicit = true
+            try_individual = true if try_individual.nil?
+            break 0..65_535
           when /^(\d+)(?:\.\.|-)(\d+)$/
             $1.to_i..$2.to_i
           else
@@ -61,28 +69,48 @@ module Aurora
         end
         queries = Aurora.normalize_ranges(ranges)
         registers = {}
+        last_log_time = nil
         queries.each do |subquery|
+          last_log_time = log_query(last_log_time, subquery.inspect)
           registers.merge!(modbus_slave.read_multiple_holding_registers(*subquery))
-        rescue ::ModBus::Errors::IllegalDataAddress, ::ModBus::Errors::IllegalFunction
+        rescue ::ModBus::Errors::IllegalDataAddress, ::ModBus::Errors::IllegalFunction, ::ModBus::Errors::ModBusTimeout
           # maybe this unit doesn't respond to all the addresses we want?
           raise unless implicit
 
           # try each query individually
           subquery.each do |subsubquery|
+            last_log_time = log_query(last_log_time, subsubquery.inspect)
             registers.merge!(modbus_slave.read_multiple_holding_registers(subsubquery))
-          rescue ::ModBus::Errors::IllegalDataAddress, ::ModBus::Errors::IllegalFunction
+          rescue ::ModBus::Errors::IllegalDataAddress,
+                 ::ModBus::Errors::IllegalFunction,
+                 ::ModBus::Errors::ModBusTimeout => e
+            raise if e.is_a?(::ModBus::Errors::ModBusTimeout) && !try_individual
             next unless try_individual
 
             # seriously?? try each register individually
-            subsubquery.each do |i|
+            Array(subsubquery).each do |i|
+              last_log_time = log_query(last_log_time, i.to_s)
               registers[i] = modbus_slave.holding_registers[i]
             rescue ::ModBus::Errors::IllegalDataAddress, ::ModBus::Errors::IllegalFunction
+              # don't catch ModBusTimeout here... it should have no problem responding to a single register request
               next
             end
           end
         end
         registers
       end
+
+      private
+
+      def log_query(last_log_time, query)
+        last_log_time ||= Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        if now - last_log_time > 5
+          Aurora&.logger&.info("Fetching register(s) #{query}...")
+          last_log_time = now
+        end
+        last_log_time
+      end
     end
 
     attr_reader :modbus_slave,
@@ -90,23 +118,36 @@ module Aurora
                 :model,
                 :serial_number,
                 :zones,
+                :aux_heat,
                 :compressor,
                 :blower,
                 :pump,
                 :dhw,
                 :humidistat,
+                :current_fault,
                 :faults,
+                :locked_out,
+                :derated,
+                :safe_mode,
                 :current_mode,
+                :low_pressure_switch,
+                :high_pressure_switch,
+                :emergency_shutdown,
+                :load_shed,
                 :entering_air_temperature,
                 :leaving_air_temperature,
                 :leaving_water_temperature,
                 :entering_water_temperature,
                 :outdoor_temperature,
-                :fp1,
-                :fp2,
+                :air_coil_temperature,
                 :line_voltage,
-                :aux_heat_watts,
-                :total_watts
+                :watts
+
+    alias_method :emergency_shutdown?, :emergency_shutdown
+    alias_method :load_shed?, :load_shed
+    alias_method :locked_out?, :locked_out
+    alias_method :derated?, :derated
+    alias_method :safe_mode?, :safe_mode
 
     def initialize(uri)
       @modbus_slave = self.class.open_modbus_slave(uri)
@@ -129,6 +170,7 @@ module Aurora
 
       @abc_dipswitches = registers[33]
       @axb_dipswitches = registers[1103]
+      @aux_heat = AuxHeat.new(self)
       @compressor = if @program == "ABCVSP"
                       Compressor::VSDrive.new(self)
                     else
@@ -154,13 +196,15 @@ module Aurora
 
       @faults = []
 
-      @registers_to_read = [6, 19..20, 25, 30, 112, 344, 567, 1104, 1110..1111, 1114, 1150..1153, 1165]
+      @entering_air_register = awl_axb? ? 740 : 567
+      @registers_to_read = [6, 19..20, 25, 30..31, 112, 344, @entering_air_register, 1104, 1110..1111, 1114, 1150..1153,
+                            1165]
       @registers_to_read.concat([741, 31_003]) if awl_communicating?
       @registers_to_read << 900 if awl_axb?
       zones.each do |z|
         @registers_to_read.concat(z.registers_to_read)
       end
-      @components = [compressor, blower, pump, dhw, humidistat].compact
+      @components = [aux_heat, compressor, blower, pump, dhw, humidistat].compact
       @components.each do |component|
         @registers_to_read.concat(component.registers_to_read)
       end
@@ -181,34 +225,40 @@ module Aurora
 
       outputs = registers[30]
 
-      @entering_air_temperature   = registers[567]
+      @entering_air_temperature   = registers[@entering_air_register]
       @leaving_air_temperature    = registers[900] if awl_axb?
       @leaving_water_temperature  = registers[1110]
       @entering_water_temperature = registers[1111]
       @outdoor_temperature        = registers[31_003]
-      @fp1                        = registers[19]
-      @fp2                        = registers[20]
-      @locked_out                 = registers[25] & 0x8000
-      @error                      = registers[25] & 0x7fff
-      @derated                    = (41..46).cover?(@error)
-      @safe_mode                  = [47, 48, 49, 72, 74].include?(@error)
+      @air_coil_temperature       = registers[20]
+      @locked_out                 = !(registers[25] & 0x8000).zero?
+      @current_fault              = registers[25] & 0x7fff
+      @derated                    = (41..46).cover?(@current_fault)
+      @safe_mode                  = [47, 48, 49, 72, 74].include?(@current_fault)
+      @low_pressure_switch        = registers[31][:lps]
+      @high_pressure_switch       = registers[31][:hps]
+      @emergency_shutdown         = !!registers[31][:emergency_shutdown]
+      @load_shed                  = !!registers[31][:load_shed]
       @line_voltage               = registers[112]
-      @aux_heat_watts             = registers[1151]
-      @total_watts                = registers[1153]
+      @watts                      = registers[1153]
 
       @current_mode = if outputs.include?(:lockout)
                         :lockout
                       elsif registers[362]
                         :dehumidify
                       elsif outputs.include?(:cc2) || outputs.include?(:cc)
-                        outputs.include?(:rv) ? :cooling : :heating
-                      elsif outputs.include?(:eh2)
-                        outputs.include?(:rv) ? :eh2 : :emergency
-                      elsif outputs.include?(:eh1)
-                        outputs.include?(:rv) ? :eh1 : :emergency
+                        if outputs.include?(:rv)
+                          :cooling
+                        elsif outputs.include?(:eh2) || outputs.include?(:eh1)
+                          :heating_with_aux
+                        else
+                          :heating
+                        end
+                      elsif outputs.include?(:eh2) || outputs.include?(:eh1)
+                        :emergency_heat
                       elsif outputs.include?(:blower)
                         :blower
-                      elsif registers[6]
+                      elsif !registers[6].zero?
                         :waiting
                       else
                         :standby

data/lib/aurora/aux_heat.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "aurora/component"
+
+module Aurora
+  class AuxHeat < Component
+    attr_reader :stage, :watts
+
+    def refresh(registers)
+      outputs = registers[30]
+      @stage = if outputs.include?(:eh2)
+                 2
+               elsif outputs.include?(:eh1)
+                 1
+               else
+                 0
+               end
+      @watts = registers[1151] if abc.energy_monitoring?
+    end
+  end
+end

data/lib/aurora/blower.rb

@@ -36,7 +36,7 @@ module Aurora
 
       def refresh(registers)
         outputs = registers[30]
-        @speed = if outputs.include?(:eh1)
+        @speed = if outputs.include?(:eh1) || outputs.include?(:eh2)
                    4
                  elsif outputs.include?(:cc2)
                    3

data/lib/aurora/component.rb

@@ -6,6 +6,10 @@ module Aurora
       @abc = abc
     end
 
+    def registers_to_read
+      []
+    end
+
     def inspect
       "#<Aurora::#{self.class.name} #{(instance_variables - [:@abc]).map do |iv|
                                         "#{iv}=#{instance_variable_get(iv).inspect}"

data/lib/aurora/compressor.rb

@@ -5,7 +5,7 @@ require "aurora/component"
 module Aurora
   module Compressor
     class GenericCompressor < Component
-      attr_reader :speed, :watts
+      attr_reader :speed, :watts, :cooling_liquid_line_temperature, :saturated_condensor_discharge_temperature
 
       def initialize(abc, stages)
         super(abc)
@@ -21,11 +21,9 @@ module Aurora
       end
 
       def registers_to_read
-        if abc.energy_monitoring?
-          [1146..1147]
-        else
-          []
-        end
+        result = [19, 1134]
+        result << (1146..1147) if abc.energy_monitoring?
+        result
       end
 
       def refresh(registers)
@@ -37,12 +35,25 @@ module Aurora
                  else
                    0
                  end
+        @cooling_liquid_line_temperature = registers[19]
+        @saturated_condensor_discharge_temperature = registers[1134]
         @watts = registers[1146] if abc.energy_monitoring?
       end
     end
 
     class VSDrive < GenericCompressor
-      attr_reader :ambient_temperature, :iz2_desired_speed
+      attr_reader :drive_temperature,
+                  :inverter_temperature,
+                  :ambient_temperature,
+                  :iz2_desired_speed,
+                  :fan_speed,
+                  :discharge_pressure,
+                  :discharge_temperature,
+                  :suction_pressure,
+                  :suction_temperature,
+                  :saturated_evaporator_discharge_temperature,
+                  :superheat_temperature,
+                  :superheat_percentage
 
       def initialize(abc)
         super(abc, 12)
@@ -53,7 +64,7 @@ module Aurora
       end
 
       def registers_to_read
-        result = super + [209, 3001, 3326]
+        result = super + [209, 3001, 3322..3327, 3522, 3524, 3808, 3903..3906]
         result << 564 if abc.iz2?
         result
       end
@@ -62,7 +73,18 @@ module Aurora
         super
 
         @speed = registers[3001]
+        @discharge_pressure = registers[3322]
+        @suction_pressure = registers[3323]
+        @discharge_temperature = registers[3325]
         @ambient_temperature = registers[3326]
+        @drive_temperature = registers[3327]
+        @inverter_temperature = registers[3522]
+        @fan_speed = registers[3524]
+        @superheat_percentage = registers[3808]
+        @suction_temperature = registers[3903]
+        @saturated_evaporator_discharge_temperature = registers[3905]
+        @superheat_temperature = registers[3906]
+
         @iz2_desired_speed = registers[564] if abc.iz2?
       end
     end

data/lib/aurora/dhw.rb

@@ -27,7 +27,6 @@ module Aurora
 
       raw_value = (value * 10).to_i
       holding_registers[401] = raw_value
-      @set_point = value
     end
   end
 end

data/lib/aurora/humidistat.rb

@@ -75,8 +75,6 @@ module Aurora
       raw_value |= 0x4000 if humidifier_mode == :auto
       raw_value |= 0x8000 if dehumidifier_mode == :auto
       holding_registers[abc.iz2? ? 21_114 : 12_309] = raw_value
-      @humidifier_mode = humidifier_mode
-      @dehumidifier_mode = dehumidifier_mode
     end
 
     def humidification_target=(value)
@@ -92,8 +90,6 @@ module Aurora
       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
-      @dehumidification_target = dehumidification_target
     end
   end
 end

data/lib/aurora/iz2_zone.rb

@@ -46,28 +46,24 @@ module Aurora
       return unless (raw_value = Aurora::HEATING_MODE.invert[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
-      @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
-      @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
-      @fan_intermittent_off = value
     end
 
     def heating_target_temperature=(value)
@@ -75,7 +71,6 @@ module Aurora
 
       raw_value = (value * 10).to_i
       holding_registers[21_203 + ((zone_number - 1) * 9)] = raw_value
-      @heating_target_temperature = value
     end
 
     def cooling_target_temperature=(value)
@@ -83,7 +78,6 @@ module Aurora
 
       raw_value = (value * 10).to_i
       holding_registers[21_204 + ((zone_number - 1) * 9)] = raw_value
-      @cooling_target_temperature = value
     end
   end
 end

data/lib/aurora/mock_abc.rb

@@ -4,7 +4,8 @@ module Aurora
   class MockABC
     attr_accessor :logger
 
-    def initialize(registers)
+    def initialize(registers, ignore_missing_registers: false)
+      @ignore_missing_registers = ignore_missing_registers
       @registers = registers
     end
 
@@ -59,6 +60,8 @@ module Aurora
     private
 
     def missing_register(idx)
+      raise ::ModBus::Errors::IllegalDataAddress unless @ignore_missing_registers
+
       logger.warn("missing register #{idx}")
     end
   end

data/lib/aurora/registers.rb

@@ -60,6 +60,7 @@ module Aurora
   end
 
   def to_int32(registers, idx)
+    Aurora&.logger&.warn("Missing register #{idx + 1}") unless registers[idx + 1]
     (registers[idx] << 16) + registers[idx + 1]
   end
 
@@ -229,6 +230,8 @@ module Aurora
     0x08 => :blower,
     0x10 => :eh1,
     0x20 => :eh2,
+    # 0x40 => ??, # this turns on and off quite a bit during normal operation
+    # 0x80 => ??, # this turns on occasionally during normal operation; I've only seen it when aux heat is on
     0x200 => :accessory,
     0x400 => :lockout,
     0x800 => :alarm
@@ -703,10 +706,11 @@ module Aurora
     9 => "Compressor Minimum Run Time",
     15 => "Blower Off Delay",
     16 => "Line Voltage",
-    17 => "Aux/E Heat Stage", # this has some complicated condition based on
-    # current inputs and outputs on if it should have a value (310 - v) or (130 - v), or be 0
-    19 => "FP1 (Cooling Liquid Line) Temperature",
-    20 => "FP2",
+    17 => "Aux/E Heat Stage", # this is how long aux/eheat have been requested in seconds
+    # when in eheat mode (explicit on the thermostat), it will stage up to eh2 after 130s
+    # when in aux mode (thermostat set to heat; compressor at full capacity), it will stage up to eh2 after 310s
+    19 => "Cooling Liquid Line Temperature (FP1)",
+    20 => "Air Coil Temperature (FP2)",
     21 => "Condensate", # >= 270 normal, otherwise fault
     25 => "Last Fault Number", # high bit set if locked out
     26 => "Last Lockout",
@@ -867,11 +871,11 @@ module Aurora
     3225 => "VS Drive Details (Safemode 2)",
     3226 => "VS Drive Details (Alarm 1)",
     3227 => "VS Drive Details (Alarm 2)",
-    3327 => "VS Drive Temperature",
     3322 => "VS Drive Discharge Pressure",
     3323 => "VS Drive Suction Pressure",
     3325 => "VS Drive Discharge Temperature",
     3326 => "VS Drive Compressor Ambient Temperature",
+    3327 => "VS Drive Temperature",
     3330 => "VS Drive Entering Water Temperature",
     3331 => "VS Drive Line Voltage",
     3332 => "VS Drive Thermo Power",

data/lib/aurora/thermostat.rb

@@ -15,9 +15,9 @@ module Aurora
                 :fan_intermittent_off
 
     def registers_to_read
-      return [31] unless @abc.awl_thermostat?
+      return [] unless @abc.awl_thermostat?
 
-      [31, 502, 745..746, 12_005..12_006]
+      [502, 745..746, 12_005..12_006]
     end
 
     def refresh(registers)
@@ -48,14 +48,12 @@ module Aurora
       return unless (raw_value = HEATING_MODE.invert[value])
 
       @abc.modbus_slave.holding_registers[12_606] = raw_value
-      @target_mode = value
     end
 
     def target_fan_mode=(value)
       return unless (raw_value = FAN_MODE.invert[value])
 
       @abc.modbus_slave.holding_registers[12_621] = raw_value
-      @target_fan_mode = value
     end
 
     def heating_target_temperature=(value)
@@ -63,7 +61,6 @@ module Aurora
 
       raw_value = (value * 10).to_i
       @abc.modbus_slave.holding_registers[12_619] = raw_value
-      @heating_target_temperature = value
     end
 
     def cooling_target_temperature=(value)
@@ -71,21 +68,18 @@ module Aurora
 
       raw_value = (value * 10).to_i
       @abc.modbus_slave.holding_registers[12_620] = raw_value
-      @cooling_target_temperature = value
     end
 
     def fan_intermittent_on=(value)
       return unless value >= 0 && value <= 25 && (value % 5).zero?
 
       holding_registers[12_622] = value
-      @fan_intermittent_on = value
     end
 
     def fan_intermittent_off=(value)
       return unless value >= 0 && value <= 40 && (value % 5).zero?
 
       holding_registers[12_623] = value
-      @fan_intermittent_off = value
     end
   end
 end

data/lib/aurora/version.rb

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

data/lib/aurora.rb

@@ -15,4 +15,7 @@ ModBus::Client::Slave.prepend(Aurora::ModBus::Slave)
 ModBus::RTUSlave.prepend(Aurora::ModBus::RTU)
 
 module Aurora
+  class << self
+    attr_accessor :logger
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: waterfurnace_aurora
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Cody Cutrer
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-27 00:00:00.000000000 Z
+date: 2022-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ccutrer-serialport
@@ -166,6 +166,7 @@ files:
 - exe/web_aid_tool
 - lib/aurora.rb
 - lib/aurora/abc_client.rb
+- lib/aurora/aux_heat.rb
 - lib/aurora/blower.rb
 - lib/aurora/component.rb
 - lib/aurora/compressor.rb