waterfurnace_aurora 0.3.12 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdebb583f3d84e8f1c050e21ac205d29bba5d29d91cb14de2c106a5de26917cd
-  data.tar.gz: 64f7a0b749c050e0041e34d6682f1428320b8bc3762532c62b825f43ff4c40b7
+  metadata.gz: 0e43967c61aa8b5c445ec2a6024e9da5ba8cc94205cc853ff07fed0374827dc3
+  data.tar.gz: 875004f5c9835f25f7c18d7e7e7d632f0877db6ac7a3fc8215fa28b68c5ce2b9
 SHA512:
-  metadata.gz: 8ec3c74f737e3d38fd593831246e1153ab2ec5eef39a488aaac43c2c22bf5df92e9e613157e1b101c6af2008d451f3513b3e47a6badae0a01b966d4ed87bc3ee
-  data.tar.gz: 3973f340af41d8645de59291245d599a9d7993691249ad9d0b4b7b7582a11ee5d5f95d8c11493ba1be8d9f7611e755e33e6778114bb14a5197eacb9bac16f119
+  metadata.gz: f5d48422906f8dbac8aa83645ab3f46a9481f96d7e4720b75772dfbf2be2cf8456753f5d364a4cde3ad69fb778fd3ba29f23249ec08010806339039264bcbefc
+  data.tar.gz: 3a78e33d93f256e0153ae98b7f8df92da2f3138c246e1b5ef47550f4759d5502725a1d52acb6fe3f084b8a158962538ed73a3c1acf072cc151bf18ad9db2f75d

data/exe/aurora_fetch

@@ -28,28 +28,10 @@ unless ARGV.length == 2
   exit 1
 end
 
-uri = URI.parse(ARGV[0])
-
-args = case uri.scheme
-       when "tcp"
-         require "socket"
-         [TCPSocket.new(uri.host, uri.port)]
-       when "telnet", "rfc2217"
-         require "net/telnet/rfc2217"
-         [Net::Telnet::RFC2217.new(uri.host,
-                                   port: uri.port || 23,
-                                   baud: 19_200,
-                                   parity: :even)]
-       else
-         [CCutrer::SerialPort.new(uri.path, baud: 19_200, parity: :even)]
-       end
-
-client = ModBus::RTUClient.new(*args)
-client.logger = Logger.new($stdout)
-client.logger.level = debug_modbus ? :debug : :warn
-
-slave = client.with_slave(1)
-abc = Aurora::ABCClient.new(slave)
+abc = Aurora::ABCClient.new(ARGV[0])
+abc.modbus_slave.logger = Logger.new($stdout)
+abc.modbus_slave.logger.level = debug_modbus ? :debug : :warn
+
 registers = abc.query_registers(ARGV[1])
 
 if yaml

data/exe/aurora_mock

@@ -2,29 +2,29 @@
 # frozen_string_literal: true
 
 require "aurora"
-require "ccutrer-serialport"
 require "uri"
 require "yaml"
 
 uri = URI.parse(ARGV[0])
 
-args = case uri.scheme
-       when "tcp"
-         require "socket"
-         [TCPSocket.new(uri.host, uri.port)]
-       when "telnet", "rfc2217"
-         require "net/telnet/rfc2217"
-         [Net::Telnet::RFC2217.new(uri.host,
-                                   port: uri.port || 23,
-                                   baud: 19_200,
-                                   parity: :even)]
-       else
-         [CCutrer::SerialPort.new(uri.path, baud: 19_200, parity: :even)]
-       end
+io = case uri.scheme
+     when "tcp"
+       require "socket"
+       TCPSocket.new(uri.host, uri.port)
+     when "telnet", "rfc2217"
+       require "net/telnet/rfc2217"
+       Net::Telnet::RFC2217.new(uri.host,
+                                port: uri.port || 23,
+                                baud: 19_200,
+                                parity: :even)
+     else
+       require "ccutrer-serialport"
+       CCutrer::SerialPort.new(uri.path, baud: 19_200, parity: :even)
+     end
 
 port = ARGV[1]&.to_i || 502
 
-server1 = ModBus::RTUServer.new(*args)
+server1 = ModBus::RTUServer.new(io)
 server1.logger = Logger.new($stdout, :debug)
 # AID Tool queries slave 1, AWL queries slave 2; just use both
 slave1 = server1.with_slave(1)
@@ -35,7 +35,7 @@ slave255 = server2.with_slave(255)
 r = slave1.holding_registers = slave2.holding_registers = slave255.holding_registers = Array.new(31_473, 0)
 
 # prepopulate some data
-registers = YAML.safe_load(File.read(File.expand_path("registers.yml", __dir__)))
+registers = YAML.safe_load(File.read(ARGV[2]))
 registers.each { |(k, v)| r[k] = v }
 
 server1.request_callback = lambda { |uid, func, req|

data/exe/aurora_monitor

@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 require "aurora"
-require "ccutrer-serialport"
 require "logger"
 require "optparse"
 require "socket"
@@ -10,7 +9,7 @@ require "uri"
 
 diff_only = debug_modbus = ignore_awl_heartbeat = ignore_sensors = false
 
-OptionParser.new do |opts|
+options = OptionParser.new do |opts|
   opts.banner = "Usage: aurora_monitor /path/to/serial/port [options]"
 
   opts.on("-q", "--quiet",
@@ -27,7 +26,14 @@ OptionParser.new do |opts|
     puts opts
     exit
   end
-end.parse!
+end
+
+options.parse!
+
+unless ARGV.length == 2
+  puts options
+  exit 1
+end
 
 uri = URI.parse(ARGV[0])
 
@@ -36,21 +42,22 @@ last_registers = {}
 SENSOR_REGISTERS = [16, 19, 20, 740, 900, 1109, 1105, 1106, 1107, 1108, 1110, 1111, 1114, 1117, 1134, 1147, 1149, 1151,
                     1153, 1165].freeze
 
-args = case uri.scheme
-       when "tcp"
-         require "socket"
-         [TCPSocket.new(uri.host, uri.port)]
-       when "telnet", "rfc2217"
-         require "net/telnet/rfc2217"
-         [Net::Telnet::RFC2217.new(uri.host,
-                                   port: uri.port || 23,
-                                   baud: 19_200,
-                                   parity: :even)]
-       else
-         [CCutrer::SerialPort.new(uri.path, baud: 19_200, parity: :even)]
-       end
-
-server = ModBus::RTUServer.new(*args)
+io = case uri.scheme
+     when "tcp"
+       require "socket"
+       TCPSocket.new(uri.host, uri.port)
+     when "telnet", "rfc2217"
+       require "net/telnet/rfc2217"
+       Net::Telnet::RFC2217.new(uri.host,
+                                port: uri.port || 23,
+                                baud: 19_200,
+                                parity: :even)
+     else
+       require "ccutrer-serialport"
+       CCutrer::SerialPort.new(uri.path, baud: 19_200, parity: :even)
+     end
+
+server = ModBus::RTUServer.new(io)
 server.promiscuous = true
 server.logger = Logger.new($stdout)
 server.logger.level = debug_modbus ? :debug : :warn

data/exe/aurora_mqtt_bridge

@@ -5,27 +5,34 @@ require "aurora"
 require "homie-mqtt"
 require "ccutrer-serialport"
 require "uri"
+require "optparse"
+require "yaml"
 require "aurora/core_ext/string"
 
-uri = URI.parse(ARGV[0])
+debug_modbus = false
+
+options = OptionParser.new do |opts|
+  opts.banner = "Usage: aurora_mqtt_bridge /path/to/serial/port [options]"
+
+  opts.on("--debug-modbus", "Print actual protocol bytes") { debug_modbus = true }
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+end
+
+options.parse!
+
+unless ARGV.length == 2
+  puts options
+  exit 1
+end
+
 mqtt_uri = ARGV[1]
 
-args = case uri.scheme
-       when "tcp"
-         require "socket"
-         [TCPSocket.new(uri.host, uri.port)]
-       when "telnet", "rfc2217"
-         require "net/telnet/rfc2217"
-         [Net::Telnet::RFC2217.new(uri.host,
-                                   port: uri.port || 23,
-                                   baud: 19_200,
-                                   parity: :even)]
-       else
-         [CCutrer::SerialPort.new(uri.path, baud: 19_200, parity: :even)]
-       end
-
-slave = ModBus::RTUClient.new(*args).with_slave(1)
-abc = Aurora::ABCClient.new(slave)
+abc = Aurora::ABCClient.new(ARGV[0])
+abc.modbus_slave.logger = Logger.new($stdout)
+abc.modbus_slave.logger.level = debug_modbus ? :debug : :warn
 
 class MQTTBridge
   def initialize(abc, homie)
@@ -71,6 +78,16 @@ class MQTTBridge
             property.value = @abc.public_send(property.id.tr("-", "_"))
           end
 
+          @blower.each do |property|
+            property.value = @abc.blower.public_send(property.id.tr("-", "_"))
+          end
+
+          if @abc.dhw?
+            @dhw["enabled"].value = @abc.dhw_enabled
+            @dhw["water-temperature"].value = @abc.dhw_water_temperature
+            @dhw["set-point"].value = @abc.dhw_setpoint
+          end
+
           @abc.faults.each_with_index do |fault_count, i|
             @faults["e#{i + 1}"].value = fault_count
           end
@@ -92,15 +109,14 @@ class MQTTBridge
 
   def publish_basic_attributes
     @homie_abc = @homie.node("abc", "Aurora Basic Control", "ABC") do |node|
-      node.property("compressor-speed", "Compressor Speed", :integer, @abc.compressor_speed, format: 0..1)
+      node.property("compressor-speed", "Compressor Speed", :integer, @abc.compressor_speed,
+                    format: @abc.vs_drive? ? 0..12 : 0..2)
       node.property("current-mode", "Current Heating/Cooling Mode", :enum, @abc.current_mode,
-                    format: %w[lockout standby blower h1 h2 c1 c2 eh1 eh2])
-      node.property("dhw-water-temperature", "DHW Water Temperature", :float, @abc.dhw_water_temperature, unit: "ºF")
+                    format: %w[lockout standby blower heating cooling eh1 eh2 emergency waiting dehumidify])
       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("fan-speed", "Fan Speed", :integer, @abc.fan_speed, format: 0..11)
       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,
@@ -110,22 +126,49 @@ class MQTTBridge
       end
       node.property("relative-humidity", "Relative Humidity", :integer, @abc.relative_humidity, unit: "%",
                                                                                                 format: 0..100)
-      node.property("waterflow", "Waterflow", :float, unit: "gpm")
+      node.property("waterflow", "Waterflow", :float, @abc.waterflow, unit: "gpm")
       node.property("fp1", "FP1 Sensor", :float, @abc.fp1, unit: "ºF")
       node.property("fp2", "FP2 Sensor", :float, @abc.fp2, unit: "ºF")
-      %i[compressor blower aux_heat loop_pump total].each do |component|
+      %i[compressor aux_heat loop_pump total].each do |component|
         component = "#{component}_watts"
         node.property(component.tr("_", "-"), component.tr("_", " ").titleize, :integer,
                       @abc.public_send(component), unit: "W")
       end
+    end
 
-      node.property("blower-only-ecm-speed", "Blower Only ECM Speed", :integer, @abc.blower_only_ecm_speed,
-                    format: 1..12) do |value, property|
-        @mutex.synchronize { property.value = @abc.blower_only_ecm_speed = value }
+    @blower = @homie.node("blower", "Blower", @abc.blower.type) do |node|
+      if @abc.blower.respond_to?(:running)
+        node.property("running", "Blower is running", :boolean, @abc.blower.running?)
+      else
+        node.property("speed", "Current blower speed", :integer, @abc.blower.speed, format: @abc.blower.speed_range)
+      end
+      node.property("watts", "Energy Usage", :integer, @abc.blower.watts, unit: "W") if @abc.energy_monitoring?
+      if @abc.blower.is_a?(Aurora::Blower::ECM)
+        %w[blower-only low-compressor high-compressor aux-heat].each do |setting|
+          field = "#{setting.tr('-', '_')}_speed"
+          node.property("#{setting}-speed", "#{setting.tr('-', ' ').titleize} Speed", :integer,
+                        @abc.blower.public_send(field), format: 1..12) do |value, property|
+            @mutex.synchronize { property.value = @abc.blower.public_send("#{field}=", value) }
+          end
+        end
+        if @abc.iz2?
+          node.property("iz2-desired-speed", "IZ2 Desired Speed", :integer, @abc.blower.iz2_desired_speed,
+                        format: 0..100, unit: "%")
+        end
       end
-      node.property("aux-heat-ecm-speed", "Aux Heat ECM Speed", :integer, @abc.aux_heat_ecm_speed,
-                    format: 1..12) do |value, property|
-        @mutex.synchronize { property.value = @abc.aux_heat_ecm_speed = value }
+    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|
+          @mutex.synchronize { property.value = @abc.dhw_enabled = value }
+        end
+        node.property("water-temperature", "DHW Water Temperature", :float,
+                      @abc.dhw_water_temperature, unit: "ºF")
+        node.property("set-point", "DHW Set Point", :float, @abc.dhw_setpoint, format: 100..140,
+                                                                               unit: "ºF") do |value, property|
+          @mutex.synchronize { property.value = @abc.dhw_setpoint = value }
+        end
       end
     end
 
@@ -191,7 +234,7 @@ end
 log_level = ARGV.include?("--debug") ? :debug : :warn
 logger = Logger.new($stdout)
 logger.level = log_level
-slave.logger = logger
+abc.modbus_slave.logger = logger
 
 device = "aurora-#{abc.serial_number}"
 homie = MQTT::Homie::Device.new(device, "Aurora MQTT Bridge", mqtt: mqtt_uri)

data/exe/web_aid_tool

@@ -7,17 +7,13 @@ require "logger"
 require "optparse"
 require "yaml"
 
-debug_modbus = monitor = mock = false
+debug_modbus = monitor = 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("--mock",
-          "Instead of talking to an actual heat pump, mock it with registers from the given YAML file (instead of a serial port)") do # rubocop:disable Layout/LineLength
-    mock = true
-  end
-  opts.on("--monitor", "Print interperted registers as they are requested, like aurora_monitor") { monitor = true }
+  opts.on("--monitor", "Print interpreted registers as they are requested, like aurora_monitor") { monitor = true }
   opts.on("-h", "--help", "Prints this help") do
     puts opts
     exit
@@ -31,51 +27,9 @@ unless ARGV.length == 1
   exit 1
 end
 
-class MockSlave
-  def initialize(registers)
-    @registers = registers
-  end
-
-  def read_multiple_holding_registers(*queries)
-    result = {}
-    queries.each do |query|
-      Array(query).each do |i|
-        result[i] = @registers[i]
-      end
-    end
-    result
-  end
-
-  def write_holding_register(addr, value)
-    @registers[addr] = value
-  end
-end
-
-if mock
-  slave = MockSlave.new(YAML.load_file(ARGV[0]))
-else
-  uri = URI.parse(ARGV[0])
-
-  args = case uri.scheme
-         when "tcp"
-           require "socket"
-           [TCPSocket.new(uri.host, uri.port)]
-         when "telnet", "rfc2217"
-           require "net/telnet/rfc2217"
-           [Net::Telnet::RFC2217.new(uri.host,
-                                     port: uri.port || 23,
-                                     baud: 19_200,
-                                     parity: :even)]
-         else
-           [CCutrer::SerialPort.new(uri.path, baud: 19_200, parity: :even)]
-         end
-
-  client = ModBus::RTUClient.new(*args)
-  client.logger = Logger.new($stdout)
-  client.logger.level = debug_modbus ? :debug : :warn
-
-  slave = client.with_slave(1)
-end
+slave = Aurora::ABCClient.open_modbus_slave(ARGV[0])
+slave.logger = Logger.new($stdout)
+slave.logger.level = debug_modbus ? :debug : :warn
 
 def parse_query_string(query_string)
   query_string.split("&").map { |p| p.split("=") }.to_h
@@ -89,6 +43,7 @@ end
 require "sinatra"
 
 set :public_folder, "html"
+set :logging, false
 
 get "/" do
   send_file "html/index.htm"
@@ -138,7 +93,10 @@ get "/request.cgi" do
       start...(start + length)
     end
     registers = slave.read_multiple_holding_registers(*queries)
-    puts Aurora.print_registers(registers) if monitor
+    if monitor
+      puts "READING"
+      puts Aurora.print_registers(registers)
+    end
     result["values"] = registers.values.join(",")
   when "putregs"
     writes = params["regs"].split(";").map do |write|
@@ -147,7 +105,6 @@ get "/request.cgi" do
     if monitor
       puts "WRITING"
       puts Aurora.print_registers(writes)
-      puts "==="
     end
 
     writes.each do |(addr, value)|

data/lib/aurora/abc_client.rb

@@ -1,13 +1,49 @@
 # frozen_string_literal: true
 
+require "yaml"
+require "uri"
+
+require "aurora/blower"
+require "aurora/iz2_zone"
+require "aurora/thermostat"
+
 module Aurora
   class ABCClient
+    class << self
+      def open_modbus_slave(uri)
+        uri = URI.parse(uri)
+
+        io = case uri.scheme
+             when "tcp"
+               require "socket"
+               TCPSocket.new(uri.host, uri.port)
+             when "telnet", "rfc2217"
+               require "net/telnet/rfc2217"
+               Net::Telnet::RFC2217.new(uri.host,
+                                        port: uri.port || 23,
+                                        baud: 19_200,
+                                        parity: :even)
+
+             else
+               return Aurora::MockABC.new(YAML.load_file(uri.path)) if File.file?(uri.path)
+
+               require "ccutrer-serialport"
+               CCutrer::SerialPort.new(uri.path, baud: 19_200, parity: :even)
+             end
+
+        client = ::ModBus::RTUClient.new(io)
+        client.with_slave(1)
+      end
+    end
+
     attr_reader :modbus_slave,
                 :serial_number,
                 :zones,
+                :blower,
                 :faults,
                 :current_mode,
-                :fan_speed,
+                :dhw_enabled,
+                :dhw_setpoint,
                 :entering_air_temperature,
                 :relative_humidity,
                 :leaving_air_temperature,
@@ -19,21 +55,27 @@ module Aurora
                 :outdoor_temperature,
                 :fp1,
                 :fp2,
-                :blower_only_ecm_speed,
-                :aux_heat_ecm_speed,
                 :compressor_watts,
-                :blower_watts,
                 :aux_heat_watts,
                 :loop_pump_watts,
                 :total_watts
 
-    def initialize(modbus_slave)
-      @modbus_slave = modbus_slave
+    def initialize(uri)
+      @modbus_slave = self.class.open_modbus_slave(uri)
       @modbus_slave.read_retry_timeout = 15
       @modbus_slave.read_retries = 2
-      registers_array = @modbus_slave.holding_registers[105...110]
-      registers = registers_array.each_with_index.map { |r, i| [i + 105, r] }.to_h
-      @serial_number = Aurora.transform_registers(registers)[105]
+      raw_registers = @modbus_slave.holding_registers[88..91, 105...110, 404, 412, 1114]
+      registers = Aurora.transform_registers(raw_registers.dup)
+      @program = registers[88]
+      @serial_number = registers[105]
+      @dhw_water_temperature = registers[1114]
+      @energy_monitor = raw_registers[412]
+
+      @blower = case raw_registers[404]
+                when 1, 2 then Blower::ECM.new(self, registers[404])
+                when 3 then Blower::FiveSpeed.new(self, registers[404])
+                else; Blower::PSC.new(self, registers[404])
+                end
 
       @zones = if iz2?
                  iz2_zone_count = @modbus_slave.holding_registers[483]
@@ -45,11 +87,14 @@ module Aurora
     end
 
     def query_registers(query)
+      implicit = false
       ranges = query.split(",").map do |addr|
         case addr
         when "known"
+          implicit = true
           Aurora::REGISTER_NAMES.keys
         when "valid"
+          implicit = true
           break Aurora::REGISTER_RANGES
         when /^(\d+)(?:\.\.|-)(\d+)$/
           $1.to_i..$2.to_i
@@ -61,13 +106,27 @@ module Aurora
       registers = {}
       queries.each do |subquery|
         registers.merge!(@modbus_slave.read_multiple_holding_registers(*subquery))
+      rescue ::ModBus::Errors::IllegalDataAddress
+        # maybe this unit doesn't respond to all the addresses we want?
+        raise unless implicit
+
+        # try each query individually
+        subquery.each do |subsubquery|
+          registers.merge!(@modbus_slave.read_multiple_holding_registers(subsubquery))
+        rescue ::ModBus::Errors::IllegalDataAddress
+          next
+        end
       end
       registers
     end
 
     def refresh
-      registers_to_read = [19..20, 30, 340, 344, 347, 740..741, 900, 1110..1111, 1114, 1117, 1147..1153, 1165,
-                           3027, 31_003]
+      registers_to_read = [6, 19..20, 25, 30, 344, 740..741, 900, 1110..1111, 1114, 1117, 1147..1153, 1165,
+                           31_003]
+      registers_to_read << (400..401) if dhw?
+      registers_to_read.concat(blower.registers_to_read)
+      registers_to_read.concat([362, 3001]) if vs_drive?
+
       if zones.first.is_a?(IZ2Zone)
         zones.each_with_index do |_z, i|
           base1 = 21_203 + i * 9
@@ -87,7 +146,10 @@ module Aurora
       registers = @modbus_slave.holding_registers[*registers_to_read]
       Aurora.transform_registers(registers)
 
-      @fan_speed                  = registers[344]
+      outputs = registers[30]
+
+      @dhw_enabled                = registers[400]
+      @dhw_setpoint               = registers[401]
       @entering_air_temperature   = registers[740]
       @relative_humidity          = registers[741]
       @leaving_air_temperature    = registers[900]
@@ -95,36 +157,47 @@ module Aurora
       @entering_water_temperature = registers[1111]
       @dhw_water_temperature      = registers[1114]
       @waterflow                  = registers[1117]
-      @compressor_speed           = registers[3027]
+      @compressor_speed = if vs_drive?
+                            registers[3001]
+                          elsif outputs.include?(:cc2)
+                            2
+                          elsif outputs.include?(:cc)
+                            1
+                          else
+                            0
+                          end
       @outdoor_temperature        = registers[31_003]
       @fp1                        = registers[19]
       @fp2                        = registers[20]
-      @locked_out                 = registers[1117]
-      @blower_only_ecm_speed      = registers[340]
-      @aux_heat_ecm_speed         = registers[347]
+      @locked_out                 = registers[25] & 0x8000
+      @error                      = registers[25] & 0x7fff
+      @derated                    = (41..46).include?(@error)
+      @safe_mode                  = [47, 48, 49, 72, 74].include?(@error)
       @compressor_watts           = registers[1147]
-      @blower_watts               = registers[1149]
       @aux_heat_watts             = registers[1151]
       @loop_pump_watts            = registers[1165]
       @total_watts                = registers[1153]
 
-      outputs = registers[30]
       @current_mode = if outputs.include?(:lockout)
                         :lockout
-                      elsif outputs.include?(:cc2)
-                        outputs.include?(:rv) ? :c2 : :h2
-                      elsif outputs.include?(:cc)
-                        outputs.include?(:rv) ? :c1 : :h1
+                      elsif registers[362]
+                        :dehumidify
+                      elsif outputs.include?(:cc2) || outputs.include?(:cc)
+                        outputs.include?(:rv) ? :cooling : :heating
                       elsif outputs.include?(:eh2)
-                        :eh2
+                        outputs.include?(:rv) ? :eh2 : :emergency
                       elsif outputs.include?(:eh1)
-                        :eh1
+                        outputs.include?(:rv) ? :eh1 : :emergency
                       elsif outputs.include?(:blower)
                         :blower
+                      elsif registers[6]
+                        :waiting
                       else
                         :standby
                       end
 
+      blower.refresh(registers)
+
       zones.each do |z|
         z.refresh(registers)
       end
@@ -152,7 +225,9 @@ module Aurora
     end
 
     def dhw_setpoint=(value)
-      @modbus_slave.holding_registers[401] = value
+      raise ArgumentError unless (100..140).include?(value)
+
+      @modbus_slave.holding_registers[401] = (value * 10).to_i
     end
 
     def loop_pressure_trip=(value)
@@ -173,11 +248,61 @@ module Aurora
       @modbus_slave.holding_registers[322] = value
     end
 
+    def line_voltage=(value)
+      raise ArgumentError unless (90..635).include?(value)
+
+      @modbus_slave.holding_registers[112] = value
+    end
+
+    def clear_fault_history
+      @modbus_slave.holding_registers[47] = 0x5555
+    end
+
+    def manual_operation(mode: :off,
+                         compressor_speed: 0,
+                         blower_speed: :with_compressor,
+                         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)
+
+      unless blower_speed == :with_compressor || (0..12).include?(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)
+        raise ArgumentError,
+              "pump speed must be :with_compressor or between 0 and 100"
+      end
+
+      value = 0
+      value = 0x7fff if mode == :off
+      value |= 0x100 if mode == :cooling
+      value |= blower_speed == :with_compressor ? 0xf0 : (blower_speed << 4)
+      value |= 0x200 if aux_heat
+
+      @modbus_slave.holding_registers[3002] = value
+      @modbus_slave.holding_registers[323] = pump_speed == :with_compressor ? 0x7fff : pump_speed
+    end
+
+    def energy_monitoring?
+      @energy_monitor == 2
+    end
+
+    def vs_drive?
+      @program == "ABCVSP"
+    end
+
+    def dhw?
+      (-999..999).include?(dhw_water_temperature)
+    end
+
     # config aurora system
     { thermostat: 800, axb: 806, iz2: 812, aoc: 815, moc: 818, eev2: 824 }.each do |(component, register)|
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{component}?
-          @modbus_slave.holding_registers[#{register}] != 3
+          return @#{component} if instance_variable_defined?(:@#{component})
+          @#{component} = @modbus_slave.holding_registers[#{register}] != 3
         end
 
         def add_#{component}