Corrections (#1662)

* Address "SyntaxWarning: invalid escape sequence"

* Correcttypo for CEC Blue button

* Fix enablement when already open

* Icons path corrected

* Correct path and simplify command

* Have enum class generalised

* Address compile warnings

* Update tinkerforce led_strip

* Address compiler waring

* Fix Install/Uninstall desktop- and icon file handling

* Address "fatal: detected dubious ownership in repository"

* platform fix

* Test  "fatal: detected dubious ownership in repository"

* Update "fatal: detected dubious ownership in repository"

* Update to Protobuf 25.1

* Update cmds with sudo

* Update SEDU default baud rates

* Replace deprecated Py_NoSiteFlag

* Correct default config

---------

Co-authored-by: Paulchen-Panther <16664240+Paulchen-Panther@users.noreply.github.com>

dependencies/build/tinkerforge/bricklet_led_strip.c

@@ -1,11 +1,11 @@
 /* ***********************************************************
- * This file was automatically generated on 2013-12-19.      *
+ * This file was automatically generated on 2023-11-30.      *
  *                                                           *
- * Bindings Version 2.0.13                                    *
+ * C/C++ Bindings Version 2.1.33                             *
  *                                                           *
  * 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                   *
+ * to the generators git repository on tinkerforge.com       *
  *************************************************************/
 
 
@@ -15,9 +15,13 @@
 
 #include <string.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 
-typedef void (*FrameRenderedCallbackFunction)(uint16_t, void *);
+
+typedef void (*FrameRendered_CallbackFunction)(uint16_t length, void *user_data);
 
 #if defined _MSC_VER || defined __BORLANDC__
 	#pragma pack(push)
@@ -26,7 +30,7 @@ typedef void (*FrameRenderedCallbackFunction)(uint16_t, void *);
 #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
+		// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52991
 		#define ATTRIBUTE_PACKED __attribute__((gcc_struct, packed))
 	#else
 		#define ATTRIBUTE_PACKED __attribute__((packed))
@@ -42,66 +46,135 @@ typedef struct {
 	uint8_t r[16];
 	uint8_t g[16];
 	uint8_t b[16];
-} ATTRIBUTE_PACKED SetRGBValues_;
+} ATTRIBUTE_PACKED SetRGBValues_Request;
 
 typedef struct {
 	PacketHeader header;
 	uint16_t index;
 	uint8_t length;
-} ATTRIBUTE_PACKED GetRGBValues_;
+} ATTRIBUTE_PACKED GetRGBValues_Request;
 
 typedef struct {
 	PacketHeader header;
 	uint8_t r[16];
 	uint8_t g[16];
 	uint8_t b[16];
-} ATTRIBUTE_PACKED GetRGBValuesResponse_;
+} ATTRIBUTE_PACKED GetRGBValues_Response;
 
 typedef struct {
 	PacketHeader header;
 	uint16_t duration;
-} ATTRIBUTE_PACKED SetFrameDuration_;
+} ATTRIBUTE_PACKED SetFrameDuration_Request;
 
 typedef struct {
 	PacketHeader header;
-} ATTRIBUTE_PACKED GetFrameDuration_;
+} ATTRIBUTE_PACKED GetFrameDuration_Request;
 
 typedef struct {
 	PacketHeader header;
 	uint16_t duration;
-} ATTRIBUTE_PACKED GetFrameDurationResponse_;
+} ATTRIBUTE_PACKED GetFrameDuration_Response;
 
 typedef struct {
 	PacketHeader header;
-} ATTRIBUTE_PACKED GetSupplyVoltage_;
+} ATTRIBUTE_PACKED GetSupplyVoltage_Request;
 
 typedef struct {
 	PacketHeader header;
 	uint16_t voltage;
-} ATTRIBUTE_PACKED GetSupplyVoltageResponse_;
+} ATTRIBUTE_PACKED GetSupplyVoltage_Response;
 
 typedef struct {
 	PacketHeader header;
 	uint16_t length;
-} ATTRIBUTE_PACKED FrameRenderedCallback_;
+} ATTRIBUTE_PACKED FrameRendered_Callback;
 
 typedef struct {
 	PacketHeader header;
 	uint32_t frequency;
-} ATTRIBUTE_PACKED SetClockFrequency_;
+} ATTRIBUTE_PACKED SetClockFrequency_Request;
 
 typedef struct {
 	PacketHeader header;
-} ATTRIBUTE_PACKED GetClockFrequency_;
+} ATTRIBUTE_PACKED GetClockFrequency_Request;
 
 typedef struct {
 	PacketHeader header;
 	uint32_t frequency;
-} ATTRIBUTE_PACKED GetClockFrequencyResponse_;
+} ATTRIBUTE_PACKED GetClockFrequency_Response;
 
 typedef struct {
 	PacketHeader header;
-} ATTRIBUTE_PACKED GetIdentity_;
+	uint16_t chip;
+} ATTRIBUTE_PACKED SetChipType_Request;
+
+typedef struct {
+	PacketHeader header;
+} ATTRIBUTE_PACKED GetChipType_Request;
+
+typedef struct {
+	PacketHeader header;
+	uint16_t chip;
+} ATTRIBUTE_PACKED GetChipType_Response;
+
+typedef struct {
+	PacketHeader header;
+	uint16_t index;
+	uint8_t length;
+	uint8_t r[12];
+	uint8_t g[12];
+	uint8_t b[12];
+	uint8_t w[12];
+} ATTRIBUTE_PACKED SetRGBWValues_Request;
+
+typedef struct {
+	PacketHeader header;
+	uint16_t index;
+	uint8_t length;
+} ATTRIBUTE_PACKED GetRGBWValues_Request;
+
+typedef struct {
+	PacketHeader header;
+	uint8_t r[12];
+	uint8_t g[12];
+	uint8_t b[12];
+	uint8_t w[12];
+} ATTRIBUTE_PACKED GetRGBWValues_Response;
+
+typedef struct {
+	PacketHeader header;
+	uint8_t mapping;
+} ATTRIBUTE_PACKED SetChannelMapping_Request;
+
+typedef struct {
+	PacketHeader header;
+} ATTRIBUTE_PACKED GetChannelMapping_Request;
+
+typedef struct {
+	PacketHeader header;
+	uint8_t mapping;
+} ATTRIBUTE_PACKED GetChannelMapping_Response;
+
+typedef struct {
+	PacketHeader header;
+} ATTRIBUTE_PACKED EnableFrameRenderedCallback_Request;
+
+typedef struct {
+	PacketHeader header;
+} ATTRIBUTE_PACKED DisableFrameRenderedCallback_Request;
+
+typedef struct {
+	PacketHeader header;
+} ATTRIBUTE_PACKED IsFrameRenderedCallbackEnabled_Request;
+
+typedef struct {
+	PacketHeader header;
+	uint8_t enabled;
+} ATTRIBUTE_PACKED IsFrameRenderedCallbackEnabled_Response;
+
+typedef struct {
+	PacketHeader header;
+} ATTRIBUTE_PACKED GetIdentity_Request;
 
 typedef struct {
 	PacketHeader header;
@@ -111,7 +184,7 @@ typedef struct {
 	uint8_t hardware_version[3];
 	uint8_t firmware_version[3];
 	uint16_t device_identifier;
-} ATTRIBUTE_PACKED GetIdentityResponse_;
+} ATTRIBUTE_PACKED GetIdentity_Response;
 
 #if defined _MSC_VER || defined __BORLANDC__
 	#pragma pack(pop)
@@ -119,10 +192,18 @@ typedef struct {
 #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];
+	FrameRendered_CallbackFunction callback_function;
+	void *user_data;
+	FrameRendered_Callback *callback;
+
+	if (packet->header.length != sizeof(FrameRendered_Callback)) {
+		return; // silently ignoring callback with wrong length
+	}
+
+	callback_function = (FrameRendered_CallbackFunction)device_p->registered_callbacks[DEVICE_NUM_FUNCTION_IDS + LED_STRIP_CALLBACK_FRAME_RENDERED];
+	user_data = device_p->registered_callback_user_data[DEVICE_NUM_FUNCTION_IDS + LED_STRIP_CALLBACK_FRAME_RENDERED];
+	callback = (FrameRendered_Callback *)packet;
+	(void)callback; // avoid unused variable warning
 
 	if (callback_function == NULL) {
 		return;
@@ -134,9 +215,10 @@ static void led_strip_callback_wrapper_frame_rendered(DevicePrivate *device_p, P
 }
 
 void led_strip_create(LEDStrip *led_strip, const char *uid, IPConnection *ipcon) {
+	IPConnectionPrivate *ipcon_p = ipcon->p;
 	DevicePrivate *device_p;
 
-	device_create(led_strip, uid, ipcon->p, 2, 0, 1);
+	device_create(led_strip, uid, ipcon_p, 2, 0, 3, LED_STRIP_DEVICE_IDENTIFIER);
 
 	device_p = led_strip->p;
 
@@ -145,16 +227,26 @@ void led_strip_create(LEDStrip *led_strip, const char *uid, IPConnection *ipcon)
 	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_SET_CHIP_TYPE] = DEVICE_RESPONSE_EXPECTED_FALSE;
+	device_p->response_expected[LED_STRIP_FUNCTION_GET_CHIP_TYPE] = DEVICE_RESPONSE_EXPECTED_ALWAYS_TRUE;
+	device_p->response_expected[LED_STRIP_FUNCTION_SET_RGBW_VALUES] = DEVICE_RESPONSE_EXPECTED_FALSE;
+	device_p->response_expected[LED_STRIP_FUNCTION_GET_RGBW_VALUES] = DEVICE_RESPONSE_EXPECTED_ALWAYS_TRUE;
+	device_p->response_expected[LED_STRIP_FUNCTION_SET_CHANNEL_MAPPING] = DEVICE_RESPONSE_EXPECTED_FALSE;
+	device_p->response_expected[LED_STRIP_FUNCTION_GET_CHANNEL_MAPPING] = DEVICE_RESPONSE_EXPECTED_ALWAYS_TRUE;
+	device_p->response_expected[LED_STRIP_FUNCTION_ENABLE_FRAME_RENDERED_CALLBACK] = DEVICE_RESPONSE_EXPECTED_TRUE;
+	device_p->response_expected[LED_STRIP_FUNCTION_DISABLE_FRAME_RENDERED_CALLBACK] = DEVICE_RESPONSE_EXPECTED_TRUE;
+	device_p->response_expected[LED_STRIP_FUNCTION_IS_FRAME_RENDERED_CALLBACK_ENABLED] = 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;
+
+	ipcon_add_device(ipcon_p, device_p);
 }
 
 void led_strip_destroy(LEDStrip *led_strip) {
-	device_destroy(led_strip);
+	device_release(led_strip->p);
 }
 
 int led_strip_get_response_expected(LEDStrip *led_strip, uint8_t function_id, bool *ret_response_expected) {
@@ -169,8 +261,8 @@ int led_strip_set_response_expected_all(LEDStrip *led_strip, bool response_expec
 	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);
+void led_strip_register_callback(LEDStrip *led_strip, int16_t callback_id, void (*function)(void), void *user_data) {
+	device_register_callback(led_strip->p, callback_id, function, user_data);
 }
 
 int led_strip_get_api_version(LEDStrip *led_strip, uint8_t ret_api_version[3]) {
@@ -179,9 +271,15 @@ int led_strip_get_api_version(LEDStrip *led_strip, uint8_t ret_api_version[3]) {
 
 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;
+	SetRGBValues_Request request;
 	int ret;
 
+	ret = device_check_validity(device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
 	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_SET_RGB_VALUES, device_p->ipcon_p, device_p);
 
 	if (ret < 0) {
@@ -194,18 +292,23 @@ int led_strip_set_rgb_values(LEDStrip *led_strip, uint16_t index, uint8_t length
 	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);
-
+	ret = device_send_request(device_p, (Packet *)&request, NULL, 0);
 
 	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;
+	GetRGBValues_Request request;
+	GetRGBValues_Response response;
 	int ret;
 
+	ret = device_check_validity(device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
 	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_GET_RGB_VALUES, device_p->ipcon_p, device_p);
 
 	if (ret < 0) {
@@ -215,25 +318,30 @@ int led_strip_get_rgb_values(LEDStrip *led_strip, uint16_t index, uint8_t length
 	request.index = leconvert_uint16_to(index);
 	request.length = length;
 
-	ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
+	ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response, sizeof(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;
+	SetFrameDuration_Request request;
 	int ret;
 
+	ret = device_check_validity(device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
 	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_SET_FRAME_DURATION, device_p->ipcon_p, device_p);
 
 	if (ret < 0) {
@@ -242,67 +350,80 @@ int led_strip_set_frame_duration(LEDStrip *led_strip, uint16_t duration) {
 
 	request.duration = leconvert_uint16_to(duration);
 
-	ret = device_send_request(device_p, (Packet *)&request, NULL);
-
+	ret = device_send_request(device_p, (Packet *)&request, NULL, 0);
 
 	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;
+	GetFrameDuration_Request request;
+	GetFrameDuration_Response response;
 	int ret;
 
+	ret = device_check_validity(device_p);
+
+	if (ret < 0) {
+		return 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);
+	ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response, sizeof(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;
+	GetSupplyVoltage_Request request;
+	GetSupplyVoltage_Response response;
 	int ret;
 
+	ret = device_check_validity(device_p);
+
+	if (ret < 0) {
+		return 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);
+	ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response, sizeof(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;
+	SetClockFrequency_Request request;
 	int ret;
 
+	ret = device_check_validity(device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
 	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_SET_CLOCK_FREQUENCY, device_p->ipcon_p, device_p);
 
 	if (ret < 0) {
@@ -311,41 +432,287 @@ int led_strip_set_clock_frequency(LEDStrip *led_strip, uint32_t frequency) {
 
 	request.frequency = leconvert_uint32_to(frequency);
 
-	ret = device_send_request(device_p, (Packet *)&request, NULL);
-
+	ret = device_send_request(device_p, (Packet *)&request, NULL, 0);
 
 	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;
+	GetClockFrequency_Request request;
+	GetClockFrequency_Response response;
 	int ret;
 
+	ret = device_check_validity(device_p);
+
+	if (ret < 0) {
+		return 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);
+	ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response, sizeof(response));
 
 	if (ret < 0) {
 		return ret;
 	}
+
 	*ret_frequency = leconvert_uint32_from(response.frequency);
 
+	return ret;
+}
 
+int led_strip_set_chip_type(LEDStrip *led_strip, uint16_t chip) {
+	DevicePrivate *device_p = led_strip->p;
+	SetChipType_Request request;
+	int ret;
+
+	ret = device_check_validity(device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_SET_CHIP_TYPE, device_p->ipcon_p, device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	request.chip = leconvert_uint16_to(chip);
+
+	ret = device_send_request(device_p, (Packet *)&request, NULL, 0);
+
+	return ret;
+}
+
+int led_strip_get_chip_type(LEDStrip *led_strip, uint16_t *ret_chip) {
+	DevicePrivate *device_p = led_strip->p;
+	GetChipType_Request request;
+	GetChipType_Response response;
+	int ret;
+
+	ret = device_check_validity(device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_GET_CHIP_TYPE, device_p->ipcon_p, device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response, sizeof(response));
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	*ret_chip = leconvert_uint16_from(response.chip);
+
+	return ret;
+}
+
+int led_strip_set_rgbw_values(LEDStrip *led_strip, uint16_t index, uint8_t length, uint8_t r[12], uint8_t g[12], uint8_t b[12], uint8_t w[12]) {
+	DevicePrivate *device_p = led_strip->p;
+	SetRGBWValues_Request request;
+	int ret;
+
+	ret = device_check_validity(device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_SET_RGBW_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, 12 * sizeof(uint8_t));
+	memcpy(request.g, g, 12 * sizeof(uint8_t));
+	memcpy(request.b, b, 12 * sizeof(uint8_t));
+	memcpy(request.w, w, 12 * sizeof(uint8_t));
+
+	ret = device_send_request(device_p, (Packet *)&request, NULL, 0);
+
+	return ret;
+}
+
+int led_strip_get_rgbw_values(LEDStrip *led_strip, uint16_t index, uint8_t length, uint8_t ret_r[12], uint8_t ret_g[12], uint8_t ret_b[12], uint8_t ret_w[12]) {
+	DevicePrivate *device_p = led_strip->p;
+	GetRGBWValues_Request request;
+	GetRGBWValues_Response response;
+	int ret;
+
+	ret = device_check_validity(device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_GET_RGBW_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, sizeof(response));
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	memcpy(ret_r, response.r, 12 * sizeof(uint8_t));
+	memcpy(ret_g, response.g, 12 * sizeof(uint8_t));
+	memcpy(ret_b, response.b, 12 * sizeof(uint8_t));
+	memcpy(ret_w, response.w, 12 * sizeof(uint8_t));
+
+	return ret;
+}
+
+int led_strip_set_channel_mapping(LEDStrip *led_strip, uint8_t mapping) {
+	DevicePrivate *device_p = led_strip->p;
+	SetChannelMapping_Request request;
+	int ret;
+
+	ret = device_check_validity(device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_SET_CHANNEL_MAPPING, device_p->ipcon_p, device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	request.mapping = mapping;
+
+	ret = device_send_request(device_p, (Packet *)&request, NULL, 0);
+
+	return ret;
+}
+
+int led_strip_get_channel_mapping(LEDStrip *led_strip, uint8_t *ret_mapping) {
+	DevicePrivate *device_p = led_strip->p;
+	GetChannelMapping_Request request;
+	GetChannelMapping_Response response;
+	int ret;
+
+	ret = device_check_validity(device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_GET_CHANNEL_MAPPING, device_p->ipcon_p, device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response, sizeof(response));
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	*ret_mapping = response.mapping;
+
+	return ret;
+}
+
+int led_strip_enable_frame_rendered_callback(LEDStrip *led_strip) {
+	DevicePrivate *device_p = led_strip->p;
+	EnableFrameRenderedCallback_Request request;
+	int ret;
+
+	ret = device_check_validity(device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_ENABLE_FRAME_RENDERED_CALLBACK, device_p->ipcon_p, device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	ret = device_send_request(device_p, (Packet *)&request, NULL, 0);
+
+	return ret;
+}
+
+int led_strip_disable_frame_rendered_callback(LEDStrip *led_strip) {
+	DevicePrivate *device_p = led_strip->p;
+	DisableFrameRenderedCallback_Request request;
+	int ret;
+
+	ret = device_check_validity(device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_DISABLE_FRAME_RENDERED_CALLBACK, device_p->ipcon_p, device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	ret = device_send_request(device_p, (Packet *)&request, NULL, 0);
+
+	return ret;
+}
+
+int led_strip_is_frame_rendered_callback_enabled(LEDStrip *led_strip, bool *ret_enabled) {
+	DevicePrivate *device_p = led_strip->p;
+	IsFrameRenderedCallbackEnabled_Request request;
+	IsFrameRenderedCallbackEnabled_Response response;
+	int ret;
+
+	ret = device_check_validity(device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_IS_FRAME_RENDERED_CALLBACK_ENABLED, device_p->ipcon_p, device_p);
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response, sizeof(response));
+
+	if (ret < 0) {
+		return ret;
+	}
+
+	*ret_enabled = response.enabled != 0;
 
 	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;
+	GetIdentity_Request request;
+	GetIdentity_Response response;
 	int ret;
 
 	ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_GET_IDENTITY, device_p->ipcon_p, device_p);
@@ -354,20 +721,22 @@ int led_strip_get_identity(LEDStrip *led_strip, char ret_uid[8], char ret_connec
 		return ret;
 	}
 
-
-	ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
+	ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response, sizeof(response));
 
 	if (ret < 0) {
 		return ret;
 	}
-	strncpy(ret_uid, response.uid, 8);
-	strncpy(ret_connected_uid, response.connected_uid, 8);
+
+	memcpy(ret_uid, response.uid, 8);
+	memcpy(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;
 }
+
+#ifdef __cplusplus
+}
+#endif

dependencies/include/tinkerforge/bricklet_led_strip.h

@@ -1,11 +1,11 @@
 /* ***********************************************************
- * This file was automatically generated on 2013-12-19.      *
+ * This file was automatically generated on 2023-11-30.      *
  *                                                           *
- * Bindings Version 2.0.13                                    *
+ * C/C++ Bindings Version 2.1.33                             *
  *                                                           *
  * 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                   *
+ * to the generators git repository on tinkerforge.com       *
  *************************************************************/
 
 #ifndef BRICKLET_LED_STRIP_H
@@ -13,14 +13,18 @@
 
 #include "ip_connection.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /**
- * \defgroup BrickletLEDStrip LEDStrip Bricklet
+ * \defgroup BrickletLEDStrip LED Strip Bricklet
  */
 
 /**
  * \ingroup BrickletLEDStrip
  *
- * Device to control up to 320 RGB LEDs
+ * Controls up to 320 RGB LEDs
  */
 typedef Device LEDStrip;
 
@@ -59,6 +63,51 @@ typedef Device LEDStrip;
  */
 #define LED_STRIP_FUNCTION_GET_CLOCK_FREQUENCY 8
 
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_FUNCTION_SET_CHIP_TYPE 9
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_FUNCTION_GET_CHIP_TYPE 10
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_FUNCTION_SET_RGBW_VALUES 11
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_FUNCTION_GET_RGBW_VALUES 12
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_FUNCTION_SET_CHANNEL_MAPPING 13
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_FUNCTION_GET_CHANNEL_MAPPING 14
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_FUNCTION_ENABLE_FRAME_RENDERED_CALLBACK 15
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_FUNCTION_DISABLE_FRAME_RENDERED_CALLBACK 16
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_FUNCTION_IS_FRAME_RENDERED_CALLBACK_ENABLED 17
+
 /**
  * \ingroup BrickletLEDStrip
  */
@@ -68,21 +117,197 @@ typedef Device LEDStrip;
  * \ingroup BrickletLEDStrip
  *
  * Signature: \code void callback(uint16_t length, void *user_data) \endcode
- * 
- * This callback is triggered directly after a new frame is rendered.
- * 
+ *
+ * This callback is triggered directly after a new frame is rendered. The
+ * parameter is the number of RGB or RGBW LEDs in that frame.
+ *
  * 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
+ */
+#define LED_STRIP_CHIP_TYPE_WS2801 2801
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHIP_TYPE_WS2811 2811
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHIP_TYPE_WS2812 2812
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHIP_TYPE_LPD8806 8806
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHIP_TYPE_APA102 102
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_RGB 6
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_RBG 9
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_BRG 33
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_BGR 36
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_GRB 18
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_GBR 24
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_RGBW 27
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_RGWB 30
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_RBGW 39
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_RBWG 45
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_RWGB 54
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_RWBG 57
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_GRWB 78
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_GRBW 75
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_GBWR 108
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_GBRW 99
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_GWBR 120
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_GWRB 114
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_BRGW 135
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_BRWG 141
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_BGRW 147
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_BGWR 156
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_BWRG 177
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_BWGR 180
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_WRBG 201
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_WRGB 198
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_WGBR 216
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_WGRB 210
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_WBGR 228
+
+/**
+ * \ingroup BrickletLEDStrip
+ */
+#define LED_STRIP_CHANNEL_MAPPING_WBRG 225
+
 /**
  * \ingroup BrickletLEDStrip
  *
- * This constant is used to identify a LEDStrip Bricklet.
+ * This constant is used to identify a LED Strip Bricklet.
  *
  * The {@link led_strip_get_identity} function and the
  * {@link IPCON_CALLBACK_ENUMERATE} callback of the IP Connection have a
@@ -90,6 +315,13 @@ typedef Device LEDStrip;
  */
 #define LED_STRIP_DEVICE_IDENTIFIER 231
 
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * This constant represents the display name of a LED Strip Bricklet.
+ */
+#define LED_STRIP_DEVICE_DISPLAY_NAME "LED Strip Bricklet"
+
 /**
  * \ingroup BrickletLEDStrip
  *
@@ -122,7 +354,7 @@ void led_strip_destroy(LEDStrip *led_strip);
  * 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
+ * disabled for a setter function then no response is sent 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);
@@ -133,13 +365,12 @@ int led_strip_get_response_expected(LEDStrip *led_strip, uint8_t function_id, bo
  * 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.
+ * (default value: *true*). For getter functions it is always 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,
+ * setter function then no response is sent 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);
@@ -155,10 +386,10 @@ int led_strip_set_response_expected_all(LEDStrip *led_strip, bool response_expec
 /**
  * \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.
+ * Registers the given \c function with the given \c callback_id. The
+ * \c user_data will be passed as the last parameter to the \c function.
  */
-void led_strip_register_callback(LEDStrip *led_strip, uint8_t id, void *callback, void *user_data);
+void led_strip_register_callback(LEDStrip *led_strip, int16_t callback_id, void (*function)(void), void *user_data);
 
 /**
  * \ingroup BrickletLEDStrip
@@ -171,38 +402,40 @@ 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.
- * 
+ * Sets *length* RGB values for the LEDs starting from *index*.
+ *
+ * To make the colors show correctly you need to configure the chip type
+ * ({@link led_strip_set_chip_type}) and a 3-channel channel mapping ({@link led_strip_set_channel_mapping})
+ * according to the connected LEDs.
+ *
  * 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.
- * 
+ *
+ * \note Depending on the LED circuitry colors can be permuted.
+ *
  * The colors will be transfered to actual LEDs when the next
  * frame duration ends, see {@link led_strip_set_frame_duration}.
- * 
- * Generic approach: 
- * 
+ *
+ * Generic approach:
+ *
  * * Set the frame duration to a value that represents
- *   the number of frames per second you want to achieve. 
+ *   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
@@ -213,9 +446,9 @@ int led_strip_set_rgb_values(LEDStrip *led_strip, uint16_t index, uint8_t length
 /**
  * \ingroup BrickletLEDStrip
  *
- * Returns the rgb with the given *length* starting from the
- * given *index*.
- * 
+ * Returns *length* R, G and B values starting from the
+ * given LED *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]);
@@ -223,14 +456,12 @@ int led_strip_get_rgb_values(LEDStrip *led_strip, uint16_t index, uint8_t length
 /**
  * \ingroup BrickletLEDStrip
  *
- * Sets the frame duration in ms.
- * 
+ * Sets the frame duration.
+ *
  * Example: If you want to achieve 20 frames per second, you should
- * set the frame duration to 50ms (50ms * 20 = 1 second). 
- * 
+ * 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);
 
@@ -244,58 +475,223 @@ 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.
+ * Returns the current supply voltage of the LEDs.
  */
 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).
- * 
+ * Sets the frequency of the clock.
+ *
  * 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)
+ *
+ * .. versionadded:: 2.0.1$nbsp;(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)
+ * Returns the currently used clock frequency as set by {@link led_strip_set_clock_frequency}.
+ *
+ * .. versionadded:: 2.0.1$nbsp;(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, 
+ * Sets the type of the LED driver chip. We currently support the chips
+ *
+ * * WS2801,
+ * * WS2811,
+ * * WS2812 / SK6812 / NeoPixel RGB,
+ * * SK6812RGBW / NeoPixel RGBW (Chip Type = WS2812),
+ * * LPD8806 and
+ * * APA102 / DotStar.
+ *
+ * .. versionadded:: 2.0.2$nbsp;(Plugin)
+ */
+int led_strip_set_chip_type(LEDStrip *led_strip, uint16_t chip);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Returns the currently used chip type as set by {@link led_strip_set_chip_type}.
+ *
+ * .. versionadded:: 2.0.2$nbsp;(Plugin)
+ */
+int led_strip_get_chip_type(LEDStrip *led_strip, uint16_t *ret_chip);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Sets *length* RGBW values for the LEDs starting from *index*.
+ *
+ * To make the colors show correctly you need to configure the chip type
+ * ({@link led_strip_set_chip_type}) and a 4-channel channel mapping ({@link led_strip_set_channel_mapping})
+ * according to the connected LEDs.
+ *
+ * The maximum length is 12, the index goes from 0 to 239 and the rgbw values
+ * have 8 bits each.
+ *
+ * Example: If you set
+ *
+ * * index to 5,
+ * * length to 4,
+ * * r to [255, 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],
+ * * b to [0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0] and
+ * * w to [0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+ *
+ * the LED with index 5 will be red, 6 will be green, 7 will be blue and 8 will be white.
+ *
+ * \note Depending on the LED circuitry colors can be permuted.
+ *
+ * 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_rgbw_values} with index + length above the
+ * bounds is ignored completely.
+ *
+ * The LPD8806 LED driver chips have 7-bit channels for RGB. Internally the LED
+ * Strip Bricklets divides the 8-bit values set using this function by 2 to make
+ * them 7-bit. Therefore, you can just use the normal value range (0-255) for
+ * LPD8806 LEDs.
+ *
+ * The brightness channel of the APA102 LED driver chips has 5-bit. Internally the
+ * LED Strip Bricklets divides the 8-bit values set using this function by 8 to make
+ * them 5-bit. Therefore, you can just use the normal value range (0-255) for
+ * the brightness channel of APA102 LEDs.
+ *
+ * .. versionadded:: 2.0.6$nbsp;(Plugin)
+ */
+int led_strip_set_rgbw_values(LEDStrip *led_strip, uint16_t index, uint8_t length, uint8_t r[12], uint8_t g[12], uint8_t b[12], uint8_t w[12]);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Returns *length* RGBW values starting from the given *index*.
+ *
+ * The values are the last values that were set by {@link led_strip_set_rgbw_values}.
+ *
+ * .. versionadded:: 2.0.6$nbsp;(Plugin)
+ */
+int led_strip_get_rgbw_values(LEDStrip *led_strip, uint16_t index, uint8_t length, uint8_t ret_r[12], uint8_t ret_g[12], uint8_t ret_b[12], uint8_t ret_w[12]);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Sets the channel mapping for the connected LEDs.
+ *
+ * {@link led_strip_set_rgb_values} and {@link led_strip_set_rgbw_values} take the data in RGB(W) order.
+ * But the connected LED driver chips might have their 3 or 4 channels in a
+ * different order. For example, the WS2801 chips typically use BGR order, the
+ * WS2812 chips typically use GRB order and the APA102 chips typically use WBGR
+ * order.
+ *
+ * The APA102 chips are special. They have three 8-bit channels for RGB
+ * and an additional 5-bit channel for the overall brightness of the RGB LED
+ * making them 4-channel chips. Internally the brightness channel is the first
+ * channel, therefore one of the Wxyz channel mappings should be used. Then
+ * the W channel controls the brightness.
+ *
+ * If a 3-channel mapping is selected then {@link led_strip_set_rgb_values} has to be used.
+ * Calling {@link led_strip_set_rgbw_values} with a 3-channel mapping will produce incorrect
+ * results. Vice-versa if a 4-channel mapping is selected then
+ * {@link led_strip_set_rgbw_values} has to be used. Calling {@link led_strip_set_rgb_values} with a
+ * 4-channel mapping will produce incorrect results.
+ *
+ * .. versionadded:: 2.0.6$nbsp;(Plugin)
+ */
+int led_strip_set_channel_mapping(LEDStrip *led_strip, uint8_t mapping);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Returns the currently used channel mapping as set by {@link led_strip_set_channel_mapping}.
+ *
+ * .. versionadded:: 2.0.6$nbsp;(Plugin)
+ */
+int led_strip_get_channel_mapping(LEDStrip *led_strip, uint8_t *ret_mapping);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Enables the {@link LED_STRIP_CALLBACK_FRAME_RENDERED} callback.
+ *
+ * By default the callback is enabled.
+ *
+ * .. versionadded:: 2.0.6$nbsp;(Plugin)
+ */
+int led_strip_enable_frame_rendered_callback(LEDStrip *led_strip);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Disables the {@link LED_STRIP_CALLBACK_FRAME_RENDERED} callback.
+ *
+ * By default the callback is enabled.
+ *
+ * .. versionadded:: 2.0.6$nbsp;(Plugin)
+ */
+int led_strip_disable_frame_rendered_callback(LEDStrip *led_strip);
+
+/**
+ * \ingroup BrickletLEDStrip
+ *
+ * Returns *true* if the {@link LED_STRIP_CALLBACK_FRAME_RENDERED} callback is enabled, *false* otherwise.
+ *
+ * .. versionadded:: 2.0.6$nbsp;(Plugin)
+ */
+int led_strip_is_frame_rendered_callback_enabled(LEDStrip *led_strip, bool *ret_enabled);
+
+/**
+ * \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)
+ *
+ * The position can be 'a', 'b', 'c', 'd', 'e', 'f', 'g' or 'h' (Bricklet Port).
+ * A Bricklet connected to an :ref:`Isolator Bricklet <isolator_bricklet>` is always at
+ * position 'z'.
+ *
+ * The device identifier numbers can be found :ref:`here <device_identifier>`.
+ * |device_identifier_constant|
  */
 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);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif

dependencies/include/tinkerforge/ip_connection.h

@@ -1,9 +1,10 @@
 /*
- * Copyright (C) 2012-2013 Matthias Bolte <matthias@tinkerforge.com>
+ * Copyright (C) 2012-2014, 2019-2020 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.
+ * with or without modification, are permitted. See the Creative
+ * Commons Zero (CC0 1.0) License for more details.
  */
 
 #ifndef IP_CONNECTION_H
@@ -16,11 +17,12 @@
 #ifndef __STDC_LIMIT_MACROS
 	#define __STDC_LIMIT_MACROS
 #endif
+
 #include <stdint.h>
 #include <string.h>
 #include <stdlib.h>
 
-#if !defined __cplusplus && defined __GNUC__
+#if !defined __cplusplus && (defined __GNUC__ || (defined _MSC_VER && _MSC_VER >= 1600))
 	#include <stdbool.h>
 #endif
 
@@ -34,6 +36,10 @@
 	#include <semaphore.h>
 #endif
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 enum {
 	E_OK = 0,
 	E_TIMEOUT = -1,
@@ -46,9 +52,21 @@ enum {
 	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
+	E_UNKNOWN_ERROR_CODE = -11, // error response from device
+	E_STREAM_OUT_OF_SYNC = -12,
+	E_INVALID_UID = -13,
+	E_NON_ASCII_CHAR_IN_SECRET = -14,
+	E_WRONG_DEVICE_TYPE = -15,
+	E_DEVICE_REPLACED = -16,
+	E_WRONG_RESPONSE_LENGTH = -17
 };
 
+#ifdef IPCON_EXPOSE_MILLISLEEP
+
+void millisleep(uint32_t msec);
+
+#endif // IPCON_EXPOSE_MILLISLEEP
+
 #ifdef IPCON_EXPOSE_INTERNALS
 
 typedef struct _Socket Socket;
@@ -113,7 +131,6 @@ typedef struct _QueueItem {
 	struct _QueueItem *next;
 	int kind;
 	void *data;
-	int length;
 } QueueItem;
 
 typedef struct {
@@ -130,7 +147,7 @@ typedef struct {
 #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
+		// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52991
 		#define ATTRIBUTE_PACKED __attribute__((gcc_struct, packed))
 	#else
 		#define ATTRIBUTE_PACKED __attribute__((packed))
@@ -140,7 +157,7 @@ typedef struct {
 #endif
 
 typedef struct {
-	uint32_t uid;
+	uint32_t uid; // always little endian
 	uint8_t length;
 	uint8_t function_id;
 	uint8_t sequence_number_and_options;
@@ -168,24 +185,35 @@ typedef struct _DevicePrivate DevicePrivate;
 #ifdef IPCON_EXPOSE_INTERNALS
 
 typedef struct _CallbackContext CallbackContext;
+typedef struct _HighLevelCallback HighLevelCallback;
+
+/**
+ * \internal
+ */
+struct _HighLevelCallback {
+	bool exists;
+	void *data;
+	size_t length;
+};
 
 #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);
+										  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);
+										  void *user_data);
 typedef void (*DisconnectedCallbackFunction)(uint8_t disconnect_reason,
-                                             void *user_data);
+											 void *user_data);
 
 #ifdef IPCON_EXPOSE_INTERNALS
 
+typedef void (*CallbackFunction)(void);
 typedef void (*CallbackWrapperFunction)(DevicePrivate *device_p, Packet *packet);
 
 #endif
@@ -201,16 +229,31 @@ struct _Device {
 
 #define DEVICE_NUM_FUNCTION_IDS 256
 
+typedef enum {
+	DEVICE_IDENTIFIER_CHECK_PENDING = 0,
+	DEVICE_IDENTIFIER_CHECK_MATCH = 1,
+	DEVICE_IDENTIFIER_CHECK_MISMATCH = 2
+} DeviceIdentifierCheck;
+
 /**
  * \internal
  */
 struct _DevicePrivate {
-	uint32_t uid;
+	int ref_count;
+
+	bool replaced;
+
+	uint32_t uid; // always host endian
+	bool uid_valid;
 
 	IPConnectionPrivate *ipcon_p;
 
 	uint8_t api_version[3];
 
+	uint16_t device_identifier;
+	Mutex device_identifier_mutex;
+	DeviceIdentifierCheck device_identifier_check; // protected by device_identifier_mutex
+
 	Mutex request_mutex;
 
 	uint8_t expected_response_function_id; // protected by request_mutex
@@ -220,9 +263,12 @@ struct _DevicePrivate {
 	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];
+	Mutex stream_mutex;
+
+	CallbackFunction registered_callbacks[DEVICE_NUM_FUNCTION_IDS * 2];
+	void *registered_callback_user_data[DEVICE_NUM_FUNCTION_IDS * 2];
 	CallbackWrapperFunction callback_wrappers[DEVICE_NUM_FUNCTION_IDS];
+	HighLevelCallback high_level_callbacks[DEVICE_NUM_FUNCTION_IDS];
 };
 
 /**
@@ -231,7 +277,6 @@ struct _DevicePrivate {
 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
 };
@@ -240,25 +285,26 @@ enum {
  * \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);
+				   IPConnectionPrivate *ipcon_p, uint8_t api_version_major,
+				   uint8_t api_version_minor, uint8_t api_version_release,
+				   uint16_t device_identifier);
 
 /**
  * \internal
  */
-void device_destroy(Device *device);
+void device_release(DevicePrivate *device_p);
 
 /**
  * \internal
  */
 int device_get_response_expected(DevicePrivate *device_p, uint8_t function_id,
-                                 bool *ret_response_expected);
+								 bool *ret_response_expected);
 
 /**
  * \internal
  */
 int device_set_response_expected(DevicePrivate *device_p, uint8_t function_id,
-                                 bool response_expected);
+								 bool response_expected);
 
 /**
  * \internal
@@ -268,8 +314,8 @@ int device_set_response_expected_all(DevicePrivate *device_p, bool response_expe
 /**
  * \internal
  */
-void device_register_callback(DevicePrivate *device_p, uint8_t id, void *callback,
-                              void *user_data);
+void device_register_callback(DevicePrivate *device_p, int16_t callback_id,
+							  void (*function)(void), void *user_data);
 
 /**
  * \internal
@@ -279,7 +325,13 @@ 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);
+int device_send_request(DevicePrivate *device_p, Packet *request, Packet *response,
+						int expected_response_length);
+
+/**
+ * \internal
+ */
+int device_check_validity(DevicePrivate *device_p);
 
 #endif // IPCON_EXPOSE_INTERNALS
 
@@ -347,6 +399,12 @@ struct _IPConnection {
 #ifdef IPCON_EXPOSE_INTERNALS
 
 #define IPCON_NUM_CALLBACK_IDS 256
+#define IPCON_MAX_SECRET_LENGTH 64
+
+/**
+ * \internal
+ */
+typedef Device BrickDaemon;
 
 /**
  * \internal
@@ -368,9 +426,13 @@ struct _IPConnectionPrivate {
 	Mutex sequence_number_mutex;
 	uint8_t next_sequence_number; // protected by sequence_number_mutex
 
+	Mutex authentication_mutex; // protects authentication handshake
+	uint32_t next_authentication_nonce; // protected by authentication_mutex
+
+	Mutex devices_ref_mutex; // protects DevicePrivate.ref_count
 	Table devices;
 
-	void *registered_callbacks[IPCON_NUM_CALLBACK_IDS];
+	CallbackFunction registered_callbacks[IPCON_NUM_CALLBACK_IDS];
 	void *registered_callback_user_data[IPCON_NUM_CALLBACK_IDS];
 
 	Mutex socket_mutex;
@@ -387,6 +449,8 @@ struct _IPConnectionPrivate {
 	Event disconnect_probe_event;
 
 	Semaphore wait;
+
+	BrickDaemon brickd;
 };
 
 #endif // IPCON_EXPOSE_INTERNALS
@@ -431,6 +495,21 @@ int ipcon_connect(IPConnection *ipcon, const char *host, uint16_t port);
  */
 int ipcon_disconnect(IPConnection *ipcon);
 
+/**
+ * \ingroup IPConnection
+ *
+ * Performs an authentication handshake with the connected Brick Daemon or
+ * WIFI/Ethernet Extension. If the handshake succeeds the connection switches
+ * from non-authenticated to authenticated state and communication can
+ * continue as normal. If the handshake fails then the connection gets closed.
+ * Authentication can fail if the wrong secret was used or if authentication
+ * is not enabled at all on the Brick Daemon or the WIFI/Ethernet Extension.
+ *
+ * For more information about authentication see
+ * https://www.tinkerforge.com/en/doc/Tutorials/Tutorial_Authentication/Tutorial.html
+ */
+int ipcon_authenticate(IPConnection *ipcon, const char *secret);
+
 /**
  * \ingroup IPConnection
  *
@@ -514,19 +593,25 @@ void ipcon_unwait(IPConnection *ipcon);
 /**
  * \ingroup IPConnection
  *
- * Registers a callback for a given ID.
+ * Registers the given \c function with the given \c callback_id. The
+ * \c user_data will be passed as the last parameter to the \c function.
  */
-void ipcon_register_callback(IPConnection *ipcon, uint8_t id,
-                             void *callback, void *user_data);
+void ipcon_register_callback(IPConnection *ipcon, int16_t callback_id,
+							 void (*function)(void), void *user_data);
 
 #ifdef IPCON_EXPOSE_INTERNALS
 
+/**
+ * \internal
+ */
+void ipcon_add_device(IPConnectionPrivate *ipcon_p, DevicePrivate *device_p);
+
 /**
  * \internal
  */
 int packet_header_create(PacketHeader *header, uint8_t length,
-                         uint8_t function_id, IPConnectionPrivate *ipcon_p,
-                         DevicePrivate *device_p);
+						 uint8_t function_id, IPConnectionPrivate *ipcon_p,
+						 DevicePrivate *device_p);
 
 /**
  * \internal
@@ -536,8 +621,7 @@ uint8_t packet_header_get_sequence_number(PacketHeader *header);
 /**
  * \internal
  */
-void packet_header_set_sequence_number(PacketHeader *header,
-                                       uint8_t sequence_number);
+void packet_header_set_sequence_number(PacketHeader *header, uint8_t sequence_number);
 
 /**
  * \internal
@@ -547,8 +631,7 @@ uint8_t packet_header_get_response_expected(PacketHeader *header);
 /**
  * \internal
  */
-void packet_header_set_response_expected(PacketHeader *header,
-                                         uint8_t response_expected);
+void packet_header_set_response_expected(PacketHeader *header, bool response_expected);
 
 /**
  * \internal
@@ -625,6 +708,15 @@ uint64_t leconvert_uint64_from(uint64_t little);
  */
 float leconvert_float_from(float little);
 
+/**
+ * \internal
+ */
+char *string_copy(char *dest, const char *src, size_t n);
+
 #endif // IPCON_EXPOSE_INTERNALS
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif