Merge branch 'bbilger-master'

Former-commit-id: 4d5a4f9f2e867ab10ed0c483ecc3fd72c9be3a8c

.gitignore

@@ -1,3 +1,5 @@
 /*.user
 /build
 /build-x86
+.DS_Store
+

CMakeLists.txt

@@ -16,6 +16,9 @@ message(STATUS "ENABLE_SPIDEV = " ${ENABLE_SPIDEV})
 option(ENABLE_V4L2 "Enable the V4L2 grabber" ON)
 message(STATUS "ENABLE_V4L2 = " ${ENABLE_V4L2})
 
+option(ENABLE_TINKERFORGE "Enable the TINKERFORGE device" OFF)
+message(STATUS "ENABLE_TINKERFORGE = " ${ENABLE_TINKERFORGE})
+
 # Createt the configuration file
 # configure a header file to pass some of the CMake settings
 # to the source code
@@ -62,6 +65,10 @@ set(CMAKE_FIND_LIBRARY_SUFFIXES_OLD)
 find_package(libusb-1.0 REQUIRED)
 find_package(Threads REQUIRED)
 
+if (ENABLE_TINKERFORGE)
+	#find_package(libtinkerforge-1.0 REQUIRED)
+endif (ENABLE_TINKERFORGE)
+
 include(${QT_USE_FILE})
 add_definitions(${QT_DEFINITIONS})
 # TODO[TvdZ]: This linking directory should only be added if we are cross compiling

HyperionConfig.h.in

@@ -8,3 +8,6 @@
 
 // Define to enable the spi-device
 #cmakedefine ENABLE_SPIDEV
+
+// Define to enable the spi-device
+#cmakedefine ENABLE_TINKERFORGE

dependencies/build/CMakeLists.txt

@@ -1,5 +1,6 @@
 
-add_subdirectory(jsoncpp)
 add_subdirectory(getoptPlusPlus)
-add_subdirectory(serial)
 add_subdirectory(hidapi)
+add_subdirectory(jsoncpp)
+add_subdirectory(serial)
+add_subdirectory(tinkerforge)

dependencies/build/tinkerforge/CMakeLists.txt

@@ -0,0 +1,14 @@
+project(tinkerforge)
+
+# define the current source/header path
+set(CURRENT_HEADER_DIR ${CMAKE_SOURCE_DIR}/dependencies/include/tinkerforge)
+set(CURRENT_SOURCE_DIR ${CMAKE_SOURCE_DIR}/dependencies/build/tinkerforge)
+
+include_directories(${CURRENT_HEADER_DIR})
+
+add_library(tinkerforge
+		${CURRENT_HEADER_DIR}/bricklet_led_strip.h
+		${CURRENT_HEADER_DIR}/ip_connection.h
+
+		${CURRENT_SOURCE_DIR}/bricklet_led_strip.c
+		${CURRENT_SOURCE_DIR}/ip_connection.c)

dependencies/build/tinkerforge/bricklet_led_strip.c

@@ -0,0 +1,373 @@
+/* ***********************************************************
+ * This file was automatically generated on 2013-12-19.      *
+ *                                                           *
+ * Bindings Version 2.0.13                                    *
+ *                                                           *
+ * 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 generator git on tinkerforge.com                   *
+ *************************************************************/
+
+
+#define IPCON_EXPOSE_INTERNALS
+
+#include "bricklet_led_strip.h"
+
+#include <string.h>
+
+
+
+typedef void (*FrameRenderedCallbackFunction)(uint16_t, void *);
+
+#if defined _MSC_VER || defined __BORLANDC__
+	#pragma pack(push)
+	#pragma pack(1)
+	#define ATTRIBUTE_PACKED
+#elif defined __GNUC__
+	#ifdef _WIN32
+		// workaround struct packing bug in GCC 4.7 on Windows
+		// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52991
+		#define ATTRIBUTE_PACKED __attribute__((gcc_struct, packed))
+	#else
+		#define ATTRIBUTE_PACKED __attribute__((packed))
+	#endif
+#else
+	#error unknown compiler, do not know how to enable struct packing
+#endif
+
+typedef struct {
+	PacketHeader header;
+	uint16_t index;
+	uint8_t length;
+	uint8_t r[16];
+	uint8_t g[16];
+	uint8_t b[16];
+} ATTRIBUTE_PACKED SetRGBValues_;
+
+typedef struct {
+	PacketHeader header;
+	uint16_t index;
+	uint8_t length;
+} ATTRIBUTE_PACKED GetRGBValues_;
+
+typedef struct {
+	PacketHeader header;
+	uint8_t r[16];
+	uint8_t g[16];
+	uint8_t b[16];
+} ATTRIBUTE_PACKED GetRGBValuesResponse_;
+
+typedef struct {
+	PacketHeader header;
+	uint16_t duration;
+} ATTRIBUTE_PACKED SetFrameDuration_;
+
+typedef struct {
+	PacketHeader header;
+} ATTRIBUTE_PACKED GetFrameDuration_;
+
+typedef struct {
+	PacketHeader header;
+	uint16_t duration;
+} ATTRIBUTE_PACKED GetFrameDurationResponse_;
+
+typedef struct {
+	PacketHeader header;
+} ATTRIBUTE_PACKED GetSupplyVoltage_;
+
+typedef struct {
+	PacketHeader header;
+	uint16_t voltage;
+} ATTRIBUTE_PACKED GetSupplyVoltageResponse_;
+
+typedef struct {
+	PacketHeader header;
+	uint16_t length;
+} ATTRIBUTE_PACKED FrameRenderedCallback_;
+
+typedef struct {
+	PacketHeader header;
+	uint32_t frequency;
+} ATTRIBUTE_PACKED SetClockFrequency_;
+
+typedef struct {
+	PacketHeader header;
+} ATTRIBUTE_PACKED GetClockFrequency_;
+
+typedef struct {
+	PacketHeader header;
+	uint32_t frequency;
+} ATTRIBUTE_PACKED GetClockFrequencyResponse_;
+
+typedef struct {
+	PacketHeader header;
+} ATTRIBUTE_PACKED GetIdentity_;
+
+typedef struct {
+	PacketHeader header;
+	char uid[8];
+	char connected_uid[8];
+	char position;
+	uint8_t hardware_version[3];
+	uint8_t firmware_version[3];
+	uint16_t device_identifier;
+} ATTRIBUTE_PACKED GetIdentityResponse_;
+
+#if defined _MSC_VER || defined __BORLANDC__
+	#pragma pack(pop)
+#endif
+#undef ATTRIBUTE_PACKED
+
+static void led_strip_callback_wrapper_frame_rendered(DevicePrivate *device_p, Packet *packet) {
+	FrameRenderedCallbackFunction callback_function;
+	void *user_data = device_p->registered_callback_user_data[LED_STRIP_CALLBACK_FRAME_RENDERED];
+	FrameRenderedCallback_ *callback = (FrameRenderedCallback_ *)packet;
+	*(void **)(&callback_function) = device_p->registered_callbacks[LED_STRIP_CALLBACK_FRAME_RENDERED];
+
+	if (callback_function == NULL) {
+		return;
+	}
+
+	callback->length = leconvert_uint16_from(callback->length);
+
+	callback_function(callback->length, user_data);
+}
+
+void led_strip_create(LEDStrip *led_strip, const char *uid, IPConnection *ipcon) {
+	DevicePrivate *device_p;
+
+	device_create(led_strip, uid, ipcon->p, 2, 0, 1);
+
+	device_p = led_strip->p;
+
+	device_p->response_expected[LED_STRIP_FUNCTION_SET_RGB_VALUES] = DEVICE_RESPONSE_EXPECTED_FALSE;
+	device_p->response_expected[LED_STRIP_FUNCTION_GET_RGB_VALUES] = DEVICE_RESPONSE_EXPECTED_ALWAYS_TRUE;
+	device_p->response_expected[LED_STRIP_FUNCTION_SET_FRAME_DURATION] = DEVICE_RESPONSE_EXPECTED_FALSE;
+	device_p->response_expected[LED_STRIP_FUNCTION_GET_FRAME_DURATION] = DEVICE_RESPONSE_EXPECTED_ALWAYS_TRUE;
+	device_p->response_expected[LED_STRIP_FUNCTION_GET_SUPPLY_VOLTAGE] = DEVICE_RESPONSE_EXPECTED_ALWAYS_TRUE;
+	device_p->response_expected[LED_STRIP_CALLBACK_FRAME_RENDERED] = DEVICE_RESPONSE_EXPECTED_ALWAYS_FALSE;
+	device_p->response_expected[LED_STRIP_FUNCTION_SET_CLOCK_FREQUENCY] = DEVICE_RESPONSE_EXPECTED_FALSE;
+	device_p->response_expected[LED_STRIP_FUNCTION_GET_CLOCK_FREQUENCY] = DEVICE_RESPONSE_EXPECTED_ALWAYS_TRUE;
+	device_p->response_expected[LED_STRIP_FUNCTION_GET_IDENTITY] = DEVICE_RESPONSE_EXPECTED_ALWAYS_TRUE;
+
+	device_p->callback_wrappers[LED_STRIP_CALLBACK_FRAME_RENDERED] = led_strip_callback_wrapper_frame_rendered;
+}
+
+void led_strip_destroy(LEDStrip *led_strip) {
+	device_destroy(led_strip);
+}
+
+int led_strip_get_response_expected(LEDStrip *led_strip, uint8_t function_id, bool *ret_response_expected) {
+	return device_get_response_expected(led_strip->p, function_id, ret_response_expected);
+}
+
+int led_strip_set_response_expected(LEDStrip *led_strip, uint8_t function_id, bool response_expected) {
+	return device_set_response_expected(led_strip->p, function_id, response_expected);
+}
+
+int led_strip_set_response_expected_all(LEDStrip *led_strip, bool response_expected) {
+	return device_set_response_expected_all(led_strip->p, response_expected);
+}
+
+void led_strip_register_callback(LEDStrip *led_strip, uint8_t id, void *callback, void *user_data) {
+	device_register_callback(led_strip->p, id, callback, user_data);
+}
+
+int led_strip_get_api_version(LEDStrip *led_strip, uint8_t ret_api_version[3]) {
+	return device_get_api_version(led_strip->p, ret_api_version);
+}
+
+int led_strip_set_rgb_values(LEDStrip *led_strip, uint16_t index, uint8_t length, uint8_t r[16], uint8_t g[16], uint8_t b[16]) {
+	DevicePrivate *device_p = led_strip->p;
+	SetRGBValues_ request;
+	int ret;
+
+	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_SET_RGB_VALUES, device_p->ipcon_p, device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	request.index = leconvert_uint16_to(index);
+	request.length = length;
+	memcpy(request.r, r, 16 * sizeof(uint8_t));
+	memcpy(request.g, g, 16 * sizeof(uint8_t));
+	memcpy(request.b, b, 16 * sizeof(uint8_t));
+
+	ret = device_send_request(device_p, (Packet *)&request, NULL);
+
+
+	return ret;
+}
+
+int led_strip_get_rgb_values(LEDStrip *led_strip, uint16_t index, uint8_t length, uint8_t ret_r[16], uint8_t ret_g[16], uint8_t ret_b[16]) {
+	DevicePrivate *device_p = led_strip->p;
+	GetRGBValues_ request;
+	GetRGBValuesResponse_ response;
+	int ret;
+
+	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_GET_RGB_VALUES, device_p->ipcon_p, device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	request.index = leconvert_uint16_to(index);
+	request.length = length;
+
+	ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
+
+	if (ret < 0) {
+		return ret;
+	}
+	memcpy(ret_r, response.r, 16 * sizeof(uint8_t));
+	memcpy(ret_g, response.g, 16 * sizeof(uint8_t));
+	memcpy(ret_b, response.b, 16 * sizeof(uint8_t));
+
+
+
+	return ret;
+}
+
+int led_strip_set_frame_duration(LEDStrip *led_strip, uint16_t duration) {
+	DevicePrivate *device_p = led_strip->p;
+	SetFrameDuration_ request;
+	int ret;
+
+	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_SET_FRAME_DURATION, device_p->ipcon_p, device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	request.duration = leconvert_uint16_to(duration);
+
+	ret = device_send_request(device_p, (Packet *)&request, NULL);
+
+
+	return ret;
+}
+
+int led_strip_get_frame_duration(LEDStrip *led_strip, uint16_t *ret_duration) {
+	DevicePrivate *device_p = led_strip->p;
+	GetFrameDuration_ request;
+	GetFrameDurationResponse_ response;
+	int ret;
+
+	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_GET_FRAME_DURATION, device_p->ipcon_p, device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+
+	ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
+
+	if (ret < 0) {
+		return ret;
+	}
+	*ret_duration = leconvert_uint16_from(response.duration);
+
+
+
+	return ret;
+}
+
+int led_strip_get_supply_voltage(LEDStrip *led_strip, uint16_t *ret_voltage) {
+	DevicePrivate *device_p = led_strip->p;
+	GetSupplyVoltage_ request;
+	GetSupplyVoltageResponse_ response;
+	int ret;
+
+	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_GET_SUPPLY_VOLTAGE, device_p->ipcon_p, device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+
+	ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
+
+	if (ret < 0) {
+		return ret;
+	}
+	*ret_voltage = leconvert_uint16_from(response.voltage);
+
+
+
+	return ret;
+}
+
+int led_strip_set_clock_frequency(LEDStrip *led_strip, uint32_t frequency) {
+	DevicePrivate *device_p = led_strip->p;
+	SetClockFrequency_ request;
+	int ret;
+
+	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_SET_CLOCK_FREQUENCY, device_p->ipcon_p, device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	request.frequency = leconvert_uint32_to(frequency);
+
+	ret = device_send_request(device_p, (Packet *)&request, NULL);
+
+
+	return ret;
+}
+
+int led_strip_get_clock_frequency(LEDStrip *led_strip, uint32_t *ret_frequency) {
+	DevicePrivate *device_p = led_strip->p;
+	GetClockFrequency_ request;
+	GetClockFrequencyResponse_ response;
+	int ret;
+
+	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_GET_CLOCK_FREQUENCY, device_p->ipcon_p, device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+
+	ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
+
+	if (ret < 0) {
+		return ret;
+	}
+	*ret_frequency = leconvert_uint32_from(response.frequency);
+
+
+
+	return ret;
+}
+
+int led_strip_get_identity(LEDStrip *led_strip, char ret_uid[8], char ret_connected_uid[8], char *ret_position, uint8_t ret_hardware_version[3], uint8_t ret_firmware_version[3], uint16_t *ret_device_identifier) {
+	DevicePrivate *device_p = led_strip->p;
+	GetIdentity_ request;
+	GetIdentityResponse_ response;
+	int ret;
+
+	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_GET_IDENTITY, device_p->ipcon_p, device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+
+	ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
+
+	if (ret < 0) {
+		return ret;
+	}
+	strncpy(ret_uid, response.uid, 8);
+	strncpy(ret_connected_uid, response.connected_uid, 8);
+	*ret_position = response.position;
+	memcpy(ret_hardware_version, response.hardware_version, 3 * sizeof(uint8_t));
+	memcpy(ret_firmware_version, response.firmware_version, 3 * sizeof(uint8_t));
+	*ret_device_identifier = leconvert_uint16_from(response.device_identifier);
+
+
+
+	return ret;
+}

dependencies/include/tinkerforge/bricklet_led_strip.h

@@ -0,0 +1,301 @@
+/* ***********************************************************
+ * This file was automatically generated on 2013-12-19.      *
+ *                                                           *
+ * Bindings Version 2.0.13                                    *
+ *                                                           *
+ * 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 generator git on tinkerforge.com                   *
+ *************************************************************/
+
+#ifndef BRICKLET_LED_STRIP_H
+#define BRICKLET_LED_STRIP_H
+
+#include "ip_connection.h"
+
+/**
+ * \defgroup BrickletLEDStrip LEDStrip Bricklet
+ */
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Device to control up to 320 RGB LEDs
+ */
+typedef Device LEDStrip;
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_FUNCTION_SET_RGB_VALUES 1
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_FUNCTION_GET_RGB_VALUES 2
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_FUNCTION_SET_FRAME_DURATION 3
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_FUNCTION_GET_FRAME_DURATION 4
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_FUNCTION_GET_SUPPLY_VOLTAGE 5
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_FUNCTION_SET_CLOCK_FREQUENCY 7
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_FUNCTION_GET_CLOCK_FREQUENCY 8
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_FUNCTION_GET_IDENTITY 255
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Signature: \code void callback(uint16_t length, void *user_data) \endcode
+ * 
+ * This callback is triggered directly after a new frame is rendered.
+ * 
+ * You should send the data for the next frame directly after this callback
+ * was triggered.
+ * 
+ * For an explanation of the general approach see {@link led_strip_set_rgb_values}.
+ */
+#define LED_STRIP_CALLBACK_FRAME_RENDERED 6
+
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * This constant is used to identify a LEDStrip Bricklet.
+ *
+ * The {@link led_strip_get_identity} function and the
+ * {@link IPCON_CALLBACK_ENUMERATE} callback of the IP Connection have a
+ * \c device_identifier parameter to specify the Brick's or Bricklet's type.
+ */
+#define LED_STRIP_DEVICE_IDENTIFIER 231
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Creates the device object \c led_strip with the unique device ID \c uid and adds
+ * it to the IPConnection \c ipcon.
+ */
+void led_strip_create(LEDStrip *led_strip, const char *uid, IPConnection *ipcon);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Removes the device object \c led_strip from its IPConnection and destroys it.
+ * The device object cannot be used anymore afterwards.
+ */
+void led_strip_destroy(LEDStrip *led_strip);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Returns the response expected flag for the function specified by the
+ * \c function_id parameter. It is *true* if the function is expected to
+ * send a response, *false* otherwise.
+ *
+ * For getter functions this is enabled by default and cannot be disabled,
+ * because those functions will always send a response. For callback
+ * configuration functions it is enabled by default too, but can be disabled
+ * via the led_strip_set_response_expected function. For setter functions it is
+ * disabled by default and can be enabled.
+ *
+ * Enabling the response expected flag for a setter function allows to
+ * detect timeouts and other error conditions calls of this setter as well.
+ * The device will then send a response for this purpose. If this flag is
+ * disabled for a setter function then no response is send and errors are
+ * silently ignored, because they cannot be detected.
+ */
+int led_strip_get_response_expected(LEDStrip *led_strip, uint8_t function_id, bool *ret_response_expected);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Changes the response expected flag of the function specified by the
+ * \c function_id parameter. This flag can only be changed for setter
+ * (default value: *false*) and callback configuration functions
+ * (default value: *true*). For getter functions it is always enabled and
+ * callbacks it is always disabled.
+ *
+ * Enabling the response expected flag for a setter function allows to detect
+ * timeouts and other error conditions calls of this setter as well. The device
+ * will then send a response for this purpose. If this flag is disabled for a
+ * setter function then no response is send and errors are silently ignored,
+ * because they cannot be detected.
+ */
+int led_strip_set_response_expected(LEDStrip *led_strip, uint8_t function_id, bool response_expected);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Changes the response expected flag for all setter and callback configuration
+ * functions of this device at once.
+ */
+int led_strip_set_response_expected_all(LEDStrip *led_strip, bool response_expected);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Registers a callback with ID \c id to the function \c callback. The
+ * \c user_data will be given as a parameter of the callback.
+ */
+void led_strip_register_callback(LEDStrip *led_strip, uint8_t id, void *callback, void *user_data);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Returns the API version (major, minor, release) of the bindings for this
+ * device.
+ */
+int led_strip_get_api_version(LEDStrip *led_strip, uint8_t ret_api_version[3]);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Sets the *rgb* values for the LEDs with the given *length* starting 
+ * from *index*.
+ * 
+ * The maximum length is 16, the index goes from 0 to 319 and the rgb values
+ * have 8 bits each.
+ * 
+ * Example: If you set
+ * 
+ * * index to 5,
+ * * length to 3,
+ * * r to [255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ * * g to [0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] and
+ * * b to [0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+ * 
+ * the LED with index 5 will be red, 6 will be green and 7 will be blue.
+ * 
+ * The colors will be transfered to actual LEDs when the next
+ * frame duration ends, see {@link led_strip_set_frame_duration}.
+ * 
+ * Generic approach: 
+ * 
+ * * Set the frame duration to a value that represents
+ *   the number of frames per second you want to achieve. 
+ * * Set all of the LED colors for one frame.
+ * * Wait for the {@link LED_STRIP_CALLBACK_FRAME_RENDERED} callback.
+ * * Set all of the LED colors for next frame.
+ * * Wait for the {@link LED_STRIP_CALLBACK_FRAME_RENDERED} callback.
+ * * and so on.
+ * 
+ * This approach ensures that you can change the LED colors with
+ * a fixed frame rate.
+ * 
+ * The actual number of controllable LEDs depends on the number of free
+ * Bricklet ports. See :ref:`here <led_strip_bricklet_ram_constraints>` for more
+ * information. A call of {@link led_strip_set_rgb_values} with index + length above the
+ * bounds is ignored completely.
+ */
+int led_strip_set_rgb_values(LEDStrip *led_strip, uint16_t index, uint8_t length, uint8_t r[16], uint8_t g[16], uint8_t b[16]);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Returns the rgb with the given *length* starting from the
+ * given *index*.
+ * 
+ * The values are the last values that were set by {@link led_strip_set_rgb_values}.
+ */
+int led_strip_get_rgb_values(LEDStrip *led_strip, uint16_t index, uint8_t length, uint8_t ret_r[16], uint8_t ret_g[16], uint8_t ret_b[16]);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Sets the frame duration in ms.
+ * 
+ * Example: If you want to achieve 20 frames per second, you should
+ * set the frame duration to 50ms (50ms * 20 = 1 second). 
+ * 
+ * For an explanation of the general approach see {@link led_strip_set_rgb_values}.
+ * 
+ * Default value: 100ms (10 frames per second).
+ */
+int led_strip_set_frame_duration(LEDStrip *led_strip, uint16_t duration);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Returns the frame duration as set by {@link led_strip_set_frame_duration}.
+ */
+int led_strip_get_frame_duration(LEDStrip *led_strip, uint16_t *ret_duration);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Returns the current supply voltage of the LEDs. The voltage is given in mV.
+ */
+int led_strip_get_supply_voltage(LEDStrip *led_strip, uint16_t *ret_voltage);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Sets the frequency of the clock in Hz. The range is 10000Hz (10kHz) up to
+ * 2000000Hz (2MHz).
+ * 
+ * The Bricklet will choose the nearest achievable frequency, which may
+ * be off by a few Hz. You can get the exact frequency that is used by
+ * calling {@link led_strip_get_clock_frequency}.
+ * 
+ * If you have problems with flickering LEDs, they may be bits flipping. You
+ * can fix this by either making the connection between the LEDs and the
+ * Bricklet shorter or by reducing the frequency.
+ * 
+ * With a decreasing frequency your maximum frames per second will decrease
+ * too.
+ * 
+ * The default value is 1.66MHz.
+ * 
+ * \note
+ *  The frequency in firmware version 2.0.0 is fixed at 2MHz.
+ * 
+ * .. versionadded:: 2.0.1~(Plugin)
+ */
+int led_strip_set_clock_frequency(LEDStrip *led_strip, uint32_t frequency);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Returns the currently used clock frequency.
+ * 
+ * .. versionadded:: 2.0.1~(Plugin)
+ */
+int led_strip_get_clock_frequency(LEDStrip *led_strip, uint32_t *ret_frequency);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * 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 identifiers can be found :ref:`here <device_identifier>`.
+ * 
+ * .. versionadded:: 2.0.0~(Plugin)
+ */
+int led_strip_get_identity(LEDStrip *led_strip, char ret_uid[8], char ret_connected_uid[8], char *ret_position, uint8_t ret_hardware_version[3], uint8_t ret_firmware_version[3], uint16_t *ret_device_identifier);
+
+#endif

dependencies/include/tinkerforge/ip_connection.h

@@ -0,0 +1,630 @@
+/*
+ * Copyright (C) 2012-2013 Matthias Bolte <matthias@tinkerforge.com>
+ * Copyright (C) 2011 Olaf Lüke <olaf@tinkerforge.com>
+ *
+ * Redistribution and use in source and binary forms of this file,
+ * with or without modification, are permitted.
+ */
+
+#ifndef IP_CONNECTION_H
+#define IP_CONNECTION_H
+
+/**
+ * \defgroup IPConnection IP Connection
+ */
+
+#ifndef __STDC_LIMIT_MACROS
+	#define __STDC_LIMIT_MACROS
+#endif
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+
+#if !defined __cplusplus && defined __GNUC__
+	#include <stdbool.h>
+#endif
+
+#ifdef _WIN32
+	#ifndef WIN32_LEAN_AND_MEAN
+		#define WIN32_LEAN_AND_MEAN
+	#endif
+	#include <windows.h>
+#else
+	#include <pthread.h>
+	#include <semaphore.h>
+#endif
+
+enum {
+	E_OK = 0,
+	E_TIMEOUT = -1,
+	E_NO_STREAM_SOCKET = -2,
+	E_HOSTNAME_INVALID = -3,
+	E_NO_CONNECT = -4,
+	E_NO_THREAD = -5,
+	E_NOT_ADDED = -6, // unused since v2.0
+	E_ALREADY_CONNECTED = -7,
+	E_NOT_CONNECTED = -8,
+	E_INVALID_PARAMETER = -9, // error response from device
+	E_NOT_SUPPORTED = -10, // error response from device
+	E_UNKNOWN_ERROR_CODE = -11 // error response from device
+};
+
+#ifdef IPCON_EXPOSE_INTERNALS
+
+typedef struct _Socket Socket;
+
+typedef struct {
+#ifdef _WIN32
+	CRITICAL_SECTION handle;
+#else
+	pthread_mutex_t handle;
+#endif
+} Mutex;
+
+void mutex_create(Mutex *mutex);
+
+void mutex_destroy(Mutex *mutex);
+
+void mutex_lock(Mutex *mutex);
+
+void mutex_unlock(Mutex *mutex);
+
+typedef struct {
+#ifdef _WIN32
+	HANDLE handle;
+#else
+	pthread_cond_t condition;
+	pthread_mutex_t mutex;
+	bool flag;
+#endif
+} Event;
+
+typedef struct {
+#ifdef _WIN32
+	HANDLE handle;
+#else
+	sem_t object;
+	sem_t *pointer;
+#endif
+} Semaphore;
+
+typedef void (*ThreadFunction)(void *opaque);
+
+typedef struct {
+#ifdef _WIN32
+	HANDLE handle;
+	DWORD id;
+#else
+	pthread_t handle;
+#endif
+	ThreadFunction function;
+	void *opaque;
+} Thread;
+
+typedef struct {
+	Mutex mutex;
+	int used;
+	int allocated;
+	uint32_t *keys;
+	void **values;
+} Table;
+
+typedef struct _QueueItem {
+	struct _QueueItem *next;
+	int kind;
+	void *data;
+	int length;
+} QueueItem;
+
+typedef struct {
+	Mutex mutex;
+	Semaphore semaphore;
+	QueueItem *head;
+	QueueItem *tail;
+} Queue;
+
+#if defined _MSC_VER || defined __BORLANDC__
+	#pragma pack(push)
+	#pragma pack(1)
+	#define ATTRIBUTE_PACKED
+#elif defined __GNUC__
+	#ifdef _WIN32
+		// workaround struct packing bug in GCC 4.7 on Windows
+		// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52991
+		#define ATTRIBUTE_PACKED __attribute__((gcc_struct, packed))
+	#else
+		#define ATTRIBUTE_PACKED __attribute__((packed))
+	#endif
+#else
+	#error unknown compiler, do not know how to enable struct packing
+#endif
+
+typedef struct {
+	uint32_t uid;
+	uint8_t length;
+	uint8_t function_id;
+	uint8_t sequence_number_and_options;
+	uint8_t error_code_and_future_use;
+} ATTRIBUTE_PACKED PacketHeader;
+
+typedef struct {
+	PacketHeader header;
+	uint8_t payload[64];
+	uint8_t optional_data[8];
+} ATTRIBUTE_PACKED Packet;
+
+#if defined _MSC_VER || defined __BORLANDC__
+	#pragma pack(pop)
+#endif
+#undef ATTRIBUTE_PACKED
+
+#endif // IPCON_EXPOSE_INTERNALS
+
+typedef struct _IPConnection IPConnection;
+typedef struct _IPConnectionPrivate IPConnectionPrivate;
+typedef struct _Device Device;
+typedef struct _DevicePrivate DevicePrivate;
+
+#ifdef IPCON_EXPOSE_INTERNALS
+
+typedef struct _CallbackContext CallbackContext;
+
+#endif
+
+typedef void (*EnumerateCallbackFunction)(const char *uid,
+                                          const char *connected_uid,
+                                          char position,
+                                          uint8_t hardware_version[3],
+                                          uint8_t firmware_version[3],
+                                          uint16_t device_identifier,
+                                          uint8_t enumeration_type,
+                                          void *user_data);
+typedef void (*ConnectedCallbackFunction)(uint8_t connect_reason,
+                                          void *user_data);
+typedef void (*DisconnectedCallbackFunction)(uint8_t disconnect_reason,
+                                             void *user_data);
+
+#ifdef IPCON_EXPOSE_INTERNALS
+
+typedef void (*CallbackWrapperFunction)(DevicePrivate *device_p, Packet *packet);
+
+#endif
+
+/**
+ * \internal
+ */
+struct _Device {
+	DevicePrivate *p;
+};
+
+#ifdef IPCON_EXPOSE_INTERNALS
+
+#define DEVICE_NUM_FUNCTION_IDS 256
+
+/**
+ * \internal
+ */
+struct _DevicePrivate {
+	uint32_t uid;
+
+	IPConnectionPrivate *ipcon_p;
+
+	uint8_t api_version[3];
+
+	Mutex request_mutex;
+
+	uint8_t expected_response_function_id; // protected by request_mutex
+	uint8_t expected_response_sequence_number; // protected by request_mutex
+	Mutex response_mutex;
+	Packet response_packet; // protected by response_mutex
+	Event response_event;
+	int response_expected[DEVICE_NUM_FUNCTION_IDS];
+
+	void *registered_callbacks[DEVICE_NUM_FUNCTION_IDS];
+	void *registered_callback_user_data[DEVICE_NUM_FUNCTION_IDS];
+	CallbackWrapperFunction callback_wrappers[DEVICE_NUM_FUNCTION_IDS];
+};
+
+/**
+ * \internal
+ */
+enum {
+	DEVICE_RESPONSE_EXPECTED_INVALID_FUNCTION_ID = 0,
+	DEVICE_RESPONSE_EXPECTED_ALWAYS_TRUE, // getter
+	DEVICE_RESPONSE_EXPECTED_ALWAYS_FALSE, // callback
+	DEVICE_RESPONSE_EXPECTED_TRUE, // setter
+	DEVICE_RESPONSE_EXPECTED_FALSE // setter, default
+};
+
+/**
+ * \internal
+ */
+void device_create(Device *device, const char *uid,
+                   IPConnectionPrivate *ipcon_p, uint8_t api_version_major,
+                   uint8_t api_version_minor, uint8_t api_version_release);
+
+/**
+ * \internal
+ */
+void device_destroy(Device *device);
+
+/**
+ * \internal
+ */
+int device_get_response_expected(DevicePrivate *device_p, uint8_t function_id,
+                                 bool *ret_response_expected);
+
+/**
+ * \internal
+ */
+int device_set_response_expected(DevicePrivate *device_p, uint8_t function_id,
+                                 bool response_expected);
+
+/**
+ * \internal
+ */
+int device_set_response_expected_all(DevicePrivate *device_p, bool response_expected);
+
+/**
+ * \internal
+ */
+void device_register_callback(DevicePrivate *device_p, uint8_t id, void *callback,
+                              void *user_data);
+
+/**
+ * \internal
+ */
+int device_get_api_version(DevicePrivate *device_p, uint8_t ret_api_version[3]);
+
+/**
+ * \internal
+ */
+int device_send_request(DevicePrivate *device_p, Packet *request, Packet *response);
+
+#endif // IPCON_EXPOSE_INTERNALS
+
+/**
+ * \ingroup IPConnection
+ *
+ * Possible IDs for ipcon_register_callback.
+ */
+enum {
+	IPCON_CALLBACK_ENUMERATE = 253,
+	IPCON_CALLBACK_CONNECTED = 0,
+	IPCON_CALLBACK_DISCONNECTED = 1
+};
+
+/**
+ * \ingroup IPConnection
+ *
+ * Possible values for enumeration_type parameter of EnumerateCallback.
+ */
+enum {
+	IPCON_ENUMERATION_TYPE_AVAILABLE = 0,
+	IPCON_ENUMERATION_TYPE_CONNECTED = 1,
+	IPCON_ENUMERATION_TYPE_DISCONNECTED = 2
+};
+
+/**
+ * \ingroup IPConnection
+ *
+ * Possible values for connect_reason parameter of ConnectedCallback.
+ */
+enum {
+	IPCON_CONNECT_REASON_REQUEST = 0,
+	IPCON_CONNECT_REASON_AUTO_RECONNECT = 1
+};
+
+/**
+ * \ingroup IPConnection
+ *
+ * Possible values for disconnect_reason parameter of DisconnectedCallback.
+ */
+enum {
+	IPCON_DISCONNECT_REASON_REQUEST = 0,
+	IPCON_DISCONNECT_REASON_ERROR = 1,
+	IPCON_DISCONNECT_REASON_SHUTDOWN = 2
+};
+
+/**
+ * \ingroup IPConnection
+ *
+ * Possible return values of ipcon_get_connection_state.
+ */
+enum {
+	IPCON_CONNECTION_STATE_DISCONNECTED = 0,
+	IPCON_CONNECTION_STATE_CONNECTED = 1,
+	IPCON_CONNECTION_STATE_PENDING = 2 // auto-reconnect in progress
+};
+
+/**
+ * \internal
+ */
+struct _IPConnection {
+	IPConnectionPrivate *p;
+};
+
+#ifdef IPCON_EXPOSE_INTERNALS
+
+#define IPCON_NUM_CALLBACK_IDS 256
+
+/**
+ * \internal
+ */
+struct _IPConnectionPrivate {
+#ifdef _WIN32
+	bool wsa_startup_done; // protected by socket_mutex
+#endif
+
+	char *host;
+	uint16_t port;
+
+	uint32_t timeout; // in msec
+
+	bool auto_reconnect;
+	bool auto_reconnect_allowed;
+	bool auto_reconnect_pending;
+
+	Mutex sequence_number_mutex;
+	uint8_t next_sequence_number; // protected by sequence_number_mutex
+
+	Table devices;
+
+	void *registered_callbacks[IPCON_NUM_CALLBACK_IDS];
+	void *registered_callback_user_data[IPCON_NUM_CALLBACK_IDS];
+
+	Mutex socket_mutex;
+	Socket *socket; // protected by socket_mutex
+	uint64_t socket_id; // protected by socket_mutex
+
+	bool receive_flag;
+	Thread receive_thread; // protected by socket_mutex
+
+	CallbackContext *callback;
+
+	bool disconnect_probe_flag;
+	Thread disconnect_probe_thread; // protected by socket_mutex
+	Event disconnect_probe_event;
+
+	Semaphore wait;
+};
+
+#endif // IPCON_EXPOSE_INTERNALS
+
+/**
+ * \ingroup IPConnection
+ *
+ * Creates an IP Connection object that can be used to enumerate the available
+ * devices. It is also required for the constructor of Bricks and Bricklets.
+ */
+void ipcon_create(IPConnection *ipcon);
+
+/**
+ * \ingroup IPConnection
+ *
+ * Destroys the IP Connection object. Calls ipcon_disconnect internally.
+ * The connection to the Brick Daemon gets closed and the threads of the
+ * IP Connection are terminated.
+ */
+void ipcon_destroy(IPConnection *ipcon);
+
+/**
+ * \ingroup IPConnection
+ *
+ * Creates a TCP/IP connection to the given \c host and c\ port. The host and
+ * port can point to a Brick Daemon or to a WIFI/Ethernet Extension.
+ *
+ * Devices can only be controlled when the connection was established
+ * successfully.
+ *
+ * Blocks until the connection is established and returns an error code if
+ * there is no Brick Daemon or WIFI/Ethernet Extension listening at the given
+ * host and port.
+ */
+int ipcon_connect(IPConnection *ipcon, const char *host, uint16_t port);
+
+/**
+ * \ingroup IPConnection
+ *
+ * Disconnects the TCP/IP connection from the Brick Daemon or the WIFI/Ethernet
+ * Extension.
+ */
+int ipcon_disconnect(IPConnection *ipcon);
+
+/**
+ * \ingroup IPConnection
+ *
+ * Can return the following states:
+ *
+ * - IPCON_CONNECTION_STATE_DISCONNECTED: No connection is established.
+ * - IPCON_CONNECTION_STATE_CONNECTED: A connection to the Brick Daemon or
+ *   the WIFI/Ethernet Extension is established.
+ * - IPCON_CONNECTION_STATE_PENDING: IP Connection is currently trying to
+ *   connect.
+ */
+int ipcon_get_connection_state(IPConnection *ipcon);
+
+/**
+ * \ingroup IPConnection
+ *
+ * Enables or disables auto-reconnect. If auto-reconnect is enabled,
+ * the IP Connection will try to reconnect to the previously given
+ * host and port, if the connection is lost.
+ *
+ * Default value is *true*.
+ */
+void ipcon_set_auto_reconnect(IPConnection *ipcon, bool auto_reconnect);
+
+/**
+ * \ingroup IPConnection
+ *
+ * Returns *true* if auto-reconnect is enabled, *false* otherwise.
+ */
+bool ipcon_get_auto_reconnect(IPConnection *ipcon);
+
+/**
+ * \ingroup IPConnection
+ *
+ * Sets the timeout in milliseconds for getters and for setters for which the
+ * response expected flag is activated.
+ *
+ * Default timeout is 2500.
+ */
+void ipcon_set_timeout(IPConnection *ipcon, uint32_t timeout);
+
+/**
+ * \ingroup IPConnection
+ *
+ * Returns the timeout as set by ipcon_set_timeout.
+ */
+uint32_t ipcon_get_timeout(IPConnection *ipcon);
+
+/**
+ * \ingroup IPConnection
+ *
+ * Broadcasts an enumerate request. All devices will respond with an enumerate
+ * callback.
+ */
+int ipcon_enumerate(IPConnection *ipcon);
+
+/**
+ * \ingroup IPConnection
+ *
+ * Stops the current thread until ipcon_unwait is called.
+ *
+ * This is useful if you rely solely on callbacks for events, if you want
+ * to wait for a specific callback or if the IP Connection was created in
+ * a thread.
+ *
+ * ipcon_wait and ipcon_unwait act in the same way as "acquire" and "release"
+ * of a semaphore.
+ */
+void ipcon_wait(IPConnection *ipcon);
+
+/**
+ * \ingroup IPConnection
+ *
+ * Unwaits the thread previously stopped by ipcon_wait.
+ *
+ * ipcon_wait and ipcon_unwait act in the same way as "acquire" and "release"
+ * of a semaphore.
+ */
+void ipcon_unwait(IPConnection *ipcon);
+
+/**
+ * \ingroup IPConnection
+ *
+ * Registers a callback for a given ID.
+ */
+void ipcon_register_callback(IPConnection *ipcon, uint8_t id,
+                             void *callback, void *user_data);
+
+#ifdef IPCON_EXPOSE_INTERNALS
+
+/**
+ * \internal
+ */
+int packet_header_create(PacketHeader *header, uint8_t length,
+                         uint8_t function_id, IPConnectionPrivate *ipcon_p,
+                         DevicePrivate *device_p);
+
+/**
+ * \internal
+ */
+uint8_t packet_header_get_sequence_number(PacketHeader *header);
+
+/**
+ * \internal
+ */
+void packet_header_set_sequence_number(PacketHeader *header,
+                                       uint8_t sequence_number);
+
+/**
+ * \internal
+ */
+uint8_t packet_header_get_response_expected(PacketHeader *header);
+
+/**
+ * \internal
+ */
+void packet_header_set_response_expected(PacketHeader *header,
+                                         uint8_t response_expected);
+
+/**
+ * \internal
+ */
+uint8_t packet_header_get_error_code(PacketHeader *header);
+
+/**
+ * \internal
+ */
+int16_t leconvert_int16_to(int16_t native);
+
+/**
+ * \internal
+ */
+uint16_t leconvert_uint16_to(uint16_t native);
+
+/**
+ * \internal
+ */
+int32_t leconvert_int32_to(int32_t native);
+
+/**
+ * \internal
+ */
+uint32_t leconvert_uint32_to(uint32_t native);
+
+/**
+ * \internal
+ */
+int64_t leconvert_int64_to(int64_t native);
+
+/**
+ * \internal
+ */
+uint64_t leconvert_uint64_to(uint64_t native);
+
+/**
+ * \internal
+ */
+float leconvert_float_to(float native);
+
+/**
+ * \internal
+ */
+int16_t leconvert_int16_from(int16_t little);
+
+/**
+ * \internal
+ */
+uint16_t leconvert_uint16_from(uint16_t little);
+
+/**
+ * \internal
+ */
+int32_t leconvert_int32_from(int32_t little);
+
+/**
+ * \internal
+ */
+uint32_t leconvert_uint32_from(uint32_t little);
+
+/**
+ * \internal
+ */
+int64_t leconvert_int64_from(int64_t little);
+
+/**
+ * \internal
+ */
+uint64_t leconvert_uint64_from(uint64_t little);
+
+/**
+ * \internal
+ */
+float leconvert_float_from(float little);
+
+#endif // IPCON_EXPOSE_INTERNALS
+
+#endif

libsrc/leddevice/CMakeLists.txt

@@ -67,6 +67,17 @@ if(ENABLE_SPIDEV)
 	)
 endif(ENABLE_SPIDEV)
 
+if(ENABLE_TINKERFORGE)
+	SET(Leddevice_HEADERS
+			${Leddevice_HEADERS}
+			${CURRENT_SOURCE_DIR}/LedDeviceTinkerforge.h
+	)
+	SET(Leddevice_SOURCES
+			${Leddevice_SOURCES}
+			${CURRENT_SOURCE_DIR}/LedDeviceTinkerforge.cpp
+	)
+endif(ENABLE_TINKERFORGE)
+
 
 QT4_WRAP_CPP(Leddevice_HEADERS_MOC ${Leddevice_QT_HEADERS})
 
@@ -84,6 +95,11 @@ target_link_libraries(leddevice
 	${CMAKE_THREAD_LIBS_INIT}
 	${QT_LIBRARIES}
 )
+
+if(ENABLE_TINKERFORGE)
+	target_link_libraries(leddevice tinkerforge)
+endif()
+
 if(APPLE)
 	target_link_libraries(leddevice hidapi-mac)
 else()

libsrc/leddevice/LedDeviceFactory.cpp

@@ -16,6 +16,10 @@
 	#include "LedDeviceWs2801.h"
 #endif
 
+#ifdef ENABLE_TINKERFORGE
+	#include "LedDeviceTinkerforge.h"
+#endif
+
 #include "LedDeviceAdalight.h"
 #include "LedDeviceLightpack.h"
 #include "LedDeviceMultiLightpack.h"
@@ -87,6 +91,22 @@ LedDevice * LedDeviceFactory::construct(const Json::Value & deviceConfig)
 		device = deviceWs2801;
 	}
 #endif
+
+#ifdef ENABLE_TINKERFORGE
+	else if (type=="tinkerforge") 
+	{
+		const std::string host 	= deviceConfig.get("output", "127.0.0.1").asString();
+		const uint16_t port 		= deviceConfig.get("port", 4223).asInt();
+		const std::string  uid		= deviceConfig["uid"].asString();
+		const unsigned rate 	= deviceConfig["rate"].asInt();
+
+		LedDeviceTinkerforge* deviceTinkerforge = new LedDeviceTinkerforge(host, port, uid, rate);
+		deviceTinkerforge->open();
+
+		device = deviceTinkerforge;
+	}
+#endif
+
 //      else if (type == "ws2811")
 //      {
 //              const std::string output       = deviceConfig["output"].asString();

libsrc/leddevice/LedDeviceTinkerforge.cpp

@@ -0,0 +1,143 @@
+
+// STL includes
+#include <cerrno>
+#include <cstring>
+
+// Local LedDevice includes
+#include "LedDeviceTinkerforge.h"
+
+static const unsigned MAX_NUM_LEDS = 320;
+static const unsigned MAX_NUM_LEDS_SETTABLE = 16;
+
+LedDeviceTinkerforge::LedDeviceTinkerforge(const std::string & host, uint16_t port, const std::string & uid, const unsigned interval) :
+		LedDevice(),
+		_host(host),
+		_port(port),
+		_uid(uid),
+		_interval(interval),
+		_ipConnection(nullptr),
+		_ledStrip(nullptr),
+		_colorChannelSize(0)
+{
+	// empty
+}
+
+LedDeviceTinkerforge::~LedDeviceTinkerforge()
+{
+	// Close the device (if it is opened)
+	if (_ipConnection != nullptr && _ledStrip != nullptr)
+	{
+		switchOff();
+	}
+
+	// Clean up claimed resources
+	delete _ipConnection;
+	delete _ledStrip;
+}
+
+int LedDeviceTinkerforge::open()
+{
+	// Check if connection is already createds
+	if (_ipConnection != nullptr)
+	{
+		std::cout << "Attempt to open existing connection; close before opening" << std::endl;
+		return -1;
+	}
+
+	// Initialise a new connection
+	_ipConnection = new IPConnection;
+	ipcon_create(_ipConnection);
+
+	int connectionStatus = ipcon_connect(_ipConnection, _host.c_str(), _port);
+	if (connectionStatus < 0) 
+	{
+		std::cerr << "Attempt to connect to master brick (" << _host << ":" << _port << ") failed with status " << connectionStatus << std::endl;
+		return -1;
+	}
+
+	// Create the 'LedStrip'
+	_ledStrip = new LEDStrip;
+	led_strip_create(_ledStrip, _uid.c_str(), _ipConnection);
+
+	int frameStatus = led_strip_set_frame_duration(_ledStrip, _interval);
+	if (frameStatus < 0) 
+	{
+		std::cerr << "Attempt to connect to led strip bricklet (led_strip_set_frame_duration()) failed with status " << frameStatus << std::endl;
+		return -1;
+	}
+
+	return 0;
+}
+
+int LedDeviceTinkerforge::write(const std::vector<ColorRgb> &ledValues)
+{
+	unsigned nrLedValues = ledValues.size();
+
+	if (nrLedValues > MAX_NUM_LEDS) 
+	{
+		std::cerr << "Invalid attempt to write led values. Not more than " << MAX_NUM_LEDS << " leds are allowed." << std::endl;
+		return -1;
+	}
+
+	if (_colorChannelSize < nrLedValues)
+	{
+		_redChannel.resize(nrLedValues, uint8_t(0));
+		_greenChannel.resize(nrLedValues, uint8_t(0));
+		_blueChannel.resize(nrLedValues, uint8_t(0));
+	}
+	_colorChannelSize = nrLedValues;
+
+	auto redIt   = _redChannel.begin();
+	auto greenIt = _greenChannel.begin();
+	auto blueIt  = _blueChannel.begin();
+
+	for (const ColorRgb &ledValue : ledValues)
+	{
+		*redIt = ledValue.red;
+		++redIt;
+		*greenIt = ledValue.green;
+		++greenIt;
+		*blueIt = ledValue.blue;
+		++blueIt;
+	}
+
+	return transferLedData(_ledStrip, 0, _colorChannelSize, _redChannel.data(), _greenChannel.data(), _blueChannel.data());
+}
+
+int LedDeviceTinkerforge::switchOff()
+{
+	std::cerr << "Switchoff" << std::endl;
+	std::fill(_redChannel.begin(),   _redChannel.end(),   0);
+	std::fill(_greenChannel.begin(), _greenChannel.end(), 0);
+	std::fill(_blueChannel.begin(),  _blueChannel.end(),  0);
+
+	return transferLedData(_ledStrip, 0, _colorChannelSize, _redChannel.data(), _greenChannel.data(), _blueChannel.data());
+}
+
+int LedDeviceTinkerforge::transferLedData(LEDStrip *ledStrip, unsigned index, unsigned length, uint8_t *redChannel, uint8_t *greenChannel, uint8_t *blueChannel) 
+{
+	if (length == 0 || index >= length || length > MAX_NUM_LEDS)
+	{
+		return E_INVALID_PARAMETER;
+	}
+
+	uint8_t * redPtr   = redChannel;
+	uint8_t * greenPtr = greenChannel;
+	uint8_t * bluePtr  = blueChannel;
+	for (unsigned i=index; i<length; i+=MAX_NUM_LEDS_SETTABLE)
+	{
+		const unsigned copyLength = (i + MAX_NUM_LEDS_SETTABLE > length) ? length - i : MAX_NUM_LEDS_SETTABLE;
+		const int status = led_strip_set_rgb_values(ledStrip, i, copyLength, redPtr, greenPtr, bluePtr);
+		redPtr   += copyLength;
+		greenPtr += copyLength;
+		bluePtr  += copyLength;
+
+		if (status != E_OK)
+		{
+			std::cerr << "Setting led values failed with status " << status << std::endl;
+			return status;
+		}
+	}
+
+	return E_OK;
+}

libsrc/leddevice/LedDeviceTinkerforge.h

@@ -0,0 +1,82 @@
+
+#pragma once
+
+// STL includes
+#include <cstdio>
+
+// Hyperion-Leddevice includes
+#include <leddevice/LedDevice.h>
+
+
+extern "C" {
+	#include <tinkerforge/ip_connection.h>
+	#include <tinkerforge/bricklet_led_strip.h>
+}
+
+class LedDeviceTinkerforge : public LedDevice
+{
+public:
+	
+	LedDeviceTinkerforge(const std::string &host, uint16_t port, const std::string &uid, const unsigned interval);
+
+	virtual ~LedDeviceTinkerforge();
+
+	///
+	/// Attempts to open a connection to the master bricklet and the led strip bricklet.
+	///
+	/// @return Zero on succes else negative
+	///
+	int open();
+
+	///
+	/// Writes the colors to the led strip bricklet
+	///
+	/// @param ledValues The color value for each led
+	///
+	/// @return Zero on success else negative
+	///
+	virtual int write(const std::vector<ColorRgb> &ledValues);
+
+	///
+	/// Switches off the leds
+	///
+	/// @return Zero on success else negative
+	///
+	virtual int switchOff();
+
+private:
+	///
+	/// Writes the data to the led strip blicklet 
+	int transferLedData(LEDStrip *ledstrip, unsigned int index, unsigned int length, uint8_t *redChannel, uint8_t *greenChannel, uint8_t *blueChannel);
+
+	/// The host of the master brick
+	const std::string _host;
+
+	/// The port of the master brick
+	const uint16_t _port;
+
+	/// The uid of the led strip bricklet
+	const std::string _uid;
+
+	/// The interval/rate
+	const unsigned _interval;
+
+	/// ip connection handle 
+	IPConnection *_ipConnection;
+
+	/// led strip handle
+	LEDStrip *_ledStrip;
+
+	/// buffer for red channel led data
+	std::vector<uint8_t> _redChannel;
+
+	/// buffer for red channel led data
+	std::vector<uint8_t> _greenChannel;
+
+	/// buffer for red channel led data
+	std::vector<uint8_t> _blueChannel;
+
+	/// buffer size of the color channels
+	unsigned int _colorChannelSize;
+
+};