balboa_worldwide_app 1.2.5 → 2.0.2

data/lib/bwa/messages/configuration.rb

@@ -1,8 +1,14 @@
+# 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
+        "#<BWA::Messages::Configuration>"
+      end
     end
   end
 end

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

data/lib/bwa/messages/control_configuration.rb

@@ -1,13 +1,16 @@
+# frozen_string_literal: true
+
 module BWA
   module Messages
     class ControlConfiguration < Message
-      MESSAGE_TYPE = "\xbf\x24".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_TYPE = (+"\xbf\x24").force_encoding(Encoding::ASCII_8BIT)
       MESSAGE_LENGTH = 21
 
       attr_accessor :model, :version
 
       def initialize
-        @model = ''
+        super
+        @model = ""
         @version = 0
       end
 
@@ -22,15 +25,17 @@ module BWA
     end
 
     class ControlConfiguration2 < Message
-      MESSAGE_TYPE = "\xbf\x2e".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_TYPE = (+"\xbf\x2e").force_encoding(Encoding::ASCII_8BIT)
       MESSAGE_LENGTH = 6
 
-      attr_accessor :pumps, :lights, :circ_pump, :blower, :mister, :aux
+      attr_accessor :pumps, :lights, :circulation_pump, :blower, :mister, :aux
 
       def initialize
+        super
+
         self.pumps = Array.new(6, 0)
         self.lights = Array.new(2, false)
-        self.circ_pump = false
+        self.circulation_pump = false
         self.blower = 0
         self.mister = false
         self.aux = Array.new(2, false)
@@ -50,7 +55,7 @@ module BWA
         lights[1] = ((flags >> 6) & 0x03 != 0)
         flags = data[3].ord
         self.blower = flags & 0x03
-        self.circ_pump = ((flags >> 6) & 0x03 != 0)
+        self.circulation_pump = ((flags >> 6) & 0x03 != 0)
         flags = data[4].ord
         self.mister = (flags & 0x30 != 0)
         aux[0] = (flags & 0x01 != 0)
@@ -58,17 +63,16 @@ module BWA
       end
 
       def inspect
-        result = "#<BWA::Messages::ControlConfiguration2 "
         items = []
 
         items << "pumps=#{pumps.inspect}"
         items << "lights=#{lights.inspect}"
-        items << "circ_pump" if circ_pump
+        items << "circulation_pump" if circulation_pump
         items << "blower=#{blower}" if blower != 0
         items << "mister" if mister
         items << "aux=#{aux.inspect}"
 
-        result << items.join(' ') << ">"
+        "#<BWA::Messages::ControlConfiguration2 #{items.join(" ")}>"
       end
     end
   end

data/lib/bwa/messages/control_configuration_request.rb

@@ -1,20 +1,40 @@
+# frozen_string_literal: true
+
 module BWA
   module Messages
     class ControlConfigurationRequest < Message
-      MESSAGE_TYPE = "\xbf\x22".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_TYPE = (+"\xbf\x22").force_encoding(Encoding::ASCII_8BIT)
       MESSAGE_LENGTH = 3
 
       attr_accessor :type
 
       def initialize(type = 1)
+        super()
         self.type = type
       end
 
       def parse(data)
-        self.type = data == "\x02\x00\x00" ? 1 : 2
+        self.type = case data
+                    when "\x02\x00\x00" then 1
+                    when "\x00\x00\x01" then 2
+                    when "\x01\x00\x00" then 3
+                    else 0
+                    end
       end
 
+      def serialize
+        data = case type
+               when 1 then "\x02\x00\x00"
+               when 2 then "\x00\x00\x01"
+               when 3 then "\x01\x00\x00"
+               else "\x00\x00\x00"
+               end
+        super(data)
+      end
 
+      def inspect
+        "#<BWA::Messages::ControlConfigurationRequest #{type}>"
+      end
     end
   end
 end

data/lib/bwa/messages/filter_cycles.rb

@@ -1,39 +1,67 @@
+# frozen_string_literal: true
+
 module BWA
   module Messages
     class FilterCycles < Message
-      attr_reader :filter1_hour, :filter1_minute, :filter1_duration_hours, :filter1_duration_minutes,
-                  :filter2_enabled,
-                  :filter2_hour, :filter2_minute, :filter2_duration_hours, :filter2_duration_minutes
+      attr_accessor :cycle1_start_hour, :cycle1_start_minute, :cycle1_duration,
+                    :cycle2_enabled, :cycle2_start_hour, :cycle2_start_minute, :cycle2_duration
+      alias_method :cycle2_enabled?, :cycle2_enabled
 
-      MESSAGE_TYPE = "\xbf\x23".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_TYPE = (+"\xbf\x23").force_encoding(Encoding::ASCII_8BIT)
       MESSAGE_LENGTH = 8
 
       def parse(data)
-        @filter1_hour = data[0].ord
-        @filter1_minute = data[1].ord
-        @filter1_duration_hours = data[2].ord
-        @filter1_duration_minutes = data[3].ord
-
-        f2_hour = data[4].ord
-        @filter2_enabled = !!(f2_hour & 0x80 == 0x80)
-        @filter2_hour = f2_hour & 0x7f
-        @filter2_minute = data[5].ord
-        @filter2_duration_hours = data[6].ord
-        @filter2_duration_minutes = data[7].ord
+        self.cycle1_start_hour = data[0].ord
+        self.cycle1_start_minute = data[1].ord
+        hours = data[2].ord
+        minutes = data[3].ord
+        self.cycle1_duration = (hours * 60) + minutes
+
+        c2_hour = data[4].ord
+        self.cycle2_enabled = !!(c2_hour & 0x80 == 0x80)
+        self.cycle2_start_hour = c2_hour & 0x7f
+        self.cycle2_start_minute = data[5].ord
+        hours = data[6].ord
+        minutes = data[7].ord
+        self.cycle2_duration = (hours * 60) + minutes
+      end
+
+      def serialize
+        data = cycle1_start_hour.chr
+        data += cycle1_start_minute.chr
+        data += (cycle1_duration / 60).chr
+        data += (cycle1_duration % 60).chr
+
+        # The cycle2 start hour is merged with the cycle2 enable.
+        # The high order bit of the byte is a flag to indicate this so we have
+        #  to do a bit of different processing to set that.
+        # Get the filter 2 start hour
+        start_hour = cycle2_start_hour
+
+        # Check to see if we want filter 2 enabled (either because it changed or from the current configuration)
+        start_hour |= 0x80 if cycle2_enabled
+
+        data += start_hour.chr
+
+        data += cycle2_start_minute.chr
+        data += (cycle2_duration / 60).chr
+        data += (cycle2_duration % 60).chr
+
+        super(data)
       end
 
       def inspect
-        result = "#<BWA::Messages::FilterCycles "
+        result = +"#<BWA::Messages::FilterCycles "
 
-        result << "filter1 "
-        result << self.class.format_duration(filter1_duration_hours, filter1_duration_minutes)
+        result << "cycle1 "
+        result << self.class.format_duration(cycle1_duration)
         result << "@"
-        result << self.class.format_time(filter1_hour, filter1_minute)
+        result << self.class.format_time(cycle1_start_hour, cycle1_start_minute)
 
-        result << " filter2(#{@filter2_enabled ? 'enabled' : 'disabled'}) "
-        result << self.class.format_duration(filter2_duration_hours, filter2_duration_minutes)
+        result << " cycle2(#{@cycle2_enabled ? "enabled" : "disabled"}) "
+        result << self.class.format_duration(cycle2_duration)
         result << "@"
-        result << self.class.format_time(filter2_hour, filter2_minute)
+        result << self.class.format_time(cycle2_start_hour, cycle2_start_minute)
 
         result << ">"
       end

data/lib/bwa/messages/ready.rb

@@ -1,8 +1,14 @@
+# frozen_string_literal: true
+
 module BWA
   module Messages
     class Ready < Message
-      MESSAGE_TYPE = "\xbf\06".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_TYPE = (+"\xbf\06").force_encoding(Encoding::ASCII_8BIT)
       MESSAGE_LENGTH = 0
+
+      def inspect
+        "#<BWA::Messages::Ready>"
+      end
     end
   end
 end

data/lib/bwa/messages/{set_temperature.rb → set_target_temperature.rb}

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 module BWA
   module Messages
-    class SetTemperature < Message
-      MESSAGE_TYPE = "\xbf\x20".force_encoding(Encoding::ASCII_8BIT)
+    class SetTargetTemperature < Message
+      MESSAGE_TYPE = (+"\xbf\x20").force_encoding(Encoding::ASCII_8BIT)
       MESSAGE_LENGTH = 1
 
       attr_accessor :temperature
 
       def initialize(temperature = nil)
+        super()
         self.temperature = temperature
       end
 
@@ -19,7 +22,7 @@ module BWA
       end
 
       def inspect
-        "#<BWA::Messages::SetTemperature #{temperature}º>"
+        "#<BWA::Messages::SetTargetTemperature #{temperature}°>"
       end
     end
   end

data/lib/bwa/messages/set_temperature_scale.rb

@@ -1,17 +1,20 @@
+# frozen_string_literal: true
+
 module BWA
   module Messages
     class SetTemperatureScale < Message
-      MESSAGE_TYPE = "\xbf\x27".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_TYPE = (+"\xbf\x27").force_encoding(Encoding::ASCII_8BIT)
       MESSAGE_LENGTH = 2
 
       attr_accessor :scale
 
       def initialize(scale = nil)
+        super()
         self.scale = scale
       end
 
       def parse(data)
-        self.scale = data[1].ord == 0x00 ? :fahrenheit : :celsius
+        self.scale = data[1].ord.zero? ? :fahrenheit : :celsius
       end
 
       def serialize
@@ -21,7 +24,7 @@ module BWA
       end
 
       def inspect
-        "#<BWA::Messages::SetTemperatureScale º#{scale.to_s[0].upcase}>"
+        "#<BWA::Messages::SetTemperatureScale °#{scale.to_s[0].upcase}>"
       end
     end
   end

data/lib/bwa/messages/set_time.rb

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 module BWA
   module Messages
     class SetTime < Message
-      MESSAGE_TYPE = "\xbf\x21".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_TYPE = (+"\xbf\x21").force_encoding(Encoding::ASCII_8BIT)
       MESSAGE_LENGTH = 2
 
       attr_accessor :hour, :minute, :twenty_four_hour_time
 
       def initialize(hour = nil, minute = nil, twenty_four_hour_time = nil)
+        super()
         self.hour, self.minute, self.twenty_four_hour_time = hour, minute, twenty_four_hour_time
       end
 
@@ -23,7 +26,7 @@ module BWA
       end
 
       def inspect
-        "#<BWA::Messages::SetTime #{Status.format_time(hour, minute, twenty_four_hour_time)}>"
+        "#<BWA::Messages::SetTime #{Status.format_time(hour, minute, twenty_four_hour_time: twenty_four_hour_time)}>"
       end
     end
   end

data/lib/bwa/messages/status.rb

@@ -1,58 +1,72 @@
+# frozen_string_literal: true
+
 module BWA
   module Messages
     class Status < Message
-      attr_accessor :priming,
+      attr_accessor :hold,
+                    :priming,
                     :heating_mode,
-                    :temperature_scale,
                     :twenty_four_hour_time,
-                    :filter,
+                    :filter_cycles,
                     :heating,
                     :temperature_range,
                     :hour, :minute,
-                    :circ_pump,
+                    :circulation_pump,
                     :blower,
                     :pumps,
                     :lights,
                     :mister,
                     :aux,
-                    :current_temperature, :set_temperature
+                    :current_temperature,
+                    :target_temperature
+      attr_reader :temperature_scale
+      alias_method :hold?, :hold
+      alias_method :priming?, :priming
+      alias_method :twenty_four_hour_time?, :twenty_four_hour_time
+      alias_method :heating?, :heating
 
-      MESSAGE_TYPE = "\xaf\x13".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_TYPE = (+"\xaf\x13").force_encoding(Encoding::ASCII_8BIT)
       # additional features have been added in later versions
-      MESSAGE_LENGTH = 24..32
+      MESSAGE_LENGTH = (24..32).freeze
 
       def initialize
+        super
+
         @src = 0xff
+        self.hold = false
         self.priming = false
         self.heating_mode = :ready
         @temperature_scale = :fahrenheit
         self.twenty_four_hour_time = false
-        self.filter = Array.new(2, false)
+        self.filter_cycles = Array.new(2, false)
         self.heating = false
         self.temperature_range = :high
         self.hour = self.minute = 0
-        self.circ_pump = false
+        self.circulation_pump = false
         self.pumps = Array.new(6, 0)
         self.lights = Array.new(2, false)
         self.mister = false
         self.aux = Array.new(2, false)
-        self.set_temperature = 100
+        self.target_temperature = 100
       end
 
       def parse(data)
+        flags = data[0].ord
+        self.hold = (flags & 0x05 != 0)
+
         flags = data[1].ord
         self.priming = (flags & 0x01 == 0x01)
         flags = data[5].ord
         self.heating_mode = case flags & 0x03
-                              when 0x00; :ready
-                              when 0x01; :rest
-                              when 0x02; :ready_in_rest
+                            when 0x00 then :ready
+                            when 0x01 then :rest
+                            when 0x02 then :ready_in_rest
                             end
         flags = data[9].ord
         self.temperature_scale = (flags & 0x01 == 0x01) ? :celsius : :fahrenheit
         self.twenty_four_hour_time = (flags & 0x02 == 0x02)
-        filter[0] = (flags & 0x04 != 0)
-        filter[1] = (flags & 0x08 != 0)
+        filter_cycles[0] = (flags & 0x04 != 0)
+        filter_cycles[1] = (flags & 0x08 != 0)
         flags = data[10].ord
         self.heating = (flags & 0x30 != 0)
         self.temperature_range = (flags & 0x04 == 0x04) ? :high : :low
@@ -66,8 +80,8 @@ module BWA
         pumps[5] = (flags >> 2) & 0x03
 
         flags = data[13].ord
-        self.circ_pump = (flags & 0x02 == 0x02)
-        self.blower = (flags & 0x0C == 0x0C)
+        self.circulation_pump = (flags & 0x02 == 0x02)
+        self.blower = (flags >> 2) & 0x03
         flags = data[14].ord
         lights[0] = (flags & 0x03 != 0)
         lights[1] = ((flags >> 2) & 0x03 != 0)
@@ -78,22 +92,22 @@ module BWA
         self.hour = data[3].ord
         self.minute = data[4].ord
         self.current_temperature = data[2].ord
-        self.current_temperature = nil if self.current_temperature == 0xff
-        self.set_temperature = data[20].ord
-        if temperature_scale == :celsius
-          self.current_temperature /= 2.0 if self.current_temperature
-          self.set_temperature /= 2.0 if self.set_temperature
-        end
+        self.current_temperature = nil if current_temperature == 0xff
+        self.target_temperature = data[20].ord
+
+        return unless temperature_scale == :celsius
+
+        self.current_temperature /= 2.0 if current_temperature
+        self.target_temperature /= 2.0 if target_temperature
       end
 
       def serialize
         data = "\x00" * 24
+        data[0] = (hold ? 0x05 : 0x00).chr
         data[1] = (priming ? 0x01 : 0x00).chr
-        data[5] = (case heating_mode
-                     when :ready; 0x00
-                     when :rest; 0x01
-                     when :ready_in_rest; 0x02
-                   end).chr
+        data[5] = { ready: 0x00,
+                    rest: 0x01,
+                    ready_in_rest: 0x02 }[heating_mode].chr
         flags = 0
         flags |= 0x01 if temperature_scale == :celsius
         flags |= 0x02 if twenty_four_hour_time
@@ -107,7 +121,7 @@ module BWA
         flags |= pump2 * 4
         data[11] = flags.chr
         flags = 0
-        flags |= 0x02 if circ_pump
+        flags |= 0x02 if circulation_pump
         data[13] = flags.chr
         flags = 0
         flags |= 0x03 if light1
@@ -116,10 +130,10 @@ module BWA
         data[4] = minute.chr
         if temperature_scale == :celsius
           data[2] = (current_temperature ? (current_temperature * 2).to_i : 0xff).chr
-          data[20] = (set_temperature * 2).to_i.chr
+          data[20] = (target_temperature * 2).to_i.chr
         else
-          data[2] = (current_temperature&.to_i || 0xff).chr
-          data[20] = set_temperature.to_i.chr
+          data[2] = (current_temperature.to_i || 0xff).chr
+          data[20] = target_temperature.to_i.chr
         end
 
         super(data)
@@ -129,46 +143,46 @@ module BWA
         if value != @temperature_scale
           if value == :fahrenheit
             if current_temperature
-              self.current_temperature *= 9.0/5
+              self.current_temperature *= 9.0 / 5
               self.current_temperature += 32
               self.current_temperature = current_temperature.round
             end
-            self.set_temperature *= 9.0/5
-            self.set_temperature += 32
-            self.set_temperature = set_temperature.round
+            self.target_temperature *= 9.0 / 5
+            self.target_temperature += 32
+            self.target_temperature = target_temperature.round
           else
             if current_temperature
               self.current_temperature -= 32
-              self.current_temperature *= 5.0/90
+              self.current_temperature *= 5.0 / 90
               self.current_temperature = (current_temperature * 2).round / 2.0
             end
-            self.set_temperature -= 32
-            self.set_temperature *= 5.0/9
-            self.set_temperature = (set_temperature * 2).round / 2.0
+            self.target_temperature -= 32
+            self.target_temperature *= 5.0 / 9
+            self.target_temperature = (target_temperature * 2).round / 2.0
           end
         end
         @temperature_scale = value
       end
 
       def inspect
-        result = "#<BWA::Messages::Status "
         items = []
 
+        items << "hold" if hold
         items << "priming" if priming
-        items << self.class.format_time(hour, minute, twenty_four_hour_time)
-        items << "#{current_temperature || '--'}/#{set_temperature}º#{temperature_scale.to_s[0].upcase}"
-        items << "filter=#{filter.inspect}"
+        items << self.class.format_time(hour, minute, twenty_four_hour_time: twenty_four_hour_time)
+        items << "#{current_temperature || "--"}/#{target_temperature}°#{temperature_scale.to_s[0].upcase}"
+        items << "filter_cycles=#{filter_cycles.inspect}"
         items << heating_mode
         items << "heating" if heating
         items << temperature_range
-        items << "circ_pump" if circ_pump
-        items << "blower" if blower
+        items << "circulation_pump" if circulation_pump
+        items << "blower=#{blower}"
         items << "pumps=#{pumps.inspect}"
         items << "lights=#{lights.inspect}"
         items << "aux=#{aux.inspect}"
         items << "mister" if mister
 
-        result << items.join(' ') << ">"
+        "#<BWA::Messages::Status #{items.join(" ")}>"
       end
     end
   end

data/lib/bwa/messages/toggle_item.rb

@@ -1,36 +1,48 @@
+# frozen_string_literal: true
+
 module BWA
   module Messages
     class ToggleItem < Message
-      MESSAGE_TYPE = "\xbf\x11".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_TYPE = (+"\xbf\x11").force_encoding(Encoding::ASCII_8BIT)
       MESSAGE_LENGTH = 2
+      ITEMS = {
+        normal_operation: 0x01,
+        clear_notification: 0x03,
+        pump1: 0x04,
+        pump2: 0x05,
+        pump3: 0x06,
+        pump4: 0x07,
+        pump5: 0x08,
+        pump6: 0x09,
+        blower: 0x0c,
+        mister: 0x0e,
+        light1: 0x11,
+        light2: 0x12,
+        aux1: 0x16,
+        aux2: 0x17,
+        hold: 0x3c,
+        temperature_range: 0x50,
+        heating_mode: 0x51
+      }.freeze
 
       attr_accessor :item
 
       def initialize(item = nil)
+        super()
         self.item = item
       end
 
       def parse(data)
-        self.item = case data[0].ord
-                      when 0x04; :pump1
-                      when 0x05; :pump2
-                      when 0x11; :light1
-                      when 0x3c; :hold
-                      when 0x50; :temperature_range
-                      when 0x51; :heating_mode
-                      else; data[0].ord
-                    end
+        self.item = ITEMS.invert[data[0].ord] || data[0].ord
       end
 
       def serialize
-        data = "\x00\x00"
-        data[0] = (case setting
-                     when :pump1; 0x04
-                     when :pump2; 0x05
-                     when :light1; 0x11
-                     when :temperature_range; 0x50
-                     when :heating_mode; 0x51
-                   end).chr
+        data = +"\x00\x00"
+        data[0] = if item.is_a? Integer
+                    item.chr
+                  else
+                    ITEMS[item].chr
+                  end
         super(data)
       end