waterfurnace_aurora 0.3.13 → 0.4.3

data/lib/aurora/abc_client.rb

@@ -1,39 +1,88 @@
 # frozen_string_literal: true
 
+require "yaml"
+require "uri"
+
+require "aurora/blower"
+require "aurora/iz2_zone"
+require "aurora/pump"
+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,
+                :pump,
                 :faults,
                 :current_mode,
-                :fan_speed,
+                :dhw_enabled,
+                :dhw_setpoint,
                 :entering_air_temperature,
                 :relative_humidity,
                 :leaving_air_temperature,
                 :leaving_water_temperature,
                 :entering_water_temperature,
                 :dhw_water_temperature,
-                :waterflow,
                 :compressor_speed,
                 :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..413, 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
+      @pump = if (3..5).include?(raw_registers[413])
+                Pump::VSPump.new(self,
+                                 registers[413])
+              else
+                Pump::GenericPump.new(self,
+                                      registers[413])
+              end
 
       @zones = if iz2?
                  iz2_zone_count = @modbus_slave.holding_registers[483]
@@ -79,8 +128,13 @@ module Aurora
     end
 
     def refresh
-      registers_to_read = [6, 19..20, 25, 30, 340, 344, 347, 362, 740..741, 900, 1110..1111, 1114, 1147..1153, 1165,
-                           3027, 31_003]
+      registers_to_read = [6, 19..20, 25, 30, 344, 740..741, 900, 1110..1111, 1114, 1147..1153, 1165,
+                           31_003]
+      registers_to_read << (400..401) if dhw?
+      registers_to_read.concat(blower.registers_to_read)
+      registers_to_read.concat(pump.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
@@ -100,15 +154,25 @@ 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]
       @leaving_water_temperature  = registers[1110]
       @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]
@@ -116,23 +180,16 @@ module Aurora
       @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]
-      @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 registers[362]
                         :dehumidify
-                      elsif outputs.include?(:cc2)
-                        outputs.include?(:rv) ? :c2 : :h2
-                      elsif outputs.include?(:cc)
-                        outputs.include?(:rv) ? :c1 : :h1
+                      elsif outputs.include?(:cc2) || outputs.include?(:cc)
+                        outputs.include?(:rv) ? :cooling : :heating
                       elsif outputs.include?(:eh2)
                         outputs.include?(:rv) ? :eh2 : :emergency
                       elsif outputs.include?(:eh1)
@@ -145,6 +202,9 @@ module Aurora
                         :standby
                       end
 
+      blower.refresh(registers)
+      pump.refresh(registers)
+
       zones.each do |z|
         z.refresh(registers)
       end
@@ -172,7 +232,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)
@@ -193,6 +255,12 @@ 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
@@ -224,11 +292,24 @@ module Aurora
       @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}

data/lib/aurora/blower.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "aurora/component"
+
+module Aurora
+  module Blower
+    class GenericBlower < Component
+      attr_reader :type, :watts
+
+      def initialize(abc, type)
+        super(abc)
+        @type = type
+      end
+
+      def registers_to_read
+        if abc.energy_monitoring?
+          [1148..1149]
+        else
+          []
+        end
+      end
+
+      def refresh(registers)
+        @watts = registers[1148] if abc.energy_monitoring?
+      end
+    end
+
+    class PSC < GenericBlower
+      attr_reader :running
+      alias running? running
+
+      def refresh(registers)
+        @running = registers[30].include?(:g)
+      end
+    end
+
+    class FiveSpeed < GenericBlower
+      attr_reader :speed
+
+      def speed_range
+        0..4
+      end
+
+      def refresh(registers)
+        outputs = registers[30]
+        @speed = if outputs.include?(:eh1)
+                   4
+                 elsif outputs.include?(:cc2)
+                   3
+                 elsif outputs.include?(:cc)
+                   2
+                 elsif outputs.include?(:g)
+                   1
+                 else
+                   0
+                 end
+      end
+    end
+
+    class ECM < GenericBlower
+      attr_reader :speed, :blower_only_speed, :low_compressor_speed, :high_compressor_speed, :aux_heat_speed,
+                  :iz2_desired_speed
+
+      def speed_range
+        0..12
+      end
+
+      def registers_to_read
+        result = super + [340..342, 344, 347]
+        result << 565 if abc.iz2?
+        result
+      end
+
+      def refresh(registers)
+        super
+
+        @speed                  = registers[344]
+        @blower_only_speed      = registers[340]
+        @low_compressor_speed   = registers[341]
+        @high_compressor_speed  = registers[342]
+        @aux_heat_speed         = registers[347]
+        @iz2_desired_speed      = registers[565] if abc.iz2?
+      end
+
+      { blower_only: 340,
+        low_compressor: 341,
+        high_compressor: 342,
+        aux_heat: 347 }.each do |(setting, register)|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{setting}_speed=(value)
+            raise ArgumentError unless (1..12).include?(value)
+
+            holding_registers[#{register}] = value
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/aurora/component.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Aurora
+  class Component
+    def initialize(abc)
+      @abc = abc
+    end
+
+    private
+
+    attr_reader :abc
+
+    def holding_registers
+      abc.modbus_slave.holding_registers
+    end
+  end
+end

data/lib/aurora/mock_abc.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Aurora
+  class MockABC
+    attr_accessor :logger
+
+    def initialize(registers)
+      @registers = registers
+    end
+
+    def read_retry_timeout=(_); end
+
+    def read_retries=(_); end
+
+    def holding_registers
+      self
+    end
+
+    def [](*register)
+      if register.length == 1
+        case register.first
+        when Integer
+          @registers[register.first]
+        when Range
+          @registers.values_at(*register.first.to_a)
+        else
+          raise ArgumentError, "Not implemented yet #{register.inspect}"
+        end
+      else
+        read_multiple_holding_registers(*register)
+      end
+    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
+    alias []= write_holding_register
+  end
+end

data/lib/aurora/pump.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "aurora/component"
+
+module Aurora
+  module Pump
+    class GenericPump < Component
+      attr_reader :type, :watts, :waterflow
+
+      def initialize(abc, type)
+        super(abc)
+        @type = type
+      end
+
+      def registers_to_read
+        result = [1117]
+        result.concat([1164..1165]) if abc.energy_monitoring?
+        result
+      end
+
+      def refresh(registers)
+        @waterflow = registers[1117]
+        @watts = registers[1164] if abc.energy_monitoring?
+      end
+    end
+
+    class VSPump < GenericPump
+      attr_reader :speed, :minimum_speed, :maximum_speed, :manual_control
+      alias manual_control? manual_control
+
+      def registers_to_read
+        super + [321..325]
+      end
+
+      def refresh(registers)
+        super
+        @minimum_speed = registers[321]
+        @maximum_speed = registers[322]
+        @manual_control = registers[323] != :off
+        @speed = registers[325]
+      end
+
+      def manual_control=(value)
+        holding_registers[323] = value ? speed : 0x7fff
+      end
+
+      { speed: 323,
+        minimum_speed: 321,
+        maximum_speed: 322 }.each do |(setting, register)|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{setting}=(value)
+            raise ArgumentError unless (1..100).include?(value)
+
+            holding_registers[#{register}] = value
+          end
+        RUBY
+      end
+    end
+  end
+end