balboa_worldwide_app 1.2.5 → 2.0.2

data/lib/bwa/client.rb

@@ -1,26 +1,59 @@
-require 'uri'
+# frozen_string_literal: true
 
-require 'bwa/message'
+require "forwardable"
+require "uri"
+
+require "bwa/logger"
+require "bwa/message"
 
 module BWA
   class Client
-    attr_reader :last_status, :last_control_configuration, :last_control_configuration2, :last_filter_configuration
+    extend Forwardable
+
+    attr_reader :status, :control_configuration, :configuration, :filter_cycles
+
+    delegate model: :control_configuration
+    delegate %i[hold
+                hold?
+                priming
+                priming?
+                heating_mode
+                temperature_scale
+                twenty_four_hour_time
+                twenty_four_hour_time?
+                heating
+                heating?
+                temperature_range
+                current_temperature
+                target_temperature
+                circulation_pump
+                blower
+                mister
+                pumps
+                lights
+                aux] => :status
 
     def initialize(uri)
       uri = URI.parse(uri)
-      if uri.scheme == 'tcp'
-        require 'socket'
-        @io = TCPSocket.new(uri.host, uri.port || 4217)
-      elsif uri.scheme == 'telnet' || uri.scheme == 'rfc2217'
-        require 'net/telnet/rfc2217'
-        @io = Net::Telnet::RFC2217.new("Host" => uri.host, "Port" => uri.port || 23, "baud" => 115200)
+      case uri.scheme
+      when "tcp"
+        require "socket"
+        @io = TCPSocket.new(uri.host, uri.port || 4257)
+      when "telnet", "rfc2217"
+        require "net/telnet/rfc2217"
+        @io = Net::Telnet::RFC2217.new("Host" => uri.host, "Port" => uri.port || 23, "baud" => 115_200)
         @queue = []
       else
-        require 'ccutrer-serialport'
-        @io = CCutrer::SerialPort.new(uri.path, baud: 115200)
+        require "ccutrer-serialport"
+        @io = CCutrer::SerialPort.new(uri.path, baud: 115_200)
         @queue = []
       end
-      @buffer = ""
+      @src = 0x0a
+      @buffer = +""
+    end
+
+    def full_configuration?
+      status && control_configuration && configuration && filter_cycles
     end
 
     def poll
@@ -43,18 +76,20 @@ module BWA
       end
 
       if message.is_a?(Messages::Ready) && (msg = @queue&.shift)
-        puts "wrote #{msg.unpack('H*').first}"
+        unless BWA.verbosity < 1 && msg[3..4] == Messages::ControlConfigurationRequest::MESSAGE_TYPE
+          BWA.logger.debug "wrote: #{BWA.raw2str(msg)}"
+        end
         @io.write(msg)
       end
-      @last_status = message.dup if message.is_a?(Messages::Status)
-      @last_filter_configuration = message.dup if message.is_a?(Messages::FilterCycles)
-      @last_control_configuration = message.dup if message.is_a?(Messages::ControlConfiguration)
-      @last_control_configuration2 = message.dup if message.is_a?(Messages::ControlConfiguration2)
+      @status = message.dup if message.is_a?(Messages::Status)
+      @filter_cycles = message.dup if message.is_a?(Messages::FilterCycles)
+      @control_configuration = message.dup if message.is_a?(Messages::ControlConfiguration)
+      @configuration = message.dup if message.is_a?(Messages::ControlConfiguration2)
       message
     end
 
     def messages_pending?
-      !!IO.select([@io], nil, nil, 0)
+      !!@io.wait_readable(0)
     end
 
     def drain_message_queue
@@ -62,132 +97,170 @@ module BWA
     end
 
     def send_message(message)
-      length = message.length + 2
-      full_message = "#{length.chr}#{message}".force_encoding(Encoding::ASCII_8BIT)
-      checksum = CRC.checksum(full_message)
-      full_message = "\x7e#{full_message}#{checksum.chr}\x7e".force_encoding(Encoding::ASCII_8BIT)
+      message.src = @src
+      full_message = message.serialize
+      unless BWA.verbosity < 1 && message.is_a?(Messages::ControlConfigurationRequest)
+        BWA.logger.info "  to spa: #{message.inspect}"
+      end
       if @queue
         @queue.push(full_message)
       else
+        unless BWA.verbosity < 1 && message.is_a?(Messages::ControlConfigurationRequest)
+          BWA.logger.debug "wrote: #{BWA.raw2str(full_message)}"
+        end
         @io.write(full_message)
       end
     end
 
     def request_configuration
-      send_message("\x0a\xbf\x04")
+      send_message(Messages::ConfigurationRequest.new)
     end
 
     def request_control_info2
-      send_message("\x0a\xbf\x22\x00\x00\x01")
+      send_message(Messages::ControlConfigurationRequest.new(2))
     end
 
     def request_control_info
-      send_message("\x0a\xbf\x22\x02\x00\x00")
+      send_message(Messages::ControlConfigurationRequest.new(1))
     end
 
     def request_filter_configuration
-      send_message("\x0a\xbf\x22\x01\x00\x00")
+      send_message(Messages::ControlConfigurationRequest.new(3))
     end
 
     def toggle_item(item)
-      send_message("\x0a\xbf\x11#{item.chr}\x00")
+      send_message(Messages::ToggleItem.new(item))
+    end
+
+    def toggle_pump(index)
+      toggle_item(index + 0x04)
     end
 
-    def toggle_pump(i)
-      toggle_item(i + 3)
+    def toggle_light(index)
+      toggle_item(index + 0x11)
     end
 
-    def toggle_light(i)
-      toggle_item(i + 0x10)
+    def toggle_aux(index)
+      toggle_item(index + 0x16)
     end
 
     def toggle_mister
-      toggle_item(0x0e)
+      toggle_item(:mister)
     end
 
     def toggle_blower
-      toggle_item(0x0c)
+      toggle_item(:blower)
     end
 
-    def set_pump(i, desired)
-      return unless last_status && last_control_configuration2
-      times = (desired - last_status.pumps[i - 1]) % (last_control_configuration2.pumps[i - 1] + 1)
+    def toggle_hold
+      toggle_item(:hold)
+    end
+
+    def set_pump(index, desired)
+      return unless status && configuration
+
+      desired = 0 if desired == false
+      desired = 1 if desired == true
+      times = (desired - status.pumps[index]) % (configuration.pumps[index] + 1)
       times.times do
-        toggle_pump(i)
+        toggle_pump(index)
         sleep(0.1)
       end
     end
 
-    %w{light aux}.each do |type|
+    %i[light aux].each do |type|
+      suffix = "s" if type == :light
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def set_#{type}(i, desired)
-          return unless last_status
-          return if last_status.#{type}s[i - 1] == desired
-          toggle_#{type}(i)
+        def set_#{type}(index, desired)
+          return unless status
+          return if status.#{type}#{suffix}[index] == desired
+
+          toggle_#{type}(index)
         end
       RUBY
     end
 
-    def set_mister(desired)
-      return unless last_status
-      return if last_status.mister == desired
+    def mister=(desired)
+      return unless status
+      return if status.mister == desired
+
       toggle_mister
     end
 
-    def set_blower(desired)
-      return unless last_status && last_control_configuration2
-      times = (desired - last_status.blower) % (last_control_configuration2.blower + 1)
+    def blower=(desired)
+      return unless status && configuration
+
+      desired = 0 if desired == false
+      desired = 1 if desired == true
+      times = (desired - status.blower) % (configuration.blower + 1)
       times.times do
         toggle_blower
         sleep(0.1)
       end
     end
 
-    # high range is 80-104 for F, 26-40 for C (by 0.5)
-    # low range is 50-80 for F, 10-26 for C (by 0.5)
-    def set_temperature(desired)
-      desired *= 2 if last_status && last_status.temperature_scale == :celsius || desired < 50
-      send_message("\x0a\xbf\x20#{desired.round.chr}")
+    def hold=(desired)
+      return unless status
+      return if status.hold == desired
+
+      toggle_hold
+    end
+
+    # high range is 80-106 for F, 26-40 for C (by 0.5)
+    # low range is 50-99 for F, 10-26 for C (by 0.5)
+    def target_temperature=(desired)
+      return unless status
+      return if status.target_temperature == desired
+
+      desired *= 2 if (status && status.temperature_scale == :celsius) || desired < 50
+      send_message(Messages::SetTargetTemperature.new(desired.round))
+    end
+
+    def set_time(hour, minute, twenty_four_hour_time: false)
+      send_message(Messages::SetTime.new(hour, minute, twenty_four_hour_time))
     end
 
-    def set_time(hour, minute, twenty_four_hour_time = false)
-      hour |= 0x80 if twenty_four_hour_time
-      send_message("\x0a\xbf\x21".force_encoding(Encoding::ASCII_8BIT) + hour.chr + minute.chr)
+    def temperature_scale=(scale)
+      raise ArgumentError, "scale must be :fahrenheit or :celsius" unless %I[fahrenheit celsius].include?(scale)
+
+      send_message(Messages::SetTemperatureScale.new(scale))
     end
 
-    def set_temperature_scale(scale)
-      raise ArgumentError, "scale must be :fahrenheit or :celsius" unless %I{fahrenheit :celsius}.include?(scale)
-      arg = scale == :fahrenheit ? 0 : 1
-      send_message("\x0a\xbf\x27\x01".force_encoding(Encoding::ASCII_8BIT) + arg.chr)
+    def update_filter_cycles(new_filter_cycles)
+      send_message(new_filter_cycles)
+      @filter_cycles = new_filter_cycles.dup
+      request_filter_configuration
     end
 
     def toggle_temperature_range
       toggle_item(0x50)
     end
 
-    def set_temperature_range(desired)
-      return unless last_status
-      return if last_status.temperature_range == desired
+    def temperature_range=(desired)
+      return unless status
+      return if status.temperature_range == desired
+
       toggle_temperature_range
     end
 
     def toggle_heating_mode
-      toggle_item(0x51)
-    end
-
-    HEATING_MODES = %I{ready rest ready_in_rest}.freeze
-    def set_heating_mode(desired)
-      raise ArgumentError, "heating_mode must be :ready or :rest" unless %I{ready rest}.include?(desired)
-      return unless last_status
-      times = if last_status.heating_mode == :ready && desired == :rest ||
-                 last_status.heating_mode == :rest && desired == :ready ||
-                 last_status.heating_mode == :ready_in_rest && desired == :rest
-          1
-        elsif last_status.heating_mode == :ready_in_rest && desired == :ready
-          2
-        else
-          0
-        end
+      toggle_item(:heating_mode)
+    end
+
+    HEATING_MODES = %I[ready rest ready_in_rest].freeze
+    def heating_mode=(desired)
+      raise ArgumentError, "heating_mode must be :ready or :rest" unless %I[ready rest].include?(desired)
+      return unless status
+
+      times = if (status.heating_mode == :ready && desired == :rest) ||
+                 (status.heating_mode == :rest && desired == :ready) ||
+                 (status.heating_mode == :ready_in_rest && desired == :rest)
+                1
+              elsif status.heating_mode == :ready_in_rest && desired == :ready
+                2
+              else
+                0
+              end
       times.times { toggle_heating_mode }
     end
   end

data/lib/bwa/crc.rb

@@ -1,4 +1,6 @@
-require 'digest/crc'
+# frozen_string_literal: true
+
+require "digest/crc"
 
 module BWA
   class CRC < Digest::CRC8

data/lib/bwa/discovery.rb

@@ -1,26 +1,27 @@
-require 'socket'
+# frozen_string_literal: true
+
+require "socket"
+require "bwa/logger"
 
 module BWA
   class Discovery
     class << self
-      def discover(timeout = 5, exhaustive = false)
+      def discover(timeout = 5, exhaustive: false)
         socket = UDPSocket.new
         socket.bind("0.0.0.0", 0)
         socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, true)
-        socket.sendmsg("Discovery: Who is out there?", 0, Socket.sockaddr_in(30303, '255.255.255.255'))
+        socket.sendmsg("Discovery: Who is out there?", 0, Socket.sockaddr_in(30_303, "255.255.255.255"))
         spas = {}
         loop do
-          if IO.select([socket], nil, nil, timeout)
-            msg, ip = socket.recvfrom(64)
-            ip = ip[2]
-            name, mac = msg.split("\r\n")
-            name.strip!
-            if mac.start_with?("00-15-27-")
-              spas[ip] = name
-              break unless exhaustive
-            end
-          else
-            break
+          break unless socket.wait_readable(timeout)
+
+          msg, ip = socket.recvfrom(64)
+          ip = ip[2]
+          name, mac = msg.split("\r\n")
+          name.strip!
+          if mac.start_with?("00-15-27-")
+            spas[ip] = name
+            break unless exhaustive
           end
         end
         spas
@@ -28,13 +29,14 @@ module BWA
 
       def advertise
         socket = UDPSocket.new
-        socket.bind("0.0.0.0", 30303)
+        socket.bind("0.0.0.0", 30_303)
         msg = "BWGSPA\r\n00-15-27-00-00-01\r\n"
         loop do
           data, addr = socket.recvfrom(32)
-          next unless data == 'Discovery: Who is out there?'
+          next unless data == "Discovery: Who is out there?"
+
           ip = addr.last
-          puts "Advertising to #{ip}"
+          BWA.logger.info "Advertising to #{ip}"
           socket.sendmsg(msg, 0, Socket.sockaddr_in(addr[1], ip))
         end
       end

data/lib/bwa/logger.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module BWA
+  # This module logs to stdout by default, or you can provide a logger as BWA.logger.
+  # If using default logger, set LOG_LEVEL in the environment to control logging.
+  #
+  # Log levels are:
+  #
+  # FATAL - fatal errors
+  # ERROR - handled errors
+  # WARN  - problems while parsing known messages
+  # INFO  - unrecognized messages
+  # DEBUG - all messages
+  #
+  # Certain very frequent messages are suppressed by default even in DEBUG mode.
+  # Set LOG_VERBOSITY to one of the following levels to see these:
+  #
+  # 0 - default
+  # 1 - show status messages
+  # 2 - show ready and nothing-to-send messages
+  #
+  class << self
+    attr_writer :logger, :verbosity
+
+    def logger
+      @logger ||= Logger.new($stdout).tap do |log|
+        $stdout.sync = true
+        log.level = ENV.fetch("LOG_LEVEL", "WARN")
+        log.formatter = proc do |severity, _datetime, _progname, msg|
+          "#{severity[0..0]}, #{msg2logstr(msg)}\n"
+        end
+      end
+    end
+
+    def verbosity
+      @verbosity ||= ENV.fetch("LOG_VERBOSITY", "0").to_i
+      @verbosity
+    end
+
+    def msg2logstr(msg)
+      case msg
+      when ::String
+        msg
+      when ::Exception
+        "#{msg.message} (#{msg.class})\n#{msg.backtrace&.join("\n")}"
+      else
+        msg.inspect
+      end
+    end
+
+    def raw2str(data)
+      data.unpack1("H*").gsub!(/(..)/, "\\1 ").chop!
+    end
+  end
+end

data/lib/bwa/message.rb

@@ -1,4 +1,7 @@
-require 'bwa/crc'
+# frozen_string_literal: true
+
+require "bwa/logger"
+require "bwa/crc"
 
 module BWA
   class InvalidMessage < RuntimeError
@@ -11,30 +14,65 @@ module BWA
   end
 
   class Message
+    attr_accessor :src
+
     class Unrecognized < Message
     end
 
     class << self
       def inherited(klass)
+        super
+
         @messages ||= []
         @messages << klass
       end
 
+      # Ignore (parse and throw away) messages of these types.
+      IGNORED_MESSAGES = [
+        (+"\xbf\x00").force_encoding(Encoding::ASCII_8BIT), # request for new clients
+        (+"\xbf\xe1").force_encoding(Encoding::ASCII_8BIT),
+        (+"\xbf\x07").force_encoding(Encoding::ASCII_8BIT) # nothing to send
+      ].freeze
+
+      # Don't log messages of these types, even in DEBUG mode.
+      # They are very frequent and would swamp the logs.
+      def common_messages
+        @common_messages ||= begin
+          msgs = []
+          unless BWA.verbosity >= 1
+            msgs += [
+              Messages::Status::MESSAGE_TYPE,
+              (+"\xbf\xe1").force_encoding(Encoding::ASCII_8BIT)
+            ]
+          end
+          unless BWA.verbosity >= 2
+            msgs += [
+              (+"\xbf\x00").force_encoding(Encoding::ASCII_8BIT),
+              (+"\xbf\xe1").force_encoding(Encoding::ASCII_8BIT),
+              Messages::Ready::MESSAGE_TYPE,
+              (+"\xbf\x07").force_encoding(Encoding::ASCII_8BIT)
+            ]
+          end
+          msgs
+        end
+      end
+
       def parse(data)
         offset = -1
-        message_type = length = message_class = nil
+        message_type = length = nil
         loop do
           offset += 1
+          # Not enough data for a full message; return and hope for more
           return nil if data.length - offset < 5
 
           # Keep scanning until message start char
-          next unless data[offset] == '~'
+          next unless data[offset] == "~"
 
           # Read length (safe since we have at least 5 chars)
           length = data[offset + 1].ord
 
           # No message is this short or this long; keep scanning
-          next if length < 5 or length >= '~'.ord
+          next if (length < 5) || (length >= "~".ord)
 
           # don't have enough data for what this message wants;
           # return and hope for more (yes this might cause a
@@ -43,7 +81,7 @@ module BWA
           return nil if length + 2 > data.length - offset
 
           # Not properly terminated; keep scanning
-          next unless data[offset + length + 1] == '~'
+          next unless data[offset + length + 1] == "~"
 
           # Not a valid checksum; keep scanning
           next unless CRC.checksum(data.slice(offset + 1, length - 1)) == data[offset + length].ord
@@ -52,27 +90,33 @@ module BWA
           break
         end
 
-        puts "discarding invalid data prior to message #{data[0...offset].unpack('H*').first}" unless offset == 0
-        #puts "read #{data.slice(offset, length + 2).unpack('H*').first}"
+        message_type = data.slice(offset + 3, 2)
+        BWA.logger.debug "discarding invalid data prior to message #{BWA.raw2str(data[0...offset])}" unless offset.zero?
+        unless common_messages.include?(message_type)
+          BWA.logger.debug " read: #{BWA.raw2str(data.slice(offset,
+                                                            length + 2))}"
+        end
 
         src = data[offset + 2].ord
-        message_type = data.slice(offset + 3, 2)
         klass = @messages.find { |k| k::MESSAGE_TYPE == message_type }
 
-
-        return [nil, offset + length + 2] if [
-                      "\xbf\x00".force_encoding(Encoding::ASCII_8BIT),
-                      "\xbf\xe1".force_encoding(Encoding::ASCII_8BIT),
-                      "\xbf\x07".force_encoding(Encoding::ASCII_8BIT)].include?(message_type)
+        # Ignore these message types
+        return [nil, offset + length + 2] if IGNORED_MESSAGES.include?(message_type)
 
         if klass
           valid_length = if klass::MESSAGE_LENGTH.respond_to?(:include?)
-            klass::MESSAGE_LENGTH.include?(length - 5)
-          else
-            length - 5 == klass::MESSAGE_LENGTH
+                           klass::MESSAGE_LENGTH.include?(length - 5)
+                         else
+                           length - 5 == klass::MESSAGE_LENGTH
+                         end
+          unless valid_length
+            raise InvalidMessage.new("Unrecognized data length (#{length}) for message #{klass}",
+                                     data)
           end
-          raise InvalidMessage.new("Unrecognized data length (#{length}) for message #{klass}", data) unless valid_length
         else
+          BWA.logger.info(
+            "Unrecognized message type #{BWA.raw2str(message_type)}: #{BWA.raw2str(data.slice(offset, length + 2))}"
+          )
           klass = Unrecognized
         end
 
@@ -80,56 +124,56 @@ module BWA
         message.parse(data.slice(offset + 5, length - 5))
         message.instance_variable_set(:@raw_data, data.slice(offset, length + 2))
         message.instance_variable_set(:@src, src)
+        BWA.logger.debug "from spa: #{message.inspect}" unless common_messages.include?(message_type)
         [message, offset + length + 2]
       end
 
-      def format_time(hour, minute, twenty_four_hour_time = true)
+      def format_time(hour, minute, twenty_four_hour_time: true)
         if twenty_four_hour_time
-          print_hour = "%02d" % hour
+          format("%02d:%02d", hour, minute)
         else
           print_hour = hour % 12
-          print_hour = 12 if print_hour == 0
-          am_pm = (hour >= 12 ? "PM" : "AM")
+          print_hour = 12 if print_hour.zero?
+          format("%d:%02d%s", print_hour, minute, hour >= 12 ? "PM" : "AM")
         end
-        "#{print_hour}:#{"%02d" % minute}#{am_pm}"
       end
 
-      def format_duration(hours, minutes)
-        "#{hours}:#{"%02d" % minutes}"
+      def format_duration(minutes)
+        format("%d:%02d", minutes / 60, minutes % 60)
       end
     end
 
-    attr_reader :raw_data, :src
+    attr_reader :raw_data
 
     def initialize
       # most messages we're sending come from this address
       @src = 0x0a
     end
 
-    def parse(_data)
-    end
+    def parse(_data); end
 
     def serialize(message = "")
       length = message.length + 5
-      full_message = "#{length.chr}#{src.chr}#{self.class::MESSAGE_TYPE}#{message}".force_encoding(Encoding::ASCII_8BIT)
+      full_message = (+"#{length.chr}#{src.chr}#{self.class::MESSAGE_TYPE}#{message}")
+                     .force_encoding(Encoding::ASCII_8BIT)
       checksum = CRC.checksum(full_message)
-      "\x7e#{full_message}#{checksum.chr}\x7e".force_encoding(Encoding::ASCII_8BIT)
+      (+"\x7e#{full_message}#{checksum.chr}\x7e").force_encoding(Encoding::ASCII_8BIT)
     end
 
     def inspect
-      "#<#{self.class.name} #{raw_data.unpack("H*").first}>"
+      "#<#{self.class.name} #{raw_data.unpack1("H*")}>"
     end
   end
 end
 
-require 'bwa/messages/configuration'
-require 'bwa/messages/configuration_request'
-require 'bwa/messages/control_configuration'
-require 'bwa/messages/control_configuration_request'
-require 'bwa/messages/filter_cycles'
-require 'bwa/messages/ready'
-require 'bwa/messages/set_temperature'
-require 'bwa/messages/set_temperature_scale'
-require 'bwa/messages/set_time'
-require 'bwa/messages/status'
-require 'bwa/messages/toggle_item'
+require "bwa/messages/configuration"
+require "bwa/messages/configuration_request"
+require "bwa/messages/control_configuration"
+require "bwa/messages/control_configuration_request"
+require "bwa/messages/filter_cycles"
+require "bwa/messages/ready"
+require "bwa/messages/set_target_temperature"
+require "bwa/messages/set_temperature_scale"
+require "bwa/messages/set_time"
+require "bwa/messages/status"
+require "bwa/messages/toggle_item"