tinkerforge 2.1.24 → 2.1.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: '079f652eea712eed74c2d5cd78a755758a697e3f1f56d494f27d380cedceb20f'
-  data.tar.gz: cca1e723fa33b5f5b7359c4b9a369f781a0607656dd8e2099f8df92556232066
+SHA1:
+  metadata.gz: 230f7a5c93853c69863d8547f48eebcf6a07a776
+  data.tar.gz: 2db97f5f906248e1216b0ddd10eb27e9ef9fcebc
 SHA512:
-  metadata.gz: 668fbf0aac5f208792cad08bbc3428d7b6d6cc06f11abe636938a6a85c9e140dd722343a3d268e83ffee90b28ec5d55815651d935dfe9ecdd82f012f8c1f23e4
-  data.tar.gz: 15f365b69eeda8a8b07d54a2422a08036b1bc4f8d6a40090dd4360c53afe3bee77170cc3d563f6b8d28c6d86fd9395da5c6e2790357dd6c36b17cf3de1749406
+  metadata.gz: 3b441d9e549ea256d67ddf9424aa9f6edcfc14ca9a20c113a93fe5c4d69123d1a3f78226cd95cb41a62b7831c5f1d05ec4dd1540287e361d0cadceb78d479658
+  data.tar.gz: 8a395c5ce48fb09f26f437ec3ccbcc683d335d1d584c42f34f70c5f8845a92320a26184b7061d0aa201681d24b52aae9bc8c6fb5478a17f3ea1372d2943c4320

data/lib/tinkerforge/brick_dc.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 one brushed DC motor with up to 28V and 5A (peak)
   class BrickDC < Device
@@ -16,8 +18,7 @@ module Tinkerforge
     DEVICE_DISPLAY_NAME = 'DC Brick' # :nodoc:
 
     # This callback is triggered when the input voltage drops below the value set by
-    # BrickDC#set_minimum_voltage. The parameter is the current voltage given
-    # in mV.
+    # BrickDC#set_minimum_voltage. The parameter is the current voltage.
     CALLBACK_UNDER_VOLTAGE = 21
 
     # This callback is triggered if either the current consumption
@@ -88,6 +89,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:
 
     DRIVE_MODE_DRIVE_BRAKE = 0 # :nodoc:
@@ -104,7 +107,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, 3]
 
@@ -140,13 +143,16 @@ 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_EMERGENCY_SHUTDOWN] = ''
-      @callback_formats[CALLBACK_VELOCITY_REACHED] = 's'
-      @callback_formats[CALLBACK_CURRENT_VELOCITY] = 's'
+      @callback_formats[CALLBACK_UNDER_VOLTAGE] = [10, 'S']
+      @callback_formats[CALLBACK_EMERGENCY_SHUTDOWN] = [8, '']
+      @callback_formats[CALLBACK_VELOCITY_REACHED] = [10, 's']
+      @callback_formats[CALLBACK_CURRENT_VELOCITY] = [10, 's']
 
+      @ipcon.add_device self
     end
 
     # Sets the velocity of the motor. Whereas -32767 is full speed backward,
@@ -158,22 +164,26 @@ module Tinkerforge
     # controlled, e.g. a velocity of 3277 sets a PWM with a 10% duty cycle.
     # You can not only control the duty cycle of the PWM but also the frequency,
     # see BrickDC#set_pwm_frequency.
-    # 
-    # The default velocity is 0.
     def set_velocity(velocity)
-      send_request FUNCTION_SET_VELOCITY, [velocity], 's', 0, ''
+      check_validity
+
+      send_request FUNCTION_SET_VELOCITY, [velocity], 's', 8, ''
     end
 
     # Returns the velocity as set by BrickDC#set_velocity.
     def get_velocity
-      send_request FUNCTION_GET_VELOCITY, [], '', 2, 's'
+      check_validity
+
+      send_request FUNCTION_GET_VELOCITY, [], '', 10, 's'
     end
 
     # Returns the *current* velocity of the motor. This value is different
     # from BrickDC#get_velocity whenever the motor is currently accelerating
     # to a goal set by BrickDC#set_velocity.
     def get_current_velocity
-      send_request FUNCTION_GET_CURRENT_VELOCITY, [], '', 2, 's'
+      check_validity
+
+      send_request FUNCTION_GET_CURRENT_VELOCITY, [], '', 10, 's'
     end
 
     # Sets the acceleration of the motor. It is given in *velocity/s*. An
@@ -186,34 +196,38 @@ module Tinkerforge
     # 
     # If acceleration is set to 0, there is no speed ramping, i.e. a new velocity
     # is immediately given to the motor.
-    # 
-    # The default acceleration is 10000.
     def set_acceleration(acceleration)
-      send_request FUNCTION_SET_ACCELERATION, [acceleration], 'S', 0, ''
+      check_validity
+
+      send_request FUNCTION_SET_ACCELERATION, [acceleration], 'S', 8, ''
     end
 
     # Returns the acceleration as set by BrickDC#set_acceleration.
     def get_acceleration
-      send_request FUNCTION_GET_ACCELERATION, [], '', 2, 'S'
+      check_validity
+
+      send_request FUNCTION_GET_ACCELERATION, [], '', 10, 'S'
     end
 
-    # Sets the frequency (in Hz) of the PWM with which the motor is driven.
-    # The possible range of the frequency is 1-20000Hz. Often a high frequency
+    # Sets the frequency of the PWM with which the motor is driven.
+    # Often a high frequency
     # is less noisy and the motor runs smoother. However, with a low frequency
     # there are less switches and therefore fewer switching losses. Also with
     # most motors lower frequencies enable higher torque.
     # 
     # If you have no idea what all this means, just ignore this function and use
     # the default frequency, it will very likely work fine.
-    # 
-    # The default frequency is 15 kHz.
     def set_pwm_frequency(frequency)
-      send_request FUNCTION_SET_PWM_FREQUENCY, [frequency], 'S', 0, ''
+      check_validity
+
+      send_request FUNCTION_SET_PWM_FREQUENCY, [frequency], 'S', 8, ''
     end
 
-    # Returns the PWM frequency (in Hz) as set by BrickDC#set_pwm_frequency.
+    # Returns the PWM frequency as set by BrickDC#set_pwm_frequency.
     def get_pwm_frequency
-      send_request FUNCTION_GET_PWM_FREQUENCY, [], '', 2, 'S'
+      check_validity
+
+      send_request FUNCTION_GET_PWM_FREQUENCY, [], '', 10, 'S'
     end
 
     # Executes an active full brake.
@@ -225,17 +239,21 @@ module Tinkerforge
     # 
     # Call BrickDC#set_velocity with 0 if you just want to stop the motor.
     def full_brake
-      send_request FUNCTION_FULL_BRAKE, [], '', 0, ''
+      check_validity
+
+      send_request FUNCTION_FULL_BRAKE, [], '', 8, ''
     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 DC Brick.
     # 
     # If there is an external input voltage and a stack input voltage, the motor
@@ -248,45 +266,65 @@ 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
 
-    # Returns the current consumption of the motor in mA.
+    # Returns the current consumption of the motor.
     def get_current_consumption
-      send_request FUNCTION_GET_CURRENT_CONSUMPTION, [], '', 2, 'S'
+      check_validity
+
+      send_request FUNCTION_GET_CURRENT_CONSUMPTION, [], '', 10, 'S'
     end
 
     # Enables the driver chip. The driver parameters can be configured (velocity,
     # acceleration, etc) before it is enabled.
     def enable
-      send_request FUNCTION_ENABLE, [], '', 0, ''
+      check_validity
+
+      send_request FUNCTION_ENABLE, [], '', 8, ''
     end
 
     # Disables the driver chip. The configurations are kept (velocity,
     # acceleration, etc) but the motor is not driven until it is enabled again.
+    # 
+    # .. warning::
+    #  Disabling the driver chip while the motor is still turning can damage the
+    #  driver chip. The motor should be stopped calling BrickDC#set_velocity with 0
+    #  before disabling the motor power. The BrickDC#set_velocity function will **not**
+    #  wait until the motor is actually stopped. You have to explicitly wait for the
+    #  appropriate time after calling the BrickDC#set_velocity function before calling
+    #  the BrickDC#disable function.
     def disable
-      send_request FUNCTION_DISABLE, [], '', 0, ''
+      check_validity
+
+      send_request FUNCTION_DISABLE, [], '', 8, ''
     end
 
     # Returns *true* if the driver chip is enabled, *false* otherwise.
     def is_enabled
-      send_request FUNCTION_IS_ENABLED, [], '', 1, '?'
+      check_validity
+
+      send_request FUNCTION_IS_ENABLED, [], '', 9, '?'
     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 DC Brick is 6V.
     # You can use this function to detect the discharge of a battery that is used
     # to drive the motor. If you have a fixed power supply, you likely do not need
     # this functionality.
-    # 
-    # The default value is 6V.
     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 BrickDC#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
 
     # Sets the drive mode. Possible modes are:
@@ -304,36 +342,40 @@ module Tinkerforge
     # In Drive/Coast mode, the motor is always either driving or freewheeling.
     # Advantages are: Less current consumption and less demands on the motor and
     # driver chip.
-    # 
-    # The default value is 0 = Drive/Brake.
     def set_drive_mode(mode)
-      send_request FUNCTION_SET_DRIVE_MODE, [mode], 'C', 0, ''
+      check_validity
+
+      send_request FUNCTION_SET_DRIVE_MODE, [mode], 'C', 8, ''
     end
 
     # Returns the drive mode, as set by BrickDC#set_drive_mode.
     def get_drive_mode
-      send_request FUNCTION_GET_DRIVE_MODE, [], '', 1, 'C'
+      check_validity
+
+      send_request FUNCTION_GET_DRIVE_MODE, [], '', 9, 'C'
     end
 
-    # Sets a period in ms with which the CALLBACK_CURRENT_VELOCITY callback is triggered.
+    # Sets a period with which the CALLBACK_CURRENT_VELOCITY callback is triggered.
     # A period of 0 turns the callback off.
-    # 
-    # The default value is 0.
     def set_current_velocity_period(period)
-      send_request FUNCTION_SET_CURRENT_VELOCITY_PERIOD, [period], 'S', 0, ''
+      check_validity
+
+      send_request FUNCTION_SET_CURRENT_VELOCITY_PERIOD, [period], 'S', 8, ''
     end
 
     # Returns the period as set by BrickDC#set_current_velocity_period.
     def get_current_velocity_period
-      send_request FUNCTION_GET_CURRENT_VELOCITY_PERIOD, [], '', 2, 'S'
+      check_validity
+
+      send_request FUNCTION_GET_CURRENT_VELOCITY_PERIOD, [], '', 10, 'S'
     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
@@ -347,20 +389,20 @@ module Tinkerforge
     # BrickDC#set_spitfp_baudrate. If the dynamic baudrate is disabled, the baudrate
     # as set by BrickDC#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.5$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 BrickDC#set_spitfp_baudrate_config.
     # 
     # .. versionadded:: 2.3.5$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.
@@ -372,11 +414,12 @@ module Tinkerforge
     # 
     # .. versionadded:: 2.3.3$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
@@ -387,21 +430,23 @@ module Tinkerforge
     # function corresponds to the maximum baudrate (see BrickDC#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.3$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 BrickDC#set_spitfp_baudrate.
     # 
     # .. versionadded:: 2.3.3$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.
@@ -418,7 +463,9 @@ module Tinkerforge
     # 
     # .. versionadded:: 2.3.3$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.
@@ -430,7 +477,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.
@@ -442,14 +491,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
@@ -458,17 +511,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
@@ -478,19 +535,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>.