waterfurnace_aurora 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d968e612fad4716e6bebfa9190d31fd40124ae5f5d793d61defe131929aee135
-  data.tar.gz: c8309747cbbb06b7649620a0c065015de5ac53237e460bb8ff9138669e6315f3
+  metadata.gz: 353f714b82fb803a5a816781e39f1e952fea04485fa09d32f36f363b003bcfd3
+  data.tar.gz: 70b12365ae3f13cfca0fd70104d552efee6b520985e2844795a480130ae42929
 SHA512:
-  metadata.gz: 01c73b395a6f32e9d30db37a6d9bedcb82a0f2059163dd511e356c0bccd68ed2037ef6a7fcc880a4e030a6f355af835ceab67f9aa77fbb69258800c86c985730
-  data.tar.gz: d8dd44d7963e4d79dd81f8329435fe2fbb51e4e4b8e98008a6e014da8d9a97ef4910c776bd34e7d821af244555f62e60d625b8d14101c4501d39edfd30fea4fa
+  metadata.gz: 40937d99b2c3cc6044f6ddfda7ef3c8e789192e31e7ca47e5057f18c4deeb5b33a745bcef155a0c78bc35ce598f631e5d3a9bbbb18bb3b739d0aab7c4b87e2c7
+  data.tar.gz: 4c7e83279bce76b4baa09d74b5b56394822405694fbcecc3b8674caedb9eef9e0baeea518305e1268ac39c719e411010c9d78c00ab1cccb9b0378763b0809873

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/{bin → exe}/aurora_monitor

@@ -1,27 +1,28 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require 'aurora'
-require 'ccutrer-serialport'
-require 'socket'
-require 'uri'
+require "aurora"
+require "ccutrer-serialport"
+require "socket"
+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' => 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
 
 server = ModBus::RTUServer.new(*args)
 server.promiscuous = true
 server.debug = true
 
-server.request_callback = ->(uid, func, req) do
+server.request_callback = lambda { |uid, func, req|
   if func == 68
     puts "===== no idea to #{uid}: #{req.inspect}"
   elsif func == 67
@@ -33,12 +34,13 @@ server.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
+}
 
-server.response_callback = ->(uid, func, res, req) do
+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"
@@ -66,11 +68,11 @@ server.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
+}
 
-require 'byebug'
 server.send(:serve, server.instance_variable_get(:@sp))
-loop {}
+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 do |z|
+            homie_zone = @homie["zone#{z.zone_number}"]
+            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 do |zone|
+      type = zone.is_a?(Aurora::IZ2Zone) ? "IntelliZone 2 Zone" : "Thermostat"
+      @homie.node("zone#{zone.zone_number}", "Zone #{zone.zone_number}", type) do |node|
+        allowed_modes = %w[off auto cool heat]
+        allowed_modes << "eheat" if !zone.respond_to?(:zone_number) || zone.zone_number == 1
+        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