tinkerforge 2.1.15 → 2.1.16

data/lib/tinkerforge/bricklet_motion_detector_v2.rb

@@ -0,0 +1,261 @@
+# -*- ruby encoding: utf-8 -*-
+#############################################################
+# This file was automatically generated on 2018-02-28.      #
+#                                                           #
+# Ruby Bindings Version 2.1.16                              #
+#                                                           #
+# 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
+  # Passive infrared (PIR) motion sensor, 12m range
+  class BrickletMotionDetectorV2 < Device
+    DEVICE_IDENTIFIER = 292 # :nodoc:
+    DEVICE_DISPLAY_NAME = 'Motion Detector Bricklet 2.0' # :nodoc:
+
+    # This callback is called after a motion was detected.
+    CALLBACK_MOTION_DETECTED = 6
+
+    # This callback is called when the detection cycle ended. When this
+    # callback is called, a new motion can be detected again after approximately 2
+    # seconds.
+    CALLBACK_DETECTION_CYCLE_ENDED = 7
+
+    FUNCTION_GET_MOTION_DETECTED = 1 # :nodoc:
+    FUNCTION_SET_SENSITIVITY = 2 # :nodoc:
+    FUNCTION_GET_SENSITIVITY = 3 # :nodoc:
+    FUNCTION_SET_INDICATOR = 4 # :nodoc:
+    FUNCTION_GET_INDICATOR = 5 # :nodoc:
+    FUNCTION_GET_SPITFP_ERROR_COUNT = 234 # :nodoc:
+    FUNCTION_SET_BOOTLOADER_MODE = 235 # :nodoc:
+    FUNCTION_GET_BOOTLOADER_MODE = 236 # :nodoc:
+    FUNCTION_SET_WRITE_FIRMWARE_POINTER = 237 # :nodoc:
+    FUNCTION_WRITE_FIRMWARE = 238 # :nodoc:
+    FUNCTION_SET_STATUS_LED_CONFIG = 239 # :nodoc:
+    FUNCTION_GET_STATUS_LED_CONFIG = 240 # :nodoc:
+    FUNCTION_GET_CHIP_TEMPERATURE = 242 # :nodoc:
+    FUNCTION_RESET = 243 # :nodoc:
+    FUNCTION_WRITE_UID = 248 # :nodoc:
+    FUNCTION_READ_UID = 249 # :nodoc:
+    FUNCTION_GET_IDENTITY = 255 # :nodoc:
+
+    MOTION_NOT_DETECTED = 0 # :nodoc:
+    MOTION_DETECTED = 1 # :nodoc:
+    BOOTLOADER_MODE_BOOTLOADER = 0 # :nodoc:
+    BOOTLOADER_MODE_FIRMWARE = 1 # :nodoc:
+    BOOTLOADER_MODE_BOOTLOADER_WAIT_FOR_REBOOT = 2 # :nodoc:
+    BOOTLOADER_MODE_FIRMWARE_WAIT_FOR_REBOOT = 3 # :nodoc:
+    BOOTLOADER_MODE_FIRMWARE_WAIT_FOR_ERASE_AND_REBOOT = 4 # :nodoc:
+    BOOTLOADER_STATUS_OK = 0 # :nodoc:
+    BOOTLOADER_STATUS_INVALID_MODE = 1 # :nodoc:
+    BOOTLOADER_STATUS_NO_CHANGE = 2 # :nodoc:
+    BOOTLOADER_STATUS_ENTRY_FUNCTION_NOT_PRESENT = 3 # :nodoc:
+    BOOTLOADER_STATUS_DEVICE_IDENTIFIER_INCORRECT = 4 # :nodoc:
+    BOOTLOADER_STATUS_CRC_MISMATCH = 5 # :nodoc:
+    STATUS_LED_CONFIG_OFF = 0 # :nodoc:
+    STATUS_LED_CONFIG_ON = 1 # :nodoc:
+    STATUS_LED_CONFIG_SHOW_HEARTBEAT = 2 # :nodoc:
+    STATUS_LED_CONFIG_SHOW_STATUS = 3 # :nodoc:
+
+    # 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
+
+      @api_version = [2, 0, 0]
+
+      @response_expected[FUNCTION_GET_MOTION_DETECTED] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_SET_SENSITIVITY] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_GET_SENSITIVITY] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_SET_INDICATOR] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_GET_INDICATOR] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_GET_SPITFP_ERROR_COUNT] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_SET_BOOTLOADER_MODE] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_GET_BOOTLOADER_MODE] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_SET_WRITE_FIRMWARE_POINTER] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_WRITE_FIRMWARE] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_SET_STATUS_LED_CONFIG] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_GET_STATUS_LED_CONFIG] = 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_UID] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_READ_UID] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_GET_IDENTITY] = RESPONSE_EXPECTED_ALWAYS_TRUE
+
+      @callback_formats[CALLBACK_MOTION_DETECTED] = ''
+      @callback_formats[CALLBACK_DETECTION_CYCLE_ENDED] = ''
+
+    end
+
+    # Returns 1 if a motion was detected. How long this returns 1 after a motion
+    # was detected can be adjusted with one of the small potentiometers on the
+    # Motion Detector Bricklet, see :ref:`here
+    # <motion_detector_bricklet_sensitivity_delay_block_time>`.
+    # 
+    # There is also a blue LED on the Bricklet that is on as long as the Bricklet is
+    # in the "motion detected" state.
+    def get_motion_detected
+      send_request FUNCTION_GET_MOTION_DETECTED, [], '', 1, 'C'
+    end
+
+    # Sets the sensitivity of the PIR sensor. The range is 0-100. At full 
+    # sensitivity (100), the Bricklet can detect motion in a range of approximately 12m.
+    # 
+    # The actual range depends on many things in the environment (e.g. reflections) and the
+    # size of the object to be detected. While a big person might be detected in a range
+    # of 10m a cat may only be detected at 2m distance with the same setting.
+    # 
+    # So you will have to find a good sensitivity for your application by trial and error.
+    # 
+    # The default value is 50.
+    def set_sensitivity(sensitivity)
+      send_request FUNCTION_SET_SENSITIVITY, [sensitivity], 'C', 0, ''
+    end
+
+    # Returns the sensitivity as set by BrickletMotionDetectorV2#set_sensitivity.
+    def get_sensitivity
+      send_request FUNCTION_GET_SENSITIVITY, [], '', 1, 'C'
+    end
+
+    # Sets the blue backlight of the fresnel lens. The backlight consists of
+    # three LEDs. The brightness of each LED can be controlled with a 8-bit value
+    # (0-255). A value of 0 turns the LED off and a value of 255 turns the LED
+    # to full brightness.
+    # 
+    # The default value is 0, 0, 0.
+    def set_indicator(top_left, top_right, bottom)
+      send_request FUNCTION_SET_INDICATOR, [top_left, top_right, bottom], 'C C C', 0, ''
+    end
+
+    # Returns the indicator configuration as set by BrickletMotionDetectorV2#set_indicator.
+    def get_indicator
+      send_request FUNCTION_GET_INDICATOR, [], '', 3, 'C C C'
+    end
+
+    # Returns the error count for the communication between Brick and Bricklet.
+    # 
+    # The errors are divided into
+    # 
+    # * ack checksum errors,
+    # * message checksum errors,
+    # * frameing errors and
+    # * overflow errors.
+    # 
+    # The errors counts are for errors that occur on the Bricklet side. All
+    # Bricks have a similar function that returns the errors on the Brick side.
+    def get_spitfp_error_count
+      send_request FUNCTION_GET_SPITFP_ERROR_COUNT, [], '', 16, 'L L L L'
+    end
+
+    # Sets the bootloader mode and returns the status after the requested
+    # mode change was instigated.
+    # 
+    # You can change from bootloader mode to firmware mode and vice versa. A change
+    # from bootloader mode to firmware mode will only take place if the entry function,
+    # device identifier und crc are present and correct.
+    # 
+    # This function is used by Brick Viewer during flashing. It should not be
+    # necessary to call it in a normal user program.
+    def set_bootloader_mode(mode)
+      send_request FUNCTION_SET_BOOTLOADER_MODE, [mode], 'C', 1, 'C'
+    end
+
+    # Returns the current bootloader mode, see BrickletMotionDetectorV2#set_bootloader_mode.
+    def get_bootloader_mode
+      send_request FUNCTION_GET_BOOTLOADER_MODE, [], '', 1, 'C'
+    end
+
+    # Sets the firmware pointer for BrickletMotionDetectorV2#write_firmware. The pointer has
+    # to be increased by chunks of size 64. The data is written to flash
+    # every 4 chunks (which equals to one page of size 256).
+    # 
+    # This function is used by Brick Viewer during flashing. It should not be
+    # necessary to call it in a normal user program.
+    def set_write_firmware_pointer(pointer)
+      send_request FUNCTION_SET_WRITE_FIRMWARE_POINTER, [pointer], 'L', 0, ''
+    end
+
+    # Writes 64 Bytes of firmware at the position as written by
+    # BrickletMotionDetectorV2#set_write_firmware_pointer before. The firmware is written
+    # to flash every 4 chunks.
+    # 
+    # You can only write firmware in bootloader mode.
+    # 
+    # This function is used by Brick Viewer during flashing. It should not be
+    # necessary to call it in a normal user program.
+    def write_firmware(data)
+      send_request FUNCTION_WRITE_FIRMWARE, [data], 'C64', 1, 'C'
+    end
+
+    # Sets the status LED configuration. By default the LED shows
+    # communication traffic between Brick and Bricklet, it flickers once
+    # for every 10 received data packets.
+    # 
+    # You can also turn the LED permanently on/off or show a heartbeat.
+    # 
+    # If the Bricklet is in bootloader mode, the LED is will show heartbeat by default.
+    def set_status_led_config(config)
+      send_request FUNCTION_SET_STATUS_LED_CONFIG, [config], 'C', 0, ''
+    end
+
+    # Returns the configuration as set by BrickletMotionDetectorV2#set_status_led_config
+    def get_status_led_config
+      send_request FUNCTION_GET_STATUS_LED_CONFIG, [], '', 1, 'C'
+    end
+
+    # Returns the temperature in °C 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 bad
+    # accuracy. Practically it is only useful as an indicator for
+    # temperature changes.
+    def get_chip_temperature
+      send_request FUNCTION_GET_CHIP_TEMPERATURE, [], '', 2, 's'
+    end
+
+    # Calling this function will reset the Bricklet. All configurations
+    # will be lost.
+    # 
+    # After a reset you have to create new device objects,
+    # calling functions on the existing ones will result in
+    # undefined behavior!
+    def reset
+      send_request FUNCTION_RESET, [], '', 0, ''
+    end
+
+    # Writes a new UID into flash. If you want to set a new UID
+    # you have to decode the Base58 encoded UID string into an
+    # integer first.
+    # 
+    # We recommend that you use Brick Viewer to change the UID.
+    def write_uid(uid)
+      send_request FUNCTION_WRITE_UID, [uid], 'L', 0, ''
+    end
+
+    # Returns the current UID as an integer. Encode as
+    # Base58 to get the usual string version.
+    def read_uid
+      send_request FUNCTION_READ_UID, [], '', 4, 'L'
+    end
+
+    # Returns the UID, the UID where the Bricklet is connected to,
+    # the position, the hardware and firmware version as well as the
+    # device identifier.
+    # 
+    # The position can be 'a', 'b', 'c' or 'd'.
+    # 
+    # 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'
+    end
+
+    # Registers a callback with ID <tt>id</tt> to the block <tt>block</tt>.
+    def register_callback(id, &block)
+      callback = block
+      @registered_callbacks[id] = callback
+    end
+  end
+end

data/lib/tinkerforge/bricklet_motorized_linear_poti.rb

@@ -1,8 +1,8 @@
 # -*- ruby encoding: utf-8 -*-
 #############################################################
-# This file was automatically generated on 2017-11-20.      #
+# This file was automatically generated on 2018-02-28.      #
 #                                                           #
-# Ruby Bindings Version 2.1.15                              #
+# Ruby Bindings Version 2.1.16                              #
 #                                                           #
 # 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  #

data/lib/tinkerforge/bricklet_multi_touch.rb

@@ -1,8 +1,8 @@
 # -*- ruby encoding: utf-8 -*-
 #############################################################
-# This file was automatically generated on 2017-11-20.      #
+# This file was automatically generated on 2018-02-28.      #
 #                                                           #
-# Ruby Bindings Version 2.1.15                              #
+# Ruby Bindings Version 2.1.16                              #
 #                                                           #
 # 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  #

data/lib/tinkerforge/bricklet_nfc.rb

@@ -0,0 +1,998 @@
+# -*- ruby encoding: utf-8 -*-
+#############################################################
+# This file was automatically generated on 2018-02-28.      #
+#                                                           #
+# Ruby Bindings Version 2.1.16                              #
+#                                                           #
+# 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
+  # NFC tag read/write, NFC P2P and Card Emulation
+  class BrickletNFC < Device
+    DEVICE_IDENTIFIER = 286 # :nodoc:
+    DEVICE_DISPLAY_NAME = 'NFC Bricklet' # :nodoc:
+
+    # This callback is called if the reader state of the NFC Bricklet changes.
+    # See BrickletNFC#reader_get_state for more information about the possible states.
+    CALLBACK_READER_STATE_CHANGED = 13
+
+    # This callback is called if the cardemu state of the NFC Bricklet changes.
+    # See BrickletNFC#cardemu_get_state for more information about the possible states.
+    CALLBACK_CARDEMU_STATE_CHANGED = 18
+
+    # This callback is called if the P2P state of the NFC Bricklet changes.
+    # See BrickletNFC#p2p_get_state for more information about the possible states.
+    CALLBACK_P2P_STATE_CHANGED = 24
+
+    FUNCTION_SET_MODE = 1 # :nodoc:
+    FUNCTION_GET_MODE = 2 # :nodoc:
+    FUNCTION_READER_REQUEST_TAG_ID = 3 # :nodoc:
+    FUNCTION_READER_GET_TAG_ID_LOW_LEVEL = 4 # :nodoc:
+    FUNCTION_READER_GET_STATE = 5 # :nodoc:
+    FUNCTION_READER_WRITE_NDEF_LOW_LEVEL = 6 # :nodoc:
+    FUNCTION_READER_REQUEST_NDEF = 7 # :nodoc:
+    FUNCTION_READER_READ_NDEF_LOW_LEVEL = 8 # :nodoc:
+    FUNCTION_READER_AUTHENTICATE_MIFARE_CLASSIC_PAGE = 9 # :nodoc:
+    FUNCTION_READER_WRITE_PAGE_LOW_LEVEL = 10 # :nodoc:
+    FUNCTION_READER_REQUEST_PAGE = 11 # :nodoc:
+    FUNCTION_READER_READ_PAGE_LOW_LEVEL = 12 # :nodoc:
+    FUNCTION_CARDEMU_GET_STATE = 14 # :nodoc:
+    FUNCTION_CARDEMU_START_DISCOVERY = 15 # :nodoc:
+    FUNCTION_CARDEMU_WRITE_NDEF_LOW_LEVEL = 16 # :nodoc:
+    FUNCTION_CARDEMU_START_TRANSFER = 17 # :nodoc:
+    FUNCTION_P2P_GET_STATE = 19 # :nodoc:
+    FUNCTION_P2P_START_DISCOVERY = 20 # :nodoc:
+    FUNCTION_P2P_WRITE_NDEF_LOW_LEVEL = 21 # :nodoc:
+    FUNCTION_P2P_START_TRANSFER = 22 # :nodoc:
+    FUNCTION_P2P_READ_NDEF_LOW_LEVEL = 23 # :nodoc:
+    FUNCTION_SET_DETECTION_LED_CONFIG = 25 # :nodoc:
+    FUNCTION_GET_DETECTION_LED_CONFIG = 26 # :nodoc:
+    FUNCTION_GET_SPITFP_ERROR_COUNT = 234 # :nodoc:
+    FUNCTION_SET_BOOTLOADER_MODE = 235 # :nodoc:
+    FUNCTION_GET_BOOTLOADER_MODE = 236 # :nodoc:
+    FUNCTION_SET_WRITE_FIRMWARE_POINTER = 237 # :nodoc:
+    FUNCTION_WRITE_FIRMWARE = 238 # :nodoc:
+    FUNCTION_SET_STATUS_LED_CONFIG = 239 # :nodoc:
+    FUNCTION_GET_STATUS_LED_CONFIG = 240 # :nodoc:
+    FUNCTION_GET_CHIP_TEMPERATURE = 242 # :nodoc:
+    FUNCTION_RESET = 243 # :nodoc:
+    FUNCTION_WRITE_UID = 248 # :nodoc:
+    FUNCTION_READ_UID = 249 # :nodoc:
+    FUNCTION_GET_IDENTITY = 255 # :nodoc:
+
+    MODE_OFF = 0 # :nodoc:
+    MODE_CARDEMU = 1 # :nodoc:
+    MODE_P2P = 2 # :nodoc:
+    MODE_READER = 3 # :nodoc:
+    TAG_TYPE_MIFARE_CLASSIC = 0 # :nodoc:
+    TAG_TYPE_TYPE1 = 1 # :nodoc:
+    TAG_TYPE_TYPE2 = 2 # :nodoc:
+    TAG_TYPE_TYPE3 = 3 # :nodoc:
+    TAG_TYPE_TYPE4 = 4 # :nodoc:
+    READER_STATE_INITIALIZATION = 0 # :nodoc:
+    READER_STATE_IDLE = 128 # :nodoc:
+    READER_STATE_ERROR = 192 # :nodoc:
+    READER_STATE_REQUEST_TAG_ID = 2 # :nodoc:
+    READER_STATE_REQUEST_TAG_ID_READY = 130 # :nodoc:
+    READER_STATE_REQUEST_TAG_ID_ERROR = 194 # :nodoc:
+    READER_STATE_AUTHENTICATE_MIFARE_CLASSIC_PAGE = 3 # :nodoc:
+    READER_STATE_AUTHENTICATE_MIFARE_CLASSIC_PAGE_READY = 131 # :nodoc:
+    READER_STATE_AUTHENTICATE_MIFARE_CLASSIC_PAGE_ERROR = 195 # :nodoc:
+    READER_STATE_WRITE_PAGE = 4 # :nodoc:
+    READER_STATE_WRITE_PAGE_READY = 132 # :nodoc:
+    READER_STATE_WRITE_PAGE_ERROR = 196 # :nodoc:
+    READER_STATE_REQUEST_PAGE = 5 # :nodoc:
+    READER_STATE_REQUEST_PAGE_READY = 133 # :nodoc:
+    READER_STATE_REQUEST_PAGE_ERROR = 197 # :nodoc:
+    READER_STATE_WRITE_NDEF = 6 # :nodoc:
+    READER_STATE_WRITE_NDEF_READY = 134 # :nodoc:
+    READER_STATE_WRITE_NDEF_ERROR = 198 # :nodoc:
+    READER_STATE_REQUEST_NDEF = 7 # :nodoc:
+    READER_STATE_REQUEST_NDEF_READY = 135 # :nodoc:
+    READER_STATE_REQUEST_NDEF_ERROR = 199 # :nodoc:
+    KEY_A = 0 # :nodoc:
+    KEY_B = 1 # :nodoc:
+    READER_WRITE_TYPE4_CAPABILITY_CONTAINER = 3 # :nodoc:
+    READER_WRITE_TYPE4_NDEF = 4 # :nodoc:
+    READER_REQUEST_TYPE4_CAPABILITY_CONTAINER = 3 # :nodoc:
+    READER_REQUEST_TYPE4_NDEF = 4 # :nodoc:
+    CARDEMU_STATE_INITIALIZATION = 0 # :nodoc:
+    CARDEMU_STATE_IDLE = 128 # :nodoc:
+    CARDEMU_STATE_ERROR = 192 # :nodoc:
+    CARDEMU_STATE_DISCOVER = 2 # :nodoc:
+    CARDEMU_STATE_DISCOVER_READY = 130 # :nodoc:
+    CARDEMU_STATE_DISCOVER_ERROR = 194 # :nodoc:
+    CARDEMU_STATE_TRANSFER_NDEF = 3 # :nodoc:
+    CARDEMU_STATE_TRANSFER_NDEF_READY = 131 # :nodoc:
+    CARDEMU_STATE_TRANSFER_NDEF_ERROR = 195 # :nodoc:
+    CARDEMU_TRANSFER_ABORT = 0 # :nodoc:
+    CARDEMU_TRANSFER_WRITE = 1 # :nodoc:
+    P2P_STATE_INITIALIZATION = 0 # :nodoc:
+    P2P_STATE_IDLE = 128 # :nodoc:
+    P2P_STATE_ERROR = 192 # :nodoc:
+    P2P_STATE_DISCOVER = 2 # :nodoc:
+    P2P_STATE_DISCOVER_READY = 130 # :nodoc:
+    P2P_STATE_DISCOVER_ERROR = 194 # :nodoc:
+    P2P_STATE_TRANSFER_NDEF = 3 # :nodoc:
+    P2P_STATE_TRANSFER_NDEF_READY = 131 # :nodoc:
+    P2P_STATE_TRANSFER_NDEF_ERROR = 195 # :nodoc:
+    P2P_TRANSFER_ABORT = 0 # :nodoc:
+    P2P_TRANSFER_WRITE = 1 # :nodoc:
+    P2P_TRANSFER_READ = 2 # :nodoc:
+    DETECTION_LED_CONFIG_OFF = 0 # :nodoc:
+    DETECTION_LED_CONFIG_ON = 1 # :nodoc:
+    DETECTION_LED_CONFIG_SHOW_HEARTBEAT = 2 # :nodoc:
+    DETECTION_LED_CONFIG_SHOW_DETECTION = 3 # :nodoc:
+    BOOTLOADER_MODE_BOOTLOADER = 0 # :nodoc:
+    BOOTLOADER_MODE_FIRMWARE = 1 # :nodoc:
+    BOOTLOADER_MODE_BOOTLOADER_WAIT_FOR_REBOOT = 2 # :nodoc:
+    BOOTLOADER_MODE_FIRMWARE_WAIT_FOR_REBOOT = 3 # :nodoc:
+    BOOTLOADER_MODE_FIRMWARE_WAIT_FOR_ERASE_AND_REBOOT = 4 # :nodoc:
+    BOOTLOADER_STATUS_OK = 0 # :nodoc:
+    BOOTLOADER_STATUS_INVALID_MODE = 1 # :nodoc:
+    BOOTLOADER_STATUS_NO_CHANGE = 2 # :nodoc:
+    BOOTLOADER_STATUS_ENTRY_FUNCTION_NOT_PRESENT = 3 # :nodoc:
+    BOOTLOADER_STATUS_DEVICE_IDENTIFIER_INCORRECT = 4 # :nodoc:
+    BOOTLOADER_STATUS_CRC_MISMATCH = 5 # :nodoc:
+    STATUS_LED_CONFIG_OFF = 0 # :nodoc:
+    STATUS_LED_CONFIG_ON = 1 # :nodoc:
+    STATUS_LED_CONFIG_SHOW_HEARTBEAT = 2 # :nodoc:
+    STATUS_LED_CONFIG_SHOW_STATUS = 3 # :nodoc:
+
+    # 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
+
+      @api_version = [2, 0, 0]
+
+      @response_expected[FUNCTION_SET_MODE] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_GET_MODE] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_READER_REQUEST_TAG_ID] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_READER_GET_TAG_ID_LOW_LEVEL] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_READER_GET_STATE] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_READER_WRITE_NDEF_LOW_LEVEL] = RESPONSE_EXPECTED_TRUE
+      @response_expected[FUNCTION_READER_REQUEST_NDEF] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_READER_READ_NDEF_LOW_LEVEL] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_READER_AUTHENTICATE_MIFARE_CLASSIC_PAGE] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_READER_WRITE_PAGE_LOW_LEVEL] = RESPONSE_EXPECTED_TRUE
+      @response_expected[FUNCTION_READER_REQUEST_PAGE] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_READER_READ_PAGE_LOW_LEVEL] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_CARDEMU_GET_STATE] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_CARDEMU_START_DISCOVERY] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_CARDEMU_WRITE_NDEF_LOW_LEVEL] = RESPONSE_EXPECTED_TRUE
+      @response_expected[FUNCTION_CARDEMU_START_TRANSFER] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_P2P_GET_STATE] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_P2P_START_DISCOVERY] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_P2P_WRITE_NDEF_LOW_LEVEL] = RESPONSE_EXPECTED_TRUE
+      @response_expected[FUNCTION_P2P_START_TRANSFER] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_P2P_READ_NDEF_LOW_LEVEL] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_SET_DETECTION_LED_CONFIG] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_GET_DETECTION_LED_CONFIG] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_GET_SPITFP_ERROR_COUNT] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_SET_BOOTLOADER_MODE] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_GET_BOOTLOADER_MODE] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_SET_WRITE_FIRMWARE_POINTER] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_WRITE_FIRMWARE] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_SET_STATUS_LED_CONFIG] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_GET_STATUS_LED_CONFIG] = 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_UID] = RESPONSE_EXPECTED_FALSE
+      @response_expected[FUNCTION_READ_UID] = RESPONSE_EXPECTED_ALWAYS_TRUE
+      @response_expected[FUNCTION_GET_IDENTITY] = RESPONSE_EXPECTED_ALWAYS_TRUE
+
+      @callback_formats[CALLBACK_READER_STATE_CHANGED] = 'C ?'
+      @callback_formats[CALLBACK_CARDEMU_STATE_CHANGED] = 'C ?'
+      @callback_formats[CALLBACK_P2P_STATE_CHANGED] = 'C ?'
+
+    end
+
+    # Sets the mode. The NFC Bricklet supports four modes:
+    # 
+    # * Off
+    # * Card Emulation (Cardemu): Emulates a tag for other readers
+    # * Peer to Peer (P2P): Exchange data with other readers
+    # * Reader: Reads and writes tags
+    # 
+    # If you change a mode, the Bricklet will reconfigure the hardware for this mode.
+    # Therefore, you can only use functions corresponding to the current mode. For
+    # example, in Reader mode you can only use Reader functions.
+    # 
+    # The default mode is "off".
+    def set_mode(mode)
+      send_request FUNCTION_SET_MODE, [mode], 'C', 0, ''
+    end
+
+    # Returns the mode as set by BrickletNFC#set_mode.
+    def get_mode
+      send_request FUNCTION_GET_MODE, [], '', 1, 'C'
+    end
+
+    # To read or write a tag that is in proximity of the NFC Bricklet you
+    # first have to call this function with the expected tag type as parameter.
+    # It is no problem if you don't know the tag type. You can cycle through
+    # the available tag types until the tag answers the request.
+    # 
+    # Currently the following tag types are supported:
+    # 
+    # * Mifare Classic
+    # * NFC Forum Type 1
+    # * NFC Forum Type 2
+    # * NFC Forum Type 3
+    # * NFC Forum Type 4
+    # 
+    # After you call BrickletNFC#reader_request_tag_id the NFC Bricklet will try to read
+    # the tag ID from the tag. After this process is done the state will change.
+    # You can either register the CALLBACK_READER_STATE_CHANGED callback or you can poll
+    # BrickletNFC#reader_get_state to find out about the state change.
+    # 
+    # If the state changes to *ReaderRequestTagIDError* it means that either there was
+    # no tag present or that the tag has an incompatible type. If the state
+    # changes to *ReaderRequestTagIDReady* it means that a compatible tag was found
+    # and that the tag ID has been saved. You can now read out the tag ID by
+    # calling BrickletNFC#reader_get_tag_id.
+    # 
+    # If two tags are in the proximity of the NFC Bricklet, this
+    # function will cycle through the tags. To select a specific tag you have
+    # to call BrickletNFC#reader_request_tag_id until the correct tag ID is found.
+    # 
+    # In case of any *ReaderError* state the selection is lost and you have to
+    # start again by calling BrickletNFC#reader_request_tag_id.
+    def reader_request_tag_id
+      send_request FUNCTION_READER_REQUEST_TAG_ID, [], '', 0, ''
+    end
+
+    # Returns the tag type and the tag ID. This function can only be called if the
+    # NFC Bricklet is currently in one of the *ReaderReady* states. The returned tag ID
+    # is the tag ID that was saved through the last call of BrickletNFC#reader_request_tag_id.
+    # 
+    # To get the tag ID of a tag the approach is as follows:
+    # 
+    # 1. Call BrickletNFC#reader_request_tag_id
+    # 2. Wait for state to change to *ReaderRequestTagIDReady* (see BrickletNFC#reader_get_state or
+    #    CALLBACK_READER_STATE_CHANGED callback)
+    # 3. Call BrickletNFC#reader_get_tag_id
+    def reader_get_tag_id_low_level
+      send_request FUNCTION_READER_GET_TAG_ID_LOW_LEVEL, [], '', 34, 'C C C32'
+    end
+
+    # Returns the current reader state of the NFC Bricklet.
+    # 
+    # On startup the Bricklet will be in the *ReaderInitialization* state. The
+    # initialization will only take about 20ms. After that it changes to *ReaderIdle*.
+    # 
+    # The Bricklet is also reinitialized if the mode is changed, see BrickletNFC#set_mode.
+    # 
+    # The functions of this Bricklet can be called in the *ReaderIdle* state and all of
+    # the *ReaderReady* and *ReaderError* states.
+    # 
+    # Example: If you call BrickletNFC#reader_request_page, the state will change to
+    # *ReaderRequestPage* until the reading of the page is finished. Then it will change
+    # to either *ReaderRequestPageReady* if it worked or to *ReaderRequestPageError* if it
+    # didn't. If the request worked you can get the page by calling BrickletNFC#reader_read_page.
+    # 
+    # The same approach is used analogously for the other API functions.
+    def reader_get_state
+      send_request FUNCTION_READER_GET_STATE, [], '', 2, 'C ?'
+    end
+
+    # Writes NDEF formated data with a maximum of 255 bytes.
+    # 
+    # This function currently supports NFC Forum Type 2 and 4.
+    # 
+    # The general approach for writing a NDEF message is as follows:
+    # 
+    # 1. Call BrickletNFC#reader_request_tag_id
+    # 2. Wait for state to change to *ReaderRequestTagIDReady* (see
+    #    BrickletNFC#reader_get_state or CALLBACK_READER_STATE_CHANGED callback)
+    # 3. If looking for a specific tag then call BrickletNFC#reader_get_tag_id and check
+    #    if the expected tag was found, if it was not found got back to step 1
+    # 4. Call BrickletNFC#reader_write_ndef with the NDEF message that you want to write
+    # 5. Wait for state to change to *ReaderWriteNDEFReady* (see BrickletNFC#reader_get_state
+    #    or CALLBACK_READER_STATE_CHANGED callback)
+    def reader_write_ndef_low_level(ndef_length, ndef_chunk_offset, ndef_chunk_data)
+      send_request FUNCTION_READER_WRITE_NDEF_LOW_LEVEL, [ndef_length, ndef_chunk_offset, ndef_chunk_data], 'S S C60', 0, ''
+    end
+
+    # Reads NDEF formated data from a tag.
+    # 
+    # This function currently supports NFC Forum Type 1, 2, 3 and 4.
+    # 
+    # The general approach for reading a NDEF message is as follows:
+    # 
+    # 1. Call BrickletNFC#reader_request_tag_id
+    # 2. Wait for state to change to *RequestTagIDReady* (see BrickletNFC#reader_get_state
+    #    or CALLBACK_READER_STATE_CHANGED callback)
+    # 3. If looking for a specific tag then call BrickletNFC#reader_get_tag_id and check if the
+    #    expected tag was found, if it was not found got back to step 1
+    # 4. Call BrickletNFC#reader_request_ndef
+    # 5. Wait for state to change to *ReaderRequestNDEFReady* (see BrickletNFC#reader_get_state
+    #    or CALLBACK_READER_STATE_CHANGED callback)
+    # 6. Call BrickletNFC#reader_read_ndef to retrieve the NDEF message from the buffer
+    def reader_request_ndef
+      send_request FUNCTION_READER_REQUEST_NDEF, [], '', 0, ''
+    end
+
+    # Returns the NDEF data from an internal buffer. To fill the buffer
+    # with a NDEF message you have to call BrickletNFC#reader_request_ndef beforehand.
+    # 
+    # The buffer can have a size of up to 8192 bytes.
+    def reader_read_ndef_low_level
+      send_request FUNCTION_READER_READ_NDEF_LOW_LEVEL, [], '', 64, 'S S C60'
+    end
+
+    # Mifare Classic tags use authentication. If you want to read from or write to
+    # a Mifare Classic page you have to authenticate it beforehand.
+    # Each page can be authenticated with two keys: A (``key_number`` = 0) and B
+    # (``key_number`` = 1). A new Mifare Classic
+    # tag that has not yet been written to can be accessed with key A
+    # and the default key ``[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]``.
+    # 
+    # The approach to read or write a Mifare Classic page is as follows:
+    # 
+    # 1. Call BrickletNFC#reader_request_tag_id
+    # 2. Wait for state to change to *ReaderRequestTagIDReady* (see BrickletNFC#reader_get_state
+    #    or CALLBACK_READER_STATE_CHANGED callback)
+    # 3. If looking for a specific tag then call BrickletNFC#reader_get_tag_id and check if the
+    #    expected tag was found, if it was not found got back to step 1
+    # 4. Call BrickletNFC#reader_authenticate_mifare_classic_page with page and key for the page
+    # 5. Wait for state to change to *ReaderAuthenticatingMifareClassicPageReady* (see
+    #    BrickletNFC#reader_get_state or CALLBACK_READER_STATE_CHANGED callback)
+    # 6. Call BrickletNFC#reader_request_page or BrickletNFC#reader_write_page to read/write page
+    # 
+    # The authentication will always work for one whole sector (4 pages).
+    def reader_authenticate_mifare_classic_page(page, key_number, key)
+      send_request FUNCTION_READER_AUTHENTICATE_MIFARE_CLASSIC_PAGE, [page, key_number, key], 'S C C6', 0, ''
+    end
+
+    # Writes a maximum of 8192 bytes starting from the given page. How many pages are written
+    # depends on the tag type. The page sizes are as follows:
+    # 
+    # * Mifare Classic page size: 16 byte
+    # * NFC Forum Type 1 page size: 8 byte
+    # * NFC Forum Type 2 page size: 4 byte
+    # * NFC Forum Type 3 page size: 16 byte
+    # * NFC Forum Type 4: No pages, page = file selection (CC or NDEF, see below)
+    # 
+    # The general approach for writing to a tag is as follows:
+    # 
+    # 1. Call BrickletNFC#reader_request_tag_id
+    # 2. Wait for state to change to *ReaderRequestTagIDReady* (see BrickletNFC#reader_get_state or
+    #    CALLBACK_READER_STATE_CHANGED callback)
+    # 3. If looking for a specific tag then call BrickletNFC#reader_get_tag_id and check if the
+    #    expected tag was found, if it was not found got back to step 1
+    # 4. Call BrickletNFC#reader_write_page with page number and data
+    # 5. Wait for state to change to *ReaderWritePageReady* (see BrickletNFC#reader_get_state or
+    #    CALLBACK_READER_STATE_CHANGED callback)
+    # 
+    # If you use a Mifare Classic tag you have to authenticate a page before you
+    # can write to it. See BrickletNFC#reader_authenticate_mifare_classic_page.
+    # 
+    # NFC Forum Type 4 tags are not organized into pages but different files. We currently
+    # support two files: Capability Container file (CC) and NDEF file.
+    # 
+    # Choose CC by setting page to 3 or NDEF by setting page to 4.
+    def reader_write_page_low_level(page, data_length, data_chunk_offset, data_chunk_data)
+      send_request FUNCTION_READER_WRITE_PAGE_LOW_LEVEL, [page, data_length, data_chunk_offset, data_chunk_data], 'S S S C58', 0, ''
+    end
+
+    # Reads a maximum of 8192 bytes starting from the given page and stores them into a buffer.
+    # The buffer can then be read out with BrickletNFC#reader_read_page.
+    # How many pages are read depends on the tag type. The page sizes are
+    # as follows:
+    # 
+    # * Mifare Classic page size: 16 byte
+    # * NFC Forum Type 1 page size: 8 byte
+    # * NFC Forum Type 2 page size: 4 byte 
+    # * NFC Forum Type 3 page size: 16 byte
+    # * NFC Forum Type 4: No pages, page = file selection (CC or NDEF, see below)
+    # 
+    # The general approach for reading a tag is as follows:
+    # 
+    # 1. Call BrickletNFC#reader_request_tag_id
+    # 2. Wait for state to change to *RequestTagIDReady* (see BrickletNFC#reader_get_state
+    #    or CALLBACK_READER_STATE_CHANGED callback)
+    # 3. If looking for a specific tag then call BrickletNFC#reader_get_tag_id and check if the
+    #    expected tag was found, if it was not found got back to step 1
+    # 4. Call BrickletNFC#reader_request_page with page number
+    # 5. Wait for state to change to *ReaderRequestPageReady* (see BrickletNFC#reader_get_state
+    #    or CALLBACK_READER_STATE_CHANGED callback)
+    # 6. Call BrickletNFC#reader_read_page to retrieve the page from the buffer
+    # 
+    # If you use a Mifare Classic tag you have to authenticate a page before you
+    # can read it. See BrickletNFC#reader_authenticate_mifare_classic_page.
+    # 
+    # NFC Forum Type 4 tags are not organized into pages but different files. We currently
+    # support two files: Capability Container file (CC) and NDEF file.
+    # 
+    # Choose CC by setting page to 3 or NDEF by setting page to 4.
+    def reader_request_page(page, length)
+      send_request FUNCTION_READER_REQUEST_PAGE, [page, length], 'S S', 0, ''
+    end
+
+    # Returns the page data from an internal buffer. To fill the buffer
+    # with specific pages you have to call BrickletNFC#reader_request_page beforehand.
+    # 
+    # The buffer can have a size of up to 8192 bytes.
+    def reader_read_page_low_level
+      send_request FUNCTION_READER_READ_PAGE_LOW_LEVEL, [], '', 64, 'S S C60'
+    end
+
+    # Returns the current cardemu state of the NFC Bricklet.
+    # 
+    # On startup the Bricklet will be in the *CardemuInitialization* state. The
+    # initialization will only take about 20ms. After that it changes to *CardemuIdle*.
+    # 
+    # The Bricklet is also reinitialized if the mode is changed, see BrickletNFC#set_mode.
+    # 
+    # The functions of this Bricklet can be called in the *CardemuIdle* state and all of
+    # the *CardemuReady* and *CardemuError* states.
+    # 
+    # Example: If you call BrickletNFC#cardemu_start_discovery, the state will change to
+    # *CardemuDiscover* until the discovery is finished. Then it will change
+    # to either *CardemuDiscoverReady* if it worked or to *CardemuDiscoverError* if it
+    # didn't.
+    # 
+    # The same approach is used analogously for the other API functions.
+    def cardemu_get_state
+      send_request FUNCTION_CARDEMU_GET_STATE, [], '', 2, 'C ?'
+    end
+
+    # Starts the discovery process. If you call this function while a NFC
+    # reader device is near to the NFC Bricklet the state will change from
+    # *CardemuDiscovery* to *CardemuDiscoveryReady*.
+    # 
+    # If no NFC reader device can be found or if there is an error during
+    # discovery the cardemu state will change to *CardemuDiscoveryError*. In this case you
+    # have to restart the discovery process.
+    # 
+    # If the cardemu state changes to *CardemuDiscoveryReady* you can start the NDEF message
+    # transfer with BrickletNFC#cardemu_write_ndef and BrickletNFC#cardemu_start_transfer.
+    def cardemu_start_discovery
+      send_request FUNCTION_CARDEMU_START_DISCOVERY, [], '', 0, ''
+    end
+
+    # Writes the NDEF messages that is to be transferred to the NFC peer.
+    # 
+    # The maximum supported NDEF message size in Cardemu mode is 255 byte.
+    # 
+    # You can call this function at any time in Cardemu mode. The internal buffer
+    # will not be overwritten until you call this function again or change the
+    # mode.
+    def cardemu_write_ndef_low_level(ndef_length, ndef_chunk_offset, ndef_chunk_data)
+      send_request FUNCTION_CARDEMU_WRITE_NDEF_LOW_LEVEL, [ndef_length, ndef_chunk_offset, ndef_chunk_data], 'S S C60', 0, ''
+    end
+
+    # You can start the transfer of a NDEF message if the cardemu state is *CardemuDiscoveryReady*.
+    # 
+    # Before you call this function to start a write transfer, the NDEF message that
+    # is to be transferred has to be written via BrickletNFC#cardemu_write_ndef first.
+    # 
+    # After you call this function the state will change to *CardemuTransferNDEF*. It will
+    # change to *CardemuTransferNDEFReady* if the transfer was successful or
+    # *CardemuTransferNDEFError* if it wasn't.
+    def cardemu_start_transfer(transfer)
+      send_request FUNCTION_CARDEMU_START_TRANSFER, [transfer], 'C', 0, ''
+    end
+
+    # Returns the current P2P state of the NFC Bricklet.
+    # 
+    # On startup the Bricklet will be in the *P2PInitialization* state. The
+    # initialization will only take about 20ms. After that it changes to *P2PIdle*.
+    # 
+    # The Bricklet is also reinitialized if the mode is changed, see BrickletNFC#set_mode.
+    # 
+    # The functions of this Bricklet can be called in the *P2PIdle* state and all of
+    # the *P2PReady* and *P2PError* states.
+    # 
+    # Example: If you call BrickletNFC#p2p_start_discovery, the state will change to
+    # *P2PDiscover* until the discovery is finished. Then it will change
+    # to either P2PDiscoverReady* if it worked or to *P2PDiscoverError* if it
+    # didn't.
+    # 
+    # The same approach is used analogously for the other API functions.
+    def p2p_get_state
+      send_request FUNCTION_P2P_GET_STATE, [], '', 2, 'C ?'
+    end
+
+    # Starts the discovery process. If you call this function while another NFC
+    # P2P enabled device is near to the NFC Bricklet the state will change from
+    # *P2PDiscovery* to *P2PDiscoveryReady*.
+    # 
+    # If no NFC P2P enabled device can be found or if there is an error during
+    # discovery the P2P state will change to *P2PDiscoveryError*. In this case you
+    # have to restart the discovery process.
+    # 
+    # If the P2P state changes to *P2PDiscoveryReady* you can start the NDEF message
+    # transfer with BrickletNFC#p2p_start_transfer.
+    def p2p_start_discovery
+      send_request FUNCTION_P2P_START_DISCOVERY, [], '', 0, ''
+    end
+
+    # Writes the NDEF messages that is to be transferred to the NFC peer.
+    # 
+    # The maximum supported NDEF message size for P2P transfer is 255 byte.
+    # 
+    # You can call this function at any time in P2P mode. The internal buffer
+    # will not be overwritten until you call this function again, change the
+    # mode or use P2P to read an NDEF messages.
+    def p2p_write_ndef_low_level(ndef_length, ndef_chunk_offset, ndef_chunk_data)
+      send_request FUNCTION_P2P_WRITE_NDEF_LOW_LEVEL, [ndef_length, ndef_chunk_offset, ndef_chunk_data], 'S S C60', 0, ''
+    end
+
+    # You can start the transfer of a NDEF message if the P2P state is *P2PDiscoveryReady*.
+    # 
+    # Before you call this function to start a write transfer, the NDEF message that
+    # is to be transferred has to be written via BrickletNFC#p2p_write_ndef first.
+    # 
+    # After you call this function the P2P state will change to *P2PTransferNDEF*. It will
+    # change to *P2PTransferNDEFReady* if the transfer was successfull or
+    # *P2PTransferNDEFError* if it wasn't.
+    # 
+    # If you started a write transfer you are now done. If you started a read transfer
+    # you can now use BrickletNFC#p2p_read_ndef to read the NDEF message that was written
+    # by the NFC peer.
+    def p2p_start_transfer(transfer)
+      send_request FUNCTION_P2P_START_TRANSFER, [transfer], 'C', 0, ''
+    end
+
+    # Returns the NDEF message that was written by a NFC peer in NFC P2P mode.
+    # The maximum NDEF length is 8192 byte.
+    # 
+    # The NDEF message is ready if you called BrickletNFC#p2p_start_transfer with a
+    # read transfer and the P2P state changed to *P2PTransferNDEFReady*.
+    def p2p_read_ndef_low_level
+      send_request FUNCTION_P2P_READ_NDEF_LOW_LEVEL, [], '', 64, 'S S C60'
+    end
+
+    # Sets the detection LED configuration. By default the LED shows
+    # if a card/reader is detected.
+    # 
+    # You can also turn the LED permanently on/off or show a heartbeat.
+    # 
+    # If the Bricklet is in bootloader mode, the LED is off.
+    def set_detection_led_config(config)
+      send_request FUNCTION_SET_DETECTION_LED_CONFIG, [config], 'C', 0, ''
+    end
+
+    # Returns the configuration as set by BrickletNFC#set_detection_led_config
+    def get_detection_led_config
+      send_request FUNCTION_GET_DETECTION_LED_CONFIG, [], '', 1, 'C'
+    end
+
+    # Returns the error count for the communication between Brick and Bricklet.
+    # 
+    # The errors are divided into
+    # 
+    # * ack checksum errors,
+    # * message checksum errors,
+    # * frameing errors and
+    # * overflow errors.
+    # 
+    # The errors counts are for errors that occur on the Bricklet side. All
+    # Bricks have a similar function that returns the errors on the Brick side.
+    def get_spitfp_error_count
+      send_request FUNCTION_GET_SPITFP_ERROR_COUNT, [], '', 16, 'L L L L'
+    end
+
+    # Sets the bootloader mode and returns the status after the requested
+    # mode change was instigated.
+    # 
+    # You can change from bootloader mode to firmware mode and vice versa. A change
+    # from bootloader mode to firmware mode will only take place if the entry function,
+    # device identifier und crc are present and correct.
+    # 
+    # This function is used by Brick Viewer during flashing. It should not be
+    # necessary to call it in a normal user program.
+    def set_bootloader_mode(mode)
+      send_request FUNCTION_SET_BOOTLOADER_MODE, [mode], 'C', 1, 'C'
+    end
+
+    # Returns the current bootloader mode, see BrickletNFC#set_bootloader_mode.
+    def get_bootloader_mode
+      send_request FUNCTION_GET_BOOTLOADER_MODE, [], '', 1, 'C'
+    end
+
+    # Sets the firmware pointer for BrickletNFC#write_firmware. The pointer has
+    # to be increased by chunks of size 64. The data is written to flash
+    # every 4 chunks (which equals to one page of size 256).
+    # 
+    # This function is used by Brick Viewer during flashing. It should not be
+    # necessary to call it in a normal user program.
+    def set_write_firmware_pointer(pointer)
+      send_request FUNCTION_SET_WRITE_FIRMWARE_POINTER, [pointer], 'L', 0, ''
+    end
+
+    # Writes 64 Bytes of firmware at the position as written by
+    # BrickletNFC#set_write_firmware_pointer before. The firmware is written
+    # to flash every 4 chunks.
+    # 
+    # You can only write firmware in bootloader mode.
+    # 
+    # This function is used by Brick Viewer during flashing. It should not be
+    # necessary to call it in a normal user program.
+    def write_firmware(data)
+      send_request FUNCTION_WRITE_FIRMWARE, [data], 'C64', 1, 'C'
+    end
+
+    # Sets the status LED configuration. By default the LED shows
+    # communication traffic between Brick and Bricklet, it flickers once
+    # for every 10 received data packets.
+    # 
+    # You can also turn the LED permanently on/off or show a heartbeat.
+    # 
+    # If the Bricklet is in bootloader mode, the LED is will show heartbeat by default.
+    def set_status_led_config(config)
+      send_request FUNCTION_SET_STATUS_LED_CONFIG, [config], 'C', 0, ''
+    end
+
+    # Returns the configuration as set by BrickletNFC#set_status_led_config
+    def get_status_led_config
+      send_request FUNCTION_GET_STATUS_LED_CONFIG, [], '', 1, 'C'
+    end
+
+    # Returns the temperature in °C 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 bad
+    # accuracy. Practically it is only useful as an indicator for
+    # temperature changes.
+    def get_chip_temperature
+      send_request FUNCTION_GET_CHIP_TEMPERATURE, [], '', 2, 's'
+    end
+
+    # Calling this function will reset the Bricklet. All configurations
+    # will be lost.
+    # 
+    # After a reset you have to create new device objects,
+    # calling functions on the existing ones will result in
+    # undefined behavior!
+    def reset
+      send_request FUNCTION_RESET, [], '', 0, ''
+    end
+
+    # Writes a new UID into flash. If you want to set a new UID
+    # you have to decode the Base58 encoded UID string into an
+    # integer first.
+    # 
+    # We recommend that you use Brick Viewer to change the UID.
+    def write_uid(uid)
+      send_request FUNCTION_WRITE_UID, [uid], 'L', 0, ''
+    end
+
+    # Returns the current UID as an integer. Encode as
+    # Base58 to get the usual string version.
+    def read_uid
+      send_request FUNCTION_READ_UID, [], '', 4, 'L'
+    end
+
+    # Returns the UID, the UID where the Bricklet is connected to,
+    # the position, the hardware and firmware version as well as the
+    # device identifier.
+    # 
+    # The position can be 'a', 'b', 'c' or 'd'.
+    # 
+    # 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'
+    end
+
+    # Returns the tag type and the tag ID. This function can only be called if the
+    # NFC Bricklet is currently in one of the *ReaderReady* states. The returned tag ID
+    # is the tag ID that was saved through the last call of BrickletNFC#reader_request_tag_id.
+    # 
+    # To get the tag ID of a tag the approach is as follows:
+    # 
+    # 1. Call BrickletNFC#reader_request_tag_id
+    # 2. Wait for state to change to *ReaderRequestTagIDReady* (see BrickletNFC#reader_get_state or
+    #    CALLBACK_READER_STATE_CHANGED callback)
+    # 3. Call BrickletNFC#reader_get_tag_id
+    def reader_get_tag_id
+      ret = reader_get_tag_id_low_level
+
+      [ret[0], ret[2][0, ret[1]]]
+    end
+
+    # Writes NDEF formated data with a maximum of 255 bytes.
+    # 
+    # This function currently supports NFC Forum Type 2 and 4.
+    # 
+    # The general approach for writing a NDEF message is as follows:
+    # 
+    # 1. Call BrickletNFC#reader_request_tag_id
+    # 2. Wait for state to change to *ReaderRequestTagIDReady* (see
+    #    BrickletNFC#reader_get_state or CALLBACK_READER_STATE_CHANGED callback)
+    # 3. If looking for a specific tag then call BrickletNFC#reader_get_tag_id and check
+    #    if the expected tag was found, if it was not found got back to step 1
+    # 4. Call BrickletNFC#reader_write_ndef with the NDEF message that you want to write
+    # 5. Wait for state to change to *ReaderWriteNDEFReady* (see BrickletNFC#reader_get_state
+    #    or CALLBACK_READER_STATE_CHANGED callback)
+    def reader_write_ndef(ndef)
+      if ndef.length > 65535
+        raise ArgumentError, 'NDEF can be at most 65535 items long'
+      end
+
+      ndef_length = ndef.length
+      ndef_chunk_offset = 0
+
+      if ndef_length == 0
+        ndef_chunk_data = [0] * 60
+        ret = reader_write_ndef_low_level ndef_length, ndef_chunk_offset, ndef_chunk_data
+      else
+        ret = nil # assigned in block
+
+        @stream_mutex.synchronize {
+          while ndef_chunk_offset < ndef_length
+            ndef_chunk_data = ndef[ndef_chunk_offset, 60]
+
+            if ndef_chunk_data.length < 60
+              ndef_chunk_data += [0] * (60 - ndef_chunk_data.length)
+            end
+
+            ret = reader_write_ndef_low_level ndef_length, ndef_chunk_offset, ndef_chunk_data
+            ndef_chunk_offset += 60
+          end
+        }
+      end
+
+      ret
+    end
+
+    # Returns the NDEF data from an internal buffer. To fill the buffer
+    # with a NDEF message you have to call BrickletNFC#reader_request_ndef beforehand.
+    # 
+    # The buffer can have a size of up to 8192 bytes.
+    def reader_read_ndef
+      ndef_length = nil # assigned in block
+      ndef_data = nil # assigned in block
+
+      @stream_mutex.synchronize {
+        ret = reader_read_ndef_low_level
+        ndef_length = ret[0]
+        ndef_chunk_offset = ret[1]
+        ndef_out_of_sync = ndef_chunk_offset != 0
+        ndef_data = ret[2]
+
+        while not ndef_out_of_sync and ndef_data.length < ndef_length
+          ret = reader_read_ndef_low_level
+          ndef_length = ret[0]
+          ndef_chunk_offset = ret[1]
+          ndef_out_of_sync = ndef_chunk_offset != ndef_data.length
+          ndef_data += ret[2]
+        end
+
+        if ndef_out_of_sync # discard remaining stream to bring it back in-sync
+          while ndef_chunk_offset + 60 < ndef_length
+            ret = reader_read_ndef_low_level
+            ndef_length = ret[0]
+            ndef_chunk_offset = ret[1]
+          end
+
+          raise StreamOutOfSyncException, 'NDEF stream is out-of-sync'
+        end
+      }
+
+      ndef_data[0, ndef_length]
+    end
+
+    # Writes a maximum of 8192 bytes starting from the given page. How many pages are written
+    # depends on the tag type. The page sizes are as follows:
+    # 
+    # * Mifare Classic page size: 16 byte
+    # * NFC Forum Type 1 page size: 8 byte
+    # * NFC Forum Type 2 page size: 4 byte
+    # * NFC Forum Type 3 page size: 16 byte
+    # * NFC Forum Type 4: No pages, page = file selection (CC or NDEF, see below)
+    # 
+    # The general approach for writing to a tag is as follows:
+    # 
+    # 1. Call BrickletNFC#reader_request_tag_id
+    # 2. Wait for state to change to *ReaderRequestTagIDReady* (see BrickletNFC#reader_get_state or
+    #    CALLBACK_READER_STATE_CHANGED callback)
+    # 3. If looking for a specific tag then call BrickletNFC#reader_get_tag_id and check if the
+    #    expected tag was found, if it was not found got back to step 1
+    # 4. Call BrickletNFC#reader_write_page with page number and data
+    # 5. Wait for state to change to *ReaderWritePageReady* (see BrickletNFC#reader_get_state or
+    #    CALLBACK_READER_STATE_CHANGED callback)
+    # 
+    # If you use a Mifare Classic tag you have to authenticate a page before you
+    # can write to it. See BrickletNFC#reader_authenticate_mifare_classic_page.
+    # 
+    # NFC Forum Type 4 tags are not organized into pages but different files. We currently
+    # support two files: Capability Container file (CC) and NDEF file.
+    # 
+    # Choose CC by setting page to 3 or NDEF by setting page to 4.
+    def reader_write_page(page, data)
+      if data.length > 65535
+        raise ArgumentError, 'Data can be at most 65535 items long'
+      end
+
+      data_length = data.length
+      data_chunk_offset = 0
+
+      if data_length == 0
+        data_chunk_data = [0] * 58
+        ret = reader_write_page_low_level page, data_length, data_chunk_offset, data_chunk_data
+      else
+        ret = nil # assigned in block
+
+        @stream_mutex.synchronize {
+          while data_chunk_offset < data_length
+            data_chunk_data = data[data_chunk_offset, 58]
+
+            if data_chunk_data.length < 58
+              data_chunk_data += [0] * (58 - data_chunk_data.length)
+            end
+
+            ret = reader_write_page_low_level page, data_length, data_chunk_offset, data_chunk_data
+            data_chunk_offset += 58
+          end
+        }
+      end
+
+      ret
+    end
+
+    # Returns the page data from an internal buffer. To fill the buffer
+    # with specific pages you have to call BrickletNFC#reader_request_page beforehand.
+    # 
+    # The buffer can have a size of up to 8192 bytes.
+    def reader_read_page
+      data_length = nil # assigned in block
+      data_data = nil # assigned in block
+
+      @stream_mutex.synchronize {
+        ret = reader_read_page_low_level
+        data_length = ret[0]
+        data_chunk_offset = ret[1]
+        data_out_of_sync = data_chunk_offset != 0
+        data_data = ret[2]
+
+        while not data_out_of_sync and data_data.length < data_length
+          ret = reader_read_page_low_level
+          data_length = ret[0]
+          data_chunk_offset = ret[1]
+          data_out_of_sync = data_chunk_offset != data_data.length
+          data_data += ret[2]
+        end
+
+        if data_out_of_sync # discard remaining stream to bring it back in-sync
+          while data_chunk_offset + 60 < data_length
+            ret = reader_read_page_low_level
+            data_length = ret[0]
+            data_chunk_offset = ret[1]
+          end
+
+          raise StreamOutOfSyncException, 'Data stream is out-of-sync'
+        end
+      }
+
+      data_data[0, data_length]
+    end
+
+    # Writes the NDEF messages that is to be transferred to the NFC peer.
+    # 
+    # The maximum supported NDEF message size in Cardemu mode is 255 byte.
+    # 
+    # You can call this function at any time in Cardemu mode. The internal buffer
+    # will not be overwritten until you call this function again or change the
+    # mode.
+    def cardemu_write_ndef(ndef)
+      if ndef.length > 65535
+        raise ArgumentError, 'NDEF can be at most 65535 items long'
+      end
+
+      ndef_length = ndef.length
+      ndef_chunk_offset = 0
+
+      if ndef_length == 0
+        ndef_chunk_data = [0] * 60
+        ret = cardemu_write_ndef_low_level ndef_length, ndef_chunk_offset, ndef_chunk_data
+      else
+        ret = nil # assigned in block
+
+        @stream_mutex.synchronize {
+          while ndef_chunk_offset < ndef_length
+            ndef_chunk_data = ndef[ndef_chunk_offset, 60]
+
+            if ndef_chunk_data.length < 60
+              ndef_chunk_data += [0] * (60 - ndef_chunk_data.length)
+            end
+
+            ret = cardemu_write_ndef_low_level ndef_length, ndef_chunk_offset, ndef_chunk_data
+            ndef_chunk_offset += 60
+          end
+        }
+      end
+
+      ret
+    end
+
+    # Writes the NDEF messages that is to be transferred to the NFC peer.
+    # 
+    # The maximum supported NDEF message size for P2P transfer is 255 byte.
+    # 
+    # You can call this function at any time in P2P mode. The internal buffer
+    # will not be overwritten until you call this function again, change the
+    # mode or use P2P to read an NDEF messages.
+    def p2p_write_ndef(ndef)
+      if ndef.length > 65535
+        raise ArgumentError, 'NDEF can be at most 65535 items long'
+      end
+
+      ndef_length = ndef.length
+      ndef_chunk_offset = 0
+
+      if ndef_length == 0
+        ndef_chunk_data = [0] * 60
+        ret = p2p_write_ndef_low_level ndef_length, ndef_chunk_offset, ndef_chunk_data
+      else
+        ret = nil # assigned in block
+
+        @stream_mutex.synchronize {
+          while ndef_chunk_offset < ndef_length
+            ndef_chunk_data = ndef[ndef_chunk_offset, 60]
+
+            if ndef_chunk_data.length < 60
+              ndef_chunk_data += [0] * (60 - ndef_chunk_data.length)
+            end
+
+            ret = p2p_write_ndef_low_level ndef_length, ndef_chunk_offset, ndef_chunk_data
+            ndef_chunk_offset += 60
+          end
+        }
+      end
+
+      ret
+    end
+
+    # Returns the NDEF message that was written by a NFC peer in NFC P2P mode.
+    # The maximum NDEF length is 8192 byte.
+    # 
+    # The NDEF message is ready if you called BrickletNFC#p2p_start_transfer with a
+    # read transfer and the P2P state changed to *P2PTransferNDEFReady*.
+    def p2p_read_ndef
+      ndef_length = nil # assigned in block
+      ndef_data = nil # assigned in block
+
+      @stream_mutex.synchronize {
+        ret = p2p_read_ndef_low_level
+        ndef_length = ret[0]
+        ndef_chunk_offset = ret[1]
+        ndef_out_of_sync = ndef_chunk_offset != 0
+        ndef_data = ret[2]
+
+        while not ndef_out_of_sync and ndef_data.length < ndef_length
+          ret = p2p_read_ndef_low_level
+          ndef_length = ret[0]
+          ndef_chunk_offset = ret[1]
+          ndef_out_of_sync = ndef_chunk_offset != ndef_data.length
+          ndef_data += ret[2]
+        end
+
+        if ndef_out_of_sync # discard remaining stream to bring it back in-sync
+          while ndef_chunk_offset + 60 < ndef_length
+            ret = p2p_read_ndef_low_level
+            ndef_length = ret[0]
+            ndef_chunk_offset = ret[1]
+          end
+
+          raise StreamOutOfSyncException, 'NDEF stream is out-of-sync'
+        end
+      }
+
+      ndef_data[0, ndef_length]
+    end
+
+    # Registers a callback with ID <tt>id</tt> to the block <tt>block</tt>.
+    def register_callback(id, &block)
+      callback = block
+      @registered_callbacks[id] = callback
+    end
+  end
+end