balboa_worldwide_app 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7daff60d63c09a23f5628f69102fa722745c343d5c3641d7d87f09e47be7549a
+  data.tar.gz: b70859344d26e0f7a54b3a8ffea6389637683c5b5f31de5a0defb8bb52176c0a
+SHA512:
+  metadata.gz: '085e33a524d9410cbd069592804a716448031eece734bf5d2209318ef387ef9b2cda6fe941f4956681015889ca70f6f4429805eabfbc56e0bd23322262c3f850'
+  data.tar.gz: 749b99bc33e6df19dec5f276206a62556310be025daec5b8c71f061f8fd45510d7a6f58f201655f8b9cfc0bfaf826cf7c7b5b3d5b43755bbedc44ed87bdd70b5

data/bin/bwa_client

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+require 'bwa/client'
+require 'bwa/discovery'
+
+def watch(spa)
+  loop do
+    begin
+      message = spa.poll
+      next if message.is_a?(BWA::Messages::Ready)
+      puts message.raw_data.unpack("H*").first.scan(/[0-9a-f]{2}/).join(' ')
+      puts message.inspect
+      if block_given?
+        break if yield
+      end
+    rescue BWA::InvalidMessage => e
+      puts e.message
+      puts e.raw_data.unpack("H*").first.scan(/[0-9a-f]{2}/).join(' ')
+      break
+    end
+  end
+end
+
+if ARGV.empty?
+  spas = BWA::Discovery.discover
+  if spas.empty?
+    $stderr.puts "Could not find spa!"
+    exit 1
+  end
+  spa_ip = spas.first.first
+else
+  spa_ip = ARGV[0]
+end
+
+spa = BWA::Client.new(spa_ip)
+
+spa.request_configuration
+spa.request_control_info
+watch(spa) do
+  spa.last_status
+end
+
+watch(spa)

data/bin/bwa_mqtt_bridge

@@ -0,0 +1,188 @@
+#!/usr/bin/env ruby
+
+require 'mqtt'
+
+require 'bwa/client'
+require 'bwa/discovery'
+
+class MQTTBridge
+  def initialize(mqtt_uri, bwa, device_id: "bwa", base_topic: "homie")
+    @base_topic = "#{base_topic}/#{device_id}"
+    @mqtt = MQTT::Client.new(mqtt_uri)
+    @mqtt.set_will("#{@base_topic}/$state", "lost", true)
+    @mqtt.connect
+    @bwa = bwa
+    @attributes = {}
+
+    publish_basic_attributes
+
+    bwa_thread = Thread.new do
+      loop do
+        begin
+          message = @bwa.poll
+          next if message.is_a?(BWA::Messages::Ready)
+
+          case message
+          when BWA::Messages::Status
+            # make sure time is in sync
+            now = Time.now
+            if message.hour != now.hour || message.minute != now.min
+              @bwa.set_time(now.hour, now.min, message.twenty_four_hour_time)
+            end
+            publish_attribute("spa/priming", message.priming)
+            publish_attribute("spa/heatingmode", message.heating_mode)
+            publish_attribute("spa/temperaturescale", message.temperature_scale)
+            publish_attribute("spa/24htime", message.twenty_four_hour_time)
+            publish_attribute("spa/heating", message.heating)
+            publish_attribute("spa/temperaturerange", message.temperature_range)
+            publish_attribute("spa/circpump", message.circ_pump)
+            publish_attribute("spa/pump1", message.pump1)
+            publish_attribute("spa/pump2", message.pump2)
+            publish_attribute("spa/light1", message.light1)
+            publish_attribute("spa/currenttemperature", message.current_temperature)
+            publish_attribute("spa/currenttemperature/$unit", "º#{message.temperature_scale.to_s[0].upcase}")
+            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/settemperature/$format", message.temperature_range == :high ? "26:40" : "10:26")
+            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")
+            end
+          end
+        end
+      end
+    end
+
+    @mqtt.get do |topic, value|
+      puts "got #{value.inspect} at #{topic}"
+      case topic[@base_topic.length + 1..-1]
+      when "heatingmode"
+        next unless %w{ready rest ready_in_rest}.include?(value)
+        # @bwa.set_heating_mode(value.to_sym)
+      when "temperaturescale"
+        next unless %w{fahrenheit celsius}.include?(value)
+        # @bwa.set_temperature_scale(value.to_sym)
+      when "spa/24htime/set"
+        next unless %w{true false}.include?(value)
+        now = Time.now
+        @bwa.set_time(now.hour, now.min, value == 'true')
+      when "temperaturerange"
+        next unless %w{low high}.include?(value)
+        # @bwa.set_temperature_range(value.to_sym)
+      when %r{^spa/(pump[12])/set}
+        @bwa.send(:"set_#{$1}", value.to_i)
+      when "spa/light1/set"
+        next unless %w{true false}.include?(value)
+        @bwa.set_light1(value == 'true')
+      when "spa/settemperature/set"
+        @bwa.set_temperature(value.to_i)
+      end
+    end
+  end
+
+  def publish(topic, value)
+    @mqtt.publish("#{@base_topic}/#{topic}", value, true)
+  end
+
+  def publish_attribute(attr, value)
+    if !@attributes.key?(attr) || @attributes[attr] != value
+      publish(attr, value.to_s)
+      @attributes[attr] = value
+    end
+  end
+
+  def subscribe(topic)
+    @mqtt.subscribe("#{@base_topic}/#{topic}")
+  end
+
+  def publish_basic_attributes
+    publish("$homie", "v4.0.0")
+    publish("$name", "BWA Spa")
+    publish("$state", "init")
+    publish("$nodes", "spa")
+
+    publish("spa/$name", "BWA Spa")
+    publish("spa/$type", "spa")
+    publish("spa/$properties", "priming,heatingmode,temperaturescale,24htime,heating,temperaturerange,circpump,pump1,pump2,light1,currenttemperature,settemperature")
+
+    publish("spa/priming/$name", "Is the pump priming")
+    publish("spa/priming/$datatype", "boolean")
+
+    publish("spa/heatingmode/$name", "Current heating mode")
+    publish("spa/heatingmode/$datatype", "enum")
+    publish("spa/heatingmode/$format", "ready,rest,ready_in_rest")
+    publish("spa/heatingmode/$settable", "true")
+    subscribe("spa/heatingmode/set")
+
+    publish("spa/temperaturescale/$name", "Temperature scale")
+    publish("spa/temperaturescale/$datatype", "enum")
+    publish("spa/temperaturescale/$format", "fahrenheit,celsius")
+    publish("spa/temperaturescale/$settable", "true")
+    subscribe("spa/temperaturescale/set")
+
+    publish("spa/24htime/$name", "Clock is 24 hour time")
+    publish("spa/24htime/$datatype", "boolean")
+    publish("spa/24htime/$settable", "true")
+    subscribe("spa/24htime/set")
+
+    publish("spa/heating/$name", "Heater is currently running")
+    publish("spa/heating/$datatype", "boolean")
+
+    publish("spa/temperaturerange/$name", "Current temperature range")
+    publish("spa/temperaturerange/$datatype", "enum")
+    publish("spa/temperaturerange/$format", "high,low")
+    publish("spa/temperaturerange/$settable", "true")
+    subscribe("spa/temperaturerange/set")
+
+    publish("spa/circpump/$name", "Circ pump is currently running")
+    publish("spa/circpump/$datatype", "boolean")
+
+    publish("spa/pump1/$name", "Pump 1 speed")
+    publish("spa/pump1/$datatype", "integer")
+    publish("spa/pump1/$format", "0:2")
+    publish("spa/pump1/$settable", "true")
+    subscribe("spa/pump1/set")
+
+    publish("spa/pump2/$name", "Pump 2 speed")
+    publish("spa/pump2/$datatype", "integer")
+    publish("spa/pump2/$format", "0:2")
+    publish("spa/pump2/$settable", "true")
+    subscribe("spa/pump2/set")
+
+    publish("spa/light1/$name", "Light 1")
+    publish("spa/light1/$datatype", "boolean")
+    publish("spa/light1/$settable", "true")
+    subscribe("spa/light1/set")
+
+    publish("spa/currenttemperature/$name", "Current temperature")
+    publish("spa/currenttemperature/$datatype", "integer")
+
+    publish("spa/settemperature/$name", "Set Temperature")
+    publish("spa/settemperature/$datatype", "integer")
+    publish("spa/settemperature/$settable", "true")
+    subscribe("spa/settemperature/set")
+
+    publish("$state", "ready")
+  end
+end
+
+mqtt_uri = ARGV.shift
+
+if ARGV.empty?
+  spas = BWA::Discovery.discover
+  if spas.empty?
+    $stderr.puts "Could not find spa!"
+    exit 1
+  end
+  spa_ip = spas.first.first
+else
+  spa_ip = ARGV[0]
+end
+
+spa = BWA::Client.new(spa_ip)
+
+spa.request_configuration
+
+MQTTBridge.new(mqtt_uri, spa)

data/bin/bwa_proxy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bwa/discovery'
+require 'bwa/proxy'
+
+Thread.new do
+  BWA::Discovery.advertise
+end
+
+proxy = BWA::Proxy.new(ARGV[0])
+
+loop do
+  proxy.run
+end

data/bin/bwa_server

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bwa/discovery'
+require 'bwa/server'
+
+Thread.new do
+  BWA::Discovery.advertise
+end
+
+server = BWA::Server.new
+
+loop do
+  server.run
+end

data/lib/balboa_worldwide_app.rb

@@ -0,0 +1 @@
+require 'bwa/client'

data/lib/bwa/client.rb

@@ -0,0 +1,117 @@
+require 'bwa/message'
+
+module BWA
+  class Client
+    attr_reader :last_status, :last_filter_configuration
+
+    def initialize(host, port = 4257)
+      if host =~ %r{^/dev}
+        require 'serialport'
+        @io = SerialPort.open(host, "baud" => 115200)
+        @queue = []
+      else
+        require 'socket'
+        @io = TCPSocket.new(host, port)
+      end
+    end
+
+    def poll
+      message = nil
+      while message.nil?
+        begin
+          message = Message.parse(@io)
+          if message.is_a?(Messages::Ready) && (msg = @queue.shift)
+            @io.write(msg)
+          end
+        rescue BWA::InvalidMessage => e
+          unless e.message =~ /Incorrect data length/
+            puts e.message
+            puts e.raw_data.unpack("H*").first.scan(/[0-9a-f]{2}/).join(' ')
+          end
+        end
+      end
+      @last_status = message.dup if message.is_a?(Messages::Status)
+      @last_filter_configuration = message.dup if message.is_a?(Messages::FilterCycles)
+      message
+    end
+
+    def messages_pending?
+      !!IO.select([@io], nil, nil, 0)
+    end
+
+    def drain_message_queue
+      poll while messages_pending?
+    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)
+      if @queue
+        @queue.push(full_message)
+      else
+        @io.write(full_message)
+      end
+    end
+
+    def request_configuration
+      send_message("\x0a\xbf\x04")
+    end
+
+    def request_control_info
+      send_message("\x0a\xbf\x22\x02\x00\x00")
+    end
+
+    def request_filter_configuration
+      send_message("\x0a\xbf\x22\x01\x00\x00")
+    end
+
+    def toggle_item(args)
+      send_message("\x0a\xbf\x11#{args}")
+    end
+
+    def toggle_light1
+      toggle_item("\x11\x00")
+    end
+
+    def toggle_pump1
+      toggle_item("\x04\x00")
+    end
+
+    def toggle_pump2
+      toggle_item("\x05\x00")
+    end
+
+    (1..2).each do |i|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def set_pump#{i}(desired)
+        return unless last_status
+        times = (desired - last_status.pump#{i}) % 3
+        times.times do
+          toggle_pump#{i}
+          sleep(0.1)
+        end
+      end
+      RUBY
+    end
+
+    def set_light1(desired)
+      return unless last_status
+      return if last_status.light1 == desired
+      toggle_light1
+    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.chr}")
+    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)
+    end
+  end
+end

data/lib/bwa/crc.rb

@@ -0,0 +1,8 @@
+require 'digest/crc'
+
+module BWA
+  class CRC < Digest::CRC8
+    INIT_CRC = 0x02
+    XOR_MASK = 0x02
+  end
+end

data/lib/bwa/discovery.rb

@@ -0,0 +1,43 @@
+require 'socket'
+
+module BWA
+  class Discovery
+    class << self
+      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'))
+        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
+          end
+        end
+        spas
+      end
+
+      def advertise
+        socket = UDPSocket.new
+        socket.bind("0.0.0.0", 30303)
+        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?'
+          ip = addr.last
+          puts "Advertising to #{ip}"
+          socket.sendmsg(msg, 0, Socket.sockaddr_in(addr[1], ip))
+        end
+      end
+    end
+  end
+end

data/lib/bwa/message.rb

@@ -0,0 +1,119 @@
+require 'bwa/crc'
+
+module BWA
+  class InvalidMessage < RuntimeError
+    attr_reader :raw_data
+
+    def initialize(message, data)
+      @raw_data = data
+      super(message)
+    end
+  end
+
+  class Message
+    class << self
+      def inherited(klass)
+        @messages ||= []
+        @messages << klass
+      end
+
+      def parse(io)
+        io = StringIO.new(io) if io.is_a?(String)
+        data = ''
+        # skim through until a start-of-message indicator
+        until data[0] == '~'
+          data = io.read(1)
+        end
+
+        data.concat(io.read(1))
+        length = data[-1].ord
+
+        if length < 5
+          bytes = data.bytes
+          bytes.shift
+          bytes.reverse.each { |byte| io.ungetbyte(byte) }
+          raise InvalidMessage.new("Message has bogus length: #{length}", data)
+        end
+
+        data.concat(io.read(length))
+        if data.length != length + 2
+          data.bytes.reverse.each { |b| io.ungetbyte(b) }
+          raise InvalidMessage.new("Incorrect data length (received #{data.length - 2}, expected #{length})", data)
+        end
+
+        message_type = data[2..4]
+        klass = @messages.find { |k| k::MESSAGE_TYPE == message_type }
+
+        unless data[-1] == '~'
+          bytes = data.bytes
+          bytes.shift
+          bytes.reverse.each { |b| io.ungetbyte(b) }
+          raise InvalidMessage.new("Missing trailing message indicator", data)
+        end
+
+        unless CRC.checksum(data[1...-2]) == data[-2].ord
+          bytes = data.bytes
+          bytes.shift
+          bytes.reverse.each { |b| io.ungetbyte(b) }
+          raise InvalidMessage.new("Invalid checksum", data)
+        end
+
+        return nil if [
+                      "\xfe\xbf\x00".force_encoding(Encoding::ASCII_8BIT),
+                      "\x10\xbf\xe1".force_encoding(Encoding::ASCII_8BIT),
+                      "\x10\xbf\x07".force_encoding(Encoding::ASCII_8BIT)].include?(message_type)
+
+        raise InvalidMessage.new("Unrecognized message #{message_type.unpack("H*").first}", data) unless klass
+        raise InvalidMessage.new("Unrecognized data length (#{length}) for message #{klass}", data) unless length - 5 == klass::MESSAGE_LENGTH
+
+        message = klass.new
+        message.parse(data[5..-2])
+        message.instance_variable_set(:@raw_data, data)
+        message
+      end
+
+      def format_time(hour, minute, twenty_four_hour_time = true)
+        if twenty_four_hour_time
+          print_hour = "%02d" % hour
+        else
+          print_hour = hour % 12
+          print_hour = 12 if print_hour == 0
+          am_pm = (hour >= 12 ? "PM" : "AM")
+        end
+        "#{print_hour}:#{"%02d" % minute}#{am_pm}"
+      end
+
+      def format_duration(hours, minutes)
+        "#{hours}:#{"%02d" % minutes}"
+      end
+    end
+
+    attr_reader :raw_data
+
+    def parse(_data)
+    end
+
+    def serialize(message = "")
+      length = message.length + 5
+      full_message = "#{length.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)
+    end
+
+    def inspect
+      "#<#{self.class.name} #{raw_data.unpack("H*").first}>"
+    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'

data/lib/bwa/messages/configuration.rb

@@ -0,0 +1,8 @@
+module BWA
+  module Messages
+    class Configuration < Message
+      MESSAGE_TYPE = "\x0a\xbf\x94".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_LENGTH = 25
+    end
+  end
+end

data/lib/bwa/messages/configuration_request.rb

@@ -0,0 +1,12 @@
+module BWA
+  module Messages
+    class ConfigurationRequest < Message
+      MESSAGE_TYPE = "\x0a\xbf\x04".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_LENGTH = 0
+
+      def inspect
+        "#<BWA::Messages::ConfigurationRequest>"
+      end
+    end
+  end
+end

data/lib/bwa/messages/control_configuration.rb

@@ -0,0 +1,17 @@
+module BWA
+  module Messages
+    class ControlConfiguration < Message
+      MESSAGE_TYPE = "\x0a\xbf\x24".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_LENGTH = 21
+    end
+  end
+end
+
+module BWA
+  module Messages
+    class ControlConfiguration2 < Message
+      MESSAGE_TYPE = "\x0a\xbf\x2e".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_LENGTH = 6
+    end
+  end
+end

data/lib/bwa/messages/control_configuration_request.rb

@@ -0,0 +1,20 @@
+module BWA
+  module Messages
+    class ControlConfigurationRequest < Message
+      MESSAGE_TYPE = "\x0a\xbf\x22".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_LENGTH = 3
+
+      attr_accessor :type
+
+      def initialize(type = 1)
+        self.type = type
+      end
+
+      def parse(data)
+        self.type = data == "\x02\x00\x00" ? 1 : 2
+      end
+
+
+    end
+  end
+end

data/lib/bwa/messages/filter_cycles.rb

@@ -0,0 +1,42 @@
+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
+
+      MESSAGE_TYPE = "\x0a\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
+      end
+
+      def inspect
+        result = "#<BWA::Messages::FilterCycles "
+
+        result << "filter1 "
+        result << self.class.format_duration(filter1_duration_hours, filter1_duration_minutes)
+        result << "@"
+        result << self.class.format_time(filter1_hour, filter1_minute)
+
+        result << " filter2(#{@filter2_enabled ? 'enabled' : 'disabled'}) "
+        result << self.class.format_duration(filter2_duration_hours, filter2_duration_minutes)
+        result << "@"
+        result << self.class.format_time(filter2_hour, filter2_minute)
+
+        result << ">"
+      end
+    end
+  end
+end

data/lib/bwa/messages/ready.rb

@@ -0,0 +1,8 @@
+module BWA
+  module Messages
+    class Ready < Message
+      MESSAGE_TYPE = "\x10\xbf\06".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_LENGTH = 0
+    end
+  end
+end

data/lib/bwa/messages/set_temperature.rb

@@ -0,0 +1,26 @@
+module BWA
+  module Messages
+    class SetTemperature < Message
+      MESSAGE_TYPE = "\x0a\xbf\x20".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_LENGTH = 1
+
+      attr_accessor :temperature
+
+      def initialize(temperature = nil)
+        self.temperature = temperature
+      end
+
+      def parse(data)
+        self.temperature = data[0].ord
+      end
+
+      def serialize
+        super(temperature.chr)
+      end
+
+      def inspect
+        "#<BWA::Messages::SetTemperature #{temperature}º>"
+      end
+    end
+  end
+end

data/lib/bwa/messages/set_temperature_scale.rb

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

data/lib/bwa/messages/set_time.rb

@@ -0,0 +1,30 @@
+module BWA
+  module Messages
+    class SetTime < Message
+      MESSAGE_TYPE = "\x0a\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)
+        self.hour, self.minute, self.twenty_four_hour_time = hour, minute, twenty_four_hour_time
+      end
+
+      def parse(data)
+        self.hour = data[0].ord & 0x7f
+        self.minute = data[1].ord
+        self.twenty_four_hour_time = !!(data[0].ord & 0x80)
+      end
+
+      def serialize
+        hour_encoded = hour
+        hour_encoded |= 0x80 if twenty_four_hour_time
+        super("#{hour_encoded.chr}#{minute.chr}")
+      end
+
+      def inspect
+        "#<BWA::Messages::SetTime #{Status.format_time(hour, minute, twenty_four_hour_time)}>"
+      end
+    end
+  end
+end

data/lib/bwa/messages/status.rb

@@ -0,0 +1,149 @@
+module BWA
+  module Messages
+    class Status < Message
+      attr_accessor :priming,
+                    :heating_mode,
+                    :temperature_scale,
+                    :twenty_four_hour_time,
+                    :heating,
+                    :temperature_range,
+                    :hour, :minute,
+                    :circ_pump,
+                    :pump1, :pump2,
+                    :light1,
+                    :current_temperature, :set_temperature
+
+      MESSAGE_TYPE = "\xff\xaf\x13".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_LENGTH = 24
+
+      def initialize
+        self.priming = false
+        self.heating_mode = :ready
+        @temperature_scale = :fahrenheit
+        self.twenty_four_hour_time = false
+        self.heating = false
+        self.temperature_range = :high
+        self.hour = self.minute = 0
+        self.circ_pump = false
+        self.pump1 = self.pump2 = 0
+        self.light1 = false
+        self.set_temperature = 100
+      end
+
+      def parse(data)
+        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
+                            end
+        flags = data[9].ord
+        self.temperature_scale = (flags & 0x01 == 0x01) ? :celsius : :fahrenheit
+        self.twenty_four_hour_time = (flags & 0x02 == 0x02)
+        flags = data[10].ord
+        self.heating = (flags & 0x30 != 0)
+        self.temperature_range = (flags & 0x04 == 0x04) ? :high : :low
+        flags = data[11].ord
+        self.pump1 = flags & 0x03
+        self.pump2 = (flags / 4) & 0x03
+        flags = data[13].ord
+        self.circ_pump = (flags & 0x02 == 0x02)
+        flags = data[14].ord
+        self.light1 = (flags & 0x03 == 0x03)
+        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
+          self.set_temperature /= 2.0
+        end
+      end
+
+      def serialize
+        data = "\x00" * 24
+        data[1] = (priming ? 0x01 : 0x00).chr
+        data[5] = (case heating_mode
+                     when :ready; 0x00
+                     when :rest; 0x01
+                     when :ready_in_rest; 0x02
+                   end).chr
+        flags = 0
+        flags |= 0x01 if temperature_scale == :celsius
+        flags |= 0x02 if twenty_four_hour_time
+        data[9] = flags.chr
+        flags = 0
+        flags |= 0x30 if heating
+        flags |= 0x04 if temperature_range == :high
+        data[10] = flags.chr
+        flags = 0
+        flags |= pump1
+        flags |= pump2 * 4
+        data[11] = flags.chr
+        flags = 0
+        flags |= 0x02 if circ_pump
+        data[13] = flags.chr
+        flags = 0
+        flags |= 0x03 if light1
+        data[14] = flags.chr
+        data[3] = hour.chr
+        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
+        else
+          data[2] = (current_temperature&.to_i || 0xff).chr
+          data[20] = set_temperature.to_i.chr
+        end
+
+        super(data)
+      end
+
+      def temperature_scale=(value)
+        if value != @temperature_scale
+          if value == :fahrenheit
+            if current_temperature
+              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
+          else
+            if current_temperature
+              self.current_temperature -= 32
+              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
+          end
+        end
+        @temperature_scale = value
+      end
+
+      def inspect
+        result = "#<BWA::Messages::Status "
+        items = []
+
+        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 << heating_mode
+        items << "heating" if heating
+        items << temperature_range
+        items << "circ_pump" if circ_pump
+        items << "pump1=#{pump1}" unless pump1 == 0
+        items << "pump2=#{pump2}" unless pump2 == 0
+        items << "light1" if light1
+
+        result << items.join(' ') << ">"
+      end
+    end
+  end
+end

data/lib/bwa/messages/toggle_item.rb

@@ -0,0 +1,40 @@
+module BWA
+  module Messages
+    class ToggleItem < Message
+      MESSAGE_TYPE = "\x0a\xbf\x11".force_encoding(Encoding::ASCII_8BIT)
+      MESSAGE_LENGTH = 2
+
+      attr_accessor :item
+
+      def initialize(item = nil)
+        self.item = item
+      end
+
+      def parse(data)
+        self.item = case data[0].ord
+                      when 0x04; :pump1
+                      when 0x05; :pump2
+                      when 0x11; :light1
+                      when 0x50; :temperature_range
+                      when 0x51; :heating_mode
+                    end
+      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
+        super(data)
+      end
+
+      def inspect
+        "#<BWA::Messages::ToggleItem #{item}>"
+      end
+    end
+  end
+end

data/lib/bwa/proxy.rb

@@ -0,0 +1,55 @@
+require 'socket'
+require 'bwa/message'
+
+module BWA
+  class Proxy
+    def initialize(host, port: 4257, listen_port: 4257)
+      @host, @port = host, port
+      @listen_socket = TCPServer.open(port)
+    end
+
+    def run
+      loop do
+        client_socket = @listen_socket.accept
+        server_socket = TCPSocket.new(@host, @port)
+        t1 = Thread.new do
+          shuffle_messages(client_socket, server_socket, "Client")
+        end
+        t2 = Thread.new do
+          shuffle_messages(server_socket, client_socket, "Server")
+        end
+        t1.join
+        t2.join
+        break
+      end
+    end
+
+    def shuffle_messages(socket1, socket2, tag)
+      leftover_data = "".force_encoding(Encoding::ASCII_8BIT)
+      loop do
+        if leftover_data.length < 2 || leftover_data.length < leftover_data[1].ord + 2
+          begin
+            leftover_data += socket1.recv(128)
+          rescue Errno::EBADF
+            # we closed it on ourselves
+            break
+          end
+        end
+        if leftover_data.empty?
+          socket2.close
+          break
+        end
+        data_length = leftover_data[1].ord
+        data = leftover_data[0...(data_length + 2)]
+        leftover_data = leftover_data[(data_length + 2)..-1] || ''
+        begin
+          message = Message.parse(data)
+          puts "#{tag}: #{message.inspect}"
+        rescue InvalidMessage => e
+          puts "#{tag}: #{e}"
+        end
+        socket2.send(data, 0)
+      end
+    end
+  end
+end

data/lib/bwa/server.rb

@@ -0,0 +1,93 @@
+require 'socket'
+require 'bwa/message'
+
+module BWA
+  class Server
+    def initialize(port = 4257)
+      @listen_socket = TCPServer.open(port)
+      @status = Messages::Status.new
+    end
+
+    def run
+      loop do
+        socket = @listen_socket.accept
+        #Thread.new do
+          run_client(socket)
+        #end
+        break
+      end
+    end
+
+    def send_message(socket, message)
+      length = message.length + 2
+      full_message = "#{length.chr}#{message}".force_encoding(Encoding::ASCII_8BIT)
+      checksum = CRC.checksum(full_message)
+      socket.send("\x7e#{full_message}#{checksum.chr}\x7e".force_encoding(Encoding::ASCII_8BIT), 0)
+    end
+
+    def run_client(socket)
+      puts "Received connection from #{socket.remote_address.inspect}"
+
+      send_status(socket)
+      loop do
+        if IO.select([socket], nil, nil, 1)
+          data = socket.recv(128)
+          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
+
+            case message
+            when Messages::ConfigurationRequest
+              send_configuration(socket)
+            when Messages::ControlConfigurationRequest
+              message.type == 1 ? send_control_configuration(socket) : send_control_configuration2(socket)
+            when Messages::SetTemperature
+              temperature = message.temperature
+              temperature /= 2.0 if @status.temperature_scale == :celsius
+              @status.set_temperature = temperature
+            when Messages::SetTemperatureScale
+              @status.temperature_scale = message.scale
+            when Messages::ToggleItem
+              case message.item
+              when :heating_mode
+                @status.heating_mode = (@status.heating_mode == :rest ? :ready : :rest)
+              when :temperature_range
+                @status.temperature_range = (@status.temperature_range == :low ? :high : :low)
+              when :pump1
+                @status.pump1 = (@status.pump1 + 1) % 3
+              when :pump2
+                @status.pump2 = (@status.pump2 + 1) % 3
+              when :light1
+                @status.light1 = !@status.light1
+              end
+            end
+          rescue BWA::InvalidMessage => e
+            puts e.message
+            puts e.raw_data.unpack("H*").first.scan(/[0-9a-f]{2}/).join(' ')
+          end
+        else
+          send_status(socket)
+        end
+      end
+    end
+
+    def send_status(socket)
+      puts "sending #{@status.inspect}"
+      socket.send(@status.serialize, 0)
+    end
+
+    def send_configuration(socket)
+      send_message(socket, "\x0a\xbf\x94\x02\x02\x80\x00\x15\x27\x10\xab\xd2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x27\xff\xff\x10\xab\xd2")
+    end
+
+    def send_control_configuration(socket)
+      send_message(socket, "\x0a\xbf\x24\x64\xdc\x11\x00\x42\x46\x42\x50\x32\x30\x20\x20\x01\x3d\x12\x38\x2e\x01\x0a\x04\x00")
+    end
+
+    def send_control_configuration2(socket)
+      send_message(socket, "\x0a\xbf\x2e\x0a\x00\x01\xd0\x00\x44")
+    end
+  end
+end

data/lib/bwa/version.rb

@@ -0,0 +1,3 @@
+module BWA
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: balboa_worldwide_app
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Cody Cutrer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: digest-crc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: serialport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+- !ruby/object:Gem::Dependency
+  name: mqtt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: 
+email: cody@cutrer.com'
+executables:
+- bwa_mqtt_bridge
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/bwa_client
+- bin/bwa_mqtt_bridge
+- bin/bwa_proxy
+- bin/bwa_server
+- lib/balboa_worldwide_app.rb
+- lib/bwa/client.rb
+- lib/bwa/crc.rb
+- lib/bwa/discovery.rb
+- lib/bwa/message.rb
+- lib/bwa/messages/configuration.rb
+- lib/bwa/messages/configuration_request.rb
+- lib/bwa/messages/control_configuration.rb
+- lib/bwa/messages/control_configuration_request.rb
+- lib/bwa/messages/filter_cycles.rb
+- lib/bwa/messages/ready.rb
+- lib/bwa/messages/set_temperature.rb
+- lib/bwa/messages/set_temperature_scale.rb
+- lib/bwa/messages/set_time.rb
+- lib/bwa/messages/status.rb
+- lib/bwa/messages/toggle_item.rb
+- lib/bwa/proxy.rb
+- lib/bwa/server.rb
+- lib/bwa/version.rb
+homepage: https://github.com/ccutrer/bwa
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Library for communication with Balboa Water Group's WiFi module or RS-485
+test_files: []