Merge branch 'develop'

Author: simon-wh

.gitmodules

@@ -1,3 +1,4 @@
 [submodule "hidapi"]
 	path = hidapi
-	url = https://github.com/PastaJ36/hidapi.git
+	url = https://github.com/libusb/hidapi.git
+	branch = master

hidapi

@@ -24,11 +24,13 @@ static uint8_t rgb_buffer0[RGB_RAW_BUFFER_SIZE] = { 0 };
 static uint8_t rgb_buffer1[RGB_RAW_BUFFER_SIZE] = { 0 };
 static uint8_t rgb_buffer2[RGB_RAW_BUFFER_SIZE] = { 0 };
 static uint8_t rgb_buffer3[RGB_RAW_BUFFER_SIZE] = { 0 };
+static uint8_t rgb_buffer4[RGB_RAW_BUFFER_SIZE] = { 0 };
 
 static bool rgb_buffer0_changed = false;
 static bool rgb_buffer1_changed = false;
 static bool rgb_buffer2_changed = false;
 static bool rgb_buffer3_changed = false;
+static bool rgb_buffer4_changed = false;
 
 // Converts the array index to a memory location in the RGB buffers
 static uint8_t get_safe_led_idex(uint8_t row, uint8_t column) {
@@ -41,7 +43,8 @@ static uint8_t get_safe_led_idex(uint8_t row, uint8_t column) {
 		{ 10, 22, 21, NOLED, NOLED, NOLED, 33, NOLED, NOLED, NOLED, 94, 58, 67, 68, 70, 79, 82, NOLED, 111, 112, NOLED }
 	};
 
-	if (row < WOOTING_RGB_ROWS && column < WOOTING_RGB_COLS) {
+	WOOTING_USB_META* meta = wooting_usb_get_meta();
+	if (row < meta->max_rows && column < meta->max_columns) {
 		return rgb_led_index[row][column];
 	} else {
 		return NOLED;
@@ -59,6 +62,7 @@ void wooting_rgb_set_disconnected_cb(void_cb cb) {
 bool wooting_rgb_reset() {
 	if (wooting_usb_send_feature(WOOTING_RESET_ALL_COMMAND, 0, 0, 0, 0)) {
 		wooting_usb_disconnect(false);
+		return true;
 	}
 	else {
 		return false;
@@ -144,6 +148,13 @@ bool wooting_rgb_array_update_keyboard() {
 		rgb_buffer3_changed = false;
 	}
 
+	if (rgb_buffer4_changed && wooting_usb_get_meta()->device_type == DEVICE_KEYBOARD) {
+		if (!wooting_usb_send_buffer(PART4, rgb_buffer4)) {
+			return false;
+		}
+		rgb_buffer4_changed = false;
+	}
+
 	return true;
 }
 
@@ -155,13 +166,19 @@ static bool wooting_rgb_array_change_single(uint8_t row, uint8_t column, uint8_t
 		0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d,
 		0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d
 	};
+
 	uint8_t led_index = get_safe_led_idex(row, column);
 	uint8_t *buffer_pointer;
 
-	if (led_index >= 96) {
+	// prevent assigning led's that don't exist
+	if (led_index > wooting_usb_get_meta()->led_index_max) {
 		return false;
 	}
-	if (led_index >= 72) {
+	if (led_index >= 96) {
+		buffer_pointer = rgb_buffer4;
+		rgb_buffer4_changed = true;
+	}
+	else if (led_index >= 72) {
 		buffer_pointer = rgb_buffer3;
 		rgb_buffer3_changed = true;
 	}
@@ -189,7 +206,7 @@ static bool wooting_rgb_array_change_single(uint8_t row, uint8_t column, uint8_t
 		rgb_buffer2[iso_enter_index + 0x10] = rgb_buffer2[buffer_index + 0x10];
 		rgb_buffer2[iso_enter_index + 0x20] = rgb_buffer2[buffer_index + 0x20];
 	}
-	if (led_index == LED_LEFT_SHIFT_ANSI) {
+	else if (led_index == LED_LEFT_SHIFT_ANSI) {
 		uint8_t iso_shift_index = pwm_mem_map[LED_LEFT_SHIFT_ISO];
 		rgb_buffer0[iso_shift_index] = rgb_buffer0[buffer_index];
 		rgb_buffer0[iso_shift_index + 0x10] = rgb_buffer0[buffer_index + 0x10];
@@ -213,16 +230,18 @@ bool wooting_rgb_array_set_single(uint8_t row, uint8_t column, uint8_t red, uint
 }
 
 bool wooting_rgb_array_set_full(const uint8_t* colors_buffer) {
-	int baseIndex = 0;
-	for (int row = 0; row < WOOTING_RGB_ROWS; row++) {
-		for (int col = 0; col < WOOTING_RGB_COLS; col++) {
-			uint8_t red = colors_buffer[baseIndex + 0];
-			uint8_t green = colors_buffer[baseIndex + 1];
-			uint8_t blue = colors_buffer[baseIndex + 2];
+	const uint8_t columns = wooting_usb_get_meta()->max_columns;
+
+	for (uint8_t row = 0; row < WOOTING_RGB_ROWS; row++) {
+		const uint8_t* color = colors_buffer + row * WOOTING_RGB_COLS * 3;
+		for (uint8_t col = 0; col < columns; col++) {
+			uint8_t red = color[0];
+			uint8_t green = color[1];
+			uint8_t blue = color[2];
 
 			wooting_rgb_array_change_single(row, col, red, green, blue);
 
-			baseIndex += 3;
+			color += 3;
 		}
 	}
 
@@ -233,3 +252,8 @@ bool wooting_rgb_array_set_full(const uint8_t* colors_buffer) {
 		return true;
 	}
 }
+
+const WOOTING_USB_META* wooting_rgb_device_info() {
+	if (!wooting_usb_get_meta()->connected) wooting_usb_find_keyboard();
+	return wooting_usb_get_meta();
+}

src/wooting-rgb-sdk.c

@@ -27,8 +27,6 @@ extern "C" {
 
 typedef void(*void_cb)(void);
 
-#define WOOTING_RGB_ROWS 6
-#define WOOTING_RGB_COLS 21
 
 /** @brief Check if keyboard connected.
 
@@ -149,7 +147,7 @@ This function will set a complete color array. This will not directly update the
 If you use a non-C language it is recommended to use the wooting_rgb_array_set_single function to change the colors to avoid compatibility issues.
 
 Buffer should be layout out as [Row0Col0Red, Row0Col0Green, Row0Col0Blue, Row0Col1Red, Row0Col1Green, Row0Col1Blue, ... Row5Row20Red, Row5Row20Green, Row5Row20Blue]. 
-Expected size is 6 row * 21 columns * 3 colors per key = 576 bytes.
+Expected size is 6 row * 21 columns * 3 colors per key = 378 bytes.
 
 @ingroup API
 @param colors_buffer Pointer to a buffer of a full color array 
@@ -159,6 +157,17 @@ This functions return true (1) if the colours are changed (if auto update flag:
 */
 WOOTINGRGBSDK_API bool wooting_rgb_array_set_full(const uint8_t *colors_buffer);
 
+/** @brief Retrieve information about the connected Device
+
+This function returns a pointer to a struct which provides various relevant details about the currently connected device. E.g. max rgb rows, columns, etc
+
+@ingroup API
+
+@returns
+This functions returns a pointer to a `WOOTING_USB_META` struct which contains relevant Device Information
+*/
+WOOTINGRGBSDK_API const WOOTING_USB_META* wooting_rgb_device_info();
+
 #ifdef __cplusplus
 }
 #endif

src/wooting-rgb-sdk.h

@@ -13,10 +13,13 @@
 
 #define WOOTING_COMMAND_SIZE 8
 #define WOOTING_REPORT_SIZE 129
-#define WOOTING_ONE_VID 0x03EB
+#define WOOTING_VID 0x03EB
 #define WOOTING_ONE_PID 0xFF01
+#define WOOTING_TWO_PID 0xFF02
 
-static uint16_t getCrc16ccitt(const uint8_t* buffer, uint16_t size);
+static WOOTING_USB_META wooting_usb_meta;
+
+uint8_t key_code_limit = WOOTING_TWO_KEY_CODE_LIMIT;
 
 static void_cb disconnected_callback = NULL;
 static hid_device* keyboard_handle = NULL;
@@ -41,7 +44,50 @@ static uint16_t getCrc16ccitt(const uint8_t* buffer, uint16_t size)
 	return crc;
 }
 
+#pragma region Set Meta
+
+static void reset_meta() {
+	wooting_usb_meta.connected = false;
+
+	wooting_usb_meta.model = "N/A";
+	wooting_usb_meta.device_type = -1;
+	wooting_usb_meta.led_index_max = 0;
+	wooting_usb_meta.max_rows = 0;
+	wooting_usb_meta.max_columns = 0;
+	wooting_usb_meta.led_index_max = 0;
+}
+
+static void set_meta_wooting_one() {
+	wooting_usb_meta.model = "Wooting one";
+	wooting_usb_meta.device_type = DEVICE_KEYBOARD_TKL;
+	wooting_usb_meta.led_index_max = WOOTING_ONE_KEY_CODE_LIMIT;
+	wooting_usb_meta.max_rows = WOOTING_RGB_ROWS;
+	wooting_usb_meta.max_columns = WOOTING_ONE_RGB_COLS;
+	wooting_usb_meta.led_index_max = WOOTING_ONE_KEY_CODE_LIMIT;
+}
+
+static void set_meta_wooting_two() {
+	wooting_usb_meta.model = "Wooting two";
+	wooting_usb_meta.device_type = DEVICE_KEYBOARD;
+	wooting_usb_meta.led_index_max = WOOTING_TWO_KEY_CODE_LIMIT;
+	wooting_usb_meta.max_rows = WOOTING_RGB_ROWS;
+	wooting_usb_meta.max_columns = WOOTING_TWO_RGB_COLS;
+	wooting_usb_meta.led_index_max = WOOTING_TWO_KEY_CODE_LIMIT;
+}
+
+WOOTING_USB_META* wooting_usb_get_meta() {
+	//We want to initialise the struct to the default values if it hasn't been set
+	if (wooting_usb_meta.model == NULL){
+		reset_meta();
+	}
+
+	return &wooting_usb_meta;
+}
+
+#pragma endregion
+
 void wooting_usb_disconnect(bool trigger_cb) {
+	reset_meta();
 	hid_close(keyboard_handle);
 	keyboard_handle = NULL;
 
@@ -62,9 +108,17 @@ bool wooting_usb_find_keyboard() {
 		return hid_read_timeout(keyboard_handle, &stub, 0, 0) != -1;
 	}
 
-	struct hid_device_info* hid_info = hid_enumerate(WOOTING_ONE_VID, WOOTING_ONE_PID);
+	struct hid_device_info* hid_info;
 
-	if (hid_info == NULL) {
+	reset_meta();
+	
+	if ((hid_info = hid_enumerate(WOOTING_VID, WOOTING_ONE_PID)) != NULL) {
+		set_meta_wooting_one();
+	}
+	else if ((hid_info = hid_enumerate(WOOTING_VID, WOOTING_TWO_PID)) != NULL) {
+		set_meta_wooting_two();
+	}
+	else {
 		return false;
 	}
 
@@ -105,6 +159,7 @@ bool wooting_usb_find_keyboard() {
 	}
 
 	hid_free_enumeration(hid_info);
+	wooting_usb_meta.connected = true;
 	return keyboard_found;
 }
 
@@ -120,34 +175,39 @@ bool wooting_usb_send_buffer(RGB_PARTS part_number, uint8_t rgb_buffer[]) {
 	report_buffer[2] = 0xDA; // Magicword
 	report_buffer[3] = WOOTING_RAW_COLORS_REPORT; // Report ID
 	switch (part_number) {
-	case PART0: {
-		report_buffer[4] = 0; // Slave nr
-		report_buffer[5] = 0; // Reg start address
-		break;
-	}
-	case PART1: {
-		report_buffer[4] = 0; // Slave nr
-		report_buffer[5] = RGB_RAW_BUFFER_SIZE; // Reg start address
-		break;
-	}
-	case PART2: {
-		report_buffer[4] = 1; // Slave nr
-		report_buffer[5] = 0; // Reg start address
-		break;
-	}
-	case PART3: {
-		report_buffer[4] = 1; // Slave nr
-		report_buffer[5] = RGB_RAW_BUFFER_SIZE; // Reg start address
-		break;
-	}
-	case PART4: {
-		report_buffer[4] = 2; // Slave nr
-		report_buffer[5] = 0; // Reg start address
-		break;
-	}
-	default: {
-		return false;
-	}
+		case PART0: {
+			report_buffer[4] = 0; // Slave nr
+			report_buffer[5] = 0; // Reg start address
+			break;
+		}
+		case PART1: {
+			report_buffer[4] = 0; // Slave nr
+			report_buffer[5] = RGB_RAW_BUFFER_SIZE; // Reg start address
+			break;
+		}
+		case PART2: {
+			report_buffer[4] = 1; // Slave nr
+			report_buffer[5] = 0; // Reg start address
+			break;
+		}
+		case PART3: {
+			report_buffer[4] = 1; // Slave nr
+			report_buffer[5] = RGB_RAW_BUFFER_SIZE; // Reg start address
+			break;
+		}
+		// wooting_rgb_array_update_keyboard will not run into this
+		case PART4: {
+			//Wooting One will not have this part of the report
+			if (wooting_usb_meta.device_type != DEVICE_KEYBOARD) {
+				return false;
+			}
+			report_buffer[4] = 2; // Slave nr
+			report_buffer[5] = 0; // Reg start address
+			break;
+		}
+		default: {
+			return false;
+		}
 	}
 
 	memcpy(&report_buffer[6], rgb_buffer, RGB_RAW_BUFFER_SIZE);
@@ -169,6 +229,12 @@ bool wooting_usb_send_feature(uint8_t commandId, uint8_t parameter0, uint8_t par
 	if (!wooting_usb_find_keyboard()) {
 		return false;
 	}
+	// prevent sending unnecessary data to the wootings if the index exceedes it's capabilities
+	if ((commandId == WOOTING_SINGLE_COLOR_COMMAND && parameter0 > key_code_limit)
+	|| (commandId == WOOTING_SINGLE_RESET_COMMAND && parameter3 > key_code_limit)) {
+		// this is not a usb error so let's return true. wooting_rgb_direct_set_key would also behave differently otherwise.
+		return true;
+	}
 
 	uint8_t report_buffer[WOOTING_COMMAND_SIZE];
 

src/wooting-usb.c

@@ -17,8 +17,35 @@ typedef enum RGB_PARTS {
 	PART4
 } RGB_PARTS;
 
+
+typedef enum WOOTING_DEVICE_TYPE {
+	// 10 Keyless Keyboard. E.g. Wooting One
+	DEVICE_KEYBOARD_TKL = 1,
+	
+	// Full Size keyboard. E.g. Wooting Two
+	DEVICE_KEYBOARD = 2
+} WOOTING_DEVICE_TYPE;
+
+typedef struct WOOTING_USB_META {
+	bool connected;
+	const char* model;
+	uint8_t max_rows;
+	uint8_t max_columns;
+	uint8_t led_index_max;
+	WOOTING_DEVICE_TYPE device_type;
+
+} WOOTING_USB_META;
+
 #define RGB_RAW_BUFFER_SIZE 96
 
+#define WOOTING_RGB_ROWS 6
+#define WOOTING_RGB_COLS 21
+#define WOOTING_ONE_RGB_COLS 17
+#define WOOTING_TWO_RGB_COLS 21
+
+#define WOOTING_ONE_KEY_CODE_LIMIT 95
+#define WOOTING_TWO_KEY_CODE_LIMIT 116
+
 #define WOOTING_RAW_COLORS_REPORT 11
 #define WOOTING_SINGLE_COLOR_COMMAND 30
 #define WOOTING_SINGLE_RESET_COMMAND 31
@@ -27,6 +54,10 @@ typedef enum RGB_PARTS {
 
 void wooting_usb_set_disconnected_cb(void_cb cb);
 void wooting_usb_disconnect(bool trigger_cb);
-bool wooting_usb_find_keyboard();
+
+bool wooting_usb_find_keyboard(void);
+
+WOOTING_USB_META* wooting_usb_get_meta();
+
 bool wooting_usb_send_buffer(RGB_PARTS part_number, uint8_t rgb_buffer[]);
 bool wooting_usb_send_feature(uint8_t commandId, uint8_t parameter0, uint8_t parameter1, uint8_t parameter2, uint8_t parameter3);