maxcube-client 0.4.0

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

@@ -0,0 +1,33 @@
+
+module MaxCube
+  module Messages
+    module TCP
+      class Parser
+        module MessageF
+          private
+
+          KEYS = %i[ntp_servers].freeze
+
+          # NTP server message
+          def parse_tcp_f(body)
+            { ntp_servers: body.split(',') }
+          end
+        end
+      end
+
+      class Serializer
+        module MessageF
+          private
+
+          OPT_KEYS = %i[ntp_servers].freeze
+
+          # Request for NTP servers message (F)
+          # Optionally, updates can be done
+          def serialize_tcp_f(hash)
+            hash.key?(:ntp_servers) ? hash[:ntp_servers].join(',') : ''
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+
+module MaxCube
+  module Messages
+    module TCP
+      class Parser
+        module MessageH
+          private
+
+          LENGTHS = [10, 6, 4, 8, 8, 2, 2, 6, 4, 2, 4].freeze
+
+          KEYS = %i[
+            serial_number
+            rf_address
+            firmware_version
+            unknown
+            http_id
+            duty_cycle
+            free_memory_slots
+            cube_datetime
+            state_cube_time
+            ntp_counter
+          ].freeze
+
+          # Hello message
+          def parse_tcp_h(body)
+            values = body.split(',')
+            check_msg_part_lengths(LENGTHS, *values)
+            values[1], _, values[4], values[5], values[6], _, _,
+              values[9], values[10] =
+              to_ints(16, 'RF address, ' \
+                          'firmware version, ' \
+                          'HTTP connection ID, ' \
+                          'duty cycle, ' \
+                          'free memory slots, ' \
+                          'Cube date, ' \
+                          'Cube time, ' \
+                          'state Cube time (clock set), ' \
+                          'NTP counter',
+                      values[1], values[2], values[4], values[5], values[6],
+                      values[7], values[8], values[9], values[10])
+
+            parse_tcp_h_cube_datetime(values)
+
+            KEYS.zip(values).to_h
+          end
+
+          ########################
+
+          def parse_tcp_h_cube_datetime(values)
+            date, time = values[7..8]
+            year = 2000 + date[0..1].to_i(16)
+
+            month = date[2..3].to_i(16)
+            day = date[4..5].to_i(16)
+            hours = time[0..1].to_i(16)
+            minutes = time[2..3].to_i(16)
+
+            values[7] = DateTime.new(year, month, day, hours, minutes)
+            values.delete_at(8)
+          rescue ArgumentError
+            raise InvalidMessageBody
+              .new(@msg_type, 'invalid datetime format (YYMMDD HHMM): ' \
+                              "#{date} #{time} " \
+                              "-> #{year}-#{month}-#{day} #{hours}:#{minutes}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+
+module MaxCube
+  module Messages
+    module TCP
+      class Parser
+        module MessageL
+          private
+
+          LENGTHS = [6, 11, 12].freeze
+
+          KEYS = %i[devices].freeze
+
+          # Device list message
+          def parse_tcp_l(body)
+            @io = StringIO.new(decode(body), 'rb')
+
+            hash = { devices: [] }
+            until @io.eof?
+              subhash = parse_tcp_l_submsg_1
+
+              temperature_msb = parse_tcp_l_submsg_2(subhash) if @length > 6
+              parse_tcp_l_submsg_3(subhash, temperature_msb) if @length > 11
+
+              hash[:devices] << subhash
+            end # until
+
+            hash
+          end
+
+          ########################
+
+          def parse_tcp_l_submsg_1
+            @length = read(1, true)
+            unless LENGTHS.include?(@length)
+              raise InvalidMessageBody
+                .new(@msg_type, "invalid length of submessage (#{@length}):" \
+                                " should be in #{LENGTHS}")
+            end
+            subhash = {
+              length: @length,
+              rf_address: read(3, true),
+              unknown: read(1),
+            }
+            flags = read(2, true)
+            @mode = device_mode(flags & 0x3)
+            subhash[:flags] = {
+              value: flags,
+              mode: @mode,
+              dst_setting_active: !((flags & 0x8) >> 3).zero?,
+              gateway_known: !((flags & 0x10) >> 4).zero?,
+              panel_locked: !((flags & 0x20) >> 5).zero?,
+              link_error: !((flags & 0x40) >> 6).zero?,
+              low_battery: !((flags & 0x80) >> 7).zero?,
+              status_initialized: !((flags & 0x200) >> 9).zero?,
+              is_answer: !((flags & 0x400) >> 10).zero?,
+              error: !((flags & 0x800) >> 11).zero?,
+              valid_info: !((flags & 0x1000) >> 12).zero?,
+            }
+
+            subhash
+          rescue IOError
+            raise InvalidMessageBody
+              .new(@msg_type, 'unexpected EOF reached at submessage 1st part')
+          end
+
+          def parse_tcp_l_submsg_2(subhash)
+            subhash[:valve_opening] = read(1, true)
+
+            temperature = read(1, true)
+            # This bit may be used later
+            temperature_msb = temperature >> 7
+            subhash[:temperature] = (temperature & 0x3f).to_f / 2
+
+            date_until = read(2, true)
+            year = (date_until & 0x1f) + 2000
+            month = ((date_until & 0x80) >> 7) | ((date_until & 0xe000) >> 12)
+            day = (date_until & 0x1f00) >> 8
+
+            time_until = read(1, true)
+            hours = time_until / 2
+            minutes = (time_until % 2) * 30
+            # Sometimes when device is in 'auto' mode,
+            # this field can contain 'actual_temperature' instead
+            # (but never if it is already contained in next byte)
+            # !It seems that 'datetime' is used for 'vacation' mode,
+            # but it is not sure ...
+            begin
+              subhash[:datetime_until] = DateTime.new(year, month, day,
+                                                      hours, minutes)
+            rescue ArgumentError
+              if @mode != :auto || @length > 11
+                raise InvalidMessageBody
+                  .new(@msg_type, "unrecognized message part: #{date_until}" \
+                                 " (it does not seem to be 'date until'" \
+                                 " nor 'actual temperature')")
+              end
+              subhash[:actual_temperature] = date_until.to_f / 10
+            end
+
+            temperature_msb
+          rescue IOError
+            raise InvalidMessageBody
+              .new(@msg_type,
+                   'unexpected EOF reached at submessage 2nd part')
+          end
+
+          def parse_tcp_l_submsg_3(subhash, temperature_msb)
+            subhash[:actual_temperature] = ((temperature_msb << 8) |
+                                            read(1, true)).to_f / 10
+          rescue IOError
+            raise InvalidMessageBody
+              .new(@msg_type,
+                   'unexpected EOF reached at submessage 3rd part')
+          end
+        end
+      end
+
+      class Serializer
+        module MessageL
+          private
+
+          # Command to resend device list (L)
+          # Does not contain any data
+          def serialize_tcp_l(_hash)
+            ''
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,185 @@
+
+module MaxCube
+  module Messages
+    module TCP
+      class Parser
+        module MessageM
+          private
+
+          LENGTHS = [2, 2].freeze
+
+          KEYS = %i[index count unknown1 unknown2
+                    rooms_count rooms devices_count devices].freeze
+
+          # Metadata message
+          def parse_tcp_m(body)
+            index, count, enc_data = parse_tcp_m_split(body)
+
+            @io = StringIO.new(decode(enc_data), 'rb')
+
+            hash = { index: index, count: count, unknown1: read(2), }
+            parse_tcp_m_rooms(hash)
+            parse_tcp_m_devices(hash)
+            hash[:unknown2] = read(1)
+
+            hash
+          rescue IOError
+            raise InvalidMessageBody
+              .new(@msg_type,
+                   'unexpected EOF reached at unknown parts' \
+                   ' of decoded message data')
+          end
+
+          ########################
+
+          def parse_tcp_m_split(body)
+            index, count, enc_data = body.split(',')
+            check_msg_part_lengths(LENGTHS, index, count)
+            index, count = to_ints(16, 'message index, count',
+                                   index, count)
+            unless index < count
+              raise InvalidMessageBody
+                .new(@msg_type,
+                     "index >= count: #{index} >= #{count}")
+            end
+
+            unless enc_data
+              raise InvalidMessageBody
+                .new(@msg_type, 'message data is missing')
+            end
+
+            [index, count, enc_data]
+          end
+
+          def parse_tcp_m_rooms(hash)
+            rooms_count = read(1, true)
+            hash[:rooms_count] = rooms_count
+            hash[:rooms] = []
+            rooms_count.times do
+              room_id = read(1, true)
+              room_name_length = read(1, true)
+              room = {
+                id: room_id,
+                name_length: room_name_length,
+                name: read(room_name_length),
+                rf_address: read(3, true)
+              }
+
+              # hash[:rooms][room_id] = room
+              hash[:rooms] << room
+            end
+          rescue IOError
+            raise InvalidMessageBody
+              .new(@msg_type,
+                   'unexpected EOF reached at rooms data part' \
+                   ' of decoded message data')
+          end
+
+          def parse_tcp_m_devices(hash)
+            devices_count = read(1, true)
+            hash[:devices_count] = devices_count
+            hash[:devices] = []
+            devices_count.times do
+              device = {
+                type: device_type(read(1, true)),
+                rf_address: read(3, true),
+                serial_number: read(10),
+              }
+              device_name_length = read(1, true)
+              device.merge!(
+                name_length: device_name_length,
+                name: read(device_name_length),
+                room_id: read(1, true),
+              )
+
+              hash[:devices] << device
+            end
+          rescue IOError
+            raise InvalidMessageBody
+              .new(@msg_type,
+                   'unexpected EOF reached at devices data part' \
+                   ' of decoded message data')
+          end
+        end
+      end
+
+      class Serializer
+        module MessageM
+          private
+
+          KEYS = %i[rooms_count rooms devices_count devices].freeze
+          OPT_KEYS = %i[index unknown1 unknown2].freeze
+
+          # Serialize metadata for Cube
+          # Message body has the same format as response (M)
+          # -> reverse operations
+          # ! I couldn't verify the assumption that bodies should be the same
+          # ! Cube does not check data format,
+          #   so things could break if invalid data is sent
+          def serialize_tcp_m(hash)
+            index = hash.key?(:index) ? to_int(0, 'index', hash[:index]) : 0
+            head = format('%02x,', index)
+
+            @io = StringIO.new('', 'wb')
+            write(hash.key?(:unknown1) ? hash[:unknown1] : "\x00\x00")
+
+            serialize_tcp_m_rooms(hash)
+            serialize_tcp_m_devices(hash)
+            write(hash.key?(:unknown2) ? hash[:unknown2] : "\x00")
+
+            head.b << encode(@io.string)
+          end
+
+          ########################
+
+          def serialize_tcp_m_rooms(hash)
+            write(to_int(0, 'rooms count', hash[:rooms_count]), esize: 1)
+            hash[:rooms].each do |room|
+              name = room[:name]
+              if room.key?(:name_length)
+                name_length = to_int(0, 'name length', room[:name_length])
+                unless name_length == name.length
+                  raise InvalidMessageBody
+                    .new(@msg_type, 'room name length and length of name' \
+                         " mismatch: #{name_length} != #{name.length}")
+                end
+              else
+                name_length = name.length
+              end
+
+              id, rf_address = to_ints(0, 'room id, RF address',
+                                       room[:id], room[:rf_address])
+              write(serialize(id, name_length, name, esize: 1) <<
+                    serialize(rf_address, esize: 3))
+            end
+          end
+
+          def serialize_tcp_m_devices(hash)
+            write(to_int(0, 'devices count', hash[:devices_count]), esize: 1)
+            hash[:devices].each do |device|
+              name = device[:name]
+              if device.key?(:name_length)
+                name_length = to_int(0, 'name length', device[:name_length])
+                unless name_length == name.length
+                  raise InvalidMessageBody
+                    .new(@msg_type, 'device name length and length of name' \
+                         " mismatch: #{name_length} != #{name.length}")
+                end
+              else
+                name_length = name.length
+              end
+
+              rf_address, room_id =
+                to_ints(0, 'device RF address, room ID',
+                        device[:rf_address], device[:room_id])
+              write(serialize(device_type_id(device[:type]), esize: 1) <<
+                    serialize(rf_address, esize: 3) <<
+                    serialize(device[:serial_number],
+                              name_length, name, room_id, esize: 1))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+
+module MaxCube
+  module Messages
+    module TCP
+      class Parser
+        module MessageN
+          private
+
+          KEYS = %i[device_type rf_address serial_number unknown].freeze
+
+          # New device (pairing) message
+          def parse_tcp_n(body)
+            @io = StringIO.new(decode(body), 'rb')
+
+            {
+              device_type: device_type(read(1, true)),
+              rf_address: read(3, true),
+              serial_number: read(10),
+              unknown: read(1),
+            }
+          rescue IOError
+            raise InvalidMessageBody
+              .new(@msg_type, 'unexpected EOF reached')
+          end
+        end
+      end
+
+      class Serializer
+        module MessageN
+          private
+
+          OPT_KEYS = %i[timeout].freeze
+
+          # Command to set the Cube into pairing mode
+          # with optional +timeout+ in seconds
+          def serialize_tcp_n(hash)
+            return '' unless hash.key?(:timeout)
+            format('%04x', to_int(0, 'timeout', hash[:timeout]))
+          end
+        end
+      end
+    end
+  end
+end