tinkerforge 2.1.23 → 2.1.28

data/lib/tinkerforge/device_display_names.rb

@@ -0,0 +1,167 @@
+# -*- ruby encoding: utf-8 -*-
+#############################################################
+# This file was automatically generated on 2021-01-15.      #
+#                                                           #
+# Ruby Bindings Version 2.1.28                              #
+#                                                           #
+# If you have a bugfix for this file and want to commit it, #
+# please fix the bug in the generator. You can find a link  #
+# to the generators git repository on tinkerforge.com       #
+#############################################################
+
+module Tinkerforge
+  DEVICE_DISPLAY_NAMES = {
+    11 => 'DC Brick',
+    13 => 'Master Brick',
+    14 => 'Servo Brick',
+    15 => 'Stepper Brick',
+    16 => 'IMU Brick',
+    17 => 'RED Brick',
+    18 => 'IMU Brick 2.0',
+    19 => 'Silent Stepper Brick',
+    21 => 'Ambient Light Bricklet',
+    23 => 'Current12 Bricklet',
+    24 => 'Current25 Bricklet',
+    25 => 'Distance IR Bricklet',
+    26 => 'Dual Relay Bricklet',
+    27 => 'Humidity Bricklet',
+    28 => 'IO-16 Bricklet',
+    29 => 'IO-4 Bricklet',
+    111 => 'HAT Brick',
+    112 => 'HAT Zero Brick',
+    210 => 'Joystick Bricklet',
+    211 => 'LCD 16x2 Bricklet',
+    212 => 'LCD 20x4 Bricklet',
+    213 => 'Linear Poti Bricklet',
+    214 => 'Piezo Buzzer Bricklet',
+    215 => 'Rotary Poti Bricklet',
+    216 => 'Temperature Bricklet',
+    217 => 'Temperature IR Bricklet',
+    218 => 'Voltage Bricklet',
+    219 => 'Analog In Bricklet',
+    220 => 'Analog Out Bricklet',
+    221 => 'Barometer Bricklet',
+    222 => 'GPS Bricklet',
+    223 => 'Industrial Digital In 4 Bricklet',
+    224 => 'Industrial Digital Out 4 Bricklet',
+    225 => 'Industrial Quad Relay Bricklet',
+    226 => 'PTC Bricklet',
+    227 => 'Voltage/Current Bricklet',
+    228 => 'Industrial Dual 0-20mA Bricklet',
+    229 => 'Distance US Bricklet',
+    230 => 'Dual Button Bricklet',
+    231 => 'LED Strip Bricklet',
+    232 => 'Moisture Bricklet',
+    233 => 'Motion Detector Bricklet',
+    234 => 'Multi Touch Bricklet',
+    235 => 'Remote Switch Bricklet',
+    236 => 'Rotary Encoder Bricklet',
+    237 => 'Segment Display 4x7 Bricklet',
+    238 => 'Sound Intensity Bricklet',
+    239 => 'Tilt Bricklet',
+    240 => 'Hall Effect Bricklet',
+    241 => 'Line Bricklet',
+    242 => 'Piezo Speaker Bricklet',
+    243 => 'Color Bricklet',
+    244 => 'Solid State Relay Bricklet',
+    246 => 'NFC/RFID Bricklet',
+    249 => 'Industrial Dual Analog In Bricklet',
+    250 => 'Accelerometer Bricklet',
+    251 => 'Analog In Bricklet 2.0',
+    253 => 'Load Cell Bricklet',
+    254 => 'RS232 Bricklet',
+    255 => 'Laser Range Finder Bricklet',
+    256 => 'Analog Out Bricklet 2.0',
+    258 => 'Industrial Analog Out Bricklet',
+    259 => 'Ambient Light Bricklet 2.0',
+    260 => 'Dust Detector Bricklet',
+    262 => 'CO2 Bricklet',
+    263 => 'OLED 128x64 Bricklet',
+    264 => 'OLED 64x48 Bricklet',
+    265 => 'UV Light Bricklet',
+    266 => 'Thermocouple Bricklet',
+    267 => 'Motorized Linear Poti Bricklet',
+    268 => 'Real-Time Clock Bricklet',
+    270 => 'CAN Bricklet',
+    271 => 'RGB LED Bricklet',
+    272 => 'RGB LED Matrix Bricklet',
+    276 => 'GPS Bricklet 2.0',
+    277 => 'RS485 Bricklet',
+    278 => 'Thermal Imaging Bricklet',
+    279 => 'XMC1400 Breakout Bricklet',
+    282 => 'RGB LED Button Bricklet',
+    283 => 'Humidity Bricklet 2.0',
+    284 => 'Industrial Dual Relay Bricklet',
+    285 => 'DMX Bricklet',
+    286 => 'NFC Bricklet',
+    288 => 'Outdoor Weather Bricklet',
+    289 => 'Remote Switch Bricklet 2.0',
+    290 => 'Sound Pressure Level Bricklet',
+    291 => 'Temperature IR Bricklet 2.0',
+    292 => 'Motion Detector Bricklet 2.0',
+    293 => 'Industrial Counter Bricklet',
+    294 => 'Rotary Encoder Bricklet 2.0',
+    295 => 'Analog In Bricklet 3.0',
+    296 => 'Solid State Relay Bricklet 2.0',
+    297 => 'Air Quality Bricklet',
+    298 => 'LCD 128x64 Bricklet',
+    299 => 'Distance US Bricklet 2.0',
+    2100 => 'Industrial Digital In 4 Bricklet 2.0',
+    2101 => 'PTC Bricklet 2.0',
+    2102 => 'Industrial Quad Relay Bricklet 2.0',
+    2103 => 'LED Strip Bricklet 2.0',
+    2104 => 'Load Cell Bricklet 2.0',
+    2105 => 'Voltage/Current Bricklet 2.0',
+    2106 => 'Real-Time Clock Bricklet 2.0',
+    2107 => 'CAN Bricklet 2.0',
+    2108 => 'RS232 Bricklet 2.0',
+    2109 => 'Thermocouple Bricklet 2.0',
+    2110 => 'Particulate Matter Bricklet',
+    2111 => 'IO-4 Bricklet 2.0',
+    2112 => 'OLED 128x64 Bricklet 2.0',
+    2113 => 'Temperature Bricklet 2.0',
+    2114 => 'IO-16 Bricklet 2.0',
+    2115 => 'Analog Out Bricklet 3.0',
+    2116 => 'Industrial Analog Out Bricklet 2.0',
+    2117 => 'Barometer Bricklet 2.0',
+    2118 => 'UV Light Bricklet 2.0',
+    2119 => 'Dual Button Bricklet 2.0',
+    2120 => 'Industrial Dual 0-20mA Bricklet 2.0',
+    2121 => 'Industrial Dual Analog In Bricklet 2.0',
+    2122 => 'Isolator Bricklet',
+    2123 => 'One Wire Bricklet',
+    2124 => 'Industrial Digital Out 4 Bricklet 2.0',
+    2125 => 'Distance IR Bricklet 2.0',
+    2127 => 'RGB LED Bricklet 2.0',
+    2128 => 'Color Bricklet 2.0',
+    2129 => 'Multi Touch Bricklet 2.0',
+    2130 => 'Accelerometer Bricklet 2.0',
+    2131 => 'Ambient Light Bricklet 3.0',
+    2132 => 'Hall Effect Bricklet 2.0',
+    2137 => 'Segment Display 4x7 Bricklet 2.0',
+    2138 => 'Joystick Bricklet 2.0',
+    2139 => 'Linear Poti Bricklet 2.0',
+    2140 => 'Rotary Poti Bricklet 2.0',
+    2144 => 'Laser Range Finder Bricklet 2.0',
+    2145 => 'Piezo Speaker Bricklet 2.0',
+    2146 => 'E-Paper 296x128 Bricklet',
+    2147 => 'CO2 Bricklet 2.0',
+    2152 => 'Energy Monitor Bricklet',
+    2153 => 'Compass Bricklet',
+    2156 => 'Performance DC Bricklet',
+    2157 => 'Servo Bricklet 2.0',
+    2161 => 'IMU Bricklet 3.0',
+    2162 => 'Industrial Dual AC Relay Bricklet'
+  }
+
+  # internal
+  def get_device_display_name(device_identifier)
+    device_display_name = DEVICE_DISPLAY_NAMES[device_identifier]
+
+    if device_display_name == nil
+      device_display_name = "Unknown Device [#{device_identifier}]"
+    end
+
+    device_display_name
+  end
+end

data/lib/tinkerforge/ip_connection.rb

@@ -1,5 +1,5 @@
 # -*- ruby encoding: utf-8 -*-
-# Copyright (C) 2012-2014, 2019 Matthias Bolte <matthias@tinkerforge.com>
+# Copyright (C) 2012-2014, 2019-2020 Matthias Bolte <matthias@tinkerforge.com>
 #
 # Redistribution and use in source and binary forms of this file,
 # with or without modification, are permitted. See the Creative
@@ -10,8 +10,10 @@ require 'thread'
 require 'timeout'
 require 'securerandom'
 require 'openssl'
+require_relative './device_display_names'
 
 module Tinkerforge
+  # internal
   class Base58
     ALPHABET = '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
 
@@ -64,6 +66,16 @@ module Tinkerforge
   class StreamOutOfSyncException < TinkerforgeException
   end
 
+  class WrongDeviceTypeException < TinkerforgeException
+  end
+
+  class DeviceReplacedException < TinkerforgeException
+  end
+
+  class WrongResponseLengthException < TinkerforgeException
+  end
+
+  # internal
   class Packer
     def self.pack(unpacked, format)
       data = ''
@@ -131,7 +143,8 @@ module Tinkerforge
           u = []
 
           if f0 == '?'
-            r = data.unpack "C#{f1}a*"
+            n1 = (Integer(f1) / 8.0).ceil()
+            r = data.unpack "C#{n1}a*"
             data = r[-1]
             r.delete_at(-1)
 
@@ -207,12 +220,18 @@ module Tinkerforge
     end
   end
 
+  # internal
   class Device
+    DEVICE_IDENTIFIER_CHECK_PENDING = 0
+    DEVICE_IDENTIFIER_CHECK_MATCH = 1
+    DEVICE_IDENTIFIER_CHECK_MISMATCH = 2
+
     RESPONSE_EXPECTED_INVALID_FUNCTION_ID = 0
     RESPONSE_EXPECTED_ALWAYS_TRUE = 1 # getter
     RESPONSE_EXPECTED_TRUE = 2 # setter
     RESPONSE_EXPECTED_FALSE = 3 # setter, default
 
+    attr_accessor :replaced
     attr_accessor :uid
     attr_accessor :expected_response_function_id
     attr_accessor :expected_response_sequence_number
@@ -220,10 +239,11 @@ module Tinkerforge
     attr_accessor :high_level_callbacks
     attr_accessor :registered_callbacks
 
-    # Creates the device object with the unique device ID <tt>uid</tt> and adds
-    # it to the IPConnection <tt>ipcon</tt>.
-    def initialize(uid, ipcon)
+    # internal
+    def initialize(uid, ipcon, device_identifier, device_display_name)
+      @replaced = false
       @uid = Base58.decode uid
+      @uid_string = uid
 
       if @uid > (1 << 64) - 1
         raise ArgumentError, "UID '#{uid}' is too big"
@@ -249,6 +269,12 @@ module Tinkerforge
 
       @ipcon = ipcon
 
+      @device_identifier = device_identifier
+      @device_display_name = device_display_name
+      @device_identifier_lock = Mutex.new
+      @device_identifier_check = DEVICE_IDENTIFIER_CHECK_PENDING # protected by device_identifier_lock
+      @wrong_device_display_name = '?' # protected by device_identifier_lock
+
       @request_mutex = Mutex.new
 
       @response_expected = Array.new(256, RESPONSE_EXPECTED_INVALID_FUNCTION_ID)
@@ -265,8 +291,6 @@ module Tinkerforge
       @callback_formats = {}
       @high_level_callbacks = {}
       @registered_callbacks = {}
-
-      @ipcon.devices[@uid] = self # FIXME: use a weakref here
     end
 
     # Returns the API version (major, minor, revision) of the bindings for
@@ -288,7 +312,7 @@ module Tinkerforge
     # Enabling the response expected flag for a setter function allows to
     # detect timeouts and other error conditions calls of this setter as
     # well. The device will then send a response for this purpose. If this
-    # flag is disabled for a setter function then no response is send and
+    # flag is disabled for a setter function then no response is sent and
     # errors are silently ignored, because they cannot be detected.
     def get_response_expected(function_id)
       if function_id < 0 or function_id > 255
@@ -317,7 +341,7 @@ module Tinkerforge
     # Enabling the response expected flag for a setter function allows to
     # detect timeouts and other error conditions calls of this setter as
     # well. The device will then send a response for this purpose. If this
-    # flag is disabled for a setter function then no response is send and
+    # flag is disabled for a setter function then no response is sent and
     # errors are silently ignored, because they cannot be detected.
     def set_response_expected(function_id, response_expected)
       if function_id < 0 or function_id > 255
@@ -360,7 +384,7 @@ module Tinkerforge
 
     # internal
     def send_request(function_id, request_data, request_format,
-                     response_length, response_format)
+                     expected_response_length, response_format)
       response = nil
 
       if request_data.length > 0
@@ -402,7 +426,13 @@ module Tinkerforge
         error_code = Packer.get_error_code_from_data packet
 
         if error_code == 0
-          # no error
+          if expected_response_length == 0
+            expected_response_length = 8 # setter with response-expected enabled
+          end
+
+          if packet.length != expected_response_length
+            raise WrongResponseLengthException, "Expected response of #{expected_response_length} byte for function ID #{function_id}, got #{packet.length} byte instead"
+          end
         elsif error_code == 1
           raise InvalidParameterException, "Got invalid parameter for function ID #{function_id}"
         elsif error_code == 2
@@ -411,7 +441,7 @@ module Tinkerforge
           raise UnknownErrorCodeException, "Function ID #{function_id} returned an unknown error"
         end
 
-        if response_length > 0
+        if response_format.length > 0
           response = Packer.unpack packet[8..-1], response_format
 
           if response.length == 1
@@ -449,6 +479,34 @@ module Tinkerforge
 
       response
     end
+
+    # internal
+    def check_validity()
+      if @replaced
+        raise DeviceReplacedException, 'Device has been replaced'
+      end
+
+      if @device_identifier_check == DEVICE_IDENTIFIER_CHECK_MATCH
+        return
+      end
+
+      @device_identifier_lock.synchronize {
+        if @device_identifier_check == DEVICE_IDENTIFIER_CHECK_PENDING
+          device_identifier = send_request(255, [], '', 33, 'Z8 Z8 k C3 C3 S')[5] # <device>.get_identity
+
+          if device_identifier == @device_identifier
+            @device_identifier_check = DEVICE_IDENTIFIER_CHECK_MATCH
+          else
+            @device_identifier_check = DEVICE_IDENTIFIER_CHECK_MISMATCH
+            @wrong_device_display_name = get_device_display_name device_identifier
+          end
+        end
+
+        if @device_identifier_check == DEVICE_IDENTIFIER_CHECK_MISMATCH
+          raise WrongDeviceTypeException, "UID #{@uid_string} belongs to a #{@wrong_device_display_name} instead of the expected #{@device_display_name}"
+        end
+      }
+    end
   end
 
   # internal
@@ -474,16 +532,18 @@ module Tinkerforge
     # Creates an object with the unique device ID <tt>uid</tt> and adds it to
     # the IP Connection <tt>ipcon</tt>.
     def initialize(uid, ipcon)
-      super uid, ipcon
+      super uid, ipcon, 0, 'Brick Daemon'
 
       @api_version = [2, 0, 0]
 
       @response_expected[FUNCTION_GET_AUTHENTICATION_NONCE] = RESPONSE_EXPECTED_ALWAYS_TRUE
       @response_expected[FUNCTION_AUTHENTICATE] = RESPONSE_EXPECTED_TRUE
+
+      @ipcon.add_device self
     end
 
     def get_authentication_nonce
-      send_request FUNCTION_GET_AUTHENTICATION_NONCE, [], '', 4, 'C4'
+      send_request FUNCTION_GET_AUTHENTICATION_NONCE, [], '', 12, 'C4'
     end
 
     def authenticate(client_nonce, digest)
@@ -492,7 +552,6 @@ module Tinkerforge
   end
 
   class IPConnection
-    attr_accessor :devices
     attr_accessor :timeout
 
     CALLBACK_ENUMERATE = 253
@@ -538,6 +597,7 @@ module Tinkerforge
       @authentication_mutex = Mutex.new # protects authentication handshake
 
       @devices = {}
+      @replace_mutex = Mutex.new # used to synchronize replacements in the devices dict
 
       @registered_callbacks = {}
 
@@ -628,6 +688,9 @@ module Tinkerforge
     # For more information about authentication see
     # https://www.tinkerforge.com/en/doc/Tutorials/Tutorial_Authentication/Tutorial.html
     def authenticate(secret)
+      if not secret.ascii_only?
+        raise ArgumentError, "Authentication secret contains non-ASCII characters"
+      end
       @authentication_mutex.synchronize {
         if @next_authentication_nonce == 0
           @next_authentication_nonce = SecureRandom.random_number(1 << 32)
@@ -728,6 +791,19 @@ module Tinkerforge
       @registered_callbacks[id] = callback
     end
 
+    # internal
+    def add_device(device)
+      @replace_mutex.synchronize {
+        replaced_device = @devices.fetch device.uid, nil
+
+        if replaced_device != nil
+          replaced_device.replaced = true
+        end
+
+        @devices[device.uid] = device # FIXME: use a weakref here
+      }
+    end
+
     # internal
     def get_next_sequence_number
       @sequence_number_mutex.synchronize {
@@ -948,8 +1024,10 @@ module Tinkerforge
     # internal
     def dispatch_meta(function_id, parameter, socket_id)
       if function_id == CALLBACK_CONNECTED
-        if @registered_callbacks.has_key? CALLBACK_CONNECTED
-          @registered_callbacks[CALLBACK_CONNECTED].call parameter
+        cb = @registered_callbacks[CALLBACK_CONNECTED]
+
+        if cb != nil
+          cb.call parameter
         end
       elsif function_id == CALLBACK_DISCONNECTED
         if parameter != DISCONNECT_REASON_REQUEST
@@ -977,8 +1055,10 @@ module Tinkerforge
         # socket. the first receive will then fail directly
         sleep 0.1
 
-        if @registered_callbacks.has_key? CALLBACK_DISCONNECTED
-          @registered_callbacks[CALLBACK_DISCONNECTED].call parameter
+        cb = @registered_callbacks[CALLBACK_DISCONNECTED]
+
+        if cb != nil
+          cb.call parameter
         end
 
         if parameter != DISCONNECT_REASON_REQUEST and @auto_reconnect and @auto_reconnect_allowed
@@ -1015,16 +1095,41 @@ module Tinkerforge
       uid = Packer.get_uid_from_data packet
       function_id = Packer.get_function_id_from_data packet
 
-      if function_id == CALLBACK_ENUMERATE and \
-         @registered_callbacks.has_key? CALLBACK_ENUMERATE
+      if function_id == CALLBACK_ENUMERATE
+        cb = @registered_callbacks[CALLBACK_ENUMERATE]
+
+        if cb == nil
+          return
+        end
+
+        if packet.length != 34
+          return # silently ignoring callback with wrong length
+        end
+
         payload = Packer.unpack packet[8..-1], 'Z8 Z8 k C3 C3 S C'
-        @registered_callbacks[CALLBACK_ENUMERATE].call(*payload)
-      elsif @devices.has_key? uid
-        device = @devices[uid]
+
+        cb.call(*payload)
+        return
+      end
+
+      device = @devices[uid]
+
+      if device != nil
+        begin
+          device.check_validity
+        rescue TinkerforgeException
+          return # silently ignoring callback for invalid device
+        end
 
         if device.high_level_callbacks.has_key?(-function_id)
           hlcb = device.high_level_callbacks[-function_id] # [roles, options, data]
-          payload = Packer.unpack packet[8..-1], device.callback_formats[function_id]
+          format = device.callback_formats[function_id] # FIXME: currently assuming that low-level callback has more than one element
+
+          if packet.length != format[0]
+            return # silently ignoring callback with wrong length
+          end
+
+          payload = Packer.unpack packet[8..-1], format[1]
           has_data = false
           data = nil
 
@@ -1068,7 +1173,9 @@ module Tinkerforge
               end
             end
 
-            if has_data and device.registered_callbacks.has_key?(-function_id)
+            cb = device.registered_callbacks[-function_id]
+
+            if has_data and cb != nil
               result = []
 
               hlcb[0].zip(payload).each do |role, value|
@@ -1079,14 +1186,27 @@ module Tinkerforge
                 end
               end
 
-              device.registered_callbacks[-function_id].call(*result)
+              cb.call(*result)
             end
           end
         end
 
-        if device.registered_callbacks.has_key? function_id
-          payload = Packer.unpack packet[8..-1], device.callback_formats[function_id]
-          device.registered_callbacks[function_id].call(*payload)
+        cb = device.registered_callbacks[function_id]
+
+        if cb != nil
+          format = device.callback_formats[function_id]
+
+          if format == nil
+            return # silently ignore registered but unknown callback
+          end
+
+          if packet.length != format[0]
+            return # silently ignoring callback with wrong length
+          end
+
+          payload = Packer.unpack packet[8..-1], format[1]
+
+          cb.call(*payload)
         end
       end
     end
@@ -1169,7 +1289,6 @@ module Tinkerforge
     def handle_response(packet)
       @disconnect_probe_flag = false
 
-      uid = Packer.get_uid_from_data packet
       function_id = Packer.get_function_id_from_data packet
       sequence_number = Packer.get_sequence_number_from_data packet
 
@@ -1177,9 +1296,13 @@ module Tinkerforge
         if @registered_callbacks.has_key? CALLBACK_ENUMERATE
           @callback.queue.push [QUEUE_KIND_PACKET, packet]
         end
-      elsif @devices.has_key? uid
-        device = @devices[uid]
+        return
+      end
+
+      uid = Packer.get_uid_from_data packet
+      device = @devices[uid]
 
+      if device != nil
         if sequence_number == 0
           if device.registered_callbacks.has_key? function_id or \
              device.high_level_callbacks.has_key?(-function_id)