tinkerforge 2.1.24 → 2.1.29

data/lib/tinkerforge/brick_servo.rb

@@ -1,14 +1,16 @@
 # -*- ruby encoding: utf-8 -*-
 #############################################################
-# This file was automatically generated on 2019-11-25.      #
+# This file was automatically generated on 2021-05-06.      #
 #                                                           #
-# Ruby Bindings Version 2.1.24                              #
+# Ruby Bindings Version 2.1.29                              #
 #                                                           #
 # 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       #
 #############################################################
 
+require_relative './ip_connection'
+
 module Tinkerforge
   # Drives up to 7 RC Servos with up to 3A
   class BrickServo < Device
@@ -16,8 +18,7 @@ module Tinkerforge
     DEVICE_DISPLAY_NAME = 'Servo Brick' # :nodoc:
 
     # This callback is triggered when the input voltage drops below the value set by
-    # BrickServo#set_minimum_voltage. The parameter is the current voltage given
-    # in mV.
+    # BrickServo#set_minimum_voltage. The parameter is the current voltage.
     CALLBACK_UNDER_VOLTAGE = 26
 
     # This callback is triggered when a position set by BrickServo#set_position
@@ -89,6 +90,8 @@ module Tinkerforge
     FUNCTION_GET_PROTOCOL1_BRICKLET_NAME = 241 # :nodoc:
     FUNCTION_GET_CHIP_TEMPERATURE = 242 # :nodoc:
     FUNCTION_RESET = 243 # :nodoc:
+    FUNCTION_WRITE_BRICKLET_PLUGIN = 246 # :nodoc:
+    FUNCTION_READ_BRICKLET_PLUGIN = 247 # :nodoc:
     FUNCTION_GET_IDENTITY = 255 # :nodoc:
 
     COMMUNICATION_METHOD_NONE = 0 # :nodoc:
@@ -103,7 +106,7 @@ 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, DEVICE_IDENTIFIER, DEVICE_DISPLAY_NAME
 
       @api_version = [2, 0, 4]
 
@@ -150,32 +153,41 @@ module Tinkerforge
       @response_expected[FUNCTION_GET_PROTOCOL1_BRICKLET_NAME] = RESPONSE_EXPECTED_ALWAYS_TRUE
       @response_expected[FUNCTION_GET_CHIP_TEMPERATURE] = RESPONSE_EXPECTED_ALWAYS_TRUE
       @response_expected[FUNCTION_RESET] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_WRITE_BRICKLET_PLUGIN] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_READ_BRICKLET_PLUGIN] = RESPONSE_EXPECTED_ALWAYS_TRUE
       @response_expected[FUNCTION_GET_IDENTITY] = RESPONSE_EXPECTED_ALWAYS_TRUE
 
-      @callback_formats[CALLBACK_UNDER_VOLTAGE] = 'S'
-      @callback_formats[CALLBACK_POSITION_REACHED] = 'C s'
-      @callback_formats[CALLBACK_VELOCITY_REACHED] = 'C s'
+      @callback_formats[CALLBACK_UNDER_VOLTAGE] = [10, 'S']
+      @callback_formats[CALLBACK_POSITION_REACHED] = [11, 'C s']
+      @callback_formats[CALLBACK_VELOCITY_REACHED] = [11, 'C s']
 
+      @ipcon.add_device self
     end
 
     # Enables a servo (0 to 6). If a servo is enabled, the configured position,
     # velocity, acceleration, etc. are applied immediately.
     def enable(servo_num)
-      send_request FUNCTION_ENABLE, [servo_num], 'C', 0, ''
+      check_validity
+
+      send_request FUNCTION_ENABLE, [servo_num], 'C', 8, ''
     end
 
     # Disables a servo (0 to 6). Disabled servos are not driven at all, i.e. a
     # disabled servo will not hold its position if a load is applied.
     def disable(servo_num)
-      send_request FUNCTION_DISABLE, [servo_num], 'C', 0, ''
+      check_validity
+
+      send_request FUNCTION_DISABLE, [servo_num], 'C', 8, ''
     end
 
     # Returns *true* if the specified servo is enabled, *false* otherwise.
     def is_enabled(servo_num)
-      send_request FUNCTION_IS_ENABLED, [servo_num], 'C', 1, '?'
+      check_validity
+
+      send_request FUNCTION_IS_ENABLED, [servo_num], 'C', 9, '?'
     end
 
-    # Sets the position in °/100 for the specified servo.
+    # Sets the position for the specified servo.
     # 
     # The default range of the position is -9000 to 9000, but it can be specified
     # according to your servo with BrickServo#set_degree.
@@ -184,80 +196,92 @@ module Tinkerforge
     # similar with the Servo Brick, you can also define lengths or speeds with
     # BrickServo#set_degree.
     def set_position(servo_num, position)
-      send_request FUNCTION_SET_POSITION, [servo_num, position], 'C s', 0, ''
+      check_validity
+
+      send_request FUNCTION_SET_POSITION, [servo_num, position], 'C s', 8, ''
     end
 
     # Returns the position of the specified servo as set by BrickServo#set_position.
     def get_position(servo_num)
-      send_request FUNCTION_GET_POSITION, [servo_num], 'C', 2, 's'
+      check_validity
+
+      send_request FUNCTION_GET_POSITION, [servo_num], 'C', 10, 's'
     end
 
     # Returns the *current* position of the specified servo. This may not be the
     # value of BrickServo#set_position if the servo is currently approaching a
     # position goal.
     def get_current_position(servo_num)
-      send_request FUNCTION_GET_CURRENT_POSITION, [servo_num], 'C', 2, 's'
+      check_validity
+
+      send_request FUNCTION_GET_CURRENT_POSITION, [servo_num], 'C', 10, 's'
     end
 
-    # Sets the maximum velocity of the specified servo in °/100s. The velocity
+    # Sets the maximum velocity of the specified servo. The velocity
     # is accelerated according to the value set by BrickServo#set_acceleration.
     # 
     # The minimum velocity is 0 (no movement) and the maximum velocity is 65535.
     # With a value of 65535 the position will be set immediately (no velocity).
-    # 
-    # The default value is 65535.
     def set_velocity(servo_num, velocity)
-      send_request FUNCTION_SET_VELOCITY, [servo_num, velocity], 'C S', 0, ''
+      check_validity
+
+      send_request FUNCTION_SET_VELOCITY, [servo_num, velocity], 'C S', 8, ''
     end
 
     # Returns the velocity of the specified servo as set by BrickServo#set_velocity.
     def get_velocity(servo_num)
-      send_request FUNCTION_GET_VELOCITY, [servo_num], 'C', 2, 'S'
+      check_validity
+
+      send_request FUNCTION_GET_VELOCITY, [servo_num], 'C', 10, 'S'
     end
 
     # Returns the *current* velocity of the specified servo. This may not be the
     # value of BrickServo#set_velocity if the servo is currently approaching a
     # velocity goal.
     def get_current_velocity(servo_num)
-      send_request FUNCTION_GET_CURRENT_VELOCITY, [servo_num], 'C', 2, 'S'
+      check_validity
+
+      send_request FUNCTION_GET_CURRENT_VELOCITY, [servo_num], 'C', 10, 'S'
     end
 
-    # Sets the acceleration of the specified servo in °/100s².
+    # Sets the acceleration of the specified servo.
     # 
     # The minimum acceleration is 1 and the maximum acceleration is 65535.
     # With a value of 65535 the velocity will be set immediately (no acceleration).
-    # 
-    # The default value is 65535.
     def set_acceleration(servo_num, acceleration)
-      send_request FUNCTION_SET_ACCELERATION, [servo_num, acceleration], 'C S', 0, ''
+      check_validity
+
+      send_request FUNCTION_SET_ACCELERATION, [servo_num, acceleration], 'C S', 8, ''
     end
 
     # Returns the acceleration for the specified servo as set by
     # BrickServo#set_acceleration.
     def get_acceleration(servo_num)
-      send_request FUNCTION_GET_ACCELERATION, [servo_num], 'C', 2, 'S'
+      check_validity
+
+      send_request FUNCTION_GET_ACCELERATION, [servo_num], 'C', 10, 'S'
     end
 
-    # Sets the output voltages with which the servos are driven in mV.
-    # The minimum output voltage is 2000mV and the maximum output voltage is
-    # 9000mV.
+    # Sets the output voltages with which the servos are driven.
     # 
     # .. note::
     #  We recommend that you set this value to the maximum voltage that is
     #  specified for your servo, most servos achieve their maximum force only
     #  with high voltages.
-    # 
-    # The default value is 5000.
     def set_output_voltage(voltage)
-      send_request FUNCTION_SET_OUTPUT_VOLTAGE, [voltage], 'S', 0, ''
+      check_validity
+
+      send_request FUNCTION_SET_OUTPUT_VOLTAGE, [voltage], 'S', 8, ''
     end
 
     # Returns the output voltage as specified by BrickServo#set_output_voltage.
     def get_output_voltage
-      send_request FUNCTION_GET_OUTPUT_VOLTAGE, [], '', 2, 'S'
+      check_validity
+
+      send_request FUNCTION_GET_OUTPUT_VOLTAGE, [], '', 10, 'S'
     end
 
-    # Sets the minimum and maximum pulse width of the specified servo in µs.
+    # Sets the minimum and maximum pulse width of the specified servo.
     # 
     # Usually, servos are controlled with a
     # `PWM <https://en.wikipedia.org/wiki/Pulse-width_modulation>`__, whereby the
@@ -269,19 +293,19 @@ module Tinkerforge
     # maximum pulse width, you should set the values accordingly. If your servo
     # comes without any datasheet you have to find the values via trial and error.
     # 
-    # Both values have a range from 1 to 65535 (unsigned 16-bit integer). The
-    # minimum must be smaller than the maximum.
-    # 
-    # The default values are 1000µs (1ms) and 2000µs (2ms) for minimum and
-    # maximum pulse width.
+    # The minimum must be smaller than the maximum.
     def set_pulse_width(servo_num, min, max)
-      send_request FUNCTION_SET_PULSE_WIDTH, [servo_num, min, max], 'C S S', 0, ''
+      check_validity
+
+      send_request FUNCTION_SET_PULSE_WIDTH, [servo_num, min, max], 'C S S', 8, ''
     end
 
     # Returns the minimum and maximum pulse width for the specified servo as set by
     # BrickServo#set_pulse_width.
     def get_pulse_width(servo_num)
-      send_request FUNCTION_GET_PULSE_WIDTH, [servo_num], 'C', 4, 'S S'
+      check_validity
+
+      send_request FUNCTION_GET_PULSE_WIDTH, [servo_num], 'C', 12, 'S S'
     end
 
     # Sets the minimum and maximum degree for the specified servo (by default
@@ -310,21 +334,22 @@ module Tinkerforge
     #   control it with a RC brushless motor controller. In this case you can set the
     #   minimum to 0 and the maximum to 10000. BrickServo#set_position now controls the rpm.
     # 
-    # Both values have a possible range from -32767 to 32767
-    # (signed 16-bit integer). The minimum must be smaller than the maximum.
-    # 
-    # The default values are -9000 and 9000 for the minimum and maximum degree.
+    # The minimum must be smaller than the maximum.
     def set_degree(servo_num, min, max)
-      send_request FUNCTION_SET_DEGREE, [servo_num, min, max], 'C s s', 0, ''
+      check_validity
+
+      send_request FUNCTION_SET_DEGREE, [servo_num, min, max], 'C s s', 8, ''
     end
 
     # Returns the minimum and maximum degree for the specified servo as set by
     # BrickServo#set_degree.
     def get_degree(servo_num)
-      send_request FUNCTION_GET_DEGREE, [servo_num], 'C', 4, 's s'
+      check_validity
+
+      send_request FUNCTION_GET_DEGREE, [servo_num], 'C', 12, 's s'
     end
 
-    # Sets the period of the specified servo in µs.
+    # Sets the period of the specified servo.
     # 
     # Usually, servos are controlled with a
     # `PWM <https://en.wikipedia.org/wiki/Pulse-width_modulation>`__. Different
@@ -333,39 +358,45 @@ module Tinkerforge
     # 
     # If your servo comes with a datasheet that specifies a period, you should
     # set it accordingly. If you don't have a datasheet and you have no idea
-    # what the correct period is, the default value (19.5ms) will most likely
+    # what the correct period is, the default value will most likely
     # work fine.
-    # 
-    # The minimum possible period is 1µs and the maximum is 65535µs.
-    # 
-    # The default value is 19.5ms (19500µs).
     def set_period(servo_num, period)
-      send_request FUNCTION_SET_PERIOD, [servo_num, period], 'C S', 0, ''
+      check_validity
+
+      send_request FUNCTION_SET_PERIOD, [servo_num, period], 'C S', 8, ''
     end
 
     # Returns the period for the specified servo as set by BrickServo#set_period.
     def get_period(servo_num)
-      send_request FUNCTION_GET_PERIOD, [servo_num], 'C', 2, 'S'
+      check_validity
+
+      send_request FUNCTION_GET_PERIOD, [servo_num], 'C', 10, 'S'
     end
 
-    # Returns the current consumption of the specified servo in mA.
+    # Returns the current consumption of the specified servo.
     def get_servo_current(servo_num)
-      send_request FUNCTION_GET_SERVO_CURRENT, [servo_num], 'C', 2, 'S'
+      check_validity
+
+      send_request FUNCTION_GET_SERVO_CURRENT, [servo_num], 'C', 10, 'S'
     end
 
-    # Returns the current consumption of all servos together in mA.
+    # Returns the current consumption of all servos together.
     def get_overall_current
-      send_request FUNCTION_GET_OVERALL_CURRENT, [], '', 2, 'S'
+      check_validity
+
+      send_request FUNCTION_GET_OVERALL_CURRENT, [], '', 10, 'S'
     end
 
-    # Returns the stack input voltage in mV. The stack input voltage is the
+    # Returns the stack input voltage. The stack input voltage is the
     # voltage that is supplied via the stack, i.e. it is given by a
     # Step-Down or Step-Up Power Supply.
     def get_stack_input_voltage
-      send_request FUNCTION_GET_STACK_INPUT_VOLTAGE, [], '', 2, 'S'
+      check_validity
+
+      send_request FUNCTION_GET_STACK_INPUT_VOLTAGE, [], '', 10, 'S'
     end
 
-    # Returns the external input voltage in mV. The external input voltage is
+    # Returns the external input voltage. The external input voltage is
     # given via the black power input connector on the Servo Brick.
     # 
     # If there is an external input voltage and a stack input voltage, the motors
@@ -378,23 +409,27 @@ module Tinkerforge
     #  the external connection, it will immediately be driven by the high
     #  stack voltage
     def get_external_input_voltage
-      send_request FUNCTION_GET_EXTERNAL_INPUT_VOLTAGE, [], '', 2, 'S'
+      check_validity
+
+      send_request FUNCTION_GET_EXTERNAL_INPUT_VOLTAGE, [], '', 10, 'S'
     end
 
-    # Sets the minimum voltage in mV, below which the CALLBACK_UNDER_VOLTAGE callback
+    # Sets the minimum voltage, below which the CALLBACK_UNDER_VOLTAGE callback
     # is triggered. The minimum possible value that works with the Servo Brick is 5V.
     # You can use this function to detect the discharge of a battery that is used
     # to drive the stepper motor. If you have a fixed power supply, you likely do
     # not need this functionality.
-    # 
-    # The default value is 5V (5000mV).
     def set_minimum_voltage(voltage)
-      send_request FUNCTION_SET_MINIMUM_VOLTAGE, [voltage], 'S', 0, ''
+      check_validity
+
+      send_request FUNCTION_SET_MINIMUM_VOLTAGE, [voltage], 'S', 8, ''
     end
 
     # Returns the minimum voltage as set by BrickServo#set_minimum_voltage
     def get_minimum_voltage
-      send_request FUNCTION_GET_MINIMUM_VOLTAGE, [], '', 2, 'S'
+      check_validity
+
+      send_request FUNCTION_GET_MINIMUM_VOLTAGE, [], '', 10, 'S'
     end
 
     # Enables the CALLBACK_POSITION_REACHED callback.
@@ -403,23 +438,27 @@ module Tinkerforge
     # 
     # .. versionadded:: 2.0.1$nbsp;(Firmware)
     def enable_position_reached_callback
-      send_request FUNCTION_ENABLE_POSITION_REACHED_CALLBACK, [], '', 0, ''
+      check_validity
+
+      send_request FUNCTION_ENABLE_POSITION_REACHED_CALLBACK, [], '', 8, ''
     end
 
     # Disables the CALLBACK_POSITION_REACHED callback.
     # 
-    # Default is disabled.
-    # 
     # .. versionadded:: 2.0.1$nbsp;(Firmware)
     def disable_position_reached_callback
-      send_request FUNCTION_DISABLE_POSITION_REACHED_CALLBACK, [], '', 0, ''
+      check_validity
+
+      send_request FUNCTION_DISABLE_POSITION_REACHED_CALLBACK, [], '', 8, ''
     end
 
     # Returns *true* if CALLBACK_POSITION_REACHED callback is enabled, *false* otherwise.
     # 
     # .. versionadded:: 2.0.1$nbsp;(Firmware)
     def is_position_reached_callback_enabled
-      send_request FUNCTION_IS_POSITION_REACHED_CALLBACK_ENABLED, [], '', 1, '?'
+      check_validity
+
+      send_request FUNCTION_IS_POSITION_REACHED_CALLBACK_ENABLED, [], '', 9, '?'
     end
 
     # Enables the CALLBACK_VELOCITY_REACHED callback.
@@ -428,7 +467,9 @@ module Tinkerforge
     # 
     # .. versionadded:: 2.0.1$nbsp;(Firmware)
     def enable_velocity_reached_callback
-      send_request FUNCTION_ENABLE_VELOCITY_REACHED_CALLBACK, [], '', 0, ''
+      check_validity
+
+      send_request FUNCTION_ENABLE_VELOCITY_REACHED_CALLBACK, [], '', 8, ''
     end
 
     # Disables the CALLBACK_VELOCITY_REACHED callback.
@@ -437,22 +478,26 @@ module Tinkerforge
     # 
     # .. versionadded:: 2.0.1$nbsp;(Firmware)
     def disable_velocity_reached_callback
-      send_request FUNCTION_DISABLE_VELOCITY_REACHED_CALLBACK, [], '', 0, ''
+      check_validity
+
+      send_request FUNCTION_DISABLE_VELOCITY_REACHED_CALLBACK, [], '', 8, ''
     end
 
     # Returns *true* if CALLBACK_VELOCITY_REACHED callback is enabled, *false* otherwise.
     # 
     # .. versionadded:: 2.0.1$nbsp;(Firmware)
     def is_velocity_reached_callback_enabled
-      send_request FUNCTION_IS_VELOCITY_REACHED_CALLBACK_ENABLED, [], '', 1, '?'
+      check_validity
+
+      send_request FUNCTION_IS_VELOCITY_REACHED_CALLBACK_ENABLED, [], '', 9, '?'
     end
 
     # The SPITF protocol can be used with a dynamic baudrate. If the dynamic baudrate is
     # enabled, the Brick will try to adapt the baudrate for the communication
     # between Bricks and Bricklets according to the amount of data that is transferred.
     # 
-    # The baudrate will be increased exponentially if lots of data is send/received and
-    # decreased linearly if little data is send/received.
+    # The baudrate will be increased exponentially if lots of data is sent/received and
+    # decreased linearly if little data is sent/received.
     # 
     # This lowers the baudrate in applications where little data is transferred (e.g.
     # a weather station) and increases the robustness. If there is lots of data to transfer
@@ -466,20 +511,20 @@ module Tinkerforge
     # BrickServo#set_spitfp_baudrate. If the dynamic baudrate is disabled, the baudrate
     # as set by BrickServo#set_spitfp_baudrate will be used statically.
     # 
-    # The minimum dynamic baudrate has a value range of 400000 to 2000000 baud.
-    # 
-    # By default dynamic baudrate is enabled and the minimum dynamic baudrate is 400000.
-    # 
     # .. versionadded:: 2.3.4$nbsp;(Firmware)
     def set_spitfp_baudrate_config(enable_dynamic_baudrate, minimum_dynamic_baudrate)
-      send_request FUNCTION_SET_SPITFP_BAUDRATE_CONFIG, [enable_dynamic_baudrate, minimum_dynamic_baudrate], '? L', 0, ''
+      check_validity
+
+      send_request FUNCTION_SET_SPITFP_BAUDRATE_CONFIG, [enable_dynamic_baudrate, minimum_dynamic_baudrate], '? L', 8, ''
     end
 
     # Returns the baudrate config, see BrickServo#set_spitfp_baudrate_config.
     # 
     # .. versionadded:: 2.3.4$nbsp;(Firmware)
     def get_spitfp_baudrate_config
-      send_request FUNCTION_GET_SPITFP_BAUDRATE_CONFIG, [], '', 5, '? L'
+      check_validity
+
+      send_request FUNCTION_GET_SPITFP_BAUDRATE_CONFIG, [], '', 13, '? L'
     end
 
     # Returns the timeout count for the different communication methods.
@@ -491,11 +536,12 @@ module Tinkerforge
     # 
     # .. versionadded:: 2.3.2$nbsp;(Firmware)
     def get_send_timeout_count(communication_method)
-      send_request FUNCTION_GET_SEND_TIMEOUT_COUNT, [communication_method], 'C', 4, 'L'
+      check_validity
+
+      send_request FUNCTION_GET_SEND_TIMEOUT_COUNT, [communication_method], 'C', 12, 'L'
     end
 
-    # Sets the baudrate for a specific Bricklet port ('a' - 'd'). The
-    # baudrate can be in the range 400000 to 2000000.
+    # Sets the baudrate for a specific Bricklet port.
     # 
     # If you want to increase the throughput of Bricklets you can increase
     # the baudrate. If you get a high error count because of high
@@ -506,21 +552,23 @@ module Tinkerforge
     # function corresponds to the maximum baudrate (see BrickServo#set_spitfp_baudrate_config).
     # 
     # Regulatory testing is done with the default baudrate. If CE compatibility
-    # or similar is necessary in you applications we recommend to not change
+    # or similar is necessary in your applications we recommend to not change
     # the baudrate.
     # 
-    # The default baudrate for all ports is 1400000.
-    # 
     # .. versionadded:: 2.3.2$nbsp;(Firmware)
     def set_spitfp_baudrate(bricklet_port, baudrate)
-      send_request FUNCTION_SET_SPITFP_BAUDRATE, [bricklet_port, baudrate], 'k L', 0, ''
+      check_validity
+
+      send_request FUNCTION_SET_SPITFP_BAUDRATE, [bricklet_port, baudrate], 'k L', 8, ''
     end
 
     # Returns the baudrate for a given Bricklet port, see BrickServo#set_spitfp_baudrate.
     # 
     # .. versionadded:: 2.3.2$nbsp;(Firmware)
     def get_spitfp_baudrate(bricklet_port)
-      send_request FUNCTION_GET_SPITFP_BAUDRATE, [bricklet_port], 'k', 4, 'L'
+      check_validity
+
+      send_request FUNCTION_GET_SPITFP_BAUDRATE, [bricklet_port], 'k', 12, 'L'
     end
 
     # Returns the error count for the communication between Brick and Bricklet.
@@ -537,7 +585,9 @@ module Tinkerforge
     # 
     # .. versionadded:: 2.3.2$nbsp;(Firmware)
     def get_spitfp_error_count(bricklet_port)
-      send_request FUNCTION_GET_SPITFP_ERROR_COUNT, [bricklet_port], 'k', 16, 'L L L L'
+      check_validity
+
+      send_request FUNCTION_GET_SPITFP_ERROR_COUNT, [bricklet_port], 'k', 24, 'L L L L'
     end
 
     # Enables the status LED.
@@ -549,7 +599,9 @@ module Tinkerforge
     # 
     # .. versionadded:: 2.3.1$nbsp;(Firmware)
     def enable_status_led
-      send_request FUNCTION_ENABLE_STATUS_LED, [], '', 0, ''
+      check_validity
+
+      send_request FUNCTION_ENABLE_STATUS_LED, [], '', 8, ''
     end
 
     # Disables the status LED.
@@ -561,14 +613,18 @@ module Tinkerforge
     # 
     # .. versionadded:: 2.3.1$nbsp;(Firmware)
     def disable_status_led
-      send_request FUNCTION_DISABLE_STATUS_LED, [], '', 0, ''
+      check_validity
+
+      send_request FUNCTION_DISABLE_STATUS_LED, [], '', 8, ''
     end
 
     # Returns *true* if the status LED is enabled, *false* otherwise.
     # 
     # .. versionadded:: 2.3.1$nbsp;(Firmware)
     def is_status_led_enabled
-      send_request FUNCTION_IS_STATUS_LED_ENABLED, [], '', 1, '?'
+      check_validity
+
+      send_request FUNCTION_IS_STATUS_LED_ENABLED, [], '', 9, '?'
     end
 
     # Returns the firmware and protocol version and the name of the Bricklet for a
@@ -577,17 +633,21 @@ module Tinkerforge
     # This functions sole purpose is to allow automatic flashing of v1.x.y Bricklet
     # plugins.
     def get_protocol1_bricklet_name(port)
-      send_request FUNCTION_GET_PROTOCOL1_BRICKLET_NAME, [port], 'k', 44, 'C C3 Z40'
+      check_validity
+
+      send_request FUNCTION_GET_PROTOCOL1_BRICKLET_NAME, [port], 'k', 52, 'C C3 Z40'
     end
 
-    # Returns the temperature in °C/10 as measured inside the microcontroller. The
+    # Returns the temperature as measured inside the microcontroller. The
     # value returned is not the ambient temperature!
     # 
     # The temperature is only proportional to the real temperature and it has an
     # accuracy of ±15%. Practically it is only useful as an indicator for
     # temperature changes.
     def get_chip_temperature
-      send_request FUNCTION_GET_CHIP_TEMPERATURE, [], '', 2, 's'
+      check_validity
+
+      send_request FUNCTION_GET_CHIP_TEMPERATURE, [], '', 10, 's'
     end
 
     # Calling this function will reset the Brick. Calling this function
@@ -597,19 +657,43 @@ module Tinkerforge
     # calling functions on the existing ones will result in
     # undefined behavior!
     def reset
-      send_request FUNCTION_RESET, [], '', 0, ''
+      check_validity
+
+      send_request FUNCTION_RESET, [], '', 8, ''
+    end
+
+    # Writes 32 bytes of firmware to the bricklet attached at the given port.
+    # The bytes are written to the position offset * 32.
+    # 
+    # This function is used by Brick Viewer during flashing. It should not be
+    # necessary to call it in a normal user program.
+    def write_bricklet_plugin(port, offset, chunk)
+      check_validity
+
+      send_request FUNCTION_WRITE_BRICKLET_PLUGIN, [port, offset, chunk], 'k C C32', 8, ''
+    end
+
+    # Reads 32 bytes of firmware from the bricklet attached at the given port.
+    # The bytes are read starting at the position offset * 32.
+    # 
+    # This function is used by Brick Viewer during flashing. It should not be
+    # necessary to call it in a normal user program.
+    def read_bricklet_plugin(port, offset)
+      check_validity
+
+      send_request FUNCTION_READ_BRICKLET_PLUGIN, [port, offset], 'k C', 40, 'C32'
     end
 
     # Returns the UID, the UID where the Brick is connected to,
     # the position, the hardware and firmware version as well as the
     # device identifier.
     # 
-    # The position can be '0'-'8' (stack position).
+    # The position is the position in the stack from '0' (bottom) to '8' (top).
     # 
     # The device identifier numbers can be found :ref:`here <device_identifier>`.
     # |device_identifier_constant|
     def get_identity
-      send_request FUNCTION_GET_IDENTITY, [], '', 25, 'Z8 Z8 k C3 C3 S'
+      send_request FUNCTION_GET_IDENTITY, [], '', 33, 'Z8 Z8 k C3 C3 S'
     end
 
     # Registers a callback with ID <tt>id</tt> to the block <tt>block</tt>.