Add Translations field to SDK protocol

Added support for Lenovo Legion M300 RGB Mouse.
Added all supported modes Static, Rainbow, Breathing and Off
Also Tested all modes to verify its working

.gitlab-ci.yml

@@ -61,7 +61,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 32 AppImage":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-32
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-32
   stage: build
   script:
   - export $(dpkg-architecture)
@@ -87,7 +87,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 64 AppImage":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-64
   stage: build
   script:
   - export $(dpkg-architecture)

.gitlab/merge_request_templates/New Device.md

@@ -10,6 +10,7 @@ Please put "Initial commit for" name of the product, including manufacturer abov
 <!-- For admin purposes: Please leave this section as is -->
 
 # Checklist for Accepting a Merge Request for a New Device
+- [ ] The source branch of the merge request is not protected (`master` is protected by default when creating a fork, so it is recommended to not use it as your source).
 - [ ] The `New Device` issue raised for this device is linked to this MR with a keyword `Closes / Resolves / Implements`
 - [ ] There is a device protocol page in the [Developer Wiki](https://gitlab.com/OpenRGBDevelopers/OpenRGB-Wiki) or there is enough information / captures in the `New Device` issue to provide ongoing support.
 - [ ] The code to be merged follows the style guide and change requirements as [documented in the contributing guide](https://gitlab.com/CalcProgrammer1/OpenRGB/-/blob/master/CONTRIBUTING.md).

AutoStart/AutoStart-Linux.cpp

@@ -4,6 +4,7 @@
 
 #include <fstream>
 #include <iostream>
+#include <sstream>
 #include <unistd.h>
 #include <linux/limits.h>
 

CONTRIBUTING.md

@@ -11,6 +11,7 @@ To create a merge request, log into GitLab and fork the OpenRGB project.  Push y
 * Mark your merge request as a draft (start title with "Draft:") until it has been tested and verified working.
 * Follow the Style Guidelines below when making your code changes.
 * Avoid using `git merge` when updating your fork.  The OpenRGB project uses a linear git history, meaning all changes are rebased onto the tip of master.  By using `git rebase` to update your fork, you will make it easier to accept merge requests.
+* Do not submit a merge request using your fork's `master` branch as the source.  The `master` branch is protected by default when creating a fork and I cannot manually rebase a protected branch before merging.  If you submit a merge request with a protected `master` branch as the source, it may not get merged until you unprotect it.
 
 ### Pipelines, Shared Runners and Quotas
 

Controllers/A4TechController/A4Tech_Detector.cpp

@@ -1,3 +1,13 @@
+/*-------------------------------------------------------------------*\
+|  A4TechDetector.cpp                                                 |
+|                                                                     |
+|  Driver for A4Tech Devices Detector                                 |
+|                                                                     |
+|  Chris M (Dr_No)                              30 Jun 2022           |
+|  Mohammed Julfikar Ali Mahbub (o-julfikar)    01 Apr 2024           |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
 /*-----------------------------------------------------*\
 | OpenRGB includes                                      |
 \*-----------------------------------------------------*/
@@ -9,6 +19,7 @@
 | A4 Tech specific includes                             |
 \*-----------------------------------------------------*/
 #include "RGBController_BloodyMouse.h"
+#include "RGBController_BloodyB820R.h"
 
 /*-----------------------------------------------------*\
 | A4 Tech USB vendor ID                                 |
@@ -29,6 +40,21 @@ void DetectA4TechMouseControllers(hid_device_info* info, const std::string& name
     }
 }
 
+void DetectBloodyB820R(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path);
+        RGBController_BloodyB820R* rgb_controller = new RGBController_BloodyB820R(controller);
+        rgb_controller->name                      = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
 REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_MAX_PID,     2,      0xFF33,     0x053D);
 REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);
+REGISTER_HID_DETECTOR_IPU("A4Tech Bloody B820R",    DetectBloodyB820R,                  A4_TECH_VID,    BLOODY_B820R_PID,       2,      0xFF52,     0x0210);

Controllers/A4TechController/BloodyB820RController.cpp

@@ -0,0 +1,102 @@
+/*-------------------------------------------------------------------*\
+|  BloodyB820RController.cpp                                          |
+|                                                                     |
+|  Driver for A4Tech Bloody B820R Keyboard Controller                 |
+|                                                                     |
+|  Mohammed Julfikar Ali Mahbub (o-julfikar)          01 Apr 2024     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "BloodyB820RController.h"
+
+/*--------------------------------------------------------------------------------------*\
+ * The controller for this device should pass a packet of 64 bytes where the subsequent *
+ * two packets are for RED, GREEN, and BLUE respectively. The first 6 bytes are control *
+ * or information bytes and colors bytes starts from index 6. Moreover, the first pack- *
+ * et of each RGB contains color for 58 keys and the rest (104 - 58 == 46) are send on  *
+ * the second packet.                                                                   *
+\*--------------------------------------------------------------------------------------*/
+
+BloodyB820RController::BloodyB820RController(hid_device* dev_handle, const char* path)
+{
+    dev                 = dev_handle;
+    location            = path;
+
+    SendControlPacket(BLOODY_B820R_GAIN_CONTROL);
+}
+
+BloodyB820RController::~BloodyB820RController()
+{
+    SendControlPacket(BLOODY_B820R_RELEASE_CONTROL);
+    hid_close(dev);
+}
+
+std::string BloodyB820RController::GetSerial()
+{
+    const int szTemp    = HID_MAX_STR;
+    wchar_t   tmpName[szTemp];
+
+    hid_get_serial_number_string(dev, tmpName, szTemp);
+    std::wstring wName  = std::wstring(tmpName);
+    std::string serial  = std::string(wName.begin(), wName.end());
+
+    return serial;
+}
+
+std::string BloodyB820RController::GetLocation()
+{
+    return("HID: " + location);
+}
+
+void  BloodyB820RController::SendControlPacket(uint8_t data)
+{
+    uint8_t buffer[BLOODY_B820R_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };
+
+    hid_send_feature_report(dev, buffer, BLOODY_B820R_PACKET_SIZE);
+
+    buffer[BLOODY_B820R_MODE_BYTE]                   = 0;
+    buffer[BLOODY_B820R_DATA_BYTE]                   = data;
+
+    hid_send_feature_report(dev, buffer, BLOODY_B820R_PACKET_SIZE);
+}
+
+void BloodyB820RController::SetLEDDirect(std::vector<RGBColor> colors)
+{
+
+    uint8_t r1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x07, 0x00, 0x00 };
+    uint8_t r2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x08, 0x00, 0x00 };
+    uint8_t g1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x09, 0x00, 0x00 };
+    uint8_t g2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0A, 0x00, 0x00 };
+    uint8_t b1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0B, 0x00, 0x00 };
+    uint8_t b2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0C, 0x00, 0x00 };
+
+    /*-----------------------------------------------------------------*\
+    | Set up Direct packet                                              |
+    |   packet_map is the index of the Key from full_matrix_map and     |
+    |   the value is the position in the direct packet buffer           |
+    \*-----------------------------------------------------------------*/
+
+
+    for(size_t i = 0; i < colors.size(); i++)
+    {
+        RGBColor    color                     = colors[i];
+        uint8_t     offset                    = BLOODY_B820R_RGB_OFFSET;
+        uint8_t     buffer_idx                = offset + i % BLOODY_B820R_RGB_BUFFER_SIZE;
+        uint8_t*    buffers[2][3]             =
+                {
+                        {r1_buffer, g1_buffer, b1_buffer},
+                        {r2_buffer, g2_buffer, b2_buffer}
+                };
+
+        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][0][buffer_idx] = RGBGetRValue(color);
+        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][1][buffer_idx] = RGBGetGValue(color);
+        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][2][buffer_idx] = RGBGetBValue(color);
+    }
+
+    hid_send_feature_report(dev, r1_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, r2_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, g1_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, g2_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, b1_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, b2_buffer, BLOODY_B820R_PACKET_SIZE);
+}

Controllers/A4TechController/BloodyB820RController.h

@@ -0,0 +1,51 @@
+/*-------------------------------------------------------------------*\
+|  BloodyB820RController.h                                            |
+|                                                                     |
+|  Driver for A4Tech Bloody B820R Keyboard Controller                 |
+|                                                                     |
+|  Mohammed Julfikar Ali Mahbub (o-julfikar)          01 Apr 2024     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include <string>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+
+#pragma once
+#define NA                                      0xFFFFFFFF
+#define HID_MAX_STR                             255
+
+#define BLOODY_B820R_RGB_BUFFER_SIZE    58
+#define BLOODY_B820R_RGB_OFFSET         6
+#define BLOODY_B820R_PACKET_SIZE        64
+#define BLOODY_B820R_KEYCOUNT           104
+#define BLOODY_B820R_MODE_BYTE          3
+#define BLOODY_B820R_DATA_BYTE          8
+#define BLOODY_B820R_GAIN_CONTROL       0x01
+#define BLOODY_B820R_RELEASE_CONTROL    0x00
+
+/*---------------------------------------------------------*\
+| Bloody B820R product ID                                    |
+\*---------------------------------------------------------*/
+#define BLOODY_B820R_PID                               0xFA10
+
+enum
+{
+    BLOODY_B820R_MODE_DIRECT     = 0x01,    // Direct LED control - Independently set LEDs in zone
+};
+
+class BloodyB820RController
+{
+public:
+    BloodyB820RController(hid_device* dev_handle, const char* path);
+    ~BloodyB820RController();
+
+    std::string     GetSerial();
+    std::string     GetLocation();
+
+    void            SetLEDDirect(std::vector<RGBColor> colors);
+    void            SendControlPacket(uint8_t data);
+private:
+    std::string     location;
+    hid_device*     dev;
+};

Controllers/A4TechController/RGBController_BloodyB820R.cpp

@@ -0,0 +1,247 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_BloodyB820R.cpp                                      |
+|                                                                     |
+|  Driver for A4Tech Bloody B820R Keyboard Controller                 |
+|                                                                     |
+|  Mohammed Julfikar Ali Mahbub (o-julfikar)          01 Apr 2024     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "RGBControllerKeyNames.h"
+#include "RGBController_BloodyB820R.h"
+
+static unsigned int matrix_map[6][21] =
+        {
+                {0, NA, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, NA, NA, NA, NA, 13, 14, 15},
+                {16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36},
+                {37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57},
+                {58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, NA, NA, NA, NA, 71, 72, 73, NA},
+                {74, NA, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, NA, NA, 86, NA, 87, 88, 89, 90},
+                {91, 92, 93, 94, NA, NA, NA, NA, NA, NA, 95, 96, 97, 98, 99, 100, 101, 102, NA, 103, NA},
+        };
+
+static const char *led_names[] =
+        {
+                KEY_EN_ESCAPE,              //00
+                KEY_EN_F1,
+                KEY_EN_F2,
+                KEY_EN_F3,
+                KEY_EN_F4,
+                KEY_EN_F5,
+                KEY_EN_F6,
+                KEY_EN_F7,
+                KEY_EN_F8,
+                KEY_EN_F9,
+                KEY_EN_F10,                 
+                KEY_EN_F11,
+                KEY_EN_F12,
+                KEY_EN_PRINT_SCREEN,
+                KEY_EN_SCROLL_LOCK,
+                KEY_EN_PAUSE_BREAK,
+
+                KEY_EN_BACK_TICK,           //10
+                KEY_EN_1,
+                KEY_EN_2,
+                KEY_EN_3,
+                KEY_EN_4,                   
+                KEY_EN_5,
+                KEY_EN_6,
+                KEY_EN_7,
+                KEY_EN_8,
+                KEY_EN_9,
+                KEY_EN_0,
+                KEY_EN_MINUS,
+                KEY_EN_EQUALS,
+                KEY_EN_BACKSPACE,
+                KEY_EN_INSERT,
+                KEY_EN_HOME,
+                KEY_EN_PAGE_UP,
+                KEY_EN_NUMPAD_LOCK,
+                KEY_EN_NUMPAD_DIVIDE,
+                KEY_EN_NUMPAD_TIMES,
+                KEY_EN_NUMPAD_MINUS,
+
+                KEY_EN_TAB,                 //20
+                KEY_EN_Q,
+                KEY_EN_W,
+                KEY_EN_E,
+                KEY_EN_R,
+                KEY_EN_T,
+                KEY_EN_Y,
+                KEY_EN_U,
+                KEY_EN_I,
+                KEY_EN_O,
+                KEY_EN_P,
+                KEY_EN_LEFT_BRACKET,
+                KEY_EN_RIGHT_BRACKET,
+                KEY_EN_ANSI_BACK_SLASH,
+                KEY_EN_DELETE,
+                KEY_EN_END,
+                KEY_EN_PAGE_DOWN,
+                KEY_EN_NUMPAD_7,
+                KEY_EN_NUMPAD_8,
+                KEY_EN_NUMPAD_9,
+                KEY_EN_NUMPAD_PLUS,
+
+                KEY_EN_CAPS_LOCK,           //30
+                KEY_EN_A,
+                KEY_EN_S,
+                KEY_EN_D,
+                KEY_EN_F,
+                KEY_EN_G,
+                KEY_EN_H,
+                KEY_EN_J,
+                KEY_EN_K,
+                KEY_EN_L,
+                KEY_EN_SEMICOLON,
+                KEY_EN_QUOTE,
+                KEY_EN_ANSI_ENTER,
+                KEY_EN_NUMPAD_4,
+                KEY_EN_NUMPAD_5,
+                KEY_EN_NUMPAD_6,
+
+                KEY_EN_LEFT_SHIFT,          //40
+                KEY_EN_Z,
+                KEY_EN_X,
+                KEY_EN_C,
+                KEY_EN_V,
+                KEY_EN_B,
+                KEY_EN_N,
+                KEY_EN_M,
+                KEY_EN_COMMA,
+                KEY_EN_PERIOD,
+                KEY_EN_FORWARD_SLASH,
+                KEY_EN_RIGHT_SHIFT,
+                KEY_EN_UP_ARROW,
+                KEY_EN_NUMPAD_1,
+                KEY_EN_NUMPAD_2,
+                KEY_EN_NUMPAD_3,
+                KEY_EN_NUMPAD_ENTER,
+
+                KEY_EN_LEFT_CONTROL,        //50
+                KEY_EN_LEFT_WINDOWS,
+                KEY_EN_LEFT_ALT,
+                KEY_EN_SPACE,
+                KEY_EN_RIGHT_ALT,
+                KEY_EN_RIGHT_FUNCTION,
+                KEY_EN_MENU,
+                KEY_EN_RIGHT_CONTROL,
+                KEY_EN_LEFT_ARROW,
+                KEY_EN_DOWN_ARROW,
+                KEY_EN_RIGHT_ARROW,
+                KEY_EN_NUMPAD_0,
+                KEY_EN_NUMPAD_PERIOD
+        };
+
+/**------------------------------------------------------------------*\
+    @name A4Tech Bloody B820R
+    @category Keyboard
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors A4TechDetector
+    @comment The A4Tech Bloody B820R keyboard controller currently
+        supports the full size (ANSI layout).
+\*-------------------------------------------------------------------*/
+
+RGBController_BloodyB820R::RGBController_BloodyB820R(BloodyB820RController *controller_ptr)
+{
+    controller                  = controller_ptr;
+
+    name                        = "Bloody B820R";
+    vendor                      = "A4Tech";
+    type                        = DEVICE_TYPE_KEYBOARD;
+    description                 = "A4Tech Bloody Keyboard";
+    serial                      = controller->GetSerial();
+    location                    = controller->GetLocation();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = BLOODY_B820R_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+}
+
+RGBController_BloodyB820R::~RGBController_BloodyB820R()
+{
+    delete controller;
+}
+
+void RGBController_BloodyB820R::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Create the Keyboard zone and add the matrix map   |
+    \*-------------------------------------------------*/
+    zone KB_zone;
+    KB_zone.name                = ZONE_EN_KEYBOARD;
+    KB_zone.type                = ZONE_TYPE_MATRIX;
+    KB_zone.leds_min            = BLOODY_B820R_KEYCOUNT;
+    KB_zone.leds_max            = BLOODY_B820R_KEYCOUNT;
+    KB_zone.leds_count          = BLOODY_B820R_KEYCOUNT;
+
+    KB_zone.matrix_map          = new matrix_map_type;
+    KB_zone.matrix_map->height  = 6;
+    KB_zone.matrix_map->width   = 21;
+    KB_zone.matrix_map->map     = (unsigned int *)&matrix_map;
+    zones.push_back(KB_zone);
+
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
+    leds.clear();
+    colors.clear();
+
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    for(unsigned int led_index = 0; led_index < BLOODY_B820R_KEYCOUNT; led_index++)
+    {
+        led new_led;
+        new_led.name        = led_names[led_index];
+        new_led.value       = led_index;
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_BloodyB820R::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+
+void RGBController_BloodyB820R::DeviceUpdateLEDs()
+{
+    controller->SetLEDDirect(colors);
+}
+
+void RGBController_BloodyB820R::UpdateZoneLEDs(int zone)
+{
+    std::vector<RGBColor> colour;
+    for(size_t i = 0; i < zones[zone].leds_count; i++)
+    {
+        colour.push_back(zones[zone].colors[i]);
+    }
+
+    controller->SetLEDDirect(colour);
+}
+
+void RGBController_BloodyB820R::UpdateSingleLED(int led)
+{
+    std::vector<RGBColor> colour;
+    colour.push_back(colors[led]);
+
+    controller->SetLEDDirect(colour);
+}
+
+void RGBController_BloodyB820R::DeviceUpdateMode()
+{
+    /* This device does not support modes yet */
+}

Controllers/A4TechController/RGBController_BloodyB820R.h

@@ -0,0 +1,32 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_BloodyB820R.h                                |
+|                                                                     |
+|  Driver for A4Tech Bloody B820R Keyboard Controller                   |
+|                                                                     |
+|  Mohammed Julfikar Ali Mahbub (o-julfikar)          01 Apr 2024     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "BloodyB820RController.h"
+#include <vector>
+
+class RGBController_BloodyB820R : public RGBController
+{
+public:
+    RGBController_BloodyB820R(BloodyB820RController* controller_ptr);
+    ~RGBController_BloodyB820R();
+
+    void    SetupZones();
+    void    ResizeZone(int zone, int new_size);
+
+    void    DeviceUpdateLEDs();
+    void    UpdateZoneLEDs(int zone);
+    void    UpdateSingleLED(int led);
+
+    void    DeviceUpdateMode();
+
+private:
+    BloodyB820RController* controller;
+};

Controllers/AOCKeyboardController/AOCKeyboardControllerDetect.cpp

@@ -8,6 +8,7 @@
 \*-----------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_GK500_PID                               0x1178
+#define AOC_GK500_PID_2                             0x1229
 
 /******************************************************************************************\
 *                                                                                          *
@@ -32,3 +33,4 @@ void DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name
 }
 
 REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID,   0xFF19, 0xFF19);
+REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID_2,   0xFF19, 0xFF19);

Controllers/AlienwareKeyboardController/AlienwareAW410KController.cpp

@@ -0,0 +1,448 @@
+/*------------------------------------------------------*\
+|  AlienwareAW410KController.cpp                         |
+|                                                        |
+|  Driver for Alienware AW410K                           |
+|  keyboard light controller                             |
+|                                                        |
+|  based on AW510K controller by Mohamad Sallal - msallal|
+|                                                        |
+|  Dominik Mikolajczyk - dmiko 23/10/2023                |
+\*------------------------------------------------------*/
+
+#include "AlienwareAW410KController.h"
+#include <cstring>
+
+AlienwareAW410KController::AlienwareAW410KController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+
+    SendCommit();
+}
+
+AlienwareAW410KController::~AlienwareAW410KController()
+{
+    hid_close(dev);
+}
+
+std::string AlienwareAW410KController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AlienwareAW410KController::GetSerialString()
+{
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+void AlienwareAW410KController::SendCommit()
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Commit packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x05;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x0A]           = 0x10;
+    usb_buf[0x0B]           = 0x0A;
+    usb_buf[0x0C]           = 0x01;
+    usb_buf[0x0D]           = 0x02;
+    usb_buf[0x0E]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 20 milliseconds                                 |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(20));
+}
+
+
+void AlienwareAW410KController::SendfeatureReport
+    (
+    unsigned char   first_byte,
+    unsigned char   second_byte,
+    unsigned char   third_byte,
+    unsigned char   forth_byte
+    )
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Feature report packet                          |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = first_byte;
+    usb_buf[0x02]           = second_byte;
+    usb_buf[0x03]           = third_byte;
+    usb_buf[0x04]           = forth_byte;
+
+    /*-----------------------------------------------------*\
+    | Send Feature report packet                            |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 10 milliseconds                                 |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+}
+
+void AlienwareAW410KController::SendEdit()
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Edit packet                                    |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x01;
+    usb_buf[0x02]           = 0x00;
+    usb_buf[0x03]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 2 milliseconds                                  |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
+}
+
+void AlienwareAW410KController::SendInitialize()
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Commit packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x0E;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = 0x00;
+    usb_buf[0x04]           = 0x01;
+    usb_buf[0x05]           = 0xAD;
+    usb_buf[0x06]           = 0x80;
+    usb_buf[0x07]           = 0x10;
+    usb_buf[0x08]           = 0xA5;
+    usb_buf[0x0A]           = 0x0A;
+    usb_buf[0x12]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 2 milliseconds                                  |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
+}
+
+void AlienwareAW410KController::SetDirect
+    (
+    unsigned char   /*zone*/,
+    unsigned char   r,
+    unsigned char   g,
+    unsigned char   b
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Lighting Control packet                        |
+    \*-----------------------------------------------------*/
+
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x05;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = 0x01;
+    usb_buf[0x04]           = r;
+    usb_buf[0x05]           = g;
+    usb_buf[0x06]           = b;
+    usb_buf[0x0B]           = 0x0A;
+    usb_buf[0x0D]           = 0x01;
+    usb_buf[0x0E]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 2 milliseconds                                  |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
+}
+
+void AlienwareAW410KController::SendDirectOn
+    (
+    std::vector<SelectedButtons>     &frame_data
+    )
+{
+    SendfeatureReport(0x0E, frame_data.size(), 0x00, 0x01);
+
+    /*-----------------------------------------------*\
+    | To Guarantee the data are always %4 =0 append   |
+    | zeros at end of last packet                     |
+    \*-----------------------------------------------*/
+    for(unsigned int i = 0; i < (frame_data.size() % 4); i++)
+    {
+        SelectedButtons key;
+        key.idx     = 0x00;
+        key.red     = 0x00;
+        key.green   = 0x00;
+        key.blue    = 0x00;
+
+        frame_data.push_back(key);
+    }
+
+    unsigned char usb_buf[65];
+    unsigned int  frame_idx = 0;
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, 65);
+
+    for(unsigned int packet_idx = 0; packet_idx < frame_data.size(); packet_idx++)
+    {
+        usb_buf[0x00]           = 0x00;
+        usb_buf[0x01]           = 0x0E;
+        usb_buf[0x02]           = 0x01;
+        usb_buf[0x03]           = 0x00;
+        usb_buf[0x04]           = ++frame_idx;
+        usb_buf[0x05]           = frame_data[packet_idx].idx;
+        usb_buf[0x06]           = 0x81;
+        usb_buf[0x07]           = 0x00;
+        usb_buf[0x08]           = 0xA5;
+        usb_buf[0x0A]           = 0x0A;
+        usb_buf[0x0B]           = frame_data[packet_idx].red;
+        usb_buf[0x0C]           = frame_data[packet_idx].green;
+        usb_buf[0x0D]           = frame_data[packet_idx].blue;
+        usb_buf[0x12]           = 0x01;
+
+        usb_buf[0x14]           = frame_data[++packet_idx].idx;
+        usb_buf[0x15]           = 0x81;
+        usb_buf[0x16]           = 0x00;
+        usb_buf[0x17]           = 0xA5;
+        usb_buf[0x19]           = 0x0A;
+        usb_buf[0x1A]           = frame_data[packet_idx].red;
+        usb_buf[0x1B]           = frame_data[packet_idx].green;
+        usb_buf[0x1C]           = frame_data[packet_idx].blue;
+        usb_buf[0x21]           = 0x01;
+
+        usb_buf[0x23]           = frame_data[++packet_idx].idx;
+        usb_buf[0x24]           = 0x81;
+        usb_buf[0x25]           = 0x00;
+        usb_buf[0x26]           = 0xA5;
+        usb_buf[0x28]           = 0x0A;
+        usb_buf[0x29]           = frame_data[packet_idx].red;
+        usb_buf[0x2A]           = frame_data[packet_idx].green;
+        usb_buf[0x2B]           = frame_data[packet_idx].blue;
+        usb_buf[0x30]           = 0x01;
+
+        usb_buf[0x32]           = frame_data[++packet_idx].idx;
+        usb_buf[0x33]           = 0x81;
+        usb_buf[0x34]           = 0x00;
+        usb_buf[0x35]           = 0xA5;
+        usb_buf[0x37]           = 0x0A;
+        usb_buf[0x38]           = frame_data[packet_idx].red;
+        usb_buf[0x39]           = frame_data[packet_idx].green;
+        usb_buf[0x3A]           = frame_data[packet_idx].blue;
+        usb_buf[0x3F]           = 0x01;
+
+        hid_write(dev, (unsigned char *)usb_buf, 65);
+    }
+}
+
+
+void AlienwareAW410KController::SetMode
+    (
+    unsigned char   mode,
+    unsigned short  speed,
+    unsigned char   direction,
+    unsigned char   colorMode,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    SendMode(ALIENWARE_AW410K_ZONE_MODE_KEYBOARD, mode, speed, direction, colorMode, red, green, blue);
+    SendCommit();
+}
+
+void AlienwareAW410KController::UpdateSingleLED
+    (
+    unsigned char   led,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    SendfeatureReport(0x0E, 0x01, 0x00, 0x01);
+
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Single LED packet                              |
+    \*-----------------------------------------------------*/
+
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x0E;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = 0x00;
+    usb_buf[0x04]           = 0x01;
+    usb_buf[0x05]           = led;
+    usb_buf[0x06]           = 0x81;
+    usb_buf[0x07]           = 0x00;
+    usb_buf[0x08]           = 0xA5;
+    usb_buf[0x09]           = 0x00;
+    usb_buf[0x0A]           = 0x0A;
+    usb_buf[0x0B]           = red;
+    usb_buf[0x0C]           = green;
+    usb_buf[0x0D]           = blue;
+    usb_buf[0x12]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 20 milliseconds                                 |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(20));
+
+}
+void AlienwareAW410KController::SendMode
+    (
+    unsigned char   /*zone*/,
+    unsigned char   mode,
+    unsigned short  speed,
+    unsigned char   direction,
+    unsigned char   colorMode,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Mode Control packet                            |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x05;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = mode;
+    usb_buf[0x04]           = red;
+    usb_buf[0x05]           = green;
+    usb_buf[0x06]           = blue;
+    usb_buf[0x0A]           = speed;
+    usb_buf[0x0B]           = 0x0A;
+    usb_buf[0x0D]           = 0x01;
+    usb_buf[0x0E]           = colorMode;
+    usb_buf[0x0F]           = direction;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+}
+
+void AlienwareAW410KController::SetMorphMode
+    (
+    unsigned char   mode,
+    unsigned short  speed,
+    unsigned char   red1,
+    unsigned char   green1,
+    unsigned char   blue1,
+    unsigned char   red2,
+    unsigned char   green2,
+    unsigned char   blue2
+    )
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Morph Mode packet                              |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x05;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = mode;
+    usb_buf[0x04]           = red1;
+    usb_buf[0x05]           = green1;
+    usb_buf[0x06]           = blue1;
+    usb_buf[0x07]           = red2;
+    usb_buf[0x08]           = green2;
+    usb_buf[0x09]           = blue2;
+    usb_buf[0x0E]           = 0x02;
+    usb_buf[0x0A]           = speed;
+    usb_buf[0x0B]           = 0x0A;
+    usb_buf[0x0D]           = 0x01;
+    usb_buf[0x0E]           = ALIENWARE_AW410K_TWO_USER_DEFINED_COLOR_MODE;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+}

Controllers/AlienwareKeyboardController/AlienwareAW410KController.h

@@ -0,0 +1,155 @@
+/*------------------------------------------------------*\
+|  AlienwareAW410KController.h                           |
+|                                                        |
+|  Definitions and types for alienware                   |
+|  AW410K Keyboard                                       |
+|                                                        |
+|  based on AW510K controller by Mohamad Sallal - msallal|
+|                                                        |
+|  Dominik Mikolajczyk - dmiko 23/10/2023                |
+\*------------------------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    ALIENWARE_AW410K_ZONE_MODE_KEYBOARD         = 0x01,
+};
+
+enum
+{
+    ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD       = 0x01,
+    ALIENWARE_AW410K_ZONE_DIRECT_MEDIA          = 0x02,
+    ALIENWARE_AW410K_ZONE_DIRECT_INDICATORS     = 0x40,
+};
+
+enum
+{
+    ALIENWARE_AW410K_MODE_OFF                   = 0x00,
+    ALIENWARE_AW410K_MODE_DIRECT                = 0x01,
+    ALIENWARE_AW410K_MODE_PULSE                 = 0x02,
+    ALIENWARE_AW410K_MODE_MORPH                 = 0x03,
+    ALIENWARE_AW410K_MODE_BREATHING             = 0x07,
+    ALIENWARE_AW410K_MODE_SPECTRUM              = 0x08,
+    ALIENWARE_AW410K_MODE_SINGLE_WAVE           = 0x0F,
+    ALIENWARE_AW410K_MODE_RAINBOW_WAVE          = 0x10,
+    ALIENWARE_AW410K_MODE_SCANNER               = 0x11,
+    ALIENWARE_AW410K_MODE_STATIC                = 0x13,
+};
+
+enum
+{
+    ALIENWARE_AW410K_SPEED_SLOWEST              = 0x2D,     /* Slowest speed                                */
+    ALIENWARE_AW410K_SPEED_NORMAL               = 0x19,     /* Normal speed                                 */
+    ALIENWARE_AW410K_SPEED_FASTEST              = 0x0A,     /* Fastest speed                                */
+};
+
+enum
+{
+    ALIENWARE_AW410K_DIRECTION_LEFT_TO_RIGHT    = 0x01,
+    ALIENWARE_AW410K_DIRECTION_RIGHT_TO_LEFT    = 0x02,
+    ALIENWARE_AW410K_DIRECTION_TOP_TO_BOTTOM    = 0x03,
+    ALIENWARE_AW410K_DIRECTION_BOTTOM_TO_TOP    = 0x04,
+};
+
+enum
+{
+    ALIENWARE_AW410K_SINGLE_COLOR_MODE          = 0x01,
+    ALIENWARE_AW410K_TWO_USER_DEFINED_COLOR_MODE= 0x02,
+    ALIENWARE_AW410K_RANBOW_COLOR_MODE          = 0x03,
+};
+
+struct SelectedButtons
+{
+    unsigned char idx;
+    unsigned char red;
+    unsigned char green;
+    unsigned char blue;
+};
+
+class AlienwareAW410KController
+{
+public:
+    AlienwareAW410KController(hid_device* dev_handle, const char* path);
+    ~AlienwareAW410KController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void        SendInitialize();
+    void        SendCommit();
+    void        SendfeatureReport
+                    (
+                    unsigned char   first_byte,
+                    unsigned char   second_byte,
+                    unsigned char   third_byte,
+                    unsigned char   forth_byte
+                    );
+
+    void        SendEdit();
+
+    void        SetDirect
+                    (
+                    unsigned char   zone,
+                    unsigned char   r,
+                    unsigned char   g,
+                    unsigned char   b
+                    );
+
+    void    SendDirectOn
+                    (
+                    std::vector<SelectedButtons>     &frame_data
+                    );
+
+    void        SetMode
+                    (
+                    unsigned char   mode,
+                    unsigned short  speed,
+                    unsigned char   direction,
+                    unsigned char   colorMode,
+                    unsigned char   red,
+                    unsigned char   green,
+                    unsigned char   blue
+                    );
+
+    void        SetMorphMode
+                    (
+                    unsigned char   mode,
+                    unsigned short  speed,
+                    unsigned char   red1,
+                    unsigned char   green1,
+                    unsigned char   blue1,
+                    unsigned char   red2,
+                    unsigned char   green2,
+                    unsigned char   blue2
+                    );
+
+    void        UpdateSingleLED
+                    (
+                    unsigned char   led,
+                    unsigned char   red,
+                    unsigned char   green,
+                    unsigned char   blue
+                    );
+
+private:
+    hid_device*             dev;
+    std::string             location;
+
+    void        SendMode
+                    (
+                    unsigned char   zone,
+                    unsigned char   mode,
+                    unsigned short  speed,
+                    unsigned char   direction,
+                    unsigned char   colorMode,
+                    unsigned char   red,
+                    unsigned char   green,
+                    unsigned char   blue
+                    );
+};

Controllers/AlienwareKeyboardController/AlienwareKeyboardControllerDetect.cpp

@@ -1,7 +1,9 @@
 #include "Detector.h"
 #include "AlienwareAW510KController.h"
+#include "AlienwareAW410KController.h"
 #include "RGBController.h"
 #include "RGBController_AlienwareAW510K.h"
+#include "RGBController_AlienwareAW410K.h"
 #include <hidapi/hidapi.h>
 
 /*-----------------------------------------------------*\
@@ -13,6 +15,7 @@
 | Keyboard product IDs                                  |
 \*-----------------------------------------------------*/
 #define ALIENWARE_AW510K_PID    0x1830
+#define ALIENWARE_AW410K_PID    0x1968
 
 /******************************************************************************************\
 *                                                                                          *
@@ -32,7 +35,20 @@ void DetectAlienwareAW510KControllers(hid_device_info* info, const std::string&
         rgb_controller->name = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-}   /* DetectAlienwareKeyboardControllers() */
+}
+
+void DetectAlienwareAW410KControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
+    {
+        AlienwareAW410KController*     controller     = new AlienwareAW410KController(dev, info->path);
+        RGBController_AlienwareAW410K* rgb_controller = new RGBController_AlienwareAW410K(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}/* DetectAlienwareKeyboardControllers() */
 
 
 REGISTER_HID_DETECTOR_IPU("Alienware AW510K",   DetectAlienwareAW510KControllers,   ALIENWARE_VID,  ALIENWARE_AW510K_PID,   0x02,   0xFF00, 0x01);
+REGISTER_HID_DETECTOR_IPU("Alienware AW410K",   DetectAlienwareAW410KControllers,   ALIENWARE_VID,  ALIENWARE_AW410K_PID,   0x02,   0xFF00, 0x01);

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW410K.cpp

@@ -0,0 +1,481 @@
+/*------------------------------------------------------*\
+|  RGBController_AlienwareAW410K.cpp                     |
+|                                                        |
+|  Generic RGB Interface for alienware                   |
+|  AW410K Keyboard                                       |
+|                                                        |
+|  based on AW510K controller by Mohamad Sallal - msallal|
+|                                                        |
+|  Dominik Mikolajczyk - dmiko 23/10/2023                |
+\*------------------------------------------------------*/
+
+#include "RGBControllerKeyNames.h"
+#include "RGBController_AlienwareAW410K.h"
+#include <iterator>
+
+//0xFFFFFFFF indicates an unused entry in matrix
+#define NA  0xFFFFFFFF
+
+int GetAW410K_WaveDirection(int input);
+
+static unsigned int matrix_map[6][24] =
+{ {  0,   NA,   1,   2,   3,   4,  NA,   5,   6,   7,   8,   9,  10,  11,  12, NA,  13,  14,  15,  NA,  NA,  16,  17,  18 },
+  {  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  NA, NA,  33,  34,  35,  NA,  36,  37,  38,  39 },
+  {  40,  NA,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  52,  53, NA,  54,  55,  56,  NA,  57,  58,  59,  60 },
+  {  61,  NA,  62,  63,  64,  65,  66,  67,  68,  69,  70,  71,  72,  NA,  73, NA,  NA,  NA,  NA,  NA,  74,  75,  76,  NA },
+  {  77,  NA,  NA,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  NA, NA,  NA,  89,  NA,  NA,  90,  91,  92,  93 },
+  {  94,  NA,  95,  96,  NA,  NA,  NA,  97,  NA,  NA,  NA,  98,  99, 100, 101, NA, 102, 103, 104,  NA, 105,  NA, 106,  NA }};
+
+static const char* zone_names[] =
+{
+    "AW410K",
+};
+
+static zone_type zone_types[] =
+{
+    ZONE_TYPE_MATRIX,
+};
+
+static const unsigned int zone_sizes[] =
+{
+    107,
+};
+
+typedef struct
+{
+    const char *        name;
+    const unsigned char zone;
+    const unsigned char idx;
+} aw410k_led_type;
+
+static const aw410k_led_type led_names[] =
+{
+    /* Key Label                Zone,                                      Index  */
+    { KEY_EN_ESCAPE,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB0    },
+    { KEY_EN_F1,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x98    },
+    { KEY_EN_F2,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x90    },
+    { KEY_EN_F3,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x88    },
+    { KEY_EN_F4,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x80    },
+    { KEY_EN_F5,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x70    },
+    { KEY_EN_F6,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x68    },
+    { KEY_EN_F7,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x60    },
+    { KEY_EN_F8,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x58    },
+    { KEY_EN_F9,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x50    },
+    { KEY_EN_F10,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x48    },
+    { KEY_EN_F11,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x40    },
+    { KEY_EN_F12,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x38    },
+    { KEY_EN_PRINT_SCREEN,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x30    },
+    { KEY_EN_SCROLL_LOCK,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x28    },
+    { KEY_EN_PAUSE_BREAK,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x20    },
+    { KEY_EN_MEDIA_MUTE,        ALIENWARE_AW410K_ZONE_DIRECT_MEDIA,        0x18    },
+    { KEY_EN_MEDIA_VOLUME_DOWN, ALIENWARE_AW410K_ZONE_DIRECT_MEDIA,        0x10    },
+    { KEY_EN_MEDIA_VOLUME_UP,   ALIENWARE_AW410K_ZONE_DIRECT_MEDIA,        0x08    },
+    { KEY_EN_BACK_TICK,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB1    },
+    { KEY_EN_1,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA1    },
+    { KEY_EN_2,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x99    },
+    { KEY_EN_3,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x91    },
+    { KEY_EN_4,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x89    },
+    { KEY_EN_5,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x81    },
+    { KEY_EN_6,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x79    },
+    { KEY_EN_7,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x71    },
+    { KEY_EN_8,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x69    },
+    { KEY_EN_9,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x61    },
+    { KEY_EN_0,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x59    },
+    { KEY_EN_MINUS,             ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x51    },
+    { KEY_EN_EQUALS,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x49    },
+    { KEY_EN_BACKSPACE,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x39    },
+    { KEY_EN_INSERT,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x31    },
+    { KEY_EN_HOME,              ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x29    },
+    { KEY_EN_PAGE_UP,           ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x21    },
+    { KEY_EN_NUMPAD_LOCK,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x19    },
+    { KEY_EN_NUMPAD_DIVIDE,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x11    },
+    { KEY_EN_NUMPAD_TIMES,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x09    },
+    { KEY_EN_NUMPAD_MINUS,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x01    },
+    { KEY_EN_TAB,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB2    },
+    { KEY_EN_Q,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA2    },
+    { KEY_EN_W,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x9A    },
+    { KEY_EN_E,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x92    },
+    { KEY_EN_R,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x8A    },
+    { KEY_EN_T,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x82    },
+    { KEY_EN_Y,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x7A    },
+    { KEY_EN_U,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x72    },
+    { KEY_EN_I,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x6A    },
+    { KEY_EN_O,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x62    },
+    { KEY_EN_P,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x5A    },
+    { KEY_EN_LEFT_BRACKET,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x52    },
+    { KEY_EN_RIGHT_BRACKET,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x4A    },
+    { KEY_EN_ANSI_BACK_SLASH,   ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x42    },
+    { KEY_EN_DELETE,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x32    },
+    { KEY_EN_END,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x2A    },
+    { KEY_EN_PAGE_DOWN,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x22    },
+    { KEY_EN_NUMPAD_7,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x1A    },
+    { KEY_EN_NUMPAD_8,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x12    },
+    { KEY_EN_NUMPAD_9,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x0A    },
+    { KEY_EN_NUMPAD_PLUS,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x03    },
+    { KEY_EN_CAPS_LOCK,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB3    },
+    { KEY_EN_A,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA3    },
+    { KEY_EN_S,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x9B    },
+    { KEY_EN_D,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x93    },
+    { KEY_EN_F,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x8B    },
+    { KEY_EN_G,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x83    },
+    { KEY_EN_H,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x7B    },
+    { KEY_EN_J,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x73    },
+    { KEY_EN_K,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x6B    },
+    { KEY_EN_L,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x63    },
+    { KEY_EN_SEMICOLON,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x5B    },
+    { KEY_EN_QUOTE,             ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x53    },
+    { KEY_EN_ANSI_ENTER,        ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x43    },
+    { KEY_EN_NUMPAD_4,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x1B    },
+    { KEY_EN_NUMPAD_5,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x13    },
+    { KEY_EN_NUMPAD_6,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x0B    },
+    { KEY_EN_LEFT_SHIFT,        ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB4    },
+    { KEY_EN_Z,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA4    },
+    { KEY_EN_X,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x9C    },
+    { KEY_EN_C,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x94    },
+    { KEY_EN_V,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x8C    },
+    { KEY_EN_B,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x84    },
+    { KEY_EN_N,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x7C    },
+    { KEY_EN_M,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x74    },
+    { KEY_EN_COMMA,             ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x6C    },
+    { KEY_EN_PERIOD,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x64    },
+    { KEY_EN_FORWARD_SLASH,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x5C    },
+    { KEY_EN_RIGHT_SHIFT,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x4C    },
+    { KEY_EN_UP_ARROW,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x2C    },
+    { KEY_EN_NUMPAD_1,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x1C    },
+    { KEY_EN_NUMPAD_2,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x14    },
+    { KEY_EN_NUMPAD_3,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x0C    },
+    { KEY_EN_NUMPAD_ENTER,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x05    },
+    { KEY_EN_LEFT_CONTROL,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB5    },
+    { KEY_EN_LEFT_WINDOWS,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xAD    },
+    { KEY_EN_LEFT_ALT,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA5    },
+    { KEY_EN_SPACE,             ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x85    },
+    { KEY_EN_RIGHT_ALT,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x65    },
+    { KEY_EN_RIGHT_FUNCTION,    ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x5D    },
+    { KEY_EN_MENU,              ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x55    },
+    { KEY_EN_RIGHT_CONTROL,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x4D    },
+    { KEY_EN_LEFT_ARROW,        ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x35    },
+    { KEY_EN_DOWN_ARROW,        ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x2D    },
+    { KEY_EN_RIGHT_ARROW,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x25    },
+    { KEY_EN_NUMPAD_0,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x1D    },
+    { KEY_EN_NUMPAD_PERIOD,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x0D    }
+};
+
+/**------------------------------------------------------------------*\
+    @name Alienware AW410 Keyboard
+    @category Keyboard
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAlienwareAW410KControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AlienwareAW410K::RGBController_AlienwareAW410K(AlienwareAW410KController* controller_ptr)
+{
+    controller                      = controller_ptr;
+
+    name                            = "Alienware AW410K Keyboard Device";
+    vendor                          = "Alienware";
+    type                            = DEVICE_TYPE_KEYBOARD;
+    description                     = "Alienware AW410K Keyboard Device";
+    location                        = controller->GetDeviceLocation();
+    serial                          = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name                     = "Direct";
+    Direct.value                    = ALIENWARE_AW410K_MODE_DIRECT;
+    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode               = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Static;
+    Static.name                     = "Static";
+    Static.value                    = ALIENWARE_AW410K_MODE_STATIC;
+    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min               = 1;
+    Static.colors_max               = 1;
+    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Pulse;
+    Pulse.name                      = "Pulse";
+    Pulse.value                     = ALIENWARE_AW410K_MODE_PULSE;
+    Pulse.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Pulse.color_mode                = MODE_COLORS_MODE_SPECIFIC;
+    Pulse.speed_min                 = ALIENWARE_AW410K_SPEED_SLOWEST;
+    Pulse.speed_max                 = ALIENWARE_AW410K_SPEED_NORMAL;
+    Pulse.speed                     = ALIENWARE_AW410K_SPEED_NORMAL;
+    Pulse.colors_min                = 1;
+    Pulse.colors_max                = 1;
+    Pulse.colors.resize(1);
+    modes.push_back(Pulse);
+
+    mode Morph;
+    Morph.name                      = "Morph";
+    Morph.value                     = ALIENWARE_AW410K_MODE_MORPH;
+    Morph.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Morph.color_mode                = MODE_COLORS_MODE_SPECIFIC;
+    Morph.speed_min                 = ALIENWARE_AW410K_SPEED_SLOWEST;
+    Morph.speed_max                 = ALIENWARE_AW410K_SPEED_NORMAL;
+    Morph.speed                     = ALIENWARE_AW410K_SPEED_NORMAL;
+    Morph.colors_min                = 2;
+    Morph.colors_max                = 2;
+    Morph.colors.resize(2);
+    modes.push_back(Morph);
+
+    mode Breathing;
+    Breathing.name                  = "Breathing";
+    Breathing.value                 = ALIENWARE_AW410K_MODE_BREATHING;
+    Breathing.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Breathing.colors_min            = 1;
+    Breathing.colors_max            = 1;
+    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors.resize(1);
+    Breathing.speed_min             = ALIENWARE_AW410K_SPEED_SLOWEST;
+    Breathing.speed_max             = ALIENWARE_AW410K_SPEED_FASTEST;
+    Breathing.speed                 = ALIENWARE_AW410K_SPEED_NORMAL;
+    modes.push_back(Breathing);
+
+    mode SingleWave;
+    SingleWave.name                  = "Single Wave";
+    SingleWave.value                 = ALIENWARE_AW410K_MODE_SINGLE_WAVE;
+    SingleWave.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
+    SingleWave.speed_min             = ALIENWARE_AW410K_SPEED_SLOWEST;
+    SingleWave.speed_max             = ALIENWARE_AW410K_SPEED_FASTEST;
+    SingleWave.speed                 = ALIENWARE_AW410K_SPEED_NORMAL;
+    SingleWave.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    SingleWave.colors_min            = 1;
+    SingleWave.colors_max            = 1;
+    SingleWave.colors.resize(1);
+    modes.push_back(SingleWave);
+
+    mode RainbowWave;
+    RainbowWave.name                  = "Rainbow Wave";
+    RainbowWave.value                 = ALIENWARE_AW410K_MODE_RAINBOW_WAVE;
+    RainbowWave.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
+    RainbowWave.speed_min             = ALIENWARE_AW410K_SPEED_SLOWEST;
+    RainbowWave.speed_max             = ALIENWARE_AW410K_SPEED_FASTEST;
+    RainbowWave.speed                 = ALIENWARE_AW410K_SPEED_NORMAL;
+    RainbowWave.colors_min            = 1;
+    RainbowWave.colors_max            = 1;
+    RainbowWave.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    RainbowWave.colors.resize(1);
+    modes.push_back(RainbowWave);
+
+    mode Off;
+    Off.name                          = "Off";
+    Off.value                         = ALIENWARE_AW410K_MODE_OFF;
+    Off.flags                         = 0;
+    Off.color_mode                    = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    SetupZones();
+    std::copy(colors.begin(), colors.end(),std::back_inserter(current_colors));
+}
+
+RGBController_AlienwareAW410K::~RGBController_AlienwareAW410K()
+{
+    /*---------------------------------------------------------*\
+    | Delete the matrix map                                     |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    {
+        if(zones[zone_index].matrix_map != NULL)
+        {
+            delete zones[zone_index].matrix_map;
+        }
+    }
+
+    delete controller;
+}
+
+void RGBController_AlienwareAW410K::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    unsigned int total_led_count = 0;
+
+    for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
+    {
+        zone new_zone;
+        new_zone.name                   = zone_names[zone_idx];
+        new_zone.type                   = zone_types[zone_idx];
+        new_zone.leds_min               = zone_sizes[zone_idx];
+        new_zone.leds_max               = zone_sizes[zone_idx];
+        new_zone.leds_count             = zone_sizes[zone_idx];
+
+        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
+        {
+            new_zone.matrix_map         = new matrix_map_type;
+            new_zone.matrix_map->height = 6;
+            new_zone.matrix_map->width  = 24;
+            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+        }
+        else
+        {
+            new_zone.matrix_map         = NULL;
+        }
+
+        zones.push_back(new_zone);
+
+        total_led_count += zone_sizes[zone_idx];
+    }
+
+    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
+    {
+        led new_led;
+        new_led.name  = led_names[led_idx].name;
+        new_led.value = led_names[led_idx].idx;
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AlienwareAW410K::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AlienwareAW410K::DeviceUpdateLEDs()
+{
+    std::vector<SelectedButtons>   frame_buf_keys;
+    std::vector<RGBColor>       new_colors;
+
+    std::copy(colors.begin(), colors.end(),std::back_inserter(new_colors));
+
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+            SelectedButtons key;
+
+            key.idx     = (unsigned char)leds[led_idx].value;
+            key.red     = RGBGetRValue(colors[led_idx]);
+            key.green   = RGBGetGValue(colors[led_idx]);
+            key.blue    = RGBGetBValue(colors[led_idx]);
+
+            frame_buf_keys.push_back(key);
+    }
+
+    controller->SendInitialize();
+    controller->SendfeatureReport(0x05, 0x01, 0x51, 0x00);
+    controller->SendCommit();
+
+    if(frame_buf_keys.size() > 0)
+    {
+        controller->SendDirectOn(frame_buf_keys);
+    }
+
+    std::copy(new_colors.begin(), new_colors.end(),current_colors.begin());
+}
+
+void RGBController_AlienwareAW410K::UpdateZoneLEDs(int zone)
+{
+    controller->SetDirect((unsigned char) zone, RGBGetRValue(zones[zone].colors[0]), RGBGetGValue(zones[zone].colors[0]), RGBGetBValue(zones[zone].colors[0]));
+}
+
+void RGBController_AlienwareAW410K::UpdateSingleLED(int led)
+{
+    controller->UpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
+}
+
+void RGBController_AlienwareAW410K::DeviceUpdateMode()
+{
+    if(active_mode == 0xFFFF)
+    {
+        UpdateLEDs();
+        return;
+    }
+
+    controller->SendfeatureReport(0x05, 0x01, 0x51, 0x00);
+    unsigned char red = 0;
+    unsigned char grn = 0;
+    unsigned char blu = 0;
+
+    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        red = RGBGetRValue(modes[active_mode].colors[0]);
+        grn = RGBGetGValue(modes[active_mode].colors[0]);
+        blu = RGBGetBValue(modes[active_mode].colors[0]);
+    }
+
+    switch(modes[active_mode].value)
+    {
+        case ALIENWARE_AW410K_MODE_DIRECT:
+            /*-------------------------------------------------------------*\
+            | Load LEDs again in case of profile load etc.                  |
+            \*-------------------------------------------------------------*/
+            DeviceUpdateLEDs();
+            break;  
+        case ALIENWARE_AW410K_MODE_MORPH:
+            /*-------------------------------------------------------------*\
+            | In case of morph it requires two colors (color1 and color2)   |
+            \*-------------------------------------------------------------*/
+            {
+                unsigned char red2 = RGBGetRValue(modes[active_mode].colors[1]);
+                unsigned char grn2 = RGBGetGValue(modes[active_mode].colors[1]);
+                unsigned char blu2 = RGBGetBValue(modes[active_mode].colors[1]);
+
+                controller->SetMorphMode(modes[active_mode].value, modes[active_mode].speed, red, grn, blu, red2, grn2, blu2);
+            }
+            break;
+
+        case ALIENWARE_AW410K_MODE_SPECTRUM:
+            /*-------------------------------------------------------------*\
+            | Spectrum only set mode, speed and colorMode                   |
+            \*-------------------------------------------------------------*/
+            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, 0x00, ALIENWARE_AW410K_RANBOW_COLOR_MODE, 0x00, 0x00, 0x00);
+            break;
+
+        case ALIENWARE_AW410K_MODE_SINGLE_WAVE:
+            /*-------------------------------------------------------------*\
+            | Wave only set mode, speed, direction and colorMode            |
+            \*-------------------------------------------------------------*/
+            {
+                int waveDirection = GetAW410K_WaveDirection(modes[active_mode].direction);
+                controller->SetMode(modes[active_mode].value, modes[active_mode].speed, waveDirection, ALIENWARE_AW410K_SINGLE_COLOR_MODE, red, grn, blu);
+            }
+            break;
+
+        case ALIENWARE_AW410K_MODE_RAINBOW_WAVE:
+            /*-------------------------------------------------------------*\
+            | Wave only set mode, speed, direction and colorMode            |
+            \*-------------------------------------------------------------*/
+            {
+            int waveDirection = GetAW410K_WaveDirection(modes[active_mode].direction);
+            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, waveDirection, ALIENWARE_AW410K_RANBOW_COLOR_MODE, 0x00, 0x00, 0x00);
+            }
+            break;
+
+
+        default:
+            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, 0x00, ALIENWARE_AW410K_SINGLE_COLOR_MODE, red, grn, blu);
+            break;
+    }
+}
+
+int GetAW410K_WaveDirection(int input)
+{
+    switch(input)
+    {
+        case MODE_DIRECTION_LEFT:
+            return(ALIENWARE_AW410K_DIRECTION_RIGHT_TO_LEFT);
+
+        case MODE_DIRECTION_RIGHT:
+            return(ALIENWARE_AW410K_DIRECTION_LEFT_TO_RIGHT);
+
+        case MODE_DIRECTION_UP:
+            return(ALIENWARE_AW410K_DIRECTION_BOTTOM_TO_TOP);
+
+        case MODE_DIRECTION_DOWN:
+            return(ALIENWARE_AW410K_DIRECTION_TOP_TO_BOTTOM);
+
+        default:
+            return(ALIENWARE_AW410K_DIRECTION_RIGHT_TO_LEFT);
+    }
+}
+

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW410K.h

@@ -0,0 +1,36 @@
+/*------------------------------------------------------*\
+|  RGBController_AlienwareAW410K.h                       |
+|                                                        |
+|  Generic RGB Interface for Alienware                   |
+|  AW410K keyboard                                       |
+|                                                        |
+|  based on AW510K controller by Mohamad Sallal - msallal|
+|                                                        |
+|  Dominik Mikolajczyk - dmiko 23/10/2023                |
+\*------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AlienwareAW410KController.h"
+
+class RGBController_AlienwareAW410K : public RGBController
+{
+public:
+    RGBController_AlienwareAW410K(AlienwareAW410KController* controller_ptr);
+    ~RGBController_AlienwareAW410K();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AlienwareAW410KController*  controller;
+    std::vector<RGBColor>       current_colors;
+};

Controllers/AnnePro2Controller/AnnePro2ControllerDetect.cpp

@@ -4,7 +4,8 @@
 #include "RGBController_AnnePro2.h"
 #include <hidapi/hidapi.h>
 
-#define ANNE_PRO_2_VID 0x04D9
+#define ANNE_PRO_2_VID_1 0x04D9
+#define ANNE_PRO_2_VID_2 0x3311
 #define ANNE_PRO_2_PID_1 0x8008
 #define ANNE_PRO_2_PID_2 0x8009
 #define ANNE_PRO_2_PID_3 0xA292
@@ -31,8 +32,8 @@ void DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
     }
 }
 
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_1, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_2, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_3, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_4, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_5, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_1, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_2, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_3, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_4, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_2, ANNE_PRO_2_PID_5, 1);

Controllers/AsusAuraGPUController/AsusAuraGPUController.cpp

@@ -7,6 +7,7 @@
 \*-----------------------------------------*/
 
 #include "AsusAuraGPUController.h"
+#include "pci_ids.h"
 #include <cstring>
 
 AuraGPUController::AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id dev)
@@ -52,25 +53,16 @@ unsigned char AuraGPUController::GetLEDBlue()
     return(AuraGPURegisterRead(AURA_GPU_REG_BLUE));
 }
 
-void AuraGPUController::SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue)                  // Direct Mode is just Static Mode without applying color changes
+void AuraGPUController::SetLEDColors(unsigned char red, unsigned char green, unsigned char blue)
 {
     AuraGPURegisterWrite(AURA_GPU_REG_RED, red);
     AuraGPURegisterWrite(AURA_GPU_REG_GREEN, green);
     AuraGPURegisterWrite(AURA_GPU_REG_BLUE, blue);
 }
 
-void AuraGPUController::SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
-{
-    AuraGPURegisterWrite(AURA_GPU_REG_RED, red);
-    AuraGPURegisterWrite(AURA_GPU_REG_GREEN, green);
-    AuraGPURegisterWrite(AURA_GPU_REG_BLUE, blue);
-    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
-}
-
 void AuraGPUController::SetMode(unsigned char mode)
 {
     AuraGPURegisterWrite(AURA_GPU_REG_MODE, mode);
-    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
 }
 
 unsigned char AuraGPUController::AuraGPURegisterRead(unsigned char reg)
@@ -81,4 +73,21 @@ unsigned char AuraGPUController::AuraGPURegisterRead(unsigned char reg)
 void AuraGPUController::AuraGPURegisterWrite(unsigned char reg, unsigned char val)
 {
     bus->i2c_smbus_write_byte_data(dev, reg, val);
-}
+}
+
+bool AuraGPUController::SaveOnlyApplies()
+{
+    switch (bus->pci_subsystem_device)
+    {
+        case ASUS_VEGA64_STRIX:
+            return false;
+    }
+    // Behavior on other GPU models is unknown and needs to be tested.
+    // Assume the safest option to prevent damaage from excessive writes.
+    return false;
+}
+
+void AuraGPUController::Save()
+{
+    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
+}

Controllers/AsusAuraGPUController/AsusAuraGPUController.h

@@ -23,7 +23,7 @@ enum
     AURA_GPU_REG_BLUE                       = 0x06,    /* AURA GPU BLUE Register           */
     AURA_GPU_REG_MODE                       = 0x07,    /* AURA GPU Mode Selection Register */
     AURA_GPU_REG_SYNC                       = 0x0C,    /* AURA GPU "Sync" Register         */
-    AURA_GPU_REG_APPLY                      = 0x0E,    /* AURA GPU Apply Chnages Register  */
+    AURA_GPU_REG_APPLY                      = 0x0E,    /* AURA GPU Save or Apply Register  */
 };
 
 enum
@@ -48,17 +48,18 @@ public:
     unsigned char GetLEDRed();
     unsigned char GetLEDGreen();
     unsigned char GetLEDBlue();
-    void          SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue);
-    void          SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue);
+    void          SetLEDColors(unsigned char red, unsigned char green, unsigned char blue);
     void          SetMode(unsigned char mode);
+    void          Save();
 
     unsigned char AuraGPURegisterRead(unsigned char reg);
     void          AuraGPURegisterWrite(unsigned char reg, unsigned char val);
 
+    bool          SaveOnlyApplies();
     bool          direct = false;                                                // Temporary solution to check if we are in "Direct" mode
 
 private:
     char                    device_name[16];
     i2c_smbus_interface *   bus;
     aura_gpu_dev_id         dev;
-};
+};

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -69,68 +69,69 @@ void DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
 |  NVidia GPUs                              |
 \*-----------------------------------------*/
 
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 O2G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI 4G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI O4G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI O4G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING_2,      0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1060 Strix 6G Gaming"             , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX_6G_GAMING,               0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1060 Strix"                       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX,                         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1070 Strix Gaming"                , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_GAMING,                  0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1070 Strix OC"                    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_OC,                      0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1070 Ti 8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_8G_GAMING,         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1070 Ti A8G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,        0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1080 Strix OC"                    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_GTX1080_STRIX,                         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 A8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_A8G_GAMING,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 O8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_GAMING,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 O8G 11Gbps"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_11GBPS,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 Ti Gaming"          , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_GAMING,            0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 Ti 11G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,        0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 Ti O11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING,       0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 Ti O11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING_A02,   0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1650S OC 4G"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1650S_OC,                 0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660S O6G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1660 Ti OC 6G"                , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_GTX1660TI_OC,                      0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 EVO Gaming 6G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING_86D2,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G EVO Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S 8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G EVO Gaming"   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S 8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G V2 Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_V2_GAMING,       0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S O8G White"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_WHITE,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING_866C,   0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060 Ti 8G Gaming OC"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 O2G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 Ti 4G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 Ti O4G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 Ti O4G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING_2,      0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1060 Strix 6G Gaming"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX_6G_GAMING,               0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1060 Strix"                      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX,                         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1070 Strix Gaming"               , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_GAMING,                  0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1070 Strix OC"                   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_OC,                      0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1070 Ti 8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_8G_GAMING,         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1070 Ti A8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,        0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1080 Strix OC"                   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_GTX1080_STRIX,                         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 A8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_A8G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 O8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 O8G 11Gbps"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_11GBPS,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti Gaming"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_GAMING,            0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti 11G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,        0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti O11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING,       0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti O11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING_A02,   0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1650 SUPER OC 4G"          , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1650S_OC,                 0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660 SUPER O6G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660 SUPER 6G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_6G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660 Ti OC 6G"             , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_GTX1660TI_OC,                      0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 EVO Gaming 6G"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING_86D2,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G EVO Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER 8G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER A8G EVO Gaming" , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER 8G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G V2 Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_V2_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 SUPER O8G White"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_WHITE,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING_866C,   0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti O11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060 Ti 8G Gaming OC"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x2A);
 
 /*-----------------------------------------*\
 |  AMD GPUs                                 |
 \*-----------------------------------------*/
 
-REGISTER_I2C_PCI_DETECTOR("ASUS AREZ Strix RX Vega 56 O8G"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS Vega 64 Strix"                        , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 5600XT Strix O6G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 5700XT Strix Gaming OC"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 5700XT Strix 08G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING,             0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX470 O4G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX480 Gaming OC"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX480_STRIX_GAMING_OC,                 0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX560 Gaming"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING,                 0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 570 Strix O4G Gaming OC"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 570 Strix O8G Gaming OC"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O8G_GAMING_OC,             0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 580 Strix Gaming OC"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_OC,                 0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 580 Strix Gaming TOP"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_TOP,                0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS AREZ Strix RX Vega 56 O8G"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Vega 64 Strix"                       , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5600 XT Strix O6G Gaming"         , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5700 XT Strix Gaming OC"          , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5700 XT Strix 08G Gaming"         , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING,             0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 470 O4G Gaming"             , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 480 Gaming OC"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX480_STRIX_GAMING_OC,                 0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 560 Gaming"                 , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING,                 0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 570 Strix O4G Gaming OC"          , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 570 Strix O8G Gaming OC"          , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O8G_GAMING_OC,             0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 580 Strix Gaming OC"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_OC,                 0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 580 Strix Gaming TOP"             , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_TOP,                0x29);

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp

@@ -45,11 +45,15 @@ int RGBController_AuraGPU::GetDeviceMode()
     @name Asus Aura GPU
     @category GPU
     @type SMBus
-    @save :x:
+    @save :tools:
     @direct :white_check_mark:
     @effects :white_check_mark:
     @detectors DetectAsusAuraGPUControllers
-    @comment
+    @comment On some models save command might function like apply.
+        Known models with correctly working save: ASUS Vega 64 Strix.
+        This may result in changes not applying until user clicks
+        "save to device". Contact OpenRGB developers if you have one
+        of the affected models.
 \*-------------------------------------------------------------------*/
 
 RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * controller_ptr)
@@ -69,38 +73,44 @@ RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * controller_ptr)
     Direct.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
+    unsigned int save_flags = 0;
+    if(!controller->SaveOnlyApplies())
+    {
+        save_flags |= MODE_FLAG_MANUAL_SAVE;
+    }
+
     mode Off;
     Off.name       = "Off";
     Off.value      = AURA_GPU_MODE_OFF;
-    Off.flags      = 0;
+    Off.flags      = save_flags;
     Off.color_mode = MODE_COLORS_NONE;
     modes.push_back(Off);
 
     mode Static;
     Static.name       = "Static";
     Static.value      = AURA_GPU_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR | save_flags;
     Static.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     mode Breathing;
     Breathing.name       = "Breathing";
     Breathing.value      = AURA_GPU_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR | save_flags;
     Breathing.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Breathing);
 
     mode Flashing;
     Flashing.name       = "Flashing";
     Flashing.value      = AURA_GPU_MODE_FLASHING;
-    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR | save_flags;
     Flashing.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Flashing);
 
     mode Spectrum_Cycle;
     Spectrum_Cycle.name       = "Spectrum Cycle";
-    Spectrum_Cycle.value      = AURA_GPU_MODE_SPECTRUM_CYCLE;
-    Spectrum_Cycle.flags      = 0;
+    Spectrum_Cycle.value      = AURA_GPU_MODE_SPECTRUM_CYCLE ;
+    Spectrum_Cycle.flags      = save_flags;
     Spectrum_Cycle.color_mode = MODE_COLORS_NONE;
     modes.push_back(Spectrum_Cycle);
 
@@ -162,14 +172,11 @@ void RGBController_AuraGPU::DeviceUpdateLEDs()
         unsigned char grn = RGBGetGValue(colors[led]);
         unsigned char blu = RGBGetBValue(colors[led]);
 
-        if (GetMode() == 0)
-        {
-            controller->SetLEDColorsDirect(red, grn, blu);
-        }
-        else
-        {
-            controller->SetLEDColorsEffect(red, grn, blu);
-        }
+        controller->SetLEDColors(red, grn, blu);
+    }
+    if (controller->SaveOnlyApplies() && GetMode() != 0)
+    {
+        controller->Save();
     }
 }
 
@@ -192,7 +199,7 @@ void RGBController_AuraGPU::DeviceUpdateMode()
     {
         // Set all LEDs to 0 and Mode to static as a workaround for the non existing Off Mode
         case AURA_GPU_MODE_OFF:
-            controller->SetLEDColorsEffect(0, 0, 0);
+            controller->SetLEDColors(0, 0, 0);
             new_mode           = AURA_GPU_MODE_STATIC;
             break;
 
@@ -204,4 +211,13 @@ void RGBController_AuraGPU::DeviceUpdateMode()
     }
 
     controller->SetMode(new_mode);
+    if (controller->SaveOnlyApplies())
+    {
+        controller->Save();
+    }
+}
+
+void RGBController_AuraGPU::DeviceSaveMode()
+{
+    controller->Save();
 }

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.h

@@ -26,6 +26,7 @@ public:
     void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
     AuraGPUController* controller;

Controllers/AsusAuraUSBController/AsusAuraAddressableController.cpp

@@ -28,37 +28,12 @@ AuraAddressableController::~AuraAddressableController()
 
 void AuraAddressableController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
 {
-    unsigned char   led_data[60];
-    unsigned int    leds_sent = 0;
-
-    while(leds_sent < num_colors)
-    {
-        unsigned int leds_to_send = 20;
-
-        if((num_colors - leds_sent) < leds_to_send)
-        {
-            leds_to_send = num_colors - leds_sent;
-        }
-
-        for(unsigned int led_idx = 0; led_idx < leds_to_send; led_idx++)
-        {
-            led_data[(led_idx * 3) + 0] = RGBGetRValue(colors[led_idx + leds_sent]);
-            led_data[(led_idx * 3) + 1] = RGBGetGValue(colors[led_idx + leds_sent]);
-            led_data[(led_idx * 3) + 2] = RGBGetBValue(colors[led_idx + leds_sent]);
-        }
-
-        SendDirect
-        (
-            channel,
-            leds_sent,
-            leds_to_send,
-            led_data
-        );
-
-        leds_sent += leds_to_send;
-    }
-
-    SendDirectApply(channel);
+    SendDirect
+    (
+        device_info[channel].direct_channel,
+        num_colors,
+        colors
+    );
 }
 
 void AuraAddressableController::SetMode
@@ -117,28 +92,3 @@ void AuraAddressableController::SendEffect
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
 }
-
-void AuraAddressableController::SendDirectApply
-    (
-    unsigned char   channel
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_CONTROL_MODE_DIRECT;
-    usb_buf[0x02]   = 0x80 | channel;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}

Controllers/AsusAuraUSBController/AsusAuraAddressableController.h

@@ -52,9 +52,4 @@ private:
         unsigned char   grn,
         unsigned char   blu
         );
-
-    void    SendDirectApply
-        (
-        unsigned char   channel
-        );
 };

Controllers/AsusAuraUSBController/AsusAuraMainboardController.cpp

@@ -46,36 +46,13 @@ AuraMainboardController::~AuraMainboardController()
 
 void AuraMainboardController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
 {
-    unsigned char   led_data[60];
-    unsigned int    leds_sent = 0;
+    SendDirect
+    (
+        device_info[channel].direct_channel,
+        num_colors,
+        colors
+    );
 
-    while(leds_sent < num_colors)
-    {
-        unsigned int leds_to_send = 20;
-
-        if((num_colors - leds_sent) < leds_to_send)
-        {
-            leds_to_send = num_colors - leds_sent;
-        }
-
-        for(unsigned int led_idx = 0; led_idx < leds_to_send; led_idx++)
-        {
-            led_data[(led_idx * 3) + 0] = RGBGetRValue(colors[led_idx + leds_sent]);
-            led_data[(led_idx * 3) + 1] = RGBGetGValue(colors[led_idx + leds_sent]);
-            led_data[(led_idx * 3) + 2] = RGBGetBValue(colors[led_idx + leds_sent]);
-        }
-
-        SendDirect
-        (
-            device_info[channel].direct_channel,
-            leds_sent,
-            leds_to_send,
-            led_data,
-            leds_sent + leds_to_send >= num_colors
-        );
-
-        leds_sent += leds_to_send;
-    }
 }
 
 void AuraMainboardController::SetMode

Controllers/AsusAuraUSBController/AsusAuraMonitorController.cpp

@@ -49,7 +49,7 @@ void AuraMonitorController::BeginUpdate()
 {
     unsigned char usb_buf[8];
 
-    if (device_pid == AURA_ROG_PG32UQ_PID)
+    if (device_pid == AURA_ROG_PG32UQ_PID || device_pid == AURA_ROG_STRIX_XG32VC_PID)
     {
         memset(usb_buf, 0x00, sizeof(usb_buf));
 

Controllers/AsusAuraUSBController/AsusAuraMonitorController.h

@@ -19,6 +19,7 @@ enum
     AURA_ROG_STRIX_XG27AQM_PID  = 0x19BB,
     AURA_ROG_STRIX_XG279Q_PID   = 0x1919,
     AURA_ROG_STRIX_XG27W_PID    = 0x1933,
+    AURA_ROG_STRIX_XG32VC_PID   = 0x1968,
     AURA_ROG_PG32UQ_PID         = 0x19B9,
 };
 

Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp

@@ -28,6 +28,32 @@ std::string AuraMouseController::GetDeviceLocation()
     return("HID: " + location);
 }
 
+std::string AuraMouseController::CleanSerial(const std::wstring& wstr)
+{
+    /*---------------------------------------------------------------*\
+    | Cleanes garbage at the end of serial numbers                    |
+    | (apparently 2 characters too much, but maybe variable)          |
+    | Limited to new devices, old ones don't even have serial numbers |
+    \*---------------------------------------------------------------*/
+    std::string result;
+    for(wchar_t c : wstr)
+    {
+        /*-----------------------------------------------------*\
+        | Forbid anything besides digits and upper case letters |
+        \*-----------------------------------------------------*/
+        bool isUpperCaseLetter = (c >= 64 && c <= 90);
+        bool isDigit           = (c >= 48 && c <= 57);
+        if(!isUpperCaseLetter && !isDigit)
+        {
+            break;
+        }
+
+        result += c;
+    }
+
+    return(result);
+}
+
 std::string AuraMouseController::GetSerialString()
 {
     wchar_t serial_string[HID_MAX_STR];
@@ -38,8 +64,8 @@ std::string AuraMouseController::GetSerialString()
         return("");
     }
 
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
+    std::wstring serial_wstring = serial_string;
+    std::string return_string = CleanSerial(serial_wstring);
 
     return(return_string);
 }
@@ -184,3 +210,48 @@ void AuraMouseController::SendUpdate
     unsigned char usb_buf_out[ASUS_AURA_MOUSE_PACKET_SIZE];
     hid_read_timeout(dev, usb_buf_out, ASUS_AURA_MOUSE_PACKET_SIZE, 10);
 }
+
+void AuraMouseController::SendDirect
+    (
+    std::vector<RGBColor>   zone_colors
+    )
+{
+    std::vector<RGBColor> colors = {};
+    colors.resize(aura_mouse_led_maps[device_pid].led_amount);
+
+    for(unsigned char zone = 0; zone < zone_colors.size(); zone++)
+    {
+        std::vector<uint8_t> zone_map = aura_mouse_led_maps[device_pid].map[zone];
+        for(unsigned char led = 0; led < zone_map.size(); led++)
+        {
+            colors[zone_map[led]] = zone_colors[zone];
+        }
+    }
+
+    /*-----------------------------------------------------*\
+    | Only 5 colors can be sent in each packet              |
+    \*-----------------------------------------------------*/
+    for(unsigned char led = 0; led < aura_mouse_led_maps[device_pid].led_amount; led += 5)
+    {
+        unsigned char usb_buf[ASUS_AURA_MOUSE_PACKET_SIZE];
+        memset(usb_buf, 0x00, ASUS_AURA_MOUSE_PACKET_SIZE);
+
+        unsigned char colors_in_packet = (aura_mouse_led_maps[device_pid].led_amount >= led + 5) ? 5 : aura_mouse_led_maps[device_pid].led_amount - led;
+
+        usb_buf[0x00]   = 0x00;
+        usb_buf[0x01]   = 0x51;
+        usb_buf[0x02]   = 0x29;
+        usb_buf[0x03]   = colors_in_packet; // colors in this packet
+        usb_buf[0x04]   = 0x00;
+        usb_buf[0x05]   = led; // offset
+
+        for(unsigned char color = 0; color < colors_in_packet; color++)
+        {
+            usb_buf[0x06 + color * 3] = RGBGetRValue(colors[led + color]);
+            usb_buf[0x07 + color * 3] = RGBGetGValue(colors[led + color]);
+            usb_buf[0x08 + color * 3] = RGBGetBValue(colors[led + color]);
+        }
+
+        hid_write(dev, usb_buf, ASUS_AURA_MOUSE_PACKET_SIZE);
+    }
+};

Controllers/AsusAuraUSBController/AsusAuraMouseController.h

@@ -25,6 +25,7 @@ public:
     virtual ~AuraMouseController();
 
     std::string GetDeviceLocation();
+    std::string CleanSerial(const std::wstring& wstr);
     std::string GetSerialString();
     std::string GetVersion(bool wireless, int protocol);
 
@@ -41,6 +42,10 @@ public:
         unsigned char   speed,
         unsigned char   brightness
         );
+    void SendDirect
+        (
+        std::vector<RGBColor>   zone_colors
+        );
 
     uint16_t                    device_pid;
 

Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h

@@ -11,43 +11,50 @@
 
 #pragma once
 
-#define AURA_ROG_GLADIUS_II_CORE_PID                0x18DD
-#define AURA_ROG_GLADIUS_II_PID                     0x1845
-#define AURA_ROG_GLADIUS_II_ORIGIN_PID              0x1877
-#define AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID      0x18CD
-#define AURA_ROG_GLADIUS_II_ORIGIN_COD_PID          0x18B1
-#define AURA_ROG_GLADIUS_II_WIRELESS_1_PID          0x189E
-#define AURA_ROG_GLADIUS_II_WIRELESS_2_PID          0x18A0
-#define AURA_ROG_GLADIUS_III_PID                    0x197B
-#define AURA_ROG_GLADIUS_III_WIRELESS_USB_PID       0x197D
-#define AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID       0x197F
-#define AURA_ROG_GLADIUS_III_WIRELESS_BT_PID        0x1981
-#define AURA_ROG_CHAKRAM_WIRELESS_PID               0x18E5
-#define AURA_ROG_CHAKRAM_WIRED_1_PID                0x18E3
-#define AURA_ROG_CHAKRAM_CORE_PID                   0x1958
-#define AURA_ROG_CHAKRAM_X_USB_PID                  0x1A18
-#define AURA_ROG_CHAKRAM_X_2_4_PID                  0x1A1A
-#define AURA_ROG_SPATHA_X_USB_PID                   0x1977
-#define AURA_ROG_SPATHA_X_2_4_PID                   0x1979
-#define AURA_ROG_SPATHA_X_DOCK_PID                  0x1979
-#define AURA_ROG_PUGIO_PID                          0x1846
-#define AURA_ROG_PUGIO_II_WIRED_PID                 0x1906
-#define AURA_ROG_PUGIO_II_WIRELESS_PID              0x1908
-#define AURA_ROG_STRIX_IMPACT_PID                   0x1847
-#define AURA_ROG_STRIX_IMPACT_II_PID                0x18E1
-#define AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID         0x189E
-#define AURA_ROG_STRIX_IMPACT_II_PUNK_PID           0x1956
-#define AURA_ROG_STRIX_IMPACT_II_WHITE_PID          0x19D2
-#define AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID   0x1947
-#define AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID   0x1949
-#define AURA_ROG_KERIS                              0x195C
-#define AURA_ROG_KERIS_WIRELESS_USB_PID             0x195E
-#define AURA_ROG_KERIS_WIRELESS_2_4_PID             0x1960
-#define AURA_ROG_KERIS_WIRELESS_BT_PID              0x1962
-#define AURA_TUF_M3_PID                             0x1910
-#define AURA_TUF_M5_PID                             0x1898
+#define AURA_ROG_GLADIUS_II_CORE_PID                    0x18DD
+#define AURA_ROG_GLADIUS_II_PID                         0x1845
+#define AURA_ROG_GLADIUS_II_ORIGIN_PID                  0x1877
+#define AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID          0x18CD
+#define AURA_ROG_GLADIUS_II_ORIGIN_COD_PID              0x18B1
+#define AURA_ROG_GLADIUS_II_WIRELESS_1_PID              0x189E
+#define AURA_ROG_GLADIUS_II_WIRELESS_2_PID              0x18A0
+#define AURA_ROG_GLADIUS_III_PID                        0x197B
+#define AURA_ROG_GLADIUS_III_WIRELESS_USB_PID           0x197D
+#define AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID           0x197F
+#define AURA_ROG_GLADIUS_III_WIRELESS_BT_PID            0x1981
+#define AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_USB_PID  0x1A70
+#define AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_2_4_PID  0x1A72
+#define AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_BT_PID   0x1A74
+#define AURA_ROG_CHAKRAM_WIRELESS_PID                   0x18E5
+#define AURA_ROG_CHAKRAM_WIRED_1_PID                    0x18E3
+#define AURA_ROG_CHAKRAM_CORE_PID                       0x1958
+#define AURA_ROG_CHAKRAM_X_USB_PID                      0x1A18
+#define AURA_ROG_CHAKRAM_X_2_4_PID                      0x1A1A
+#define AURA_ROG_SPATHA_X_USB_PID                       0x1977
+#define AURA_ROG_SPATHA_X_2_4_PID                       0x1979
+#define AURA_ROG_SPATHA_X_DOCK_PID                      0x1979
+#define AURA_ROG_PUGIO_PID                              0x1846
+#define AURA_ROG_PUGIO_II_WIRED_PID                     0x1906
+#define AURA_ROG_PUGIO_II_WIRELESS_PID                  0x1908
+#define AURA_ROG_STRIX_IMPACT_PID                       0x1847
+#define AURA_ROG_STRIX_IMPACT_II_PID                    0x18E1
+#define AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID             0x189E
+#define AURA_ROG_STRIX_IMPACT_II_PUNK_PID               0x1956
+#define AURA_ROG_STRIX_IMPACT_II_WHITE_PID              0x19D2
+#define AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID       0x1947
+#define AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID       0x1949
+#define AURA_ROG_STRIX_IMPACT_III_PID                   0x1A88
+#define AURA_ROG_KERIS                                  0x195C
+#define AURA_ROG_KERIS_WIRELESS_USB_PID                 0x195E
+#define AURA_ROG_KERIS_WIRELESS_2_4_PID                 0x1960
+#define AURA_ROG_KERIS_WIRELESS_BT_PID                  0x1962
+#define AURA_ROG_KERIS_WIRELESS_AIMPOINT_USB_PID        0x1A66
+#define AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID        0x1A68
+#define AURA_ROG_KERIS_WIRELESS_AIMPOINT_BT_PID         0x1A6A
+#define AURA_TUF_M3_PID                                 0x1910
+#define AURA_TUF_M5_PID                                 0x1898
 
-#define AURA_ROG_SPATHA_X_DOCK_FAKE_PID             0xFFFF
+#define AURA_ROG_SPATHA_X_DOCK_FAKE_PID                 0xFFFF
 
 enum
 {
@@ -67,6 +74,7 @@ enum
     AURA_MOUSE_MODE_REACTIVE    = 4,
     AURA_MOUSE_MODE_COMET       = 5,
     AURA_MOUSE_MODE_BATTERY     = 6,
+    AURA_MOUSE_MODE_DIRECT      = 254,
     AURA_MOUSE_MODE_NONE        = 255,
 };
 
@@ -78,6 +86,7 @@ typedef struct
     uint8_t                 brightness_max;
     bool                    wireless;
     int                     version_protocol;
+    bool                    direct;
     std::vector<uint8_t>    mouse_zones;
     std::vector<uint8_t>    mouse_modes;
 } mouse_type;
@@ -101,6 +110,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,      // Brightness Max
             false,  // is wireless? (important for fetching the version)
             1,      // version protocol
+            false,  // direct - defines whether the mouse has a native direct mode or just uses static as direct (only present on newer devices)
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
@@ -114,6 +124,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             0,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
         }
@@ -127,6 +138,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             0,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
         }
@@ -140,6 +152,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             0,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
         }
@@ -153,6 +166,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             0,
+            false,
             { AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
         }
@@ -166,6 +180,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             true,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
@@ -179,6 +194,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             true,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
@@ -192,6 +208,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             100,
             false,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
         }
@@ -205,6 +222,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             100,
             false,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
         }
@@ -218,6 +236,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             100,
             true,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
         }
@@ -231,10 +250,39 @@ static std::map<int,mouse_type> aura_mouse_devices =
             100,
             true,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
         }
     },
+    {
+        AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_USB_PID, // ROG Gladius III Wireless AimPoint USB
+        {
+            255,
+            1,
+            0,
+            100,
+            false,
+            2,
+            true,
+            { AURA_MOUSE_ZONE_LOGO },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
+    {
+        AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_2_4_PID, // ROG Gladius III Wireless AimPoint 2.4 GHz Dongle
+        {
+            255,
+            1,
+            0,
+            100,
+            true,
+            2,
+            true,
+            { AURA_MOUSE_ZONE_LOGO },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
     {
         AURA_ROG_CHAKRAM_WIRELESS_PID, // ROG Chakram Wireless
         {
@@ -244,6 +292,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             true,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
         }
@@ -257,6 +306,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
         }
@@ -270,6 +320,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
@@ -283,6 +334,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             100,
             false,
             2,
+            true,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
         }
@@ -296,6 +348,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             100,
             true,
             2,
+            true,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
         }
@@ -309,6 +362,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             100,
             false,
             1,
+            true,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
         }
@@ -322,6 +376,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             100,
             true,
             1,
+            true,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
         }
@@ -335,6 +390,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             0,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
         }
@@ -348,6 +404,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
         }
@@ -361,6 +418,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             true,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
         }
@@ -374,6 +432,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             4,
+            false,
             { AURA_MOUSE_ZONE_LOGO },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE }
         }
@@ -387,6 +446,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
@@ -400,6 +460,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
@@ -413,6 +474,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
@@ -426,6 +488,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
@@ -439,6 +502,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1, // not tested, but likely same as ROG Strix Impact II non wireless
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
@@ -452,10 +516,25 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             true,
             1, // not tested, but likely same as ROG Strix Impact II non wireless
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
     },
+    {
+        AURA_ROG_STRIX_IMPACT_III_PID, // ROG Strix Impact III
+        {
+            0,
+            0,
+            0,
+            100,
+            false,
+            1,
+            true,
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE }
+        }
+    },
     {
         AURA_ROG_KERIS, // ROG Keris
         {
@@ -464,7 +543,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
             0,
             4,
             false,
-            1, // might be the wrong protocol for version
+            1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
@@ -476,8 +556,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
             0,
             0,
             4,
-            true,
-            1, // might be the wrong protocol for version
+            false,
+            1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
@@ -490,7 +571,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
             0,
             4,
             true,
-            1, // might be the wrong protocol for version
+            1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
@@ -503,11 +585,40 @@ static std::map<int,mouse_type> aura_mouse_devices =
             0,
             4,
             true,
-            1, // might be the wrong protocol for version
+            1,
+            false,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
     },
+    {
+        AURA_ROG_KERIS_WIRELESS_AIMPOINT_USB_PID, // ROG Keris Wireless AimPoint
+        {
+            0,
+            0,
+            0,
+            100,
+            false,
+            1,
+            true,
+            { AURA_MOUSE_ZONE_LOGO },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
+    {
+        AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID, // ROG Keris Wireless AimPoint
+        {
+            0,
+            0,
+            0,
+            100,
+            true,
+            2,
+            true,
+            { AURA_MOUSE_ZONE_LOGO },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
     {
         AURA_TUF_M3_PID, // TUF M3
         {
@@ -517,6 +628,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             1,
+            false,
             { AURA_MOUSE_ZONE_LOGO },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
@@ -530,6 +642,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             4,
             false,
             3,
+            false,
             { AURA_MOUSE_ZONE_LOGO },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
@@ -543,8 +656,118 @@ static std::map<int,mouse_type> aura_mouse_devices =
             100,
             false,
             1,
+            false,
             { AURA_MOUSE_ZONE_DOCK },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
     },
 };
+
+typedef struct
+{
+    unsigned char                                           led_amount;
+    std::map< unsigned char, std::vector<unsigned char>>    map;
+} led_map;
+
+/*-----------------------------------------------------------------*\
+|  LED MAP                                                          |
+|                                                                   |
+|    This maps the LEDs to the correct zone.                        |
+|    This is necessary, because openrgb doesn't support per-zone    |
+|    lighting. To allow for per-zone color of modes like breathing, |
+|    the leds defined need to be the zones, which means the actual  |
+|    LEDs can't be implemented.                                     |
+\*-----------------------------------------------------------------*/
+static std::map<unsigned short, led_map > aura_mouse_led_maps =
+{
+    {
+        AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_USB_PID,
+        {
+            1,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 0 } },
+            }
+        }
+    },
+    {
+        AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_2_4_PID,
+        {
+            1,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 0 } },
+            }
+        }
+    },
+    {
+        AURA_ROG_KERIS_WIRELESS_AIMPOINT_USB_PID,
+        {
+            1,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 0 } },
+            }
+        }
+    },
+    {
+        AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID,
+        {
+            1,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 0 } },
+            }
+        }
+    },
+    {
+        AURA_ROG_SPATHA_X_2_4_PID,
+        {
+            5,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 0 } },
+                { AURA_MOUSE_ZONE_SCROLL, { 1 } },
+                { AURA_MOUSE_ZONE_UNDERGLOW, { 2, 3, 4 } },
+            }
+        }
+    },
+    {
+        AURA_ROG_SPATHA_X_USB_PID,
+        {
+            5,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 0 } },
+                { AURA_MOUSE_ZONE_SCROLL, { 1 } },
+                { AURA_MOUSE_ZONE_UNDERGLOW, { 2, 3, 4 } },
+            }
+        }
+    },
+    {
+        AURA_ROG_CHAKRAM_X_USB_PID,
+        {
+            9,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 7 } },
+                { AURA_MOUSE_ZONE_SCROLL, { 8 } },
+                { AURA_MOUSE_ZONE_UNDERGLOW, { 0, 1, 2, 3, 4, 5, 6 } },
+            }
+        }
+    },
+    {
+        AURA_ROG_CHAKRAM_X_2_4_PID,
+        {
+            9,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 7 } },
+                { AURA_MOUSE_ZONE_SCROLL, { 8 } },
+                { AURA_MOUSE_ZONE_UNDERGLOW, { 0, 1, 2, 3, 4, 5, 6 } },
+            }
+        }
+    },
+    {
+        AURA_ROG_STRIX_IMPACT_III_PID,
+        {
+            2,
+            {
+                { AURA_MOUSE_ZONE_LOGO, { 0 } },
+                { AURA_MOUSE_ZONE_SCROLL, { 1 } },
+            }
+        }
+    }
+};

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller.cpp

@@ -0,0 +1,176 @@
+/*-----------------------------------------*\
+|  AsusAuraMouseGen1Controller.cpp          |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Mola19 11/30/2021                        |
+\*-----------------------------------------*/
+
+#include "AsusAuraMouseGen1Controller.h"
+
+#include <cstring>
+#include <chrono>
+#include <thread>
+
+AsusAuraMouseGen1Controller::AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid)
+{
+    dev         = dev_handle;
+    location    = path;
+    device_pid  = pid;
+}
+
+AsusAuraMouseGen1Controller::~AsusAuraMouseGen1Controller()
+{
+    hid_close(dev);
+}
+
+std::string AsusAuraMouseGen1Controller::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AsusAuraMouseGen1Controller::GetSerialString()
+{
+    wchar_t serial_string[HID_MAX_STR];
+    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
+
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+std::string AsusAuraMouseGen1Controller::GetVersion()
+{
+    unsigned char usb_buf[9] = { 0x0C, 0xC4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+    usb_buf[3] = (device_pid == 0x1824) ? 0x02 : 0x00;
+    hid_send_feature_report(dev, usb_buf, 9);
+
+    unsigned char usb_buf_out[9] = { 0x0C };
+    hid_get_feature_report(dev, usb_buf_out, 9);
+
+    return std::string("1." +  std::to_string(usb_buf_out[3]));
+}
+
+int AsusAuraMouseGen1Controller::GetActiveProfile()
+{
+    unsigned char profile;
+
+    unsigned char profile_amount = 0;
+    unsigned char profile_key    = 0;
+
+    switch(device_pid)
+    {
+        case 0x185B:
+            profile_amount = 3;
+            profile_key    = 0xF0;
+            break;
+        case 0x181C:
+        case 0x1824:
+        default:
+            profile_amount = 6;
+            profile_key    = 0x60;
+            break;
+    }
+
+    do
+    {
+        unsigned char usb_buf[9] = { 0x0C, 0xDF, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+        hid_send_feature_report(dev, usb_buf, 9);
+
+        unsigned char usb_buf_out[9] = { 0x0C };
+        hid_get_feature_report(dev, usb_buf_out, 9);
+
+        profile = usb_buf_out[4];
+    } while(profile < profile_key || profile > profile_key + profile_amount - 1);
+
+    return (profile % 16) + 1;
+}
+
+void AsusAuraMouseGen1Controller::SendUpdate
+    (
+    unsigned char   key,
+    unsigned char   value
+    )
+{
+    unsigned char usb_buf[9];
+
+    memset(usb_buf, 0x00, 9);
+
+    usb_buf[0x00]   = 0x0C;
+    usb_buf[0x01]   = 0xC4;
+    usb_buf[0x02]   = 0x0F;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = key;
+    usb_buf[0x05]   = value;
+    hid_send_feature_report(dev, usb_buf, 9);
+
+    unsigned char buf_in[9];
+    buf_in[0] = 0x0C;
+    hid_get_feature_report(dev, buf_in, 9);
+    
+    std::this_thread::sleep_for(std::chrono::milliseconds(15));
+}
+
+
+void AsusAuraMouseGen1Controller::UpdateProfile
+    (
+    unsigned char   key,
+    unsigned char   profile,
+    unsigned char   value
+    )
+{
+    unsigned char usb_buf[9];
+
+    memset(usb_buf, 0x00, 9);
+
+    usb_buf[0x00]   = 0x0C;
+    usb_buf[0x01]   = 0xDE;
+    usb_buf[0x02]   = key;
+    usb_buf[0x03]   = profile;
+    usb_buf[0x04]   = value;
+    hid_send_feature_report(dev, usb_buf, 9);
+
+    unsigned char buf_in[9];
+    buf_in[0] = 0x0C;
+    hid_get_feature_report(dev, buf_in, 9);
+}
+
+void AsusAuraMouseGen1Controller::SendDirectSpatha(std::vector<RGBColor> colors)
+{
+    unsigned char usb_buf[33];
+
+    memset(usb_buf, 0x00, 33);
+
+    usb_buf[0x00]   = 0x10;
+    usb_buf[0x01]   = 0x00;
+    usb_buf[0x02]   = 0xF0;
+    usb_buf[0x03]   = 0x00;
+    
+    for(unsigned char i = 0; i < 3; i++)
+    {
+        usb_buf[4 + i * 3] = RGBGetRValue(colors[i]);
+        usb_buf[5 + i * 3] = RGBGetGValue(colors[i]);
+        usb_buf[6 + i * 3] = RGBGetBValue(colors[i]);
+    }
+
+    hid_send_feature_report(dev, usb_buf, 33);
+}
+
+void AsusAuraMouseGen1Controller::ResetToSavedLighting()
+{
+    unsigned char usb_buf[9];
+
+    memset(usb_buf, 0x00, 9);
+
+    usb_buf[0x00]   = 0x0C;
+    usb_buf[0x01]   = 0xC4;
+
+    hid_send_feature_report(dev, usb_buf, 9);
+}

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraStrixEvolveController.h          |
+|  AsusAuraMouseGen1Controller.h            |
 |                                           |
 |  Definitions and types for ASUS Aura      |
 |  USB RGB lighting controller              |
@@ -10,17 +10,18 @@
 #include "RGBController.h"
 
 #include <string>
+#include <vector>
 #include <hidapi/hidapi.h>
 
 #pragma once
 
 #define HID_MAX_STR 255
 
-class AuraStrixEvolveController
+class AsusAuraMouseGen1Controller
 {
 public:
-    AuraStrixEvolveController(hid_device* dev_handle, const char* path, uint16_t pid);
-    virtual ~AuraStrixEvolveController();
+    AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid);
+    virtual ~AsusAuraMouseGen1Controller();
 
     std::string GetDeviceLocation();
     std::string GetSerialString();
@@ -39,8 +40,9 @@ public:
         unsigned char   profile,
         unsigned char   value
         );
+    void SendDirectSpatha(std::vector<RGBColor> colors);
 
-    void SendSavePacket();
+    void ResetToSavedLighting();
 
     uint16_t                    device_pid;
 

Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.cpp

@@ -1,146 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraStrixEvolveController.cpp        |
-|                                           |
-|  Driver for ASUS Aura RGB USB             |
-|  lighting controller                      |
-|                                           |
-|  Mola19 11/30/2021                        |
-\*-----------------------------------------*/
-
-#include "AsusAuraStrixEvolveController.h"
-
-#include <cstring>
-#include <chrono>
-#include <thread>
-
-AuraStrixEvolveController::AuraStrixEvolveController(hid_device* dev_handle, const char* path, uint16_t pid)
-{
-    dev         = dev_handle;
-    location    = path;
-    device_pid  = pid;
-}
-
-AuraStrixEvolveController::~AuraStrixEvolveController()
-{
-    hid_close(dev);
-}
-
-std::string AuraStrixEvolveController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AuraStrixEvolveController::GetSerialString()
-{
-    wchar_t serial_string[HID_MAX_STR];
-    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-std::string AuraStrixEvolveController::GetVersion()
-{
-    unsigned char usb_buf[9] = { 0x0c, 0xc4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-    hid_send_feature_report(dev, usb_buf, 9);
-
-    unsigned char usb_buf_out[9] = { 0x0c };
-    hid_get_feature_report(dev, usb_buf_out, 9);
-
-    return std::string("1." +  std::to_string(usb_buf_out[3]));
-}
-
-int AuraStrixEvolveController::GetActiveProfile()
-{
-    int profile;
-
-    do
-    {
-        unsigned char usb_buf[9] = { 0x0c, 0xdf, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-        hid_send_feature_report(dev, usb_buf, 9);
-
-        unsigned char usb_buf_out[9] = { 0x0c };
-        hid_get_feature_report(dev, usb_buf_out, 9);
-
-        profile = usb_buf_out[4] % 16;
-    } while (profile > 2);
-
-    return profile + 1;
-}
-
-void AuraStrixEvolveController::SendUpdate
-    (
-    unsigned char   key,
-    unsigned char   value
-    )
-{
-    unsigned char usb_buf[9];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, 9);
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x0c;
-    usb_buf[0x01]   = 0xc4;
-    usb_buf[0x02]   = 0x0f;
-    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = key;
-    usb_buf[0x05]   = value;
-    hid_send_feature_report(dev, usb_buf, 9);
-}
-
-
-void AuraStrixEvolveController::UpdateProfile
-    (
-    unsigned char   key,
-    unsigned char   profile,
-    unsigned char   value
-    )
-{
-    unsigned char usb_buf[9];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, 9);
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x0c;
-    usb_buf[0x01]   = 0xde;
-    usb_buf[0x02]   = key;
-    usb_buf[0x03]   = profile;
-    usb_buf[0x04]   = value;
-    hid_send_feature_report(dev, usb_buf, 9);
-    std::this_thread::sleep_for(std::chrono::milliseconds(5));
-}
-
-void AuraStrixEvolveController::SendSavePacket()
-{
-    unsigned char usb_buf[9];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, 9);
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x0c;
-    usb_buf[0x01]   = 0xc4;
-
-    hid_send_feature_report(dev, usb_buf, 9);
-}

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp

@@ -95,11 +95,19 @@ std::string AuraTUFKeyboardController::GetVersion()
         
         switch(device_pid)
         {
+            case AURA_ROG_AZOTH_USB_PID:
+            case AURA_ROG_AZOTH_2_4_PID:
             case AURA_TUF_K3_GAMING_PID:
             case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
+            case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID:
+            case AURA_ROG_STRIX_SCOPE_II_PID:
+            case AURA_ROG_STRIX_SCOPE_II_RX_PID:
             case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
                 snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
                 break;
+            case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID:
+                snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[13], usb_buf_out[12], usb_buf_out[11]);
+                break;
             default:
                 snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
         }
@@ -343,6 +351,131 @@ void AuraTUFKeyboardController::UpdateK1Wave
     AwaitResponse(20);
 }
 
+void AuraTUFKeyboardController::UpdateScopeIIRainbowRipple
+    (
+    unsigned char           mode,
+    std::vector<RGBColor>   colors,
+    unsigned char           direction,
+    unsigned char           color_mode,
+    unsigned char           speed,
+    unsigned char           brightness
+    )
+{
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x51;
+    usb_buf[0x02]   = 0x2C;
+    usb_buf[0x03]   = mode;
+    usb_buf[0x04]   = 0x02;
+    usb_buf[0x05]   = speed;
+    usb_buf[0x06]   = brightness;
+    usb_buf[0x07]   = color_mode;
+    usb_buf[0x08]   = direction;
+    usb_buf[0x09]   = 0x02;
+    usb_buf[0x0A]   = colors.size();
+
+    for(unsigned int i = 0; i < 2; i ++)
+    {
+        if (i >= colors.size()) continue;
+        usb_buf[11 + i * 4] = 100/(double)colors.size()*(i+1);
+        usb_buf[12 + i * 4] = RGBGetRValue(colors[i]);
+        usb_buf[13 + i * 4] = RGBGetGValue(colors[i]);
+        usb_buf[14 + i * 4] = RGBGetBValue(colors[i]);
+    }
+
+    ClearResponses();
+    hid_write(dev, usb_buf, 65);
+    AwaitResponse(20);
+
+    memset(usb_buf + 4, 0x00, sizeof(usb_buf) - 4);
+
+    usb_buf[0x04] = 0x01;
+
+    for(unsigned int i = 0; i < 4; i ++)
+    {
+        if (i + 2 >= colors.size()) continue;
+        usb_buf[5 + i * 4] = 100/(double)colors.size()*(i+1+2);
+        usb_buf[6 + i * 4] = RGBGetRValue(colors[i+2]);
+        usb_buf[7 + i * 4] = RGBGetGValue(colors[i+2]);
+        usb_buf[8 + i * 4] = RGBGetBValue(colors[i+2]);
+    }
+
+    ClearResponses();
+    hid_write(dev, usb_buf, 65);
+    AwaitResponse(20);
+
+    memset(usb_buf + 4, 0x00, sizeof(usb_buf) - 4);
+
+    usb_buf[0x04] = 0x00;
+
+    for(unsigned int i = 0; i < 1; i ++)
+    {
+        if (i + 6 >= colors.size()) continue;
+        usb_buf[5 + i * 4] = 100/(double)colors.size()*(i+1+6);
+        usb_buf[6 + i * 4] = RGBGetRValue(colors[i+6]);
+        usb_buf[7 + i * 4] = RGBGetGValue(colors[i+6]);
+        usb_buf[8 + i * 4] = RGBGetBValue(colors[i+6]);
+    }
+
+    ClearResponses();
+    hid_write(dev, usb_buf, 65);
+    AwaitResponse(20);
+}
+
+void AuraTUFKeyboardController::UpdateScopeIIQuicksand
+    (
+    std::vector<RGBColor>   colors,
+    unsigned char           direction,
+    unsigned char           color_mode,
+    unsigned char           speed,
+    unsigned char           brightness
+    )
+{
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x51;
+    usb_buf[0x02]   = 0x2C;
+    usb_buf[0x03]   = 0x07;
+    usb_buf[0x04]   = 0x01;
+    usb_buf[0x05]   = speed;
+    usb_buf[0x06]   = brightness;
+    usb_buf[0x07]   = color_mode;
+    usb_buf[0x08]   = direction;
+    usb_buf[0x09]   = 0x02;
+
+    for(unsigned int i = 0; i < 3; i ++)
+    {
+        usb_buf[10 + i * 3] = RGBGetRValue(colors[i]);
+        usb_buf[11 + i * 3] = RGBGetGValue(colors[i]);
+        usb_buf[12 + i * 3] = RGBGetBValue(colors[i]);
+    }
+
+    ClearResponses();
+    hid_write(dev, usb_buf, 65);
+    AwaitResponse(20);
+
+    memset(usb_buf + 4, 0x00, sizeof(usb_buf) - 4);
+
+    usb_buf[0x04] = 0x00;
+
+    for(unsigned int i = 0; i < 3; i ++)
+    {
+        usb_buf[5 + i * 3] = RGBGetRValue(colors[i+3]);
+        usb_buf[6 + i * 3] = RGBGetGValue(colors[i+3]);
+        usb_buf[7 + i * 3] = RGBGetBValue(colors[i+3]);
+    }
+
+    ClearResponses();
+    hid_write(dev, usb_buf, 65);
+    AwaitResponse(20);
+}
+
 void AuraTUFKeyboardController::UpdateDevice
     (
     unsigned char           mode,
@@ -358,6 +491,24 @@ void AuraTUFKeyboardController::UpdateDevice
         return UpdateK1Wave(colors, direction, speed, brightness);
     }
 
+    if(device_pid == AURA_ROG_AZOTH_USB_PID
+    || device_pid == AURA_ROG_AZOTH_2_4_PID
+    || device_pid == AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID
+    || device_pid == AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID
+    || device_pid == AURA_ROG_STRIX_SCOPE_II_PID
+    || device_pid == AURA_ROG_STRIX_SCOPE_II_RX_PID
+    || device_pid == AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID)
+    {
+        if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
+        {
+            return UpdateScopeIIRainbowRipple(mode, colors, direction, color_mode, speed, brightness);
+        }
+        else if (mode == AURA_KEYBOARD_MODE_QUICKSAND)
+        {
+            return UpdateScopeIIQuicksand(colors, direction, color_mode, speed, brightness);
+        }
+    }
+
     unsigned char usb_buf[65];
     memset(usb_buf, 0x00, sizeof(usb_buf));
 

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h

@@ -33,20 +33,27 @@ enum
 
 enum
 {
-    AURA_ROG_STRIX_FLARE_PID                     = 0x1875,
-    AURA_ROG_STRIX_FLARE_PNK_LTD_PID             = 0x18CF,
-    AURA_ROG_STRIX_FLARE_COD_BO4_PID             = 0x18AF,
-    AURA_ROG_FALCHION_WIRED_PID                  = 0x193C,
-    AURA_ROG_FALCHION_WIRELESS_PID               = 0x193E,
-    AURA_ROG_STRIX_SCOPE_PID                     = 0x18F8,
-    AURA_ROG_STRIX_SCOPE_RX_PID                  = 0x1951,
-    AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID  = 0x1AAE,
-    AURA_ROG_STRIX_FLARE_II_ANIMATE_PID          = 0x19FC,
-    AURA_TUF_K1_GAMING_PID                       = 0x1945,
-    AURA_TUF_K3_GAMING_PID                       = 0x194B,
-    AURA_TUF_K5_GAMING_PID                       = 0x1899,
-    AURA_TUF_K7_GAMING_PID                       = 0x18AA,
-    AURA_ROG_CLAYMORE_PID                        = 0x184D,
+    AURA_ROG_AZOTH_USB_PID                              = 0x1A83,
+    AURA_ROG_AZOTH_2_4_PID                              = 0x1A85,
+    AURA_ROG_CLAYMORE_PID                               = 0x184D,
+    AURA_ROG_FALCHION_WIRED_PID                         = 0x193C,
+    AURA_ROG_FALCHION_WIRELESS_PID                      = 0x193E,
+    AURA_ROG_STRIX_FLARE_PID                            = 0x1875,
+    AURA_ROG_STRIX_FLARE_PNK_LTD_PID                    = 0x18CF,
+    AURA_ROG_STRIX_FLARE_COD_BO4_PID                    = 0x18AF,
+    AURA_ROG_STRIX_FLARE_II_PID                         = 0x19FE,
+    AURA_ROG_STRIX_FLARE_II_ANIMATE_PID                 = 0x19FC,
+    AURA_ROG_STRIX_SCOPE_PID                            = 0x18F8,
+    AURA_ROG_STRIX_SCOPE_RX_PID                         = 0x1951,
+    AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID     = 0x19F6,
+    AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID     = 0x19F8,
+    AURA_ROG_STRIX_SCOPE_II_PID                         = 0x1AB3,
+    AURA_ROG_STRIX_SCOPE_II_RX_PID                      = 0x1AB5,
+    AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID         = 0x1AAE,
+    AURA_TUF_K1_GAMING_PID                              = 0x1945,
+    AURA_TUF_K3_GAMING_PID                              = 0x194B,
+    AURA_TUF_K5_GAMING_PID                              = 0x1899,
+    AURA_TUF_K7_GAMING_PID                              = 0x18AA,
 };
 
 struct led_color
@@ -90,6 +97,25 @@ public:
         unsigned char           brightness
         );
 
+    void UpdateScopeIIRainbowRipple
+        (
+        unsigned char           mode,
+        std::vector<RGBColor>   colors,
+        unsigned char           direction,
+        unsigned char           color_mode,
+        unsigned char           speed,
+        unsigned char           brightness
+        );
+
+    void UpdateScopeIIQuicksand
+        (
+        std::vector<RGBColor>   colors,
+        unsigned char           direction,
+        unsigned char           color_mode,
+        unsigned char           speed,
+        unsigned char           brightness
+        );
+
     void UpdateDevice
         (
         unsigned char           mode,

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardLayouts.h

@@ -80,6 +80,24 @@ static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_ISO[6][24] =
     {   5,   8,  14,  NA,  NA,  NA,  34,  NA,  NA,  NA,  55,  61,  66,  NA,  74,  NA,  78,  83,  87,  NA,  92,  NA, 101,  NA }
 };
 
+static unsigned int ASUS_ROG_AZOTH_LAYOUT_KEYS_US[6][16] = {
+    {   0,   6,   9,  15,  20,  25,  30,  36,  41,  46,  51,  57,  63,  NA,  NA,  NA },
+    {   1,   7,  10,  16,  21,  26,  31,  37,  42,  47,  52,  58,  64,  69,  NA,  76 },
+    {   2,  NA,  11,  17,  22,  27,  32,  38,  43,  48,  53,  59,  65,  70,  72,  77 },
+    {   3,  NA,  12,  18,  23,  28,  33,  39,  44,  49,  54,  60,  66,  NA,  73,  78 },
+    {   4,  NA,  13,  19,  24,  29,  34,  40,  45,  50,  55,  61,  67,  NA,  74,  79 },
+    {   5,   8,  14,  NA,  NA,  NA,  35,  NA,  NA,  NA,  56,  62,  68,  71,  75,  80 }
+};
+
+static unsigned int ASUS_ROG_AZOTH_LAYOUT_KEYS_UK[6][16] = {
+    {   0,   6,  10,  16,  21,  26,  31,  37,  42,  47,  52,  58,  64,  NA,  NA,  NA },
+    {   1,   7,  11,  17,  22,  27,  32,  38,  43,  48,  53,  59,  65,  70,  NA,  77 },
+    {   2,  NA,  12,  18,  23,  28,  33,  39,  44,  49,  54,  60,  66,  71,  NA,  78 },
+    {   3,  NA,  13,  19,  24,  29,  34,  40,  45,  50,  55,  61,  67,  72,  74,  79 },
+    {   4,   8,  14,  20,  25,  30,  35,  41,  46,  51,  56,  62,  68,  NA,  75,  80 },
+    {   5,   9,  15,  NA,  NA,  NA,  36,  NA,  NA,  NA,  57,  63,  69,  73,  76,  81 }
+};
+
 static unsigned int ASUS_ROG_STRIX_SCOPE_LAYOUT_KEYS_ANSI[6][24] =
 {
     {   0,  NA,   8,  14,  19,  24,  NA,  34,  39,  44,  49,  55,  61,  66,  70,  NA,  74,  78,  83,  NA,  NA,  NA, 104, 105 },
@@ -101,6 +119,27 @@ static unsigned int ASUS_ROG_STRIX_SCOPE_LAYOUT_KEYS_ISO[6][24] =
     {   5,   8,  14,  NA,  NA,  NA,  34,  NA,  NA,  NA,  55,  61,  66,  NA,  74,  NA,  78,  83,  87,  NA,  92,  NA, 101,  NA }
 };
 
+static unsigned int ASUS_ROG_STRIX_SCOPE_II_LAYOUT_KEYS_ANSI[6][24] =
+{
+    {   0,  NA,   8,  14,  19,  24,  NA,  35,  41,  46,  51,  57,  63,  68,  72,  NA,  76,  80,  85,  NA,  NA,  94,  NA,  NA },
+    {   1,   6,   9,  15,  20,  25,  30,  36,  42,  47,  52,  58,  64,  69,  NA,  NA,  77,  81,  86,  NA,  89,  95,  99, 104 },
+    {   2,  NA,  10,  16,  21,  26,  31,  37,  43,  48,  53,  59,  65,  70,  73,  NA,  78,  82,  87,  NA,  90,  96, 100, 105 },
+    {   3,  NA,  11,  17,  22,  27,  32,  38,  44,  49,  54,  60,  66,  NA,  74,  NA,  NA,  NA,  NA,  NA,  91,  97, 101,  NA },
+    {   4,  NA,  12,  18,  23,  28,  33,  39,  45,  50,  55,  61,  NA,  71,  NA,  NA,  NA,  83,  NA,  NA,  92,  98, 102, 106 },
+    {   5,   7,  13,  NA,  NA,  29,  34,  40,  NA,  NA,  56,  62,  67,  NA,  75,  NA,  79,  84,  88,  NA,  93,  NA, 103,  NA }
+};
+
+
+static unsigned int ASUS_ROG_STRIX_SCOPE_II_LAYOUT_KEYS_ISO[6][24] =
+{
+    {   0,  NA,   9,  15,  20,  25,  NA,  36,  42,  47,  52,  58,  64,  69,  74,  NA,  77,  81,  86,  NA,  NA,  95,  NA,  NA },
+    {   1,   6,  10,  16,  21,  26,  31,  37,  43,  48,  53,  59,  65,  70,  NA,  NA,  78,  82,  87,  NA,  90,  96, 100, 105 },
+    {   2,  NA,  11,  17,  22,  27,  32,  38,  44,  49,  54,  60,  66,  71,  NA,  NA,  79,  83,  88,  NA,  91,  97, 101, 106 },
+    {   3,  NA,  12,  18,  23,  28,  33,  39,  45,  50,  55,  61,  67,  72,  75,  NA,  NA,  NA,  NA,  NA,  92,  98, 102,  NA },
+    {   4,   7,  13,  19,  24,  29,  34,  40,  46,  51,  56,  62,  NA,  73,  NA,  NA,  NA,  84,  NA,  NA,  93,  99, 103, 107 },
+    {   5,   8,  14,  NA,  NA,  30,  35,  41,  NA,  NA,  57,  63,  68,  NA,  76,  NA,  80,  85,  89,  NA,  94,  NA, 104,  NA }
+};
+
 static unsigned int ASUS_ROG_STRIX_SCOPE_II_96_WIRELESS_LAYOUT_KEYS_ANSI[6][19] =
 {
     {   0,   6,  11,  17,  22,  27,  33,  39,  45,  50,  55,  61,  67,  72,  77,  80,  86,  NA,  97 },
@@ -142,6 +181,28 @@ static unsigned int ASUS_ROG_STRIX_FLARE_LAYOUT_KEYS_ISO[6][26] =
 };
 
 static unsigned int ASUS_ROG_STRIX_FLARE_II_LAYOUT_KEYS_ANSI[7][30] =
+{
+    {  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 104, 105,  NA,  NA },
+    {   0,  NA,   8,  14,  19,  24,  NA,  34,  39,  44,  49,  55,  61,  66,  70,  NA,  NA,  NA,  NA,  74,  78,  83,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
+    {   1,   6,   9,  15,  20,  25,  29,  35,  40,  45,  50,  56,  62,  67,  NA,  NA,  NA,  NA,  NA,  75,  79,  84,  NA,  NA,  NA,  NA,  87,  92,  96, 101 },
+    {   2,  NA,  10,  16,  21,  26,  30,  36,  41,  46,  51,  57,  63,  68,  71,  NA,  NA,  NA,  NA,  76,  80,  85,  NA,  NA,  NA,  NA,  88,  93,  97, 102 },
+    {   3,  NA,  11,  17,  22,  27,  31,  37,  42,  47,  52,  58,  64,  NA,  72,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  89,  94,  98,  NA },
+    {   4,  NA,  12,  18,  23,  28,  32,  38,  43,  48,  53,  59,  NA,  69,  NA,  NA,  NA,  NA,  NA,  NA,  81,  NA,  NA,  NA,  NA,  NA,  90,  95,  99, 103 },
+    {   5,   7,  13,  NA,  NA,  NA,  33,  NA,  NA,  NA,  54,  60,  65,  NA,  73,  NA,  NA,  NA,  NA,  77,  82,  86,  NA,  NA,  NA,  NA,  91,  NA, 100,  NA },
+};
+
+static unsigned int ASUS_ROG_STRIX_FLARE_II_LAYOUT_KEYS_ISO[7][30] =
+{
+    {  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 105, 106,  NA,  NA },
+    {   0,  NA,   9,  15,  20,  25,  NA,  35,  40,  45,  50,  56,  62,  67,  72,  NA,  NA,  NA,  NA,  75,  79,  84,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
+    {   1,   6,  10,  16,  21,  26,  30,  36,  41,  46,  51,  57,  63,  68,  NA,  NA,  NA,  NA,  NA,  76,  80,  85,  NA,  NA,  NA,  NA,  88,  93,  97, 102 },
+    {   2,  NA,  11,  17,  22,  27,  31,  37,  42,  47,  52,  58,  64,  69,  NA,  NA,  NA,  NA,  NA,  77,  81,  86,  NA,  NA,  NA,  NA,  89,  94,  98, 103 },
+    {   3,  NA,  12,  18,  23,  28,  32,  38,  43,  48,  53,  59,  65,  70,  73,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  90,  95,  99,  NA },
+    {   4,   7,  13,  19,  24,  29,  33,  39,  44,  49,  54,  60,  NA,  71,  NA,  NA,  NA,  NA,  NA,  NA,  82,  NA,  NA,  NA,  NA,  NA,  91,  96, 100, 104 },
+    {   5,   8,  14,  NA,  NA,  NA,  34,  NA,  NA,  NA,  55,  61,  66,  NA,  74,  NA,  NA,  NA,  NA,  78,  83,  87,  NA,  NA,  NA,  NA,  92,  NA, 101,  NA },
+};
+
+static unsigned int ASUS_ROG_STRIX_FLARE_II_ANIMATE_LAYOUT_KEYS_ANSI[7][30] =
 {
     {   0,  NA,   8,  14,  19,  24,  NA,  34,  39,  44,  49,  55,  61,  66,  70,  NA,  NA,  NA,  NA,  74,  78,  83,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
     {   1,   6,   9,  15,  20,  25,  29,  35,  40,  45,  50,  56,  62,  67,  NA,  NA,  NA,  NA,  NA,  75,  79,  84,  NA,  NA,  NA,  NA,  87,  92,  96, 101 },
@@ -152,7 +213,7 @@ static unsigned int ASUS_ROG_STRIX_FLARE_II_LAYOUT_KEYS_ANSI[7][30] =
     { 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133 }
 };
 
-static unsigned int ASUS_ROG_STRIX_FLARE_II_LAYOUT_KEYS_ISO[7][30] =
+static unsigned int ASUS_ROG_STRIX_FLARE_II_ANIMATE_LAYOUT_KEYS_ISO[7][30] =
 {
     {   0,  NA,   9,  15,  20,  25,  NA,  35,  40,  45,  50,  56,  62,  67,  72,  NA,  NA,  NA,  NA,  75,  79,  84,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
     {   1,   6,  10,  16,  21,  26,  30,  36,  41,  46,  51,  57,  63,  68,  NA,  NA,  NA,  NA,  NA,  76,  80,  85,  NA,  NA,  NA,  NA,  88,  93,  97, 102 },
@@ -175,8 +236,8 @@ static unsigned int ASUS_FALCHION_LAYOUT_KEYS_ANSI[5][16] =
 static unsigned int ASUS_FALCHION_LAYOUT_KEYS_ISO[5][16] =
 {
     {   0,   5,   8,  13,  17,  21,  25,  30,  34,  38,  42,  47,  52,  57,  NA,  64 },
-    {   1,  NA,   9,  14,  18,  22,  26,  31,  35,  39,  43,  48,  53,  58,  61,  65 },
-    {   2,  NA,  10,  15,  19,  23,  27,  32,  36,  40,  44,  49,  54,  59,  NA,  66 },
+    {   1,  NA,   9,  14,  18,  22,  26,  31,  35,  39,  43,  48,  53,  58,  NA,  65 },
+    {   2,  NA,  10,  15,  19,  23,  27,  32,  36,  40,  44,  49,  54,  59,  61,  66 },
     {   3,   6,  11,  16,  20,  24,  28,  33,  37,  41,  45,  50,  55,  NA,  62,  67 },
     {   4,   7,  12,  NA,  NA,  NA,  29,  NA,  NA,  NA,  46,  51,  56,  60,  63,  68 }
 };
@@ -529,6 +590,225 @@ static std::map<int,layout_info> AsusTUFK7Layouts =
     },
 };
 
+static std::map<int,layout_info> AsusROGAzothLayouts =
+{
+    {
+        ASUS_TUF_K7_LAYOUT_UK,
+        {
+            *ASUS_ROG_AZOTH_LAYOUT_KEYS_UK,
+            82,
+            6,
+            16,
+            {
+                { KEY_EN_ESCAPE,              0x00 },
+                { KEY_EN_BACK_TICK,           0x01 },
+                { KEY_EN_TAB,                 0x02 },
+                { KEY_EN_CAPS_LOCK,           0x03 },
+                { KEY_EN_LEFT_SHIFT,          0x04 },
+                { KEY_EN_LEFT_CONTROL,        0x05 },
+
+                { KEY_EN_F1,                  0x08 },
+                { KEY_EN_1,                   0x09 },
+                { KEY_EN_ISO_BACK_SLASH,      0x0C },
+                { KEY_EN_LEFT_WINDOWS,        0x0D },
+
+                { KEY_EN_F2,                  0x10 },
+                { KEY_EN_2,                   0x11 },
+                { KEY_EN_Q,                   0x0A },
+                { KEY_EN_A,                   0x0B },
+                { KEY_EN_Z,                   0x14 },
+                { KEY_EN_LEFT_ALT,            0x15 },
+
+                { KEY_EN_F3,                  0x18 },
+                { KEY_EN_3,                   0x19 },
+                { KEY_EN_W,                   0x12 },
+                { KEY_EN_S,                   0x13 },
+                { KEY_EN_X,                   0x1C },
+
+                { KEY_EN_F4,                  0x20 },
+                { KEY_EN_4,                   0x21 },
+                { KEY_EN_E,                   0x1A },
+                { KEY_EN_D,                   0x1B },
+                { KEY_EN_C,                   0x24 },
+
+                { KEY_EN_F5,                  0x28 },
+                { KEY_EN_5,                   0x29 },
+                { KEY_EN_R,                   0x22 },
+                { KEY_EN_F,                   0x23 },
+                { KEY_EN_V,                   0x2C },
+
+                { KEY_EN_F6,                  0x30 },
+                { KEY_EN_6,                   0x31 },
+                { KEY_EN_T,                   0x2A },
+                { KEY_EN_G,                   0x2B },
+                { KEY_EN_B,                   0x34 },
+                { KEY_EN_SPACE,               0x35 },
+
+                { KEY_EN_F7,                  0x38 },
+                { KEY_EN_7,                   0x39 },
+                { KEY_EN_Y,                   0x32 },
+                { KEY_EN_H,                   0x33 },
+                { KEY_EN_N,                   0x3C },
+
+                { KEY_EN_F8,                  0x40 },
+                { KEY_EN_8,                   0x41 },
+                { KEY_EN_U,                   0x3A },
+                { KEY_EN_J,                   0x3B },
+                { KEY_EN_M,                   0x44 },
+
+                { KEY_EN_F9,                  0x48 },
+                { KEY_EN_9,                   0x49 },
+                { KEY_EN_I,                   0x42 },
+                { KEY_EN_K,                   0x43 },
+                { KEY_EN_COMMA,               0x4C },
+
+                { KEY_EN_F10,                 0x50 },
+                { KEY_EN_0,                   0x51 },
+                { KEY_EN_O,                   0x4A },
+                { KEY_EN_L,                   0x4B },
+                { KEY_EN_PERIOD,              0x54 },
+                { KEY_EN_RIGHT_ALT,           0x55 },
+
+                { KEY_EN_F11,                 0x58 },
+                { KEY_EN_MINUS,               0x59 },
+                { KEY_EN_P,                   0x52 },
+                { KEY_EN_SEMICOLON,           0x53 },
+                { KEY_EN_FORWARD_SLASH,       0x5C },
+                { KEY_EN_RIGHT_FUNCTION,      0x5D },
+
+                { KEY_EN_F12,                 0x60 },
+                { KEY_EN_EQUALS,              0x61 },
+                { KEY_EN_LEFT_BRACKET,        0x5A },
+                { KEY_EN_QUOTE,               0x5B },
+                { KEY_EN_RIGHT_SHIFT,         0x64 },
+                { KEY_EN_RIGHT_CONTROL,       0x65 },
+
+                { KEY_EN_BACKSPACE,           0x69 },
+                { KEY_EN_RIGHT_BRACKET,       0x62 },
+                { KEY_EN_POUND,               0x6B },
+                { KEY_EN_LEFT_ARROW,          0x6D },
+
+                { KEY_EN_ISO_ENTER,           0x6A },
+                { KEY_EN_UP_ARROW,            0x74 },
+                { KEY_EN_DOWN_ARROW,          0x75 },
+
+                { KEY_EN_INSERT,              0x79 },
+                { KEY_EN_DELETE,              0x7A },
+                { KEY_EN_PAGE_UP,             0x7B },
+                { KEY_EN_PAGE_DOWN,           0x7C },
+                { KEY_EN_RIGHT_ARROW,         0x7D },
+            }
+        }
+    },
+    {
+        ASUS_TUF_K7_LAYOUT_US,
+        {
+            *ASUS_ROG_AZOTH_LAYOUT_KEYS_US,
+            81,
+            6,
+            16,
+            {
+                { KEY_EN_ESCAPE,              0x00 },
+                { KEY_EN_BACK_TICK,           0x01 },
+                { KEY_EN_TAB,                 0x02 },
+                { KEY_EN_CAPS_LOCK,           0x03 },
+                { KEY_EN_LEFT_SHIFT,          0x04 },
+                { KEY_EN_LEFT_CONTROL,        0x05 },
+
+                { KEY_EN_F1,                  0x08 },
+                { KEY_EN_1,                   0x09 },
+                { KEY_EN_LEFT_WINDOWS,        0x0D },
+
+                { KEY_EN_F2,                  0x10 },
+                { KEY_EN_2,                   0x11 },
+                { KEY_EN_Q,                   0x0A },
+                { KEY_EN_A,                   0x0B },
+                { KEY_EN_Z,                   0x14 },
+                { KEY_EN_LEFT_ALT,            0x15 },
+
+                { KEY_EN_F3,                  0x18 },
+                { KEY_EN_3,                   0x19 },
+                { KEY_EN_W,                   0x12 },
+                { KEY_EN_S,                   0x13 },
+                { KEY_EN_X,                   0x1C },
+
+                { KEY_EN_F4,                  0x20 },
+                { KEY_EN_4,                   0x21 },
+                { KEY_EN_E,                   0x1A },
+                { KEY_EN_D,                   0x1B },
+                { KEY_EN_C,                   0x24 },
+
+                { KEY_EN_F5,                  0x28 },
+                { KEY_EN_5,                   0x29 },
+                { KEY_EN_R,                   0x22 },
+                { KEY_EN_F,                   0x23 },
+                { KEY_EN_V,                   0x2C },
+
+                { KEY_EN_F6,                  0x30 },
+                { KEY_EN_6,                   0x31 },
+                { KEY_EN_T,                   0x2A },
+                { KEY_EN_G,                   0x2B },
+                { KEY_EN_B,                   0x34 },
+                { KEY_EN_SPACE,               0x35 },
+
+                { KEY_EN_F7,                  0x38 },
+                { KEY_EN_7,                   0x39 },
+                { KEY_EN_Y,                   0x32 },
+                { KEY_EN_H,                   0x33 },
+                { KEY_EN_N,                   0x3C },
+
+                { KEY_EN_F8,                  0x40 },
+                { KEY_EN_8,                   0x41 },
+                { KEY_EN_U,                   0x3A },
+                { KEY_EN_J,                   0x3B },
+                { KEY_EN_M,                   0x44 },
+
+                { KEY_EN_F9,                  0x48 },
+                { KEY_EN_9,                   0x49 },
+                { KEY_EN_I,                   0x42 },
+                { KEY_EN_K,                   0x43 },
+                { KEY_EN_COMMA,               0x4C },
+
+                { KEY_EN_F10,                 0x50 },
+                { KEY_EN_0,                   0x51 },
+                { KEY_EN_O,                   0x4A },
+                { KEY_EN_L,                   0x4B },
+                { KEY_EN_PERIOD,              0x54 },
+                { KEY_EN_RIGHT_ALT,           0x55 },
+
+                { KEY_EN_F11,                 0x58 },
+                { KEY_EN_MINUS,               0x59 },
+                { KEY_EN_P,                   0x52 },
+                { KEY_EN_SEMICOLON,           0x53 },
+                { KEY_EN_FORWARD_SLASH,       0x5C },
+                { KEY_EN_RIGHT_FUNCTION,      0x5D },
+
+                { KEY_EN_F12,                 0x60 },
+                { KEY_EN_EQUALS,              0x61 },
+                { KEY_EN_LEFT_BRACKET,        0x5A },
+                { KEY_EN_QUOTE,               0x5B },
+                { KEY_EN_RIGHT_SHIFT,         0x64 },
+                { KEY_EN_RIGHT_CONTROL,       0x65 },
+
+                { KEY_EN_BACKSPACE,           0x69 },
+                { KEY_EN_RIGHT_BRACKET,       0x62 },
+                { KEY_EN_LEFT_ARROW,          0x6D },
+
+                { KEY_EN_ANSI_BACK_SLASH,     0x6A },
+                { KEY_EN_ANSI_ENTER,          0x6B },
+                { KEY_EN_UP_ARROW,            0x74 },
+                { KEY_EN_DOWN_ARROW,          0x75 },
+
+                { KEY_EN_INSERT,              0x79 },
+                { KEY_EN_DELETE,              0x7A },
+                { KEY_EN_PAGE_UP,             0x7B },
+                { KEY_EN_PAGE_DOWN,           0x7C },
+                { KEY_EN_RIGHT_ARROW,         0x7D },
+            }
+        }
+    },
+};
+
 static std::map<int,layout_info> AsusROGStrixScopeLayouts =
 {
     {
@@ -812,6 +1092,290 @@ static std::map<int,layout_info> AsusROGStrixScopeLayouts =
     },
 };
 
+static std::map<int,layout_info> AsusROGStrixScopeIILayouts =
+{
+    {
+        ASUS_TUF_K7_LAYOUT_UK,
+        {
+            *ASUS_ROG_STRIX_SCOPE_II_LAYOUT_KEYS_ISO,
+            108,
+            6,
+            24,
+            {
+                { KEY_EN_ESCAPE,              0x00 },
+                { KEY_EN_BACK_TICK,           0x01 },
+                { KEY_EN_TAB,                 0x02 },
+                { KEY_EN_CAPS_LOCK,           0x03 },
+                { KEY_EN_LEFT_SHIFT,          0x04 },
+                { KEY_EN_LEFT_CONTROL,        0x05 },
+
+                { KEY_EN_1,                   0x11 },
+                { KEY_EN_ISO_BACK_SLASH,      0x0C },
+                { KEY_EN_LEFT_WINDOWS,        0x0D },
+
+                { KEY_EN_F1,                  0x18 },
+                { KEY_EN_2,                   0x19 },
+                { KEY_EN_Q,                   0x12 },
+                { KEY_EN_A,                   0x13 },
+                { KEY_EN_Z,                   0x14 },
+                { KEY_EN_LEFT_ALT,            0x15 },
+
+                { KEY_EN_F2,                  0x20 },
+                { KEY_EN_3,                   0x21 },
+                { KEY_EN_W,                   0x1A },
+                { KEY_EN_S,                   0x1B },
+                { KEY_EN_X,                   0x1C },
+
+                { KEY_EN_F3,                  0x28 },
+                { KEY_EN_4,                   0x29 },
+                { KEY_EN_E,                   0x22 },
+                { KEY_EN_D,                   0x23 },
+                { KEY_EN_C,                   0x24 },
+
+                { KEY_EN_F4,                  0x30 },
+                { KEY_EN_5,                   0x31 },
+                { KEY_EN_R,                   0x2A },
+                { KEY_EN_F,                   0x2B },
+                { KEY_EN_V,                   0x2C },
+                { KEY_EN_SPACE,               0x2D },
+
+                { KEY_EN_6,                   0x39 },
+                { KEY_EN_T,                   0x32 },
+                { KEY_EN_G,                   0x33 },
+                { KEY_EN_B,                   0x34 },
+                { KEY_EN_SPACE,               0x35 },
+
+                { KEY_EN_F5,                  0x40 },
+                { KEY_EN_7,                   0x41 },
+                { KEY_EN_Y,                   0x3A },
+                { KEY_EN_H,                   0x3B },
+                { KEY_EN_N,                   0x3C },
+                { KEY_EN_SPACE,               0x3D },
+
+                { KEY_EN_F6,                  0x48 },
+                { KEY_EN_8,                   0x49 },
+                { KEY_EN_U,                   0x42 },
+                { KEY_EN_J,                   0x43 },
+                { KEY_EN_M,                   0x44 },
+
+                { KEY_EN_F7,                  0x50 },
+                { KEY_EN_9,                   0x51 },
+                { KEY_EN_I,                   0x4A },
+                { KEY_EN_K,                   0x4B },
+                { KEY_EN_COMMA,               0x4C },
+
+                { KEY_EN_F8,                  0x58 },
+                { KEY_EN_0,                   0x59 },
+                { KEY_EN_O,                   0x52 },
+                { KEY_EN_L,                   0x53 },
+                { KEY_EN_PERIOD,              0x54 },
+                { KEY_EN_RIGHT_ALT,           0x4D },
+
+                { KEY_EN_F9,                  0x60 },
+                { KEY_EN_MINUS,               0x61 },
+                { KEY_EN_P,                   0x5A },
+                { KEY_EN_SEMICOLON,           0x5B },
+                { KEY_EN_FORWARD_SLASH,       0x5C },
+                { KEY_EN_RIGHT_FUNCTION,      0x5D },
+
+                { KEY_EN_F10,                 0x68 },
+                { KEY_EN_EQUALS,              0x69 },
+                { KEY_EN_LEFT_BRACKET,        0x62 },
+                { KEY_EN_QUOTE,               0x63 },
+                { KEY_EN_MENU,                0x65 },
+
+                { KEY_EN_F11,                 0x70 },
+                { KEY_EN_BACKSPACE,           0x79 },
+                { KEY_EN_RIGHT_BRACKET,       0x6A },
+                { KEY_EN_POUND,               0x6B },
+                { KEY_EN_RIGHT_SHIFT,         0x7C },
+
+                { KEY_EN_F12,                 0x78 },
+                { KEY_EN_ISO_ENTER,           0x7B },
+                { KEY_EN_RIGHT_CONTROL,       0x7D },
+
+                { KEY_EN_PRINT_SCREEN,        0x80 },
+                { KEY_EN_INSERT,              0x81 },
+                { KEY_EN_DELETE,              0x82 },
+                { KEY_EN_LEFT_ARROW,          0x85 },
+
+                { KEY_EN_SCROLL_LOCK,         0x88 },
+                { KEY_EN_HOME,                0x89 },
+                { KEY_EN_END,                 0x8A },
+                { KEY_EN_UP_ARROW,            0x8C },
+                { KEY_EN_DOWN_ARROW,          0x8D },
+
+                { KEY_EN_PAUSE_BREAK,         0x90 },
+                { KEY_EN_PAGE_UP,             0x91 },
+                { KEY_EN_PAGE_DOWN,           0x92 },
+                { KEY_EN_RIGHT_ARROW,         0x95 },
+
+                { KEY_EN_NUMPAD_LOCK,         0x99 },
+                { KEY_EN_NUMPAD_7,            0x9A },
+                { KEY_EN_NUMPAD_4,            0x9B },
+                { KEY_EN_NUMPAD_1,            0x9C },
+                { KEY_EN_NUMPAD_0,            0x9D },
+
+                { "Logo",                     0xA0 },
+                { KEY_EN_NUMPAD_DIVIDE,       0xA1 },
+                { KEY_EN_NUMPAD_8,            0xA2 },
+                { KEY_EN_NUMPAD_5,            0xA3 },
+                { KEY_EN_NUMPAD_2,            0xA4 },
+
+                { KEY_EN_NUMPAD_TIMES,        0xA9 },
+                { KEY_EN_NUMPAD_9,            0xAA },
+                { KEY_EN_NUMPAD_6,            0xAB },
+                { KEY_EN_NUMPAD_3,            0xAC },
+                { KEY_EN_NUMPAD_PERIOD,       0xAD },
+
+                { KEY_EN_NUMPAD_MINUS,        0xB1 },
+                { KEY_EN_NUMPAD_PLUS,         0xB2 },
+                { KEY_EN_NUMPAD_ENTER,        0xB4 },
+
+            }
+        }
+    },
+    {
+        ASUS_TUF_K7_LAYOUT_US,
+        {
+            *ASUS_ROG_STRIX_SCOPE_II_LAYOUT_KEYS_ANSI,
+            107,
+            6,
+            24,
+            {
+                { KEY_EN_ESCAPE,              0x00 },
+                { KEY_EN_BACK_TICK,           0x01 },
+                { KEY_EN_TAB,                 0x02 },
+                { KEY_EN_CAPS_LOCK,           0x03 },
+                { KEY_EN_LEFT_SHIFT,          0x04 },
+                { KEY_EN_LEFT_CONTROL,        0x05 },
+
+                { KEY_EN_1,                   0x11 },
+                { KEY_EN_LEFT_WINDOWS,        0x0D },
+
+                { KEY_EN_F1,                  0x18 },
+                { KEY_EN_2,                   0x19 },
+                { KEY_EN_Q,                   0x12 },
+                { KEY_EN_A,                   0x13 },
+                { KEY_EN_Z,                   0x14 },
+                { KEY_EN_LEFT_ALT,            0x15 },
+
+                { KEY_EN_F2,                  0x20 },
+                { KEY_EN_3,                   0x21 },
+                { KEY_EN_W,                   0x1A },
+                { KEY_EN_S,                   0x1B },
+                { KEY_EN_X,                   0x1C },
+
+                { KEY_EN_F3,                  0x28 },
+                { KEY_EN_4,                   0x29 },
+                { KEY_EN_E,                   0x22 },
+                { KEY_EN_D,                   0x23 },
+                { KEY_EN_C,                   0x24 },
+
+                { KEY_EN_F4,                  0x30 },
+                { KEY_EN_5,                   0x31 },
+                { KEY_EN_R,                   0x2A },
+                { KEY_EN_F,                   0x2B },
+                { KEY_EN_V,                   0x2C },
+                { KEY_EN_SPACE,               0x2D },
+
+                { KEY_EN_6,                   0x39 },
+                { KEY_EN_T,                   0x32 },
+                { KEY_EN_G,                   0x33 },
+                { KEY_EN_B,                   0x34 },
+                { KEY_EN_SPACE,               0x35 },
+
+                { KEY_EN_F5,                  0x40 },
+                { KEY_EN_7,                   0x41 },
+                { KEY_EN_Y,                   0x3A },
+                { KEY_EN_H,                   0x3B },
+                { KEY_EN_N,                   0x3C },
+                { KEY_EN_SPACE,               0x3D },
+
+                { KEY_EN_F6,                  0x48 },
+                { KEY_EN_8,                   0x49 },
+                { KEY_EN_U,                   0x42 },
+                { KEY_EN_J,                   0x43 },
+                { KEY_EN_M,                   0x44 },
+
+                { KEY_EN_F7,                  0x50 },
+                { KEY_EN_9,                   0x51 },
+                { KEY_EN_I,                   0x4A },
+                { KEY_EN_K,                   0x4B },
+                { KEY_EN_COMMA,               0x4C },
+
+                { KEY_EN_F8,                  0x58 },
+                { KEY_EN_0,                   0x59 },
+                { KEY_EN_O,                   0x52 },
+                { KEY_EN_L,                   0x53 },
+                { KEY_EN_PERIOD,              0x54 },
+                { KEY_EN_RIGHT_ALT,           0x4D },
+
+                { KEY_EN_F9,                  0x60 },
+                { KEY_EN_MINUS,               0x61 },
+                { KEY_EN_P,                   0x5A },
+                { KEY_EN_SEMICOLON,           0x5B },
+                { KEY_EN_FORWARD_SLASH,       0x5C },
+                { KEY_EN_RIGHT_FUNCTION,      0x5D },
+
+                { KEY_EN_F10,                 0x68 },
+                { KEY_EN_EQUALS,              0x69 },
+                { KEY_EN_LEFT_BRACKET,        0x62 },
+                { KEY_EN_QUOTE,               0x63 },
+                { KEY_EN_MENU,                0x65 },
+
+                { KEY_EN_F11,                 0x70 },
+                { KEY_EN_BACKSPACE,           0x79 },
+                { KEY_EN_RIGHT_BRACKET,       0x6A },
+                { KEY_EN_RIGHT_SHIFT,         0x7C },
+
+                { KEY_EN_F12,                 0x78 },
+                { KEY_EN_ANSI_BACK_SLASH,     0x7A },
+                { KEY_EN_ANSI_ENTER,          0x7B },
+                { KEY_EN_RIGHT_CONTROL,       0x7D },
+
+                { KEY_EN_PRINT_SCREEN,        0x80 },
+                { KEY_EN_INSERT,              0x81 },
+                { KEY_EN_DELETE,              0x82 },
+                { KEY_EN_LEFT_ARROW,          0x85 },
+
+                { KEY_EN_SCROLL_LOCK,         0x88 },
+                { KEY_EN_HOME,                0x89 },
+                { KEY_EN_END,                 0x8A },
+                { KEY_EN_UP_ARROW,            0x8C },
+                { KEY_EN_DOWN_ARROW,          0x8D },
+
+                { KEY_EN_PAUSE_BREAK,         0x90 },
+                { KEY_EN_PAGE_UP,             0x91 },
+                { KEY_EN_PAGE_DOWN,           0x92 },
+                { KEY_EN_RIGHT_ARROW,         0x95 },
+
+                { KEY_EN_NUMPAD_LOCK,         0x99 },
+                { KEY_EN_NUMPAD_7,            0x9A },
+                { KEY_EN_NUMPAD_4,            0x9B },
+                { KEY_EN_NUMPAD_1,            0x9C },
+                { KEY_EN_NUMPAD_0,            0x9D },
+
+                { "Logo",                     0xA0 },
+                { KEY_EN_NUMPAD_DIVIDE,       0xA1 },
+                { KEY_EN_NUMPAD_8,            0xA2 },
+                { KEY_EN_NUMPAD_5,            0xA3 },
+                { KEY_EN_NUMPAD_2,            0xA4 },
+
+                { KEY_EN_NUMPAD_TIMES,        0xA9 },
+                { KEY_EN_NUMPAD_9,            0xAA },
+                { KEY_EN_NUMPAD_6,            0xAB },
+                { KEY_EN_NUMPAD_3,            0xAC },
+                { KEY_EN_NUMPAD_PERIOD,       0xAD },
+
+                { KEY_EN_NUMPAD_MINUS,        0xB1 },
+                { KEY_EN_NUMPAD_PLUS,         0xB2 },
+                { KEY_EN_NUMPAD_ENTER,        0xB4 },
+            }
+        }
+    },
+};
+
 static std::map<int,layout_info> AsusROGStrixScopeII96WirelessLayouts =
 {
     {
@@ -1499,6 +2063,289 @@ static std::map<int,layout_info> AsusROGStrixFlareIILayouts =
         ASUS_TUF_K7_LAYOUT_UK,
         {
             *ASUS_ROG_STRIX_FLARE_II_LAYOUT_KEYS_ISO,
+            107,
+            7,
+            30,
+            {
+                { KEY_EN_ESCAPE,              0x00 },
+                { KEY_EN_BACK_TICK,           0x01 },
+                { KEY_EN_TAB,                 0x02 },
+                { KEY_EN_CAPS_LOCK,           0x03 },
+                { KEY_EN_LEFT_SHIFT,          0x04 },
+                { KEY_EN_LEFT_CONTROL,        0x05 },
+
+                { KEY_EN_1,                   0x11 },
+                { KEY_EN_ISO_BACK_SLASH,      0x0C },
+                { KEY_EN_LEFT_WINDOWS,        0x15 },
+
+                { KEY_EN_F1,                  0x18 },
+                { KEY_EN_2,                   0x19 },
+                { KEY_EN_Q,                   0x12 },
+                { KEY_EN_A,                   0x13 },
+                { KEY_EN_Z,                   0x14 },
+                { KEY_EN_LEFT_ALT,            0x1D },
+
+                { KEY_EN_F2,                  0x20 },
+                { KEY_EN_3,                   0x21 },
+                { KEY_EN_W,                   0x1A },
+                { KEY_EN_S,                   0x1B },
+                { KEY_EN_X,                   0x1C },
+
+                { KEY_EN_F3,                  0x28 },
+                { KEY_EN_4,                   0x29 },
+                { KEY_EN_E,                   0x22 },
+                { KEY_EN_D,                   0x23 },
+                { KEY_EN_C,                   0x24 },
+
+                { KEY_EN_F4,                  0x30 },
+                { KEY_EN_5,                   0x31 },
+                { KEY_EN_R,                   0x2A },
+                { KEY_EN_F,                   0x2B },
+                { KEY_EN_V,                   0x2C },
+
+                { KEY_EN_6,                   0x39 },
+                { KEY_EN_T,                   0x32 },
+                { KEY_EN_G,                   0x33 },
+                { KEY_EN_B,                   0x34 },
+                { KEY_EN_SPACE,               0x35 },
+
+                { KEY_EN_F5,                  0x40 },
+                { KEY_EN_7,                   0x41 },
+                { KEY_EN_Y,                   0x3A },
+                { KEY_EN_H,                   0x3B },
+                { KEY_EN_N,                   0x3C },
+
+                { KEY_EN_F6,                  0x48 },
+                { KEY_EN_8,                   0x49 },
+                { KEY_EN_U,                   0x42 },
+                { KEY_EN_J,                   0x43 },
+                { KEY_EN_M,                   0x44 },
+
+                { KEY_EN_F7,                  0x50 },
+                { KEY_EN_9,                   0x51 },
+                { KEY_EN_I,                   0x4A },
+                { KEY_EN_K,                   0x4B },
+                { KEY_EN_COMMA,               0x4C },
+
+                { KEY_EN_F8,                  0x58 },
+                { KEY_EN_0,                   0x59 },
+                { KEY_EN_O,                   0x52 },
+                { KEY_EN_L,                   0x53 },
+                { KEY_EN_PERIOD,              0x54 },
+                { KEY_EN_RIGHT_ALT,           0x4D },
+
+                { KEY_EN_F9,                  0x60 },
+                { KEY_EN_MINUS,               0x61 },
+                { KEY_EN_P,                   0x5A },
+                { KEY_EN_SEMICOLON,           0x5B },
+                { KEY_EN_FORWARD_SLASH,       0x5C },
+                { KEY_EN_RIGHT_FUNCTION,      0x5D },
+
+                { KEY_EN_F10,                 0x68 },
+                { KEY_EN_EQUALS,              0x69 },
+                { KEY_EN_LEFT_BRACKET,        0x62 },
+                { KEY_EN_QUOTE,               0x63 },
+                { KEY_EN_MENU,                0x65 },
+
+                { KEY_EN_F11,                 0x70 },
+                { KEY_EN_BACKSPACE,           0x79 },
+                { KEY_EN_RIGHT_BRACKET,       0x6A },
+                { KEY_EN_POUND,               0x6B },
+                { KEY_EN_RIGHT_SHIFT,         0x7C },
+
+                { KEY_EN_F12,                 0x78 },
+                { KEY_EN_ISO_ENTER,           0x7B },
+                { KEY_EN_RIGHT_CONTROL,       0x7D },
+
+                { KEY_EN_PRINT_SCREEN,        0x80 },
+                { KEY_EN_INSERT,              0x81 },
+                { KEY_EN_DELETE,              0x82 },
+                { KEY_EN_LEFT_ARROW,          0x85 },
+
+                { KEY_EN_SCROLL_LOCK,         0x88 },
+                { KEY_EN_HOME,                0x89 },
+                { KEY_EN_END,                 0x8A },
+                { KEY_EN_UP_ARROW,            0x8C },
+                { KEY_EN_DOWN_ARROW,          0x8D },
+
+                { KEY_EN_PAUSE_BREAK,         0x90 },
+                { KEY_EN_PAGE_UP,             0x91 },
+                { KEY_EN_PAGE_DOWN,           0x92 },
+                { KEY_EN_RIGHT_ARROW,         0x95 },
+
+                { KEY_EN_NUMPAD_LOCK,         0x99 },
+                { KEY_EN_NUMPAD_7,            0x9A },
+                { KEY_EN_NUMPAD_4,            0x9B },
+                { KEY_EN_NUMPAD_1,            0x9C },
+                { KEY_EN_NUMPAD_0,            0x9D },
+
+                { KEY_EN_NUMPAD_DIVIDE,       0xA1 },
+                { KEY_EN_NUMPAD_8,            0xA2 },
+                { KEY_EN_NUMPAD_5,            0xA3 },
+                { KEY_EN_NUMPAD_2,            0xA4 },
+
+                { KEY_EN_NUMPAD_TIMES,        0xA9 },
+                { KEY_EN_NUMPAD_9,            0xAA },
+                { KEY_EN_NUMPAD_6,            0xAB },
+                { KEY_EN_NUMPAD_3,            0xAC },
+                { KEY_EN_NUMPAD_PERIOD,       0xAD },
+
+                { KEY_EN_NUMPAD_MINUS,        0xB1 },
+                { KEY_EN_NUMPAD_PLUS,         0xB2 },
+                { KEY_EN_NUMPAD_ENTER,        0xB4 },
+
+                { "Logo 1",                    0xB0 },
+                { "Logo 2",                    0xA8 },
+            }
+        }
+    },
+    {
+        ASUS_TUF_K7_LAYOUT_US,
+        {
+            *ASUS_ROG_STRIX_FLARE_II_LAYOUT_KEYS_ANSI,
+            106,
+            7,
+            30,
+            {
+                { KEY_EN_ESCAPE,              0x00 },
+                { KEY_EN_BACK_TICK,           0x01 },
+                { KEY_EN_TAB,                 0x02 },
+                { KEY_EN_CAPS_LOCK,           0x03 },
+                { KEY_EN_LEFT_SHIFT,          0x04 },
+                { KEY_EN_LEFT_CONTROL,        0x05 },
+
+                { KEY_EN_1,                   0x11 },
+                { KEY_EN_LEFT_WINDOWS,        0x15 },
+
+                { KEY_EN_F1,                  0x18 },
+                { KEY_EN_2,                   0x19 },
+                { KEY_EN_Q,                   0x12 },
+                { KEY_EN_A,                   0x13 },
+                { KEY_EN_Z,                   0x14 },
+                { KEY_EN_LEFT_ALT,            0x1D },
+
+                { KEY_EN_F2,                  0x20 },
+                { KEY_EN_3,                   0x21 },
+                { KEY_EN_W,                   0x1A },
+                { KEY_EN_S,                   0x1B },
+                { KEY_EN_X,                   0x1C },
+
+                { KEY_EN_F3,                  0x28 },
+                { KEY_EN_4,                   0x29 },
+                { KEY_EN_E,                   0x22 },
+                { KEY_EN_D,                   0x23 },
+                { KEY_EN_C,                   0x24 },
+
+                { KEY_EN_F4,                  0x30 },
+                { KEY_EN_5,                   0x31 },
+                { KEY_EN_R,                   0x2A },
+                { KEY_EN_F,                   0x2B },
+                { KEY_EN_V,                   0x2C },
+
+                { KEY_EN_6,                   0x39 },
+                { KEY_EN_T,                   0x32 },
+                { KEY_EN_G,                   0x33 },
+                { KEY_EN_B,                   0x34 },
+                { KEY_EN_SPACE,               0x35 },
+
+                { KEY_EN_F5,                  0x40 },
+                { KEY_EN_7,                   0x41 },
+                { KEY_EN_Y,                   0x3A },
+                { KEY_EN_H,                   0x3B },
+                { KEY_EN_N,                   0x3C },
+
+                { KEY_EN_F6,                  0x48 },
+                { KEY_EN_8,                   0x49 },
+                { KEY_EN_U,                   0x42 },
+                { KEY_EN_J,                   0x43 },
+                { KEY_EN_M,                   0x44 },
+
+                { KEY_EN_F7,                  0x50 },
+                { KEY_EN_9,                   0x51 },
+                { KEY_EN_I,                   0x4A },
+                { KEY_EN_K,                   0x4B },
+                { KEY_EN_COMMA,               0x4C },
+
+                { KEY_EN_F8,                  0x58 },
+                { KEY_EN_0,                   0x59 },
+                { KEY_EN_O,                   0x52 },
+                { KEY_EN_L,                   0x53 },
+                { KEY_EN_PERIOD,              0x54 },
+                { KEY_EN_RIGHT_ALT,           0x4D },
+
+                { KEY_EN_F9,                  0x60 },
+                { KEY_EN_MINUS,               0x61 },
+                { KEY_EN_P,                   0x5A },
+                { KEY_EN_SEMICOLON,           0x5B },
+                { KEY_EN_FORWARD_SLASH,       0x5C },
+                { KEY_EN_RIGHT_FUNCTION,      0x5D },
+
+                { KEY_EN_F10,                 0x68 },
+                { KEY_EN_EQUALS,              0x69 },
+                { KEY_EN_LEFT_BRACKET,        0x62 },
+                { KEY_EN_QUOTE,               0x63 },
+                { KEY_EN_MENU,                0x65 },
+
+                { KEY_EN_F11,                 0x70 },
+                { KEY_EN_BACKSPACE,           0x79 },
+                { KEY_EN_RIGHT_BRACKET,       0x6A },
+                { KEY_EN_RIGHT_SHIFT,         0x7C },
+
+                { KEY_EN_F12,                 0x78 },
+                { KEY_EN_ANSI_BACK_SLASH,     0x7A },
+                { KEY_EN_ANSI_ENTER,          0x7B },
+                { KEY_EN_RIGHT_CONTROL,       0x7D },
+
+                { KEY_EN_PRINT_SCREEN,        0x80 },
+                { KEY_EN_INSERT,              0x81 },
+                { KEY_EN_DELETE,              0x82 },
+                { KEY_EN_LEFT_ARROW,          0x85 },
+
+                { KEY_EN_SCROLL_LOCK,         0x88 },
+                { KEY_EN_HOME,                0x89 },
+                { KEY_EN_END,                 0x8A },
+                { KEY_EN_UP_ARROW,            0x8C },
+                { KEY_EN_DOWN_ARROW,          0x8D },
+
+                { KEY_EN_PAUSE_BREAK,         0x90 },
+                { KEY_EN_PAGE_UP,             0x91 },
+                { KEY_EN_PAGE_DOWN,           0x92 },
+                { KEY_EN_RIGHT_ARROW,         0x95 },
+
+                { KEY_EN_NUMPAD_LOCK,         0x99 },
+                { KEY_EN_NUMPAD_7,            0x9A },
+                { KEY_EN_NUMPAD_4,            0x9B },
+                { KEY_EN_NUMPAD_1,            0x9C },
+                { KEY_EN_NUMPAD_0,            0x9D },
+
+                { KEY_EN_NUMPAD_DIVIDE,       0xA1 },
+                { KEY_EN_NUMPAD_8,            0xA2 },
+                { KEY_EN_NUMPAD_5,            0xA3 },
+                { KEY_EN_NUMPAD_2,            0xA4 },
+
+                { KEY_EN_NUMPAD_TIMES,        0xA9 },
+                { KEY_EN_NUMPAD_9,            0xAA },
+                { KEY_EN_NUMPAD_6,            0xAB },
+                { KEY_EN_NUMPAD_3,            0xAC },
+                { KEY_EN_NUMPAD_PERIOD,       0xAD },
+
+                { KEY_EN_NUMPAD_MINUS,        0xB1 },
+                { KEY_EN_NUMPAD_PLUS,         0xB2 },
+                { KEY_EN_NUMPAD_ENTER,        0xB4 },
+
+                { "Logo 1",                    0xB0 },
+                { "Logo 2",                    0xA8 },
+            }
+        }
+    },
+};
+
+static std::map<int,layout_info> AsusROGStrixFlareIIAnimateLayouts =
+{
+    {
+        ASUS_TUF_K7_LAYOUT_UK,
+        {
+            *ASUS_ROG_STRIX_FLARE_II_ANIMATE_LAYOUT_KEYS_ISO,
             135,
             7,
             30,
@@ -1666,7 +2513,7 @@ static std::map<int,layout_info> AsusROGStrixFlareIILayouts =
     {
         ASUS_TUF_K7_LAYOUT_US,
         {
-            *ASUS_ROG_STRIX_FLARE_II_LAYOUT_KEYS_ANSI,
+            *ASUS_ROG_STRIX_FLARE_II_ANIMATE_LAYOUT_KEYS_ANSI,
             134,
             7,
             30,

Controllers/AsusAuraUSBController/AsusAuraUSBController.cpp

@@ -11,7 +11,6 @@
 #include "LogManager.h"
 
 #include <cstring>
-#include <stdexcept>
 
 AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path)
 {
@@ -144,36 +143,56 @@ void AuraUSBController::GetFirmwareVersion()
 void AuraUSBController::SendDirect
     (
     unsigned char   device,
-    unsigned char   start_led,
     unsigned char   led_count,
-    unsigned char*  led_data,
-    bool apply /* = false */
+    RGBColor*  colors
     )
 {
     unsigned char usb_buf[65];
+    unsigned char offset         =      0x00;
+    unsigned char sent_led_count =      LEDS_PER_PACKET;
+    bool apply                   =      false;
+    while(!apply)
+    {
+        if(offset + sent_led_count > led_count)
+        {
+            sent_led_count = led_count - offset;
+        }
 
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
 
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_CONTROL_MODE_DIRECT;
-    usb_buf[0x02]   = apply ? 0x80 : 0x00;
-    usb_buf[0x02]  |= device;
-    usb_buf[0x03]   = start_led;
-    usb_buf[0x04]   = led_count;
+        if(offset + sent_led_count == led_count)
+        {
+            apply = true;
+        }
+        /*-----------------------------------------------------*\
+        | Zero out buffer                                       |
+        \*-----------------------------------------------------*/
+        memset(usb_buf, 0x00, sizeof(usb_buf));
 
-    /*-----------------------------------------------------*\
-    | Copy in color data bytes                              |
-    \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x05], led_data, led_count * 3);
+        /*-----------------------------------------------------*\
+        | Set up message packet                                 |
+        \*-----------------------------------------------------*/
+        usb_buf[0x00]   = 0xEC;
+        usb_buf[0x01]   = AURA_CONTROL_MODE_DIRECT;
+        usb_buf[0x02]   = (apply ? 0x80 : 0x00) | device;
+        usb_buf[0x03]   = offset;
+        usb_buf[0x04]   = sent_led_count;
 
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+        /*-----------------------------------------------------*\
+        | Copy in color data bytes                              |
+        \*-----------------------------------------------------*/
+        for(unsigned char led_idx = 0; led_idx < sent_led_count; led_idx++)
+        {
+
+            usb_buf[0x05 + (led_idx * 3)] = RGBGetRValue(colors[offset + led_idx]);
+            usb_buf[0x06 + (led_idx * 3)] = RGBGetGValue(colors[offset + led_idx]);
+            usb_buf[0x07 + (led_idx * 3)] = RGBGetBValue(colors[offset + led_idx]);
+        }
+
+        /*-----------------------------------------------------*\
+        | Send packet                                           |
+        \*-----------------------------------------------------*/
+        hid_write(dev, usb_buf, 65);
+
+        offset += sent_led_count;
+    }
 }

Controllers/AsusAuraUSBController/AsusAuraUSBController.h

@@ -49,6 +49,8 @@ enum class AuraDeviceType
     ADDRESSABLE,
 };
 
+#define LEDS_PER_PACKET  0x14;
+
 struct AuraDeviceInfo
 {
     unsigned char effect_channel;
@@ -97,10 +99,8 @@ protected:
     void SendDirect
         (
         unsigned char   device,
-        unsigned char   start_led,
         unsigned char   led_count,
-        unsigned char*  led_data,
-        bool apply = false
+        RGBColor *      colors
         );
 private:
     char                        device_name[16];

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -5,9 +5,9 @@
 #include "AsusAuraTUFKeyboardController.h"
 #include "AsusAuraMainboardController.h"
 #include "AsusAuraMouseController.h"
-#include "AsusAuraMousematController.h"
 #include "AsusROGAllyController.h"
-#include "AsusAuraStrixEvolveController.h"
+#include "AsusAuraMouseGen1Controller.h"
+#include "AsusAuraMousematController.h"
 #include "AsusAuraMonitorController.h"
 #include "AsusAuraRyuoAIOController.h"
 #include "RGBController.h"
@@ -20,7 +20,8 @@
 #include "RGBController_AsusAuraMousemat.h"
 #include "RGBController_AsusROGAlly.h"
 #include "RGBController_ROGStrixLC_Controller.h"
-#include "RGBController_AsusAuraStrixEvolve.h"
+#include "RGBController_AsusROGSpatha.h"
+#include "RGBController_AsusROGStrixEvolve.h"
 #include "RGBController_AsusAuraMonitor.h"
 #include "RGBController_AsusAuraRyuoAIO.h"
 #include <stdexcept>
@@ -43,29 +44,38 @@
 /*-----------------------------------------------------------------*\
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
-#define AURA_ROG_FALCHION_WIRED_PID                   0x193C
-#define AURA_ROG_FALCHION_WIRELESS_PID                0x193E
-#define AURA_ROG_STRIX_FLARE_PID                      0x1875
-#define AURA_ROG_STRIX_FLARE_PNK_LTD_PID              0x18CF
-#define AURA_ROG_STRIX_FLARE_COD_BO4_PID              0x18AF
-#define AURA_ROG_STRIX_FLARE_II_ANIMATE_PID           0x19FC
-#define AURA_ROG_STRIX_SCOPE_PID                      0x18F8
-#define AURA_ROG_STRIX_SCOPE_RX_PID                   0x1951
-#define AURA_ROG_STRIX_SCOPE_TKL_PID                  0x190C
-#define AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID        0x1A05
-#define AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID          0x1954
-#define AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID   0x1AAE
-#define AURA_ROG_CLAYMORE_PID                         0x184D
-#define AURA_TUF_K1_GAMING_PID                        0x1945
-#define AURA_TUF_K3_GAMING_PID                        0x194B
-#define AURA_TUF_K5_GAMING_PID                        0x1899
-#define AURA_TUF_K7_GAMING_PID                        0x18AA
+#define AURA_ROG_AZOTH_USB_PID                              0x1A83
+#define AURA_ROG_AZOTH_2_4_PID                              0x1A85
+#define AURA_ROG_CLAYMORE_PID                               0x184D
+#define AURA_ROG_FALCHION_WIRED_PID                         0x193C
+#define AURA_ROG_FALCHION_WIRELESS_PID                      0x193E
+#define AURA_ROG_STRIX_FLARE_PID                            0x1875
+#define AURA_ROG_STRIX_FLARE_PNK_LTD_PID                    0x18CF
+#define AURA_ROG_STRIX_FLARE_COD_BO4_PID                    0x18AF
+#define AURA_ROG_STRIX_FLARE_II_ANIMATE_PID                 0x19FC
+#define AURA_ROG_STRIX_FLARE_II_PID                         0x19FE
+#define AURA_ROG_STRIX_SCOPE_PID                            0x18F8
+#define AURA_ROG_STRIX_SCOPE_TKL_PID                        0x190C
+#define AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID                0x1954
+#define AURA_ROG_STRIX_SCOPE_RX_PID                         0x1951
+#define AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID              0x1A05
+#define AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID     0x19F6
+#define AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID     0x19F8
+#define AURA_ROG_STRIX_SCOPE_II_PID                         0x1AB3
+#define AURA_ROG_STRIX_SCOPE_II_RX_PID                      0x1AB5
+#define AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID         0x1AAE
+#define AURA_TUF_K1_GAMING_PID                              0x1945
+#define AURA_TUF_K3_GAMING_PID                              0x194B
+#define AURA_TUF_K5_GAMING_PID                              0x1899
+#define AURA_TUF_K7_GAMING_PID                              0x18AA
 
 /*-----------------------------------------------------------------*\
 |  MICE - defined in AsusAuraMouseDevices.h                         |
 \*-----------------------------------------------------------------*/
 
 #define AURA_ROG_STRIX_EVOLVE_PID                     0x185B
+#define AURA_ROG_SPATHA_WIRED_PID                     0x181C
+#define AURA_ROG_SPATHA_WIRELESS_PID                  0x1824
 
 /*-----------------------------------------------------------------*\
 | MOUSEMATS                                                         |
@@ -81,6 +91,7 @@
 #define AURA_ROG_STRIX_XG27AQM_PID                    0x19BB
 #define AURA_ROG_STRIX_XG279Q_PID                     0x1919
 #define AURA_ROG_STRIX_XG27W_PID                      0x1933
+#define AURA_ROG_STRIX_XG32VC_PID                     0x1968
 #define AURA_ROG_PG32UQ_PID                           0x19B9
 
 /*-----------------------------------------------------------------*\
@@ -241,8 +252,21 @@ void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name
 
     if(dev)
     {
-        AuraStrixEvolveController*     controller           = new AuraStrixEvolveController(dev, info->path, info->product_id);
-        RGBController_AuraStrixEvolve* rgb_controller       = new RGBController_AuraStrixEvolve(controller);
+        AsusAuraMouseGen1Controller*     controller         = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id);
+        RGBController_AsusROGStrixEvolve* rgb_controller    = new RGBController_AsusROGStrixEvolve(controller);
+        rgb_controller->name                                = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectAsusAuraUSBSpatha(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AsusAuraMouseGen1Controller*     controller         = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id);
+        RGBController_AsusROGSpatha* rgb_controller         = new RGBController_AsusROGSpatha(controller);
         rgb_controller->name                                = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
@@ -314,64 +338,78 @@ REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAs
 /*-----------------------------------------------------------------*\
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL",                    DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PID,                 1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX TKL Wireless Deluxe", DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID,       1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL PNK LTD",            DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID,         1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Claymore",                           DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_CLAYMORE_PID,                        1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                        DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                     1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",                DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,             1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare CoD Black Ops 4 Edition",DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_COD_BO4_PID,             1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)",                   DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID,                  1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)",                DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID,               1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare II Animate",             DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_II_ANIMATE_PID,          1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K1",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K1_GAMING_PID,                       2,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K3_GAMING_PID,                       1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K5",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K5_GAMING_PID,                       2,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope",                        DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID,                     1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX",                     DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID,                  1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K7",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID,                       1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope II 96 Wireless USB",     DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID,  1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL",                        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PID,                     1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX TKL Wireless Deluxe",     DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID,           1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL PNK LTD",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID,             1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Azoth USB",                              DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_AZOTH_USB_PID,                           1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Azoth 2.4GHz",                           DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_AZOTH_2_4_PID,                           1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Claymore",                               DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_CLAYMORE_PID,                            1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)",                       DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID,                      1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)",                    DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID,                   1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                            DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                         1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",                    DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,                 1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare CoD Black Ops 4 Edition",    DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_COD_BO4_PID,                 1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare II Animate",                 DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_II_ANIMATE_PID,              1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare II",                         DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_II_PID,                      1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope",                            DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID,                         1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX",                         DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID,                      1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope NX Wireless Deluxe USB",     DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID,  1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope NX Wireless Deluxe 2.4GHz",  DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID,  1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope II",                         DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_II_PID,                      1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope II RX",                      DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_II_RX_PID,                   1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope II 96 Wireless USB",         DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID,      1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K1",                              DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K1_GAMING_PID,                           2,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3",                              DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K3_GAMING_PID,                           1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K5",                              DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K5_GAMING_PID,                           2,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K7",                              DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID,                           1,  0xFF00);
 
 /*-----------------------------------------------------------------*\
 |  MICE                                                             |
 \*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID,                 0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II",                         DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_PID,                      2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin",                  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID,               2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD",          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID,       2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD",              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_COD_PID,           2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID,           1,  0xFF13);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID,           2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III",                        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_PID,                     0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless USB",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_USB_PID,        0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless 2.4Ghz",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID,        0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless Bluetooth",     DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_BT_PID,         0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRELESS_PID,                0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,                 0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram Core",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_CORE_PID,                    0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X USB",                      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_X_USB_PID,                   0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X 2.4GHz",                   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_X_2_4_PID,                   0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X USB",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_SPATHA_X_USB_PID,                    0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X 2.4GHz",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_SPATHA_X_2_4_PID,                    0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X Dock",                      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_SPATHA_X_DOCK_PID,                   0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio",                              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_PID,                           2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)",                   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID,                  0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wireless)",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRELESS_PID,               0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_PID,                    2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PID,                 0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Gundam",             DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID,          0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Electro Punk",       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PUNK_PID,            0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Moonlight White",    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WHITE_PID,           0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Wireless USB",       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID,    0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Wireless 2.4 Ghz",   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID,    0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris",                              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS,                               0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless USB",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_USB_PID,              0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless 2.4Ghz",              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_2_4_PID,              0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless Bluetooth",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_BT_PID,               0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M3",                          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M3_PID,                              1,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5",                          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M5_PID,                              2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core",                            DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID,                     0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II",                                 DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_PID,                          2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin",                          DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID,                   2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD",                  DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID,           2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD",                      DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_COD_PID,               2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                        DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID,               1,  0xFF13);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                        DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID,               2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III",                                DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_PID,                         0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless USB",                   DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_USB_PID,            0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless 2.4Ghz",                DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID,            0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless Bluetooth",             DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_BT_PID,             0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless AimPoint USB",          DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_USB_PID,   0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless AimPoint 2.4Ghz",       DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_2_4_PID,   0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",                         DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_CHAKRAM_WIRELESS_PID,                    0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",                            DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,                     0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Chakram Core",                               DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_CHAKRAM_CORE_PID,                        0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X USB",                              DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_CHAKRAM_X_USB_PID,                       0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X 2.4GHz",                           DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_CHAKRAM_X_2_4_PID,                       0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X USB",                               DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_SPATHA_X_USB_PID,                        0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X 2.4GHz",                            DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_SPATHA_X_2_4_PID,                        0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X Dock",                              DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_SPATHA_X_DOCK_PID,                       0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio",                                      DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_PUGIO_PID,                               2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)",                           DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID,                      0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wireless)",                        DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_PUGIO_II_WIRELESS_PID,                   0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact",                               DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_PID,                        2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II",                            DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PID,                     0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Gundam",                     DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID,              0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Electro Punk",               DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PUNK_PID,                0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Moonlight White",            DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WHITE_PID,               0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Wireless USB",               DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID,        0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Wireless 2.4 Ghz",           DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID,        0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact III",                           DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_III_PID,                    0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris",                                      DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS,                                   0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless USB",                         DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_USB_PID,                  0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless 2.4Ghz",                      DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_2_4_PID,                  0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless Bluetooth",                   DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_BT_PID,                   0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless AimPoint USB",                DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_AIMPOINT_USB_PID,         0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless AimPoint 2.4Ghz",             DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID,         0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M3",                                  DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_TUF_M3_PID,                                  1,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5",                                  DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_TUF_M5_PID,                                  2,  0xFF01);
 
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Evolve",                       DetectAsusAuraUSBStrixEvolve,   AURA_USB_VID, AURA_ROG_STRIX_EVOLVE_PID,                    1,  0x0008);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Spatha Wired",                       DetectAsusAuraUSBSpatha,        AURA_USB_VID, AURA_ROG_SPATHA_WIRED_PID,                    1,  0x0008);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Spatha Wireless",                    DetectAsusAuraUSBSpatha,        AURA_USB_VID, AURA_ROG_SPATHA_WIRELESS_PID,                 1,  0x0008);
 
 /*-----------------------------------------------------------------*\
 | MOUSEMATS                                                         |
@@ -386,6 +424,7 @@ REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQ",                       DetectAs
 REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQM",                      DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27AQM_PID,                   0xFFA0, 1);
 REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG279Q",                       DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG279Q_PID,                    0xFFA0, 1);
 REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27W",                        DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27W_PID,                     0xFFA0, 1);
+REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG32VC",                       DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG32VC_PID,                    0xFFA0, 1);
 REGISTER_HID_DETECTOR_PU("ASUS ROG PG32UQ",                             DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_PG32UQ_PID,                          0xFFA0, 1);
 
 /*-----------------------------------------------------------------*\

Controllers/AsusAuraUSBController/AsusROGAllyController.cpp

@@ -14,6 +14,8 @@ ROGAllyController::ROGAllyController(hid_device* dev_handle, const char* path)
 {
     dev         = dev_handle;
     location    = path;
+
+    SendInitialization();
 }
 
 ROGAllyController::~ROGAllyController()
@@ -47,6 +49,56 @@ std::string ROGAllyController::GetVersion()
     return("");
 }
 
+void ROGAllyController::SendInitialization()
+{
+    unsigned char usb_buf[64];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x5D;
+    usb_buf[0x01]   = 0xB9;
+    
+    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x5D;
+    usb_buf[0x01]   = 0x41;
+    usb_buf[0x02]   = 0x53;
+    usb_buf[0x03]   = 0x55;
+    usb_buf[0x04]   = 0x53;
+    usb_buf[0x05]   = 0x20;
+    usb_buf[0x06]   = 0x54;
+    usb_buf[0x07]   = 0x65;
+    usb_buf[0x08]   = 0x63;
+    usb_buf[0x09]   = 0x68;
+    usb_buf[0x0A]   = 0x2E;
+    usb_buf[0x0B]   = 0x49;
+    usb_buf[0x0C]   = 0x6E;
+    usb_buf[0x0D]   = 0x63;
+    usb_buf[0x0E]   = 0x2E;
+    
+    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
+}
+
+void ROGAllyController::UpdateBrightness
+    (
+    unsigned char           brightness
+    )
+{
+    unsigned char usb_buf[64];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x5A;
+    usb_buf[0x01]   = 0xBA;
+    usb_buf[0x02]   = 0xC5;
+    usb_buf[0x03]   = 0xC4;
+    usb_buf[0x04]   = brightness;
+
+    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
+}
+
 void ROGAllyController::UpdateLeds
     (
     std::vector<RGBColor>    colors
@@ -76,7 +128,6 @@ void ROGAllyController::UpdateDevice
     unsigned char           mode,
     std::vector<RGBColor>   colors,
     unsigned char           speed,
-    unsigned char           /*brightness*/,
     unsigned char           direction
     )
 {

Controllers/AsusAuraUSBController/AsusROGAllyController.h

@@ -45,6 +45,13 @@ public:
     std::string GetSerialString();
     std::string GetVersion();
 
+    void SendInitialization();
+    
+    void UpdateBrightness
+        (
+            unsigned char           brightness
+        );
+
     void UpdateLeds
         (
             std::vector<RGBColor>    colors
@@ -55,7 +62,6 @@ public:
             unsigned char           mode,
             std::vector<RGBColor>   colors,
             unsigned char           speed,
-            unsigned char           brightness,
             unsigned char           direction
             );
 

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp

@@ -45,6 +45,16 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
 
     std::vector<uint8_t> mm = aura_mouse_devices[pid].mouse_modes;
 
+    if(aura_mouse_devices[pid].direct)
+    {
+        mode Direct;
+        Direct.name                 = "Direct";
+        Direct.value                = 254;
+        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+        Direct.color_mode           = MODE_COLORS_PER_LED;
+        modes.push_back(Direct);
+    }
+
     int mode_value          = 0;
 
     for(std::vector<uint8_t>::iterator it = mm.begin(); it != mm.end(); it++)
@@ -52,16 +62,24 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
         switch(*it)
         {
             case AURA_MOUSE_MODE_STATIC:
+                /*-----------------------------------------------------------------*\
+                | If there is no direct mode, this mode can be used as direct       |
+                | (Asus does it the same way).                                      |
+                | The acutal direct mode is only found on new devices and on        |
+                | these devices static can't be used as direct anymore as it is     |
+                | too slow. The Spatha X's dock can't be controlled, because        |
+                | static is too slow and it can't be adressed in direct             |
+                \*-----------------------------------------------------------------*/
                 {
-                    mode Direct;
-                    Direct.name                 = "Direct";
-                    Direct.value                = mode_value;
-                    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-                    Direct.brightness_min       = aura_mouse_devices[pid].brightness_min;
-                    Direct.brightness_max       = aura_mouse_devices[pid].brightness_max;
-                    Direct.brightness           = aura_mouse_devices[pid].brightness_max;
-                    Direct.color_mode           = MODE_COLORS_PER_LED;
-                    modes.push_back(Direct);
+                    mode Static;
+                    Static.name                 = (aura_mouse_devices[pid].direct || pid == AURA_ROG_SPATHA_X_DOCK_FAKE_PID)? "Static" : "Direct";
+                    Static.value                = mode_value;
+                    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+                    Static.brightness_min       = aura_mouse_devices[pid].brightness_min;
+                    Static.brightness_max       = aura_mouse_devices[pid].brightness_max;
+                    Static.brightness           = aura_mouse_devices[pid].brightness_max;
+                    Static.color_mode           = MODE_COLORS_PER_LED;
+                    modes.push_back(Static);
                 }
                 break;
 
@@ -201,9 +219,16 @@ void RGBController_AuraMouse::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_AuraMouse::DeviceUpdateLEDs()
 {
-    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    if(modes[active_mode].value == AURA_MOUSE_MODE_DIRECT)
     {
-        UpdateSingleLED(zone_index);
+        controller->SendDirect(colors);
+    }
+    else
+    {
+        for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+        {
+            UpdateSingleLED(zone_index);
+        }
     }
 }
 
@@ -214,6 +239,12 @@ void RGBController_AuraMouse::UpdateZoneLEDs(int /*zone*/)
 
 void RGBController_AuraMouse::UpdateSingleLED(int led)
 {
+    if(modes[active_mode].value == AURA_MOUSE_MODE_DIRECT)
+    {
+        DeviceUpdateLEDs();
+        return;
+    }
+
     uint8_t red = RGBGetRValue(colors[led]);
     uint8_t grn = RGBGetGValue(colors[led]);
     uint8_t blu = RGBGetBValue(colors[led]);
@@ -223,6 +254,11 @@ void RGBController_AuraMouse::UpdateSingleLED(int led)
 
 void RGBController_AuraMouse::DeviceUpdateMode()
 {
+    if(modes[active_mode].value == AURA_MOUSE_MODE_DIRECT)
+    {
+        return;
+    }
+
     if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
     {
         DeviceUpdateLEDs();

Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.cpp

@@ -17,7 +17,7 @@
     @save :white_check_mark:
     @direct :white_check_mark:
     @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBMousemats
+    @detectors DetectAsusAuraUSBRyuoAIO
     @category Cooler
     @comment
 \*-------------------------------------------------------------------*/

Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.h

@@ -1,40 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraStrixEvolve.h      |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 11/30/2021                        |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusAuraStrixEvolveController.h"
-
-enum
-{
-    AURA_STRIX_EVOLVE_BRIGHTNESS_MIN     = 0,
-    AURA_STRIX_EVOLVE_BRIGHTNESS_MAX     = 255,
-    AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT = 255
-};
-
-class RGBController_AuraStrixEvolve : public RGBController
-{
-public:
-    RGBController_AuraStrixEvolve(AuraStrixEvolveController* controller_ptr);
-    ~RGBController_AuraStrixEvolve();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-    void        DeviceSaveMode();
-
-private:
-    AuraStrixEvolveController*  controller;
-};

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -58,11 +58,18 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
                 AURA_KEYBOARD_SPEED_MAX          = 0;
                 AURA_KEYBOARD_SPEED_DEFAULT      = 8;
                 break;
+            case AURA_ROG_AZOTH_USB_PID:
+            case AURA_ROG_AZOTH_2_4_PID:
             case AURA_ROG_FALCHION_WIRED_PID:
             case AURA_ROG_FALCHION_WIRELESS_PID:
+            case AURA_ROG_STRIX_FLARE_II_PID:
             case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
             case AURA_ROG_STRIX_SCOPE_RX_PID:
             case AURA_ROG_STRIX_SCOPE_PID:
+            case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID:
+            case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID:
+            case AURA_ROG_STRIX_SCOPE_II_PID:
+            case AURA_ROG_STRIX_SCOPE_II_RX_PID:
             case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
             case AURA_TUF_K5_GAMING_PID:
                 AURA_KEYBOARD_SPEED_MIN          = 255;
@@ -410,13 +417,26 @@ void RGBController_AuraTUFKeyboard::SetupZones()
             break;
         case AURA_ROG_STRIX_SCOPE_PID:
         case AURA_ROG_STRIX_SCOPE_RX_PID:
+        case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID:
+        case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID:
             keyboard_ptr = &AsusROGStrixScopeLayouts;
             break;
+        case AURA_ROG_STRIX_SCOPE_II_PID:
+        case AURA_ROG_STRIX_SCOPE_II_RX_PID:
+            keyboard_ptr = &AsusROGStrixScopeIILayouts;
+            break;
         case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
             keyboard_ptr = &AsusROGStrixScopeII96WirelessLayouts;
             break;
-        case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
+        case AURA_ROG_STRIX_FLARE_II_PID:
             keyboard_ptr = &AsusROGStrixFlareIILayouts;
+			break;
+        case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
+            keyboard_ptr = &AsusROGStrixFlareIIAnimateLayouts;
+            break;
+        case AURA_ROG_AZOTH_USB_PID:
+        case AURA_ROG_AZOTH_2_4_PID:
+            keyboard_ptr = &AsusROGAzothLayouts;
             break;
         case AURA_ROG_FALCHION_WIRED_PID:
         case AURA_ROG_FALCHION_WIRELESS_PID:

Controllers/AsusAuraUSBController/RGBController_AsusROGAlly.cpp

@@ -35,24 +35,30 @@ RGBController_AsusROGAlly::RGBController_AsusROGAlly(ROGAllyController* controll
     mode Direct;
     Direct.name                 = "Direct";
     Direct.value                = ROG_ALLY_MODE_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
     Direct.color_mode           = MODE_COLORS_PER_LED;
+    Direct.brightness_min       = 0;
+    Direct.brightness_max       = 3;
+    Direct.brightness           = 3;
     modes.push_back(Direct);
 
     mode Static;
     Static.name                 = "Static";
     Static.value                = ROG_ALLY_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
     Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
     Static.colors_min           = 1;
     Static.colors_max           = 1;
     Static.colors.resize(1);
+    Static.brightness_min       = 0;
+    Static.brightness_max       = 3;
+    Static.brightness           = 3;
     modes.push_back(Static);
 
     mode Breathing;
     Breathing.name              = "Breathing";
     Breathing.value             = ROG_ALLY_MODE_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
     Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
     Breathing.speed_min         = ROG_ALLY_SPEED_MIN;
     Breathing.speed_max         = ROG_ALLY_SPEED_MAX;
@@ -60,35 +66,47 @@ RGBController_AsusROGAlly::RGBController_AsusROGAlly(ROGAllyController* controll
     Breathing.colors_min        = 2;
     Breathing.colors_max        = 2;
     Breathing.colors.resize(2);
+    Breathing.brightness_min    = 0;
+    Breathing.brightness_max    = 3;
+    Breathing.brightness        = 3;
     modes.push_back(Breathing);
 
     mode ColorCycle;
     ColorCycle.name             = "Spectrum Cycle";
     ColorCycle.value            = ROG_ALLY_MODE_COLOR_CYCLE;
-    ColorCycle.flags            = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED;
+    ColorCycle.flags            = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
     ColorCycle.color_mode       = MODE_COLORS_RANDOM;
     ColorCycle.speed_min        = ROG_ALLY_SPEED_MIN;
     ColorCycle.speed_max        = ROG_ALLY_SPEED_MAX;
     ColorCycle.speed            = ROG_ALLY_SPEED_MED;
+    ColorCycle.brightness_min   = 0;
+    ColorCycle.brightness_max   = 3;
+    ColorCycle.brightness       = 3;
     modes.push_back(ColorCycle);
 
     mode Rainbow;
     Rainbow.name                = "Rainbow Wave";
     Rainbow.value               = ROG_ALLY_MODE_RAINBOW;
-    Rainbow.flags               = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    Rainbow.flags               = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS;
     Rainbow.color_mode          = MODE_COLORS_RANDOM;
     Rainbow.speed_min           = ROG_ALLY_SPEED_MIN;
     Rainbow.speed_max           = ROG_ALLY_SPEED_MAX;
     Rainbow.speed               = ROG_ALLY_SPEED_MED;
+    Rainbow.brightness_min      = 0;
+    Rainbow.brightness_max      = 3;
+    Rainbow.brightness          = 3;
     modes.push_back(Rainbow);
 
     mode Strobing;
     Strobing.name               = "Strobing";
     Strobing.value              = ROG_ALLY_MODE_STROBING;
-    Strobing.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Strobing.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
     Strobing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
     Strobing.colors_min         = 1;
     Strobing.colors_max         = 1;
+    Strobing.brightness_min     = 0;
+    Strobing.brightness_max     = 3;
+    Strobing.brightness         = 3;
     Strobing.colors.resize(1);
     modes.push_back(Strobing);
 
@@ -172,6 +190,8 @@ void RGBController_AsusROGAlly::UpdateSingleLED(int /*led*/)
 
 void RGBController_AsusROGAlly::DeviceUpdateMode()
 {
+    controller->UpdateBrightness(modes[active_mode].brightness);
+
     if(modes[active_mode].value == ROG_ALLY_MODE_DIRECT)
     {
         DeviceUpdateLEDs();
@@ -185,7 +205,7 @@ void RGBController_AsusROGAlly::DeviceUpdateMode()
             rog_ally_direction = ROG_ALLY_DIRECTION_LEFT;
         }
 
-        controller->UpdateDevice(modes[active_mode].value, modes[active_mode].colors, modes[active_mode].speed, modes[active_mode].brightness, rog_ally_direction);
+        controller->UpdateDevice(modes[active_mode].value, modes[active_mode].colors, modes[active_mode].speed, rog_ally_direction);
     }
 }
 

Controllers/AsusAuraUSBController/RGBController_AsusROGSpatha.cpp

@@ -0,0 +1,272 @@
+/*-----------------------------------------*\
+|  RGBController_AsusROGSpatha.cpp          |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 11/05/2023                        |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusROGSpatha.h"
+
+/**------------------------------------------------------------------*\
+    @name Asus Aura Spatha
+    @category Mouse
+    @type USB
+    @save :white_check_mark:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAsusAuraUSBSpatha
+    @comment This device allows indiviual modes for each zone,
+        which currently can't be implemented in OpenRGB.
+        Also there seem to be a firmware bug which causes static
+        to use a random colorand random to use a static color
+        that was previously set. This can be worked around by saving
+\*-------------------------------------------------------------------*/
+
+RGBController_AsusROGSpatha::RGBController_AsusROGSpatha(AsusAuraMouseGen1Controller* controller_ptr)
+{
+    controller                  = controller_ptr;
+
+    name                        = "ASUS ROG Spatha";
+    vendor                      = "ASUS";
+    type                        = DEVICE_TYPE_MOUSE;
+    description                 = "ASUS Aura Mouse Device";
+    version                     = controller->GetVersion();
+    location                    = controller->GetDeviceLocation();
+    serial                      = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = ASUS_ROG_SPATHA_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = ASUS_ROG_SPATHA_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.brightness_min       = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
+    Static.brightness_max       = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
+    Static.brightness           = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
+    Static.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = ASUS_ROG_SPATHA_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.brightness_min    = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
+    Breathing.brightness        = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
+    Breathing.colors_min        = 2;
+    Breathing.colors_max        = 2;
+    Breathing.colors.resize(2);
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    modes.push_back(Breathing);
+
+    mode ColorCycle;
+    ColorCycle.name             = "Spectrum Cycle";
+    ColorCycle.value            = ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE;
+    ColorCycle.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    ColorCycle.brightness_min   = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
+    ColorCycle.brightness_max   = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
+    ColorCycle.brightness       = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
+    ColorCycle.colors_min       = 12;
+    ColorCycle.colors_max       = 12;
+    ColorCycle.colors.resize(12);
+    ColorCycle.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    modes.push_back(ColorCycle);
+
+    mode Random;
+    Random.name                 = "Random";
+    Random.value                = ASUS_ROG_SPATHA_MODE_RANDOM;
+    Random.flags                = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Random.brightness_min       = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
+    Random.brightness_max       = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
+    Random.brightness           = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
+    Random.color_mode           = MODE_COLORS_NONE;
+    modes.push_back(Random);
+
+    mode Reactive;
+    Reactive.name               = "Reactive";
+    Reactive.value              = ASUS_ROG_SPATHA_MODE_REACTIVE;
+    Reactive.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Reactive.brightness_min     = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
+    Reactive.brightness_max     = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
+    Reactive.brightness         = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
+    Reactive.color_mode         = MODE_COLORS_PER_LED;
+    modes.push_back(Reactive);
+
+    mode Battery;
+    Battery.name               = "Battery";
+    Battery.value              = ASUS_ROG_SPATHA_MODE_BATTERY;
+    Battery.flags              = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Battery.brightness_min     = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
+    Battery.brightness_max     = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
+    Battery.brightness         = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
+    Battery.color_mode         = MODE_COLORS_NONE;
+    modes.push_back(Battery);
+
+    SetupZones();
+}
+
+RGBController_AsusROGSpatha::~RGBController_AsusROGSpatha()
+{
+    delete controller;
+}
+
+void RGBController_AsusROGSpatha::SetupZones()
+{
+
+    std::string zones_names[3] = {"Side", "Scroll Wheel", "Logo"};
+
+    for(unsigned char i = 0; i < 3; i++)
+    {
+        zone spatha_zone;
+
+        spatha_zone.name         = zones_names[i];
+        spatha_zone.type         = ZONE_TYPE_SINGLE;
+        spatha_zone.leds_min     = 1;
+        spatha_zone.leds_max     = 1;
+        spatha_zone.leds_count   = 1;
+        spatha_zone.matrix_map   = NULL;
+
+        zones.push_back(spatha_zone);
+
+        led spatha_led;
+
+        spatha_led.name          = zones_names[i];
+        spatha_led.value         = 1;
+
+        leds.push_back(spatha_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AsusROGSpatha::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
+void RGBController_AsusROGSpatha::DeviceUpdateLEDs()
+{
+    if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
+    {
+        controller->SendDirectSpatha(colors);
+    }
+    else
+    {
+        UpdateSingleLED(0);
+        UpdateSingleLED(1);
+        UpdateSingleLED(2);
+    }
+}
+
+void RGBController_AsusROGSpatha::UpdateZoneLEDs(int zone)
+{
+    if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
+    {
+        controller->SendDirectSpatha(colors);
+    }
+    else
+    {
+        UpdateSingleLED(zone);
+    }
+}
+
+void RGBController_AsusROGSpatha::UpdateSingleLED(int led)
+{
+    if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
+    {
+        controller->SendDirectSpatha(colors);
+    }
+    else
+    {
+        controller->SendUpdate(0x13 + led * 38, RGBGetRValue(colors[led]));
+        controller->SendUpdate(0x14 + led * 38, RGBGetGValue(colors[led]));
+        controller->SendUpdate(0x15 + led * 38, RGBGetBValue(colors[led]));
+    }
+}
+
+void RGBController_AsusROGSpatha::DeviceUpdateMode()
+{
+    if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
+    {
+        return;
+    }
+    
+    /*-----------------------------------------------------*\
+    | Needed to overwrite direct                            |
+    \*-----------------------------------------------------*/
+    controller->ResetToSavedLighting();
+
+    /*-----------------------------------------------------*\
+    | Send data to all 3 zones                              |
+    \*-----------------------------------------------------*/
+    for(int i = 0; i < 3; i++)
+    {
+        controller->SendUpdate(0x11 + i * 38, modes[active_mode].value);
+
+        /*------------------------------------------------------------------*\
+        | This mouse has independent brightness for wired and wireless.      |
+        | Each is 4-bit in the same byte (wireless is the first/bigger one). |
+        | OpenRGB misses that feature, hence both are the same               |
+        \*------------------------------------------------------------------*/
+        controller->SendUpdate(0x12 + i * 38, (modes[active_mode].brightness << 4) + modes[active_mode].brightness);
+        
+        if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE || modes[active_mode].value == ASUS_ROG_SPATHA_MODE_BREATHING)
+        {
+            for(int j = 0; j < modes[active_mode].colors.size(); j++)
+            {
+                controller->SendUpdate(0x13 + j * 3 + i * 38, RGBGetRValue(modes[active_mode].colors[j]));
+                controller->SendUpdate(0x14 + j * 3 + i * 38, RGBGetGValue(modes[active_mode].colors[j]));
+                controller->SendUpdate(0x15 + j * 3 + i * 38, RGBGetBValue(modes[active_mode].colors[j]));
+            }
+        }
+    }
+}
+
+void RGBController_AsusROGSpatha::DeviceSaveMode()
+{
+    if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
+    {
+        return;
+    }
+
+    unsigned int profile = controller->GetActiveProfile();
+    
+    /*-----------------------------------------------------*\
+    | Send data to all 3 zones                              |
+    \*-----------------------------------------------------*/
+    for(int i = 0; i < 3; i++)
+    {
+        controller->UpdateProfile(0x11 + i * 38, profile, modes[active_mode].value);
+        /*------------------------------------------------------------------*\
+        | This mouse has independent brightness for wired and wireless.      |
+        | Each is 4-bit in the same byte (wireless is the first/bigger one). |
+        | OpenRGB misses that feature, hence both are the same               |
+        \*------------------------------------------------------------------*/
+        controller->UpdateProfile(0x12 + i * 38, profile, (modes[active_mode].brightness << 4) + modes[active_mode].brightness);
+        
+        if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE || modes[active_mode].value == ASUS_ROG_SPATHA_MODE_BREATHING)
+        {
+            for(int j = 0; j < modes[active_mode].colors.size(); j++)
+            {
+                controller->UpdateProfile(0x13 + j * 3 + i * 38, profile, RGBGetRValue(modes[active_mode].colors[j]));
+                controller->UpdateProfile(0x14 + j * 3 + i * 38, profile, RGBGetGValue(modes[active_mode].colors[j]));
+                controller->UpdateProfile(0x15 + j * 3 + i * 38, profile, RGBGetBValue(modes[active_mode].colors[j]));
+            }
+        }
+        else if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_STATIC || modes[active_mode].value == ASUS_ROG_SPATHA_MODE_REACTIVE)
+        {
+            controller->UpdateProfile(0x13 + i * 38, profile, RGBGetRValue(colors[i]));
+            controller->UpdateProfile(0x14 + i * 38, profile, RGBGetGValue(colors[i]));
+            controller->UpdateProfile(0x15 + i * 38, profile, RGBGetBValue(colors[i]));
+        }
+    }
+
+    controller->ResetToSavedLighting();
+}

Controllers/AsusAuraUSBController/RGBController_AsusROGSpatha.h

@@ -0,0 +1,51 @@
+/*-----------------------------------------*\
+|  RGBController_AsusROGSpatha.h           |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 11/05/2023                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraMouseGen1Controller.h"
+
+enum
+{
+    ASUS_ROG_SPATHA_BRIGHTNESS_MIN          = 0,
+    ASUS_ROG_SPATHA_BRIGHTNESS_MAX          = 15,
+    ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT      = 15
+};
+
+enum
+{
+    ASUS_ROG_SPATHA_MODE_DIRECT             = 0xFF,
+    ASUS_ROG_SPATHA_MODE_STATIC             = 0x01,
+    ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE     = 0x05,
+    ASUS_ROG_SPATHA_MODE_RANDOM             = 0x06,
+    ASUS_ROG_SPATHA_MODE_BREATHING          = 0x0A,
+    ASUS_ROG_SPATHA_MODE_BATTERY            = 0x0B,
+    ASUS_ROG_SPATHA_MODE_REACTIVE           = 0x0C,
+};
+
+class RGBController_AsusROGSpatha : public RGBController
+{
+public:
+    RGBController_AsusROGSpatha(AsusAuraMouseGen1Controller* controller_ptr);
+    ~RGBController_AsusROGSpatha();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+    void        DeviceSaveMode();
+
+private:
+    AsusAuraMouseGen1Controller*  controller;
+};

Controllers/AsusAuraUSBController/RGBController_AsusROGStrixEvolve.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AsusAuraStrixEvolve.cpp    |
+|  RGBController_AsusROGStrixEvolve.cpp     |
 |                                           |
 |  Generic RGB Interface for Asus Aura      |
 |  USB controller driver                    |
@@ -7,7 +7,7 @@
 |  Mola19 11/30/2021                        |
 \*-----------------------------------------*/
 
-#include "RGBController_AsusAuraStrixEvolve.h"
+#include "RGBController_AsusROGStrixEvolve.h"
 
 /**------------------------------------------------------------------*\
     @name Asus Aura Strix Evolve
@@ -20,7 +20,7 @@
     @comment
 \*-------------------------------------------------------------------*/
 
-RGBController_AuraStrixEvolve::RGBController_AuraStrixEvolve(AuraStrixEvolveController* controller_ptr)
+RGBController_AsusROGStrixEvolve::RGBController_AsusROGStrixEvolve(AsusAuraMouseGen1Controller* controller_ptr)
 {
     controller                  = controller_ptr;
 
@@ -34,53 +34,53 @@ RGBController_AuraStrixEvolve::RGBController_AuraStrixEvolve(AuraStrixEvolveCont
 
     mode Direct;
     Direct.name                 = "Direct";
-    Direct.value                = 1;
+    Direct.value                = ASUS_ROG_STRIX_EVOLVE_MODE_DIRECT;
     Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Direct.brightness_min       = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
-    Direct.brightness_max       = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
-    Direct.brightness           = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    Direct.brightness_min       = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    Direct.brightness_max       = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    Direct.brightness           = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
     Direct.color_mode           = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode Breathing;
     Breathing.name              = "Breathing";
-    Breathing.value             = 2;
+    Breathing.value             = ASUS_ROG_STRIX_EVOLVE_MODE_BREATHING;
     Breathing.flags             = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Breathing.brightness_min    = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
-    Breathing.brightness_max    = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
-    Breathing.brightness        = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    Breathing.brightness_min    = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    Breathing.brightness        = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
     Breathing.color_mode        = MODE_COLORS_PER_LED;
     modes.push_back(Breathing);
 
     mode ColorCycle;
     ColorCycle.name             = "Spectrum Cycle";
-    ColorCycle.value            = 3;
+    ColorCycle.value            = ASUS_ROG_STRIX_EVOLVE_MODE_SPECTRUM_CYCLE;
     ColorCycle.flags            = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    ColorCycle.brightness_min   = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
-    ColorCycle.brightness_max   = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
-    ColorCycle.brightness       = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    ColorCycle.brightness_min   = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    ColorCycle.brightness_max   = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    ColorCycle.brightness       = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
     ColorCycle.color_mode       = MODE_COLORS_NONE;
     modes.push_back(ColorCycle);
 
     mode Reactive;
     Reactive.name               = "Reactive";
-    Reactive.value              = 4;
+    Reactive.value              = ASUS_ROG_STRIX_EVOLVE_MODE_REACTIVE;
     Reactive.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Reactive.brightness_min     = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
-    Reactive.brightness_max     = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
-    Reactive.brightness         = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    Reactive.brightness_min     = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    Reactive.brightness_max     = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    Reactive.brightness         = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
     Reactive.color_mode         = MODE_COLORS_PER_LED;
     modes.push_back(Reactive);
 
     SetupZones();
 }
 
-RGBController_AuraStrixEvolve::~RGBController_AuraStrixEvolve()
+RGBController_AsusROGStrixEvolve::~RGBController_AsusROGStrixEvolve()
 {
     delete controller;
 }
 
-void RGBController_AuraStrixEvolve::SetupZones()
+void RGBController_AsusROGStrixEvolve::SetupZones()
 {
     zone mouse_zone;
 
@@ -103,58 +103,48 @@ void RGBController_AuraStrixEvolve::SetupZones()
     SetupColors();
 }
 
-void RGBController_AuraStrixEvolve::ResizeZone(int /*zone*/, int /*new_size*/)
+void RGBController_AsusROGStrixEvolve::ResizeZone(int /*zone*/, int /*new_size*/)
 {
 
 }
 
-void RGBController_AuraStrixEvolve::DeviceUpdateLEDs()
+void RGBController_AsusROGStrixEvolve::DeviceUpdateLEDs()
 {
-    unsigned char red = RGBGetRValue(colors[0]);
-    unsigned char grn = RGBGetGValue(colors[0]);
-    unsigned char blu = RGBGetBValue(colors[0]);
-
-    controller->SendUpdate(0x1C, red);
-    controller->SendUpdate(0x1D, grn);
-    controller->SendUpdate(0x1E, blu);
+    UpdateSingleLED(0);
 }
 
-void RGBController_AuraStrixEvolve::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AsusROGStrixEvolve::UpdateZoneLEDs(int zone)
 {
-    DeviceUpdateLEDs();
+    UpdateSingleLED(zone);
 }
 
-void RGBController_AuraStrixEvolve::UpdateSingleLED(int /*led*/)
+void RGBController_AsusROGStrixEvolve::UpdateSingleLED(int led)
 {
-    DeviceUpdateLEDs();
+    controller->SendUpdate(0x1C, RGBGetRValue(colors[0]));
+    controller->SendUpdate(0x1D, RGBGetGValue(colors[0]));
+    controller->SendUpdate(0x1E, RGBGetBValue(colors[0]));
 }
 
-void RGBController_AuraStrixEvolve::DeviceUpdateMode()
+void RGBController_AsusROGStrixEvolve::DeviceUpdateMode()
 {
-    unsigned char red = RGBGetRValue(colors[0]);
-    unsigned char grn = RGBGetGValue(colors[0]);
-    unsigned char blu = RGBGetBValue(colors[0]);
-
     controller->SendUpdate(0x19, modes[active_mode].value);
     controller->SendUpdate(0x1A, modes[active_mode].brightness);
-    controller->SendUpdate(0x1C, red);
-    controller->SendUpdate(0x1D, grn);
-    controller->SendUpdate(0x1E, blu);
 }
 
-void RGBController_AuraStrixEvolve::DeviceSaveMode()
+void RGBController_AsusROGStrixEvolve::DeviceSaveMode()
 {
-    unsigned char red = RGBGetRValue(colors[0]);
-    unsigned char grn = RGBGetGValue(colors[0]);
-    unsigned char blu = RGBGetBValue(colors[0]);
-
     unsigned int profile = controller->GetActiveProfile();
 
+
     controller->UpdateProfile(0x19, profile, modes[active_mode].value);
     controller->UpdateProfile(0x1A, profile, modes[active_mode].brightness);
-    controller->UpdateProfile(0x1C, profile, red);
-    controller->UpdateProfile(0x1D, profile, grn);
-    controller->UpdateProfile(0x1E, profile, blu);
 
-    controller->SendSavePacket();
+    if(modes[active_mode].value != ASUS_ROG_STRIX_EVOLVE_MODE_SPECTRUM_CYCLE)
+    {
+        controller->UpdateProfile(0x1C, profile, RGBGetRValue(colors[0]));
+        controller->UpdateProfile(0x1D, profile, RGBGetGValue(colors[0]));
+        controller->UpdateProfile(0x1E, profile, RGBGetBValue(colors[0]));
+    }
+
+    controller->ResetToSavedLighting();
 }

Controllers/AsusAuraUSBController/RGBController_AsusROGStrixEvolve.h

@@ -0,0 +1,48 @@
+/*-----------------------------------------*\
+|  RGBController_AsusROGStrixEvolve.h       |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 11/30/2021                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraMouseGen1Controller.h"
+
+enum
+{
+    ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN        = 0,
+    ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX        = 255,
+    ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT    = 255,
+};
+
+enum
+{
+    ASUS_ROG_STRIX_EVOLVE_MODE_DIRECT           = 0x01,
+    ASUS_ROG_STRIX_EVOLVE_MODE_BREATHING        = 0x02,
+    ASUS_ROG_STRIX_EVOLVE_MODE_SPECTRUM_CYCLE   = 0x03,
+    ASUS_ROG_STRIX_EVOLVE_MODE_REACTIVE         = 0x04,
+};
+
+class RGBController_AsusROGStrixEvolve : public RGBController
+{
+public:
+    RGBController_AsusROGStrixEvolve(AsusAuraMouseGen1Controller* controller_ptr);
+    ~RGBController_AsusROGStrixEvolve();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+    void        DeviceSaveMode();
+
+private:
+    AsusAuraMouseGen1Controller*  controller;
+};

Controllers/AsusTUFLaptopController/AsusTUFLaptopController_Linux.cpp

@@ -1,4 +1,4 @@
-#include "AsusTUFLaptopLinuxController.h"
+#include "AsusTUFLaptopController_Linux.h"
 
 #include <string>
 

Controllers/AsusTUFLaptopController/AsusTUFLaptopController_Windows.cpp

@@ -1,6 +1,6 @@
 #ifdef _WIN32
 
-#include "AsusTUFLaptopController.h"
+#include "AsusTUFLaptopController_Windows.h"
 
 #include <Objbase.h>
 #include <setupapi.h>

Controllers/AsusTUFLaptopController/AsusTUFLaptopDetect_Linux.cpp

@@ -1,5 +1,4 @@
-#include "RGBController_AsusTUFLaptopLinux.h"
-#include "AsusTUFLaptopLinuxController.h"
+#include "RGBController_AsusTUFLaptop_Linux.h"
 
 #include <string>
 #include "Detector.h"

Controllers/AsusTUFLaptopController/AsusTUFLaptopDetect_Windows.cpp

@@ -1,7 +1,6 @@
 #ifdef _WIN32
 
-#include "AsusTUFLaptopController.h"
-#include "RGBController_AsusTUFLaptopWMI.h"
+#include "RGBController_AsusTUFLaptop_Windows.h"
 
 #include "Detector.h"
 #include "wmi.h"

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptop_Linux.cpp

@@ -1,4 +1,4 @@
-#include "RGBController_AsusTUFLaptopLinux.h"
+#include "RGBController_AsusTUFLaptop_Linux.h"
 
 /**------------------------------------------------------------------*\
     @name Asus TUF Laptop Linux WMI

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptop_Linux.h

@@ -2,7 +2,7 @@
 #define RGBCONTROLLER_ASUSTUFLAPTOPLINUX_H
 
 #include "RGBController.h"
-#include "AsusTUFLaptopLinuxController.h"
+#include "AsusTUFLaptopController_Linux.h"
 
 
 class RGBController_AsusTUFLaptopLinux : public RGBController

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptop_Windows.cpp

@@ -1,6 +1,6 @@
 #ifdef _WIN32
 
-#include "RGBController_AsusTUFLaptopWMI.h"
+#include "RGBController_AsusTUFLaptop_Windows.h"
 
 using namespace std::chrono_literals;
 

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptop_Windows.h

@@ -3,7 +3,7 @@
 #ifndef RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
 #define RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
 
-#include "AsusTUFLaptopController.h"
+#include "AsusTUFLaptopController_Windows.h"
 #include "RGBController.h"
 
 class RGBController_AsusTUFLaptopWMI : public RGBController

Controllers/CherryKeyboardController/CherryKeyboardController.cpp

@@ -95,18 +95,19 @@ void CherryKeyboardController::SendKeyboardModeEx
     unsigned char       blue
     )
 {
-    unsigned char parameter_data[8];
+    unsigned char parameter_data[9];
 
-    parameter_data[0]   = mode;
-    parameter_data[1]   = brightness;
-    parameter_data[2]   = speed;
-    parameter_data[3]   = direction;
-    parameter_data[4]   = random_flag;
-    parameter_data[5]   = red;
-    parameter_data[6]   = green;
-    parameter_data[7]   = blue;
+    parameter_data[0]   = 0x0;
+    parameter_data[1]   = mode;
+    parameter_data[2]   = brightness;
+    parameter_data[3]   = speed;
+    parameter_data[4]   = direction;
+    parameter_data[5]   = random_flag;
+    parameter_data[6]   = red;
+    parameter_data[7]   = green;
+    parameter_data[8]   = blue;
 
-    SendKeyboardParameter(0, 8, parameter_data);
+    SendKeyboardParameter(0, 9, parameter_data);
 }
 
 /*-------------------------------------------------------------------------------------------------*\
@@ -237,17 +238,18 @@ void CherryKeyboardController::SendKeyboardParameter
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
     /*-----------------------------------------------------*\
-    | Set up Keyboard Parameter (0x06) packet               |
+    | Set up Keyboard Parameter (0x08) packet               |
     \*-----------------------------------------------------*/
     usb_buf[0x00]           = 0x04;
     usb_buf[0x03]           = CHERRY_KB_COMMAND_SET_PARAMETER;
     usb_buf[0x04]           = parameter_size;
     usb_buf[0x05]           = parameter;
+    usb_buf[0x07]           = 0x55;
 
     /*-----------------------------------------------------*\
     | Copy in data bytes                                    |
     \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x09], parameter_data, parameter_size);
+    memcpy(&usb_buf[0x08], parameter_data, parameter_size);
 
     /*-----------------------------------------------------*\
     | Compute Checksum                                      |

Controllers/CherryKeyboardController/CherryKeyboardController.h

@@ -17,6 +17,34 @@
 #define CHERRY_KB_PACKET_SIZE                        64
 #define CHERRY_KB_MAX_PACKET_SIZE                  ( 0x36 )/* max packet size for color*/
                                                             /* update packets           */
+
+/*-----------------------------------------------------*\
+| Cherry keyboard product IDs                           |
+\*-----------------------------------------------------*/
+#define MX_BOARD_3_0S_FL_NBL_PID        0x0077
+#define MX_BOARD_3_0S_FL_RGB_PID        0x0079
+#define MX_BOARD_3_0S_FL_RGB_KOR_PID    0x0083
+#define MX_1_0_FL_BL_PID                0x00AB
+#define MX_BOARD_1_0_TKL_RGB_PID        0x00AC
+#define MX_BOARD_8_0_TKL_RGB_PID        0x00B7
+#define MX_BOARD_10_0_FL_RGB_PID        0x00BB
+#define G80_3000_TKL_NBL_PID            0x00C3
+#define MX_BOARD_2_0S_FL_RGB_PID        0x00C4
+#define G80_3000_TKL_RGB_PID            0x00C5
+#define MV_BOARD_3_0FL_RGB_PID          0x00C7
+#define CCF_MX_8_0_TKL_BL_PID           0x00C9
+#define CCF_MX_1_0_TKL_BL_PID           0x00CA
+#define CCF_MX_1_0_TKL_NBL_PID          0x00CB
+#define G80_3000_TKL_NBL_KOR_PID        0x00CD
+#define MX_BOARD_2_0S_FL_NBL_PID        0x00CE
+#define MX_1_0_FL_NBL_PID               0x00D2
+#define MX_1_0_FL_RGB_PID               0x00D3
+#define G80_3000N_TKL_RGB_PID           0x00DD
+#define G80_3000N_FL_RGB_PID            0x00DE
+#define MX_BOARD_10_0N_FL_RGB_PID       0x00DF
+#define MX_BOARD_2_0S_FL_RGB_DE_PID     0x01A6
+
+
 enum
 {
     CHERRY_KB_COMMAND_BEGIN                        = 0x01, /* Begin packet command     */

Controllers/CherryKeyboardController/CherryKeyboardControllerDetect.cpp

@@ -6,32 +6,10 @@
 #include <hidapi/hidapi.h>
 
 /*-----------------------------------------------------*\
-| Keyboard product IDs                                  |
+| Cherry keyboard VID and usage page                    |
 \*-----------------------------------------------------*/
 #define CHERRY_KEYBOARD_VID             0x046A
 #define CHERRY_KEYBOARD_USAGE_PAGE      0xFF1C
-#define MX_BOARD_3_0S_FL_NBL_PID        0x0077
-#define MX_BOARD_3_0S_FL_RGB_PID        0x0079
-#define MX_BOARD_3_0S_FL_RGB_KOR_PID    0x0083
-#define MX_1_0_FL_BL_PID                0x00AB
-#define MX_BOARD_1_0_TKL_RGB_PID        0x00AC
-#define MX_BOARD_8_0_TKL_RGB_PID        0x00B7
-#define MX_BOARD_10_0_FL_RGB_PID        0x00BB
-#define G80_3000_TKL_NBL_PID            0x00C3
-#define MX_BOARD_2_0S_FL_RGB_PID        0x00C4
-#define G80_3000_TKL_RGB_PID            0x00C5
-#define MV_BOARD_3_0FL_RGB_PID          0x00C7
-#define CCF_MX_8_0_TKL_BL_PID           0x00C9
-#define CCF_MX_1_0_TKL_BL_PID           0x00CA
-#define CCF_MX_1_0_TKL_NBL_PID          0x00CB
-#define G30_3000_TKL_NBL_KOR_PID        0x00CD
-#define MX_BOARD_2_0S_FL_NBL_PID        0x00CE
-#define MX_1_0_FL_NBL_PID               0x00D2
-#define MX_1_0_FL_RGB_PID               0x00D3
-#define G80_3000N_TKL_RGB_PID           0x00DD
-#define G30_3000N_FL_RGB_PID            0x00DE
-#define MX_BOARD_10_0N_FL_RGB_PID       0x00DF
-#define MX_BOARD_2_0S_FL_RGB_DE_PID     0x01A6
 
 /******************************************************************************************\
 *                                                                                          *
@@ -47,7 +25,7 @@ void DetectCherryKeyboards(hid_device_info* info, const std::string& name)
     if( dev )
     {
         CherryKeyboardController* controller = new CherryKeyboardController(dev, info->path);
-        RGBController_CherryKeyboard* rgb_controller = new RGBController_CherryKeyboard(controller);
+        RGBController_CherryKeyboard* rgb_controller = new RGBController_CherryKeyboard(controller, info->product_id);
         rgb_controller->name = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
@@ -70,11 +48,11 @@ REGISTER_HID_DETECTOR_IP("Cherry Keyboard MV BOARD 3.0 FL RGB",         DetectCh
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard CCF MX 8.0 TKL BL",           DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   CCF_MX_8_0_TKL_BL_PID       , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard CCF MX 1.0 TKL BL",           DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   CCF_MX_1_0_TKL_BL_PID       , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard CCF MX 1.0 TKL NBL",          DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   CCF_MX_1_0_TKL_NBL_PID      , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000 TKL NBL KOREAN",     DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   G30_3000_TKL_NBL_KOR_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000 TKL NBL KOREAN",     DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   G80_3000_TKL_NBL_KOR_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 2.0S FL NBL",        DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_2_0S_FL_NBL_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX 1.0 FL NBL",               DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_1_0_FL_NBL_PID           , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX 1.0 FL RGB",               DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_1_0_FL_RGB_PID           , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000N TKL RGB",           DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   G80_3000N_TKL_RGB_PID       , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000N FL RGB",            DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   G30_3000N_FL_RGB_PID        , 1, CHERRY_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000N FL RGB",            DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   G80_3000N_FL_RGB_PID        , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 10.0N FL RGB",       DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_10_0N_FL_RGB_PID   , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 2.0S FL RGB DE",     DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_2_0S_FL_RGB_DE_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);

Controllers/CherryKeyboardController/RGBController_CherryKeyboard.cpp

@@ -11,14 +11,20 @@
 
 //0xFFFFFFFF indicates an unused entry in matrix
 #define NA  0xFFFFFFFF
+#define CHERRY_MATRIX_MAP_HEIGHT 6
+#define CHERRY_MATRIX_MAP_WIDTH 21
+#define CHERRY_MATRIX_CELL_COUNT ( CHERRY_MATRIX_MAP_HEIGHT * CHERRY_MATRIX_MAP_WIDTH )
 
-static unsigned int matrix_map[6][23] =
-    { {  0,  NA,  12,  18,  24,  30,  36,  42,  48,  54,  60,  66,  72,  78,  84,  90,  96,  NA,  NA,  NA,  NA,  NA,  NA },
-      {  1,   7,  13,  19,  25,  31,  37,  43,  49,  55,  61,  67,  73,  79,  85,  91,  97,  NA,  NA,  NA,  NA,  NA,  NA },
-      {  2,   8,  14,  20,  26,  32,  38,  44,  50,  56,  62,  68,  74,  NA,  86,  92,  98,  NA,  NA,  NA,  NA,  NA,  NA },
-      {  3,   9,  15,  21,  27,  33,  39,  45,  51,  57,  63,  69,  75,  81,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
-      {  4,  10,  16,  22,  28,  34,  40,  46,  52,  58,  64,  70,  NA,  82,  NA,  94,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
-      {  5,  11,  17,  NA,  NA,  NA,  41,  NA,  NA,  NA,  65,  71,  77,  83,  89,  95, 101,  NA,  NA,  NA,  NA,  NA,  NA } };
+/* The total byte count for all colors is 'number of matrix cells' times '3 color components' */
+#define CUSTOM_COLOR_ARRAY_BYTE_COUNT ( CHERRY_MATRIX_CELL_COUNT * 3 )
+
+static unsigned int matrix_map[CHERRY_MATRIX_MAP_HEIGHT][CHERRY_MATRIX_MAP_WIDTH] =
+    { {  0,  NA,  12,  18,  24,  30,  36,  42,  48,  54,  60,  66,  72,  78,  84,  90,  96,  102, 108, 114, 120 },
+      {  1,   7,  13,  19,  25,  31,  37,  43,  49,  55,  61,  67,  73,  79,  85,  91,  97,  103, 109, 115, 121 },
+      {  2,   8,  14,  20,  26,  32,  38,  44,  50,  56,  62,  68,  74,  NA,  86,  92,  98,  104, 110, 116,  NA },
+      {  3,   9,  15,  21,  27,  33,  39,  45,  51,  57,  63,  69,  75,  81,  NA,  NA,  NA,  105, 111, 117, 122 },
+      {  4,  10,  16,  22,  28,  34,  40,  46,  52,  58,  64,  70,  NA,  82,  NA,  94,  NA,  106, 112, 118,  NA },
+      {  5,  11,  17,  NA,  NA,  NA,  41,  NA,  NA,  NA,  65,  71,  77,  83,  89,  95, 101,  113,  NA, 119, 124 } };
 
 /**------------------------------------------------------------------*\
     @name Cherry Keyboard
@@ -31,7 +37,7 @@ static unsigned int matrix_map[6][23] =
     @comment
 \*-------------------------------------------------------------------*/
 
-RGBController_CherryKeyboard::RGBController_CherryKeyboard(CherryKeyboardController* controller_ptr)
+RGBController_CherryKeyboard::RGBController_CherryKeyboard(CherryKeyboardController* controller_ptr, uint16_t product_id)
 {
     controller  = controller_ptr;
 
@@ -43,202 +49,259 @@ RGBController_CherryKeyboard::RGBController_CherryKeyboard(CherryKeyboardControl
     serial      = controller->GetSerialString();
 
     mode Custom;
-    Custom.name       = "Custom";
-    Custom.value      = CHERRY_KB_MODE_CUSTOM;
-    Custom.flags      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Custom.color_mode = MODE_COLORS_PER_LED;
+    Custom.name           = "Custom";
+    Custom.value          = CHERRY_KB_MODE_CUSTOM;
+    Custom.flags          = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Custom.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
+    Custom.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Custom.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Custom.color_mode     = MODE_COLORS_PER_LED;
     modes.push_back(Custom);
 
     mode Wave;
-    Wave.name       = "Wave";
-    Wave.value      = CHERRY_KB_MODE_WAVE;
-    Wave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Wave.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Wave.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Wave.speed      = CHERRY_KB_SPEED_NORMAL;
-    Wave.colors_min = 1;
-    Wave.colors_max = 1;
-    Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Wave.name           = "Wave";
+    Wave.value          = CHERRY_KB_MODE_WAVE;
+    Wave.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Wave.speed_min      = CHERRY_KB_SPEED_SLOWEST;
+    Wave.speed_max      = CHERRY_KB_SPEED_FASTEST;
+    Wave.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
+    Wave.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Wave.colors_min     = 1;
+    Wave.colors_max     = 1;
+    Wave.speed          = CHERRY_KB_SPEED_NORMAL;
+    Wave.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Wave.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Wave.colors.resize(1);
     modes.push_back(Wave);
 
     mode Spectrum;
-    Spectrum.name       = "Spectrum";
-    Spectrum.value      = CHERRY_KB_MODE_SPECTRUM;
-    Spectrum.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-    Spectrum.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Spectrum.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Spectrum.speed      = CHERRY_KB_SPEED_NORMAL;
-    Spectrum.color_mode = MODE_COLORS_NONE;
+    Spectrum.name           = "Spectrum";
+    Spectrum.value          = CHERRY_KB_MODE_SPECTRUM;
+    Spectrum.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Spectrum.speed_min      = CHERRY_KB_SPEED_SLOWEST;
+    Spectrum.speed_max      = CHERRY_KB_SPEED_FASTEST;
+    Spectrum.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
+    Spectrum.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Spectrum.speed          = CHERRY_KB_SPEED_NORMAL;
+    Spectrum.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Spectrum.color_mode     = MODE_COLORS_NONE;
     Spectrum.colors.resize(1);
     modes.push_back(Spectrum);
 
     mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = CHERRY_KB_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Breathing.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Breathing.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Breathing.speed      = CHERRY_KB_SPEED_NORMAL;
-    Breathing.colors_min = 1;
-    Breathing.colors_max = 1;
-    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.name           = "Breathing";
+    Breathing.value          = CHERRY_KB_MODE_BREATHING;
+    Breathing.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Breathing.speed_min      = CHERRY_KB_SPEED_SLOWEST;
+    Breathing.speed_max      = CHERRY_KB_SPEED_FASTEST;
+    Breathing.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
+    Breathing.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Breathing.colors_min     = 1;
+    Breathing.colors_max     = 1;
+    Breathing.speed          = CHERRY_KB_SPEED_NORMAL;
+    Breathing.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Breathing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Breathing.colors.resize(1);
     modes.push_back(Breathing);
 
     mode Static;
-    Static.name       = "Static";
-    Static.value      = CHERRY_KB_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Static.colors_min = 1;
-    Static.colors_max = 1;
-    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Static.name           = "Static";
+    Static.value          = CHERRY_KB_MODE_STATIC;
+    Static.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Static.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
+    Static.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Static.colors_min     = 1;
+    Static.colors_max     = 1;
+    Static.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Static.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Static.colors.resize(1);
     modes.push_back(Static);
 
     mode Radar;
-    Radar.name       = "Radar";
-    Radar.value      = CHERRY_KB_MODE_RADAR;
-    Radar.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Radar.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Radar.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Radar.speed      = CHERRY_KB_SPEED_NORMAL;
-    Radar.colors_min = 1;
-    Radar.colors_max = 1;
-    Radar.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Radar.name           = "Radar";
+    Radar.value          = CHERRY_KB_MODE_RADAR;
+    Radar.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Radar.speed_min      = CHERRY_KB_SPEED_SLOWEST;
+    Radar.speed_max      = CHERRY_KB_SPEED_FASTEST;
+    Radar.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
+    Radar.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Radar.colors_min     = 1;
+    Radar.colors_max     = 1;
+    Radar.speed          = CHERRY_KB_SPEED_NORMAL;
+    Radar.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Radar.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Radar.colors.resize(1);
-    modes.push_back(Radar);
+    if(hasUnofficialModeSupport(product_id))
+        modes.push_back(Radar);
 
     mode Vortex;
-    Vortex.name       = "Vortex";
-    Vortex.value      = CHERRY_KB_MODE_VORTEX;
-    Vortex.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Vortex.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Vortex.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Vortex.speed      = CHERRY_KB_SPEED_NORMAL;
-    Vortex.colors_min = 1;
-    Vortex.colors_max = 1;
-    Vortex.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Vortex.name           = "Vortex";
+    Vortex.value          = CHERRY_KB_MODE_VORTEX;
+    Vortex.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Vortex.speed_min      = CHERRY_KB_SPEED_SLOWEST;
+    Vortex.speed_max      = CHERRY_KB_SPEED_FASTEST;
+    Vortex.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
+    Vortex.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Vortex.colors_min     = 1;
+    Vortex.colors_max     = 1;
+    Vortex.speed          = CHERRY_KB_SPEED_NORMAL;
+    Vortex.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Vortex.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Vortex.colors.resize(1);
-    modes.push_back(Vortex);
+    if(hasUnofficialModeSupport(product_id))
+        modes.push_back(Vortex);
 
     mode Fire;
-    Fire.name       = "Fire";
-    Fire.value      = CHERRY_KB_MODE_FIRE;
-    Fire.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Fire.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Fire.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Fire.speed      = CHERRY_KB_SPEED_NORMAL;
-    Fire.colors_min = 1;
-    Fire.colors_max = 1;
-    Fire.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Fire.name           = "Fire";
+    Fire.value          = CHERRY_KB_MODE_FIRE;
+    Fire.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Fire.speed_min      = CHERRY_KB_SPEED_SLOWEST;
+    Fire.speed_max      = CHERRY_KB_SPEED_FASTEST;
+    Fire.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
+    Fire.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Fire.colors_min     = 1;
+    Fire.colors_max     = 1;
+    Fire.speed          = CHERRY_KB_SPEED_NORMAL;
+    Fire.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Fire.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Fire.colors.resize(1);
-    modes.push_back(Fire);
+    if(hasUnofficialModeSupport(product_id))
+        modes.push_back(Fire);
 
     mode Stars;
-    Stars.name       = "Stars";
-    Stars.value      = CHERRY_KB_MODE_STARS;
-    Stars.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Stars.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Stars.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Stars.speed      = CHERRY_KB_SPEED_NORMAL;
-    Stars.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Stars.name           = "Stars";
+    Stars.value          = CHERRY_KB_MODE_STARS;
+    Stars.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Stars.speed_min      = CHERRY_KB_SPEED_SLOWEST;
+    Stars.speed_max      = CHERRY_KB_SPEED_FASTEST;
+    Stars.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
+    Stars.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Stars.speed          = CHERRY_KB_SPEED_NORMAL;
+    Stars.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Stars.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Stars.colors.resize(1);
-    modes.push_back(Stars);
+    if(hasUnofficialModeSupport(product_id))
+        modes.push_back(Stars);
 
     mode Rain;
-    Rain.name       = "Rain";
-    Rain.value      = CHERRY_KB_MODE_RAIN;
-    Rain.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Rain.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Rain.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Rain.speed      = CHERRY_KB_SPEED_NORMAL;
-    Rain.colors_min = 1;
-    Rain.colors_max = 1;
-    Rain.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Rain.name           = "Rain";
+    Rain.value          = CHERRY_KB_MODE_RAIN;
+    Rain.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Rain.speed_min      = CHERRY_KB_SPEED_SLOWEST;
+    Rain.speed_max      = CHERRY_KB_SPEED_FASTEST;
+    Rain.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
+    Rain.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Rain.colors_min     = 1;
+    Rain.colors_max     = 1;
+    Rain.speed          = CHERRY_KB_SPEED_NORMAL;
+    Rain.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Rain.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Rain.colors.resize(1);
-    modes.push_back(Rain);
+    if(hasUnofficialModeSupport(product_id))
+        modes.push_back(Rain);
 
     mode Rolling;
-    Rolling.name       = "Rolling";
-    Rolling.value      = CHERRY_KB_MODE_ROLLING;
-    Rolling.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-    Rolling.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Rolling.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Rolling.speed      = CHERRY_KB_SPEED_NORMAL;
-    Rolling.color_mode = MODE_COLORS_NONE;
+    Rolling.name           = "Rolling";
+    Rolling.value          = CHERRY_KB_MODE_ROLLING;
+    Rolling.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Rolling.speed_min      = CHERRY_KB_SPEED_SLOWEST;
+    Rolling.speed_max      = CHERRY_KB_SPEED_FASTEST;
+    Rolling.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
+    Rolling.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Rolling.speed          = CHERRY_KB_SPEED_NORMAL;
+    Rolling.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Rolling.color_mode     = MODE_COLORS_NONE;
     modes.push_back(Rolling);
     
     mode Curve;
-    Curve.name       = "Curve";
-    Curve.value      = CHERRY_KB_MODE_CURVE;
-    Curve.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Curve.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Curve.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Curve.speed      = CHERRY_KB_SPEED_NORMAL;
-    Curve.colors_min = 1;
-    Curve.colors_max = 1;
-    Curve.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Curve.name           = "Curve";
+    Curve.value          = CHERRY_KB_MODE_CURVE;
+    Curve.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Curve.speed_min      = CHERRY_KB_SPEED_SLOWEST;
+    Curve.speed_max      = CHERRY_KB_SPEED_FASTEST;
+    Curve.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
+    Curve.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Curve.colors_min     = 1;
+    Curve.colors_max     = 1;
+    Curve.speed          = CHERRY_KB_SPEED_NORMAL;
+    Curve.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Curve.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Curve.colors.resize(1);
     modes.push_back(Curve);
 
     mode WaveMid;
-    WaveMid.name       = "Wave Mid";
-    WaveMid.value      = CHERRY_KB_MODE_WAVE_MID;
-    WaveMid.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    WaveMid.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    WaveMid.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    WaveMid.speed      = CHERRY_KB_SPEED_NORMAL;
-    WaveMid.color_mode = MODE_COLORS_NONE;
+    WaveMid.name           = "Wave Mid";
+    WaveMid.value          = CHERRY_KB_MODE_WAVE_MID;
+    WaveMid.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    WaveMid.speed_min      = CHERRY_KB_SPEED_SLOWEST;
+    WaveMid.speed_max      = CHERRY_KB_SPEED_FASTEST;
+    WaveMid.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
+    WaveMid.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    WaveMid.speed          = CHERRY_KB_SPEED_NORMAL;
+    WaveMid.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    WaveMid.color_mode     = MODE_COLORS_NONE;
     WaveMid.colors.resize(1);
-    modes.push_back(WaveMid);
+    if(hasUnofficialModeSupport(product_id))
+        modes.push_back(WaveMid);
 
     mode Scan;
-    Scan.name       = "Scan";
-    Scan.value      = CHERRY_KB_MODE_SCAN;
-    Scan.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Scan.colors_min = 1;
-    Scan.colors_max = 1;
-    Scan.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Scan.name           = "Scan";
+    Scan.value          = CHERRY_KB_MODE_SCAN;
+    Scan.flags          = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Scan.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
+    Scan.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Scan.colors_min     = 1;
+    Scan.colors_max     = 1;
+    Scan.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Scan.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Scan.colors.resize(1);
     modes.push_back(Scan);
 
     mode Radiation;
-    Radiation.name       = "Radiation";
-    Radiation.value      = CHERRY_KB_MODE_RADIATION;
-    Radiation.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Radiation.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Radiation.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Radiation.speed      = CHERRY_KB_SPEED_NORMAL;
-    Radiation.colors_min = 1;
-    Radiation.colors_max = 1;
-    Radiation.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Radiation.name           = "Radiation";
+    Radiation.value          = CHERRY_KB_MODE_RADIATION;
+    Radiation.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Radiation.speed_min      = CHERRY_KB_SPEED_SLOWEST;
+    Radiation.speed_max      = CHERRY_KB_SPEED_FASTEST;
+    Radiation.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
+    Radiation.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Radiation.colors_min     = 1;
+    Radiation.colors_max     = 1;
+    Radiation.speed          = CHERRY_KB_SPEED_NORMAL;
+    Radiation.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Radiation.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Radiation.colors.resize(1);
     modes.push_back(Radiation);
 
     mode Ripples;
-    Ripples.name       = "Ripples";
-    Ripples.value      = CHERRY_KB_MODE_RIPPLES;
-    Ripples.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Ripples.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    Ripples.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    Ripples.speed      = CHERRY_KB_SPEED_NORMAL;
-    Ripples.colors_min = 1;
-    Ripples.colors_max = 1;
-    Ripples.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Ripples.name           = "Ripples";
+    Ripples.value          = CHERRY_KB_MODE_RIPPLES;
+    Ripples.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Ripples.speed_min      = CHERRY_KB_SPEED_SLOWEST;
+    Ripples.speed_max      = CHERRY_KB_SPEED_FASTEST;
+    Ripples.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
+    Ripples.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Ripples.colors_min     = 1;
+    Ripples.colors_max     = 1;
+    Ripples.speed          = CHERRY_KB_SPEED_NORMAL;
+    Ripples.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    Ripples.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Ripples.colors.resize(1);
     modes.push_back(Ripples);
 
     mode SingleKey;
-    SingleKey.name       = "Single Key";
-    SingleKey.value      = CHERRY_KB_MODE_SINGLE_KEY;
-    SingleKey.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    SingleKey.speed_min  = CHERRY_KB_SPEED_SLOWEST;
-    SingleKey.speed_max  = CHERRY_KB_SPEED_FASTEST;
-    SingleKey.speed      = CHERRY_KB_SPEED_NORMAL;
-    SingleKey.colors_min = 1;
-    SingleKey.colors_max = 1;
-    SingleKey.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    SingleKey.name           = "Single Key";
+    SingleKey.value          = CHERRY_KB_MODE_SINGLE_KEY;
+    SingleKey.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    SingleKey.speed_min      = CHERRY_KB_SPEED_SLOWEST;
+    SingleKey.speed_max      = CHERRY_KB_SPEED_FASTEST;
+    SingleKey.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
+    SingleKey.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    SingleKey.colors_min     = 1;
+    SingleKey.colors_max     = 1;
+    SingleKey.speed          = CHERRY_KB_SPEED_NORMAL;
+    SingleKey.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
+    SingleKey.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     SingleKey.colors.resize(1);
     modes.push_back(SingleKey);
 
@@ -267,17 +330,17 @@ void RGBController_CherryKeyboard::SetupZones()
 
     new_zone.name               = "Keyboard";
     new_zone.type               = ZONE_TYPE_MATRIX;
-    new_zone.leds_min           = 126;
-    new_zone.leds_max           = 126;
-    new_zone.leds_count         = 126;
+    new_zone.leds_min           = CHERRY_MATRIX_CELL_COUNT;
+    new_zone.leds_max           = CHERRY_MATRIX_CELL_COUNT;
+    new_zone.leds_count         = CHERRY_MATRIX_CELL_COUNT;
     new_zone.matrix_map         = new matrix_map_type;
-    new_zone.matrix_map->height = 6;
-    new_zone.matrix_map->width  = 23;
+    new_zone.matrix_map->height = CHERRY_MATRIX_MAP_HEIGHT;
+    new_zone.matrix_map->width  = CHERRY_MATRIX_MAP_WIDTH;
     new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
     
     zones.push_back(new_zone);
 
-    for(int led_idx = 0; led_idx < 126; led_idx++)
+    for(int led_idx = 0; led_idx < CHERRY_MATRIX_CELL_COUNT; led_idx++)
     {
         led new_led;
 
@@ -299,9 +362,9 @@ void RGBController_CherryKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_CherryKeyboard::DeviceUpdateLEDs()
 {
-    unsigned char color_data[7*CHERRY_KB_MAX_PACKET_SIZE];
+    unsigned char color_data[CUSTOM_COLOR_ARRAY_BYTE_COUNT];
 
-    for(int led_idx = 0; led_idx < 126; led_idx++)
+    for(int led_idx = 0; led_idx < CHERRY_MATRIX_CELL_COUNT; led_idx++)
     {
         color_data[(3 * led_idx) + 0] = RGBGetRValue(colors[led_idx]);
         color_data[(3 * led_idx) + 1] = RGBGetGValue(colors[led_idx]);
@@ -311,7 +374,7 @@ void RGBController_CherryKeyboard::DeviceUpdateLEDs()
     controller->SetKeyboardColors
                     (
                     color_data,
-                    CHERRY_KB_MAX_PACKET_SIZE * 7
+                    CUSTOM_COLOR_ARRAY_BYTE_COUNT
                     );
 }
 
@@ -347,7 +410,7 @@ void RGBController_CherryKeyboard::DeviceUpdateMode()
     controller->SendKeyboardModeEx
                     (
                     modes[active_mode].value,
-                    CHERRY_KB_BRIGHTNESS_HIGHEST,
+                    modes[active_mode].brightness,
                     modes[active_mode].speed,
                     0,
                     random,
@@ -356,3 +419,40 @@ void RGBController_CherryKeyboard::DeviceUpdateMode()
                     blu
                     );
 }
+
+bool RGBController_CherryKeyboard::hasUnofficialModeSupport(const uint16_t product_id)
+{
+    switch(product_id)
+    {
+    // no backlight: Why are they even listed here? (no lights, no macros)
+    case MX_BOARD_3_0S_FL_NBL_PID:
+    case G80_3000_TKL_NBL_PID:
+    case MX_1_0_FL_NBL_PID:
+    case G80_3000_TKL_NBL_KOR_PID:
+    case CCF_MX_1_0_TKL_NBL_PID:
+    // white backlight keyboards: very doubtful if any of those RGB modes match
+    case CCF_MX_8_0_TKL_BL_PID:
+    case CCF_MX_1_0_TKL_BL_PID:
+    case MX_1_0_FL_BL_PID:
+        return false;
+    // RGB keyboards known for not supporting unofficial modes
+    case MX_BOARD_3_0S_FL_RGB_PID:
+    case MX_BOARD_3_0S_FL_RGB_KOR_PID:
+    case MX_BOARD_2_0S_FL_RGB_PID:
+    case MX_BOARD_2_0S_FL_NBL_PID:
+    case MX_BOARD_2_0S_FL_RGB_DE_PID:
+    case MV_BOARD_3_0FL_RGB_PID:
+        return false;
+    // RGB keyboards which (probably) support unofficial modes
+    case MX_BOARD_1_0_TKL_RGB_PID: // unknown
+    case MX_BOARD_8_0_TKL_RGB_PID: // unknown
+    case MX_BOARD_10_0_FL_RGB_PID: // unknown (probably yes, related to 10.0N)
+    case G80_3000_TKL_RGB_PID: // unknown
+    case MX_1_0_FL_RGB_PID: // unkown
+    case G80_3000N_TKL_RGB_PID: // yes
+    case G80_3000N_FL_RGB_PID: // firmware v0102: YES, firmware v0103: NO
+    case MX_BOARD_10_0N_FL_RGB_PID: // yes
+    default:
+        return true;
+    }
+}

Controllers/CherryKeyboardController/RGBController_CherryKeyboard.h

@@ -14,7 +14,7 @@
 class RGBController_CherryKeyboard : public RGBController
 {
 public:
-    RGBController_CherryKeyboard(CherryKeyboardController* controller_ptr);
+    RGBController_CherryKeyboard(CherryKeyboardController* controller_ptr, uint16_t product_id);
     ~RGBController_CherryKeyboard();
 
     void        SetupZones();
@@ -30,4 +30,6 @@ public:
 
 private:
     CherryKeyboardController*  controller;
+
+    static bool hasUnofficialModeSupport(uint16_t product_id);
 };

Controllers/ColorfulGPUController/ColorfulGPUController.cpp

@@ -1,5 +1,7 @@
 #include "ColorfulGPUController.h"
 #include <cstring>
+#include "pci_ids.h"
+#include "LogManager.h"
 
 ColorfulGPUController::ColorfulGPUController(i2c_smbus_interface* bus, colorful_gpu_dev_id dev)
 {
@@ -28,17 +30,40 @@ void ColorfulGPUController::SetDirect(RGBColor color)
     uint8_t g = RGBGetGValue(color);
     uint8_t b = RGBGetBValue(color);
 
-    uint8_t data_pkt[COLORFUL_PACKET_LENGTH] = { 0xAA, 0xEF, 0x12, 0x03, 0x01, 0xFF, r, g, b};
-
-    int crc = 0;
-
-    for (int i = 0; i < COLORFUL_PACKET_LENGTH - 2; ++i)
+    if(this->bus->pci_subsystem_device == COLORFUL_IGAME_RTX_4070_VULCAN_OCV)
     {
-        crc += data_pkt[i];
+        uint8_t data_pkt[COLORFUL_PACKET_LENGTH_V2] = { 0xAA, 0xEF, 0x01, 0x04, 0x88, 0x26 };
+        for(int i=6; i < COLORFUL_PACKET_LENGTH_V2 -2; i = i + 3)
+        {
+            data_pkt[i] = r;
+            data_pkt[i+1] = g;
+            data_pkt[i+2] = b;
+        }
+
+        int crc = 0;
+        for(int i = 0; i < COLORFUL_PACKET_LENGTH_V2 - 2; ++i)
+        {
+            crc += data_pkt[i];
+        }
+
+        data_pkt[COLORFUL_PACKET_LENGTH_V2 - 2] = crc & 0xFF;
+        data_pkt[COLORFUL_PACKET_LENGTH_V2 - 1] = crc >> 8;
+
+        bus->i2c_write_block(dev, COLORFUL_PACKET_LENGTH_V2, data_pkt);
     }
+    else
+    {
+        uint8_t data_pkt[COLORFUL_PACKET_LENGTH_V1] = { 0xAA, 0xEF, 0x12, 0x03, 0x01, 0xFF, r, g, b};
 
-    data_pkt[COLORFUL_PACKET_LENGTH - 2] = crc & 0xFF;
-    data_pkt[COLORFUL_PACKET_LENGTH - 1] = crc >> 8;
+        int crc = 0;
+        for(int i = 0; i < COLORFUL_PACKET_LENGTH_V1 - 2; ++i)
+        {
+            crc += data_pkt[i];
+        }
 
-    bus->i2c_write_block(dev, COLORFUL_PACKET_LENGTH, data_pkt);
+        data_pkt[COLORFUL_PACKET_LENGTH_V1 - 2] = crc & 0xFF;
+        data_pkt[COLORFUL_PACKET_LENGTH_V1 - 1] = crc >> 8;
+
+        bus->i2c_write_block(dev, COLORFUL_PACKET_LENGTH_V1, data_pkt);
+    }
 }

Controllers/ColorfulGPUController/ColorfulGPUController.h

@@ -6,7 +6,8 @@
 
 typedef unsigned char colorful_gpu_dev_id;
 
-#define COLORFUL_PACKET_LENGTH 11
+#define COLORFUL_PACKET_LENGTH_V1 11
+#define COLORFUL_PACKET_LENGTH_V2 122
 
 class ColorfulGPUController
 {

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -40,20 +40,26 @@ void DetectColorfulGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
     }
 }
 
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Advanced OC 12G L-V", DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ADVANCED_OC_12G_LV, 0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",  DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,      0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",  DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,    0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V", DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,    0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV,       0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_TI_ADVANCED_OC,     0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV,       0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV2,      0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ultra W OC-V",        DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ULTRAW_OC,          0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ultra W OC LHR",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ULTRAW_OC,          0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ti Ultra W OC LHR",   DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_TI_ULTRAW_OC,       0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ti Advanced OC-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_TI_ADVANCED_OCV2,   0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Ti Advanced OC-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_TI_ADVANCED_OCV2,   0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Ti Advanced OC-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070_TI_ADVANCED_OCV,    0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",        DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV2,        0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV,       0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV2,      0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Advanced OC 12G L-V",  DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ADVANCED_OC_12G_LV, 0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",   DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,      0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",   DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_GA106_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,      0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",   DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,    0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V",  DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,    0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV,       0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_TI_ADVANCED_OC,     0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V",        DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV,       0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V",        DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV2,      0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ultra W OC-V",         DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ULTRAW_OC,          0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ultra W OC LHR",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ULTRAW_OC,          0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ti Ultra W OC LHR",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_TI_ULTRAW_OC,       0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ti Advanced OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_TI_ADVANCED_OCV2,   0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Advanced OC 10G-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_ADVANCED_OC_10G,    0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Ti Advanced OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_TI_ADVANCED_OCV2,   0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Ultra W OC 10G LHR-V", DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_ULTRAW_OC_10G,      0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Ultra W OC 10G LHR-V", DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_ULTRAW_OC_10G_2,    0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Ti Advanced OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070_TI_ADVANCED_OCV,    0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Vulcan OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070_VULCAN_OCV,         0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",         DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV,         0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",         DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV2,        0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",        DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV,       0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",        DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV2,      0x61);

Controllers/CoolerMasterController/CMKeyboardAbstractController.cpp

@@ -0,0 +1,203 @@
+/*-------------------------------------------------------------------*\
+|  CMKeyboardAbstractController.h                                     |
+|                                                                     |
+|  Abstract driver for Coolermaster keyboards                         |
+|                                                                     |
+|  Tam D (too.manyhobbies)      30th Nov 2023                         |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+#include "CMKeyboardAbstractController.h"
+
+CMKeyboardAbstractController::CMKeyboardAbstractController(hid_device* dev_handle, hid_device_info* dev_info)
+{
+    wchar_t tmp[HID_MAX_STR];
+
+    m_pDev                   = dev_handle;
+    m_productId              = dev_info->product_id;
+    m_sLocation              = dev_info->path;
+
+    hid_get_manufacturer_string(m_pDev, tmp, HID_MAX_STR);
+    std::wstring wVendorName = std::wstring(tmp);
+    m_vendorName             = std::string(wVendorName.begin(), wVendorName.end());
+
+    hid_get_product_string(m_pDev, tmp, HID_MAX_STR);
+    std::wstring wDeviceName = std::wstring(tmp);
+    m_deviceName             = std::string(wDeviceName.begin(), wDeviceName.end());
+    m_serialNumber           = m_deviceName;
+
+    bool bNotFound           = true;
+
+    for(uint16_t i = 0; i < COOLERMASTER_KEYBOARD_DEVICE_COUNT; i++)
+    {
+        if(cm_kb_device_list[i]->product_id == m_productId)
+        {
+            bNotFound = false;
+            m_deviceIndex = i;
+            break;
+        }
+    }
+
+    if(bNotFound)
+    {
+        LOG_ERROR("[%s] device capabilities not found. Please creata a new device request.",
+                m_deviceName.c_str());
+    }
+};
+
+CMKeyboardAbstractController::~CMKeyboardAbstractController()
+{
+    if(m_pDev)
+    {
+        hid_close(m_pDev);
+    }
+};
+
+std::string CMKeyboardAbstractController::GetDeviceName()
+{
+    return m_deviceName;
+}
+
+void CMKeyboardAbstractController::SetDeviceName(std::string name)
+{
+    m_deviceName = name;
+}
+
+std::string CMKeyboardAbstractController::GetDeviceVendor()
+{
+    return m_vendorName;
+}
+
+std::string CMKeyboardAbstractController::GetDeviceSerial()
+{
+    return m_serialNumber;
+}
+
+const cm_kb_device* CMKeyboardAbstractController::GetDeviceData()
+{
+    return cm_kb_device_list[m_deviceIndex];
+}
+
+std::string CMKeyboardAbstractController::GetLocation()
+{
+    return m_sLocation;
+}
+
+std::string CMKeyboardAbstractController::GetFirmwareVersion()
+{
+    return m_sFirmwareVersion;
+}
+
+int CMKeyboardAbstractController::GetProductID()
+{
+    return m_productId;
+}
+
+std::vector<uint8_t> CMKeyboardAbstractController::SendCommand(std::vector<uint8_t> buf, uint8_t fill)
+{
+    int status;
+    std::vector<uint8_t> read;
+
+    uint8_t data[CM_KEYBOARD_WRITE_SIZE];
+    memset(data, fill, CM_KEYBOARD_WRITE_SIZE);
+
+    size_t i = 1;
+    for(uint8_t b : buf)
+    {
+        data[i++] = b;
+    }
+
+    std::lock_guard<std::mutex> guard(m_mutexSendCommand);
+    status = hid_write(m_pDev, data, CM_KEYBOARD_WRITE_SIZE);
+
+    if(status < 0)
+    {
+        LOG_ERROR("[%s] SendCommand() failed code %d.", m_deviceName.c_str(), status);
+        return read;
+    }
+
+    memset(data, 0, CM_KEYBOARD_WRITE_SIZE);
+    status = hid_read(m_pDev, data, CM_KEYBOARD_WRITE_SIZE);
+
+    if(status < 0)
+    {
+        LOG_ERROR("[%s] SendCommand() failed code %d.", m_deviceName.c_str(), status);
+        return read;
+    }
+
+    for(i = 0; i < (size_t)status; i++)
+    {
+        read.push_back(data[i]);
+    }
+
+    return read;
+}
+
+/*---------------------------------------------------------*\
+| Enter/leave direct control mode                           |
+\*---------------------------------------------------------*/
+void CMKeyboardAbstractController::SetControlMode(uint8_t modeId)
+{
+    SendCommand({0x41, (uint8_t)modeId});
+};
+
+/*---------------------------------------------------------*\
+| Sets the currently active profile.                        |
+| byte[0] = 0x51 0x00 0x00 0x00                             |
+| byte[4] = profileId                                       |
+| - corresponds to saved keyboard profile i.e. [1-4]        |
+| - 0x05 - Used on MK and CK style keyboards?               |
+\*---------------------------------------------------------*/
+void CMKeyboardAbstractController::SetActiveProfile(uint8_t profileId)
+{
+    SendCommand({0x51, 0x00, 0x00, 0x00, profileId});
+};
+
+uint8_t CMKeyboardAbstractController::GetActiveProfile()
+{
+    std::vector<uint8_t> data = SendCommand({0x52, 0x00});
+
+    if(data.size() > 4)
+    {
+        return (int)data[4];
+    }
+
+    return 0xFF; // error
+}
+
+/*---------------------------------------------------------*\
+| Saves changes in currently used profile.                  |
+| byte[1] = 0x52                                            |
+\*---------------------------------------------------------*/
+void CMKeyboardAbstractController::SaveActiveProfile()
+{
+    SendCommand({0x50, 0x55});
+}
+
+void CMKeyboardAbstractController::SetActiveEffect(uint8_t effectId)
+{
+    SendCommand({0x51, 0x28, 0x00, 0x00, effectId});
+};
+
+void CMKeyboardAbstractController::SaveProfile()
+{
+    SendCommand({0x50, 0x55});
+}
+
+
+uint8_t CMKeyboardAbstractController::GetModeStatus()
+{
+    std::vector<uint8_t> data = SendCommand({0x52, 0x28});
+    return data[4];
+};
+
+std::string CMKeyboardAbstractController::GetHexString(std::vector<uint8_t> buf)
+{
+    std::stringstream hexss;
+
+    for(uint8_t b : buf)
+    {
+        hexss << std::hex << b << " ";
+    }
+
+    return hexss.str();
+}

Controllers/CoolerMasterController/CMKeyboardAbstractController.h

@@ -0,0 +1,122 @@
+/*-------------------------------------------------------------------*\
+|  CMKeyboardAbstractController.h                                     |
+|                                                                     |
+|  Abstract driver for Coolermaster keyboards                         |
+|                                                                     |
+|  Tam D (too.manyhobbies)      30th Nov 2023                         |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+
+#include <cstring>
+#include <stdint.h>
+#include <string>
+#include <sstream>
+#include <map>
+#include <vector>
+
+#include <hidapi/hidapi.h>
+
+#include "CMKeyboardDevices.h"
+#include "KeyboardLayoutManager.h"
+#include "RGBController.h"
+#include "LogManager.h"
+
+
+#define HID_MAX_STR                         255
+#define CM_KEYBOARD_WRITE_SIZE              65
+#define CM_MAX_LEDS                         255
+#define CM_KEYBOARD_TIMEOUT                 50
+#define CM_KEYBOARD_TIMEOUT_SHORT           3
+
+struct cm_keyboard_effect
+{
+    uint8_t  effectId;
+    uint8_t  p1;
+    uint8_t  p2;
+    uint8_t  p3;
+    RGBColor color1;
+    RGBColor color2;
+};
+
+/*---------------------------------------------------------*\
+| byte[0] = 0x41                                            |
+| byte[1] = modeId                                          |
+\*---------------------------------------------------------*/
+enum cm_keyboard_control_mode
+{
+    MODE_FIRMWARE           = 0x00,
+    MODE_EFFECT             = 0x01,
+    MODE_MANUAL_V2          = 0x02,
+    MODE_CUSTOM_PROFILE     = 0x03,
+    MODE_CUSTOM_PROFILE_V2  = 0x05,
+    MODE_DIRECT             = 0x80
+};
+
+class CMKeyboardAbstractController
+{
+public:
+    CMKeyboardAbstractController(hid_device* dev_handle, hid_device_info* dev_info);
+    ~CMKeyboardAbstractController();
+
+    /*---------------------------------------------------------*\
+    | Common USB controller fuctions                            |
+    \*---------------------------------------------------------*/
+    int                 GetProductID();
+    std::string         GetDeviceName();
+    void                SetDeviceName(std::string name);
+    std::string         GetDeviceVendor();
+    std::string         GetDeviceSerial();
+    std::string         GetLocation();
+    std::string         GetFirmwareVersion();
+    const cm_kb_device* GetDeviceData();
+
+    /*---------------------------------------------------------*\
+    | Keyboard Layout Manager support funtions                  |
+    \*---------------------------------------------------------*/
+
+    /*---------------------------------------------------------*\
+    | Common keyboard driver functions                          |
+    \*---------------------------------------------------------*/
+    virtual void        SetControlMode(uint8_t modeId);
+    virtual void        SetActiveProfile(uint8_t profileId);
+    virtual uint8_t     GetActiveProfile();
+    virtual void        SaveActiveProfile();
+    virtual void        SaveProfile();
+    virtual void        SetActiveEffect(uint8_t effectId);
+    virtual uint8_t     GetModeStatus();
+    virtual void        InitializeModes(std::vector<mode> &modes) = 0;
+    virtual KEYBOARD_LAYOUT GetKeyboardLayout() = 0;
+
+    /*---------------------------------------------------------*\
+    | Protocol specific funtions to be implmented               |
+    \*---------------------------------------------------------*/
+    virtual void        SetLeds(std::vector<led> leds, std::vector<RGBColor> colors) = 0;
+    virtual void        SetSingleLED(uint8_t in_led, RGBColor in_color) = 0;
+    virtual void        Initialize() = 0;
+    virtual void        Shutdown() = 0;
+    virtual void        SetLEDControl(bool bManual) = 0; // FW or SW control
+    virtual void        SetCustomMode() = 0;
+    virtual void        SetMode(mode selectedMode) = 0;
+
+protected:
+    /*---------------------------------------------------------*\
+    | Utility functions.                                        |
+    \*---------------------------------------------------------*/
+    std::vector<std::uint8_t> SendCommand(std::vector<uint8_t> buf, uint8_t fill=0x00);
+    std::string         GetHexString(std::vector<uint8_t> buf);
+    std::string         m_sFirmwareVersion;
+    std::string         m_deviceName;
+    hid_device*         m_pDev;
+    uint16_t            m_productId;
+    uint16_t            m_deviceIndex;
+    std::string         m_vendorName;
+    std::string         m_sLocation;
+    std::string         m_serialNumber;
+    KEYBOARD_LAYOUT     m_keyboardLayout;
+    std::map<int, int>  mapModeValueEffect;
+    std::mutex          m_mutex;
+    std::mutex          m_mutexSendCommand;
+};
+

Controllers/CoolerMasterController/CMKeyboardDevices.cpp

@@ -0,0 +1,768 @@
+/*-------------------------------------------------------------------*\
+|  CMKeyboardDevices.cpp                                              |
+|                                                                     |
+|  Keymap definitions for Cooler Master Keyboards                     |
+|                                                                     |
+|  Tam D (too.manyhobbies)      30th Nov 2023                         |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+#include "CMKeyboardDevices.h"
+
+/*-------------------------------------------------------------------------*\
+|  Coolermaster Key Values                                                  |
+\*-------------------------------------------------------------------------*/
+
+const std::vector<unsigned int> mk_pro_s_keymap =
+{
+/*  ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK        */
+	96,   97,   98,   99,   104,  105,  106,  112,  113,  114,  67,   68,   69,   102,  103,  107,
+/*  BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  */
+	0,    1,    8,    9,    16,   17,   24,   25,   32,   33,   40,   41,   48,   49,   56,   57,   64,
+/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  */
+	2,    3,    10,   11,   18,   19,   26,   27,   34,   35,   42,   43,   50,   51,   58,   59,   66,
+/*  CPLK  A     S     D     F     G     H     J     K     L     ;     "     #     ENTR                    */
+	4,    5,    12,   13,   20,   21,   28,   29,   36,   37,   44,   45,   89,   52,
+/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /     RSFT              ARWU        */
+	6,    100,  7,    14,   15,   22,   23,   30,   31,   38,   39,   46,   47,               61,
+/*  LCTL  LWIN  LALT              SPC               RALT  RFNC  RMNU  RCTL              ARWL  ARWD  ARWR  */
+	91,   90,   92,               93,               94,   60,   95,   54,               63,   62,   70,
+};
+
+const std::vector<unsigned int> mk_pro_l_keymap =
+{
+/*  ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK        P1    P2    P3    P4   */
+	11,   22,   30,   25,   27,   7,    51,   57,   62,   86,   87,   83,   85,   79,   72,   0,
+/*	BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI */
+	14,   15,   23,   31,   39,   38,   46,   47,   55,   63,   71,   70,   54,   81,   3,    1,    2,    100,  108,  116,  118,
+/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  NM7   NM8   NM9   NMPL */
+	9,    8,    16,   24,   32,   33,   41,   40,   48,   56,   64,   65,   49,   82,   94,   92,   88,   96,   104,  112,  110,
+/*  CPLK    A   S     D     F     G     H     J     K     L     ;     '     \     ENTR                    NM4   NM5   NM6        */
+	17,   10,   18,   26,   34,   35,   43,   42,   50,   58,   66,   67,   68,   84,                     97,   105,  113,
+/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /     RSFT              ARWU        NM1   NM2   NM3   NMER */
+	73,   19,   12,   20,   28,   36,   37,   45,   44,   52,   60,   69,   74,               80,         98,   106,  114,  111,
+/*  LCTL  LWIN  LALT              SPACE             RALT  RWFNC RMNU  RCTRL             ARWL  ARDN  ARWR  NM0         NMPD       */
+	6,    90,   75,               91,               77,   78,   61,   4,                95,   93,   5,    107,        115,
+};
+
+const std::vector<unsigned int> mk850_keymap =
+{
+/*        ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK        AIM   AIMU   AIMD */
+	      6,    27,   34,   41,   48,   62,   69,   76,   83,   90,   97,   104,  111,  118,  125,  132,
+/*	M1    BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI */
+	      7,    21,   28,   35,   42,   49,   56,   63,   70,   77,   84,   91,   98,   112,  119,  126,  133,  254,  147,  154,  161,
+/*  M2    TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  NM7   NM8   NM9   NMPL */
+	      8,    22,   29,   36,   43,   50,   57,   64,   71,   78,   85,   92,   99,   113,  120,  127,  134,  141,  148,  155,  162,
+/*  M3    CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR                    NM4   NM5   NM6        */
+	      9,    23,   30,   37,   44,   51,   58,   65,   72,   79,   86,   93,   0,    114,                    142,  149,  156,
+/*  M4    LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /     RSFT              ARWU        NM1   NM2   NM3   NMER */
+	      10,   0,    24,   31,   38,   45,   52,   59,   66,   73,   80,   87,   115,              129,        143,  150,  157,  164,
+/*  M5    LCTL  LWIN  LALT              SPACE             RALT  RWFNC RMNU  RCTRL             ARWL  ARDN  ARWR  NM0         NMPD       */
+	      11,   18,   25,               53,               81,   88,   95,   116,              123,  130,  137,  144,        158,
+};
+
+/*-------------------------------------------------------------*\
+| CoolerMaster SK (60%)                                         |
+\*-------------------------------------------------------------*/
+const std::vector<unsigned int> sk622_keymap =
+{
+/*	T1    T2    T3    T4    T5    T6    T7    T8    T9    T10   T11   T12   T13   T14   T15        */
+/*	L1    ESC   1     2     3     4     5     6     7     8     9     0     -     =     BPSC        R1  */
+	   	  8,    15,   22,   29,   36,   43,   50,   57,   64,   71,   78,   85,   92,   106,
+/*  L2    TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]                 R2  */
+	  	  9,    23,   30,   37,   44,   51,   58,   65,   72,   79,   86,   93,   100,
+/*  L3    CPLK  A     S     D     F     G     H     J     K     L     ;     "     \     ENTR        R3  */
+	  	  10,   24,   31,   38,   45,   52,   59,   66,   73,   80,   87,   94,   101,  108,
+/*  L4    LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     #     RSFT  ARWU   DEL  R$  */
+	      11,   18,   25,   32,   39,   46,   53,   60,   67,   74,   81,   88,   95,   102,   109,
+/*  L5    LCTL  LWIN  LALT              SPACE                         RALT  RWFNC ARWL  ARDN  ARWR  R5  */
+	  	  12,   19,   26,               54,                           82,   89,   96,   103,   110,
+/*  B1    B2    B3    B4    B5    B6    B7    B8    B9    B10   B11   B12   B13   B14   B15    B15      */
+};
+
+const std::vector<unsigned int> sk630_keymap =
+{
+/*  ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK        */
+	9,    33,   41,   49,   57,    73,   81,   89,   97,  105,  113,  121,  129,  137,  145,  153,
+/*  BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  */
+	10,   26,   34,   42,   50,   58,   66,   74,   82,   90,   98,  106,   114,  130,  138,  146,  154,
+/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  */
+	11,   27,   35,   43,   51,   59,   67,   75,   83,   91,   99,  107,   115,  131,  139,  147,  155,
+/*  CPLK  A     S     D     F     G     H     J     K     L     ;     "     #     ENTR                    */
+	12,   28,   36,   44,   52,   60,   68,   76,   84,   92,  100,  108,   116,  132,
+/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /     RSFT              ARWU        */
+	13,   21,   29,   37,   45,   53,   61,   69,   77,   85,   93,  101,   133,              149,
+/*  LCTL  LWIN  LALT              SPC               RALT  RFNC  RMNU  RCTL              ARWL  ARWD  ARWR  */
+	14,   22,   30,               62,               94,  102,  110,   134,              142,  150,  158,
+};
+
+const std::vector<unsigned int> sk650_keymap =
+{
+/*  ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK                               */
+	0,    24,   32,   40,   48,   64,   72,   80,   88,   96,   104,  112,  120,  128,  136,  144,
+/*	BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI */
+	1,    17,   25,   33,   41,   49,   57,   65,   73,   81,   89,   97,   105,  121,  129,  137,  145,  153,  161,  169,  177,
+/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  NM7   NM8   NM9   NMPL */
+	2,    18,   26,   34,   42,   50,   58,   66,   74,   82,   90,   98,   106,  122,  130,  138,  146,  154,  162,  170,  178,
+/*  CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR                    NM4   NM5   NM6        */
+	3,    19,   27,   35,   43,   51,   59,   67,   75,   83,   91,   99,   107,  123,                    155,  163,  171,
+/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /           RSFT        ARWU        NM1   NM2   NM3   NMER */
+	4,    20,   28,   36,   44,   52,   60,   68,   76,   84,   92,   100,        124,        140,        156,  164,  172,  180,
+/*  LCTL  LWIN  LALT              SPACE             RALT  RWFNC RMNU  RCTRL             ARWL  ARDN  ARWR        NM0   NMPD       */
+	5,    13,   21,               53,                     85,   93,   101,        125,  133,  141,  149,        165,  173,
+};
+
+const std::vector<unsigned int> sk652_keymap =
+{
+
+/*  ESC         F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK                         */
+    9,          33,   41,   49,   57,   73,   81,   89,   97,   105,  113,  121,  129,  137,  145,  153,
+/*  BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI */
+    10,   26,   34,   42,   50,   58,   66,   74,   82,   90,   98,   106,  114,  130,  138,  146,  154,  162,  170,  178,  186,
+/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  NM7   NM8   NM9   NMPL */
+    11,   27,   35,   43,   51,   59,   67,   75,   83,   91,   99,   107,  115,  131,  139,  147,  155,  163,  171,  179,  187,
+/*  CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR                    NM4   NM5   NM6        */
+    12,   28,   36,   44,   52,   60,   68,   76,   84,   92,   100,  108,  116,  132,                    164,  172,  180,
+/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /           RSFT        ARWU        NM1   NM2   NM3   NMER */
+    13,   21,   29,   37,   45,   53,   61,   69,   77,   85,   93,   101,        133,        149,        165,  173,  181,  189,
+/*  LCTL  LWIN  LALT              SPACE                         RALT  RWFNC RMNU  RCTRL ARWL  ARDN  ARWR        NM0   NMPD       */
+    14,   22,   30,               62,                           94,   102,  110,  134,  142,  150,  158,        174,  182,
+};
+
+const std::vector<unsigned int> sk653_keymap =
+{
+/*  ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK                               */
+	0,    24,   32,   40,   48,   64,   72,   80,   88,   96,   104,  112,  120,  128,  136,  144,
+/*	BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI */
+	1,    17,   25,   33,   41,   49,   57,   65,   73,   81,   89,   97,   105,  121,  129,  137,  145,  153,  161,  169,  177,
+/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  NM7   NM8   NM9   NMPL */
+	2,    18,   26,   34,   42,   50,   58,   66,   74,   82,   90,   98,   106,  122,  130,  138,  146,  154,  162,  170,  178,
+/*  CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR                    NM4   NM5   NM6        */
+	3,    19,   27,   35,   43,   51,   59,   67,   75,   83,   91,   99,   107,  123,                    155,  163,  171,
+/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /           RSFT        ARWU        NM1   NM2   NM3   NMER */
+	4,    20,   28,   36,   44,   52,   60,   68,   76,   84,   92,   100,        124,        140,        156,  164,  172,  180,
+/*  LCTL  LWIN  LALT              SPACE             RALT  RWFNC RMNU  RCTRL             ARWL  ARDN  ARWR        NM0   NMPD       */
+	5,    13,   21,               53,                     85,   93,   101,        125,  133,  141,  149,        165,  173,
+};
+
+const std::vector<unsigned int> mk730_keymap =
+{
+/*      ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK            */
+        7,    28,   35,   42,   49,   63,   70,   77,   84,   91,   98,   105,  112,   119,  126,  133,
+/*	L1  BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  R1  */
+	    8,    22,   29,   36,   43,   50,   57,   64,   71,   78,   85,   92,   99,    113,  120,  127,  134,
+/*  L2  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  R2  */
+	    9,    23,   30,   37,   44,   51,   58,   65,   72,   79,   86,   93,   100,   114,  121,  128,  135,
+/*  L3  CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR                    R3  */
+	    10,   24,   31,   38,   45,   52,   59,   66,   73,   80,   87,   94,   108,   115,
+/*  L4  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /           RSFT        ARWU        R4  */
+	    11,   18,   25,   32,   39,   46,   53,   60,   67,   74,   81,   88,          116,       130,
+/*      LCTL  LWIN  LALT              SPACE             RALT  RWFNC RMNU  RCTRL             ARWL  ARDN  ARWR      */
+	    12,   19,   26,               54,               82,   89,   96,   117,               124, 131,  138,
+/*      B1    B2    B3    B4    B5    B6    B7    B8    B9    B10   B11   B12   B12                          */
+};
+
+const std::vector<unsigned int> mk750_keymap =
+{
+/*      ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK  MUT   PLA   REW   FFWD            */
+        7,    28,   35,   42,   49,   63,   70,   77,   84,   91,   98,   105,  112,  119,  136,  133,
+/*	L1  BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI  R1  */
+	    8,    22,   29,   36,   43,   50,   57,   64,   71,   78,   85,   92,   99,   113,  120,  127,  134,    0,  148,  155,  162,
+/*  L2  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  NM7   NM8   NM9   NMPL  R2  */
+	    9,    23,   30,   37,   44,   51,   58,   65,   72,   79,   86,   93,   100,  114,  121,  128,  135,  142,  149,  156,  163,
+/*  L3  CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR                    NM4   NM5   NM6         R3  */
+	    10,   24,   31,   38,   45,   52,   59,   66,   73,   80,   87,   94,   108,  115,                    143,  150,  157,
+/*  L4  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /           RSFT        ARWU        NM1   NM2   NM3   NMER  R4  */
+	    11,   18,   25,   32,   39,   46,   53,   60,   67,   74,   81,   88,         116,        130,        144,  151,  158,  165,
+/*      LCTL  LWIN  LALT              SPACE             RALT  RWFNC RMNU  RCTRL             ARWL  ARDN  ARWR        NM0   NMPD            */
+	    12,   19,   26,               54,               82,   89,   96,   117,              124,  131,  138,        152,  159,
+/*      B1    B2    B3    B4    B5    B6    B7    B8    B9    B10   B11   B12   B12   B13   B14   B15   B16  B17  B18                     */
+};
+
+
+const std::vector<unsigned int> ck530_keymap =
+{
+/*  ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK        */
+    6,    21,   27,   34,   41,   55,   62,   69,   76,   83,   90,   97,   104,  111,  118,  125,
+/*  BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  */
+    7,    15,   22,   28,   35,   42,   49,   56,   63,   70,   77,   84,   91,   105,  112,  119,  126,
+/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  */
+    8,    16,   23,   29,   36,   43,   50,   57,   64,   71,   78,   85,   92,   106,  113,  120,  127,
+/*  CPLK  A     S     D     F     G     H     J     K     L     ;     "     #     ENTR                    */
+    9,    17,   24,   30,   37,   44,   51,   58,   65,   72,   79,   86,   93,   107,
+/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /           RSFT        ARWU        */
+    10,   18,   25,   31,   38,   45,   52,   59,   66,   73,   80,   87,         108,        122,
+/*  LCTL  LWIN  LALT              SPC                     RALT  RFNC  RMNU  RCTL        ARWL  ARWD  ARWR  */
+    11,   12,   19,               46,                    74,   81,    88,  109,         116,  123,  130,
+};
+
+const std::vector<unsigned int> ck550_v2_keymap =
+{
+/*  ESC         F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK                         */
+	0,          18,   24,   30,   36,   48,   54,   60,   66,   72,   78,   84,   90,   96,   102,  108,
+/*	BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI */
+	1,    13,   19,   25,   31,   37,   43,   49,   55,   61,   67,   73,   79,   91,   97,   103,  109,  115,  121,  127,  133,
+/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  NM7   NM8   NM9   NMPL */
+    2,    14,   20,   26,   32,   38,   44,   50,   56,   62,   68,   74,   80,   92,   98,   104,  110,  116,  122,  128,  134,
+/*  CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR                    NM4   NM5   NM6        */
+    3,    15,   21,   27,   33,   39,   45,   51,   57,   63,   69,   75,   87,   93,                     117,  123,  129,
+/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /           RSFT        ARWU        NM1   NM2   NM3   NMER */
+    4,    10,   16,   22,   28,   34,   40,   46,   52,   58,   64,   70,/*76,*/  94,         106,        118,  124,  130,  136,
+/*  LCTL  LWIN  LALT              SPACE                   RALT  RWFNC RMNU        RCTRL  ARWL ARDN  ARWR        NM0   NMPD       */
+    5,    11,   17,               41,                     65,   71,   77,         95,    101, 107,  113,        125,  131,
+};
+
+const std::vector<unsigned int> ck552_keymap =
+{
+/*  ESC         F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK                         */
+	0,          18,   24,   30,   36,   48,   54,   60,   66,   72,   78,   84,   90,   96,   102,  108,
+/*	BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI */
+	1,    13,   19,   25,   31,   37,   43,   49,   55,   61,   67,   73,   79,   91,   97,   103,  109,  115,  121,  127,  133,
+/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  NM7   NM8   NM9   NMPL */
+    2,    14,   20,   26,   32,   38,   44,   50,   56,   62,   68,   74,   80,   92,   98,   104,  110,  116,  122,  128,  134,
+/*  CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR                    NM4   NM5   NM6        */
+    3,    15,   21,   27,   33,   39,   45,   51,   57,   63,   69,   75,   81,   93,                     117,  123,  129,
+/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /           RSFT        ARWU        NM1   NM2   NM3   NMER */
+    4,    10,   16,   22,   28,   34,   40,   46,   52,   58,   64,   70,/*76,*/  94,         106,        118,  124,  130,  136,
+/*  LCTL  LWIN  LALT              SPACE                   RALT  RWFNC RMNU        RCTRL  ARWL ARDN  ARWR        NM0   NMPD       */
+    5,    11,   17,               41,                     65,   71,   77,         95,    101, 107,  113,        125,  131,
+};
+
+/*-------------------------------------------------------------------------*\
+|  KEYMAPS                                                                  |
+\*-------------------------------------------------------------------------*/
+keyboard_keymap_overlay_values mk_pro_s_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_TKL,
+    {
+        mk_pro_s_keymap,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+    },
+};
+
+keyboard_keymap_overlay_values mk_pro_l_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
+    {
+        mk_pro_l_keymap,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Name,       Translated Name,    OpCode,                         |
+        \*---------------------------------------------------------------------------------------------------------*/
+        {   0,      0,      17,         101,        "Key: P1",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      18,         109,        "Key: P2",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      19,         117,        "Key: P3",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      20,         119,        "Key: P4",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+    },
+};
+
+/*-------------------------------------------------------------*\
+| CoolerMaster MK85O Keyboard                                   |
+| Unknown Keys: ISO\, ISO# set to 0                             |
+\*-------------------------------------------------------------*/
+keyboard_keymap_overlay_values mk850_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
+    {
+        mk850_keymap,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Name,           Translated Name,    OpCode,                     |
+        \*---------------------------------------------------------------------------------------------------------*/
+        {   0,      0,      17,       146,          "Key: Aim <|>", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // aimpad <|>
+        {   0,      0,      18,       153,          "Key: Aim -",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // aimpad +
+        {   0,      0,      19,       160,          "Key: Aim +",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // aimpad -
+        {   0,      1,       0,         0,          "Key: M5",      KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      2,       0,         1,          "Key: M4",      KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      3,       0,         2,          "Key: M3",      KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      4,       0,         3,          "Key: M2",      KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      5,       0,         4,          "Key: M1",      KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+    },
+};
+
+keyboard_keymap_overlay_values sk622_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_SIXTY,
+    {
+        sk622_keymap,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Name,               Translated Name,    OpCode,                 |
+        \*---------------------------------------------------------------------------------------------------------*/
+        {   0,      0,      0,          7,          "Light: Top 1",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_ROW, },
+        {   0,      0,      1,         14,          "Light: Top 2",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      2,         21,          "Light: Top 3",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      3,         28,          "Light: Top 4",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      4,         35,          "Light: Top 5",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      5,         42,          "Light: Top 6",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      6,         49,          "Light: Top 7",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      7,         56,          "Light: Top 8",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      8,         63,          "Light: Top 9",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      9,         70,          "Light: Top 10",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      10,        77,          "Light: Top 11",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      11,        84,          "Light: Top 12",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      12,        91,          "Light: Top 13",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      13,        98,          "Light: Top 14",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      14,       105,          "Light: Top 14",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      1,      0,          0,          "Light: Left 1",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      2,      0,          1,          "Light: Left 2",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      3,      0,          2,          "Light: Left 3",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      4,      0,          3,          "Light: Left 4",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      5,      0,          4,          "Light: Left 5",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      1,      16,       112,          "Light: Right 1",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      2,      16,       113,          "Light: Right 2",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      3,      16,       114,          "Light: Right 3",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      4,      16,       115,          "Light: Right 4",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      5,      16,       116,          "Light: Right 5",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       0,         6,          "Light: Bottom 1",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_ROW, },
+        {   0,      6,       1,        20,          "Light: Bottom 2",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       2,        27,          "Light: Bottom 3",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       3,        34,          "Light: Bottom 4",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       4,        41,          "Light: Bottom 5",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       5,        48,          "Light: Bottom 6",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       6,        55,          "Light: Bottom 7",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       7,        62,          "Light: Bottom 8",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       8,        69,          "Light: Bottom 9",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       9,        76,          "Light: Bottom 10", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       10,       83,          "Light: Bottom 11", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       11,       90,          "Light: Bottom 12", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       12,       97,          "Light: Bottom 13", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       13,      104,          "Light: Bottom 14", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       14,      111,          "Light: Bottom 15", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       14,      118,          "Light: Bottom 16", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+    },
+};
+
+keyboard_keymap_overlay_values sk630_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_TKL,
+    {
+        sk630_keymap,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+    }
+};
+
+keyboard_keymap_overlay_values sk650_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
+    {
+        sk650_keymap,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+    }
+};
+
+keyboard_keymap_overlay_values sk652_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
+    {
+        sk652_keymap,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+    }
+};
+
+keyboard_keymap_overlay_values sk653_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
+    {
+        sk653_keymap,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+    }
+};
+
+/*-------------------------------------------------------------*\
+| CoolerMaster MK730 Keyboard                                   |
+\*-------------------------------------------------------------*/
+keyboard_keymap_overlay_values mk730_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_TKL,
+    {
+        mk730_keymap,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Name,               Translated Name,    OpCode,                 |
+        \*---------------------------------------------------------------------------------------------------------*/
+        {   0,      1,      0,          1,          "Light: Left 1",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      2,      0,          2,          "Light: Left 2",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      3,      0,          3,          "Light: Left 3",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      4,      0,          4,          "Light: Left 4",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      1,      18,       141,          "Light: Right 1",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      2,      18,       142,          "Light: Right 2",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      3,      18,       143,          "Light: Right 3",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      4,      18,       144,          "Light: Right 4",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       1,        13,          "Light: Bottom 1",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_ROW, },
+        {   0,      6,       2,        20,          "Light: Bottom 2",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       3,        27,          "Light: Bottom 3",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       4,        34,          "Light: Bottom 4",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       5,        41,          "Light: Bottom 5",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       6,        55,          "Light: Bottom 6",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       7,        62,          "Light: Bottom 7",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       8,        69,          "Light: Logo",      KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      10,        76,          "Light: Bottom 8",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      11,        90,          "Light: Bottom 9",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      12,       104,          "Light: Bottom 10", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      13,       111,          "Light: Bottom 11", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      14,       118,          "Light: Bottom 12", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      15,       125,          "Light: Bottom 13", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+    }
+};
+
+/*-------------------------------------------------------------*\
+| CoolerMaster MK750 Keyboard                                   |
+| based on keymap defined in Signal.                            |
+| The keymap needs the following adjustments                    |
+| NMLK - Unknown set to 0                                       |
+| SCLK - Unknown set to 0                                       |
+| CAPS - Unknown set to 0                                       |
+| Guesses on ISO\ and #                                         |
+\*-------------------------------------------------------------*/
+keyboard_keymap_overlay_values mk750_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
+    {
+        mk750_keymap,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Name,                       Translated Name,    OpCode,         |
+        \*---------------------------------------------------------------------------------------------------------*/
+        {   0,      0,      17,       140,          KEY_EN_MEDIA_MUTE,          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      18,       147,          KEY_EN_MEDIA_PLAY_PAUSE,    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      19,       154,          KEY_EN_MEDIA_PREVIOUS,      KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      20,       161,          KEY_EN_MEDIA_NEXT,          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      1,      0,          1,          "Light: Left 1",            KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      2,      0,          2,          "Light: Left 2",            KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      3,      0,          3,          "Light: Left 3",            KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      4,      0,          4,          "Light: Left 4",            KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      1,      22,       170,          "Light: Right 1",           KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      2,      22,       171,          "Light: Right 2",           KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      3,      22,       172,          "Light: Right 3",           KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      4,      22,       173,          "Light: Right 4",           KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       1,        20,          "Light: Bottom 1",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_ROW, },
+        {   0,      6,       2,        27,          "Light: Bottom 2",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       3,        34,          "Light: Bottom 3",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       4,        41,          "Light: Bottom 4",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       5,        55,          "Light: Bottom 5",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       6,        62,          "Light: Bottom 6",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       7,        69,          "Light: Bottom 7",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       8,        76,          "Light: Bottom 8",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       9,        83,          "Light: Bottom 9",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      10,        90,          "Light: Bottom 10",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      11,       104,          "Light: Bottom 11",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      12,       111,          "Light: Bottom 12",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      13,       118,          "Light: Bottom 13",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      14,       125,          "Light: Bottom 14",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      15,       132,          "Light: Bottom 15",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      16,       146,          "Light: Bottom 16",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      17,       153,          "Light: Bottom 17",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      18,       160,          "Light: Bottom 18",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+    }
+};
+
+keyboard_keymap_overlay_values ck530_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_TKL,
+    {
+        ck530_keymap,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+    }
+};
+
+keyboard_keymap_overlay_values ck550v2_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
+    {
+        ck550_v2_keymap,
+        {
+            {
+                /* Add more regional layout fixes here */
+                /*---------------------------------------------------------------------------------------------------------*\
+                | Edit Keys                                                                                                 |
+                |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+                \*---------------------------------------------------------------------------------------------------------*/
+            },
+        },
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Name,           Translated Name,    OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+        {   0,      0,      17,        120,         "Indicator: N", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      18,        126,         "Indicator: C", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      19,        132,         "Indicator: S", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+    },
+};
+
+keyboard_keymap_overlay_values ck552_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
+    {
+        ck552_keymap,
+        {
+            {
+                /* Add more regional layout fixes here */
+                /*---------------------------------------------------------------------------------------------------------*\
+                | Edit Keys                                                                                                 |
+                |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+                \*---------------------------------------------------------------------------------------------------------*/
+            },
+        },
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+    },
+};
+
+static const cm_kb_zone cm_generic_zone =
+{
+    ZONE_EN_KEYBOARD,
+    ZONE_TYPE_MATRIX,
+};
+
+cm_kb_device mk_pro_s_device
+{
+    COOLERMASTER_KEYBOARD_PRO_S_PID,
+    {
+        &cm_generic_zone,
+    },
+    &mk_pro_s_layout,
+};
+
+cm_kb_device mk_pro_l_device
+{
+    COOLERMASTER_KEYBOARD_PRO_L_PID,
+    {
+        &cm_generic_zone,
+    },
+    &mk_pro_l_layout,
+};
+
+cm_kb_device mk850_device
+{
+    COOLERMASTER_KEYBOARD_MK850_PID,
+    {
+        &cm_generic_zone,
+    },
+    &mk850_layout,
+};
+
+cm_kb_device sk622w_device
+{
+    COOLERMASTER_KEYBOARD_SK622W_PID,
+    {
+        &cm_generic_zone,
+    },
+    &sk622_layout,
+};
+
+cm_kb_device sk622b_device
+{
+    COOLERMASTER_KEYBOARD_SK622B_PID,
+    {
+        &cm_generic_zone,
+    },
+    &sk622_layout,
+};
+
+cm_kb_device sk630_device
+{
+    COOLERMASTER_KEYBOARD_SK630_PID,
+    {
+        &cm_generic_zone,
+    },
+    &sk630_layout,
+};
+
+cm_kb_device sk650_device
+{
+    COOLERMASTER_KEYBOARD_SK650_PID,
+    {
+        &cm_generic_zone,
+    },
+    &sk650_layout,
+};
+
+cm_kb_device sk652_device
+{
+    COOLERMASTER_KEYBOARD_SK652_PID,
+    {
+        &cm_generic_zone,
+    },
+    &sk652_layout,
+};
+
+cm_kb_device sk653_device
+{
+    COOLERMASTER_KEYBOARD_SK653_PID,
+    {
+        &cm_generic_zone,
+    },
+    &sk652_layout,
+};
+
+/*---------------------------------------------------------*\
+| TODO: Keymap is incomplete. Extra keys mode enabled to    |
+| aid in key discovery.                                     |
+\*---------------------------------------------------------*/
+cm_kb_device mk730_device
+{
+    COOLERMASTER_KEYBOARD_MK730_PID,
+    {
+        &cm_generic_zone,
+    },
+    &mk730_layout,
+};
+
+cm_kb_device mk750_device
+{
+    COOLERMASTER_KEYBOARD_MK750_PID,
+    {
+        &cm_generic_zone,
+    },
+    &mk750_layout,
+};
+
+cm_kb_device ck530_device
+{
+    COOLERMASTER_KEYBOARD_CK530_PID,
+    {
+        &cm_generic_zone,
+    },
+    &ck530_layout,
+};
+
+cm_kb_device ck530_v2_device
+{
+    COOLERMASTER_KEYBOARD_CK530_V2_PID,
+    {
+        &cm_generic_zone,
+    },
+    &ck530_layout,
+};
+
+cm_kb_device ck550_v2_device
+{
+    COOLERMASTER_KEYBOARD_CK550_V2_PID,
+    {
+        &cm_generic_zone,
+    },
+    &ck550v2_layout,
+};
+
+cm_kb_device ck552_v2_device
+{
+    COOLERMASTER_KEYBOARD_CK552_V2_PID,
+    {
+        &cm_generic_zone,
+    },
+    &ck552_layout,
+};
+
+cm_kb_device mk_pro_l_white_device
+{
+    COOLERMASTER_KEYBOARD_PRO_L_WHITE_PID,
+    {
+        &cm_generic_zone,
+    },
+    &mk_pro_s_layout,
+};
+
+/*-----------------------------------------------------------------*\
+|  KEYBOARDS                                                        |
+\*-----------------------------------------------------------------*/
+const cm_kb_device* cm_kb_devices[] =
+{
+    &mk_pro_s_device,
+    &mk_pro_l_device,
+    &mk850_device,
+    &sk622w_device,
+    &sk622b_device,
+    &sk630_device,
+    &sk650_device,
+    &sk652_device,
+    &sk653_device,
+    &mk730_device,
+    &mk750_device,
+    &ck530_device,
+    &ck530_v2_device,
+    &ck550_v2_device,
+    &ck552_v2_device,
+    &mk_pro_l_white_device,
+};
+
+const unsigned int COOLERMASTER_KEYBOARD_DEVICE_COUNT = (sizeof(cm_kb_devices) / sizeof(cm_kb_devices[ 0 ]));
+const cm_kb_device** cm_kb_device_list = cm_kb_devices;

Controllers/CoolerMasterController/CMKeyboardDevices.h

@@ -0,0 +1,120 @@
+/*-------------------------------------------------------------------*\
+|  CMKeyboardDevices.h                                                |
+|                                                                     |
+|  Keymap definitions for Cooler Master Keyboards                     |
+|                                                                     |
+|  Tam D (too.manyhobbies)      30th Nov 2023                         |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+#pragma once
+
+#include "RGBController.h"
+#include "KeyboardLayoutManager.h"
+
+/*-----------------------------------------------------*\
+| List of all supported effects by this controller.     |
+| All of these effects are firmware controlled, and     |
+| they types of effects supported will depend on the    |
+| Keyboard.                                             |
+|                                                       |
+| To enable a command, the SetEffect(effectId) needs    |
+| to be called. The specific effectId->Effect mapping   |
+| depends on the keyboard.                              |
+\*-----------------------------------------------------*/
+enum cm_keyboard_effect_type
+{
+    NONE = 0,
+    DIRECT,
+    SINGLE,
+    FULLY_LIT,
+    STATIC,
+    BREATHE,
+    CYCLE,
+    WAVE,
+    RIPPLE,
+    CROSS,
+    RAINDROPS,
+    STARS,
+    SNAKE,
+    CUSTOMIZED,
+    INDICATOR,
+    MULTILAYER,
+    REACTIVE_FADE,
+    REACTIVE_PUNCH,
+    REACTIVE_TORNADO,
+    HEARTBEAT,
+    FIREBALL,
+    SNOW,
+    CIRCLE_SPECTRUM,
+    WATER_RIPPLE,
+    OFF
+};
+
+#define CM_KB_ZONES_MAX 1
+
+typedef struct
+{
+    std::string                     name;
+    zone_type                       type;
+} cm_kb_zone;
+
+typedef struct
+{
+    uint16_t                        product_id;
+    const cm_kb_zone *              zones[CM_KB_ZONES_MAX];
+    keyboard_keymap_overlay_values* layout_new;
+} cm_kb_device;
+
+#define COOLERMASTER_VID    0x2516
+
+#define CMKB_MAXKEYS        256
+
+/*-----------------------------------------------------------------*\
+| keyboard support status is indicated to the right of              |
+| the PID definition. Attribution to products is also               |
+| indicated.                                                        |
+|                                                                   |
+| libcmmk                                                           |
+| signal    https://gitlab.com/signalrgb/signal-plugins             |
+| openrgb                                                           |
+| ck550-macos https://github.com/vookimedlo/ck550-macos/tree/master |
+| reversed                                                          |
+|                                                                   |
+| issue tickets, open merge requests etc are provided               |
+| for developer references.                                         |
+| # denotes issue ticket                                            |
+| ! denotes merge/pull request                                      |
+\*-----------------------------------------------------------------*/
+#define COOLERMASTER_KEYBOARD_CK351_PID           0x014F // unsupported
+#define COOLERMASTER_KEYBOARD_CK530_PID           0x009F // [ck550-macos]
+#define COOLERMASTER_KEYBOARD_CK530_V2_PID        0x0147 // [signal]
+#define COOLERMASTER_KEYBOARD_CK550_V2_PID        0x0145 // [openrgb #800, #2863, signal]
+#define COOLERMASTER_KEYBOARD_CK552_V2_PID        0x007F // [ck550-macos, signal]
+#define COOLERMASTER_KEYBOARD_CK570_V2_PID        0x01E8 // unsupported
+#define COOLERMASTER_KEYBOARD_CK720_PID           0x016B // unsupported
+#define COOLERMASTER_KEYBOARD_CK721_PID           0x016D // unsupported
+#define COOLERMASTER_KEYBOARD_CK721LINE_PID       0x01EE // unsupported
+#define COOLERMASTER_KEYBOARD_PRO_L_PID           0x003B // [libcmmk !16]
+#define COOLERMASTER_KEYBOARD_PRO_L_WHITE_PID     0x0047 // [libcmmk]
+#define COOLERMASTER_KEYBOARD_PRO_S_PID           0x003C // [libcmmk #30 !31 !36, !37, !7, #5(closed), #3(closed)]
+// MASTERKEYS PRO M [libcmmk #17]
+#define COOLERMASTER_KEYBOARD_MK721_PID           0x016F // unsupported
+#define COOLERMASTER_KEYBOARD_MK730_PID           0x008F // [openrgb #1630, libcmmk]
+#define COOLERMASTER_KEYBOARD_MK750_PID           0x0067 // fw1.2 [libcmmk #25 !9, !14, signal]
+#define COOLERMASTER_KEYBOARD_MK770_PID           0x01D5 // unsupported
+#define COOLERMASTER_KEYBOARD_MK850_PID           0x0069 // [signal]
+#define COOLERMASTER_KEYBOARD_SK620B_PID          0x0157 // unsupported
+#define COOLERMASTER_KEYBOARD_SK620W_PID          0x0159 // [signal]
+#define COOLERMASTER_KEYBOARD_SK622B_PID          0x0149 // [openrgb #3110, signal #217(closed)]
+#define COOLERMASTER_KEYBOARD_SK622W_PID          0x014B // [signal]
+#define COOLERMASTER_KEYBOARD_SK630_PID           0x0089 // [openrgb #967, libcmmk !21]
+#define COOLERMASTER_KEYBOARD_SK631B_PID          0x008B // unsupported
+#define COOLERMASTER_KEYBOARD_SK631W_PID          0x0125 // [libcmmk]
+#define COOLERMASTER_KEYBOARD_SK650_PID           0x008D // [openrgb #613, libcmmk #23 !37 !27 !28, signal]
+#define COOLERMASTER_KEYBOARD_SK651B_PID          0x0091 // unsupported
+#define COOLERMASTER_KEYBOARD_SK651W_PID          0x0127 // [signal]
+#define COOLERMASTER_KEYBOARD_SK652_PID           0x015D // [signal]
+#define COOLERMASTER_KEYBOARD_SK653_PID           0x01AB // [openrgb #3571, signal]
+
+extern const unsigned int COOLERMASTER_KEYBOARD_DEVICE_COUNT;
+extern const cm_kb_device** cm_kb_device_list;

Controllers/CoolerMasterController/CMKeyboardV1Controller.cpp

@@ -0,0 +1,497 @@
+/*-------------------------------------------------------------------*\
+|  CMKeyboardV1Controller.cpp                                         |
+|                                                                     |
+|  Driver for Coolermaster MasterKeys keyboards (V1)                  |
+|                                                                     |
+|  Tam D (too.manyhobbies)      30th Nov 2023                         |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+#include "CMKeyboardV1Controller.h"
+#include "LogManager.h"
+#include <cmath>
+
+CMKeyboardV1Controller::CMKeyboardV1Controller(hid_device* dev_handle, hid_device_info* dev_info) : CMKeyboardAbstractController(dev_handle, dev_info)
+{
+    m_sFirmwareVersion = _GetFirmwareVersion();
+}
+
+CMKeyboardV1Controller::~CMKeyboardV1Controller()
+{
+}
+
+void CMKeyboardV1Controller::Initialize()
+{
+    SetLEDControl(true);
+}
+
+void CMKeyboardV1Controller::SetActiveEffect(uint8_t effectId)
+{
+    SendCommand({0x51, 0x28, 0x00, 0x00, effectId});
+}
+
+uint8_t CMKeyboardV1Controller::GetActiveEffect()
+{
+    std::vector<uint8_t> data = SendCommand({0x52, 0x28});
+
+    return data[4];
+}
+
+void CMKeyboardV1Controller::SetEffect(uint8_t effectId, uint8_t p1, uint8_t p2, uint8_t p3, RGBColor color1, RGBColor color2)
+{
+    std::vector<uint8_t> data;
+
+    data.push_back(0x51);
+    data.push_back(0x2C);
+    data.push_back(0x00); // multilayer_mode - NOT SUPPORTED
+    data.push_back(0x00);
+    data.push_back(effectId);
+    data.push_back(p1);
+    data.push_back(p2);
+    data.push_back(p3);
+    data.push_back(0xFF);
+    data.push_back(0xFF);
+    data.push_back(RGBGetRValue(color1));
+    data.push_back(RGBGetGValue(color1));
+    data.push_back(RGBGetBValue(color1));
+    data.push_back(RGBGetRValue(color2));
+    data.push_back(RGBGetGValue(color2));
+    data.push_back(RGBGetBValue(color2));
+
+    /*-------------------------------------------*\
+    | Likely a bit mask for each LEDs.            |
+    | 3 bits per LED x 127 possible LEDs ~48 bytes|
+    \*-------------------------------------------*/
+    for(size_t i = 0; i < 48; i++)
+    {
+        data.push_back(0xFF);
+    }
+
+    SetCustomMode();
+    SetActiveEffect(effectId);
+    SendCommand(data);
+}
+
+void CMKeyboardV1Controller::SetCustomMode()
+{
+    SetControlMode(0x01);
+}
+
+void CMKeyboardV1Controller::SetMode(mode selectedMode)
+{
+    RGBColor color1     = 0;
+    RGBColor color2     = 0;
+    uint8_t cSpeed      = 0;
+    uint8_t cDirection  = 0;
+    uint8_t effectId    = selectedMode.value;
+    bool bModeRandom    = false;
+
+    if(selectedMode.colors.size() >= 1)
+    {
+        color1 = selectedMode.colors[0];
+    }
+
+    if(selectedMode.colors.size() >= 2)
+    {
+        color2 = selectedMode.colors[1];
+    }
+
+    if(selectedMode.color_mode == MODE_COLORS_RANDOM)
+    {
+        bModeRandom = true;
+    }
+
+    int selectedEffect = mapModeValueEffect[effectId];
+    cSpeed = selectedMode.speed;
+
+    switch(selectedMode.direction)
+    {
+        case MODE_DIRECTION_LEFT:
+        case MODE_DIRECTION_HORIZONTAL:
+        cDirection = 0x00;
+        break;
+
+        case MODE_DIRECTION_RIGHT:
+        cDirection = 0x04;
+        break;
+
+        case MODE_DIRECTION_UP:
+        case MODE_DIRECTION_VERTICAL:
+        cDirection = 0x06;
+        break;
+
+        case MODE_DIRECTION_DOWN:
+        cDirection = 0x02;
+        break;
+
+        default:
+        break;
+    }
+
+    switch(selectedEffect)
+    {
+        case DIRECT:
+        case STATIC:
+        {
+            SetEffect(effectId, 0, 0, 0, color1, color2);
+        }
+        break;
+
+        case CROSS:
+        case BREATHE:
+        case REACTIVE_PUNCH:
+        case CIRCLE_SPECTRUM:
+        case SNAKE:
+        {
+            SetEffect(effectId, cSpeed, 0, 0xFF, color1, color2);
+        }
+        break;
+
+        case WAVE:
+        {
+            SetEffect(effectId, cSpeed, cDirection, 0xFF, color1, color2);
+        }
+        break;
+
+        case RIPPLE:
+        {
+            SetEffect(effectId, cSpeed, bModeRandom ? 0x80 : 0x00, 0xFF, color1, color2);
+        }
+        break;
+
+        case RAINDROPS:
+        {
+            SetEffect(effectId, 0x6a, 0x00, cSpeed, color1, color2);
+        }
+        break;
+
+        case STARS:
+        {
+            SetEffect(effectId, cSpeed, 0x00, 0x10, color1, color2);
+        }
+        break;
+
+        default:
+        break;
+    }
+}
+
+void CMKeyboardV1Controller::InitializeModes(std::vector<mode> &modes)
+{
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = 0x02;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+
+    modes.push_back(Direct);
+
+    mapModeValueEffect[0x02]    = DIRECT;
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = 0x00;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+    mapModeValueEffect[0x00]    = STATIC;
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = 0x01;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed_min         = 0x46;
+    Breathing.speed_max         = 0x27;
+    Breathing.speed             = 0x36;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 1;
+    Breathing.colors.resize(1);
+    modes.push_back(Breathing);
+    mapModeValueEffect[0x01]    = BREATHE;
+
+    mode Cycle;
+    Cycle.name                  = "Spectrum Cycle";
+    Cycle.value                 = 0x02;
+    Cycle.flags                 = MODE_FLAG_HAS_SPEED;
+    Cycle.color_mode            = MODE_COLORS_NONE;
+    Cycle.speed_min             = 0x96;
+    Cycle.speed_max             = 0x68;
+    Cycle.speed                 = 0x7F;
+    modes.push_back(Cycle);
+    mapModeValueEffect[0x02]    = CIRCLE_SPECTRUM;
+
+    mode Reactive;
+    Reactive.name               = "Reactive";
+    Reactive.value              = 0x03;
+    Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    Reactive.speed_min          = 0x3C;
+    Reactive.speed_max          = 0x2F;
+    Reactive.speed              = 0x35;
+    Reactive.colors_min         = 2;
+    Reactive.colors_max         = 2;
+    Reactive.colors.resize(2);
+    modes.push_back(Reactive);
+    mapModeValueEffect[0x03]    = REACTIVE_PUNCH;
+
+    mode Wave;
+    Wave.name                   = "Rainbow Wave";
+    Wave.value                  = 0x04;
+    Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
+    Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Wave.speed_min              = 0x48;
+    Wave.speed_max              = 0x2A;
+    Wave.speed                  = 0x29;
+    Wave.direction              = MODE_DIRECTION_LEFT;
+    Wave.colors_min             = 1;
+    Wave.colors_max             = 1;
+    Wave.colors.resize(1);
+    modes.push_back(Wave);
+    mapModeValueEffect[0x04]    = WAVE;
+
+    mode Ripple;
+    Ripple.name                 = "Ripple Effect";
+    Ripple.value                = 0x05;
+    Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
+    Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Ripple.speed_min            = 0x96;
+    Ripple.speed_max            = 0x62;
+    Ripple.speed                = 0x7C;
+    Ripple.colors_min           = 2;
+    Ripple.colors_max           = 2;
+    Ripple.colors.resize(2);
+    modes.push_back(Ripple);
+    mapModeValueEffect[0x05]    = RIPPLE;
+
+    mode Cross;
+    Cross.name                  = "Cross";
+    Cross.value                 = 0x06;
+    Cross.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Cross.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Cross.speed_min             = 0x2A;
+    Cross.speed_max             = 0x48;
+    Cross.speed                 = 0x39;
+    Cross.colors_min            = 2;
+    Cross.colors_max            = 2;
+    Cross.colors.resize(2);
+    modes.push_back(Cross);
+    mapModeValueEffect[0x06]    = CROSS;
+
+    mode Raindrops;
+    Raindrops.name              = "Raindrops";
+    Raindrops.value             = 0x07;
+    Raindrops.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Raindrops.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Raindrops.speed_min         = 0x40;
+    Raindrops.speed_max         = 0x08;
+    Raindrops.speed             = 0x24;
+    Raindrops.colors_min        = 2;
+    Raindrops.colors_max        = 2;
+    Raindrops.colors.resize(2);
+    modes.push_back(Raindrops);
+    mapModeValueEffect[0x07]    = RAINDROPS;
+
+    mode Stars;
+    Stars.name                  = "Starfield";
+    Stars.value                 = 0x08;
+    Stars.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Stars.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Stars.speed_min             = 0x46;
+    Stars.speed_max             = 0x32;
+    Stars.speed                 = 0x3C;
+    Stars.colors_min            = 2;
+    Stars.colors_max = 2;
+    Stars.colors.resize(2);
+    modes.push_back(Stars);
+    mapModeValueEffect[0x08]    = STARS;
+
+    mode Snake;
+    Snake.name                  = "Snake";
+    Snake.value                 = 0x09;
+    Snake.flags                 = MODE_FLAG_HAS_SPEED;
+    Snake.color_mode            = MODE_COLORS_NONE;
+    Snake.speed_min             = 0x48;
+    Snake.speed_max             = 0x2A;
+    Snake.speed                 = 0x39;
+    modes.push_back(Snake);
+    mapModeValueEffect[0x09]    = SNAKE;
+}
+
+struct cm_keyboard_effect CMKeyboardV1Controller::GetEffect(uint8_t effectId)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0x52);
+    data.push_back(0x2C);
+    data.push_back(0x00);
+    data.push_back(0x00);
+    data.push_back(effectId);
+
+    data = SendCommand(data);
+    struct cm_keyboard_effect response;
+
+    response.effectId   = effectId;
+    response.p1         = data[5];
+    response.p2         = data[6];
+    response.p3         = data[7];
+    response.color1     = ToRGBColor(data[10], data[11], data[12]);
+    response.color2     = ToRGBColor(data[13], data[14], data[15]);
+
+    return response;
+}
+
+std::vector<uint8_t> CMKeyboardV1Controller::GetEnabledEffects()
+{
+    std::vector<uint8_t> data;
+
+    data = SendCommand({0x52, 0x29});
+
+    std::vector<uint8_t> effects;
+
+    for(size_t i = 4; data[i] != 0xFF; i++)
+    {
+        effects.push_back(data[i]);
+    }
+
+    return effects;
+}
+
+
+void CMKeyboardV1Controller::SetLEDControl(bool bManual)
+{
+    uint8_t modeId = 0; // firmware
+
+    if(bManual)
+    {
+        modeId = 0x02;  // manual
+    }
+
+    SetControlMode(modeId);
+};
+
+void CMKeyboardV1Controller::SetLeds(std::vector<led> leds, std::vector<RGBColor> colors)
+{
+    SetLEDControl(true);
+
+    RGBColor rgbColorMap[CM_MAX_LEDS];
+    memset(rgbColorMap, 0, sizeof(RGBColor)*CM_MAX_LEDS);
+
+    for(size_t i = 0; i < leds.size(); i++)
+    {
+        rgbColorMap[leds[i].value] = colors[i];
+    }
+
+    RGBColor * pRGBColor = rgbColorMap;
+
+    std::lock_guard<std::mutex> guard(m_mutex);
+
+    for(size_t i = 0; i < 8; i++)
+    {
+        std::vector<uint8_t> data;
+        data.push_back(0xC0);
+        data.push_back(0x02);
+        data.push_back(i*2);
+        data.push_back(0x00);
+
+        for(size_t j = 0; j < 16; j++)
+        {
+            data.push_back(RGBGetRValue(*pRGBColor));
+            data.push_back(RGBGetGValue(*pRGBColor));
+            data.push_back(RGBGetBValue(*pRGBColor));
+
+            ++pRGBColor;
+        }
+
+        SendCommand(data);
+    }
+}
+
+void CMKeyboardV1Controller::SetSingleLED(uint8_t in_led, RGBColor in_color)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0xC0);
+    data.push_back(0x01);
+    data.push_back(0x01);
+    data.push_back(0x00);
+    data.push_back(in_led);
+    data.push_back(RGBGetRValue(in_color));
+    data.push_back(RGBGetGValue(in_color));
+    data.push_back(RGBGetBValue(in_color));
+
+    SendCommand(data);
+}
+
+/*-------------------------------------------------------------------*\
+| Detect the Firmware Version                                         |
+|                                                                     |
+|  Firmware version string is in the format:                          |
+|    <layout>.<minor>.<major>                                         |
+|  Where <layout> is:                                                 |
+|   UNK = 0, ANSI/US = 1, ISO/EU = 2, JP = 3                          |
+|  Examples:                                                          |
+|  1.2.1 = ANSI/US Keyboard (PRO S)                                   |
+|  2.2.1 = ISO/EU Keyboard (PRO L)                                    |
+\*-------------------------------------------------------------------*/
+std::string CMKeyboardV1Controller::_GetFirmwareVersion()
+{
+    std::vector<uint8_t> read;
+
+    SetControlMode(MODE_FIRMWARE);
+    read = SendCommand({0x01, 0x02});
+
+    char cVersionStr[CM_KEYBOARD_WRITE_SIZE];
+
+    for(size_t i = 0; i < read.size(); i++)
+    {
+        cVersionStr[i] = read[i];
+    }
+
+    cVersionStr[CM_KEYBOARD_WRITE_SIZE - 1] = 0;
+
+    std::string sFirmwareVersion;
+
+    sFirmwareVersion = std::string(cVersionStr+4);
+
+    LOG_VERBOSE("[%s] GetFirmwareVersion(): [%s]", m_deviceName.c_str(), sFirmwareVersion.c_str());
+
+    return sFirmwareVersion;
+}
+
+void CMKeyboardV1Controller::Shutdown()
+{
+
+}
+
+KEYBOARD_LAYOUT CMKeyboardV1Controller::GetKeyboardLayout()
+{
+    KEYBOARD_LAYOUT layout = KEYBOARD_LAYOUT_DEFAULT;
+
+    if(m_sFirmwareVersion.empty())
+    {
+        LOG_WARNING("[%s] GetKeyboardLayout() empty firmware string detected. Unable to detect firmware layout. Assuming defaults.", m_deviceName.c_str());
+
+        layout = KEYBOARD_LAYOUT_ANSI_QWERTY;
+        return layout;
+    }
+
+    switch(m_sFirmwareVersion.c_str()[0])
+    {
+        case '0':
+        default:
+        case '1':
+        layout = KEYBOARD_LAYOUT_ANSI_QWERTY;
+        break;
+
+        case '2':
+        layout = KEYBOARD_LAYOUT_ISO_QWERTY;
+        break;
+
+        case '3':
+        layout = KEYBOARD_LAYOUT_JIS;
+        break;
+    }
+
+    return layout;
+}

Controllers/CoolerMasterController/CMKeyboardV1Controller.h

@@ -0,0 +1,39 @@
+/*-------------------------------------------------------------------*\
+|  CMKeyboardV1Controller.h                                           |
+|                                                                     |
+|  Driver for Coolermaster MasterKeys keyboards (V1)                  |
+|                                                                     |
+|  Tam D (too.manyhobbies)      30th Nov 2023                         |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+#include "CMKeyboardAbstractController.h"
+
+class CMKeyboardV1Controller : public CMKeyboardAbstractController
+{
+public:
+    CMKeyboardV1Controller(hid_device* dev_handle, hid_device_info* dev_info);
+    ~CMKeyboardV1Controller();
+
+    /*---------------------------------------------------------*\
+    | Protocol specific funtions to be implmented               |
+    \*---------------------------------------------------------*/
+    void                        SetLeds(std::vector<led> leds, std::vector<RGBColor> colors);
+    void                        SetSingleLED(uint8_t in_led, RGBColor in_color);
+    void                        Initialize();
+    void                        Shutdown();
+    void                        SetLEDControl(bool bManual);
+
+    void                        SetActiveEffect(uint8_t effectId);
+    uint8_t                     GetActiveEffect();
+    void                        SetEffect(uint8_t effectId, uint8_t p1, uint8_t p2, uint8_t p3, RGBColor color1, RGBColor color2);
+    struct cm_keyboard_effect   GetEffect(uint8_t effectId);
+    void                        SetCustomMode();
+    void                        SetMode(mode selectedMode);
+    std::vector<uint8_t>        GetEnabledEffects();
+    void                        InitializeModes(std::vector<mode> &modes);
+    KEYBOARD_LAYOUT             GetKeyboardLayout();
+
+private:
+    std::string                 _GetFirmwareVersion();
+
+};

Controllers/CoolerMasterController/CMKeyboardV2Controller.h

@@ -0,0 +1,54 @@
+/*-------------------------------------------------------------------*\
+|  CMKeyboardV2Controller.h                                           |
+|                                                                     |
+|  Driver for Coolermaster V2                                         |
+|                                                                     |
+|  Tam D (too.manyhobbies)      30th Nov 2023                         |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+#include "CMKeyboardAbstractController.h"
+
+struct stCMKeyboardV2_mode
+{
+    const char      *name;
+    unsigned int    value;
+    unsigned int    speed_min;
+    unsigned int    speed_max;
+    unsigned int    speed;
+    unsigned int    brightness;
+    unsigned int    direction;
+    unsigned int    nColors;
+    unsigned int    color_mode;
+    unsigned int    flags;
+};
+
+class CMKeyboardV2Controller : public CMKeyboardAbstractController
+{
+public:
+    CMKeyboardV2Controller(hid_device* dev_handle, hid_device_info* dev_info);
+    ~CMKeyboardV2Controller();
+
+    /*---------------------------------------------------------*\
+    | Protocol specific funtions to be implmented               |
+    \*---------------------------------------------------------*/
+    void            SetLeds(std::vector<led> leds, std::vector<RGBColor> colors);
+    void            SetSingleLED(uint8_t in_led, RGBColor in_color);
+    void            Initialize();
+    void            Shutdown();
+    void            SetLEDControl(bool bManual);
+    void            SendApplyPacket(uint8_t mode);
+    void            MagicStartupPacket();
+    void            MagicCommand(uint8_t profileId);
+    void            SetCustomMode();
+    void            SetMode(mode selectedMode);
+    void            SetEffect(uint8_t effectId, uint8_t p1, uint8_t p2, uint8_t p3, RGBColor color1, RGBColor color2);
+    void            InitializeModes(std::vector<mode> &modes);
+    KEYBOARD_LAYOUT GetKeyboardLayout();
+
+private:
+    void            _SetEffectMode(uint8_t effectId);
+    void            _UpdateSpeed(mode selectedMode, uint8_t &cSpeed1, uint8_t &cSpeed2);
+    std::string     _GetFirmwareVersion();
+
+    bool            m_bMoreFFs;
+};

Controllers/CoolerMasterController/CMMKController.cpp

@@ -1,320 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  CMMKController.cpp                                                 |
-|                                                                     |
-|  Lukas N (chmod222)          28th Jun 2020                          |
-|  Tam D (too.manyhobbies)     25th Apr 2021                          |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#include "CMMKController.h"
-
-CMMKController::CMMKController(hid_device* dev, hid_device_info* dev_info)
-{
-    location            =  dev_info->path;
-
-    const int szTemp    = 256;
-    wchar_t tmpName[szTemp];
-
-    hid_get_manufacturer_string(dev, tmpName, szTemp);
-    std::wstring wName  = std::wstring(tmpName);
-    vendor_name         = std::string(wName.begin(), wName.end());
-
-    hid_get_product_string(dev, tmpName, szTemp);
-    wName  = std::wstring(tmpName);
-    device_name         = std::string(wName.begin(), wName.end());
-
-    cmmk_attach_path(&cmmk_handle, dev_info->path, dev_info->product_id, -1);
-
-    char buf[32] = {0};
-    cmmk_get_firmware_version(&cmmk_handle, buf, 32);
-    firmware_version = std::string(buf);
-
-    enum cmmk_product_type kb_type = cmmk_get_device_model(&cmmk_handle);
-
-    switch(kb_type)
-    {
-        case CMMK_PRODUCT_MASTERKEYS_PRO_S:
-        case CMMK_PRODUCT_MASTERKEYS_SK630:
-            kb_size = KEYBOARD_SIZE_TKL;
-            row_count = CMMK_ROWS_MAX - 1;
-            column_count = CMMK_COLS_MAX - 4;
-            break;
-
-        case CMMK_PRODUCT_MASTERKEYS_PRO_L:
-        case CMMK_PRODUCT_MASTERKEYS_SK650:
-            kb_size = KEYBOARD_SIZE_FULL;
-            row_count = CMMK_ROWS_MAX - 1;
-            column_count = CMMK_COLS_MAX;
-            break;
-
-        case CMMK_PRODUCT_MASTERKEYS_MK750:
-        default:
-            kb_size = KEYBOARD_SIZE_FULL;
-            row_count = CMMK_ROWS_MAX;
-            column_count = CMMK_COLS_MAX;
-    }
-
-    /*--------------------------------------------------------------*\
-    | Detect the keyboard version and set the appropriate layout.    |
-    \*--------------------------------------------------------------*/
-
-    switch(firmware_version[0])
-    {
-        case '1':
-            kb_layout_type = KEYBOARD_LAYOUT_ANSI_QWERTY;
-            break;
-
-        /*--------------------------------------------------------------*\
-        | In case we need to handle different versions in the future.    |
-        \*--------------------------------------------------------------*/
-        default:
-            kb_layout_type = KEYBOARD_LAYOUT_ISO_QWERTY;
-            break;
-    }
-
-    /*--------------------------------------------------------------*\
-    | Populate key offsets.                                          |
-    \*--------------------------------------------------------------*/
-    keyboard_layout*    kb_layout;
-    if(KEYBOARD_LAYOUT_ANSI_QWERTY == kb_layout_type)
-    {
-        switch (kb_type)
-        {
-            case CMMK_PRODUCT_MASTERKEYS_PRO_L:
-                kb_layout = &layout_ansi_pro_l;
-                break;
-            case CMMK_PRODUCT_MASTERKEYS_PRO_S:
-                kb_layout = &layout_ansi_pro_s;
-                break;
-            case CMMK_PRODUCT_MASTERKEYS_MK750:
-                kb_layout = &layout_ansi_mk750;
-                break;
-            case CMMK_PRODUCT_MASTERKEYS_SK630:
-                kb_layout = &layout_ansi_sk630;
-                break;
-            case CMMK_PRODUCT_MASTERKEYS_SK650:
-                kb_layout = &layout_ansi_sk650;
-                break;
-
-            default:
-                kb_layout = 0;
-                break;
-        }
-    }
-    else
-    {
-        switch (kb_type)
-        {
-            case CMMK_PRODUCT_MASTERKEYS_PRO_L:
-                kb_layout = &layout_iso_pro_l;
-                break;
-            case CMMK_PRODUCT_MASTERKEYS_PRO_S:
-                kb_layout = &layout_iso_pro_s;
-                break;
-            case CMMK_PRODUCT_MASTERKEYS_MK750:
-                kb_layout = &layout_iso_mk750;
-                break;
-            case CMMK_PRODUCT_MASTERKEYS_SK630:
-                kb_layout = &layout_iso_sk630;
-                break;
-            case CMMK_PRODUCT_MASTERKEYS_SK650:
-                kb_layout = &layout_iso_sk650;
-                break;
-
-            default:
-                kb_layout = 0;
-                break;
-        }
-    }
-
-    std::vector<int> keys_fn, keys_main, keys_num, keys_extra;
-
-    memset(&kb_transform, -1, row_count*column_count);
-
-    int key_idx = 0;
-    if(kb_layout)
-    {
-        for(int row = 0; row < row_count; row++)
-        {
-            for(int col = 0; col < column_count; col++)
-            {
-                int val = (*kb_layout)[row][col];
-
-                if (-1 != val)
-                {
-                    kb_offsets.ansi.push_back(val);
-                    kb_transform[row][col] = key_idx;
-                    key_idx++;
-                }
-            }
-        }
-    }
-}
-
-CMMKController::~CMMKController()
-{
-    cmmk_detach(&cmmk_handle);
-}
-
-std::string CMMKController::GetDeviceName()
-{
-    return device_name;
-}
-
-std::string CMMKController::GetDeviceVendor()
-{
-    return vendor_name;
-}
-
-std::string CMMKController::GetLocation()
-{
-    return location;
-}
-
-std::string CMMKController::GetFirmwareVersion()
-{
-    return firmware_version;
-}
-
-uint8_t CMMKController::GetRowCount()
-{
-    return row_count;
-}
-
-uint8_t CMMKController::GetColumnCount()
-{
-    return column_count;
-}
-
-KEYBOARD_LAYOUT CMMKController::GetLayout()
-{
-    return kb_layout_type;
-}
-
-keyboard_layout * CMMKController::GetTransform()
-{
-    return &kb_transform;
-}
-
-KEYBOARD_SIZE CMMKController::GetSize()
-{
-    return kb_size;
-}
-
-layout_values CMMKController::GetLayoutValues()
-{
-    return kb_offsets;
-}
-
-void CMMKController::SetFirmwareControl()
-{
-    ActivateMode(CMMK_FIRMWARE);
-}
-
-void CMMKController::SetManualControl()
-{
-    ActivateMode(CMMK_MANUAL);
-}
-
-void CMMKController::SetSingle(int row, int col, struct rgb color)
-{
-    cmmk_set_single_key(&cmmk_handle, row, col, &color);
-}
-
-void CMMKController::SetAll(struct cmmk_color_matrix const& colors)
-{
-    cmmk_set_leds(&cmmk_handle, &colors);
-}
-
-void CMMKController::SetAllSingle(struct rgb color)
-{
-    cmmk_set_all_single(&cmmk_handle, &color);
-}
-
-void CMMKController::SetMode(cmmk_effect_fully_lit eff)
-{
-    ActivateEffect(CMMK_EFFECT_FULLY_LIT);
-    cmmk_set_effect_fully_lit(&cmmk_handle, &eff);
-}
-
-void CMMKController::SetMode(cmmk_effect_breathe eff)
-{
-    ActivateEffect(CMMK_EFFECT_BREATHE);
-    cmmk_set_effect_breathe(&cmmk_handle, &eff);
-}
-
-void CMMKController::SetMode(cmmk_effect_cycle eff)
-{
-    ActivateEffect(CMMK_EFFECT_CYCLE);
-    cmmk_set_effect_cycle(&cmmk_handle, &eff);
-}
-
-void CMMKController::SetMode(cmmk_effect_single eff)
-{
-    ActivateEffect(CMMK_EFFECT_SINGLE);
-    cmmk_set_effect_single(&cmmk_handle, &eff);
-}
-
-void CMMKController::SetMode(cmmk_effect_wave eff)
-{
-    ActivateEffect(CMMK_EFFECT_WAVE);
-    cmmk_set_effect_wave(&cmmk_handle, &eff);
-}
-
-void CMMKController::SetMode(cmmk_effect_ripple eff)
-{
-    ActivateEffect(CMMK_EFFECT_RIPPLE);
-    cmmk_set_effect_ripple(&cmmk_handle, &eff);
-}
-
-void CMMKController::SetMode(cmmk_effect_cross eff)
-{
-    ActivateEffect(CMMK_EFFECT_CROSS);
-    cmmk_set_effect_cross(&cmmk_handle, &eff);
-}
-
-void CMMKController::SetMode(cmmk_effect_raindrops eff)
-{
-    ActivateEffect(CMMK_EFFECT_RAINDROPS);
-    cmmk_set_effect_raindrops(&cmmk_handle, &eff);
-}
-
-void CMMKController::SetMode(cmmk_effect_stars eff)
-{
-    ActivateEffect(CMMK_EFFECT_STARS);
-    cmmk_set_effect_stars(&cmmk_handle, &eff);
-}
-
-void CMMKController::SetMode(cmmk_effect_snake eff)
-{
-    ActivateEffect(CMMK_EFFECT_SNAKE);
-    cmmk_set_effect_snake(&cmmk_handle, &eff);
-}
-
-bool CMMKController::PositionValid(int y, int x)
-{
-    return(cmmk_lookup_key_id(&cmmk_handle, y, x) >= 0);
-}
-
-void CMMKController::ActivateMode(int mode)
-{
-    if (current_mode != mode)
-    {
-        cmmk_set_control_mode(&cmmk_handle, mode);
-
-        current_mode = mode;
-        current_effect = -1;
-    }
-}
-
-void CMMKController::ActivateEffect(int effect)
-{
-    ActivateMode(CMMK_EFFECT);
-
-    if (current_effect != effect)
-    {
-        cmmk_set_active_effect(&cmmk_handle, (enum cmmk_effect_id)effect);
-
-        current_effect = effect;
-    }
-}

Controllers/CoolerMasterController/CMMKController.h

@@ -1,97 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  CMMKController.h                                                   |
-|                                                                     |
-|  Driver for Coolermaster MasterKeys keyboards                       |
-|                                                                     |
-|  Lukas N (chmod222)       28th Jun 2020                             |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#include <cstring>
-#include <KeyboardLayoutManager.h>
-#include <hidapi/hidapi.h>
-#include <libcmmk/libcmmk.h>
-
-typedef int16_t keyboard_layout[CMMK_ROWS_MAX][CMMK_COLS_MAX];
-
-/*---------------------------------------------------------*\
-| i'm not thrilled with the include path, but this will     |
-| work for now. fixing this would need to happen in libcmmk |
-\*---------------------------------------------------------*/
-#pragma GCC push
-#pragma GCC diagnostic ignored "-Wunused-variable"
-#include <ansi/pro_s.h>
-#include <ansi/pro_l.h>
-#include <ansi/mk750.h>
-#include <ansi/sk630.h>
-#include <ansi/sk650.h>
-#include <iso/pro_s.h>
-#include <iso/pro_l.h>
-#include <iso/mk750.h>
-#include <iso/sk630.h>
-#include <iso/sk650.h>
-#pragma GCC pop
-
-#pragma once
-
-class CMMKController
-{
-public:
-    CMMKController(hid_device* dev_handle, hid_device_info* dev_info);
-    ~CMMKController();
-
-    std::string         GetDeviceName();
-    std::string         GetDeviceVendor();
-    std::string         GetLocation();
-    std::string         GetFirmwareVersion();
-    uint8_t             GetRowCount();
-    uint8_t             GetColumnCount();
-
-    KEYBOARD_LAYOUT     GetLayout();
-    KEYBOARD_SIZE       GetSize();
-    layout_values       GetLayoutValues();
-    keyboard_layout*    GetTransform();
-
-    void SetFirmwareControl();
-    void SetManualControl();
-
-    void SetSingle(int row, int col, struct rgb color);
-    void SetAll(struct cmmk_color_matrix const& colors);
-    void SetAllSingle(struct rgb color);
-
-    void SetMode(cmmk_effect_fully_lit eff);
-    void SetMode(cmmk_effect_breathe eff);
-    void SetMode(cmmk_effect_cycle eff);
-    void SetMode(cmmk_effect_single eff);
-    void SetMode(cmmk_effect_wave eff);
-    void SetMode(cmmk_effect_ripple eff);
-    void SetMode(cmmk_effect_cross eff);
-    void SetMode(cmmk_effect_raindrops eff);
-    void SetMode(cmmk_effect_stars eff);
-    void SetMode(cmmk_effect_snake eff);
-
-    bool PositionValid(int y, int x);
-
-private:
-    void ActivateMode(int mode);
-    void ActivateEffect(int effect);
-
-    int         current_mode    = -1;
-    int         current_effect  = -1;
-
-    std::string device_name;
-    std::string vendor_name;
-    std::string location;
-    std::string firmware_version;
-
-    KEYBOARD_SIZE       kb_size;
-    KEYBOARD_LAYOUT     kb_layout_type;
-    layout_values       kb_offsets;
-    keyboard_layout     kb_transform;
-    keyboard_layout*    kb_layout;
-
-    uint8_t     row_count;
-    uint8_t     column_count;
-
-    mutable struct cmmk cmmk_handle;
-};

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -17,8 +17,9 @@
 #include "RGBController_CMARGBGen2A1Controller.h"
 #include "RGBController_CMRGBController.h"
 #include "RGBController_CMR6000Controller.h"
-#include "RGBController_CMMKController.h"
 #include "RGBController_CMMonitorController.h"
+#include "RGBController_CMKeyboardController.h"
+
 /*-----------------------------------------------------*\
 | Coolermaster USB vendor ID                            |
 \*-----------------------------------------------------*/
@@ -26,13 +27,8 @@
 
 /*-----------------------------------------------------*\
 | Coolermaster Keyboards                                |
+|   PIDs defined in `CMMKControllerV2.h`                |
 \*-----------------------------------------------------*/
-#define COOLERMASTER_MASTERKEYS_PRO_L_PID           0x003B
-#define COOLERMASTER_MASTERKEYS_PRO_L_WHITE_PID     0x0047
-#define COOLERMASTER_MASTERKEYS_PRO_S_PID           0x003C
-#define COOLERMASTER_MASTERKEYS_MK750_PID           0x0067
-#define COOLERMASTER_MASTERKEYS_SK630_PID           0x0089
-#define COOLERMASTER_MASTERKEYS_SK650_PID           0x008D
 
 /*-----------------------------------------------------*\
 | Coolermaster GPUs                                     |
@@ -125,16 +121,75 @@ void DetectCoolerMasterGPU(hid_device_info* info, const std::string&)
     }
 }
 
-void DetectCoolerMasterKeyboards(hid_device_info* info, const std::string&)
+void DetectCoolerMasterV1Keyboards(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
-        CMMKController*               controller     = new CMMKController(dev, info);
-        RGBController_CMMKController* rgb_controller = new RGBController_CMMKController(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        switch(info->product_id)
+        {
+            case COOLERMASTER_KEYBOARD_PRO_L_PID:
+            case COOLERMASTER_KEYBOARD_PRO_L_WHITE_PID:
+            case COOLERMASTER_KEYBOARD_PRO_S_PID:
+            {
+                CMKeyboardV1Controller* controller                 = new CMKeyboardV1Controller(dev, info);
+                controller->SetDeviceName(name);
+                RGBController_CMKeyboardController* rgb_controller = new RGBController_CMKeyboardController(controller);
+                ResourceManager::get()->RegisterRGBController(rgb_controller);
+            }
+            break;
+
+            default:
+
+                LOG_DEBUG("[%s] Controller not created as the product ID %04X is missing from detector switch", name.c_str(), info->product_id);
+            break;
+        }
+    }
+}
+
+void DetectCoolerMasterV2Keyboards(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        switch(info->product_id)
+        {
+            case COOLERMASTER_KEYBOARD_PRO_L_PID:
+            case COOLERMASTER_KEYBOARD_PRO_L_WHITE_PID:
+            case COOLERMASTER_KEYBOARD_PRO_S_PID:
+            {
+                CMKeyboardV1Controller* controller                 = new CMKeyboardV1Controller(dev, info);
+                controller->SetDeviceName(name);
+                RGBController_CMKeyboardController* rgb_controller = new RGBController_CMKeyboardController(controller);
+                ResourceManager::get()->RegisterRGBController(rgb_controller);
+            }
+            break;
+
+            case COOLERMASTER_KEYBOARD_SK622B_PID:
+            case COOLERMASTER_KEYBOARD_SK622W_PID:
+            case COOLERMASTER_KEYBOARD_SK630_PID:
+            case COOLERMASTER_KEYBOARD_SK650_PID:
+            case COOLERMASTER_KEYBOARD_SK652_PID:
+            case COOLERMASTER_KEYBOARD_SK653_PID:
+            case COOLERMASTER_KEYBOARD_CK530_PID:
+            case COOLERMASTER_KEYBOARD_CK530_V2_PID:
+            case COOLERMASTER_KEYBOARD_CK550_V2_PID:
+            case COOLERMASTER_KEYBOARD_CK552_V2_PID:
+            case COOLERMASTER_KEYBOARD_MK730_PID:
+            case COOLERMASTER_KEYBOARD_MK750_PID:
+            {
+                CMKeyboardV2Controller* controller                 = new CMKeyboardV2Controller(dev, info);
+                controller->SetDeviceName(name);
+                RGBController_CMKeyboardController* rgb_controller = new RGBController_CMKeyboardController(controller);
+                ResourceManager::get()->RegisterRGBController(rgb_controller);
+            }
+
+            default:
+                LOG_DEBUG("[%s] Controller not created as the product ID %04X is missing from detector switch", name.c_str(), info->product_id);
+            break;
+        }
     }
 }
 
@@ -227,13 +282,24 @@ void DetectCoolerMasterMonitor(hid_device_info* info, const std::string& name)
 
 /*-----------------------------------------------------*\
 | Coolermaster Keyboards                                |
+|   PIDs defined in `CMKeyboardDevices.h`               |
 \*-----------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L",         DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_L_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L White",   DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_L_WHITE_PID,    1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro S",         DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_S_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master MK750",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_MK750_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master SK630",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_SK630_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master SK650",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_SK650_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro S",         DetectCoolerMasterV1Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_PRO_S_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L",         DetectCoolerMasterV1Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_PRO_L_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L White",   DetectCoolerMasterV1Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_PRO_L_WHITE_PID,    1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master MK850",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_MK850_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master SK622 White",              DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_SK622W_PID,         1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master SK622 Black",              DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_SK622B_PID,         1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master SK630",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_SK630_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master SK650",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_SK650_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master SK652",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_SK652_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master SK653",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_SK653_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master MK730",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_MK730_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master MK750",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_MK750_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master CK530",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_CK530_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master CK530 V2",                 DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_CK530_V2_PID,       1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master CK550 V2",                 DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_CK550_V2_PID,       1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master CK550 V1 / CK552",         DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_CK552_V2_PID,       1,      0xFF00, 1);
 
 /*-----------------------------------------------------*\
 | Coolermaster LEDstrip controllers                     |

Controllers/CoolerMasterController/RGBController_CMKeyboardController.cpp

@@ -0,0 +1,182 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMKeyboardController.cpp                             |
+|                                                                     |
+|  Controller for Coolermaster keyboards                              |
+|                                                                     |
+|  Tam D (too.manyhobbies)     30th Nov 2023                          |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+#include "RGBController_CMKeyboardController.h"
+#include "CMKeyboardDevices.h"
+
+/**------------------------------------------------------------------*\
+    @name Coolermaster Masterkeys Keyboards
+    @category Keyboard
+    @type USB
+    @save :robot:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectCoolerMasterKeyboards
+    @comment
+    In CMKeyboardV1Controller brightness control not supported.
+    Supported effects differ between CMKeyboardV1Controller and
+    CMKeyboardV2Controller.
+\*-------------------------------------------------------------------*/
+RGBController_CMKeyboardController::RGBController_CMKeyboardController(CMKeyboardAbstractController* pController)
+{
+    m_pController       = pController;
+    vendor              = m_pController->GetDeviceVendor();
+    type                = DEVICE_TYPE_KEYBOARD;
+    description         = "Cooler Master Keyboard Device";
+    version             = m_pController->GetFirmwareVersion();
+
+    /*----------------------------------------------------------------*\
+    | Coolermaster uses the name field to store the serial number in   |
+    | many of their keyboards.                                         |
+    \*----------------------------------------------------------------*/
+    serial              = m_pController->GetDeviceSerial();
+    location            = m_pController->GetLocation();
+    m_keyboardLayout    = m_pController->GetKeyboardLayout();
+    name                = m_pController->GetDeviceName();
+
+    m_pController->InitializeModes(modes);
+
+    SetupZones();
+}
+
+RGBController_CMKeyboardController::~RGBController_CMKeyboardController()
+{
+    for(size_t i = 0; i < m_pUnknownKeyNames.size(); i++)
+    {
+        if(m_pUnknownKeyNames[i])
+        {
+            delete(m_pUnknownKeyNames[i]);
+        }
+    }
+}
+
+#define COOLERMASTER_ZONES_MAX 1
+void RGBController_CMKeyboardController::SetupZones()
+{
+    std::string physical_size;
+    unsigned int max_led_value              = 0;
+    const cm_kb_device* coolermaster        = m_pController->GetDeviceData();
+
+    /*---------------------------------------------------------*\
+    | Fill in zones from the device data                        |
+    \*---------------------------------------------------------*/
+    for(size_t i = 0; i < COOLERMASTER_ZONES_MAX; i++)
+    {
+        if(coolermaster->zones[i] == NULL)
+        {
+            break;
+        }
+        else
+        {
+            zone new_zone;
+
+            new_zone.name                   = coolermaster->zones[i]->name;
+            new_zone.type                   = coolermaster->zones[i]->type;
+
+            if(new_zone.type == ZONE_TYPE_MATRIX)
+            {
+                KeyboardLayoutManager new_kb(m_keyboardLayout, coolermaster->layout_new->base_size, coolermaster->layout_new->key_values);
+
+                matrix_map_type * new_map   = new matrix_map_type;
+                new_zone.matrix_map         = new_map;
+
+                new_map->map                = new unsigned int[new_map->height * new_map->width];
+
+                if(coolermaster->layout_new->base_size != KEYBOARD_SIZE_EMPTY)
+                {
+                    /*---------------------------------------------------------*\
+                    | Minor adjustments to keyboard layout                      |
+                    \*---------------------------------------------------------*/
+                    keyboard_keymap_overlay_values* temp    = coolermaster->layout_new;
+                    new_kb.ChangeKeys(*temp);
+
+                    new_map->height             = new_kb.GetRowCount();
+                    new_map->width              = new_kb.GetColumnCount();
+
+                    /*---------------------------------------------------------*\
+                    | Matrix map still uses declared zone rows and columns      |
+                    |   as the packet structure depends on the matrix map       |
+                    \*---------------------------------------------------------*/
+                    new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT, new_map->height, new_map->width);
+
+                    /*---------------------------------------------------------*\
+                    | Create LEDs for the Matrix zone                           |
+                    |   Place keys in the layout to populate the matrix         |
+                    \*---------------------------------------------------------*/
+                    new_zone.leds_count                     = new_kb.GetKeyCount();
+                    LOG_DEBUG("[%s] Created KB matrix with %d rows and %d columns containing %d keys",
+                              m_pController->GetDeviceName().c_str(), new_kb.GetRowCount(), new_kb.GetColumnCount(), new_zone.leds_count);
+
+                    for(unsigned int led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
+                    {
+                        led new_led;
+
+                        new_led.name                = new_kb.GetKeyNameAt(led_idx);
+                        new_led.value               = new_kb.GetKeyValueAt(led_idx);
+                        max_led_value               = std::max(max_led_value, new_led.value);
+                        leds.push_back(new_led);
+                    }
+                }
+
+                /*---------------------------------------------------------*\
+                | Add 1 the max_led_value to account for the 0th index      |
+                \*---------------------------------------------------------*/
+                max_led_value++;
+            }
+
+            /*---------------------------------------------------------*\
+            | name is not set yet so description is used instead        |
+            \*---------------------------------------------------------*/
+            LOG_DEBUG("[%s] Creating a %s zone: %s with %d LEDs", description.c_str(),
+                      ((new_zone.type == ZONE_TYPE_MATRIX) ? "matrix": "linear"),
+                      new_zone.name.c_str(), new_zone.leds_count);
+            new_zone.leds_min                   = new_zone.leds_count;
+            new_zone.leds_max                   = new_zone.leds_count;
+            zones.push_back(new_zone);
+
+        }
+    }
+
+
+    SetupColors();
+}
+
+void RGBController_CMKeyboardController::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+}
+
+void RGBController_CMKeyboardController::DeviceUpdateLEDs()
+{
+    m_pController->SetLeds(leds, colors);
+}
+
+void RGBController_CMKeyboardController::UpdateSingleLED(int led, RGBColor color)
+{
+    uint8_t key_value = m_pLayoutManager->GetKeyValueAt(led);
+    m_pController->SetSingleLED(key_value, color);
+}
+
+void RGBController_CMKeyboardController::UpdateSingleLED(int led)
+{
+    m_pController->SetSingleLED(led, colors[led]);
+}
+
+void RGBController_CMKeyboardController::UpdateZoneLEDs(int /*zone_idx*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CMKeyboardController::DeviceUpdateMode()
+{
+    m_pController->SetMode(modes[active_mode]);
+}
+
+void RGBController_CMKeyboardController::SetCustomMode()
+{
+
+}

Controllers/CoolerMasterController/RGBController_CMKeyboardController.h

@@ -0,0 +1,41 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMKeyboardController.h                               |
+|                                                                     |
+|  Controller for Coolermaster keyboards                              |
+|                                                                     |
+|  Tam D (too.manyhobbies)     30th Nov 2023                          |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+#pragma once
+
+#include "RGBController.h"
+#include "CMKeyboardAbstractController.h"
+#include "CMKeyboardV1Controller.h"
+#include "CMKeyboardV2Controller.h"
+#include "CMKeyboardDevices.h"
+
+class RGBController_CMKeyboardController : public RGBController
+{
+public:
+    RGBController_CMKeyboardController(CMKeyboardAbstractController* pController);
+    ~RGBController_CMKeyboardController();
+
+    void SetupZones();
+    void ResizeZone(int zone, int new_size);
+
+    void DeviceUpdateLEDs();
+    void UpdateSingleLED(int led, RGBColor color);
+    void UpdateSingleLED(int led);
+    void UpdateZoneLEDs(int zone_idx);
+
+    void SetCustomMode();
+    void DeviceUpdateMode();
+
+private:
+    CMKeyboardAbstractController*   m_pController;;
+    KeyboardLayoutManager*          m_pLayoutManager;
+    KEYBOARD_LAYOUT                 m_keyboardLayout;
+    KEYBOARD_SIZE                   m_keyboardSize;
+    layout_values                   m_layoutValues;
+    std::vector<char *>             m_pUnknownKeyNames;
+};

Controllers/CoolerMasterController/RGBController_CMMKController.cpp

@@ -1,503 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  RGBController_CMMKController.cpp                                   |
-|                                                                     |
-|  Driver for Coolermaster MasterKeys keyboards                       |
-|                                                                     |
-|  Lukas N (chmod222)          28th Jun 2020                          |
-|  Tam D (too.manyhobbies)     25th Apr 2021                          |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#include "RGBController_CMMKController.h"
-
-#include <sstream>
-
-using namespace std::chrono_literals;
-
-#define CMMK_SPEED_MIN          CMMK_SPEED0
-#define CMMK_SPEED_MID          CMMK_SPEED2
-#define CMMK_SPEED_MAX          CMMK_SPEED4
-#define CMMK_MODE_FIRMWARE      0xFF
-#define CMMK_MODE_MANUAL        0x7F
-
-/**------------------------------------------------------------------*\
-    @name Coolermaster Masterkeys Keyboards
-    @category Keyboard
-    @type USB
-    @save :robot:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectCoolerMasterKeyboards
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_CMMKController::RGBController_CMMKController(CMMKController* controller_ptr)
-{
-    controller                  = controller_ptr;
-    name                        = controller->GetDeviceName();
-    vendor                      = controller->GetDeviceVendor();
-    type                        = DEVICE_TYPE_KEYBOARD;
-    description                 = "Cooler Master MasterKeys Device";
-    version                     = controller->GetFirmwareVersion();
-    serial                      = "";
-    location                    = controller->GetLocation();
-
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = CMMK_MODE_MANUAL;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Static;
-    Static.name                 = "Static";
-    Static.value                = CMMK_EFFECT_FULLY_LIT;
-    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors_min           = 1;
-    Static.colors_max           = 1;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name              = "Breathing";
-    Breathing.value             = CMMK_EFFECT_BREATHE;
-    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.speed_min         = CMMK_SPEED_MIN;
-    Breathing.speed_max         = CMMK_SPEED_MAX;
-    Breathing.speed             = CMMK_SPEED_MID;
-    Breathing.colors_min        = 1;
-    Breathing.colors_max        = 1;
-    Breathing.colors.resize(1);
-    modes.push_back(Breathing);
-
-    mode Cycle;
-    Cycle.name                  = "Spectrum Cycle";
-    Cycle.value                 = CMMK_EFFECT_CYCLE;
-    Cycle.flags                 = MODE_FLAG_HAS_SPEED;
-    Cycle.color_mode            = MODE_COLORS_NONE;
-    Cycle.speed_min             = 2 * CMMK_SPEED_MIN; //Spectrum Cycle uses a unique speed range
-    Cycle.speed_max             = 2 * CMMK_SPEED_MAX;
-    Cycle.speed                 = 2 * CMMK_SPEED_MID;
-    modes.push_back(Cycle);
-
-    mode Reactive;
-    Reactive.name               = "Reactive";
-    Reactive.value              = CMMK_EFFECT_SINGLE;
-    Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-    Reactive.speed_min          = CMMK_SPEED_MIN;
-    Reactive.speed_max          = CMMK_SPEED_MAX;
-    Reactive.speed              = CMMK_SPEED_MID;
-    Reactive.colors_min         = 2;
-    Reactive.colors_max         = 2;
-    Reactive.colors.resize(2);
-    modes.push_back(Reactive);
-
-    mode Wave;
-    Wave.name                   = "Rainbow Wave";
-    Wave.value                  = CMMK_EFFECT_WAVE;
-    Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
-    Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-    Wave.speed_min              = CMMK_SPEED_MIN;
-    Wave.speed_max              = CMMK_SPEED_MAX;
-    Wave.speed                  = CMMK_SPEED_MID;
-    Wave.direction              = MODE_DIRECTION_LEFT;
-    Wave.colors_min             = 1;
-    Wave.colors_max             = 1;
-    Wave.colors.resize(1);
-    modes.push_back(Wave);
-
-    mode Ripple;
-    Ripple.name                 = "Ripple Effect";
-    Ripple.value                = CMMK_EFFECT_RIPPLE;
-    Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
-    Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Ripple.speed_min            = CMMK_SPEED_MIN;
-    Ripple.speed_max            = CMMK_SPEED_MAX;
-    Ripple.speed                = CMMK_SPEED_MID;
-    Ripple.colors_min           = 2;
-    Ripple.colors_max           = 2;
-    Ripple.colors.resize(2);
-    modes.push_back(Ripple);
-
-    mode Cross;
-    Cross.name                  = "Cross";
-    Cross.value                 = CMMK_EFFECT_CROSS;
-    Cross.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Cross.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Cross.speed_min             = CMMK_SPEED_MIN;
-    Cross.speed_max             = CMMK_SPEED_MAX;
-    Cross.speed                 = CMMK_SPEED_MID;
-    Cross.colors_min            = 2;
-    Cross.colors_max            = 2;
-    Cross.colors.resize(2);
-    modes.push_back(Cross);
-
-    mode Raindrops;
-    Raindrops.name              = "Raindrops";
-    Raindrops.value             = CMMK_EFFECT_RAINDROPS;
-    Raindrops.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Raindrops.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Raindrops.speed_min         = CMMK_SPEED_MIN;
-    Raindrops.speed_max         = CMMK_SPEED_MAX;
-    Raindrops.speed             = CMMK_SPEED_MID;
-    Raindrops.colors_min        = 2;
-    Raindrops.colors_max        = 2;
-    Raindrops.colors.resize(2);
-    modes.push_back(Raindrops);
-
-    mode Stars;
-    Stars.name                  = "Starfield";
-    Stars.value                 = CMMK_EFFECT_STARS;
-    Stars.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Stars.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Stars.speed_min             = CMMK_SPEED_MIN;
-    Stars.speed_max             = CMMK_SPEED_MAX;
-    Stars.speed                 = CMMK_SPEED_MID;
-    Stars.colors_min            = 2;
-    Stars.colors_max = 2;
-    Stars.colors.resize(2);
-    modes.push_back(Stars);
-
-    mode Snake;
-    Snake.name                  = "Snake";
-    Snake.value                 = CMMK_EFFECT_SNAKE;
-    Snake.flags                 = MODE_FLAG_HAS_SPEED;
-    Snake.color_mode            = MODE_COLORS_NONE;
-    Snake.speed_min             = CMMK_SPEED_MIN;
-    Snake.speed_max             = CMMK_SPEED_MAX;
-    Snake.speed                 = CMMK_SPEED_MID;
-    modes.push_back(Snake);
-
-    mode FirmwareControl;
-    FirmwareControl.name        = "Firmware Controlled";
-    FirmwareControl.value       = 0xFF;
-    FirmwareControl.flags       = 0;
-    FirmwareControl.color_mode  = MODE_COLORS_NONE;
-    modes.push_back(FirmwareControl);
-
-    SetupZones();
-}
-
-RGBController_CMMKController::~RGBController_CMMKController()
-{
-    delete controller;
-}
-
-void RGBController_CMMKController::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Create the keyboard zone usiung Keyboard Layout Manager   |
-    \*---------------------------------------------------------*/
-    zone new_zone;
-    new_zone.name           = ZONE_EN_KEYBOARD;
-    new_zone.type           = ZONE_TYPE_MATRIX;
-
-    layoutManager = new KeyboardLayoutManager(controller->GetLayout(), controller->GetSize(), controller->GetLayoutValues());
-
-    matrix_map_type * new_map   = new matrix_map_type;
-    new_zone.matrix_map         = new_map;
-    new_zone.matrix_map->height = layoutManager->GetRowCount();
-    new_zone.matrix_map->width  = layoutManager->GetColumnCount();
-
-    new_zone.matrix_map->map    = new unsigned int[new_map->height * new_map->width];
-    new_zone.leds_count         = layoutManager->GetKeyCount();
-    new_zone.leds_min           = new_zone.leds_count;
-    new_zone.leds_max           = new_zone.leds_count;
-
-    /*---------------------------------------------------------*\
-    | Matrix map still uses declared zone rows and columns      |
-    |   as the packet structure depends on the matrix map       |
-    \*---------------------------------------------------------*/
-    layoutManager->GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT, new_map->height, new_map->width);
-
-    /*---------------------------------------------------------*\
-    | Create LEDs for the Matrix zone                           |
-    |   Place keys in the layout to populate the matrix         |
-    \*---------------------------------------------------------*/
-    for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
-    {
-        led new_led;
-
-        new_led.name                = layoutManager->GetKeyNameAt(led_idx);
-        new_led.value               = layoutManager->GetKeyValueAt(led_idx);
-        leds.push_back(new_led);
-    }
-
-    zones.push_back(new_zone);
-
-    SetupColors();
-}
-
-void RGBController_CMMKController::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-struct rgb map_to_cmmk_rgb(RGBColor input)
-{
-    return rgb
-    {
-        (uint8_t)RGBGetRValue(input),
-        (uint8_t)RGBGetGValue(input),
-        (uint8_t)RGBGetBValue(input)
-    };
-}
-
-enum cmmk_wave_direction map_to_cmmk_dir(int input)
-{
-    switch(input)
-    {
-        case MODE_DIRECTION_LEFT:
-            return CMMK_RIGHT_TO_LEFT;
-
-        case MODE_DIRECTION_RIGHT:
-            return CMMK_LEFT_TO_RIGHT;
-
-        case MODE_DIRECTION_UP:
-            return CMMK_FRONT_TO_BACK;
-
-        case MODE_DIRECTION_DOWN:
-            return CMMK_BACK_TO_FRONT;
-
-        default:
-            return CMMK_RIGHT_TO_LEFT;
-    }
-}
-
-
-void RGBController_CMMKController::copy_buffers(std::vector<RGBColor> &in_colors, struct cmmk_color_matrix& mat, std::atomic<bool>& dirty)
-{
-    dirty.store(false);
-
-    keyboard_layout * transform = controller->GetTransform();
-
-    if(0 == transform)
-    {
-        return;
-    }
-
-    for(int row = 0; row < controller->GetRowCount(); row++)
-    {
-        for(int col = 0; col < controller->GetColumnCount(); col++)
-        {
-            int key_idx = (*transform)[row][col];
-
-            if(-1 == key_idx)
-            {
-                continue;
-            }
-
-            struct rgb color = map_to_cmmk_rgb(in_colors[key_idx]);
-
-            dirty.store(true);
-            mat.data[row][col] = color;
-        }
-    }
-}
-
-void RGBController_CMMKController::DeviceUpdateLEDs()
-{
-    copy_buffers(colors, current_matrix, dirty);
-
-    if(force_update.load() || dirty.load())
-    {
-        controller->SetAll(current_matrix);
-
-        force_update.store(false);
-    }
-}
-
-void RGBController_CMMKController::UpdateZoneLEDs(int zone_idx)
-{
-    /*---------------------------------------------------------*\
-    | This device only supports a single zone, as a result we  |
-    | update all LEDs.                                         |
-    \*---------------------------------------------------------*/
-    DeviceUpdateLEDs();
-}
-
-void RGBController_CMMKController::UpdateSingleLED(int led_idx, RGBColor color)
-{
-    keyboard_layout * transform = controller->GetTransform();
-    led selected_led = leds[led_idx];
-
-    if(0 == transform)
-    {
-        return;
-    }
-
-    // this is really expensive
-    for(int row = 0; row < controller->GetRowCount(); row++)
-    {
-        for(int col = 0; col < controller->GetColumnCount(); col++)
-        {
-            int val = (*transform)[row][col];
-
-            if(val != (int)selected_led.value)
-            {
-                continue;
-            }
-
-            controller->SetSingle(row, col, map_to_cmmk_rgb(color));
-            dirty.store(false);
-
-            return;
-        }
-    }
-
-}
-
-void RGBController_CMMKController::UpdateSingleLED(int led_idx)
-{
-    UpdateSingleLED(led_idx, colors[led_idx]);
-}
-
-void RGBController_CMMKController::SetCustomMode()
-{
-    active_mode = 1;
-}
-
-void RGBController_CMMKController::DeviceUpdateMode()
-{
-    force_update.store(true);
-
-    switch(modes[active_mode].value)
-    {
-        case CMMK_MODE_FIRMWARE:
-            controller->SetFirmwareControl();
-            break;
-
-        case CMMK_MODE_MANUAL:
-            controller->SetManualControl();
-            break;
-
-        case CMMK_EFFECT_FULLY_LIT:
-            {
-                cmmk_effect_fully_lit fully_lit_effect;
-
-                fully_lit_effect.color  = map_to_cmmk_rgb(modes[active_mode].colors[0]);
-
-                controller->SetMode(fully_lit_effect);
-            }
-            break;
-
-        case CMMK_EFFECT_BREATHE:
-            {
-                cmmk_effect_breathe breathe_effect;
-
-                breathe_effect.speed    = (uint8_t)modes[active_mode].speed;
-                breathe_effect.color    = map_to_cmmk_rgb(modes[active_mode].colors[0]);
-
-                controller->SetMode(breathe_effect);
-            }
-            break;
-
-        case CMMK_EFFECT_CYCLE:
-            {
-                cmmk_effect_cycle cycle_effect;
-
-                cycle_effect.speed  = (uint8_t)modes[active_mode].speed;
-
-                controller->SetMode(cycle_effect);
-            }
-            break;
-
-        case CMMK_EFFECT_SINGLE:
-            {
-                cmmk_effect_single single_effect;
-
-                single_effect.speed     = (uint8_t)modes[active_mode].speed;
-                single_effect.active    = map_to_cmmk_rgb(modes[active_mode].colors[0]);
-                single_effect.rest      = map_to_cmmk_rgb(modes[active_mode].colors[1]);
-
-                controller->SetMode(single_effect);
-            }
-            break;
-
-        case CMMK_EFFECT_WAVE:
-            {
-                cmmk_effect_wave wave_effect;
-
-                wave_effect.speed       = (uint8_t)modes[active_mode].speed;
-                wave_effect.direction   = map_to_cmmk_dir(modes[active_mode].direction);
-                wave_effect.start       = map_to_cmmk_rgb(modes[active_mode].colors[0]);
-
-                controller->SetMode(wave_effect);
-            }
-            break;
-
-        case CMMK_EFFECT_RIPPLE:
-            {
-                cmmk_effect_ripple ripple_effect;
-
-                ripple_effect.speed             = (uint8_t)modes[active_mode].speed;
-                ripple_effect.active            = map_to_cmmk_rgb(modes[active_mode].colors[0]);
-                ripple_effect.rest              = map_to_cmmk_rgb(modes[active_mode].colors[1]);
-
-                if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
-                {
-                    ripple_effect.ripple_type   = CMMK_RIPPLE_RANDOM_COLOR;
-                }
-                else
-                {
-                    ripple_effect.ripple_type   = CMMK_RIPPLE_GIVEN_COLOR;
-                }
-
-                controller->SetMode(ripple_effect);
-            }
-            break;
-
-        case CMMK_EFFECT_CROSS:
-            {
-                cmmk_effect_cross cross_effect;
-
-                cross_effect.speed  = (uint8_t)modes[active_mode].speed;
-                cross_effect.active = map_to_cmmk_rgb(modes[active_mode].colors[0]);
-                cross_effect.rest   = map_to_cmmk_rgb(modes[active_mode].colors[1]);
-
-                controller->SetMode(cross_effect);
-            }
-            break;
-
-        case CMMK_EFFECT_RAINDROPS:
-            {
-                cmmk_effect_raindrops raindrops_effect;
-
-                raindrops_effect.speed      = (uint8_t)modes[active_mode].speed;
-                raindrops_effect.interval   = CMMK_SPEED_MID;
-                raindrops_effect.active     = map_to_cmmk_rgb(modes[active_mode].colors[0]);
-                raindrops_effect.rest       = map_to_cmmk_rgb(modes[active_mode].colors[1]);
-
-                controller->SetMode(raindrops_effect);
-            }
-            break;
-
-        case CMMK_EFFECT_STARS:
-            {
-                cmmk_effect_stars stars_effect;
-
-                stars_effect.speed      = (uint8_t)modes[active_mode].speed;
-                stars_effect.interval   = CMMK_SPEED_MID;
-                stars_effect.active     = map_to_cmmk_rgb(modes[active_mode].colors[0]);
-                stars_effect.rest       = map_to_cmmk_rgb(modes[active_mode].colors[1]);
-
-                controller->SetMode(stars_effect);
-            }
-            break;
-
-        case CMMK_EFFECT_SNAKE:
-            {
-                cmmk_effect_snake snake_effect;
-
-                snake_effect.speed = (uint8_t)modes[active_mode].speed;
-
-                controller->SetMode(snake_effect);
-            }
-            break;
-    }
-}

Controllers/CoolerMasterController/RGBController_CMMKController.h

@@ -1,46 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  RGBController_CMMKController.h                                     |
-|                                                                     |
-|  Driver for Coolermaster MasterKeys keyboards                       |
-|                                                                     |
-|  Lukas N (chmod222)          28th Jun 2020                          |
-|  Tam D (too.manyhobbies)     25th Apr 2021                          |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#pragma once
-
-#include <cstring>
-#include "RGBController.h"
-#include "CMMKController.h"
-#include "RGBControllerKeyNames.h"
-#include "KeyboardLayoutManager.h"
-
-class RGBController_CMMKController : public RGBController
-{
-public:
-    RGBController_CMMKController(CMMKController* controller_ptr);
-    ~RGBController_CMMKController();
-
-    void SetupZones();
-    void ResizeZone(int zone, int new_size);
-
-    void DeviceUpdateLEDs();
-    void UpdateSingleLED(int led, RGBColor color);
-    void UpdateSingleLED(int led);
-    void UpdateZoneLEDs(int zone_idx);
-
-    void SetCustomMode();
-    void DeviceUpdateMode();
-
-private:
-    void copy_buffers(std::vector<RGBColor> &in_colors, struct cmmk_color_matrix& mat, std::atomic<bool>& dirty);
-
-    CMMKController*             controller;
-    KeyboardLayoutManager*      layoutManager;
-
-    struct cmmk_color_matrix current_matrix;
-
-    std::atomic<bool>           dirty;
-    std::atomic<bool>           force_update;
-};

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreController.cpp

@@ -7,6 +7,7 @@
 \*---------------------------------------------------------*/
 
 #include "CorsairCommanderCoreController.h"
+#include "CorsairDeviceGuard.h"
 
 #include <cstring>
 #include <iomanip>
@@ -23,9 +24,7 @@ CorsairCommanderCoreController::CorsairCommanderCoreController(hid_device* dev_h
     packet_size             = CORSAIR_COMMANDER_CORE_PACKET_SIZE_V2;
     command_res_size        = packet_size - 4;
     this->pid               = pid;
-#ifdef _WIN32
-    global_corsair_access_handle = CreateMutexA(NULL, FALSE, GLOBAL_CORSAIR_MUTEX_NAME);
-#endif
+    guard_manager_ptr           = new DeviceGuardManager(new CorsairDeviceGuard());
 
     /*-----------------------------------------------------*\
     | Initialize controller                                 |
@@ -43,12 +42,6 @@ CorsairCommanderCoreController::~CorsairCommanderCoreController()
     /*-----------------------------------------------------*\
     | Close keepalive thread                                |
     \*-----------------------------------------------------*/
-#ifdef _WIN32
-    if(global_corsair_access_handle != NULL)
-    {
-        CloseHandle(global_corsair_access_handle);
-    }
-#endif
     keepalive_thread_run = 0;
     keepalive_thread->join();
     delete keepalive_thread;
@@ -57,6 +50,7 @@ CorsairCommanderCoreController::~CorsairCommanderCoreController()
     | Close HID device                                      |
     \*-----------------------------------------------------*/
     hid_close(dev);
+    delete guard_manager_ptr;
 }
 
 void CorsairCommanderCoreController::InitController()
@@ -104,6 +98,24 @@ std::string CorsairCommanderCoreController::GetLocationString()
     return("HID: " + location);
 }
 
+std::vector<unsigned short int> CorsairCommanderCoreController::GetLedCounts()
+{
+    /*-----------------------------------------------------*\
+    | Get the LED count per device                          |
+    \*-----------------------------------------------------*/
+    std::vector<unsigned short int> led_counts;
+    unsigned char endpoint[2] = {0x20, 0x00};
+    unsigned char* res = new unsigned char[command_res_size];
+    ReadData(endpoint, res);
+    for(int i = 0; i < res[2]; i++)
+    {
+        led_counts.push_back(res[i*4+6] << 8 | res[i*4+5]);
+    }
+    delete[] res;
+
+    return  led_counts;
+}
+
 void CorsairCommanderCoreController::KeepaliveThread()
 {
     while(keepalive_thread_run.load())
@@ -153,13 +165,6 @@ void CorsairCommanderCoreController::SendCommand(unsigned char command[2], unsig
     \*---------------------------------------------------------*/
     unsigned char* buf = new unsigned char[packet_size];
 
-#ifdef _WIN32
-    if(global_corsair_access_handle != NULL)
-    {
-        WaitForSingleObject(global_corsair_access_handle, INFINITE);
-    }
-#endif
-
     memset(buf, 0, packet_size);
     buf[0] = 0x00;
     buf[1] = 0x08;
@@ -170,25 +175,28 @@ void CorsairCommanderCoreController::SendCommand(unsigned char command[2], unsig
         memcpy(&buf[4], data, data_len);
     }
 
-    hid_write(dev, buf, packet_size);
-    do
+    /*---------------------------------------------------------*\
+    | HID I/O start                                             |
+    \*---------------------------------------------------------*/
     {
-        hid_read(dev, buf, packet_size);
+        DeviceGuardLock _ = guard_manager_ptr->AwaitExclusiveAccess();
+
+        hid_write(dev, buf, packet_size);
+        do
+        {
+            hid_read(dev, buf, packet_size);
+        }
+        while (buf[0] != 0x00);
     }
-    while (buf[0] != 0x00);
+    /*---------------------------------------------------------*\
+    | HID I/O end (lock released)                               |
+    \*---------------------------------------------------------*/
 
     if(res != NULL)
     {
         memcpy(res, &buf[3], command_res_size);
     }
 
-#ifdef _WIN32
-    if(global_corsair_access_handle != NULL)
-    {
-        ReleaseMutex(global_corsair_access_handle);
-    }
-#endif
-
     delete[] buf;
 }
 
@@ -201,17 +209,9 @@ void CorsairCommanderCoreController::WriteData(unsigned char endpoint[2], unsign
     /*---------------------------------------------------------*\
     | Open endpoint                                             |
     \*---------------------------------------------------------*/
-#ifdef _WIN32
-    if(global_corsair_access_handle != NULL)
-    {
-        WaitForSingleObject(global_corsair_access_handle, INFINITE);
-    }
-#endif
-
-    unsigned char command[2] = {0x0d, 0x00};
+    unsigned char command[2] = {0x0D, 0x00};
     SendCommand(command, endpoint, 2, NULL);
 
-
     /*---------------------------------------------------------*\
     | Write data                                                |
     \*---------------------------------------------------------*/
@@ -271,13 +271,35 @@ void CorsairCommanderCoreController::WriteData(unsigned char endpoint[2], unsign
     command[0] = 0x05;
     command[1] = 0x01;
     SendCommand(command, NULL, 0, NULL);
+}
 
-#ifdef _WIN32
-    if(global_corsair_access_handle != NULL)
-    {
-        ReleaseMutex(global_corsair_access_handle);
-    }
-#endif
+void CorsairCommanderCoreController::ReadData(unsigned char endpoint[2], unsigned char data[])
+{
+    /*---------------------------------------------------------*\
+    | Private function to read data from an endpoint            |
+    | Note: Right now we only know how to read the first packet.|
+    |       It is not currently know how to read more.          |
+    \*---------------------------------------------------------*/
+
+    /*---------------------------------------------------------*\
+    | Open endpoint                                             |
+    \*---------------------------------------------------------*/
+    unsigned char command[2] = {0x0D, 0x00};
+    SendCommand(command, endpoint, 2, NULL);
+
+    /*---------------------------------------------------------*\
+    | Read data                                                 |
+    \*---------------------------------------------------------*/
+    command[0] = 0x08;
+    command[1] = 0x00;
+    SendCommand(command, NULL, 0, data);
+
+    /*---------------------------------------------------------*\
+    | Close endpoint                                            |
+    \*---------------------------------------------------------*/
+    command[0] = 0x05;
+    command[1] = 0x01;
+    SendCommand(command, NULL, 0, NULL);
 }
 
 void CorsairCommanderCoreController::SetDirectColor
@@ -307,24 +329,17 @@ void CorsairCommanderCoreController::SetDirectColor
                 usb_buf[packet_offset]   = RGBGetRValue(colors[i]);
                 usb_buf[packet_offset+1] = RGBGetGValue(colors[i]);
                 usb_buf[packet_offset+2] = RGBGetBValue(colors[i]);
-
                 packet_offset += 3;
             }
 
             led_idx = led_idx + zones[zone_idx].leds_count;
 
-            /*-------------------------------------------------*\
-            | Move offset for pump zone with less than 29 LEDs  |
-            \*-------------------------------------------------*/
-            if(zone_idx == 0)
-            {
-                packet_offset += 3 * (29 - zones[zone_idx].leds_count);
-            }
-            else
-            {
+
             /*-------------------------------------------------*\
             | Move offset for fans with less than 34 LEDs       |
             \*-------------------------------------------------*/
+            if(zone_idx != 0)
+            {
                 packet_offset += 3 * (34 - zones[zone_idx].leds_count);
             }
 
@@ -371,6 +386,6 @@ void CorsairCommanderCoreController::SetFanMode()
     }
 
     WriteData(endpoint, data_type, buf, 15);
-    
+
     controller_ready    = 1;
 }

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreController.h

@@ -9,15 +9,12 @@
 \*---------------------------------------------------------*/
 
 #include "RGBController.h"
+#include "DeviceGuardManager.h"
 
 #include <vector>
 #include <chrono>
 #include <hidapi/hidapi.h>
 
-#ifdef _WIN32
-#include <Windows.h>
-#endif
-
 #pragma once
 
 #define CORSAIR_COMMANDER_CORE_PACKET_SIZE_V1   1025 // First bit is the report bit
@@ -28,10 +25,6 @@
 #define CORSAIR_QL_FAN_ZONE_OFFSET              102
 #define CORSAIR_COMMANDER_CORE_NUM_CHANNELS     6
 
-#ifdef _WIN32
-#define GLOBAL_CORSAIR_MUTEX_NAME "Global\\CorsairLinkReadWriteGuardMutex"
-#endif
-
 enum
 {
     CORSAIR_COMMANDER_CORE_MODE_DIRECT          = 0x00,
@@ -44,6 +37,7 @@ public:
     ~CorsairCommanderCoreController();
 
     std::string GetFirmwareString();
+    std::vector<unsigned short int> GetLedCounts();
     std::string GetLocationString();
 
     void        SetDirectColor
@@ -56,25 +50,23 @@ public:
     void        SetFanMode();
 
 private:
-    hid_device*             dev;
-    std::thread*            keepalive_thread;
-    std::atomic<bool>       keepalive_thread_run;
-    std::atomic<bool>       controller_ready;
-    std::string             location;
-    std::vector<RGBColor>   lastcolors;
-    std::vector<zone>       lastzones;
-    unsigned short int      version[3] = {0, 0, 0};
-    int                     packet_size;
-    int                     command_res_size;
-    int                     pid;
-    std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
+    hid_device*                                         dev;
+    std::thread*                                        keepalive_thread;
+    std::atomic<bool>                                   keepalive_thread_run;
+    std::atomic<bool>                                   controller_ready;
+    std::string                                         location;
+    std::vector<RGBColor>                               lastcolors;
+    std::vector<zone>                                   lastzones;
+    unsigned short int                                  version[3] = {0, 0, 0};
+    int                                                 packet_size;
+    int                                                 command_res_size;
+    int                                                 pid;
+    std::chrono::time_point<std::chrono::steady_clock>  last_commit_time;
+    DeviceGuardManager*                                 guard_manager_ptr;
 
-#ifdef _WIN32
-    HANDLE                  global_corsair_access_handle = NULL;
-#endif
-    
     void        SendCommand(unsigned char command[2], unsigned char data[], unsigned short int data_len, unsigned char res[]);
     void        WriteData(unsigned char endpoint[2], unsigned char data_type[2], unsigned char data[], unsigned short int data_len);
+    void        ReadData(unsigned char endpoint[2], unsigned char data[]);
 
     void        SendCommit();
     void        InitController();

Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.cpp

@@ -21,7 +21,7 @@
 \*-------------------------------------------------------------------*/
 
 #define NA 0xFFFFFFFF
-static unsigned int matrix_map[7][7] =
+static unsigned int matrix_map29[7][7] =
 {
     { 28,  NA,  27,  NA,  26,  NA,  25 },
     { NA,  16,  NA,  15,  NA,  14,  NA },
@@ -32,6 +32,21 @@ static unsigned int matrix_map[7][7] =
     { 19,  NA,  20,  NA,  21,  NA,  22 },
 };
 
+static unsigned int matrix_map24[11][11] =
+{
+    { NA,  NA,  NA,  NA,  NA,   6,  NA,  NA,  NA,  NA,  NA },
+    { NA,  NA,  NA,   4,   5,  NA,   7,   8,  NA,  NA,  NA },
+    { NA,  NA,   3,  NA,  NA,  NA,  NA,  NA,   9,  NA,  NA },
+    { NA,   2,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  10,  NA },
+    { NA,   1,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  11,  NA },
+    {  0,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  12 },
+    { NA,  23,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  13,  NA },
+    { NA,  22,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  14,  NA },
+    { NA,  NA,  21,  NA,  NA,  NA,  NA,  NA,  15,  NA,  NA },
+    { NA,  NA,  NA,  20,  19,  NA,  17,  16,  NA,  NA,  NA },
+    { NA,  NA,  NA,  NA,  NA,  18,  NA,  NA,  NA,  NA,  NA }
+};
+
 RGBController_CorsairCommanderCore::RGBController_CorsairCommanderCore(CorsairCommanderCoreController* controller_ptr)
 {
     controller  = controller_ptr;
@@ -67,16 +82,26 @@ void RGBController_CorsairCommanderCore::SetupZones()
         first_run = 1;
     }
 
+    std::vector<unsigned short int> led_count = controller->GetLedCounts();
     zones.resize(7);
     zones[0].name                   = "Pump";
     zones[0].type                   = ZONE_TYPE_MATRIX;
-    zones[0].leds_min               = 29;
-    zones[0].leds_max               = 29;
-    zones[0].leds_count             = 29;
+    zones[0].leds_min               = led_count.at(0);
+    zones[0].leds_max               = led_count.at(0);
+    zones[0].leds_count             = led_count.at(0);
     zones[0].matrix_map             = new matrix_map_type;
-    zones[0].matrix_map->height     = 7;
-    zones[0].matrix_map->width      = 7;
-    zones[0].matrix_map->map        = (unsigned int *)&matrix_map;
+    if(led_count.at(0) == 24)
+    {
+        zones[0].matrix_map->height     = 11;
+        zones[0].matrix_map->width      = 11;
+        zones[0].matrix_map->map        = (unsigned int *)&matrix_map24;
+    }
+    else
+    {
+        zones[0].matrix_map->height     = 7;
+        zones[0].matrix_map->width      = 7;
+        zones[0].matrix_map->map        = (unsigned int *)&matrix_map29;
+    }
 
     for(unsigned int i = 1; i < (CORSAIR_COMMANDER_CORE_NUM_CHANNELS + 1); i++)
     {
@@ -87,7 +112,7 @@ void RGBController_CorsairCommanderCore::SetupZones()
 
         if(first_run)
         {
-            zones[i].leds_count     = 0;
+            zones[i].leds_count     = (led_count.size() > i) ? led_count.at(i) : 0;
         }
     }
 

Controllers/CorsairController/CorsairDeviceGuard.cpp

@@ -0,0 +1,64 @@
+/*---------------------------------------------------------*\
+|  CorsairDeviceGuard.h                                     |
+|                                                           |
+|  A DeviceGuard implementation for Corsair devices.        |
+|                                                           |
+|  On Windows platforms, a global mutex is used.            |
+|                                                           |
+|  Evan Mulawski, 2023-09-04                                |
+|                                                           |
+\*---------------------------------------------------------*/
+
+#include "CorsairDeviceGuard.h"
+
+CorsairDeviceGuard::CorsairDeviceGuard() : DeviceGuard()
+{
+#ifdef _WIN32
+    mutex_handle = CreateWindowsMutex();
+#endif
+}
+
+void CorsairDeviceGuard::Acquire()
+{
+#ifdef _WIN32
+    while(true)
+    {
+        DWORD result = WaitForSingleObject(mutex_handle, INFINITE);
+
+        if(result == WAIT_OBJECT_0)
+        {
+            break;
+        }
+
+        if(result == WAIT_ABANDONED)
+        {
+            ReleaseMutex(mutex_handle);
+        }
+    }
+#endif
+}
+
+void CorsairDeviceGuard::Release()
+{
+#ifdef _WIN32
+    ReleaseMutex(mutex_handle);
+#endif
+}
+
+#ifdef _WIN32
+
+HANDLE CorsairDeviceGuard::CreateWindowsMutex()
+{
+    SECURITY_DESCRIPTOR sd;
+    InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
+    SetSecurityDescriptorDacl(&sd, TRUE, NULL, FALSE);
+
+    SECURITY_ATTRIBUTES sa;
+    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
+    sa.lpSecurityDescriptor = &sd;
+    sa.bInheritHandle = FALSE;
+
+    return CreateMutex(&sa, FALSE, "Global\\CorsairLinkReadWriteGuardMutex");
+}
+
+#endif

Controllers/CorsairController/CorsairDeviceGuard.h

@@ -0,0 +1,34 @@
+/*---------------------------------------------------------*\
+|  CorsairDeviceGuard.h                                     |
+|                                                           |
+|  A DeviceGuard implementation for Corsair devices.        |
+|                                                           |
+|  On Windows platforms, a global mutex is used.            |
+|                                                           |
+|  Evan Mulawski, 2023-09-04                                |
+|                                                           |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "DeviceGuard.h"
+
+#ifdef _WIN32
+#include <Windows.h>
+#endif
+
+class CorsairDeviceGuard : public DeviceGuard
+{
+public:
+    CorsairDeviceGuard();
+
+    void Acquire() override;
+    void Release() override;
+
+private:
+#ifdef _WIN32
+    HANDLE mutex_handle;
+
+    HANDLE CreateWindowsMutex();
+#endif
+};

Controllers/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.cpp

@@ -17,6 +17,16 @@
     @effects :x:
     @detectors DetectCorsairDominatorPlatinumControllers
     @comment
+        The Corsair Dominator controller chip can be found on several
+        Corsair memory sticks which have different LED counts. This can be controlled
+        by editing the Part Number in OpenRGB.json with values in the below table.
+
+        | Part Number | LED Count |
+        | :---------: | --------: |
+        | CMG         |  6        |
+        | CMH         | 10        |
+        | CMN         | 10        |
+        | CMT         | 12        |
 \*-------------------------------------------------------------------*/
 
 RGBController_CorsairDominatorPlatinum::RGBController_CorsairDominatorPlatinum(CorsairDominatorPlatinumController* controller_ptr)

Controllers/CorsairHydroPlatinumController/CorsairHydroPlatinumController.cpp

@@ -8,6 +8,7 @@
 \*-------------------------------------------------------------------*/
 
 #include "CorsairHydroPlatinumController.h"
+#include "CorsairDeviceGuard.h"
 #include <cstring>
 
 static const uint8_t CRC_TABLE[256] =
@@ -86,6 +87,7 @@ CorsairHydroPlatinumController::CorsairHydroPlatinumController(hid_device* dev_h
 {
     dev         = dev_handle;
     location    = path;
+    guard_manager_ptr = new DeviceGuardManager(new CorsairDeviceGuard());
 
     SendMagic(MAGIC_1, CORSAIR_HYDRO_PLATINUM_MAGIC_1);
     SendMagic(MAGIC_2, CORSAIR_HYDRO_PLATINUM_MAGIC_2);
@@ -95,6 +97,7 @@ CorsairHydroPlatinumController::CorsairHydroPlatinumController(hid_device* dev_h
 CorsairHydroPlatinumController::~CorsairHydroPlatinumController()
 {
     hid_close(dev);
+    delete guard_manager_ptr;
 }
 
 std::string CorsairHydroPlatinumController::GetLocation()
@@ -152,8 +155,18 @@ void CorsairHydroPlatinumController::SendMagic(const uint8_t* magic, unsigned in
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
-    hid_read(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
+    /*---------------------------------------------------------*\
+    | HID I/O start                                             |
+    \*---------------------------------------------------------*/
+    {
+        DeviceGuardLock _ = guard_manager_ptr->AwaitExclusiveAccess();
+
+        hid_write(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
+        hid_read(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
+    }
+    /*---------------------------------------------------------*\
+    | HID I/O end (lock released)                               |
+    \*---------------------------------------------------------*/
 
     if(firmware_version.empty())
     {
@@ -204,8 +217,17 @@ void CorsairHydroPlatinumController::SendColors(std::vector<RGBColor> colors, un
     checksum_array.insert(checksum_array.begin(), std::begin(usb_buf) + 2, std::end(usb_buf) - 1);
     usb_buf[64] = ComputePEC(static_cast<void*>(checksum_array.data()), 62);
 
-    hid_write(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
-    hid_read(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
+    /*---------------------------------------------------------*\
+    | HID I/O start                                             |
+    \*---------------------------------------------------------*/
+    {
+        DeviceGuardLock _ = guard_manager_ptr->AwaitExclusiveAccess();
+
+        hid_write(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
+    }
+    /*---------------------------------------------------------*\
+    | HID I/O end (lock released)                               |
+    \*---------------------------------------------------------*/
 
     /*-----------------------------------------------------*\
     | This delay prevents the AIO from soft-locking when    |
@@ -242,4 +264,4 @@ uint8_t CorsairHydroPlatinumController::ComputePEC(const void * data, size_t siz
 	}
 
 	return val;
-}
+}

Controllers/CorsairHydroPlatinumController/CorsairHydroPlatinumController.h

@@ -10,6 +10,8 @@
 #pragma once
 
 #include "RGBController.h"
+#include "DeviceGuardManager.h"
+
 #include <vector>
 #include <string>
 #include <hidapi/hidapi.h>
@@ -39,11 +41,11 @@ public:
     void SetupColors(std::vector<RGBColor> colors);
 
 private:
-    hid_device* dev;
-    std::string location;
-    std::string firmware_version;
-
-    std::atomic<unsigned int> sequence_number;
+    hid_device*                 dev;
+    std::string                 location;
+    std::string                 firmware_version;
+    std::atomic<unsigned int>   sequence_number;
+    DeviceGuardManager*         guard_manager_ptr;
 
     void SendMagic(const uint8_t* magic, unsigned int command);
     void SendColors(std::vector<RGBColor> colors, unsigned int start, unsigned int end, unsigned int command);

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

@@ -5,6 +5,7 @@
 \*---------------------------------------------------------*/
 
 #include "CorsairLightingNodeController.h"
+#include "CorsairDeviceGuard.h"
 
 #include <fstream>
 #include <iostream>
@@ -17,6 +18,7 @@ CorsairLightingNodeController::CorsairLightingNodeController(hid_device* dev_han
 {
     dev         = dev_handle;
     location    = path;
+    guard_manager_ptr = new DeviceGuardManager(new CorsairDeviceGuard());
 
     SendFirmwareRequest();
 
@@ -37,6 +39,7 @@ CorsairLightingNodeController::~CorsairLightingNodeController()
     delete keepalive_thread;
 
     hid_close(dev);
+    delete guard_manager_ptr;
 }
 
 void CorsairLightingNodeController::KeepaliveThread()
@@ -176,7 +179,7 @@ void CorsairLightingNodeController::SetChannelLEDs(unsigned char channel, RGBCol
         {
             pkt_size = 50;
         }
-        
+
         for(int color_idx = 0; color_idx < pkt_size; color_idx++)
         {
             red_color_data[color_idx] = RGBGetRValue(colors[pkt_offset + color_idx]);
@@ -205,7 +208,7 @@ void CorsairLightingNodeController::SetChannelLEDs(unsigned char channel, RGBCol
 void CorsairLightingNodeController::SendFirmwareRequest()
 {
     int             actual;
-    unsigned char   usb_buf[65];
+    unsigned char   usb_buf[CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -221,8 +224,7 @@ void CorsairLightingNodeController::SendFirmwareRequest()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    actual = hid_read(dev, usb_buf, 17);
+    actual = WriteAndRead(usb_buf);
 
     if(actual > 0)
     {
@@ -239,7 +241,7 @@ void CorsairLightingNodeController::SendDirect
     unsigned char*  color_data
     )
 {
-    unsigned char   usb_buf[65];
+    unsigned char   usb_buf[CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -264,13 +266,12 @@ void CorsairLightingNodeController::SendDirect
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read_timeout(dev, usb_buf, 17, 5);
+    WriteAndRead(usb_buf, 5);
 }
 
 void CorsairLightingNodeController::SendCommit()
 {
-    unsigned char   usb_buf[65];
+    unsigned char   usb_buf[CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -292,8 +293,7 @@ void CorsairLightingNodeController::SendCommit()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read_timeout(dev, usb_buf, 17, 5);
+    WriteAndRead(usb_buf, 5);
 }
 
 void CorsairLightingNodeController::SendBegin
@@ -301,7 +301,7 @@ void CorsairLightingNodeController::SendBegin
     unsigned char   channel
     )
 {
-    unsigned char   usb_buf[65];
+    unsigned char   usb_buf[CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -318,8 +318,7 @@ void CorsairLightingNodeController::SendBegin
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 17);
+    WriteAndRead(usb_buf);
 }
 
 void CorsairLightingNodeController::SendEffectConfig
@@ -345,7 +344,7 @@ void CorsairLightingNodeController::SendEffectConfig
     unsigned short  temperature_2
     )
 {
-    unsigned char   usb_buf[65];
+    unsigned char   usb_buf[CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -396,8 +395,7 @@ void CorsairLightingNodeController::SendEffectConfig
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 17);
+    WriteAndRead(usb_buf);
 }
 
 void CorsairLightingNodeController::SendTemperature()
@@ -410,7 +408,7 @@ void CorsairLightingNodeController::SendReset
     unsigned char   channel
     )
 {
-    unsigned char   usb_buf[65];
+    unsigned char   usb_buf[CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -427,8 +425,7 @@ void CorsairLightingNodeController::SendReset
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 17);
+    WriteAndRead(usb_buf);
 }
 
 void CorsairLightingNodeController::SendPortState
@@ -437,7 +434,7 @@ void CorsairLightingNodeController::SendPortState
     unsigned char   state
     )
 {
-    unsigned char   usb_buf[65];
+    unsigned char   usb_buf[CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -455,8 +452,7 @@ void CorsairLightingNodeController::SendPortState
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read_timeout(dev, usb_buf, 17, 5);
+    WriteAndRead(usb_buf, 5);
 }
 
 void CorsairLightingNodeController::SendBrightness
@@ -465,7 +461,7 @@ void CorsairLightingNodeController::SendBrightness
     unsigned char   brightness
     )
 {
-    unsigned char   usb_buf[65];
+    unsigned char   usb_buf[CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE];
 
     /*-----------------------------------------------------*\
     | Brightness goes from 0-100                            |
@@ -491,8 +487,7 @@ void CorsairLightingNodeController::SendBrightness
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 17);
+    WriteAndRead(usb_buf);
 }
 
 void CorsairLightingNodeController::SendLEDCount()
@@ -504,3 +499,34 @@ void CorsairLightingNodeController::SendProtocol()
 {
 
 }
+
+int CorsairLightingNodeController::WriteAndRead
+    (
+    unsigned char *buf,
+    int read_timeout_ms
+    )
+{
+    int hid_read_ret;
+
+    /*---------------------------------------------------------*\
+    | HID I/O start                                             |
+    \*---------------------------------------------------------*/
+    {
+        DeviceGuardLock _ = guard_manager_ptr->AwaitExclusiveAccess();
+
+        hid_write(dev, buf, CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE);
+        if(read_timeout_ms > 0)
+        {
+            hid_read_ret = hid_read_timeout(dev, buf, CORSAIR_LIGHTING_NODE_READ_PACKET_SIZE, read_timeout_ms);
+        }
+        else
+        {
+            hid_read_ret = hid_read(dev, buf, CORSAIR_LIGHTING_NODE_READ_PACKET_SIZE);
+        }
+    }
+    /*---------------------------------------------------------*\
+    | HID I/O end (lock released)                               |
+    \*---------------------------------------------------------*/
+
+    return hid_read_ret;
+}

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.h

@@ -4,13 +4,18 @@
 |  Adam Honse ([email protected]), 1/12/2020        |
 \*---------------------------------------------------------*/
 
+#include "DeviceGuardManager.h"
 #include "RGBController.h"
+
 #include <chrono>
 #include <vector>
 #include <hidapi/hidapi.h>
 
 #pragma once
 
+#define CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE      65          /* First byte is the report number      */
+#define CORSAIR_LIGHTING_NODE_READ_PACKET_SIZE       17          /* First byte is the report number      */
+
 enum
 {
     CORSAIR_LIGHTING_NODE_PACKET_ID_FIRMWARE         = 0x02,     /* Get firmware version                 */
@@ -89,7 +94,7 @@ public:
     unsigned int    GetStripsOnChannel(unsigned int channel);
 
     void            SetBrightness(unsigned char brightness);
-    
+
     void            SetChannelEffect(unsigned char channel,
                                      unsigned char num_leds,
                                      unsigned char mode,
@@ -112,12 +117,13 @@ public:
     void            KeepaliveThread();
 
 private:
-    hid_device*             dev;
-    std::string             firmware_version;
-    std::string             location;
-    std::thread*            keepalive_thread;
-    std::atomic<bool>       keepalive_thread_run;
-    std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
+    hid_device*                                         dev;
+    std::string                                         firmware_version;
+    std::string                                         location;
+    std::thread*                                        keepalive_thread;
+    std::atomic<bool>                                   keepalive_thread_run;
+    std::chrono::time_point<std::chrono::steady_clock>  last_commit_time;
+    DeviceGuardManager*                                 guard_manager_ptr;
 
     void            SendFirmwareRequest();
 
@@ -182,4 +188,10 @@ private:
     void            SendLEDCount();
 
     void            SendProtocol();
+
+    int             WriteAndRead
+                        (
+                        unsigned char *buf,
+                        int read_timeout_ms = -1
+                        );
 };

Controllers/CorsairPeripheralController/CorsairK100Controller.cpp

@@ -1,172 +0,0 @@
-/*-----------------------------------------*\
-|  CorsairK100Controller.cpp                |
-|                                           |
-|  Driver for Corsair K100 Keyboard         |
-\*-----------------------------------------*/
-
-#include "CorsairK100Controller.h"
-#include "LogManager.h"
-
-static unsigned int keys_k100[] = {0x25, 0x31, 0x27, 0x35, 0x66, 0x65, 0x41, 0x2A, 0x6E, 0x5B, 0x36, 0x1A, 0x10, 0x00, 0x68, 0x42,
-                                   0x62, 0x5C, 0x37, 0x1B, 0x16, 0x12, 0x19, 0x67, 0x43, 0x26, 0x77, 0x5D, 0x38, 0x1C, 0x04, 0x03,
-                                   0x17, 0x44, 0x48, 0x7A, 0x39, 0x1D, 0x11, 0x05, 0x02, 0x28, 0x45, 0x49, 0x78, 0x58, 0x3A, 0x1E,
-                                   0x13, 0x06, 0x15, 0x46, 0x4A, 0x79, 0x59, 0x3B, 0x1F, 0x18, 0x07, 0x01, 0x47, 0x6A, 0x4F, 0x5A,
-                                   0x3C, 0x20, 0x14, 0x09, 0x0D, 0x6B, 0x2C, 0x69, 0x50, 0x55, 0x3D, 0x21, 0x08, 0x0A, 0x0C, 0x76,
-                                   0x2D, 0x4E, 0x51, 0x56, 0x3E, 0x22, 0x0E, 0x0B, 0x32, 0x61, 0x4C, 0x52, 0x57, 0x3F, 0x23, 0x0F,
-                                   0x2F, 0x33, 0x24, 0x4D, 0x53, 0x5E, 0x40, 0x29, 0x2B, 0x30, 0x34, /*Brightness,*/
-                                   0x4B, 0x54, 0x5F, 0x60, 0x2E, 0x7C,
-                                   0x7F, 0x80, 0x81, 0x82, 0x83, 0x84,//Macro
-                                   0xA6, 0xA5, 0xA4, 0xA3, 0xA2, 0xA1, 0xA0, 0x9F, 0x9E, 0x9D, 0x9C, 0x86, 0x87, 0x88, 0x89, 0x8A,
-                                   0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A,
-                                   0x9B, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,0xB0, 0xB1, //Light Bar
-                                   0x85, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9,//Nameplate
-                                   0xBA, 0xBB, 0xBC/*Logo*/};
-
-CorsairK100Controller::CorsairK100Controller(hid_device* dev_handle, const char* path)
-{
-    dev             = dev_handle;
-    location        = path;
-    keyboard_type   = CORSAIR_TYPE_K100;
-
-    LightingControl();
-}
-CorsairK100Controller::~CorsairK100Controller()
-{
-    hid_close(dev);
-}
-
-std::string CorsairK100Controller::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string CorsairK100Controller::GetFirmwareString()
-{
-    return "";
-}
-
-std::string CorsairK100Controller::GetName()
-{
-    return name;
-}
-
-void CorsairK100Controller::SetName(std::string device_name)
-{
-    name = device_name;
-}
-
-CorsairKeyboardType CorsairK100Controller::GetKeyboardType()
-{
-    return keyboard_type;
-}
-
-std::string CorsairK100Controller::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-void CorsairK100Controller::LightingControl()
-{
-    unsigned char usb_buf[65];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    //This is requered
-    usb_buf[0x01] = 0x08;
-    usb_buf[0x02] = 0x01;
-    usb_buf[0x03] = 0x03;
-    usb_buf[0x05] = 0x02;
-
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x01] = 0x08;
-    usb_buf[0x02] = 0x01;
-    usb_buf[0x03] = 0x4A;
-    usb_buf[0x05] = 0x01;
-
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x01] = 0x08;
-    usb_buf[0x02] = 0x01;
-    usb_buf[0x03] = 0x45;
-    usb_buf[0x05] = 0x00;
-
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    //This is requered
-    usb_buf[0x01] = 0x08;
-    usb_buf[0x02] = 0x0D;
-    usb_buf[0x03] = 0x01;
-    usb_buf[0x04] = 0x22;
-
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-
-    /*memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x01] = 0x08;
-    usb_buf[0x02] = 0x05;
-    usb_buf[0x03] = 0x01;
-
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    int res = hid_read_timeout(dev, usb_buf, 50, 1000);
-
-    if (res == 0 || usb_buf[1] != 0x01)
-    {
-        LOG_INFO("[Corsair-K100] This device did not allow to take control over it. recieved response: %02X", usb_buf[1]);
-        keyboard_type = CORSAIR_TYPE_UNKNOWN;
-    }*/
-
-}
-
-void CorsairK100Controller::SetLEDs(std::vector<RGBColor>colors)
-{
-    switch(keyboard_type)
-    {
-        case CORSAIR_TYPE_K100:
-            SetLEDsKeyboardFull(colors);
-            break;
-
-        case CORSAIR_TYPE_UNKNOWN:
-            break;
-    }
-}
-
-void CorsairK100Controller::SetLEDsKeyboardFull(std::vector<RGBColor> colors)
-{
-    unsigned char usb_buf[600];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x01] = 0x08;
-    usb_buf[0x02] = 0x06;
-    usb_buf[0x03] = 0x01;
-    usb_buf[0x04] = 0x45;
-    usb_buf[0x05] = 0x02;
-    usb_buf[0x08] = 0x12;
-
-    for(std::size_t color_idx = 0; color_idx < colors.size(); color_idx++)
-    {
-        RGBColor color = colors[color_idx];
-        usb_buf[0x16 + keys_k100[color_idx]*3] = RGBGetRValue(color);
-        usb_buf[0x17 + keys_k100[color_idx]*3] = RGBGetGValue(color);
-        usb_buf[0x18 + keys_k100[color_idx]*3] = RGBGetBValue(color);
-    }
-
-    hid_write(dev, (unsigned char *)usb_buf, 600);
-}

Controllers/CorsairPeripheralController/CorsairK100Controller.h

@@ -1,49 +0,0 @@
-/*-----------------------------------------*\
-|  CorsairK100Controller.h                  |
-|                                           |
-|  Driver for Corsair K100 Keyboard         |
-\*-----------------------------------------*/
-
-#ifndef CORSAIRK100CONTROLLER_H
-#define CORSAIRK100CONTROLLER_H
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-typedef enum
-{
-    CORSAIR_TYPE_UNKNOWN            = 0,
-    CORSAIR_TYPE_K100               = 1
-} CorsairKeyboardType;
-
-class CorsairK100Controller
-{
-public:
-    CorsairK100Controller(hid_device* dev_handle, const char* path);
-    ~CorsairK100Controller();
-    CorsairKeyboardType             GetKeyboardType();
-    std::string                     GetDeviceLocation();
-    std::string                     GetFirmwareString();
-    std::string                     GetName();
-    std::string                     GetSerialString();
-
-    void                            SetLEDs(std::vector<RGBColor> colors);
-    void                            SetLEDsKeyboardLimited(std::vector<RGBColor> colors);
-    void                            SetName(std::string device_name);
-
-private:
-    hid_device*             dev;
-
-    std::string             firmware_version;
-    std::string             location;
-    std::string             name;
-    device_type             type;
-    CorsairKeyboardType     keyboard_type;
-
-    void                    LightingControl();
-    void                    SetLEDsKeyboardFull(std::vector<RGBColor> colors);
-};
-
-#endif // CORSAIRK100CONTROLLER_H

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -3,7 +3,6 @@
 \*-----------------------------------------------------*/
 #include <hidapi/hidapi.h>
 #include "Detector.h"
-#include "CorsairK55RGBPROXTController.h"
 #include "LogManager.h"
 #include "RGBController.h"
 
@@ -11,7 +10,6 @@
 | Corsair Peripheral specific includes                  |
 \*-----------------------------------------------------*/
 #include "RGBController_CorsairPeripheral.h"
-#include "RGBController_CorsairK100.h"
 #include "RGBController_CorsairK55RGBPROXT.h"
 #include "RGBController_CorsairK65Mini.h"
 #include "RGBController_CorsairK95PlatinumXT.h"
@@ -34,7 +32,7 @@
 #define CORSAIR_K65_LUX_RGB_PID         0x1B37
 #define CORSAIR_K65_RGB_RAPIDFIRE_PID   0x1B39
 
-#define CORSAIR_K68_RGB                 0x1B4F
+#define CORSAIR_K68_RGB_PID             0x1B4F
 
 #define CORSAIR_K70_RGB_PID             0x1B13
 #define CORSAIR_K70_LUX_RGB_PID         0x1B33
@@ -54,6 +52,7 @@
 | Non-RGB Keyboard product IDs                          |
 \*-----------------------------------------------------*/
 #define CORSAIR_K70_LUX_PID             0x1B36
+#define CORSAIR_K68_RED_PID             0x1B3F
 
 /*-----------------------------------------------------*\
 | Mouse product IDs                                     |
@@ -85,13 +84,6 @@
 \*-----------------------------------------------------*/
 #define CORSAIR_ST100_PID               0x0A34
 
-/*-----------------------------------------------------*\
-| Corsair K100 Keyboard product ID                      |
-| This keyboard uses a separate driver                  |
-\*-----------------------------------------------------*/
-#define CORSAIR_K100_OPTICAL_PID                0x1B7C
-#define CORSAIR_K100_MXRED_PID                  0x1B7D
-
 /*-----------------------------------------------------*\
 | Corsair K55 RGB PRO XT Keyboard product ID            |
 | This keyboard uses a separate driver                  |
@@ -110,27 +102,6 @@
 \*-----------------------------------------------------*/
 #define CORSAIR_K95_PLATINUM_XT_PID     0x1B89
 
-void DetectCorsairK100Controllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        CorsairK100Controller* controller = new CorsairK100Controller(dev, info->path);
-        controller->SetName(name);
-
-        if(controller->GetKeyboardType() != CORSAIR_TYPE_UNKNOWN)
-        {
-            RGBController_CorsairK100* rgb_controller = new RGBController_CorsairK100(controller);
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
-        }
-        else
-        {
-            delete controller;
-        }
-    }
-}   /* DetectCorsairPeripheralControllers() */
-
 void DetectCorsairK55RGBPROXTControllers(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -212,7 +183,8 @@ REGISTER_HID_DETECTOR_IP("Corsair K55 RGB",                 DetectCorsairPeriphe
 REGISTER_HID_DETECTOR_IP("Corsair K65 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_PID,            1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K65 LUX RGB",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_LUX_RGB_PID,        1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K65 RGB RAPIDFIRE",       DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_RAPIDFIRE_PID,  1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K68 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K68_RGB,                1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K68 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K68_RGB_PID,            1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K68 RED",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K68_RED_PID,            1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K70 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_PID,            1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K70 LUX",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_LUX_PID,            1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K70 LUX RGB",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_LUX_RGB_PID,        1, 0xFFC2);
@@ -259,12 +231,6 @@ REGISTER_HID_DETECTOR_P("Corsair ST100 RGB",                DetectCorsairPeriphe
 REGISTER_HID_DETECTOR_I("Corsair ST100 RGB",                DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_ST100_PID,              0);
 #endif
 
-/*-----------------------------------------------------------------------------------------------------*\
-| Corsair K100 Keyboard                                                                                 |
-\*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Corsair K100",                    DetectCorsairK100Controllers,       CORSAIR_VID, CORSAIR_K100_OPTICAL_PID,       1, 0xFF42);
-REGISTER_HID_DETECTOR_IP("Corsair K100",                    DetectCorsairK100Controllers,       CORSAIR_VID, CORSAIR_K100_MXRED_PID,         1, 0xFF42);
-
 /*-----------------------------------------------------------------------------------------------------*\
 | Corsair K65 Mini Keyboard                                                                             |
 \*-----------------------------------------------------------------------------------------------------*/

Controllers/CorsairPeripheralController/RGBController_CorsairK100.cpp

@@ -1,383 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_CorsairK100.cpp            |
-|                                           |
-|  Driver for Corsair K100 Keyboard         |
-\*-----------------------------------------*/
-
-#include "RGBControllerKeyNames.h"
-#include "RGBController_CorsairK100.h"
-#include "LogManager.h"
-
-using namespace std::chrono_literals;
-
-#define NA  0xFFFFFFFF
-
-static unsigned int matrix_map_k100[7][24] =
-    { {  NA, 112,  NA,   8,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  16,  NA,  NA,  NA,},
-      { 113,   0,  NA,  10,  18,  28,  36,  NA,  46,  55,  64,  74,  NA,  84,  93, 102,   6,  15,  24,  33,  26,  35,  44,  53 },
-      { 114,   1,  11,  19,  29,  37,  47,  56,  65,  75,  85,  94,  NA, 103,   7,  25,  NA,  42,  51,  60,  62,  72,  82,  91 },
-      { 115,   2,  NA,  12,  20,  30,  38,  NA,  48,  57,  66,  76,  86,  95, 104,  70,  80,  34,  43,  52,  9,   17,  27, 100 },
-      { 116,   3,  NA,  13,  21,  31,  39,  NA,  49,  58,  67,  77,  87,  96, 105,  98, 111,  NA,  NA,  NA,  45,  54,  63,  NA },
-      { 117,   4, 110,  22,  32,  40,  50,  NA,  59,  NA,  68,  78,  88,  97, 106,  61,  NA,  NA,  81,  NA,  73,  83,  92, 108 },
-      { 118,   5,  14,  23,  NA,  NA,  NA,  NA,  41,  NA,  NA,  NA,  NA,  69,  79,  89,  71,  90,  99, 107, 101,  NA, 109,  NA } };
-
-static const char* led_names_k100[] =
-{
-    KEY_EN_ESCAPE,              //0
-    KEY_EN_BACK_TICK,           //1
-    KEY_EN_TAB,                 //2
-    KEY_EN_CAPS_LOCK,           //3
-    KEY_EN_LEFT_SHIFT,          //4
-    KEY_EN_LEFT_CONTROL,        //5
-    KEY_EN_F12,                 //6
-    KEY_EN_EQUALS,              //7
-    "Key: Lock",                //8
-    KEY_EN_NUMPAD_7,            //9
-    KEY_EN_F1,                  //12
-    KEY_EN_1,                   //13
-    KEY_EN_Q,                   //14
-    KEY_EN_A,                   //15
-    KEY_EN_LEFT_WINDOWS,        //17
-    KEY_EN_PRINT_SCREEN,        //18
-    KEY_EN_MEDIA_MUTE,          //20
-    KEY_EN_NUMPAD_8,            //21
-    KEY_EN_F2,                  //24
-    KEY_EN_2,                   //25
-    KEY_EN_W,                   //26
-    KEY_EN_S,                   //27
-    KEY_EN_Z,                   //28
-    KEY_EN_LEFT_ALT,            //29
-    KEY_EN_SCROLL_LOCK,         //30
-    KEY_EN_BACKSPACE,           //31
-    KEY_EN_MEDIA_STOP,          //32
-    KEY_EN_NUMPAD_9,            //33
-    KEY_EN_F3,                  //36
-    KEY_EN_3,                   //37
-    KEY_EN_E,                   //38
-    KEY_EN_D,                   //39
-    KEY_EN_X,                   //40
-    KEY_EN_PAUSE_BREAK,         //42
-    KEY_EN_DELETE,              //43
-    KEY_EN_MEDIA_PREVIOUS,      //44
-    KEY_EN_F4,                  //48
-    KEY_EN_4,                   //49
-    KEY_EN_R,                   //50
-    KEY_EN_F,                   //51
-    KEY_EN_C,                   //52
-    KEY_EN_SPACE,               //53
-    KEY_EN_INSERT,              //54
-    KEY_EN_END,                 //55
-    KEY_EN_MEDIA_PLAY_PAUSE,    //56
-    KEY_EN_NUMPAD_4,            //57
-    KEY_EN_F5,                  //60
-    KEY_EN_5,                   //61
-    KEY_EN_T,                   //62
-    KEY_EN_G,                   //63
-    KEY_EN_V,                   //64
-    KEY_EN_HOME,                //66
-    KEY_EN_PAGE_DOWN,           //67
-    KEY_EN_MEDIA_NEXT,          //68
-    KEY_EN_NUMPAD_5,            //69
-    KEY_EN_F6,                  //72
-    KEY_EN_6,                   //73
-    KEY_EN_Y,                   //74
-    KEY_EN_H,                   //75
-    KEY_EN_B,                   //76
-    KEY_EN_PAGE_UP,             //78
-    KEY_EN_RIGHT_SHIFT,         //79
-    KEY_EN_NUMPAD_LOCK,         //80
-    KEY_EN_NUMPAD_6,            //81
-    KEY_EN_F7,                  //84
-    KEY_EN_7,                   //85
-    KEY_EN_U,                   //86
-    KEY_EN_J,                   //87
-    KEY_EN_N,                   //88
-    KEY_EN_RIGHT_ALT,           //89
-    KEY_EN_RIGHT_BRACKET,       //90
-    KEY_EN_RIGHT_CONTROL,       //91
-    KEY_EN_NUMPAD_DIVIDE,       //92
-    KEY_EN_NUMPAD_1,            //93
-    KEY_EN_F8,                  //96
-    KEY_EN_8,                   //97
-    KEY_EN_I,                   //98
-    KEY_EN_K,                   //99
-    KEY_EN_M,                   //100
-    KEY_EN_RIGHT_WINDOWS,       //101
-    KEY_EN_ANSI_BACK_SLASH,     //102
-    KEY_EN_UP_ARROW,            //103
-    KEY_EN_NUMPAD_TIMES,        //104
-    KEY_EN_NUMPAD_2,            //105
-    KEY_EN_F9,                  //108
-    KEY_EN_9,                   //109
-    KEY_EN_O,                   //110
-    KEY_EN_L,                   //111
-    KEY_EN_COMMA,               //112
-    KEY_EN_MENU,                //113
-    KEY_EN_LEFT_ARROW,          //115
-    KEY_EN_NUMPAD_MINUS,        //116
-    KEY_EN_NUMPAD_3,            //117
-    KEY_EN_F10,                 //120
-    KEY_EN_0,                   //121
-    KEY_EN_P,                   //122
-    KEY_EN_SEMICOLON,           //123
-    KEY_EN_PERIOD,              //124
-    KEY_EN_ANSI_ENTER,          //126
-    KEY_EN_DOWN_ARROW,          //127
-    KEY_EN_NUMPAD_PLUS,         //128
-    KEY_EN_NUMPAD_0,            //129
-    KEY_EN_F11,                 //132
-    KEY_EN_MINUS,               //133
-    KEY_EN_LEFT_BRACKET,        //134
-    KEY_EN_QUOTE,               //135
-    KEY_EN_FORWARD_SLASH,       //136
-    //    "Key: Brightness",    //137
-    KEY_EN_RIGHT_ARROW,         //139
-    KEY_EN_NUMPAD_ENTER,        //140
-    KEY_EN_NUMPAD_PERIOD,       //141
-    "Key: / (ISO)",
-    KEY_EN_ISO_BACK_SLASH,
-    "Key: Preset",
-    "Key: G1",
-    "Key: G2",
-    "Key: G3",
-    "Key: G4",
-    "Key: G5",
-    "Key: G6",
-};
-static const char* led_names_lightbar[] =
-{
-    "Underglow 1",
-    "Underglow 2",
-    "Underglow 3",
-    "Underglow 4",
-    "Underglow 5",
-    "Underglow 6",
-    "Underglow 7",
-    "Underglow 8",
-    "Underglow 9",
-    "Underglow 10",
-    "Underglow 11",
-    "Underglow 12",
-    "Underglow 13",
-    "Underglow 14",
-    "Underglow 15",
-    "Underglow 16",
-    "Underglow 17",
-    "Underglow 18",
-    "Underglow 19",
-    "Underglow 20",
-    "Underglow 21",
-    "Underglow 22",
-    "Underglow 23",
-    "Underglow 24",
-    "Underglow 25",
-    "Underglow 26",
-    "Underglow 27",
-    "Underglow 28",
-    "Underglow 29",
-    "Underglow 30",
-    "Underglow 31",
-    "Underglow 32",
-    "Underglow 33",
-    "Underglow 34",
-    "Underglow 35",
-    "Underglow 36",
-    "Underglow 37",
-    "Underglow 38",
-    "Underglow 39",
-    "Underglow 40",
-    "Underglow 41",
-    "Underglow 42",
-    "Underglow 43",
-    "Underglow 44",
-};
-static const char* led_names_nameplate[] =
-{
-    "Nameplate 1",
-    "Nameplate 2",
-    "Nameplate 3",
-    "Nameplate 4",
-    "Nameplate 5",
-    "Nameplate 6",
-    "Nameplate 7",
-    "Nameplate 8",
-    "Nameplate 9",
-};
-static const char* led_names_logo[] =
-{
-    "Logo",
-    "Logo",
-    "Logo",
-};
-
-typedef struct
-{
-    const char* name;
-    const unsigned int size;
-    const zone_type type;
-    const char** led_names;
-    matrix_map_type* matrix;
-} led_zone_layout;
-
-/**------------------------------------------------------------------*\
-    @name Corsair K100 Keyboard
-    @category Keyboard
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectCorsairK100Controllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_CorsairK100::RGBController_CorsairK100(CorsairK100Controller* controller_ptr)
-{
-    controller      = controller_ptr;
-
-    name            = controller->GetName();
-    vendor          = "Corsair";
-    description     = "Corsair K100 Keyboard Device";
-    type            = DEVICE_TYPE_KEYBOARD;
-    version         = controller->GetFirmwareString();
-    location        = controller->GetDeviceLocation();
-    serial          = controller->GetSerialString();
-
-    logical_layout  = controller->GetKeyboardType();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-
-    /*-----------------------------------------------------*\
-    | The Corsair K100 requires a packet within             |
-    | 1 minutes of sending the lighting change in order     |
-    | to not revert back into rainbow mode.  Start a thread |
-    | to continuously send a keepalive packet every 50 sec  |
-    \*-----------------------------------------------------*/
-    keepalive_thread_run = true;
-    keepalive_thread = new std::thread(&RGBController_CorsairK100::KeepaliveThread, this);
-}
-
-RGBController_CorsairK100::~RGBController_CorsairK100()
-{
-    /*-----------------------------------------------------*\
-    | Close keepalive thread                                |
-    \*-----------------------------------------------------*/
-    keepalive_thread_run = false;
-    keepalive_thread->join();
-    delete keepalive_thread;
-
-    /*---------------------------------------------------------*\
-    | Delete the matrix map                                     |
-    \*---------------------------------------------------------*/
-    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
-    {
-        if(zones[zone_index].type == ZONE_TYPE_MATRIX)
-        {
-            delete zones[zone_index].matrix_map;
-        }
-    }
-
-    delete controller;
-}
-
-void RGBController_CorsairK100::SetupZones()
-{
-    std::vector<led_zone_layout> selected_zone;
-
-    switch(logical_layout)
-    {
-        case CORSAIR_TYPE_K100:
-            selected_zone.push_back({ZONE_EN_KEYBOARD,  119,    ZONE_TYPE_MATRIX, led_names_k100, new matrix_map_type{7, 24, (unsigned int *)&matrix_map_k100}});
-            selected_zone.push_back({"Underglow",       44,     ZONE_TYPE_LINEAR, led_names_lightbar, NULL});
-            selected_zone.push_back({"Nameplate",       9,      ZONE_TYPE_LINEAR, led_names_nameplate, NULL});
-            selected_zone.push_back({"Logo",            3,      ZONE_TYPE_LINEAR, led_names_logo, NULL});
-            break;
-
-        case CORSAIR_TYPE_UNKNOWN:
-            break;
-    }
-
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    for(unsigned int zone_idx = 0; zone_idx < selected_zone.size(); zone_idx++)
-    {
-        zone new_zone;
-
-        new_zone.name                   = selected_zone[zone_idx].name;
-        new_zone.type                   = selected_zone[zone_idx].type;
-        new_zone.leds_min               = selected_zone[zone_idx].size;
-        new_zone.leds_max               = selected_zone[zone_idx].size;
-        new_zone.leds_count             = selected_zone[zone_idx].size;
-
-        if (new_zone.type == ZONE_TYPE_MATRIX)
-        {
-            new_zone.matrix_map         = selected_zone[zone_idx].matrix;
-        }
-        else
-        {
-            new_zone.matrix_map         = NULL;
-        }
-
-        zones.push_back(new_zone);
-
-        for(unsigned int led_idx = 0; led_idx < selected_zone[zone_idx].size; led_idx++)
-        {
-            led new_led;
-            new_led.name = selected_zone[zone_idx].led_names[led_idx];
-            leds.push_back(new_led);
-        }
-    }
-
-    SetupColors();
-}
-
-void RGBController_CorsairK100::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_CorsairK100::DeviceUpdateLEDs()
-{
-    last_update_time = std::chrono::steady_clock::now();
-
-    controller->SetLEDs(colors);
-}
-
-void RGBController_CorsairK100::UpdateZoneLEDs(int /*zone*/)
-{
-    controller->SetLEDs(colors);
-}
-
-void RGBController_CorsairK100::UpdateSingleLED(int /*led*/)
-{
-    controller->SetLEDs(colors);
-}
-
-void RGBController_CorsairK100::DeviceUpdateMode()
-{
-
-}
-
-void RGBController_CorsairK100::KeepaliveThread()
-{
-    while(keepalive_thread_run.load())
-    {
-        if(active_mode == 0)
-        {
-            if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50000))
-            {
-                DeviceUpdateLEDs();
-            }
-        }
-        std::this_thread::sleep_for(3000ms);
-    }
-}

Controllers/CorsairPeripheralController/RGBController_CorsairK100.h

@@ -1,40 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_CorsairK100.cpp            |
-|                                           |
-|  Driver for Corsair K100 Keyboard         |
-\*-----------------------------------------*/
-
-#ifndef RGBCONTROLLER_CORSAIRK100_H
-#define RGBCONTROLLER_CORSAIRK100_H
-
-#include "RGBController.h"
-#include "CorsairK100Controller.h"
-
-class RGBController_CorsairK100 : public RGBController
-{
-public:
-    RGBController_CorsairK100(CorsairK100Controller* controller_ptr);
-    ~RGBController_CorsairK100();
-
-    void SetupZones();
-    void ResizeZone(int zone, int new_size);
-
-    void DeviceUpdateLEDs();
-    void UpdateZoneLEDs(int zone);
-    void UpdateSingleLED(int led);
-
-    void DeviceUpdateMode();
-
-    void KeepaliveThread();
-
-private:
-    CorsairK100Controller*                              controller;
-    CorsairKeyboardType                                 logical_layout;
-
-    std::thread*                                        keepalive_thread;
-    std::atomic<bool>                                   keepalive_thread_run;
-    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
-
-};
-
-#endif // RGBCONTROLLER_CORSAIRK100_H

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.cpp

@@ -36,7 +36,8 @@ CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_han
 
     switch(pid)
     {
-        case CORSAIR_SLIPSTREAM_WIRELESS_PID:
+        case CORSAIR_SLIPSTREAM_WIRELESS_PID1:
+        case CORSAIR_SLIPSTREAM_WIRELESS_PID2:
             write_cmd   = CORSAIR_V2_WRITE_WIRELESS_ID;
             pid         = GetAddress(0x12);
             break;

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2ControllerDetect.cpp

@@ -28,7 +28,8 @@ void DetectCorsairV2HardwareControllers(hid_device_info* info, const std::string
     {
         CorsairPeripheralV2HWController*    controller      = new CorsairPeripheralV2HWController(dev, info->path, name);
         RGBController_CorsairV2HW*          rgb_controller  = new RGBController_CorsairV2HW(controller);
-        if(info->product_id == CORSAIR_SLIPSTREAM_WIRELESS_PID)
+        if(info->product_id == CORSAIR_SLIPSTREAM_WIRELESS_PID1
+        || info->product_id == CORSAIR_SLIPSTREAM_WIRELESS_PID2)
         {
             rgb_controller->name                            = controller->GetName();
         }
@@ -60,19 +61,28 @@ void DetectCorsairV2SoftwareControllers(hid_device_info* info, const std::string
 REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO",                     DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K55_RGB_PRO_PID,                1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO",                     DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_PID,                1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO Low Profile",         DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_LP_PID,             1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO TKL",                 DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_TKL_PID,            1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K70 RGB PRO",                     DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K70_RGB_PRO_PID,                1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K70 RGB TKL",                     DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K70_RGB_TKL_PID,                1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K70 RGB TKL Champion Series",     DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K70_RGB_TKL_CS_PID,             1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K100 RGB Optical",                DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K100_OPTICAL_V1_PID,            1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K100 RGB Optical",                DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K100_OPTICAL_V2_PID,            1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K100 MX Red",                     DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K100_MXRED_PID,                 1,  0xFF42);
 
 /*-----------------------------------------------------------------------------------------------------*\
 | Mice                                                                                                  |
 \*-----------------------------------------------------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IP("Corsair Dark Core RGB SE (Wired)",        DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_DARK_CORE_RGB_PID,              1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair Dark Core RGB Pro SE (Wired)",    DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_DARK_CORE_RGB_PRO_PID,          1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair Harpoon Wireless (Wired)",        DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_HARPOON_WIRELESS_PID,           1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair Ironclaw Wireless (Wired)",       DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_IRONCLAW_WIRELESS_PID,          1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair Katar Pro",                       DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_KATAR_PRO_PID,                  1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair Katar Pro V2",                    DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_KATAR_PRO_V2_PID,               1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair Katar Pro XT",                    DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_KATAR_PRO_XT_PID,               1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair M55 RGB PRO",                     DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_M55_RGB_PRO_PID,                1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair M65 Ultra RGB (Wired)",           DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_M65_ULTRA_RGB_PID,              1,  0xFF42);
-REGISTER_HID_DETECTOR_IP("Corsair Slipstream Wireless Receiver",    DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_SLIPSTREAM_WIRELESS_PID,        1,  0xFF42);
-
+REGISTER_HID_DETECTOR_IP("Corsair Slipstream Wireless Receiver HW", DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_SLIPSTREAM_WIRELESS_PID1,       1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair Slipstream Wireless Receiver SW", DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_SLIPSTREAM_WIRELESS_PID2,       1,  0xFF42);
 /*-----------------------------------------------------------------------------------------------------*\
 | Mousemat                                                                                              |
 \*-----------------------------------------------------------------------------------------------------*/

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.cpp

@@ -49,10 +49,44 @@ keyboard_keymap_overlay_values corsair_K60_layout
         }
     },
     {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
-        \*---------------------------------------------------------------------------------------------------------*/
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Name,                       Translated Name,            OpCode                              |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
+    }
+};
+
+keyboard_keymap_overlay_values corsair_K60_tkl_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_TKL,
+    {
+        corsair_tkl_values,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Name,                       Translated Name,            OpCode                              |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
+    }
+};
+
+keyboard_keymap_overlay_values corsair_k70_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
+    {
+        corsair_full_size_values,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Name,                       Translated Name,            OpCode                              |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
     }
 };
 
@@ -66,20 +100,114 @@ keyboard_keymap_overlay_values corsair_K70_TKL_cs_layout
         }
     },
     {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
-        \*---------------------------------------------------------------------------------------------------------*/
-        {   0,      0,       1,         123,        KEY_EN_MEDIA_STOP,          KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Stop Key into new media keys row
-        {   0,      0,       2,         126,        KEY_EN_MEDIA_PREVIOUS,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Previous Track Key
-        {   0,      0,       3,         124,        KEY_EN_MEDIA_PLAY_PAUSE,    KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play Pause Key
-        {   0,      0,       4,         125,        KEY_EN_MEDIA_NEXT,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Next Tack Key
-        {   0,      0,       7,           1,        "Logo L",                   KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert 'Logo Left'
-        {   0,      0,       8,           3,        "Logo R",                   KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert 'Logo Right'
-        {   0,      0,      11,         128,        "Profile",                  KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Profile
-        {   0,      0,      12,         113,        "Light",                    KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Light key
-        {   0,      0,      13,         114,        "Lock",                     KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lock Key
-        {   0,      0,      14,         102,        KEY_EN_MEDIA_MUTE,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mute Key
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Name,                       Translated Name,            OpCode,                             |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
+        {   0,      0,       1,         123,        KEY_EN_MEDIA_STOP,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Stop Key into new media keys row
+        {   0,      0,       2,         126,        KEY_EN_MEDIA_PREVIOUS,      KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Previous Track Key
+        {   0,      0,       3,         124,        KEY_EN_MEDIA_PLAY_PAUSE,    KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play Pause Key
+        {   0,      0,       4,         125,        KEY_EN_MEDIA_NEXT,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Next Tack Key
+        {   0,      0,       7,           1,        "Logo L",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert 'Logo Left'
+        {   0,      0,       8,           3,        "Logo R",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert 'Logo Right'
+        {   0,      0,      11,         128,        "Profile",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Profile
+        {   0,      0,      12,         113,        "Light",                    KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Light key
+        {   0,      0,      13,         114,        "Lock",                     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lock Key
+        {   0,      0,      14,         102,        KEY_EN_MEDIA_MUTE,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mute Key
+    }
+};
+
+keyboard_keymap_overlay_values corsair_k100_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
+    {
+        corsair_full_size_values,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Name,                       Translated Name,            OpCode,                             |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
+        //media keys
+        {   0,      0,      17,         123,        KEY_EN_MEDIA_STOP,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      18,         126,        KEY_EN_MEDIA_PREVIOUS,      KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      19,         124,        KEY_EN_MEDIA_PLAY_PAUSE,    KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      20,         125,        KEY_EN_MEDIA_NEXT,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        //upper row
+        {   0,      0,      1,          128,        "Profile",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },
+        {   0,      0,      2,          137,        "iCue",                     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      3,          114,        "Lock",                     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      10,         190,        "Logo L",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      11,         191,        "Logo M",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      12,         192,        "Logo R",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      18,         102,        KEY_EN_MEDIA_MUTE,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        //macro keys
+        {   0,      1,      0,          131,        "G1",                       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      2,      0,          132,        "G2",                       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      3,      0,          133,        "G3",                       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      4,      0,          134,        "G4",                       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      5,      0,          135,        "G5",                       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      0,          136,        "G6",                       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        //underglow 44 entries
+        //underglow upper
+        {   0,      0,      0,          138,        "Underglow 1",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },
+        {   0,      0,      1,          139,        "Underglow 2",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      2,          140,        "Underglow 3",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      3,          141,        "Underglow 4",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      4,          142,        "Underglow 5",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      5,          143,        "Underglow 6",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      6,          144,        "Underglow 7",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      7,          145,        "Underglow 8",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      8,          146,        "Underglow 9",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      9,          147,        "Underglow 10",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      10,         148,        "Underglow 11",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      11,         149,        "Underglow 12",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      12,         150,        "Underglow 13",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      13,         151,        "Underglow 14",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      14,         152,        "Underglow 15",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      15,         153,        "Underglow 16",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      16,         154,        "Underglow 17",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      17,         155,        "Underglow 18",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      18,         156,        "Underglow 19",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      19,         157,        "Underglow 20",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      20,         158,        "Underglow 21",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      21,         159,        "Underglow 22",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        //underglow left
+        {   0,      0,      0,          160,        "Underglow 23",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      1,      0,          161,        "Underglow 24",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      2,      0,          162,        "Underglow 25",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      3,      0,          163,        "Underglow 26",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      4,      0,          164,        "Underglow 27",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      5,      0,          165,        "Underglow 28",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      0,          166,        "Underglow 29",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      7,      0,          167,        "Underglow 30",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      8,      0,          168,        "Underglow 31",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      9,      0,          169,        "Underglow 32",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      10,     0,          170,        "Underglow 33",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        //underglow right
+        {   0,      0,      23,         171,        "Underglow 34",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      1,      23,         172,        "Underglow 35",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      2,      23,         173,        "Underglow 36",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      3,      23,         174,        "Underglow 37",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      4,      23,         175,        "Underglow 38",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      5,      23,         176,        "Underglow 39",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,      23,         177,        "Underglow 40",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      7,      23,         178,        "Underglow 41",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      8,      23,         179,        "Underglow 42",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      9,      23,         180,        "Underglow 43",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      10,     23,         181,        "Underglow 44",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        //wheel
+        {   0,      0,      0,          182,        "Wheel 1",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },
+        {   0,      0,      1,          183,        "Wheel 2",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      2,          184,        "Wheel 3",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      3,          185,        "Wheel 4",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      4,          186,        "Wheel 5",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      5,          187,        "Wheel 6",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      6,          188,        "Wheel 7",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      7,          189,        "Wheel 8",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
     }
 };
 
@@ -263,6 +391,48 @@ static const corsair_v2_device dark_core_pro_se_device =
     nullptr
 };
 
+/*-------------------------------------------------------------*\
+|  Corsair Harpoon Wireless 1B1C:1B5E                          |
+|                                                               |
+|  Zone "Logo"                                                  |
+|       Single                                                  |
+|                                                               |
+|  Zone "Scroll Wheel"                                          |
+|       Single                                                  |
+\*-------------------------------------------------------------*/
+static const corsair_v2_zone harpoon_indicator_zone =
+{
+    "Indicator",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const corsair_v2_zone harpoon_logo_zone =
+{
+    "Logo",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const corsair_v2_device harpoon_wireless_device =
+{
+    CORSAIR_HARPOON_WIRELESS_PID,
+    DEVICE_TYPE_MOUSE,
+    1,
+    2,
+    {
+        &harpoon_indicator_zone,
+        &harpoon_logo_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    },
+    nullptr
+};
+
 /*-------------------------------------------------------------*\
 |  Corsair Ironclaw Wireless 1B1C:1B4C                          |
 |                                                               |
@@ -328,6 +498,135 @@ static const corsair_v2_device ironclaw_wireless_device =
     nullptr
 };
 
+/*-------------------------------------------------------------*\
+|  Corsair Katar Pro 1B1C:1B93                                  |
+|                                                               |
+|  Zone "Scroll Wheel"                                          |
+|       Single                                                  |
+|                                                               |
+|  Zone "DPI"                                                   |
+|       Single                                                  |
+|                                                               |
+\*-------------------------------------------------------------*/
+static const corsair_v2_zone katar_pro_scroll_zone =
+{
+    "Scroll Wheel",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const corsair_v2_zone katar_pro_dpi_zone =
+{
+    "DPI",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const corsair_v2_device katar_pro_device =
+{
+    CORSAIR_KATAR_PRO_PID,
+    DEVICE_TYPE_MOUSE,
+    1,
+    2,
+    {
+        &katar_pro_scroll_zone,
+        &katar_pro_dpi_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    },
+    nullptr
+};
+
+/*-------------------------------------------------------------*\
+|  Corsair Katar Pro V2 1B1C:1BBA                               |
+|                                                               |
+|  Zone "Scroll Wheel"                                          |
+|       Single                                                  |
+|                                                               |
+|  Zone "DPI"                                                   |
+|       Single                                                  |
+|                                                               |
+\*-------------------------------------------------------------*/
+static const corsair_v2_zone katar_pro_v2_scroll_zone =
+{
+    "Scroll Wheel",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const corsair_v2_zone katar_pro_v2_dpi_zone =
+{
+    "DPI",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const corsair_v2_device katar_pro_v2_device =
+{
+    CORSAIR_KATAR_PRO_V2_PID,
+    DEVICE_TYPE_MOUSE,
+    1,
+    2,
+    {
+        &katar_pro_v2_scroll_zone,
+        &katar_pro_v2_dpi_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    },
+    nullptr
+};
+
+/*-------------------------------------------------------------*\
+|  Corsair Katar Pro XT 1B1C:1BAC                               |
+|                                                               |
+|  Zone "Scroll Wheel"                                          |
+|       Single                                                  |
+|                                                               |
+|  Zone "DPI"                                                   |
+|       Single                                                  |
+|                                                               |
+\*-------------------------------------------------------------*/
+static const corsair_v2_zone katar_pro_xt_scroll_zone =
+{
+    "Scroll Wheel",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const corsair_v2_zone katar_pro_xt_dpi_zone =
+{
+    "DPI",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const corsair_v2_device katar_pro_xt_device =
+{
+    CORSAIR_KATAR_PRO_XT_PID,
+    DEVICE_TYPE_MOUSE,
+    1,
+    2,
+    {
+        &katar_pro_xt_scroll_zone,
+        &katar_pro_xt_dpi_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    },
+    nullptr
+};
+
 /*-------------------------------------------------------------*\
 |  Corsair K55 RGB Pro 1B1C:1BA4                                |
 |                                                               |
@@ -424,6 +723,38 @@ static const corsair_v2_device k60_rgb_pro_lp_device =
     &corsair_K60_layout
 };
 
+/*-------------------------------------------------------------*\
+|  Corsair K60 RGB Pro TKL 1B1C:1BC7                            |
+|                                                               |
+|  Zone "Keyboard"                                              |
+|       Matrix                                                  |
+|       6 Rows, 21 Columns                                      |
+\*-------------------------------------------------------------*/
+static const corsair_v2_zone k60_rgb_pro_tkl_zone =
+{
+    ZONE_EN_KEYBOARD,
+    ZONE_TYPE_MATRIX,
+    6,
+    21
+};
+
+static const corsair_v2_device k60_rgb_pro_tkl_device =
+{
+    CORSAIR_K60_RGB_PRO_TKL_PID,
+    DEVICE_TYPE_KEYBOARD,
+    6,
+    21,
+    {
+        &k60_rgb_pro_lp_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    },
+    &corsair_K60_tkl_layout
+};
+
 /*-------------------------------------------------------------*\
 |  Corsair K70 RGB TKL 1B1C:1B73                                |
 |                                                               |
@@ -488,6 +819,129 @@ static const corsair_v2_device k70_rgb_tkl_cs_device =
     &corsair_K70_TKL_cs_layout
 };
 
+/*-------------------------------------------------------------*\
+|  Corsair K70 RGB Pro 1B1C:1BC4                                |
+|                                                               |
+|  Zone "Keyboard"                                              |
+|       Matrix                                                  |
+|       6 Rows, 21 Columns                                      |
+\*-------------------------------------------------------------*/
+static const corsair_v2_zone k70_rgb_pro_zone =
+{
+    ZONE_EN_KEYBOARD,
+    ZONE_TYPE_MATRIX,
+    6,
+    21
+};
+
+static const corsair_v2_device k70_rgb_pro_device =
+{
+    CORSAIR_K70_RGB_PRO_PID,
+    DEVICE_TYPE_KEYBOARD,
+    6,
+    21,
+    {
+        &k70_rgb_pro_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    },
+    &corsair_k70_layout
+};
+
+/*-------------------------------------------------------------*\
+|   Corsair K100 MX Red 1B1C:1B7D                               |
+|                                                               |
+|   Zone "Keyboard"                                             |
+|       Matrix                                                  |
+|       12 Rows, 24 Columns                                     |
+\*-------------------------------------------------------------*/
+
+static const corsair_v2_zone k100_mx_red_zone =
+{
+    ZONE_EN_KEYBOARD,
+    ZONE_TYPE_MATRIX,
+    12,
+    24
+};
+
+static const corsair_v2_device k100_mx_red_device =
+{
+    CORSAIR_K100_MXRED_PID,
+    DEVICE_TYPE_KEYBOARD,
+    12,
+    24,
+    {
+        &k100_mx_red_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    },
+    &corsair_k100_layout
+};
+
+/*-------------------------------------------------------------*\
+|   Corsair K100 RGB Optical V1 1B1C:1B7C                       |
+|                                                               |
+|   Zone "Keyboard"                                             |
+|       Matrix                                                  |
+|       12 Rows, 24 Columns                                     |
+\*-------------------------------------------------------------*/
+
+static const corsair_v2_zone k100_rgb_opt_zone =
+{
+    ZONE_EN_KEYBOARD,
+    ZONE_TYPE_MATRIX,
+    12,
+    24
+};
+
+static const corsair_v2_device k100_rgb_opt_v1_device =
+{
+    CORSAIR_K100_OPTICAL_V1_PID,
+    DEVICE_TYPE_KEYBOARD,
+    12,
+    24,
+    {
+        &k100_rgb_opt_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    },
+    &corsair_k100_layout
+};
+
+/*-------------------------------------------------------------*\
+|   Corsair K100 RGB Optical V2 1B1C:1BC5                       |
+|                                                               |
+|   Zone "Keyboard"                                             |
+|       Matrix                                                  |
+|       12 Rows, 24 Columns                                     |
+\*-------------------------------------------------------------*/
+
+static const corsair_v2_device k100_rgb_opt_v2_device =
+{
+    CORSAIR_K100_OPTICAL_V2_PID,
+    DEVICE_TYPE_KEYBOARD,
+    12,
+    24,
+    {
+        &k100_rgb_opt_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    },
+    &corsair_k100_layout
+};
+
 /*-------------------------------------------------------------*\
 |  Corsair M55 1B1C:1B70                                        |
 |                                                               |
@@ -635,15 +1089,24 @@ const corsair_v2_device* corsair_v2_device_list_data[] =
     &k55_rgb_pro_device,
     &k60_rgb_pro_device,
     &k60_rgb_pro_lp_device,
+    &k60_rgb_pro_tkl_device,
+    &k70_rgb_pro_device,
     &k70_rgb_tkl_device,
     &k70_rgb_tkl_cs_device,
+    &k100_mx_red_device,
+    &k100_rgb_opt_v1_device,
+    &k100_rgb_opt_v2_device,
 
 /*-----------------------------------------------------------------*\
 |  MICE                                                             |
 \*-----------------------------------------------------------------*/
     &dark_core_se_device,
     &dark_core_pro_se_device,
+    &harpoon_wireless_device,
     &ironclaw_wireless_device,
+    &katar_pro_device,
+    &katar_pro_v2_device,
+    &katar_pro_xt_device,
     &m55_device,
     &m65_ultra_rgb_device,