balboa_worldwide_app 1.2.2 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b3690c43f61e80376391c61d447f3e8430ae844ffc5d380afa9bb90636095bd
-  data.tar.gz: 284a4856cac4830956a8e944572ce724f0bbeba98efa3cba0a879d932193bc23
+  metadata.gz: f1f61d30556c0536efad6d27c229cefc0bccd1293a4dc491230a3e68cfddca13
+  data.tar.gz: 3014c3c575a53cceaa2f9c2903b1977480bffa5cc0db5e44f08bce8fc8671e17
 SHA512:
-  metadata.gz: 7a82e78b7f1ea26b74fe71117e9ca9c549708851f39a62c176650faf12c972f32658a541edac023ccd81def26fa6c2e8844adb3bf8b0f95bc4720ecf11d44e9c
-  data.tar.gz: 00ffc61f1eb37ac4025e03e3a0412835e1211f2faa82d46dc6115de3a13ede7e4526fe3527bd9d04b9dfb8873ccfe566992e7a8a6955adca55161a6be2d45dd3
+  metadata.gz: 3ff3043cbbdefd778ee2fbea74ce46ad8c73860f8e541c9035911219b6d6048203f817a2f129bac16678334d4f02cddea806814357d13710c4c76fc3e1987b5e
+  data.tar.gz: bb1d5468380c06c7bc38c34cf984cd9c4550fb3a3f1314f1b85617df0cff003ece26ce4603746f59f0e00950ae8244aaf0f477149f3b693ab67b8f6ff30f8602

data/bin/bwa_client

@@ -27,7 +27,7 @@ if ARGV.empty?
     $stderr.puts "Could not find spa!"
     exit 1
   end
-  spa_ip = spas.first.first
+  spa_ip = 'tcp://' + spas.first.first + '/'
 else
   spa_ip = ARGV[0]
 end

data/bin/bwa_mqtt_bridge

@@ -1,9 +1,14 @@
 #!/usr/bin/env ruby
 
 require 'mqtt'
+require 'sd_notify'
+require 'set'
+require 'json'
 
+require 'bwa/logger'
 require 'bwa/client'
 require 'bwa/discovery'
+require 'bwa/version'
 
 class MQTTBridge
   def initialize(mqtt_uri, bwa, device_id: "bwa", base_topic: "homie")
@@ -15,7 +20,37 @@ class MQTTBridge
     @attributes = {}
     @things = Set.new
 
+    hass_discovery_topic = "homeassistant/"
+    @ha_binary_path = hass_discovery_topic + "binary_sensor/"
+    @ha_sensor_path = hass_discovery_topic + "sensor/"
+    @ha_switch_path = hass_discovery_topic + "switch/"
+    @ha_selects_path = hass_discovery_topic + "select/"
+    @ha_number_path = hass_discovery_topic + "number/"
+
+    @hass_device = {
+      device: {
+        identifiers: [device_id],
+        sw_version: BWA::VERSION,
+        name: "BWA Link"
+      }
+    }
+
+    # bwa availability topics (works for all devices)
+    @hass_availability = {
+      availability_topic: "#{@base_topic}/$state",
+      payload_available: "ready",
+      payload_not_available: "lost"
+    }
+
     publish_basic_attributes
+    publish_filtercycles
+
+    # Home Assistant MQTT Discovery Section
+    publish_hass_discovery
+
+    # Tell systemd we've started up OK. Ignored if systemd not in use.
+    BWA.logger.warn "Balboa MQTT Bridge running (version #{BWA::VERSION})"
+    SdNotify.ready
 
     bwa_thread = Thread.new do
       loop do
@@ -23,7 +58,6 @@ class MQTTBridge
           message = @bwa.poll
           next if message.is_a?(BWA::Messages::Ready)
 
-          puts message.inspect unless message.is_a?(BWA::Messages::Status)
           case message
           when BWA::Messages::ControlConfiguration
             publish("spa/$type", message.model)
@@ -32,18 +66,29 @@ class MQTTBridge
               publish_pump(i + 1, speed) if speed != 0
             end
             message.lights.each_with_index do |exists, i|
-              publish_thing("light", i + 1) if exists
+              publish_thing(:light, i + 1) if exists
             end
             message.aux.each_with_index do |exists, i|
-              publish_thing("aux", i + 1) if exists
+              publish_thing(:aux, i + 1) if exists
             end
             publish_mister if message.mister
             publish_blower(message.blower) if message.blower != 0
             publish_circpump if message.circ_pump
             publish("$state", "ready")
+          when BWA::Messages::FilterCycles
+            publish_attribute("spa/filter1hour",message.filter1_hour)
+            publish_attribute("spa/filter1minute",message.filter1_minute)
+            publish_attribute("spa/filter1durationhours",message.filter1_duration_hours)
+            publish_attribute("spa/filter1durationminutes",message.filter1_duration_minutes)
+            publish_attribute("spa/filter2enabled",message.filter2_enabled)
+            publish_attribute("spa/filter2hour",message.filter2_hour)
+            publish_attribute("spa/filter2minute",message.filter2_minute)
+            publish_attribute("spa/filter2durationhours",message.filter2_duration_hours)
+            publish_attribute("spa/filter2durationminutes",message.filter2_duration_minutes)
           when BWA::Messages::Status
             @bwa.request_control_info unless @bwa.last_control_configuration
             @bwa.request_control_info2 unless @bwa.last_control_configuration2
+            @bwa.request_filter_configuration unless @bwa.last_filter_configuration 
 
             # make sure time is in sync
             now = Time.now
@@ -54,8 +99,10 @@ class MQTTBridge
 
             # allow a skew of 1 minute, since the seconds will always be off
             if diff > 1
+              BWA.logger.info "Spa time #{"%02d:%02d" % [message.hour, message.minute]}, actually #{"%02d:%02d" % [now.hour, now.min]}; correcting difference of #{diff} min"
               @bwa.set_time(now.hour, now.min, message.twenty_four_hour_time)
             end
+            publish_attribute("spa/hold", message.hold)
             publish_attribute("spa/priming", message.priming)
             publish_attribute("spa/heatingmode", message.heating_mode)
             publish_attribute("spa/temperaturescale", message.temperature_scale)
@@ -67,11 +114,13 @@ class MQTTBridge
             publish_attribute("spa/settemperature", message.set_temperature)
             publish_attribute("spa/settemperature/$unit", "º#{message.temperature_scale.to_s[0].upcase}")
             if message.temperature_scale == :celsius
-              publish_attribute("spa/currenttemperature/$format", message.temperature_range == :high ? "26:40" : "10:26")
+              publish_attribute("spa/currenttemperature/$format", "0:42")
               publish_attribute("spa/settemperature/$format", message.temperature_range == :high ? "26:40" : "10:26")
+              publish_hass_discovery_settemp(:celsius)
             else
-              publish_attribute("spa/currenttemperature/$format", message.temperature_range == :high ? "80:104" : "26:40")
-              publish_attribute("spa/settemperature/$format", message.temperature_range == :high ? "80:104" : "26:40")
+              publish_attribute("spa/currenttemperature/$format", "32:108")
+              publish_attribute("spa/settemperature/$format", message.temperature_range == :high ? "80:106" : "50:99")
+              publish_hass_discovery_settemp(:fahrenheit)
             end
             publish_attribute("spa/filter1", message.filter[0])
             publish_attribute("spa/filter2", message.filter[1])
@@ -88,14 +137,22 @@ class MQTTBridge
             (0..1).each do |i|
               publish_attribute("spa/aux#{i + 1}", message.lights[i]) if @bwa.last_control_configuration2&.aux&.[](i)
             end
+
+            # Tell systemd we are still alive and kicking. Ignored if systemd not in use.
+            SdNotify.watchdog
+
           end
         end
       end
     end
 
     @mqtt.get do |topic, value|
-      puts "got #{value.inspect} at #{topic}"
+      BWA.logger.warn "from mqtt: #{value.inspect} at #{topic}"
       case topic[@base_topic.length + 1..-1]
+      when "spa/hold/set"
+        next @bwa.toggle_hold if value == 'toggle'
+        next unless %w{true false}.include?(value)
+        @bwa.set_hold(value == 'true')
       when "spa/heatingmode/set"
         next @bwa.toggle_heating_mode if value == 'toggle'
         next unless %w{ready rest}.include?(value)
@@ -127,11 +184,14 @@ class MQTTBridge
         @bwa.set_blower(value.to_i)
       when "spa/settemperature/set"
         @bwa.set_temperature(value.to_f)
+      when %r{^spa/(filter[12](hour|minute|durationhours|durationminutes|enabled))/set$}
+        @bwa.set_filtercycles($1, value)
       end
     end
   end
 
   def publish(topic, value)
+    BWA.logger.debug "  to mqtt: #{topic}: #{value}"
     @mqtt.publish("#{@base_topic}/#{topic}", value, true)
   end
 
@@ -146,8 +206,218 @@ class MQTTBridge
     @mqtt.subscribe("#{@base_topic}/#{topic}")
   end
 
+  def publish_hass_discovery()
+    #Priming
+    priming_config = {
+      name: "Hot Tub Priming",
+      state_topic: "#{@base_topic}/spa/priming",
+      device_class: "running",
+      unique_id: "spa_priming",
+      icon: "mdi:fast-forward"
+    }
+    @mqtt.publish(@ha_binary_path + "priming/config", priming_config
+      .merge(@hass_device)
+      .merge(@hass_availability)
+      .to_json, true)
+
+    #Circulation Pump
+    circ_config = {
+      name: "Hot Tub Circulation Pump",
+      state_topic: "#{@base_topic}/spa/circpump",
+      device_class: "running",
+      unique_id: "spa_circpump",
+      icon: "mdi:sync"
+    }
+    @mqtt.publish(@ha_binary_path + "circpump/config", circ_config
+      .merge(@hass_device)
+      .merge(@hass_availability)
+      .to_json, true)
+
+    # Filter 1 Cycle Running
+    filter1_config = {
+      name: "Hot Tub Filter 1 Cycle Running",
+      state_topic: "#{@base_topic}/spa/filter1",
+      device_class: "running",
+      unique_id: "spa_filtercycle1",
+      icon: "mdi:air-filter"
+    }
+    @mqtt.publish(@ha_binary_path + "filter1/config", filter1_config
+      .merge(@hass_device)
+      .merge(@hass_availability)
+      .to_json, true)
+
+    # Filter 2 Cycle Running
+    filter2_config = {
+      name: "Hot Tub Filter 2 Cycle Running",
+      state_topic: "#{@base_topic}/spa/filter2",
+      device_class: "running",
+      unique_id: "spa_filtercycle2",
+      icon: "mdi:air-filter"
+    }
+    @mqtt.publish(@ha_binary_path + "filter2/config", filter2_config
+      .merge(@hass_device)
+      .merge(@hass_availability)
+      .to_json, true)
+
+    # Heater Running
+    heater_config = {
+      name: "Hot Tub Heater",
+      state_topic: "#{@base_topic}/spa/heating",
+      device_class: "running",
+      unique_id: "spa_heating",
+      icon: "mdi:hot-tub"
+    }
+    @mqtt.publish(@ha_binary_path + "heating/config", heater_config
+      .merge(@hass_device)
+      .merge(@hass_availability)
+      .to_json, true)
+
+    # Heating Mode
+    heatingmode_config = {
+      name: "Hot Tub Heating Mode",
+      state_topic: "#{@base_topic}/spa/heatingmode",
+      command_topic: "#{@base_topic}/spa/heatingmode/set",
+      unique_id: "spa_heating_mode",
+      options: ["ready","rest","ready_in_rest"],
+      icon: "mdi:cog-play"
+    }
+    @mqtt.publish(@ha_selects_path + "heatingmode/config", heatingmode_config
+      .merge(@hass_device)
+      .merge(@hass_availability)
+      .to_json, true)
+
+    # Temperature Range
+    temperaturerange_config = {
+      name: "Hot Tub Temperature Range",
+      state_topic: "#{@base_topic}/spa/temperaturerange",
+      command_topic: "#{@base_topic}/spa/temperaturerange/set",
+      unique_id: "spa_temperaturerange_range",
+      options: ["high","low"],
+      icon: "mdi:thermometer-lines"
+    }
+    @mqtt.publish(@ha_selects_path + "temperaturerange/config", temperaturerange_config
+      .merge(@hass_device)
+      .merge(@hass_availability)
+      .to_json, true)
+
+    # Temperature Scale
+    temperaturescale_config = {
+      name: "Hot Tub Temperature Scale",
+      state_topic: "#{@base_topic}/spa/temperaturescale",
+      unique_id: "spa_temperaturescale"
+    }
+    @mqtt.publish(@ha_sensor_path + "temperaturescale/config", temperaturescale_config
+      .merge(@hass_device)
+      .merge(@hass_availability)
+      .to_json, true)
+
+    # Current Temperature
+    currenttemperature_config = {
+      name: "Hot Tub Current Temperature",
+      state_topic: "#{@base_topic}/spa/currenttemperature",
+      unique_id: "spa_currenttemperature",
+      device_class: "temperature"
+    }
+    @mqtt.publish(@ha_sensor_path + "currenttemperature/config", currenttemperature_config
+      .merge(@hass_device)
+      .merge(@hass_availability)
+      .to_json, true)
+
+    # Set Temperature - Assuming fahrenheit first
+    settemperature_config = {
+      name: "Hot Tub Set Temperature",
+      unique_id: "spa_settemperature",
+      state_topic: "#{@base_topic}/spa/settemperature",
+      command_topic: "#{@base_topic}/spa/settemperature/set",
+      min: 50,
+      max: 106,
+      unit_of_measurement: "°F",
+      icon: "mdi:thermometer"
+    }
+    @mqtt.publish(@ha_number_path + "settemperature/config", settemperature_config
+      .merge(@hass_device)
+      .merge(@hass_availability)
+      .to_json, true)
+  end
+
+  def publish_hass_discovery_settemp(scale)
+    return if scale == @last_scale
+    @last_scale = scale
+
+    # Update temp ranges when scale changes
+    settemperature_config = {
+      name: "Hot Tub Set Temperature",
+      unique_id: "spa_settemperature",
+      state_topic: "#{@base_topic}/spa/settemperature",
+      command_topic: "#{@base_topic}/spa/settemperature/set",
+      min: 50,
+      max: 106,
+      unit_of_measurement: "°F",
+      icon: "mdi:thermometer"
+    }
+
+    if scale == :celsius
+      settemperature_config[:min] = 10
+      settemperature_config[:max] = 40
+      settemperature_config[:unit_of_measurement] = "°C"
+    else
+      settemperature_config[:min] = 50
+      settemperature_config[:max] = 106
+      settemperature_config[:unit_of_measurement] = "°F"
+    end
+
+    @mqtt.publish(@ha_number_path + "settemperature/config", settemperature_config
+      .merge(@hass_device)
+      .merge(@hass_availability)
+      .to_json, true)
+  end
+
+  def publish_hass_discovery_pumps(i, speeds)
+    pump_config = {
+      name: "Hot Tub Pump #{i}",
+      unique_id: "spa_pump#{i}",
+      state_topic: "#{@base_topic}/spa/pump#{i}",
+      command_topic: "#{@base_topic}/spa/pump#{i}/set",
+      payload_on: "toggle",
+      payload_off: "toggle",
+      state_on: "2",
+      state_off: "0",
+      icon: "mdi:chart-bubble"
+    }
+    @mqtt.publish(@ha_switch_path + "pump#{i}/config", pump_config
+      .merge(@hass_device)
+      .merge(@hass_availability)
+      .to_json, true)
+  end
+
+  def publish_hass_discovery_things(type, i)
+    #Things - Lights and such
+    thing_config = {
+      name: "Hot Tub #{type} #{i}",
+      unique_id: "spa_#{type}#{i}",
+      state_topic: "#{@base_topic}/spa/#{type}#{i}",
+      command_topic: "#{@base_topic}/spa/#{type}#{i}/set",
+      payload_on: "true",
+      payload_off: "false",
+      state_on: "true",
+      state_off: "false"
+    }
+    case type
+    when :light
+      thing_config[:icon] = "mdi:car-parking-lights"
+    when :mister
+      thing_config[:icon] = "mdi:sprinkler-fire"
+    when :blower
+      thing_config[:icon] = "mdi:chart-bubble"
+    end
+    @mqtt.publish(@ha_switch_path+ "#{type}#{i}/config", thing_config
+      .merge(@hass_device)
+      .merge(@hass_availability)
+      .to_json, true)
+  end
+
   def publish_basic_attributes
-    publish("$homie", "v4.0.0")
+    publish("$homie", "4.0.0")
     publish("$name", "BWA Spa")
     publish("$state", "init")
     publish("$nodes", "spa")
@@ -156,6 +426,11 @@ class MQTTBridge
     publish("spa/$type", "spa")
     publish_nodes
 
+    publish("spa/hold/$name", "In Hold mode")
+    publish("spa/hold/$datatype", "boolean")
+    publish("spa/hold/$settable", "true")
+    subscribe("spa/hold/set")
+
     publish("spa/priming/$name", "Is the pump priming")
     publish("spa/priming/$datatype", "boolean")
 
@@ -208,6 +483,7 @@ class MQTTBridge
     subscribe("spa/pump#{i}/set")
 
     @things << "pump#{i}"
+    publish_hass_discovery_pumps(i, speeds)
     publish_nodes
   end
 
@@ -218,6 +494,7 @@ class MQTTBridge
     subscribe("spa/#{type}#{i}/set")
 
     @things << "#{type}#{i}"
+    publish_hass_discovery_things(type, i)
     publish_nodes
   end
 
@@ -250,8 +527,68 @@ class MQTTBridge
     publish_nodes
   end
 
+  def publish_filtercycles
+    publish("spa/filter1hour/$name", "Filter Cycle 1 Start Hour")
+    publish("spa/filter1hour/$datatype", "integer")
+    publish("spa/filter1hour/$format", "0:24")
+    publish("spa/filter1hour/$settable", "true")
+
+    publish("spa/filter1minute/$name", "Filter Cycle 1 Start Minutes")
+    publish("spa/filter1minute/$datatype", "integer")
+    publish("spa/filter1minute/$format", "0:59")
+    publish("spa/filter1minute/$settable", "true")
+
+    publish("spa/filter1durationhours/$name", "Filter Cycle 1 Duration Hours")
+    publish("spa/filter1durationhours/$datatype", "integer")
+    publish("spa/filter1durationhours/$format", "0:24")
+    publish("spa/filter1durationhours/$settable", "true")
+
+    publish("spa/filter1durationminutes/$name", "Filter Cycle 1 Duration Minutes")
+    publish("spa/filter1durationminutes/$datatype", "integer")
+    publish("spa/filter1durationminutes/$format", "0:59")
+    publish("spa/filter1durationminutes/$settable", "true")
+
+    publish("spa/filter2enabled/$name", "Filter Cycle 2 Enabled")
+    publish("spa/filter2enabled/$datatype", "boolean")
+    publish("spa/filter2enabled/$settable", "true")
+
+    publish("spa/filter2hour/$name", "Filter Cycle 2 Start Hour")
+    publish("spa/filter2hour/$datatype", "integer")
+    publish("spa/filter2hour/$format", "0:24")
+    publish("spa/filter2hour/$settable", "true")
+
+    publish("spa/filter2minute/$name", "Filter Cycle 2 Start Minutes")
+    publish("spa/filter2minute/$datatype", "integer")
+    publish("spa/filter2minute/$format", "0:59")
+    publish("spa/filter2minute/$settable", "true")
+
+    publish("spa/filter2durationhours/$name", "Filter Cycle 2 Duration Hours")
+    publish("spa/filter2durationhours/$datatype", "integer")
+    publish("spa/filter2durationhours/$format", "0:24")
+    publish("spa/filter2durationhours/$settable", "true")
+
+    publish("spa/filter2durationminutes/$name", "Filter Cycle 2 Duration Minutes")
+    publish("spa/filter2durationminutes/$datatype", "integer")
+    publish("spa/filter2durationminutes/$format", "0:59")
+    publish("spa/filter2durationminutes/$settable", "true")
+
+    subscribe("spa/filter1hour/set")
+    subscribe("spa/filter1minute/set")
+    subscribe("spa/filter1durationhours/set")
+    subscribe("spa/filter1durationminutes/set")
+    subscribe("spa/filter2enabled/set")
+    subscribe("spa/filter2hour/set")
+    subscribe("spa/filter2minute/set")
+    subscribe("spa/filter2durationhours/set")
+    subscribe("spa/filter2durationminutes/set")
+
+    @things.merge(["filter1hour,filter1minute,filter1durationhours,filter1durationminutes,filter2enabled,filter2hour,filter2minute,filter2durationhours,filter2durationminutes"])
+
+    publish_nodes
+  end
+
   def publish_nodes
-    publish("spa/$properties", (["priming,heatingmode,temperaturescale,24htime,heating,temperaturerange,currenttemperature,settemperature,filter1,filter2"] + @things.to_a).join(','))
+    publish("spa/$properties", (["hold,priming,heatingmode,temperaturescale,24htime,heating,temperaturerange,currenttemperature,settemperature,filter1,filter2"] + @things.to_a).join(','))
   end
 end
 
@@ -260,6 +597,7 @@ mqtt_uri = ARGV.shift
 if ARGV.empty?
   spas = BWA::Discovery.discover
   if spas.empty?
+    BWA.logger.fatal "Could not find spa!"
     $stderr.puts "Could not find spa!"
     exit 1
   end
@@ -271,5 +609,6 @@ end
 spa = BWA::Client.new(spa_ip)
 
 spa.request_configuration
+spa.request_filter_configuration
 
 MQTTBridge.new(mqtt_uri, spa)

data/lib/bwa/client.rb

@@ -1,3 +1,6 @@
+require 'uri'
+
+require 'bwa/logger'
 require 'bwa/message'
 
 module BWA
@@ -8,7 +11,7 @@ module BWA
       uri = URI.parse(uri)
       if uri.scheme == 'tcp'
         require 'socket'
-        @io = TCPSocket.new(uri.host, uri.port || 4217)
+        @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)
@@ -18,6 +21,7 @@ module BWA
         @io = CCutrer::SerialPort.new(uri.path, baud: 115200)
         @queue = []
       end
+      @src = 0x0a
       @buffer = ""
     end
 
@@ -41,7 +45,7 @@ module BWA
       end
 
       if message.is_a?(Messages::Ready) && (msg = @queue&.shift)
-        puts "wrote #{msg.unpack('H*').first}"
+        BWA.logger.debug "wrote: #{BWA.raw2str(msg)}" unless BWA.verbosity < 1 && msg[3..4] == Messages::ControlConfigurationRequest::MESSAGE_TYPE
         @io.write(msg)
       end
       @last_status = message.dup if message.is_a?(Messages::Status)
@@ -60,35 +64,35 @@ 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
+      BWA.logger.info "  to spa: #{message.inspect}" unless BWA.verbosity < 1 && message.is_a?(Messages::ControlConfigurationRequest)
+      full_message = message.serialize
       if @queue
         @queue.push(full_message)
       else
+        BWA.logger.debug "wrote: #{BWA.raw2str(full_message)}" unless BWA.verbosity < 1 && message.is_a?(Messages::ControlConfigurationRequest)
         @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(i)
@@ -100,11 +104,15 @@ module BWA
     end
 
     def toggle_mister
-      toggle_item(0x0e)
+      toggle_item(:mister)
     end
 
     def toggle_blower
-      toggle_item(0x0c)
+      toggle_item(:blower)
+    end
+
+    def toggle_hold
+      toggle_item(:hold)
     end
 
     def set_pump(i, desired)
@@ -141,22 +149,57 @@ module BWA
       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_hold(desired)
+      return unless last_status
+      return if last_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
+
       desired *= 2 if last_status && last_status.temperature_scale == :celsius || desired < 50
-      send_message("\x0a\xbf\x20#{desired.round.chr}")
+      send_message(Messages::SetTemperature.new(desired.round))
     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)
+      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)
-      arg = scale == :fahrenheit ? 0 : 1
-      send_message("\x0a\xbf\x27\x01".force_encoding(Encoding::ASCII_8BIT) + arg.chr)
+      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
+      request_filter_configuration
     end
 
     def toggle_temperature_range
@@ -170,7 +213,7 @@ module BWA
     end
 
     def toggle_heating_mode
-      toggle_item(0x51)
+      toggle_item(:heating_mode)
     end
 
     HEATING_MODES = %I{ready rest ready_in_rest}.freeze

data/lib/bwa/discovery.rb

@@ -1,4 +1,5 @@
 require 'socket'
+require 'bwa/logger'
 
 module BWA
   class Discovery
@@ -34,7 +35,7 @@ module BWA
           data, addr = socket.recvfrom(32)
           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,55 @@
+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") if msg.backtrace }"
+      else
+        msg.inspect
+      end
+    end
+
+    def raw2str(data)
+      data.unpack("H*").first.gsub!(/(..)/, "\\1 ").chop!
+    end
+  end
+end

data/lib/bwa/message.rb

@@ -1,3 +1,4 @@
+require 'bwa/logger'
 require 'bwa/crc'
 
 module BWA
@@ -11,6 +12,8 @@ module BWA
   end
 
   class Message
+    attr_accessor :src
+
     class Unrecognized < Message
     end
 
@@ -20,40 +23,75 @@ module BWA
         @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
+      ]
+
+      # 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 = []
+          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
+          msgs
+        end
+        @COMMON_MESSAGES
+      end
+
       def parse(data)
         offset = -1
         message_type = length = message_class = 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] == '~'
+
+          # Read length (safe since we have at least 5 chars)
           length = data[offset + 1].ord
-          # impossible message
-          next if length < 5
+
+          # No message is this short or this long; keep scanning
+          next if length < 5 or length >= '~'.ord
 
           # don't have enough data for what this message wants;
-          # it could be garbage on the line so keep scanning
-          next if length + 2 > data.length - offset
+          # return and hope for more (yes this might cause a
+          # delay, but the protocol is very chatty so it won't
+          # be long)
+          return nil if length + 2 > data.length - offset
 
+          # Not properly terminated; keep scanning
           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
+
+          # Got a valid message!
           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 == 0
+        BWA.logger.debug " read: #{BWA.raw2str(data.slice(offset, length + 2))}" unless common_messages.include?(message_type)
 
         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?)
@@ -63,6 +101,7 @@ module BWA
           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
 
@@ -70,6 +109,7 @@ 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
 

data/lib/bwa/messages/configuration.rb

@@ -3,6 +3,10 @@ module BWA
     class Configuration < Message
       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/control_configuration.rb

@@ -7,6 +7,7 @@ module BWA
       attr_accessor :model, :version
 
       def initialize
+        super
         @model = ''
         @version = 0
       end

data/lib/bwa/messages/control_configuration_request.rb

@@ -7,14 +7,32 @@ module BWA
       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"; 1
+          when "\x00\x00\x01"; 2
+          when "\x01\x00\x00"; 3
+          else 0
+        end
       end
 
+      def serialize
+        data = case type
+          when 1; "\x02\x00\x00"
+          when 2; "\x00\x00\x01"
+          when 3; "\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/ready.rb

@@ -3,6 +3,10 @@ module BWA
     class Ready < Message
       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

@@ -7,6 +7,7 @@ module BWA
       attr_accessor :temperature
 
       def initialize(temperature = nil)
+        super()
         self.temperature = temperature
       end
 

data/lib/bwa/messages/set_temperature_scale.rb

@@ -7,6 +7,7 @@ module BWA
       attr_accessor :scale
 
       def initialize(scale = nil)
+        super()
         self.scale = scale
       end
 

data/lib/bwa/messages/set_time.rb

@@ -7,6 +7,7 @@ module BWA
       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
 

data/lib/bwa/messages/status.rb

@@ -1,7 +1,8 @@
 module BWA
   module Messages
     class Status < Message
-      attr_accessor :priming,
+      attr_accessor :hold,
+                    :priming,
                     :heating_mode,
                     :temperature_scale,
                     :twenty_four_hour_time,
@@ -23,6 +24,7 @@ module BWA
 
       def initialize
         @src = 0xff
+        self.hold = false
         self.priming = false
         self.heating_mode = :ready
         @temperature_scale = :fahrenheit
@@ -40,6 +42,9 @@ module BWA
       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
@@ -81,13 +86,14 @@ module BWA
         self.current_temperature = nil if self.current_temperature == 0xff
         self.set_temperature = data[20].ord
         if temperature_scale == :celsius
-          self.current_temperature /= 2.0
-          self.set_temperature /= 2.0
+          self.current_temperature /= 2.0 if self.current_temperature
+          self.set_temperature /= 2.0 if self.set_temperature
         end
       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
@@ -118,7 +124,7 @@ module BWA
           data[2] = (current_temperature ? (current_temperature * 2).to_i : 0xff).chr
           data[20] = (set_temperature * 2).to_i.chr
         else
-          data[2] = (current_temperature&.to_i || 0xff).chr
+          data[2] = (current_temperature.to_i || 0xff).chr
           data[20] = set_temperature.to_i.chr
         end
 
@@ -154,6 +160,7 @@ module BWA
         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}"

data/lib/bwa/messages/toggle_item.rb

@@ -7,6 +7,7 @@ module BWA
       attr_accessor :item
 
       def initialize(item = nil)
+        super()
         self.item = item
       end
 
@@ -14,6 +15,8 @@ module BWA
         self.item = case data[0].ord
                       when 0x04; :pump1
                       when 0x05; :pump2
+                      when 0x0c; :blower
+                      when 0x0e; :mister
                       when 0x11; :light1
                       when 0x3c; :hold
                       when 0x50; :temperature_range
@@ -24,13 +27,20 @@ module BWA
 
       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
+        if item.is_a? Integer
+          data[0] = item.chr
+        else
+          data[0] = (case item
+                      when :pump1; 0x04
+                      when :pump2; 0x05
+                      when :blower; 0x0c
+                      when :mister; 0x0e
+                      when :light1; 0x11
+                      when :hold; 0x3c
+                      when :temperature_range; 0x50
+                      when :heating_mode; 0x51
+                    end).chr
+        end
         super(data)
       end
 

data/lib/bwa/proxy.rb

@@ -1,4 +1,5 @@
 require 'socket'
+require 'bwa/logger'
 require 'bwa/message'
 
 module BWA
@@ -44,9 +45,9 @@ module BWA
         leftover_data = leftover_data[(data_length + 2)..-1] || ''
         begin
           message = Message.parse(data)
-          puts "#{tag}: #{message.inspect}"
+          BWA.logger.info "#{tag}: #{message.inspect}"
         rescue InvalidMessage => e
-          puts "#{tag}: #{e}"
+          BWA.logger.info "#{tag}: #{e}"
         end
         socket2.send(data, 0)
       end

data/lib/bwa/server.rb

@@ -1,4 +1,5 @@
 require 'socket'
+require 'bwa/logger'
 require 'bwa/message'
 
 module BWA
@@ -26,7 +27,7 @@ module BWA
     end
 
     def run_client(socket)
-      puts "Received connection from #{socket.remote_address.inspect}"
+      BWA.logger.info "Received connection from #{socket.remote_address.inspect}"
 
       send_status(socket)
       loop do
@@ -35,8 +36,8 @@ module BWA
           break if data.empty?
           begin
             message = Message.parse(data)
-            puts message.raw_data.unpack("H*").first.scan(/[0-9a-f]{2}/).join(' ')
-            puts message.inspect
+            BWA.logger.info BWA.raw2str(message.raw_data)
+            BWA.logger.info message.inspect
 
             case message
             when Messages::ConfigurationRequest
@@ -64,8 +65,8 @@ module BWA
               end
             end
           rescue BWA::InvalidMessage => e
-            puts e.message
-            puts e.raw_data.unpack("H*").first.scan(/[0-9a-f]{2}/).join(' ')
+            BWA.logger.warn e.message
+            BWA.logger.warn BWA.raw2str(e.raw_data)
           end
         else
           send_status(socket)
@@ -74,7 +75,7 @@ module BWA
     end
 
     def send_status(socket)
-      puts "sending #{@status.inspect}"
+      BWA.logger.info "sending #{@status.inspect}"
       socket.send(@status.serialize, 0)
     end
 

data/lib/bwa/version.rb

@@ -1,3 +1,3 @@
 module BWA
-  VERSION = '1.2.2'
+  VERSION = '1.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: balboa_worldwide_app
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.3.0
 platform: ruby
 authors:
 - Cody Cutrer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-15 00:00:00.000000000 Z
+date: 2021-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: digest-crc
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: sd_notify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.1
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
@@ -109,6 +123,7 @@ files:
 - lib/bwa/client.rb
 - lib/bwa/crc.rb
 - lib/bwa/discovery.rb
+- lib/bwa/logger.rb
 - lib/bwa/message.rb
 - lib/bwa/messages/configuration.rb
 - lib/bwa/messages/configuration_request.rb
@@ -143,7 +158,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Library for communication with Balboa Water Group's WiFi module or RS-485