maxcube-client 0.4.0

data/lib/maxcube/messages/parser.rb

@@ -0,0 +1,34 @@
+require_relative 'handler'
+
+module MaxCube
+  module Messages
+    module Parser
+      include Handler
+
+      def read(count = 0, unpack = false)
+        str = if count.zero?
+                @io.read
+              else
+                raise IOError if @io.size - @io.pos < count
+                @io.read(count)
+              end
+        return str unless unpack
+        str = "\x00".b + str if count == 3
+        unpack = PACK_FORMAT[count] unless unpack.is_a?(String)
+        str.unpack1(unpack)
+      end
+
+      def parse_msg_body(body, hash, parser_type_str)
+        method_str = "parse_#{parser_type_str}_#{@msg_type.downcase}"
+        if respond_to?(method_str, true)
+          return hash.merge!(send(method_str, body))
+        end
+        hash[:data] = body
+        nil
+      rescue IOError
+        raise InvalidMessageBody
+          .new(@msg_type, 'unexpected EOF reached')
+      end
+    end
+  end
+end

data/lib/maxcube/messages/serializer.rb

@@ -0,0 +1,59 @@
+require_relative 'handler'
+
+module MaxCube
+  module Messages
+    module Serializer
+      include Handler
+
+      def serialize(*args, esize: 0, size: 0, ocount: 0)
+        return args.join if size.zero? && esize.zero?
+
+        ocount, subcount, subsize = serialize_bounds(args,
+                                                     esize: esize,
+                                                     size: size,
+                                                     ocount: ocount)
+        str = ''
+        args.reverse!
+        ocount.times do
+          str << args.pop while args.last.is_a?(String)
+          substr = args.pop(subcount).pack(PACK_FORMAT[subsize])
+          substr = substr[1..-1] if subsize == 3
+          str << substr
+        end
+        str << args.pop until args.empty?
+
+        str
+      end
+
+      def write(*args, esize: 0, size: 0, ocount: 0)
+        @io.write(serialize(*args, esize: esize, size: size, ocount: ocount))
+      end
+
+      def serialize_hash_body(hash, serializer_type_str)
+        method_str = "serialize_#{serializer_type_str}_#{@msg_type.downcase}"
+        return send(method_str, hash) if respond_to?(method_str, true)
+        raise InvalidMessageType
+          .new(@msg_type, 'serialization of message type' \
+                          ' is not implemented (yet)')
+      end
+
+      private
+
+      def serialize_bounds(args, esize: 0, size: 0, ocount: 0)
+        icount = args.size - args.count { |a| a.is_a?(String) }
+        return 0 if icount.zero?
+        if esize.zero?
+          ocount = icount if ocount.zero?
+          subsize = size / ocount
+        else
+          size = icount * esize
+          ocount = size / esize
+          subsize = esize
+        end
+        subcount = icount / ocount
+
+        [ocount, subcount, subsize]
+      end
+    end
+  end
+end

data/lib/maxcube/messages/tcp.rb

@@ -0,0 +1,18 @@
+require 'maxcube/messages'
+
+module MaxCube
+  module Messages
+    # Structure of message:
+    # * Starts with single letter followed by ':'
+    # * Ends with "\r\n"
+    # Example (unencoded):
+    # X:message\r\n
+    # As all messages are being split by "\r\n",
+    # it does not occur in single message processing,
+    # only in raw data processing.
+    module TCP
+      # Without "\r\n", with it it is 1900
+      MSG_MAX_LEN = 1898
+    end
+  end
+end

data/lib/maxcube/messages/tcp/handler.rb

@@ -0,0 +1,70 @@
+require 'maxcube/messages/tcp'
+require 'maxcube/messages/handler'
+
+module MaxCube
+  module Messages
+    module TCP
+      module Handler
+        include Messages::Handler
+
+        def valid_tcp_msg_length(msg)
+          msg.length.between?(2, MSG_MAX_LEN)
+        end
+
+        def check_tcp_msg_length(msg)
+          raise InvalidMessageLength unless valid_tcp_msg_length(msg)
+          msg.length
+        end
+
+        def valid_tcp_msg_format(msg)
+          msg =~ /\A[[:alpha:]]:[[:print:]]*\z/
+        end
+
+        def check_tcp_msg_format(msg)
+          raise InvalidMessageFormat unless valid_tcp_msg_format(msg)
+          msg
+        end
+
+        # Check single message validity, already without "\r\n" at the end
+        def valid_tcp_msg(msg)
+          valid_tcp_msg_length(msg) &&
+            valid_tcp_msg_format(msg) &&
+            valid_msg(msg)
+        end
+
+        def check_tcp_msg(msg)
+          check_tcp_msg_length(msg)
+          check_tcp_msg_format(msg)
+          check_msg(msg)
+          msg
+        end
+
+        def valid_tcp_hash(hash)
+          valid_hash(hash)
+        end
+
+        def check_tcp_hash(hash)
+          check_hash(hash)
+          hash
+        end
+
+        def valid_tcp_data(raw_data)
+          return true if raw_data.empty?
+          raw_data[0..1] != "\r\n" && raw_data.chars.last(2).join == "\r\n"
+        end
+
+        def check_tcp_data(raw_data)
+          # check_data_type(raw_data)
+          raise InvalidMessageFormat unless valid_tcp_data(raw_data)
+          raw_data
+        end
+
+        private
+
+        def msg_msg_type(msg)
+          msg.chr
+        end
+      end
+    end
+  end
+end

data/lib/maxcube/messages/tcp/parser.rb

@@ -0,0 +1,46 @@
+require_relative 'handler'
+require 'maxcube/messages/parser'
+
+module MaxCube
+  module Messages
+    module TCP
+      class Parser
+        include Handler
+        include Messages::Parser
+
+        %w[a c f h l m n s].each { |f| require_relative 'type/' << f }
+
+        MSG_TYPES = %w[H F L C M N A E D b g j p o v w S].freeze
+
+        include MessageA
+        include MessageC
+        include MessageF
+        include MessageH
+        include MessageL
+        include MessageM
+        include MessageN
+        include MessageS
+
+        # Process set of messages - raw data separated by "\r\n"
+        # @param [String, #read] raw data from a Cube
+        # @return [Array<Hash>] particular message contents
+        def parse_tcp_data(raw_data)
+          check_tcp_data(raw_data)
+          raw_data.split("\r\n").map(&method(:parse_tcp_msg))
+        end
+
+        # Parse single message already without "\r\n"
+        # @param [String, #read] single message data without "\r\n"
+        # @return [Hash] particular message parts separated into hash,
+        #                which should be human readable
+        def parse_tcp_msg(msg)
+          check_tcp_msg(msg)
+          body = msg.split(':')[1] || ''
+          hash = { type: @msg_type }
+          return hash unless parse_msg_body(body, hash, 'tcp')
+          check_tcp_hash(hash)
+        end
+      end
+    end
+  end
+end

data/lib/maxcube/messages/tcp/serializer.rb

@@ -0,0 +1,47 @@
+require_relative 'handler'
+require 'maxcube/messages/serializer'
+
+module MaxCube
+  module Messages
+    module TCP
+      class Serializer
+        include Handler
+        include Messages::Serializer
+
+        %w[a c f l m n q s t u z].each { |f| require_relative 'type/' << f }
+
+        MSG_TYPES = %w[u i s m n x g q e d B G J P O V W a r t l c v f z].freeze
+
+        include MessageA
+        include MessageC
+        include MessageF
+        include MessageL
+        include MessageM
+        include MessageN
+        include MessageQ
+        include MessageS
+        include MessageT
+        include MessageU
+        include MessageZ
+
+        # Send set of messages separated by "\r\n"
+        # @param [Array<Hash>] particular message contents
+        # @return [String] raw data for a Cube
+        def serialize_tcp_hashes(hashes)
+          raw_data = hashes.map(&method(:serialize_tcp_hash)).join
+          check_tcp_data(raw_data)
+        end
+
+        # Serialize data from hash into message with "\r\n" at the end
+        # @param [Hash, #read] particular human readable message parts
+        #                      (it is assumed to contain valid data)
+        # @return [String] single message data with "\r\n" at the end
+        def serialize_tcp_hash(hash)
+          check_tcp_hash(hash)
+          msg = "#{@msg_type}:" << serialize_hash_body(hash, 'tcp')
+          check_tcp_msg(msg) << "\r\n"
+        end
+      end
+    end
+  end
+end

data/lib/maxcube/messages/tcp/type/a.rb

@@ -0,0 +1,32 @@
+
+module MaxCube
+  module Messages
+    module TCP
+      class Parser
+        module MessageA
+          private
+
+          # Acknowledgement message to previous command
+          # e.g. factory reset (a), delete a device (t), wake up (z)
+          # Ignore all contents of the message
+          def parse_tcp_a(_body)
+            {}
+          end
+        end
+      end
+
+      class Serializer
+        module MessageA
+          private
+
+          # Factory reset command
+          # Does not contain any data
+          # Acknowledgement (A) follows
+          def serialize_tcp_a(_hash)
+            ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/maxcube/messages/tcp/type/c.rb

@@ -0,0 +1,248 @@
+
+module MaxCube
+  module Messages
+    module TCP
+      class Parser
+        module MessageC
+          private
+
+          KEYS = %i[length address rf_address device_type
+                    test_result serial_number].freeze
+          OPT_KEYS = %i[
+            firmware_version _firmware_version room_id
+
+            portal_enabled button_up_mode button_down_mode portal_url
+
+            comfort_temperature eco_temperature
+            max_setpoint_temperature min_setpoint_temperature
+            temperature_offset window_open_temperature window_open_duration
+            boost_duration valve_opening
+            decalcification_day decalcification_hour
+            max_valve_setting valve_offset
+
+            unknown unknown1 unknown2 unknown3 unknown4 weekly_program
+          ].freeze
+
+          LENGTHS = [6].freeze
+
+          # Configuration message
+          def parse_tcp_c(body)
+            addr, enc_data = parse_tcp_c_split(body)
+
+            @io = StringIO.new(decode(enc_data), 'rb')
+
+            hash = parse_tcp_c_head(addr)
+            parse_tcp_c_device_type(hash)
+
+            hash
+          end
+
+          ########################
+
+          def parse_tcp_c_split(body)
+            addr, enc_data = body.split(',')
+            check_msg_part_lengths(LENGTHS, addr)
+            to_ints(16, 'device address', addr)
+            [addr, enc_data]
+          end
+
+          def parse_tcp_c_head(addr)
+            @length = read(1, true)
+            # 'rf_address' should correspond with 'addr',
+            # but it is not checked (yet)
+            rf_address = read(3, true)
+            device_type = device_type(read(1, true))
+            hash = {
+              address: addr,
+              length: @length,
+              rf_address: rf_address,
+              device_type: device_type,
+            }
+
+            if device_type == :cube
+              # For 'cube' type, both fiels seem to be combined
+              # into 'firmware_version' string
+              room_id__fw_v = read(2, 'H*')
+              hash[:firmware_version] = room_id__fw_v[2..3] +
+                                        room_id__fw_v[0..1]
+            else
+              # For other types, both 'room_id' and 'firmware_version'
+              # are unpacked as numbers
+              # How should be 'firmware_version' interpreted ?
+              hash[:room_id] = read(1, true)
+              hash[:_firmware_version] = read(1, true)
+            end
+
+            hash.merge!(
+              test_result: read(1, true),
+              serial_number: read(10),
+            )
+          rescue IOError
+            raise InvalidMessageBody
+              .new(@msg_type,
+                   'unexpected EOF reached at head of decoded message data')
+          end
+
+          def parse_tcp_c_cube_button_mode_temp(value, base)
+            (value - base).to_f / 2 + 4.5
+          end
+
+          def parse_tcp_c_cube_button_mode(hash, up, down)
+            { 'up' => up, 'down' => down }.each do |k, v|
+              mode_key = "button_#{k}_mode".to_sym
+              case v
+              when 0x00
+                hash[mode_key] = :auto
+              when 0x41
+                hash[mode_key] = :eco
+              when 0x42
+                hash[mode_key] = :comfort
+              else
+                temp_key = "button_#{k}_temperature".to_sym
+                if v.between?(0x09, 0x3d)
+                  hash[mode_key] = :auto_temp
+                  hash[temp_key] = parse_tcp_c_cube_button_mode_temp(v, 0x09)
+                elsif v.between?(0x49, 0x7d)
+                  hash[mode_key] = :manual
+                  hash[temp_key] = parse_tcp_c_cube_button_mode_temp(v, 0x49)
+                else
+                  hash[mode_key] = :unknown
+                end
+              end
+            end
+          end
+
+          def parse_tcp_c_cube
+            hash = {
+              portal_enabled: !read(1, true).zero?,
+              unknown1: read(11),
+            }
+
+            pushbutton_up_config = read(1, true)
+            hash[:unknown2] = read(32)
+            pushbutton_down_config = read(1, true)
+            parse_tcp_c_cube_button_mode(hash,
+                                         pushbutton_up_config,
+                                         pushbutton_down_config)
+
+            # ! Exact decoding of time zones is not clear yet
+            hash.merge!(
+              unknown3: read(21),
+              portal_url: read(128),
+              # _timezone_winter: read(5),
+              # timezone_winter_month: read(1, true),
+              # timezone_winter_day: DAYS_OF_WEEK[read(1, true)],
+              # timezone_winter_hour: read(1, true),
+              # _timezone_winter_offset: read(4),
+              # _timezone_daylight: read(5),
+              # timezone_daylight_month: read(1, true),
+              # timezone_daylight_day: DAYS_OF_WEEK[read(1, true)],
+              # timezone_daylight_hour: read(1, true),
+              # _timezone_daylight_offset: read(4),
+              # unknown4: read(1),
+              unknown4: read,
+            )
+          end
+
+          def parse_tcp_c_thermostat_1
+            {
+              comfort_temperature: read(1, true).to_f / 2,
+              eco_temperature: read(1, true).to_f / 2,
+              max_setpoint_temperature: read(1, true).to_f / 2,
+              min_setpoint_temperature: read(1, true).to_f / 2,
+            }
+          end
+
+          def parse_tcp_c_program(subhash)
+            program = DAYS_OF_WEEK.zip([]).to_h
+            program.each_key do |day|
+              setpoints = []
+              13.times do
+                setpoint = read(2, true)
+                temperature = ((setpoint & 0xfe00) >> 9).to_f / 2
+                time_until = (setpoint & 0x01ff) * 5
+                setpoints << {
+                  temperature: temperature,
+                  hours_until: time_until / 60,
+                  minutes_until: time_until % 60,
+                }
+              end
+              program[day] = setpoints
+            end
+            subhash[:weekly_program] = program
+          end
+
+          def parse_tcp_c_radiator
+            subhash = parse_tcp_c_thermostat_1.merge!(
+              temperature_offset: read(1, true).to_f / 2 - 3.5,
+              window_open_temperature: read(1, true).to_f / 2,
+              window_open_duration: read(1, true) * 5,
+            )
+
+            boost = read(1, true)
+            boost_duration = ((boost & 0xe0) >> 5) * 5
+            boost_duration = 60 if boost_duration > 30
+
+            decalcification = read(1, true)
+
+            subhash.merge!(
+              boost_duration: boost_duration,
+              valve_opening: (boost & 0x1f) * 5,
+              decalcification_day: day_of_week((decalcification & 0xe0) >> 5),
+              decalcification_hour: decalcification & 0x1f,
+              max_valve_setting: read(1, true) * (100.0 / 255),
+              valve_offset: read(1, true) * (100.0 / 255),
+            )
+
+            parse_tcp_c_program(subhash)
+
+            subhash
+          end
+
+          def parse_tcp_c_wall
+            subhash = parse_tcp_c_thermostat_1
+            parse_tcp_c_program(subhash)
+            subhash[:unknown] = read(3)
+
+            subhash
+          end
+
+          def parse_tcp_c_device_type(hash)
+            device_type = hash[:device_type]
+            hash.merge!(
+              case device_type
+              when :cube
+                parse_tcp_c_cube
+              when :radiator_thermostat, :radiator_thermostat_plus
+                parse_tcp_c_radiator
+              when :wall_thermostat
+                parse_tcp_c_wall
+              else
+                {}
+              end
+            )
+          rescue IOError
+            device_type_str = device_type.to_s.split('_')
+                                         .map(&:capitalize).join(' ')
+            raise InvalidMessageBody
+              .new(@msg_type,
+                   'unexpected EOF reached in decoded message data of ' \
+                   "'#{device_type_str}' device type")
+          end
+        end
+      end
+
+      class Serializer
+        module MessageC
+          private
+
+          # Request for configuration message (C)
+          # Does not contain any data
+          def serialize_tcp_c(_hash)
+            ''
+          end
+        end
+      end
+    end
+  end
+end