balboa_worldwide_app 1.3.0 → 2.0.3

data/lib/bwa/client.rb

@@ -1,28 +1,59 @@
-require 'uri'
+# frozen_string_literal: true
 
-require 'bwa/logger'
-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'
+      case uri.scheme
+      when "tcp"
+        require "socket"
         @io = TCPSocket.new(uri.host, uri.port || 4257)
-      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)
+      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
       @src = 0x0a
-      @buffer = ""
+      @buffer = +""
+    end
+
+    def full_configuration?
+      status && control_configuration && configuration && filter_cycles
     end
 
     def poll
@@ -45,18 +76,20 @@ module BWA
       end
 
       if message.is_a?(Messages::Ready) && (msg = @queue&.shift)
-        BWA.logger.debug "wrote: #{BWA.raw2str(msg)}" unless BWA.verbosity < 1 && msg[3..4] == Messages::ControlConfigurationRequest::MESSAGE_TYPE
+        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
@@ -65,12 +98,16 @@ module BWA
 
     def send_message(message)
       message.src = @src
-      BWA.logger.info "  to spa: #{message.inspect}" unless BWA.verbosity < 1 && message.is_a?(Messages::ControlConfigurationRequest)
       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
-        BWA.logger.debug "wrote: #{BWA.raw2str(full_message)}" unless BWA.verbosity < 1 && message.is_a?(Messages::ControlConfigurationRequest)
+        unless BWA.verbosity < 1 && message.is_a?(Messages::ControlConfigurationRequest)
+          BWA.logger.debug "wrote: #{BWA.raw2str(full_message)}"
+        end
         @io.write(full_message)
       end
     end
@@ -95,12 +132,16 @@ module BWA
       send_message(Messages::ToggleItem.new(item))
     end
 
-    def toggle_pump(i)
-      toggle_item(i + 3)
+    def toggle_pump(index)
+      toggle_item(index + 0x04)
     end
 
-    def toggle_light(i)
-      toggle_item(i + 0x10)
+    def toggle_light(index)
+      toggle_item(index + 0x11)
+    end
+
+    def toggle_aux(index)
+      toggle_item(index + 0x16)
     end
 
     def toggle_mister
@@ -115,90 +156,79 @@ module BWA
       toggle_item(:hold)
     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 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
 
-    def set_hold(desired)
-      return unless last_status
-      return if last_status.hold == desired
+    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 set_temperature(desired)
-      return unless last_status
-      return if last_status.set_temperature == desired
+    def target_temperature=(desired)
+      return unless status
+      return if status.target_temperature == desired
 
-      desired *= 2 if last_status && last_status.temperature_scale == :celsius || desired < 50
-      send_message(Messages::SetTemperature.new(desired.round))
+      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)
+    def set_time(hour, minute, twenty_four_hour_time: false)
       send_message(Messages::SetTime.new(hour, minute, twenty_four_hour_time))
     end
 
-    def set_temperature_scale(scale)
-      raise ArgumentError, "scale must be :fahrenheit or :celsius" unless %I{fahrenheit :celsius}.include?(scale)
+    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_filtercycles(changedItem, changedValue)
-      #changedItem - String name of item that was changed
-      #changedValue - String value of the item that changed
-      if @last_filter_configuration
-        messagedata = if changedItem == "filter1hour" then changedValue.to_i.chr else @last_filter_configuration.filter1_hour.chr end
-        messagedata += if changedItem == "filter1minute" then changedValue.to_i.chr else @last_filter_configuration.filter1_minute.chr end
-        messagedata += if changedItem == "filter1durationhours" then changedValue.to_i.chr else @last_filter_configuration.filter1_duration_hours.chr end
-        messagedata += if changedItem == "filter1durationminutes" then changedValue.to_i.chr else @last_filter_configuration.filter1_duration_minutes.chr end
-
-        #The filter2 start hour is merged with the filter2 enable (who thought that was a good idea?) The high order bit of the byte is a flag
-        #to indicate this so we have to do a bit of different processing to do that
-        #Get the filter 2 start hour
-        starthour =  if changedItem == "filter2hour" then changedValue.to_i else @last_filter_configuration.filter2_hour end
-        #Check to see if we want filter 2 enabled (either because it changed or from the current configuration)
-        #If it is something that changed, we have to convert to boolean, if it is from the current config it already is a boolean
-        starthour |=  0x80 if (if changedItem == "filter2enabled" then (changedValue == "true" ? true : false) else @last_filter_configuration.filter2_enabled end)
-
-        messagedata += starthour.chr
-
-        messagedata += if changedItem == "filter2minute" then changedValue.to_i.chr else @last_filter_configuration.filter2_minute.chr end
-        messagedata += if changedItem == "filter2durationhours" then changedValue.to_i.chr else @last_filter_configuration.filter2_duration_hours.chr end
-        messagedata += if changedItem == "filter2durationminutes" then changedValue.to_i.chr else @last_filter_configuration.filter2_duration_minutes.chr end
-
-        send_message("\x0a\xbf\x23".force_encoding(Encoding::ASCII_8BIT) + messagedata)
-      end
+    def update_filter_cycles(new_filter_cycles)
+      send_message(new_filter_cycles)
+      @filter_cycles = new_filter_cycles.dup
       request_filter_configuration
     end
 
@@ -206,9 +236,10 @@ module BWA
       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
 
@@ -216,19 +247,20 @@ module BWA
       toggle_item(:heating_mode)
     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
+    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,27 +1,27 @@
-require 'socket'
-require 'bwa/logger'
+# 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
@@ -29,11 +29,12 @@ 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
           BWA.logger.info "Advertising to #{ip}"
           socket.sendmsg(msg, 0, Socket.sockaddr_in(addr[1], ip))

data/lib/bwa/logger.rb

@@ -1,4 +1,6 @@
-require 'logger'
+# frozen_string_literal: true
+
+require "logger"
 
 module BWA
   # This module logs to stdout by default, or you can provide a logger as BWA.logger.
@@ -23,10 +25,10 @@ module BWA
     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|
+      @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
@@ -42,14 +44,14 @@ module BWA
       when ::String
         msg
       when ::Exception
-        "#{ msg.message } (#{ msg.class })\n#{ msg.backtrace.join("\n") if msg.backtrace }"
+        "#{msg.message} (#{msg.class})\n#{msg.backtrace&.join("\n")}"
       else
         msg.inspect
       end
     end
 
     def raw2str(data)
-      data.unpack("H*").first.gsub!(/(..)/, "\\1 ").chop!
+      data.unpack1("H*").gsub!(/(..)/, "\\1 ").chop!
     end
   end
 end

data/lib/bwa/message.rb

@@ -1,5 +1,7 @@
-require 'bwa/logger'
-require 'bwa/crc'
+# frozen_string_literal: true
+
+require "bwa/logger"
+require "bwa/crc"
 
 module BWA
   class InvalidMessage < RuntimeError
@@ -19,53 +21,58 @@ module BWA
 
     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
-      ]
+        (+"\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
+        @common_messages ||= begin
           msgs = []
-          msgs += [
-            Messages::Status::MESSAGE_TYPE,
-            "\xbf\xe1".force_encoding(Encoding::ASCII_8BIT),
-          ] unless BWA.verbosity >= 1
-          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),
-          ] unless BWA.verbosity >= 2
+          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
-        @COMMON_MESSAGES
       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
@@ -74,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
@@ -84,8 +91,11 @@ module BWA
         end
 
         message_type = data.slice(offset + 3, 2)
-        BWA.logger.debug "discarding invalid data prior to message #{BWA.raw2str(data[0...offset])}" unless offset == 0
-        BWA.logger.debug " read: #{BWA.raw2str(data.slice(offset, length + 2))}" unless common_messages.include?(message_type)
+        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
         klass = @messages.find { |k| k::MESSAGE_TYPE == message_type }
@@ -95,13 +105,18 @@ module BWA
 
         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))}"
+          BWA.logger.info(
+            "Unrecognized message type #{BWA.raw2str(message_type)}: #{BWA.raw2str(data.slice(offset, length + 2))}"
+          )
           klass = Unrecognized
         end
 
@@ -113,53 +128,52 @@ module BWA
         [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"

data/lib/bwa/messages/configuration.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module BWA
   module Messages
     class Configuration < Message
-      MESSAGE_TYPE = "\xbf\x94".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_TYPE = (+"\xbf\x94").force_encoding(Encoding::ASCII_8BIT)
       MESSAGE_LENGTH = 25
 
       def inspect

data/lib/bwa/messages/configuration_request.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module BWA
   module Messages
     class ConfigurationRequest < Message
-      MESSAGE_TYPE = "\xbf\x04".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_TYPE = (+"\xbf\x04").force_encoding(Encoding::ASCII_8BIT)
       MESSAGE_LENGTH = 0
 
       def inspect