waterfurnace_aurora 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64e8260cab984391d973114e5e09a98cc4331c166d13f1797bab6e0f292d2953
-  data.tar.gz: b0a430cbf5310a30c839e9ca19807081aa316cffa80ce3c230fcffe5af928ab0
+  metadata.gz: fde3dc688654c589d5638b794484035f3ab7ca8c102fe1ef27bb6365ddd51d22
+  data.tar.gz: 6d679712a9375c94f8a1f7b2fe3fa6102c606a433c0449049ae289773cdaf735
 SHA512:
-  metadata.gz: cce5f85f7b11c6910b294511faa7ea13b0319e58523cd8e42832f03983870296659286aa071db9761cd5c33df3a107d2ae9d6d5b33e430a96daf07b9366111eb
-  data.tar.gz: 5f8affbb114893a9a67accd843b70f1a328b54d9c1485b455740e056b5f1d465f86e20a86e1d13b6c3cd7e2a9ddeabef5d6d72771c811cb5101b57bdfd881379
+  metadata.gz: dd90afd3a8f15ddec22ec29f23679d4def25b768b47eaf7adc37c37ab0a5b98bfb98a11811133d67dbbb1afd23b03ea5689fe4be55c2966eb19b68b9b8827667
+  data.tar.gz: 9c855a9730f2a86678876f3866ea7a6583925781e2397e13738b9f413e4b318a89c7860706e22e88c94d090f37afccd775b2b54242b9555530993e7021b995c6

data/exe/aurora_fetch

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "aurora"
+require "ccutrer-serialport"
+require "uri"
+
+uri = URI.parse(ARGV[0])
+
+args = if uri.scheme == "telnet" || uri.scheme == "rfc2217"
+         require "net/telnet/rfc2217"
+         [Net::Telnet::RFC2217.new("Host" => uri.host,
+                                   "Port" => uri.port || 23,
+                                   "baud" => 19_200,
+                                   "parity" => Net::Telnet::RFC2217::EVEN)]
+       else
+         [CCutrer::SerialPort.new(uri.path, baud: 19_200, parity: :even)]
+       end
+
+client = ModBus::RTUClient.new(*args)
+client.debug = true
+slave = client.with_slave(1)
+
+registers = slave.holding_registers[ARGV[1].to_i]
+
+puts registers.inspect

data/{bin → exe}/aurora_mock

@@ -1,21 +1,22 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require 'aurora'
-require 'ccutrer-serialport'
-require 'uri'
-require 'yaml'
+require "aurora"
+require "ccutrer-serialport"
+require "uri"
+require "yaml"
 
 uri = URI.parse(ARGV[0])
 
 args = if uri.scheme == "telnet" || uri.scheme == "rfc2217"
-  require 'net/telnet/rfc2217'
-  [Net::Telnet::RFC2217.new('Host' => uri.host,
-    'Port' => uri.port || 23,
-    'baud' => 19200,
-    'parity' => Net::Telnet::RFC2217::EVEN)]
-else
-  [CCutrer::SerialPort.new(uri.path, baud: 19200, parity: :even)]
-end
+         require "net/telnet/rfc2217"
+         [Net::Telnet::RFC2217.new("Host" => uri.host,
+                                   "Port" => uri.port || 23,
+                                   "baud" => 19_200,
+                                   "parity" => Net::Telnet::RFC2217::EVEN)]
+       else
+         [CCutrer::SerialPort.new(uri.path, baud: 19_200, parity: :even)]
+       end
 
 port = ARGV[1]&.to_i || 502
 
@@ -27,13 +28,13 @@ slave2 = server1.with_slave(2)
 server2 = ModBus::TCPServer.new(port)
 slave255 = server2.with_slave(255)
 
-r = slave1.holding_registers = slave2.holding_registers = slave255.holding_registers = Array.new(31473, 0)
+r = slave1.holding_registers = slave2.holding_registers = slave255.holding_registers = Array.new(31_473, 0)
 
 # prepopulate some data
-registers = YAML.load(File.read(File.expand_path('../registers.yml', __FILE__)))
+registers = YAML.safe_load(File.read(File.expand_path("registers.yml", __dir__)))
 registers.each { |(k, v)| r[k] = v }
 
-server1.request_callback = ->(uid, func, req) do
+server1.request_callback = lambda { |uid, func, req|
   if func == 68
     puts "===== no idea to #{uid}: #{req.inspect}"
   elsif func == 67
@@ -45,12 +46,13 @@ server1.request_callback = ->(uid, func, req) do
     registers = Range.new(req[:addr], req[:addr] + req[:quant] - 1).zip(req[:val]).to_h
     puts Aurora.print_registers(registers)
   elsif [3, 65, 66].include?(func)
+    # no output
   else
     puts "**** new func #{func}"
   end
-end
+}
 
-server1.response_callback = ->(uid, func, res, req) do
+server1.response_callback = lambda { |uid, func, res, req|
   if func == 3 && res.is_a?(Array) && req
     unless req[:quant] == res.length
       puts "wrong number of results"
@@ -78,12 +80,13 @@ server1.response_callback = ->(uid, func, res, req) do
     registers = req.zip(res).to_h
     puts Aurora.print_registers(registers)
   elsif [16, 67, 68].include?(func)
+    # no output
   else
     puts "**** new func #{func}"
   end
-end
+}
 
 server2.start
 server1.send(:serve, server1.instance_variable_get(:@sp))
-#server1.start
-loop {}
+# server1.start
+loop { nil }

data/exe/aurora_monitor

@@ -0,0 +1,120 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "aurora"
+require "ccutrer-serialport"
+require "optparse"
+require "socket"
+require "uri"
+
+diff_only = debug_modbus = ignore_awl_heartbeat = ignore_sensors = false
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: aurora_monitor /path/to/serial/port [options]"
+
+  opts.on("-q", "--quiet",
+          "Enables quiet mode (--diff-only, --ignore-awl-heartbeat, --ignore-sensors) to ease in deciphering new registers") do # rubocop:disable Layout/LineLength
+    diff_only = true
+    ignore_awl_heartbeat = true
+    ignore_sensors = true
+  end
+  opts.on("--diff-only", "Only show registers if they've changed from their previous value") { diff_only = true }
+  opts.on("--debug-modbus", "Print actual protocol bytes") { debug_modbus = true }
+  opts.on("--ignore-awl-heartbeat", "Don't print AWL heartbeat requests") { ignore_awl_heartbeat = true }
+  opts.on("--ignore-sensors", "Don't print sensor registers (i.e. because they change a lot)") { ignore_sensors = true }
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+end.parse!
+
+uri = URI.parse(ARGV[0])
+
+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 = if uri.scheme == "telnet" || uri.scheme == "rfc2217"
+         require "net/telnet/rfc2217"
+         [Net::Telnet::RFC2217.new("Host" => uri.host,
+                                   "Port" => uri.port || 23,
+                                   "baud" => 19_200,
+                                   "parity" => Net::Telnet::RFC2217::EVEN)]
+       else
+         [CCutrer::SerialPort.new(uri.path, baud: 19_200, parity: :even)]
+       end
+
+server = ModBus::RTUServer.new(*args)
+server.promiscuous = true
+server.debug = debug_modbus
+
+diff_and_print = lambda do |registers|
+  registers = registers.slice(*(registers.keys - SENSOR_REGISTERS)) if ignore_sensors
+  next puts Aurora.print_registers(registers) unless diff_only
+
+  new_registers = last_registers.merge(registers)
+  diff = Aurora.diff_registers(last_registers, new_registers)
+  unless diff.empty?
+    puts "#{Time.now} ===== read"
+    puts Aurora.print_registers(diff)
+  end
+  last_registers = new_registers
+end
+
+server.request_callback = lambda { |uid, func, req|
+  if func == 68
+    puts "#{Time.now} ===== no idea to #{uid}: #{req.inspect}" unless diff_only
+  elsif func == 67
+    puts "#{Time.now} ===== write discontiguous registers to #{uid}:"
+    registers = req.map { |p| [p[:addr], p[:val]] }.to_h
+    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 }
+
+    puts "#{Time.now} ===== write multiple registers to #{uid}:"
+    puts Aurora.print_registers(registers)
+  elsif [3, 65, 66].include?(func)
+    # no output
+  else
+    puts "#{Time.now} **** new func #{func}"
+  end
+}
+
+server.response_callback = lambda { |uid, func, res, req|
+  if func == 3 && res.is_a?(Array) && req
+    unless req[:quant] == res.length
+      puts "wrong number of results"
+      next
+    end
+    puts "#{Time.now} ===== read registers from #{uid}" unless diff_only
+    registers = Range.new(req[:addr], req[:addr] + req[:quant], true).to_a.zip(res).to_h
+    diff_and_print.call(registers)
+  elsif func == 65 && res.is_a?(Array) && req
+    register_list = []
+    req.each { |params| register_list.concat(Range.new(params[:addr], params[:addr] + params[:quant], true).to_a) }
+    unless register_list.length == res.length
+      puts "wrong number of results"
+      next
+    end
+    puts "#{Time.now} ===== read multiple register ranges from #{uid}" unless diff_only
+    result = register_list.zip(res).to_h
+    diff_and_print.call(result)
+  elsif func == 66 && res.is_a?(Array) && req
+    unless req.length == res.length
+      puts "wrong number of results"
+      next
+    end
+    puts "#{Time.now} ===== read discontiguous registers from #{uid}" unless diff_only
+    registers = req.zip(res).to_h
+    diff_and_print.call(registers)
+  elsif [16, 67, 68].include?(func)
+    # no output
+  else
+    puts "#{Time.now} **** new func #{func}"
+  end
+}
+
+server.send(:serve, server.instance_variable_get(:@sp))
+loop { nil }

data/exe/aurora_mqtt_bridge

@@ -0,0 +1,189 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "aurora"
+require "homie-mqtt"
+require "ccutrer-serialport"
+require "uri"
+require "aurora/core_ext/string"
+
+uri = URI.parse(ARGV[0])
+mqtt_uri = ARGV[1]
+
+args = if uri.scheme == "telnet" || uri.scheme == "rfc2217"
+         require "net/telnet/rfc2217"
+         [Net::Telnet::RFC2217.new("Host" => uri.host,
+                                   "Port" => uri.port || 23,
+                                   "baud" => 19_200,
+                                   "parity" => Net::Telnet::RFC2217::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)
+
+class MQTTBridge
+  def initialize(abc, homie)
+    @abc = abc
+    @homie = homie
+    @mutex = Mutex.new
+
+    @homie.instance_variable_set(:@block, lambda do |topic, value|
+      @mutex.synchronize do
+        case topic
+        when /\$modbus$/
+          query = value.split(",").map do |addr|
+            case addr
+            when "known"
+              Aurora::REGISTER_NAMES.keys
+            when /^(\d+)\.\.(\d+)$/
+              Regexp.last_match(1).to_i..Regexp.last_match(2).to_i
+            else
+              addr.to_i
+            end
+          end
+          queries = Aurora.normalize_ranges(query)
+          registers = {}
+          queries.each do |subquery|
+            registers.merge!(@abc.modbus_slave.read_multiple_holding_registers(*subquery))
+          end
+          result = Aurora.print_registers(registers)
+          @homie.mqtt.publish("#{@homie.topic}/$modbus/response", result, retain: false, qos: 1)
+        when %r{\$modbus/(\d+)$}
+          register = Regexp.last_match(1).to_i
+          value = case value
+                  when /\d+/
+                    value.to_i
+                  when /0x(\d+)/
+                    Regexp.last_match(1).to_i(16)
+                  end
+          @abc.modbus_slave.holding_registers[register] = value if value
+        end
+      end
+    rescue StandardError => e
+      puts "failed processing message: #{e}\n#{e.backtrace}"
+    end)
+
+    publish_basic_attributes
+
+    loop do
+      begin
+        @mutex.synchronize do
+          @abc.refresh
+          %i[compressor_speed
+             current_mode
+             dhw_water_temperature
+             entering_air_temperature
+             fan_speed
+             leaving_air_temperature
+             leaving_water_temperature
+             outdoor_temperature
+             relative_humidity
+             waterflow
+             fp1
+             fp2
+             compressor_watts
+             blower_watts
+             aux_heat_watts
+             loop_pump_watts
+             total_watts].each do |property|
+            @homie_abc[property.to_s.tr("_", "-")].value = @abc.public_send(property)
+          end
+
+          @abc.zones.each_with_index do |z, idx|
+            homie_zone = @homie["zone#{idx + 1}"]
+            homie_zone.each do |property|
+              property.value = z.public_send(property.id.tr("-", "_"))
+            end
+          end
+        end
+      rescue => e
+        puts "got garbage: #{e}; #{e.backtrace}"
+        exit 1
+      end
+      sleep(5)
+    end
+  end
+
+  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("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")
+      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,
+                    unit: "ºF")
+      node.property("outdoor-temperature", "Outdoor Temperature", :float, @abc.outdoor_temperature, unit: "ºF")
+      node.property("relative-humidity", "Relative Humidity", :integer, @abc.relative_humidity, unit: "%",
+                                                                                                format: 0..100)
+      node.property("waterflow", "Waterflow", :float, 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|
+        component = "#{component}_watts"
+        node.property(component.tr("_", "-"), component.tr("_", " ").titleize, :integer,
+                      @abc.public_send(component), unit: "W")
+      end
+    end
+
+    @abc.zones.each_with_index do |zone, i|
+      type = zone.is_a?(Aurora::IZ2Zone) ? "IntelliZone 2 Zone" : "Thermostat"
+      @homie.node("zone#{i + 1}", "Zone #{i + 1}", type) do |node|
+        allowed_modes = %w[off auto cool heat]
+        allowed_modes << "eheat" if i.zero?
+        node.property("target-mode", "Target Heating/Cooling Mode", :enum, zone.target_mode,
+                      format: allowed_modes) do |value, property|
+          @mutex.synchronize { property.value = zone.target_mode = value.to_sym }
+        end
+        if zone.respond_to?(:current_mode) # TODO: implement for non-IZ2
+          node.property("current-mode", "Current Heating/Cooling Mode Requested", :enum, zone.current_mode,
+                        format: %w[standby h1 h2 h3 c1 c2])
+        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 }
+        end
+        if zone.respond_to?(:current_fan_mode) # TODO: implement for non-IZ2
+          node.property("current-fan-mode", "Current Fan Status", :boolean, zone.current_fan_mode)
+          node.property("fan-intermittent-on", "Fan Intermittent Mode On Duration", :enum, zone.fan_intermittent_on,
+                        unit: "M", format: %w[0 5 10 15 20]) do |value, property|
+            @mutex.synchronize { property.value = zone.fan_intermittent_on = value.to_i }
+          end
+          node.property("fan-intermittent-off", "Fan Intermittent Mode Off Duration", :enum, zone.fan_intermittent_on,
+                        unit: "M", format: %w[0 5 10 15 20 25 30 35 40]) do |value, property|
+            @mutex.synchronize { property.value = zone.fan_intermittent_on = value.to_i }
+          end
+        end
+        if zone.is_a?(Aurora::IZ2Zone)
+          node.property("priority", "Zone Priority", :enum, zone.priority, format: %w[economy comfort])
+          node.property("size", "Size", :enum, zone.size, format: %w[0 25 45 70])
+          node.property("normalized-size", "Normalized Size", :integer, zone.normalized_size, unit: "%", format: 0..100)
+        end
+        node.property("ambient-temperature", "Ambient Temperature", :float, zone.ambient_temperature, unit: "ºF")
+        node.property("heating-target-temperature", "Heating Target Temperature", :integer,
+                      zone.heating_target_temperature, unit: "ºF", format: 40..90) do |value, property|
+          @mutex.synchronize { property.value = zone.heating_target_temperature = value }
+        end
+        node.property("cooling-target-temperature", "Cooling Target Temperature", :integer,
+                      zone.cooling_target_temperature, unit: "ºF", format: 54..99) do |value, property|
+          @mutex.synchronize { property.value = zone.cooling_target_temperature = value }
+        end
+      end
+    end
+
+    # direct access to modbus registers for debugging purposes
+    @homie.mqtt.subscribe("#{@homie.topic}/$modbus")
+    @homie.mqtt.subscribe("#{@homie.topic}/$modbus/+")
+    @homie.publish
+  end
+end
+
+MQTTBridge.new(abc, MQTT::Homie::Device.new("aurora", "Aurora MQTT Bridge", mqtt: mqtt_uri))

data/lib/aurora/abc_client.rb

@@ -1,39 +1,54 @@
+# frozen_string_literal: true
+
 module Aurora
   class ABCClient
     attr_reader :modbus_slave,
-      :iz2_zones,
-      :current_mode,
-      :fan_speed,
-      :entering_air_temperature,
-      :relative_humidity,
-      :leaving_air_temperature,
-      :leaving_water_temperature,
-      :entering_water_temperature,
-      :dhw_water_temperature,
-      :waterflow,
-      :compressor_speed,
-      :outdoor_temperature,
-      :fp1,
-      :fp2
+                :zones,
+                :current_mode,
+                :fan_speed,
+                :entering_air_temperature,
+                :relative_humidity,
+                :leaving_air_temperature,
+                :leaving_water_temperature,
+                :entering_water_temperature,
+                :dhw_water_temperature,
+                :waterflow,
+                :compressor_speed,
+                :outdoor_temperature,
+                :fp1,
+                :fp2,
+                :compressor_watts,
+                :blower_watts,
+                :aux_heat_watts,
+                :loop_pump_watts,
+                :total_watts
 
     def initialize(modbus_slave)
       @modbus_slave = modbus_slave
       @modbus_slave.read_retry_timeout = 15
       @modbus_slave.read_retries = 2
       iz2_zone_count = @modbus_slave.holding_registers[483]
-      @iz2_zones = (0...iz2_zone_count).map { |i| IZ2Zone.new(self, i + 1) }
+      # TODO: better detect IZ2/Non-IZ2
+      @zones = if iz2_zone_count > 1
+                 (0...iz2_zone_count).map { |i| IZ2Zone.new(self, i + 1) }
+               else
+                 [Thermostat.new(self)]
+               end
     end
 
     def refresh
-      registers_to_read = [19..20, 30, 344, 740..741, 900, 1110..1111, 1114, 1117, 3027, 31003]
-      # IZ2 zones
-      iz2_zones.each_with_index do |_z, i|
-        base1 = 21203 + i * 9
-        base2 = 31007 + i * 3
-        base3 = 31200 + i * 3
-        registers_to_read << (base1..(base1 + 1))
-        registers_to_read << (base2..(base2 + 2))
-        registers_to_read << base3
+      registers_to_read = [19..20, 30, 344, 740..741, 900, 1110..1111, 1114, 1117, 1147..1153, 1165, 3027, 31_003]
+      if zones.first.is_a?(IZ2Zone)
+        zones.each_with_index do |_z, i|
+          base1 = 21_203 + i * 9
+          base2 = 31_007 + i * 3
+          base3 = 31_200 + i * 3
+          registers_to_read << (base1..(base1 + 1))
+          registers_to_read << (base2..(base2 + 2))
+          registers_to_read << base3
+        end
+      else
+        registers_to_read << 745..747
       end
 
       registers = @modbus_slave.holding_registers[*registers_to_read]
@@ -48,35 +63,42 @@ module Aurora
       @dhw_water_temperature      = registers[1114]
       @waterflow                  = registers[1117]
       @compressor_speed           = registers[3027]
-      @outdoor_temperature        = registers[31003]
+      @outdoor_temperature        = registers[31_003]
       @fp1                        = registers[19]
       @fp2                        = registers[20]
       @locked_out                 = registers[1117]
+      @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]
-      if outputs.include?(:lockout)
-        @current_mode = :lockout
-      elsif outputs.include?(:cc2)
-        @current_mode = outputs.include?(:rv) ? :c2 : :h2
-      elsif outputs.include?(:cc)
-        @current_mode = outputs.include?(:rv) ? :c1 : :h1
-      elsif outputs.include?(:eh2)
-        @current_mode = :eh2
-      elsif outputs.include?(:eh1)
-        @current_mode = :eh1
-      elsif outputs.include?(:blower)
-        @current_mode = :blower
-      else
-        @current_mode = :standby
-      end
+      @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 outputs.include?(:eh2)
+                        :eh2
+                      elsif outputs.include?(:eh1)
+                        :eh1
+                      elsif outputs.include?(:blower)
+                        :blower
+                      else
+                        :standby
+                      end
 
-      iz2_zones.each do |z|
+      zones.each do |z|
         z.refresh(registers)
       end
     end
 
     def inspect
-      "#<Aurora::ABCClient #{(instance_variables - [:@modbus_slave]).map { |iv| "#{iv}=#{instance_variable_get(iv).inspect}" }.join(', ')}>"
+      "#<Aurora::ABCClient #{(instance_variables - [:@modbus_slave]).map do |iv|
+                               "#{iv}=#{instance_variable_get(iv).inspect}"
+                             end.join(', ')}>"
     end
   end
 end