waterfurnace_aurora 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d968e612fad4716e6bebfa9190d31fd40124ae5f5d793d61defe131929aee135
+  data.tar.gz: c8309747cbbb06b7649620a0c065015de5ac53237e460bb8ff9138669e6315f3
+SHA512:
+  metadata.gz: 01c73b395a6f32e9d30db37a6d9bedcb82a0f2059163dd511e356c0bccd68ed2037ef6a7fcc880a4e030a6f355af835ceab67f9aa77fbb69258800c86c985730
+  data.tar.gz: d8dd44d7963e4d79dd81f8329435fe2fbb51e4e4b8e98008a6e014da8d9a97ef4910c776bd34e7d821af244555f62e60d625b8d14101c4501d39edfd30fea4fa

data/bin/aurora_fetch

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+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' => 19200,
+    'parity' => Net::Telnet::RFC2217::EVEN)]
+else
+  [CCutrer::SerialPort.new(uri.path, baud: 19200, 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/aurora_mock

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+
+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
+
+port = ARGV[1]&.to_i || 502
+
+server1 = ModBus::RTUServer.new(*args)
+server1.debug = true
+# AID Tool queries slave 1, AWL queries slave 2; just use both
+slave1 = server1.with_slave(1)
+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)
+
+# prepopulate some data
+registers = YAML.load(File.read(File.expand_path('../registers.yml', __FILE__)))
+registers.each { |(k, v)| r[k] = v }
+
+server1.request_callback = ->(uid, func, req) do
+  if func == 68
+    puts "===== no idea to #{uid}: #{req.inspect}"
+  elsif func == 67
+    puts "===== write discontiguous registers to #{uid}:"
+    registers = req.map { |p| [p[:addr], p[:val]] }.to_h
+    puts Aurora.print_registers(registers)
+  elsif func == 16
+    puts "===== write multiple registers to #{uid}:"
+    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)
+  else
+    puts "**** new func #{func}"
+  end
+end
+
+server1.response_callback = ->(uid, func, res, req) do
+  if func == 3 && res.is_a?(Array) && req
+    unless req[:quant] == res.length
+      puts "wrong number of results"
+      next
+    end
+    puts "===== read registers from #{uid}"
+    registers = Range.new(req[:addr], req[:addr] + req[:quant], true).to_a.zip(res).to_h
+    puts Aurora.print_registers(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 "===== read multiple register ranges from #{uid}"
+    result = register_list.zip(res).to_h
+    puts Aurora.print_registers(result)
+  elsif func == 66 && res.is_a?(Array) && req
+    unless req.length == res.length
+      puts "wrong number of results"
+      next
+    end
+    puts "===== read discontiguous registers from #{uid}"
+    registers = req.zip(res).to_h
+    puts Aurora.print_registers(registers)
+  elsif [16, 67, 68].include?(func)
+  else
+    puts "**** new func #{func}"
+  end
+end
+
+server2.start
+server1.send(:serve, server1.instance_variable_get(:@sp))
+#server1.start
+loop {}

data/bin/aurora_monitor

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+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
+
+server = ModBus::RTUServer.new(*args)
+server.promiscuous = true
+server.debug = true
+
+server.request_callback = ->(uid, func, req) do
+  if func == 68
+    puts "===== no idea to #{uid}: #{req.inspect}"
+  elsif func == 67
+    puts "===== write discontiguous registers to #{uid}:"
+    registers = req.map { |p| [p[:addr], p[:val]] }.to_h
+    puts Aurora.print_registers(registers)
+  elsif func == 16
+    puts "===== write multiple registers to #{uid}:"
+    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)
+  else
+    puts "**** new func #{func}"
+  end
+end
+
+server.response_callback = ->(uid, func, res, req) do
+  if func == 3 && res.is_a?(Array) && req
+    unless req[:quant] == res.length
+      puts "wrong number of results"
+      next
+    end
+    puts "===== read registers from #{uid}"
+    registers = Range.new(req[:addr], req[:addr] + req[:quant], true).to_a.zip(res).to_h
+    puts Aurora.print_registers(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 "===== read multiple register ranges from #{uid}"
+    result = register_list.zip(res).to_h
+    puts Aurora.print_registers(result)
+  elsif func == 66 && res.is_a?(Array) && req
+    unless req.length == res.length
+      puts "wrong number of results"
+      next
+    end
+    puts "===== read discontiguous registers from #{uid}"
+    registers = req.zip(res).to_h
+    puts Aurora.print_registers(registers)
+  elsif [16, 67, 68].include?(func)
+  else
+    puts "**** new func #{func}"
+  end
+end
+
+require 'byebug'
+server.send(:serve, server.instance_variable_get(:@sp))
+loop {}

data/bin/aurora_mqtt_bridge

@@ -0,0 +1,289 @@
+#!/usr/bin/env ruby
+
+require 'aurora'
+require 'mqtt'
+require 'ccutrer-serialport'
+require 'uri'
+
+uri = URI.parse(ARGV[0])
+mqtt_uri = URI.parse(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' => 19200,
+    'parity' => Net::Telnet::RFC2217::EVEN)]
+else
+  [CCutrer::SerialPort.new(uri.path, baud: 19200, parity: :even)]
+end
+
+slave = ModBus::RTUClient.new(*args).with_slave(1)
+abc = Aurora::ABCClient.new(slave)
+
+class MQTTBridge
+  def initialize(abc, mqtt_uri)
+    @base_topic = "homie/aurora"
+    @abc = abc
+    @mqtt = MQTT::Client.new(mqtt_uri)
+    @mqtt.set_will("#{@base_topic}/$state", "lost", true, 1)
+    @mqtt.connect
+    @attributes = {}
+    @mutex = Mutex.new
+
+    publish_basic_attributes
+
+    abc_thread = Thread.new do
+      loop do
+        begin
+          @mutex.synchronize do
+            @abc.refresh
+            publish_attribute("abc/compressor-speed", @abc.compressor_speed)
+            publish_attribute("abc/current-mode", @abc.current_mode)
+            publish_attribute("abc/dhw-water-temperature", @abc.dhw_water_temperature)
+            publish_attribute("abc/entering-air-temperature", @abc.entering_air_temperature)
+            publish_attribute("abc/entering-water-temperature", @abc.entering_water_temperature)
+            publish_attribute("abc/fan-speed", @abc.fan_speed)
+            publish_attribute("abc/leaving-air-temperature", @abc.leaving_air_temperature)
+            publish_attribute("abc/leaving-water-temperature", @abc.leaving_water_temperature)
+            publish_attribute("abc/outdoor-temperature", @abc.outdoor_temperature)
+            publish_attribute("abc/relative-humidity", @abc.relative_humidity)
+            publish_attribute("abc/waterflow", @abc.waterflow)
+            publish_attribute("abc/fp1", @abc.fp1)
+            publish_attribute("abc/fp2", @abc.fp2)
+
+            @abc.iz2_zones.each do |z|
+              i = z.zone_number
+              publish_attribute("zone#{i}/target-mode", z.target_mode)
+              publish_attribute("zone#{i}/current-mode", z.current_mode)
+              publish_attribute("zone#{i}/target-fan-mode", z.target_fan_mode)
+              publish_attribute("zone#{i}/current-fan-mode", z.current_fan_mode)
+              publish_attribute("zone#{i}/fan-intermittent-on", z.fan_intermittent_on)
+              publish_attribute("zone#{i}/fan-intermittent-off", z.fan_intermittent_off)
+              publish_attribute("zone#{i}/priority", z.priority)
+              publish_attribute("zone#{i}/size", z.size)
+              publish_attribute("zone#{i}/normalized-size", z.normalized_size)
+              publish_attribute("zone#{i}/ambient-temperature", z.ambient_temperature)
+              publish_attribute("zone#{i}/heating-target-temperature", z.heating_target_temperature)
+              publish_attribute("zone#{i}/cooling-target-temperature", z.cooling_target_temperature)
+            end
+          end
+        rescue => e
+          puts "got garbage: #{e}; #{e.backtrace}"
+          exit 1
+        end
+        sleep(5)
+      end
+    end
+
+    @mqtt.get do |topic, value|
+      puts "got #{value.inspect} at #{topic}"
+      zone = topic =~ %r{zone([1-6])/} && @abc.iz2_zones[$1.to_i - 1]
+
+      begin
+        @mutex.synchronize do
+          case topic
+          when %r{zone([1-6])/target-mode/set$}
+            publish_attribute("zone#{$1}/target-mode", zone.target_mode = value.to_sym)
+          when %r{zone([1-6])/target-fan-mode/set$}
+            publish_attribute("zone#{$1}/target-fan-mode", zone.target_fan_mode = value.to_sym)
+          when %r{zone([1-6])/fan-intermittent-(on|off)/set$}
+            publish_attribute("zone#{$1}/fan-intermittent-#{$2}", zone.send("fan_intermittent_#{$2}=", value.to_i))
+          when %r{zone([1-6])/(heating|cooling)-target-temperature}
+            publish_attribute("zone#{$1}/#{$2}-target-temperature", zone.send("#{$2}_target_temperature=", value.to_f))
+          when /\$modbus$/
+            query = value.split(',').map do |addr|
+              if addr == "known"
+                Aurora::REGISTER_NAMES.keys
+              elsif addr =~ /^(\d+)\.\.(\d+)$/
+                $1.to_i..$2.to_i
+              else
+                addr.to_i
+              end
+            end
+            queries = Aurora.normalize_ranges(query)
+            registers = {}
+            queries.each do |query|
+              registers.merge!(@abc.modbus_slave.read_multiple_holding_registers(*query))
+            end
+            result = Aurora.print_registers(registers)
+            @mqtt.publish("#{@base_topic}/$modbus/response", result, false, 1)
+          when %r{\$modbus/(\d+)$}
+            register = $1.to_i
+            value = case value
+            when /\d+/
+              value.to_i
+            when /0x(\d+)/
+              $1.to_i(16)
+            end
+            @abc.modbus_slave.holding_registers[register] = value if value
+          end
+        end
+      rescue => e
+        puts "failed processing message: #{e}\n#{e.backtrace}"
+      end
+    end
+  end
+
+  def publish(topic, value)
+    @mqtt.publish("#{@base_topic}/#{topic}", value, true, 1)
+  end
+
+  def publish_attribute(attr, value)
+    if !@attributes.key?(attr) || @attributes[attr] != value
+      publish(attr, value.to_s)
+      @attributes[attr] = value
+    end
+  end
+
+  def subscribe(topic)
+    @mqtt.subscribe("#{@base_topic}/#{topic}")
+  end
+
+  def publish_basic_attributes
+    publish("$homie", "4.0.0")
+    publish("$name", "Aurora MQTT Bridge")
+    publish("$state", "init")
+    nodes = ["abc"]
+
+    publish("abc/$name", "Aurora Basic Control")
+    publish("abc/$datatype", "ABC")
+    publish("abc/$properties", "compressor-speed,current-mode,dhw-water-temperature,entering-air-temperature,entering-water-temperature,fan-speed,leaving-air-temperature,leaving-water-temperature,outdoor-temperature,relative-humidity,waterflow,fp1,fp2")
+
+    publish("abc/compressor-speed/$name", "Compressor Speed")
+    publish("abc/compressor-speed/$datatype", "integer")
+    publish("abc/compressor-speed/$format", "0:12")
+
+    publish("abc/current-mode/$name", "Current Heating/Cooling Mode")
+    publish("abc/current-mode/$datatype", "enum")
+    publish("abc/current-mode/$format", "lockout,standby,blower,h1,h2,c1,c2,eh1,eh2")
+
+    publish("abc/dhw-water-temperature/$name", "DHW Water Temperature")
+    publish("abc/dhw-water-temperature/$datatype", "float")
+    publish("abc/dhw-water-temperature/$unit", "ºF")
+
+    publish("abc/entering-air-temperature/$name", "Entering Air Temperature")
+    publish("abc/entering-air-temperature/$datatype", "float")
+    publish("abc/entering-air-temperature/$unit", "ºF")
+
+    publish("abc/entering-water-temperature/$name", "Entering Water Temperature")
+    publish("abc/entering-water-temperature/$datatype", "float")
+    publish("abc/entering-water-temperature/$unit", "ºF")
+
+    publish("abc/fan-speed/$name", "Fan Speed")
+    publish("abc/fan-speed/$datatype", "integer")
+    publish("abc/fan-speed/$format", "0:11")
+
+    publish("abc/leaving-air-temperature/$name", "Leaving Air Temperature")
+    publish("abc/leaving-air-temperature/$datatype", "float")
+    publish("abc/leaving-air-temperature/$unit", "ºF")
+
+    publish("abc/leaving-water-temperature/$name", "Leaving Water Temperature")
+    publish("abc/leaving-water-temperature/$datatype", "float")
+    publish("abc/leaving-water-temperature/$unit", "ºF")
+
+    publish("abc/outdoor-temperature/$name", "Outdoor Temperature")
+    publish("abc/outdoor-temperature/$datatype", "float")
+    publish("abc/outdoor-temperature/$unit", "ºF")
+
+    publish("abc/relative-humidity/$name", "Relative Humidity")
+    publish("abc/relative-humidity/$datatype", "integer")
+    publish("abc/relative-humidity/$unit", "%")
+    publish("abc/relative-humidity/$format", "0:100")
+
+    publish("abc/waterflow/$name", "Waterflow")
+    publish("abc/waterflow/$datatype", "float")
+    publish("abc/waterflow/$unit", "gpm")
+
+    publish("abc/fp1/$name", "FP1 Sensor")
+    publish("abc/fp1/$datatype", "float")
+    publish("abc/fp1/$unit", "ºF")
+
+    publish("abc/fp2/$name", "FP1 Sensor")
+    publish("abc/fp2/$datatype", "float")
+    publish("abc/fp2/$unit", "ºF")
+
+    (1..@abc.iz2_zones.length).each do |i|
+      nodes << "zone#{i}"
+      publish("zone#{i}/$name", "Zone #{i}")
+      publish("zone#{i}/$datatype", "IntelliZone 2 Zone")
+      publish("zone#{i}/$properties", "target-mode,current-mode,target-fan-mode,current-fan-mode,fan-intermittent-on,fan-intermittent-off,priority,size,normalized-size,ambient-temperature,heating-target-temperature,cooling-target-temperature")
+
+      publish("zone#{i}/target-mode/$name", "Target Heating/Cooling Mode")
+      publish("zone#{i}/target-mode/$datatype", "enum")
+      if i == 1
+        publish("zone#{i}/target-mode/$format", "off,auto,cool,heat,eheat")
+      else
+        publish("zone#{i}/target-mode/$format", "off,auto,cool,heat")
+      end
+      publish("zone#{i}/target-mode/$settable", "true")
+      subscribe("zone#{i}/target-mode/set")
+
+      publish("zone#{i}/current-mode/$name", "Current Heating/Cooling Mode Requested")
+      publish("zone#{i}/current-mode/$datatype", "enum")
+      publish("zone#{i}/current-mode/$format", "standby,h1,h2,h3,c1,c2")
+
+      publish("zone#{i}/target-fan-mode/$name", "Target Fan Mode")
+      publish("zone#{i}/target-fan-mode/$datatype", "enum")
+      publish("zone#{i}/target-fan-mode/$format", "auto,continuous,intermittent")
+      publish("zone#{i}/target-fan-mode/$settable", "true")
+      subscribe("zone#{i}/target-fan-mode/set")
+
+      publish("zone#{i}/current-fan-mode/$name", "Current Fan Status")
+      publish("zone#{i}/current-fan-mode/$datatype", "boolean")
+
+      publish("zone#{i}/fan-intermittent-on/$name", "Fan Intermittent Mode On Duration")
+      publish("zone#{i}/fan-intermittent-on/$datatype", "enum")
+      publish("zone#{i}/fan-intermittent-on/$format", "0,5,10,15,20")
+      publish("zone#{i}/fan-intermittent-on/$unit", "M")
+      publish("zone#{i}/fan-intermittent-on/$settable", "true")
+      subscribe("zone#{i}/fan-intermittent-on/set")
+
+      publish("zone#{i}/fan-intermittent-off/$name", "Fan Intermittent Mode Off Duration")
+      publish("zone#{i}/fan-intermittent-off/$datatype", "enum")
+      publish("zone#{i}/fan-intermittent-off/$format", "0,5,10,15,20,25,30,35,40")
+      publish("zone#{i}/fan-intermittent-off/$unit", "M")
+      publish("zone#{i}/fan-intermittent-off/$settable", "true")
+      subscribe("zone#{i}/fan-intermittent-off/set")
+
+      publish("zone#{i}/priority/$name", "Zone Priority")
+      publish("zone#{i}/priority/$datatype", "enum")
+      publish("zone#{i}/priority/$format", "economy,comfort")
+
+      publish("zone#{i}/size/$name", "Size")
+      publish("zone#{i}/size/$datatype", "enum")
+      publish("zone#{i}/size/$format", "0,25,45,70")
+
+      publish("zone#{i}/normalized-size/$name", "Normalized Size")
+      publish("zone#{i}/normalized-size/$datatype", "integer")
+      publish("zone#{i}/normalized-size/$format", "0:100")
+      publish("zone#{i}/normalized-size/$unit", "%")
+
+      publish("zone#{i}/ambient-temperature/$name", "Ambient Temperature")
+      publish("zone#{i}/ambient-temperature/$datatype", "float")
+      publish("zone#{i}/ambient-temperature/$unit", "ºF")
+
+      publish("zone#{i}/heating-target-temperature/$name", "Heating Target Temperature")
+      publish("zone#{i}/heating-target-temperature/$datatype", "integer")
+      publish("zone#{i}/heating-target-temperature/$unit", "ºF")
+      publish("zone#{i}/heating-target-temperature/$format", "40:90")
+      publish("zone#{i}/heating-target-temperature/$settable", "true")
+      subscribe("zone#{i}/heating-target-temperature/set")
+
+      publish("zone#{i}/cooling-target-temperature/$name", "Cooling Target Temperature")
+      publish("zone#{i}/cooling-target-temperature/$datatype", "integer")
+      publish("zone#{i}/cooling-target-temperature/$unit", "ºF")
+      publish("zone#{i}/cooling-target-temperature/$format", "54:99")
+      publish("zone#{i}/cooling-target-temperature/$settable", "true")
+      subscribe("zone#{i}/cooling-target-temperature/set")
+    end
+    publish("$nodes", nodes.join(','))
+
+    # direct access to modbus registers for debugging purposes
+    subscribe("$modbus")
+    subscribe("$modbus/+")
+    publish("$state", 'ready')
+  end
+end
+
+MQTTBridge.new(abc, mqtt_uri)