waterfurnace_aurora 0.3.10 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9043266cc8a0382960f9ee29954fa9da2c33f8507c3d0075c58d9651618fa128
-  data.tar.gz: 40520db833f13a4caea708589a334b21198ed551376ee70aff666c875257ea03
+  metadata.gz: 2d7a11b389793a826e3dc602b69ea7aea2ee73afc9839eb1b9df41f38895222e
+  data.tar.gz: c30fad75a07bded088cb3a961e88bf298f5c482eafcb681309693ae00b079de0
 SHA512:
-  metadata.gz: b8db6bf0c4f1e19270792fd43d16e06dcb3a1ab357c8553d6cc39bb820f546ff3782472a3c8f7cde7d2323686d7712c2f2699d53b8cd984344bda02982a979bc
-  data.tar.gz: 70d7fa1a21e3c3003f24f1cbe8e5909ceb216002e98d08e3262e9f56a3c2636af775a7e47b2422bbbe7511d8cf5ae390436b0d809f28a4e34f6c21ed609327a1
+  metadata.gz: 7b0d336748b78005248f5b9b64afb573345a6a0426346bb2d1053d3fdaa4a814a313e5f621ca632d02358f0ec3d2a0c4c2506cb4dada0551c344a595be1f944b
+  data.tar.gz: 0d46028195f215edfe1a1dcf0ec1b7ea50071ba1a7638ba9a2fd0bc3418cd4f451c88e7fb461c741970d683f94eef0c25ec5f2b64db4b80e1ae7ecc0b702a9f4

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
@@ -77,7 +84,10 @@ server.request_callback = lambda { |uid, func, req|
     puts Aurora.print_registers(registers)
   elsif func == 16
     registers = Range.new(req[:addr], req[:addr] + req[:quant] - 1).zip(req[:val]).to_h
-    next if ignore_awl_heartbeat && registers == { 460 => 102, 461 => 0, 462 => 5 }
+    if ignore_awl_heartbeat && [{ 460 => 102, 461 => 0, 462 => 5 },
+                                { 460 => 102, 461 => 0, 462 => 1 }].include?(registers)
+      next
+    end
 
     puts "#{Time.now} ===== write multiple registers to #{uid}:"
     puts Aurora.print_registers(registers)

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,12 @@ class MQTTBridge
             property.value = @abc.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,10 +105,10 @@ 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,
@@ -129,6 +142,20 @@ class MQTTBridge
       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|
+          @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
+
     @faults = @homie.node("faults", "Fault History", "ABC") do |node|
       @abc.faults.each_with_index do |count, i|
         name = Aurora::FAULTS[i + 1]
@@ -191,7 +218,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/grab_awl_assets.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+mkdir -p html
+mkdir -p html/css
+mkdir -p html/js
+mkdir -p html/images
+
+IP=${1:-172.20.10.1}
+
+curl http://$IP/ > html/index.htm
+curl http://$IP/config.htm > html/config.htm
+curl http://$IP/favicon.ico > html/favicon.ico
+curl http://$IP/css/index.css > html/css/index.css
+curl http://$IP/css/phone.css > html/css/phone.css
+curl http://$IP/js/indexc.js > html/js/indexc.js
+curl http://$IP/js/configc.js > html/js/configc.js
+curl http://$IP/images/aurora.png > html/images/aurora.png
+curl http://$IP/images/back.png > html/images/back.png
+curl http://$IP/images/cfailed.png > html/images/cfailed.png
+curl http://$IP/images/cgood.png > html/images/cgood.png
+curl http://$IP/images/cidle.png > html/images/cidle.png

data/exe/web_aid_tool

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "aurora"
+require "ccutrer-serialport"
+require "logger"
+require "optparse"
+require "yaml"
+
+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("--monitor", "Print interpreted registers as they are requested, like aurora_monitor") { monitor = true }
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+end
+
+options.parse!
+
+unless ARGV.length == 1
+  puts options
+  exit 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
+end
+
+# _don't_ do URI escaping
+def encode_result(params)
+  params.map { |p| p.join("=") }.join("&")
+end
+
+require "sinatra"
+
+set :public_folder, "html"
+set :logging, false
+
+get "/" do
+  send_file "html/index.htm"
+end
+
+units = 0
+
+get "/getunits.cgi" do
+  encode_result(units: units)
+end
+
+get "/setunits.cgi" do
+  units = params["units"].to_i
+  encode_result(error: 0)
+end
+
+get "/config.cgi" do
+  encode_result(
+    "AWL Version" => Aurora::VERSION,
+    "Local Web Version" => 1.08,
+    "SSID" => nil,
+    "Units" => units,
+    "AWL ID" => ARGV[0],
+    "AWL ID CRC" => nil
+  )
+end
+
+get "/request.cgi" do
+  params = parse_query_string(request.query_string)
+  result = params.slice("cmd", "id", "set", "addr")
+  result["err"] = nil
+
+  # these are just aliases to get a certain set of registers
+  case params["cmd"]
+  when "abcinfo"
+    params["regs"] = "2;8;88,4"
+  when "devices"
+    params["regs"] = "800;803;806,3;812;815;818;824"
+  end
+
+  case params["cmd"]
+  when "getregs", "abcinfo", "devices"
+    queries = params["regs"].split(";").map do |range|
+      start, length = range.split(",").map(&:to_i)
+      next start if length.nil?
+
+      start...(start + length)
+    end
+    registers = slave.read_multiple_holding_registers(*queries)
+    if monitor
+      puts "READING"
+      puts Aurora.print_registers(registers)
+    end
+    result["values"] = registers.values.join(",")
+  when "putregs"
+    writes = params["regs"].split(";").map do |write|
+      write.split(",").map(&:to_i)
+    end.compact.to_h
+    if monitor
+      puts "WRITING"
+      puts Aurora.print_registers(writes)
+    end
+
+    writes.each do |(addr, value)|
+      slave.write_holding_register(addr, value)
+    end
+  else
+    return ""
+  end
+
+  encode_result(result)
+end

data/lib/aurora/abc_client.rb

@@ -1,13 +1,45 @@
 # frozen_string_literal: true
 
+require "yaml"
+require "uri"
+
 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,
                 :faults,
                 :current_mode,
                 :fan_speed,
+                :dhw_enabled,
+                :dhw_setpoint,
                 :entering_air_temperature,
                 :relative_humidity,
                 :leaving_air_temperature,
@@ -27,29 +59,33 @@ module Aurora
                 :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]
+      registers = Aurora.transform_registers(@modbus_slave.holding_registers[88..91, 105...110, 1114])
+      @program = registers[88]
+      @serial_number = registers[105]
+      @dhw_water_temperature = registers[1114]
 
-      @zones = if @modbus_slave.holding_registers[813].zero?
-                 [Thermostat.new(self)]
-               else
+      @zones = if iz2?
                  iz2_zone_count = @modbus_slave.holding_registers[483]
                  (0...iz2_zone_count).map { |i| IZ2Zone.new(self, i + 1) }
+               else
+                 [Thermostat.new(self)]
                end
       @faults = []
     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 +97,26 @@ 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, 340, 344, 347, 740..741, 900, 1110..1111, 1114, 1147..1153, 1165,
+                           31_003]
+      registers_to_read << (400..401) if dhw?
+      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
@@ -78,7 +127,8 @@ module Aurora
           registers_to_read << base3
         end
       else
-        registers_to_read << (745..747)
+        registers_to_read << 502
+        registers_to_read << (745..746)
       end
 
       @faults = @modbus_slave.holding_registers[601..699]
@@ -86,7 +136,11 @@ module Aurora
       registers = @modbus_slave.holding_registers[*registers_to_read]
       Aurora.transform_registers(registers)
 
+      outputs = registers[30]
+
       @fan_speed                  = registers[344]
+      @dhw_enabled                = registers[400]
+      @dhw_setpoint               = registers[401]
       @entering_air_temperature   = registers[740]
       @relative_humidity          = registers[741]
       @leaving_air_temperature    = registers[900]
@@ -94,11 +148,22 @@ 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]
+      @locked_out                 = registers[25] & 0x8000
+      @error                      = registers[25] & 0x7fff
+      @derated                    = (41..46).include?(@error)
+      @safe_mode                  = [47, 48, 49, 72, 74].include?(@error)
       @blower_only_ecm_speed      = registers[340]
       @aux_heat_ecm_speed         = registers[347]
       @compressor_watts           = registers[1147]
@@ -107,19 +172,20 @@ module Aurora
       @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
@@ -141,6 +207,101 @@ module Aurora
       @modbus_slave.holding_registers[347] = value
     end
 
+    def cooling_airflow_adjustment=(value)
+      value = 0x10000 + value if value.negative?
+      @modbus_slave.holding_registers[346] = value
+    end
+
+    def dhw_enabled=(value)
+      @modbus_slave.holding_registers[400] = value ? 1 : 0
+    end
+
+    def dhw_setpoint=(value)
+      raise ArgumentError unless (100..140).include?(value)
+
+      @modbus_slave.holding_registers[401] = (value * 10).to_i
+    end
+
+    def loop_pressure_trip=(value)
+      @modbus_slave.holding_registers[419] = (value * 10).to_i
+    end
+
+    def vs_pump_control=(value)
+      raise ArgumentError unless (value = VS_PUMP_CONTROL.invert[value])
+
+      @modbus_slave.holding_registers[323] = value
+    end
+
+    def vs_pump_min=(value)
+      @modbus_slave.holding_registers[321] = value
+    end
+
+    def vs_pump_max=(value)
+      @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 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
+        end
+
+        def add_#{component}
+          @modbus_slave.holding_registers[#{register}] = 2
+        end
+
+        def remove_#{component}
+          @modbus_slave.holding_registers[#{register}] = 3
+        end
+      RUBY
+    end
+
     def inspect
       "#<Aurora::ABCClient #{(instance_variables - [:@modbus_slave]).map do |iv|
                                "#{iv}=#{instance_variable_get(iv).inspect}"