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/CODEOWNERS

@@ -74,7 +74,6 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/NZXTHue2Controller/
 /Controllers/NZXTHuePlusController/
 /Controllers/NZXTKrakenController/
-/Controllers/OpenRazerController/
 /Controllers/PNYGPUController/
 /Controllers/PatriotViperController/
 /Controllers/PhilipsHueController/

.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,15 +1,25 @@
+/*-------------------------------------------------------------------*\
+|  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                                      |
 \*-----------------------------------------------------*/
 #include <hidapi/hidapi.h>
 #include "Detector.h"
-#include "LogManager.h"
 #include "RGBController.h"
 
 /*-----------------------------------------------------*\
 | A4 Tech specific includes                             |
 \*-----------------------------------------------------*/
 #include "RGBController_BloodyMouse.h"
+#include "RGBController_BloodyB820R.h"
 
 /*-----------------------------------------------------*\
 | A4 Tech USB vendor ID                                 |
@@ -30,5 +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/BloodyMouseController.cpp

@@ -8,6 +8,7 @@
 \*---------------------------------------------------------------------*/
 
 #include "BloodyMouseController.h"
+#include "LogManager.h"
 
 BloodyMouseController::BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id)
 {

Controllers/A4TechController/BloodyMouseController.h

@@ -9,7 +9,6 @@
 
 #include <string>
 #include <hidapi/hidapi.h>
-#include "LogManager.h"
 #include "RGBController.h"
 
 #pragma once
@@ -18,6 +17,7 @@
 | Mouse product IDs                                     |
 \*-----------------------------------------------------*/
 #define BLOODY_W60_PRO_PID                          0x37EA
+#define BLOODY_W90_MAX_PID                          0x3666
 
 /*-----------------------------------------------------*\
 | Mousemat product IDs                                  |

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/A4TechController/RGBController_BloodyMouse.cpp

@@ -25,6 +25,19 @@ static const mouse_layout w60_pro
     }
 };
 
+static const mouse_layout w90_max
+{
+    {
+        "Scroll Wheel", { 14 }
+    },
+    {
+        "Logo",         { 7 }
+    },
+    {
+        "Rear",         { 13, 12, 11, 10, 9, 8, 6, 5, 4, 3, 2, 1, 0 }
+    }
+};
+
 static const mouse_layout mp_50rs
 {
     {
@@ -56,7 +69,6 @@ RGBController_BloodyMouse::RGBController_BloodyMouse(BloodyMouseController *cont
             type                = DEVICE_TYPE_MOUSE;
     }
 
-    name                        = "BloodyMouse";
     vendor                      = "Bloody";
     description                 = "Controller compatible with the Bloody W60 Pro and MP 50RS";
     serial                      = controller->GetSerial();
@@ -89,11 +101,15 @@ void RGBController_BloodyMouse::SetupZones()
     | Select layout from PID                            |
     \*-------------------------------------------------*/
     mouse_layout layout;
+
     switch(controller->GetPid())
     {
         case BLOODY_W60_PRO_PID:
             layout = w60_pro;
             break;
+        case BLOODY_W90_MAX_PID:
+            layout = w90_max;
+            break;
         case BLOODY_MP_50RS_PID:
             layout = mp_50rs;
             break;

Controllers/A4TechController/RGBController_BloodyMouse.h

@@ -9,7 +9,6 @@
 
 #pragma once
 #include <vector>
-#include "LogManager.h"
 #include "RGBController.h"
 #include "BloodyMouseController.h"
 

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/AlienwareController/AlienwareController.cpp

@@ -15,6 +15,7 @@
 #include <chrono>
 #include <algorithm>
 #include <sstream>
+#include "LogManager.h"
 
 typedef uint32_t alienware_platform_id;
 
@@ -24,8 +25,10 @@ typedef uint32_t alienware_platform_id;
 \*---------------------------------------------------------*/
 static const std::map<alienware_platform_id, uint8_t> zone_quirks_table =
 {
-    { 0x0C01,   4 }, // Dell G5 SE 5505
-    { 0x0A01,  16 }  // Dell G7 15 7500
+    { 0x0C01,   4 },    // Dell G5 SE 5505
+    { 0x0A01,  16 },    // Dell G7 15 7500
+    { 0x0E03,   4 }     // Dell G15   5511
+
 };
 
 /*---------------------------------------------------------*\
@@ -39,7 +42,8 @@ static const std::map<alienware_platform_id, std::vector<const char*>> zone_name
                   "Light Bar 1",    "Light Bar 2",  "Light Bar 3",
                   "Light Bar 4",    "Light Bar 5",  "Light Bar 6",
                   "Light Bar 7",    "Light Bar 8",  "Light Bar 9",
-                  "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } }
+                  "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } },
+    { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } }
 };
 
 static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
@@ -113,10 +117,13 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
 
     if(zone_names_table.count(platform_id))
     {
+        LOG_INFO("[%s] Known platform: %8X, Number of zones: %d", ALIENWARE_CONTROLLER_NAME, platform_id, number_of_zones);
         zone_names = zone_names_table.at(platform_id);
     }
     else
     {
+        LOG_WARNING("[%s] Unknown platform: %8X, Number of zones: %d", ALIENWARE_CONTROLLER_NAME, platform_id, number_of_zones);
+
         /*-------------------------------------------------*\
         | If this is an unknown controller, set the name of |
         | all regions to "Unknown"                          |

Controllers/AlienwareController/AlienwareController.h

@@ -19,7 +19,7 @@
 
 #define ALIENWARE_REPORT_SIZE               33
 #define HIDAPI_ALIENWARE_REPORT_SIZE        (ALIENWARE_REPORT_SIZE + 1)
-
+#define ALIENWARE_CONTROLLER_NAME           "AlienWare Controller"
 enum
 {
     ALIENWARE_COMMAND_REPORT                = 0x20,     /* Set report type to get               */

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,11 +4,13 @@
 #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
 #define ANNE_PRO_2_PID_4 0xA293
+#define ANNE_PRO_2_PID_5 0xA297
 
 /******************************************************************************************\
 *                                                                                          *
@@ -30,7 +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_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/ArcticController/ArcticController.cpp

@@ -0,0 +1,155 @@
+/*-----------------------------------------*\
+|  ArcticController.h                       |
+|                                           |
+|  Controller Interface for Arctic devices  |
+|                                           |
+|  Armin Wolf (Wer-Wolf) 01/09/2023         |
+\*-----------------------------------------*/
+
+#include "ArcticController.h"
+#include <cstring>
+
+using namespace std::chrono_literals;
+
+#define ARCTIC_COMMAND_SET_RGB          0x00
+#define ARCTIC_COMMAND_IDENTIFY         0x5C
+
+#define ARCTIC_RESPONSE_BUFFER_LENGTH   15
+#define ARCTIC_RESPONSE_COMMAND_OFFSET  0
+#define ARCTIC_RESPONSE_DATA_OFFSET     1
+#define ARCTIC_RESPONSE_DATA_LENGTH     12
+#define ARCTIC_RESPONSE_XOR_CSUM_OFFSET 13
+#define ARCTIC_RESPONSE_ADD_CSUM_OFFSET 14
+
+#define ARCTIC_COMMAND_BUFFER_LENGTH(payload_size)  (sizeof(header) + 1 + payload_size)
+#define ARCTIC_COMMAND_COMMAND_OFFSET               (sizeof(header))
+#define ARCTIC_COMMAND_PAYLOAD_OFFSET               (sizeof(header) + 1)
+
+const unsigned char header[] =
+{
+    0x01,
+    0x02,
+    0x03,
+    0xFF,
+    0x05,
+    0xFF,
+    0x02,
+    0x03
+};
+
+const unsigned char identify_payload[] =
+{
+    0x01,
+    0xFE,
+    0x01,
+    0xFE
+};
+
+ArcticController::ArcticController(const std::string &portname)
+: serialport(portname.c_str(), 250000, SERIAL_PORT_PARITY_NONE, SERIAL_PORT_SIZE_8, SERIAL_PORT_STOP_BITS_2, false)
+{
+    port_name = portname;
+    serialport.serial_set_dtr(true);
+}
+
+ArcticController::~ArcticController()
+{
+    serialport.serial_set_dtr(false);
+}
+
+static void FormatCommandBuffer(char *buffer, char command)
+{
+    std::memcpy(buffer, header, sizeof(header));
+    buffer[ARCTIC_COMMAND_COMMAND_OFFSET] = command;
+}
+
+void ArcticController::SetChannels(std::vector<RGBColor> colors)
+{
+    char* buffer = new char[ARCTIC_COMMAND_BUFFER_LENGTH(colors.size() * 3)];
+
+    FormatCommandBuffer(buffer, ARCTIC_COMMAND_SET_RGB);
+
+    for(unsigned int channel = 0; channel < colors.size(); channel++)
+    {
+        const unsigned int offset = ARCTIC_COMMAND_PAYLOAD_OFFSET + channel * 3;
+
+        buffer[offset + 0x00] = std::min<unsigned int>(254, RGBGetRValue(colors[channel]));
+        buffer[offset + 0x01] = std::min<unsigned int>(254, RGBGetGValue(colors[channel]));
+        buffer[offset + 0x02] = std::min<unsigned int>(254, RGBGetBValue(colors[channel]));
+    }
+
+    serialport.serial_write(buffer, sizeof(buffer));
+
+    delete[] buffer;
+}
+
+static char XORChecksum(char *data, int length)
+{
+    char sum = 0;
+
+    for(int i = 0; i < length; i++)
+    {
+        sum ^= data[i];
+    }
+
+    return sum;
+}
+
+static char AddChecksum(char *data, int length)
+{
+    char sum = 0;
+
+    for(int i = 0; i < length; i++)
+    {
+        sum = (char)(sum + data[i]);
+    }
+
+    return sum;
+}
+
+bool ArcticController::IsPresent()
+{
+    char buffer[ARCTIC_COMMAND_BUFFER_LENGTH(sizeof(identify_payload))];
+    char response[ARCTIC_RESPONSE_BUFFER_LENGTH];
+    int ret;
+
+    FormatCommandBuffer(buffer, ARCTIC_COMMAND_IDENTIFY);
+    std::memcpy(buffer + ARCTIC_COMMAND_PAYLOAD_OFFSET, identify_payload, sizeof(identify_payload));
+
+    serialport.serial_flush_rx();
+    ret = serialport.serial_write(buffer, sizeof(buffer));
+    if(ret != sizeof(buffer))
+    {
+        return false;
+    }
+
+    std::this_thread::sleep_for(100ms);
+
+    ret = serialport.serial_read(response, sizeof(response));
+    if(ret != sizeof(response))
+    {
+        return false;
+    }
+
+    if(response[ARCTIC_RESPONSE_COMMAND_OFFSET] != ARCTIC_COMMAND_IDENTIFY)
+    {
+        return false;
+    }
+
+    if(response[ARCTIC_RESPONSE_XOR_CSUM_OFFSET] != XORChecksum(&response[ARCTIC_RESPONSE_DATA_OFFSET], ARCTIC_RESPONSE_DATA_LENGTH))
+    {
+        return false;
+    }
+
+    if(response[ARCTIC_RESPONSE_ADD_CSUM_OFFSET] != AddChecksum(&response[ARCTIC_RESPONSE_DATA_OFFSET], ARCTIC_RESPONSE_DATA_LENGTH))
+    {
+        return false;
+    }
+
+    return true;
+}
+
+std::string ArcticController::GetLocation()
+{
+    return port_name;
+}

Controllers/ArcticController/ArcticController.h

@@ -0,0 +1,29 @@
+/*-----------------------------------------*\
+|  ArcticController.h                       |
+|                                           |
+|  Controller Interface for Arctic devices  |
+|                                           |
+|  Armin Wolf (Wer-Wolf) 01/09/2023         |
+\*-----------------------------------------*/
+
+#pragma once
+#include <algorithm>
+
+#include "RGBController.h"
+#include "serial_port.h"
+
+class ArcticController
+{
+public:
+    ArcticController(const std::string &portname);
+    ~ArcticController();
+
+    void SetChannels(std::vector<RGBColor> colors);
+    bool IsPresent();
+
+    std::string GetLocation();
+
+private:
+    std::string port_name;
+    serial_port serialport;
+};

Controllers/ArcticController/ArcticControllerDetect.cpp

@@ -0,0 +1,48 @@
+/*-----------------------------------------*\
+|  ArcticControllerDetect.cpp               |
+|                                           |
+|  Detect Arctic RGB controllers            |
+|                                           |
+|  Armin Wolf (Wer-Wolf) 01/09/2023         |
+\*-----------------------------------------*/
+
+#include "Detector.h"
+#include "ArcticController.h"
+#include "RGBController.h"
+#include "RGBController_Arctic.h"
+#include "find_usb_serial_port.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define CH341_VID   0x1A86
+#define CH341_PID   0x7523
+
+void DetectArcticControllers()
+{
+    std::vector<std::string *> ports = find_usb_serial_port(CH341_VID, CH341_PID);
+
+    for(unsigned int device = 0; device < ports.size(); device++)
+    {
+        ArcticController *controller = new ArcticController(*ports[device]);
+
+        if(controller->IsPresent())
+        {
+            RGBController_Arctic *rgb_controller = new RGBController_Arctic(controller);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+        else
+        {
+            delete controller;
+        }
+
+        delete ports[device];
+    }
+}
+
+REGISTER_DETECTOR("Arctic RGB controller", DetectArcticControllers);
+/*---------------------------------------------------------------------------------------------------------*\
+| Entries for dynamic UDEV rules                                                                            |
+|                                                                                                           |
+| DUMMY_DEVICE_DETECTOR("Arctic RGB controller", DetectArcticControllers, 0x1a86, 0x7523 )                  |
+\*---------------------------------------------------------------------------------------------------------*/

Controllers/ArcticController/RGBController_Arctic.cpp

@@ -0,0 +1,131 @@
+/*-----------------------------------------*\
+|  RGBController_Arctic.h                   |
+|                                           |
+|  Generic RGB Interface for Arctic devices |
+|                                           |
+|  Armin Wolf (Wer-Wolf) 01/09/2023         |
+\*-----------------------------------------*/
+
+#include "RGBController_Arctic.h"
+#include <math.h>
+
+using namespace std::chrono_literals;
+
+#define ARCTIC_NUM_CHANNELS     4
+#define ARCTIC_SLEEP_THRESHOLD  100ms
+#define ARCTIC_KEEPALIVE_PERIOD 500ms  /* Device requires at least 1s */
+
+/**------------------------------------------------------------------*\
+    @name Arctic RGB Controller Devices
+    @category LEDStrip
+    @type Serial
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectArcticControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_Arctic::RGBController_Arctic(ArcticController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "Arctic RGB Controller";
+    vendor      = "Arctic";
+    description = "Arctic 4-Channel RGB Controller";
+    location    = controller->GetLocation();
+    type        = DEVICE_TYPE_LEDSTRIP;
+
+    mode DirectMode;
+    DirectMode.name         = "Direct";
+    DirectMode.value        = 0;
+    DirectMode.flags        = MODE_FLAG_HAS_PER_LED_COLOR;
+    DirectMode.color_mode   = MODE_COLORS_PER_LED;
+
+    modes.push_back(DirectMode);
+
+    SetupZones();
+
+    keepalive_thread_run = true;
+    keepalive_thread = std::thread(&RGBController_Arctic::KeepaliveThreadFunction, this);
+}
+
+RGBController_Arctic::~RGBController_Arctic()
+{
+    keepalive_thread_run = false;
+    keepalive_thread.join();
+    delete controller;
+}
+
+void RGBController_Arctic::SetupZones()
+{
+    for(int channel = 0; channel < ARCTIC_NUM_CHANNELS; channel++)
+    {
+        zone LedZone;
+        LedZone.name        = "LED Strip " + std::to_string(channel);
+        LedZone.type        = ZONE_TYPE_SINGLE;
+        LedZone.leds_count  = 1;
+        LedZone.leds_min    = 1;
+        LedZone.leds_max    = 1;
+        LedZone.matrix_map  = nullptr;
+
+        led Led;
+        Led.name    = LedZone.name + " LED";
+        Led.value   = channel;
+
+        zones.push_back(LedZone);
+        leds.push_back(Led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_Arctic::ResizeZone(int /* zone */, int /* new_size */)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_Arctic::DeviceUpdateLEDs()
+{
+    last_update_time = std::chrono::steady_clock::now();
+
+    controller->SetChannels(colors);
+}
+
+void RGBController_Arctic::UpdateZoneLEDs(int /* zone */)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_Arctic::UpdateSingleLED(int /* led */)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_Arctic::DeviceUpdateMode()
+{
+    /*---------------------------------------------------------*\
+    | This device does not support mode updates                 |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_Arctic::KeepaliveThreadFunction()
+{
+    std::chrono::nanoseconds sleep_time;
+
+    while(keepalive_thread_run.load())
+    {
+        sleep_time = ARCTIC_KEEPALIVE_PERIOD - (std::chrono::steady_clock::now() - last_update_time);
+        if(sleep_time <= ARCTIC_SLEEP_THRESHOLD)
+        {
+            UpdateLEDs();   // Already protected thru a device update thread
+            std::this_thread::sleep_for(ARCTIC_KEEPALIVE_PERIOD);
+        }
+        else
+        {
+            std::this_thread::sleep_for(sleep_time);
+        }
+    }
+}

Controllers/ArcticController/RGBController_Arctic.h

@@ -0,0 +1,40 @@
+/*-----------------------------------------*\
+|  RGBController_Arctic.h                   |
+|                                           |
+|  Generic RGB Interface for Arctic devices |
+|                                           |
+|  Armin Wolf (Wer-Wolf) 27/08/2023         |
+\*-----------------------------------------*/
+
+#pragma once
+#include "ArcticController.h"
+#include "RGBController.h"
+#include "serial_port.h"
+#include <chrono>
+#include <thread>
+
+class RGBController_Arctic : public RGBController
+{
+public:
+    RGBController_Arctic(ArcticController* controller_ptr);
+    ~RGBController_Arctic();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+    void        KeepaliveThreadFunction();
+
+private:
+    ArcticController*                                   controller;
+    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
+    std::atomic<bool>                                   keepalive_thread_run;
+    std::thread                                         keepalive_thread;
+};
+

Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp

@@ -55,3 +55,4 @@ REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreContro
 REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1866);
 REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1869);
 REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 15",      DetectAsusAuraCoreLaptopControllers,    AURA_CORE_VID, AURA_STRIX_SCAR_15_PID,  0xFF31, 0x79);
+REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 17",      DetectAsusAuraCoreLaptopControllers,    AURA_CORE_VID, 0x1866,                  0xFF31, 0x79);

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController.h

@@ -13,7 +13,6 @@
 #include "LogManager.h"
 #include "RGBController.h"
 #include "ResourceManager.h"
-#include "SettingsManager.h"
 #include "RGBControllerKeyNames.h"
 
 #pragma once

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
@@ -86,11 +63,24 @@ void AuraMainboardController::SetMode
     unsigned char   grn,
     unsigned char   blu
     )
+{
+    SetMode(channel, mode, red, grn, blu, false);
+}
+
+void AuraMainboardController::SetMode
+    (
+    unsigned char   channel,
+    unsigned char   mode,
+    unsigned char   red,
+    unsigned char   grn,
+    unsigned char   blu,
+    bool            shutdown_effect
+    )
 {
     this->mode = mode;
     RGBColor color = ToRGBColor(red, grn, blu);
 
-    SendEffect(device_info[channel].effect_channel, mode);
+    SendEffect(device_info[channel].effect_channel, mode, shutdown_effect);
     if(mode == AURA_MODE_DIRECT)
     {
         return;
@@ -116,7 +106,8 @@ void AuraMainboardController::SetMode
         channel,
         start_led,
         device_info[channel].num_leds,
-        led_data
+        led_data,
+        shutdown_effect
     );
 }
 
@@ -128,7 +119,8 @@ unsigned short AuraMainboardController::GetMask(int start, int size)
 void AuraMainboardController::SendEffect
     (
     unsigned char   channel,
-    unsigned char   mode
+    unsigned char   mode,
+    bool            shutdown_effect
     )
 {
     unsigned char usb_buf[65];
@@ -145,7 +137,7 @@ void AuraMainboardController::SendEffect
     usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_EFFECT;
     usb_buf[0x02]   = channel;
     usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = 0x00;
+    usb_buf[0x04]   = shutdown_effect ? 0x01 : 0x00;
     usb_buf[0x05]   = mode;
 
     /*-----------------------------------------------------*\
@@ -159,7 +151,8 @@ void AuraMainboardController::SendColor
     unsigned char   /*channel*/,
     unsigned char   start_led,
     unsigned char   led_count,
-    unsigned char*  led_data
+    unsigned char*  led_data,
+    bool            shutdown_effect
     )
 {
     unsigned short  mask = GetMask(start_led, led_count);
@@ -177,7 +170,7 @@ void AuraMainboardController::SendColor
     usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_EFFECT_COLOR;
     usb_buf[0x02]   = mask >> 8;
     usb_buf[0x03]   = mask & 0xff;
-    usb_buf[0x04]   = 0x00;
+    usb_buf[0x04]   = shutdown_effect ? 0x01 : 0x00;
 
     /*-----------------------------------------------------*\
     | Copy in color data bytes                              |

Controllers/AsusAuraUSBController/AsusAuraMainboardController.h

@@ -44,15 +44,28 @@ public:
         unsigned char   blu
         );
 
+    void SetMode
+        (
+        unsigned char   channel,
+        unsigned char   mode,
+        unsigned char   red,
+        unsigned char   grn,
+        unsigned char   blu,
+        bool            shutdown_effect
+        );
+
+    void SendCommit();
+
 private:
     unsigned int mode;
 
     unsigned short GetMask(int start, int size);
-    
+
     void SendEffect
         (
         unsigned char   channel,
-        unsigned char   mode
+        unsigned char   mode,
+        bool            shutdown_effect
         );
 
     void SendColor
@@ -60,8 +73,7 @@ private:
         unsigned char   channel,
         unsigned char   start_led,
         unsigned char   led_count,
-        unsigned char*  led_data
+        unsigned char*  led_data,
+        bool            shutdown_effect
         );
-
-    void SendCommit();
 };

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,42 +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_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
 {
@@ -66,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,
 };
 
@@ -77,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;
@@ -100,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 }
         }
@@ -113,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 }
         }
@@ -126,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 }
         }
@@ -139,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 }
         }
@@ -152,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 }
         }
@@ -165,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 }
         }
@@ -178,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 }
         }
@@ -188,9 +205,10 @@ static std::map<int,mouse_type> aura_mouse_devices =
             255,
             1,
             0,
-            64,
+            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 }
         }
@@ -201,9 +219,10 @@ static std::map<int,mouse_type> aura_mouse_devices =
             255,
             1,
             0,
-            64,
+            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 }
         }
@@ -214,9 +233,10 @@ static std::map<int,mouse_type> aura_mouse_devices =
             255,
             1,
             0,
-            64,
+            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 }
         }
@@ -227,13 +247,42 @@ static std::map<int,mouse_type> aura_mouse_devices =
             255,
             1,
             0,
-            64,
+            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
         {
@@ -243,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 }
         }
@@ -256,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 }
         }
@@ -269,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 }
         }
@@ -279,9 +331,10 @@ static std::map<int,mouse_type> aura_mouse_devices =
             15, // technically until 255, but unusably slow after 15
             1,
             0,
-            64,
+            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 }
         }
@@ -292,9 +345,10 @@ static std::map<int,mouse_type> aura_mouse_devices =
             15, // technically until 255, but unusably slow after 15
             1,
             0,
-            64,
+            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 }
         }
@@ -305,9 +359,10 @@ static std::map<int,mouse_type> aura_mouse_devices =
             15, // technically until 255, but unusably slow after 15
             1,
             0,
-            64,
+            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 }
         }
@@ -318,9 +373,10 @@ static std::map<int,mouse_type> aura_mouse_devices =
             15, // technically until 255, but unusably slow after 15
             1,
             0,
-            64,
+            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 }
         }
@@ -334,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 }
         }
@@ -347,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 }
         }
@@ -360,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 }
         }
@@ -373,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 }
         }
@@ -386,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 }
         }
@@ -399,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 }
         }
@@ -412,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 }
         }
@@ -425,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 }
         }
@@ -438,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 }
         }
@@ -451,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
         {
@@ -463,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 }
         }
@@ -475,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 }
         }
@@ -489,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 }
         }
@@ -502,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
         {
@@ -516,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 }
         }
@@ -529,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 }
         }
@@ -542,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

@@ -37,6 +37,26 @@ std::string AuraTUFKeyboardController::GetDeviceLocation()
     return("HID: " + location);
 }
 
+std::string clean_serial(const std::wstring& wstr)
+{
+    // Skip non-ASCII, trailing garbage in serial numbers. Required by the
+    // Scope II 96, whose original firmware outputs garbage, which even differs
+    // after computer reboots and therefore breaks OpenRGB profile matching.
+    std::string result;
+    for(auto c : wstr)
+    {
+        // Forbid control chars and anything above final printable low-ASCII.
+        if(c < 32 || c > 126)
+        {
+            break;
+        }
+
+        result += c;
+    }
+
+    return(result);
+}
+
 std::string AuraTUFKeyboardController::GetSerialString()
 {
     wchar_t serial_string[128];
@@ -47,8 +67,8 @@ std::string AuraTUFKeyboardController::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 = clean_serial(serial_wstring);
 
     return(return_string);
 }
@@ -75,10 +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]);
         }
@@ -322,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,
@@ -337,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,14 +33,27 @@ enum
 
 enum
 {
-    AURA_ROG_FALCHION_WIRED_PID             = 0x193C,
-    AURA_ROG_FALCHION_WIRELESS_PID          = 0x193E,
-    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
@@ -84,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/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"
@@ -15,97 +15,105 @@
 #include "RGBController_AsusAuraHeadsetStand.h"
 #include "RGBController_AsusAuraKeyboard.h"
 #include "RGBController_AsusAuraTUFKeyboard.h"
+#include "RGBController_AsusAuraMainboard.h"
 #include "RGBController_AsusAuraMouse.h"
 #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>
 #include <hidapi/hidapi.h>
 #include "dependencies/dmiinfo.h"
 
-#define AURA_USB_VID                            0x0B05
+#define AURA_USB_VID                                  0x0B05
 
 /*-----------------------------------------------------------------*\
 |  MOTHERBOARDS                                                     |
 \*-----------------------------------------------------------------*/
-#define AURA_ADDRESSABLE_1_PID                  0x1867
-#define AURA_ADDRESSABLE_2_PID                  0x1872
-#define AURA_ADDRESSABLE_3_PID                  0x18A3
-#define AURA_ADDRESSABLE_4_PID                  0x18A5
-#define AURA_MOTHERBOARD_1_PID                  0x18F3
-#define AURA_MOTHERBOARD_2_PID                  0x1939
-#define AURA_MOTHERBOARD_3_PID                  0x19AF
+#define AURA_ADDRESSABLE_1_PID                        0x1867
+#define AURA_ADDRESSABLE_2_PID                        0x1872
+#define AURA_ADDRESSABLE_3_PID                        0x18A3
+#define AURA_ADDRESSABLE_4_PID                        0x18A5
+#define AURA_MOTHERBOARD_1_PID                        0x18F3
+#define AURA_MOTHERBOARD_2_PID                        0x1939
+#define AURA_MOTHERBOARD_3_PID                        0x19AF
 
 /*-----------------------------------------------------------------*\
 |  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_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_STRIX_EVOLVE_PID                     0x185B
+#define AURA_ROG_SPATHA_WIRED_PID                     0x181C
+#define AURA_ROG_SPATHA_WIRELESS_PID                  0x1824
 
 /*-----------------------------------------------------------------*\
 | MOUSEMATS                                                         |
 \*-----------------------------------------------------------------*/
-#define AURA_ROG_BALTEUS_PID                    0x1891
-#define AURA_ROG_BALTEUS_QI_PID                 0x1890
+#define AURA_ROG_BALTEUS_PID                          0x1891
+#define AURA_ROG_BALTEUS_QI_PID                       0x1890
 
 /*-----------------------------------------------------------------*\
 | MONITORS                                                          |
 \*-----------------------------------------------------------------*/
 
-#define AURA_ROG_STRIX_XG27AQ_PID               0x198C
-#define AURA_ROG_STRIX_XG27AQM_PID              0x19BB
-#define AURA_ROG_STRIX_XG279Q_PID               0x1919
-#define AURA_ROG_STRIX_XG27W_PID                0x1933
-#define AURA_ROG_PG32UQ_PID                     0x19B9
+#define AURA_ROG_STRIX_XG27AQ_PID                     0x198C
+#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
 
 /*-----------------------------------------------------------------*\
 | HEADSETSTANDS                                                     |
 \*-----------------------------------------------------------------*/
 
-#define AURA_ROG_THRONE_PID                     0x18D9
-#define AURA_ROG_THRONE_QI_PID                  0x18C5
-#define AURA_ROG_THRONE_QI_GUNDAM_PID           0x1994
+#define AURA_ROG_THRONE_PID                           0x18D9
+#define AURA_ROG_THRONE_QI_PID                        0x18C5
+#define AURA_ROG_THRONE_QI_GUNDAM_PID                 0x1994
 
 /*-----------------------------------------------------------------*\
 |  OTHER                                                            |
 \*-----------------------------------------------------------------*/
-#define AURA_TERMINAL_PID                       0x1889
-#define ROG_STRIX_LC120_PID                     0x879E
-#define AURA_RYUO_AIO_PID                       0x1887
-#define ASUS_ROG_ALLY_PID                       0x1ABE
+#define AURA_TERMINAL_PID                             0x1889
+#define ROG_STRIX_LC120_PID                           0x879E
+#define AURA_RYUO_AIO_PID                             0x1887
+#define ASUS_ROG_ALLY_PID                             0x1ABE
 
 AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
 {
     switch(pid)
     {
-        case AURA_ROG_STRIX_FLARE_PID:
-        case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
-        case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
-            return FLARE_LAYOUT;
-
         case AURA_ROG_STRIX_SCOPE_PID:
             return SCOPE_LAYOUT;
 
@@ -159,7 +167,7 @@ void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*n
         {
             DMIInfo dmi;
             AuraMainboardController* controller             = new AuraMainboardController(dev, info->path);
-            RGBController_AuraUSB*   rgb_controller         = new RGBController_AuraUSB(controller);
+            RGBController_AuraMainboard*   rgb_controller   = new RGBController_AuraMainboard(controller);
             rgb_controller->name                            = "ASUS " + dmi.getMainboard();
             ResourceManager::get()->RegisterRGBController(rgb_controller);
         }
@@ -191,19 +199,11 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
 
     if(dev)
     {
-        AuraMouseController*     controller                 = new AuraMouseController(dev, info->path, info->product_id);
+        uint16_t pid = (name == "Asus ROG Spatha X Dock") ? AURA_ROG_SPATHA_X_DOCK_FAKE_PID : info->product_id;
+        AuraMouseController*     controller                 = new AuraMouseController(dev, info->path, pid);
         RGBController_AuraMouse* rgb_controller             = new RGBController_AuraMouse(controller);
         rgb_controller->name                                = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
-
-        // adding the mouse dock for the ASUS ROG Spatha X
-        if(info->product_id == AURA_ROG_SPATHA_X_2_4_PID)
-        {
-            AuraMouseController*     dock_controller            = new AuraMouseController(dev, info->path, AURA_ROG_SPATHA_X_DOCK_FAKE_PID);
-            RGBController_AuraMouse* rgb_controller_dock        = new RGBController_AuraMouse(dock_controller);
-            rgb_controller_dock->name                           = "Asus ROG Spatha X Dock";
-            ResourceManager::get()->RegisterRGBController(rgb_controller_dock);
-        }
     }
 }
 
@@ -252,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);
     }
@@ -325,62 +338,78 @@ REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAs
 /*-----------------------------------------------------------------*\
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                     1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",                DetectAsusAuraUSBKeyboards,     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",DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_COD_BO4_PID,             1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope",                        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID,                     1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX",                     DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_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 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 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 TUF Gaming K7",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_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 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                                                         |
@@ -395,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_AsusAuraMainboard.cpp

@@ -0,0 +1,78 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraMainboard.cpp      |
+|                                           |
+|  RGB controller for Asus Aura USB         |
+|  mainboards                               |
+|                                           |
+|  rytypete 8/30/2023                       |
+|  based on RGBController_AsusAuraUSB.cpp   |
+|  code                                     |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusAuraMainboard.h"
+
+/**------------------------------------------------------------------*\
+    @name Asus Aura USB Mainboard
+    @category Motherboard
+    @type USB
+    @save :white_check_mark:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAsusAuraUSBMotherboards
+    @comment The Asus Aura USB Mainboard controller applies to most
+        AMD and Intel mainboards from the x570 chipset onwards.
+\*-------------------------------------------------------------------*/
+
+RGBController_AuraMainboard::RGBController_AuraMainboard(AuraMainboardController* controller_ptr) :
+    RGBController_AuraUSB(controller_ptr)
+{
+    name        = "ASUS Aura USB Mainboard";
+    description = "ASUS Aura USB Mainboard Device";
+
+    /*-------------------------------------------------------*\
+    | Add manual save flag to all modes except direct mode    |
+    \*-------------------------------------------------------*/
+    for(unsigned int mode_idx = 0; mode_idx < modes.size(); mode_idx++)
+    {
+        mode Mode = modes[mode_idx];
+        if(Mode.value != AURA_MODE_DIRECT)
+        {
+            Mode.flags |= MODE_FLAG_MANUAL_SAVE;
+            modes[mode_idx] = Mode;
+        }
+    }
+}
+
+void RGBController_AuraMainboard::DeviceUpdateShutdownEffect()
+{
+    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]);
+    }
+
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        AuraDeviceInfo device_info = controller->GetAuraDevices()[zone_idx];
+
+        /*---------------------------------------------------*\
+        | Shutdown effect only works with onboard lighting    |
+        \*---------------------------------------------------*/
+        if(device_info.device_type == AuraDeviceType::FIXED && zones[zone_idx].leds_count > 0)
+        {
+            ((AuraMainboardController*) controller)->SetMode(zone_idx, modes[active_mode].value, red, grn, blu, true);
+        }
+    }
+}
+
+void RGBController_AuraMainboard::DeviceSaveMode()
+{
+    DeviceUpdateMode();
+    DeviceUpdateShutdownEffect();
+    ((AuraMainboardController*) controller)->SendCommit();
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraMainboard.h

@@ -0,0 +1,25 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraMainboard.h        |
+|                                           |
+|  RGB controller for Asus Aura USB         |
+|  mainboards                               |
+|                                           |
+|  rytypete 8/30/2023                       |
+|  based on RGBController_AsusAuraUSB.h     |
+|  code                                     |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController_AsusAuraUSB.h"
+#include "AsusAuraMainboardController.h"
+
+class RGBController_AuraMainboard : public RGBController_AuraUSB
+{
+public:
+    RGBController_AuraMainboard(AuraMainboardController* controller_ptr);
+
+    void        DeviceSaveMode();
+
+private:
+    void        DeviceUpdateShutdownEffect();
+};

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp

@@ -9,11 +9,12 @@
 
 #include "RGBController_AsusAuraMouse.h"
 
-static std::string aura_mouse_zone_names[4]
+static std::string aura_mouse_zone_names[5]
 {
     "Logo",
     "Scroll Wheel",
     "Underglow",
+    "All",
     "Dock"
 };
 
@@ -44,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++)
@@ -51,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;
 
@@ -200,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);
+        }
     }
 }
 
@@ -213,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]);
@@ -222,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

@@ -49,23 +49,32 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
                 AURA_KEYBOARD_SPEED_MAX          = 2;
                 AURA_KEYBOARD_SPEED_DEFAULT      = 1;
                 break;
+            case AURA_ROG_STRIX_FLARE_PID:
+            case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
+            case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
             case AURA_TUF_K3_GAMING_PID:
             case AURA_TUF_K7_GAMING_PID:
                 AURA_KEYBOARD_SPEED_MIN          = 15;
                 AURA_KEYBOARD_SPEED_MAX          = 0;
                 AURA_KEYBOARD_SPEED_DEFAULT      = 8;
                 break;
-            case AURA_TUF_K5_GAMING_PID:
-                AURA_KEYBOARD_SPEED_MIN          = 63;
-                AURA_KEYBOARD_SPEED_MAX          = 0;
-                AURA_KEYBOARD_SPEED_DEFAULT      = 31;
-                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;
                 AURA_KEYBOARD_SPEED_MAX          = 0;
-                AURA_KEYBOARD_SPEED_DEFAULT      = 8;
+                AURA_KEYBOARD_SPEED_DEFAULT      = 30;
                 break;
             default:
                 AURA_KEYBOARD_SPEED_MIN          = 15;
@@ -397,12 +406,37 @@ void RGBController_AuraTUFKeyboard::SetupZones()
 
     switch(pid)
     {
+        case AURA_ROG_STRIX_FLARE_PID:
+        case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
+        case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
+            keyboard_ptr = &AsusROGStrixFlareLayouts;
+            break;
         case AURA_TUF_K3_GAMING_PID:
         case AURA_TUF_K7_GAMING_PID:
             keyboard_ptr = &AsusTUFK7Layouts;
             break;
-        case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
+        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_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_AsusAuraUSB.cpp

@@ -16,9 +16,9 @@
     @save :x:
     @direct :white_check_mark:
     @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBTerminal,DetectAsusAuraUSBAddressable,DetectAsusAuraUSBMotherboards
+    @detectors DetectAsusAuraUSBTerminal,DetectAsusAuraUSBAddressable
     @comment The Asus Aura USB controller applies to most AMD and
-        Intel mainboards from the x470 and z390 chipsets onwards.
+        Intel mainboards from the x470 and z390 chipset generations.
 \*-------------------------------------------------------------------*/
 
 RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* controller_ptr) :

Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.h

@@ -29,8 +29,10 @@ public:
 
     void        DeviceUpdateMode();
 
-private:
+protected:
     AuraUSBController*          controller;
+
+private:
     std::vector<unsigned int>   leds_channel;
     std::vector<unsigned int>   zones_channel;
     bool                        initializedMode;

Controllers/AsusAuraUSBController/RGBController_AsusROGAlly.cpp

@@ -13,9 +13,9 @@
     @name Asus ROG Ally
     @category Gamepad
     @type USB
-    @save :x:
+    @save :white_check_mark:
     @direct :white_check_mark:
-    @effects :x:
+    @effects :white_check_mark:
     @detectors DetectAsusROGAlly
     @comment
 \*-------------------------------------------------------------------*/
@@ -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/AsusLegacyUSBController/AsusLegacyUSBControllerDetect.cpp

@@ -1,16 +1,20 @@
 #include "Detector.h"
 #include "AsusCerberusKeyboardController.h"
+#include "AsusSagarisKeyboardController.h"
 #include "AsusStrixClawController.h"
 #include "RGBController.h"
 #include "RGBController_AsusCerberusKeyboard.h"
+#include "RGBController_AsusSagarisKeyboard.h"
 #include "RGBController_AsusStrixClaw.h"
 #include <stdexcept>
 #include <hidapi/hidapi.h>
 #include "dependencies/dmiinfo.h"
 
 #define ASUS_LEGACY_USB_VID         0x195D
+#define ASUS_USB_VID                0x0B05
 
 #define ASUS_CERBERUS_MECH_PID      0x2047
+#define ASUS_SAGARIS_GK1100_PID     0x1835
 #define ASUS_ROG_STRIX_CLAW_PID     0x1016
 
 void DetectAsusCerberusMech(hid_device_info* info, const std::string& name)
@@ -26,6 +30,19 @@ void DetectAsusCerberusMech(hid_device_info* info, const std::string& name)
     }
 }
 
+void DetectAsusSagarisKeyboard(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AsusSagarisKeyboardController*     controller          = new AsusSagarisKeyboardController(dev, info->path, info->release_number);
+        RGBController_AsusSagarisKeyboard* rgb_controller      = new RGBController_AsusSagarisKeyboard(controller);
+        rgb_controller->name                                = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 void DetectAsusStrixClaw(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -40,5 +57,6 @@ void DetectAsusStrixClaw(hid_device_info* info, const std::string& name)
 }
 
 REGISTER_HID_DETECTOR_IPU("ASUS Cerberus Mech",  DetectAsusCerberusMech,  ASUS_LEGACY_USB_VID, ASUS_CERBERUS_MECH_PID,  1, 0xFF01, 1);
+REGISTER_HID_DETECTOR_IPU("ASUS Sagaris GK1100", DetectAsusSagarisKeyboard,       ASUS_USB_VID,        ASUS_SAGARIS_GK1100_PID, 1, 0xFF02, 2);
 
 REGISTER_HID_DETECTOR_IPU("ASUS ROG Strix Claw", DetectAsusStrixClaw,     ASUS_LEGACY_USB_VID, ASUS_ROG_STRIX_CLAW_PID, 0, 0xFF01, 1);

Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController.cpp

@@ -0,0 +1,197 @@
+/*-----------------------------------------*\
+|  AsusSagarisKeyboardController.cpp       |
+|                                           |
+|  Driver for ASUS Sagaris USB lighting    |
+|  controller                               |
+|                                           |
+|  Mola19 08/20/2023                        |
+\*-----------------------------------------*/
+
+#include "AsusSagarisKeyboardController.h"
+
+#include <cstring>
+#include <string>
+#include <math.h>
+#include <vector>
+#include <string.h>
+
+#include "LogManager.h"
+
+#define ASUS_SAGARIS_KB_PACKET_SIZE 65
+
+AsusSagarisKeyboardController::AsusSagarisKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version)
+{
+    dev         = dev_handle;
+    location    = path;
+    version     = rev_version;
+}
+
+AsusSagarisKeyboardController::~AsusSagarisKeyboardController()
+{
+    hid_close(dev);
+}
+
+std::string AsusSagarisKeyboardController::GetVersion()
+{
+    return std::to_string((int) floor(version / 0x100)) + "." + std::to_string(version % 0x100);
+}
+
+std::string AsusSagarisKeyboardController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AsusSagarisKeyboardController::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);
+}
+
+sagaris_mode AsusSagarisKeyboardController::GetMode()
+{
+    ClearResponses();
+
+    uint8_t usb_buf_out[ASUS_SAGARIS_KB_PACKET_SIZE];
+    memset(usb_buf_out, 0x00, sizeof(usb_buf_out));
+
+    usb_buf_out[0x00] = 0x06;
+    usb_buf_out[0x01] = 0x0B;
+    usb_buf_out[0x02] = 0x03;
+
+    hid_write(dev, usb_buf_out, ASUS_SAGARIS_KB_PACKET_SIZE);
+
+    unsigned char usb_buf_in[ASUS_SAGARIS_KB_PACKET_SIZE];
+    memset(usb_buf_in, 0x00, sizeof(usb_buf_in));
+    int return_length = hid_read_timeout(dev, usb_buf_in, ASUS_SAGARIS_KB_PACKET_SIZE, 100);
+
+    if(return_length == -1)
+    {
+        LOG_DEBUG("[Asus Sagaris GK1100]: Could not fetch mode");
+        sagaris_mode default_mode;
+        default_mode.mode       = SAGARIS_KEYBOARD_MODE_STATIC;
+        default_mode.brightness = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
+        default_mode.speed      = 0;
+        default_mode.colorIndex = 0;
+
+        return default_mode;
+    }
+
+    sagaris_mode current_mode;
+    current_mode.mode       = usb_buf_in[3];
+    current_mode.brightness = usb_buf_in[4];
+    current_mode.speed      = usb_buf_in[5];
+    current_mode.colorIndex = usb_buf_in[6];
+
+    return current_mode;
+}
+
+std::vector<RGBColor> AsusSagarisKeyboardController::GetColors()
+{
+    ClearResponses();
+
+    uint8_t usb_buf_out[ASUS_SAGARIS_KB_PACKET_SIZE];
+    memset(usb_buf_out, 0x00, sizeof(usb_buf_out));
+
+    usb_buf_out[0x00] = 0x06;
+    usb_buf_out[0x01] = 0x0B;
+    usb_buf_out[0x02] = 0x05;
+
+    hid_write(dev, usb_buf_out, ASUS_SAGARIS_KB_PACKET_SIZE);
+
+    std::vector<RGBColor> colors;
+    colors.resize(7);
+
+    for(int i = 0; i < 7; i++)
+    {
+        unsigned char usb_buf_in[ASUS_SAGARIS_KB_PACKET_SIZE];
+        memset(usb_buf_in, 0x00, sizeof(usb_buf_in));
+        int return_length = hid_read_timeout(dev, usb_buf_in, ASUS_SAGARIS_KB_PACKET_SIZE, 100);
+
+        if(return_length == -1)
+        {
+           LOG_DEBUG("[Asus Sagaris GK1100]: Could not fetch color %i", i);
+           colors[i] = ToRGBColor(0, 0, 0);
+           continue;
+        }
+
+        colors[i] = ToRGBColor(usb_buf_in[4] * 16, usb_buf_in[5] * 16, usb_buf_in[6] * 16);
+    }
+
+    return colors;
+}
+
+void AsusSagarisKeyboardController::SetColor
+    (
+    uint8_t           index,
+    uint8_t           red,
+    uint8_t           green,
+    uint8_t           blue
+    )
+{
+    uint8_t usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00] = 0x06;
+    usb_buf[0x01] = 0x0B;
+    usb_buf[0x02] = 0x04;
+    usb_buf[0x03] = 0x00;
+    usb_buf[0x04] = index;
+    usb_buf[0x05] = red;
+    usb_buf[0x06] = green;
+    usb_buf[0x07] = blue;
+
+    hid_write(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE);
+}
+
+void AsusSagarisKeyboardController::SetMode
+    (
+    uint8_t           mode,
+    uint8_t           brightness,
+    uint8_t           speed,
+    uint8_t           colorIndex
+    )
+{
+    ClearResponses();
+
+    uint8_t usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00] = 0x06;
+    usb_buf[0x01] = 0x0B;
+    usb_buf[0x02] = 0x01;
+    usb_buf[0x03] = mode;
+    usb_buf[0x04] = brightness;
+    usb_buf[0x05] = speed;
+    usb_buf[0x06] = colorIndex;
+
+    hid_write(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE);
+
+    AwaitResponse(20);
+}
+
+void AsusSagarisKeyboardController::AwaitResponse(int ms)
+{
+    unsigned char usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE];
+    hid_read_timeout(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE, ms);
+}
+
+void AsusSagarisKeyboardController::ClearResponses()
+{
+    int result = 1;
+    unsigned char usb_buf_flush[65];
+    while(result > 0)
+    {
+        result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
+    }
+}

Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController.h

@@ -0,0 +1,76 @@
+/*-----------------------------------------*\
+|  AsusSagarisKeyboardController.h         |
+|                                           |
+|  Definitions and types for ASUS Sagaris  |
+|  USB RGB lighting controller              |
+|                                           |
+|  Mola19 08/20/2023                        |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    SAGARIS_KEYBOARD_MODE_OFF           = 0,
+    SAGARIS_KEYBOARD_MODE_STATIC        = 1,
+    SAGARIS_KEYBOARD_MODE_SPRIAL        = 2,
+    SAGARIS_KEYBOARD_MODE_CUSTOM        = 3,
+    SAGARIS_KEYBOARD_MODE_BREATHING     = 4,
+    SAGARIS_KEYBOARD_MODE_REACTIVE      = 5,
+    SAGARIS_KEYBOARD_MODE_STARRY_NIGHT  = 6,
+    SAGARIS_KEYBOARD_MODE_LASER         = 7,
+};
+
+enum
+{
+    SAGARIS_KEYBOARD_BRIGHTNESS_MIN     = 0,
+    SAGARIS_KEYBOARD_BRIGHTNESS_MAX     = 3,
+    SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT = 3
+};
+
+enum
+{
+    SAGARIS_KEYBOARD_SPEED_MIN     = 0,
+    SAGARIS_KEYBOARD_SPEED_MAX     = 3,
+    SAGARIS_KEYBOARD_SPEED_DEFAULT = 2
+};
+
+typedef struct
+{
+    uint8_t                 mode;
+    uint8_t                 brightness;
+    uint8_t                 speed;
+    uint8_t                 colorIndex;
+} sagaris_mode;
+
+
+class AsusSagarisKeyboardController
+{
+public:
+    AsusSagarisKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version);
+    ~AsusSagarisKeyboardController();
+
+    std::string GetVersion();
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    sagaris_mode          GetMode();
+    std::vector<RGBColor> GetColors();
+
+    void SetMode(uint8_t mode, uint8_t brightness, uint8_t speed, uint8_t colorIndex);
+    void SetColor(uint8_t index, uint8_t red, uint8_t green, uint8_t blue);
+
+    void AwaitResponse(int ms);
+    void ClearResponses();
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+    unsigned short              version;
+};

Controllers/AsusLegacyUSBController/RGBController_AsusSagarisKeyboard.cpp

@@ -0,0 +1,246 @@
+/*-----------------------------------------*\
+|  RGBController_AsusSagarisKeyboard.cpp    |
+|                                           |
+|  Generic RGB Interface for Asus Sagaris   |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 08/20/2023                        |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusSagarisKeyboard.h"
+#include <vector>
+
+/**------------------------------------------------------------------*\
+    @name Asus Sagaris Keyboard
+    @category Keyboard
+    @type USB
+    @save :robot:
+    @direct :x:
+    @effects :white_check_mark:
+    @detectors DetectAsusSagarisKeyboard
+    @comment Missing controls for modifier keys, as they have independent lighting
+\*-------------------------------------------------------------------*/
+
+#include <iostream>
+
+RGBController_AsusSagarisKeyboard::RGBController_AsusSagarisKeyboard(AsusSagarisKeyboardController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "ASUS Sagaris Keyboard";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "ASUS Sagaris Keyboard Device";
+    version    = controller->GetVersion();
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
+
+    mode Off;
+    Off.name                     = "Off";
+    Off.value                    = SAGARIS_KEYBOARD_MODE_OFF;
+    Off.flags                    = MODE_FLAG_AUTOMATIC_SAVE;
+    Off.color_mode               = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Static;
+    Static.name                  = "Static";
+    Static.value                 = SAGARIS_KEYBOARD_MODE_STATIC;
+    Static.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.brightness_min        = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
+    Static.brightness_max        = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
+    Static.brightness            = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Static.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min            = 1;
+    Static.colors_max            = 1;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Spiral;
+    Spiral.name                  = "Spiral";
+    Spiral.value                 = SAGARIS_KEYBOARD_MODE_SPRIAL;
+    Spiral.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Spiral.brightness_min        = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
+    Spiral.brightness_max        = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
+    Spiral.brightness            = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Spiral.speed_min             = SAGARIS_KEYBOARD_SPEED_MIN;
+    Spiral.speed_max             = SAGARIS_KEYBOARD_SPEED_MAX;
+    Spiral.speed                 = SAGARIS_KEYBOARD_SPEED_DEFAULT;
+    Spiral.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Spiral.colors_min            = 7;
+    Spiral.colors_max            = 7;
+    Spiral.colors.resize(7);
+    modes.push_back(Spiral);
+
+    mode Custom;
+    Custom.name                  = "Custom";
+    Custom.value                 = SAGARIS_KEYBOARD_MODE_CUSTOM;
+    Custom.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Custom.brightness_min        = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
+    Custom.brightness_max        = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
+    Custom.brightness            = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Custom.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Custom.colors_min            = 7;
+    Custom.colors_max            = 7;
+    Custom.colors.resize(7);
+    modes.push_back(Custom);
+
+    mode Breathing;
+    Breathing.name               = "Breathing";
+    Breathing.value              = SAGARIS_KEYBOARD_MODE_BREATHING;
+    Breathing.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED;
+    Breathing.speed_min          = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
+    Breathing.speed_max          = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
+    Breathing.speed              = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Breathing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors_min         = 7;
+    Breathing.colors_max         = 7;
+    Breathing.colors.resize(7);
+    modes.push_back(Breathing);
+
+    mode Reactive;
+    Reactive.name                = "Reactive";
+    Reactive.value               = SAGARIS_KEYBOARD_MODE_REACTIVE;
+    Reactive.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Reactive.brightness_min      = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
+    Reactive.brightness_max      = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
+    Reactive.brightness          = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Reactive.speed_min           = SAGARIS_KEYBOARD_SPEED_MIN;
+    Reactive.speed_max           = SAGARIS_KEYBOARD_SPEED_MAX;
+    Reactive.speed               = SAGARIS_KEYBOARD_SPEED_DEFAULT;
+    Reactive.color_mode          = MODE_COLORS_MODE_SPECIFIC;
+    Reactive.colors_min          = 1;
+    Reactive.colors_max          = 1;
+    Reactive.colors.resize(1);
+    modes.push_back(Reactive);
+
+    mode Starry_Night;
+    Starry_Night.name            = "Starry Night";
+    Starry_Night.value           = SAGARIS_KEYBOARD_MODE_STARRY_NIGHT;
+    Starry_Night.flags           = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Starry_Night.brightness_min  = SAGARIS_KEYBOARD_SPEED_MIN;
+    Starry_Night.brightness_max  = SAGARIS_KEYBOARD_SPEED_MAX;
+    Starry_Night.brightness      = SAGARIS_KEYBOARD_SPEED_DEFAULT;
+    Starry_Night.speed_min       = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
+    Starry_Night.speed_max       = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
+    Starry_Night.speed           = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Starry_Night.color_mode      = MODE_COLORS_MODE_SPECIFIC;
+    Starry_Night.colors_min      = 7;
+    Starry_Night.colors_max      = 7;
+    Starry_Night.colors.resize(7);
+    modes.push_back(Starry_Night);
+
+    mode Laser;
+    Laser.name                   = "Laser";
+    Laser.value                  = SAGARIS_KEYBOARD_MODE_LASER;
+    Laser.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Laser.brightness_min         = SAGARIS_KEYBOARD_SPEED_MIN;
+    Laser.brightness_max         = SAGARIS_KEYBOARD_SPEED_MAX;
+    Laser.brightness             = SAGARIS_KEYBOARD_SPEED_DEFAULT;
+    Laser.speed_min              = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
+    Laser.speed_max              = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
+    Laser.speed                  = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Laser.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Laser.colors_min             = 7;
+    Laser.colors_max             = 7;
+    Laser.colors.resize(7);
+    modes.push_back(Laser);
+
+    SetupZones();
+
+    sagaris_mode current_mode = controller->GetMode();
+
+    active_mode = current_mode.mode;
+    last_mode   = current_mode.mode;
+    modes[active_mode].brightness = current_mode.brightness;
+    modes[active_mode].speed      = current_mode.speed;
+
+    current_colors = controller->GetColors();
+
+    for(int i = 0; i < modes[active_mode].colors.size(); i++)
+    {
+        modes[active_mode].colors[i] = current_colors[i];
+    }
+}
+
+RGBController_AsusSagarisKeyboard::~RGBController_AsusSagarisKeyboard()
+{
+    delete controller;
+}
+
+void RGBController_AsusSagarisKeyboard::SetupZones()
+{
+    zone keyboard;
+    keyboard.name               = "Keyboard";
+    keyboard.type               = ZONE_TYPE_SINGLE;
+    keyboard.leds_min           = 1;
+    keyboard.leds_max           = 1;
+    keyboard.leds_count         = 1;
+    keyboard.matrix_map         = nullptr;
+
+    SetupColors();
+}
+
+void RGBController_AsusSagarisKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
+void RGBController_AsusSagarisKeyboard::DeviceUpdateLEDs()
+{
+
+}
+
+void RGBController_AsusSagarisKeyboard::UpdateZoneLEDs(int /*zone*/)
+{
+
+}
+
+void RGBController_AsusSagarisKeyboard::UpdateSingleLED(int led)
+{
+    
+}
+
+void RGBController_AsusSagarisKeyboard::DeviceUpdateMode()
+{
+    if(last_mode != active_mode)
+    {
+        last_mode = active_mode;
+        for(int i = 0; i < modes[active_mode].colors.size(); i++)
+        {
+            modes[active_mode].colors[i] = current_colors[i];
+        }
+    }
+    else
+    {
+        for(int i = 0; i < modes[active_mode].colors.size(); i++)
+        {
+            current_colors[i] = modes[active_mode].colors[i];
+        }
+
+        for(int i = 0; i < modes[active_mode].colors.size(); i++)
+        {
+            /*-----------------------------------------*\
+            | This device uses 4bit colorValues (0-16)  |
+            \*-----------------------------------------*/
+            uint8_t red     = RGBGetRValue(modes[active_mode].colors[i]) / 16;
+            uint8_t green   = RGBGetGValue(modes[active_mode].colors[i]) / 16;
+            uint8_t blue    = RGBGetBValue(modes[active_mode].colors[i]) / 16;
+
+            controller->SetColor(i, red, green, blue);
+        }
+    }
+
+    /*------------------------------------------------------------------------------------------------------*\
+    | This device uses a global color storage for 7 colors,                                                  |
+    | each time a mode is selected, it is specified which color is chosen (some use all).                    |
+    | As OpenRGB doesn't support selecting the color index, color 1 is used for single color modes.          |
+    \*------------------------------------------------------------------------------------------------------*/
+
+    uint8_t colorIndex = 0;
+
+    uint8_t mode = modes[active_mode].value;
+
+    if(mode == SAGARIS_KEYBOARD_MODE_STARRY_NIGHT) colorIndex = 7;
+
+    controller->SetMode(mode, modes[active_mode].brightness, modes[active_mode].speed, colorIndex);
+}

Controllers/AsusLegacyUSBController/RGBController_AsusSagarisKeyboard.h

@@ -0,0 +1,34 @@
+/*-----------------------------------------*\
+|  RGBController_AsusSagarisKeyboard.h     |
+|                                           |
+|  Generic RGB Interface for Asus Sagaris  |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 08/20/2023                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusSagarisKeyboardController.h"
+
+class RGBController_AsusSagarisKeyboard : public RGBController
+{
+public:
+    RGBController_AsusSagarisKeyboard(AsusSagarisKeyboardController* controller_ptr);
+    ~RGBController_AsusSagarisKeyboard();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AsusSagarisKeyboardController*  controller;
+    std::vector<RGBColor>           current_colors;
+    uint8_t                         last_mode;
+};

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/BlinkyTapeController/BlinkyTapeControllerDetect.cpp

@@ -2,7 +2,6 @@
 #include "BlinkyTapeController.h"
 #include "RGBController.h"
 #include "RGBController_BlinkyTape.h"
-#include "SettingsManager.h"
 #include "find_usb_serial_port.h"
 #include <vector>
 #include <stdio.h>

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

@@ -1,4 +1,5 @@
 #include "Detector.h"
+#include "LogManager.h"
 #include "ColorfulGPUController.h"
 #include "RGBController.h"
 #include "RGBController_ColorfulGPU.h"
@@ -22,7 +23,9 @@ bool TestForColorfulGPU(i2c_smbus_interface* bus, uint8_t i2c_addr)
 
     int res = bus->i2c_read_block(i2c_addr, &pktsz, read_pkt);
 
-    return res == 0 && (read_pkt[0] == 0xAA && read_pkt[1] == 0xEF && read_pkt[2] == 0x81);
+    LOG_DEBUG("[ColorfulGPUController] Handshake: res: %d. Expected 0xAA, 0xEF, 0x81. Received: 0x%02X, 0x%02X, 0x%02X.", res, read_pkt[0], read_pkt[1], read_pkt[2]);
+
+    return res >= 0 && (read_pkt[0] == 0xAA && read_pkt[1] == 0xEF && read_pkt[2] == 0x81);
 }
 
 void DetectColorfulGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
@@ -37,18 +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 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/ColorfulTuringGPUController/ColorfulTuringGPUController.cpp

@@ -65,12 +65,19 @@ void ColorfulTuringGPUController::SetStateDisplay(RGBColor color)
     bus->i2c_write_block(dev, COLORFUL_COLOR_PACKET_LENGTH, data_pkt);
 }
 
-void ColorfulTuringGPUController::SetDirect(RGBColor color)
+void ColorfulTuringGPUController::SetDirect(RGBColor color, bool save)
 {
     uint8_t r = RGBGetRValue(color);
     uint8_t g = RGBGetGValue(color);
     uint8_t b = RGBGetBValue(color);
-    uint8_t data_pkt[COLORFUL_COLOR_PACKET_LENGTH] = { 0x88, 0x02, 0x32, 0x02, r, g, b};
+    uint8_t data_pkt[COLORFUL_COLOR_PACKET_LENGTH] = { 0x08, 0x0, 0x20, 0x10, r, g, b};
+    if(save)
+    {
+        data_pkt[0] = 0x88;
+        data_pkt[1] = 0x02;
+        data_pkt[2] = 0x32;
+        data_pkt[3] = 0x02;
+    }
 
     int crc = 1;
 

Controllers/ColorfulTuringGPUController/ColorfulTuringGPUController.h

@@ -28,7 +28,7 @@ public:
     std::string             GetDeviceLocation();
     int                     GetMode();
     RGBColor                GetColor();
-    void                    SetDirect(RGBColor color);
+    void                    SetDirect(RGBColor color, bool save);
     void                    SetStateDisplay(RGBColor color);
     void                    SetBreathing(RGBColor color);
     void                    SetOff();

Controllers/ColorfulTuringGPUController/ColorfulTuringGPUControllerDetect.cpp

@@ -20,4 +20,5 @@ void DetectColorfulTuringGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_ad
     }
 }
 
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 2070 SUPER Advanced OC-V", DetectColorfulTuringGPUControllers,   NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_2070_SUPER_ADVANCED_OCV, 0x50);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 2070 SUPER Advanced OC-V", DetectColorfulTuringGPUControllers,   NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_2070_SUPER_ADVANCED_OCV,  0x50);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 2070 SUPER Advanced OC-V", DetectColorfulTuringGPUControllers,   NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_2070_SUPER_ADVANCED_OCV2, 0x50);

Controllers/ColorfulTuringGPUController/RGBController_ColorfulTuringGPU.cpp

@@ -31,7 +31,7 @@ RGBController_ColorfulTuringGPU::RGBController_ColorfulTuringGPU(ColorfulTuringG
     mode Direct;
     Direct.name             = "Direct";
     Direct.value            = COLORFUL_TURING_GPU_RGB_MODE_STATIC;
-    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
     Direct.color_mode       = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
@@ -86,7 +86,7 @@ void RGBController_ColorfulTuringGPU::SetupZones()
     zone new_zone;
 
     new_zone.name       = "GPU";
-    new_zone.type       = ZONE_TYPE_LINEAR;
+    new_zone.type       = ZONE_TYPE_SINGLE;
     new_zone.leds_min   = 1;
     new_zone.leds_max   = 1;
     new_zone.leds_count = 1;
@@ -122,10 +122,10 @@ void RGBController_ColorfulTuringGPU::DeviceUpdateLEDs()
             controller->SetStateDisplay(colors[0]);
             break;
         case COLORFUL_TURING_GPU_RGB_MODE_STATIC:
-            controller->SetDirect(colors[0]);
+            controller->SetDirect(colors[0], false);
             break;
         default:
-            controller->SetDirect(colors[0]);
+            controller->SetDirect(colors[0], false);
     }
 }
 
@@ -143,3 +143,15 @@ void RGBController_ColorfulTuringGPU::DeviceUpdateMode()
 {
     DeviceUpdateLEDs();
 }
+
+void RGBController_ColorfulTuringGPU::DeviceSaveMode()
+{
+    switch(modes[active_mode].value)
+    {
+        case COLORFUL_TURING_GPU_RGB_MODE_STATIC:
+            controller->SetDirect(colors[0], true);
+            break;
+        default:
+            DeviceUpdateLEDs();
+    }
+}

Controllers/ColorfulTuringGPUController/RGBController_ColorfulTuringGPU.h

@@ -15,6 +15,7 @@ public:
     void                         UpdateZoneLEDs(int zone);
     void                         UpdateSingleLED(int led);
     void                         DeviceUpdateMode();
+    void                         DeviceSaveMode();
 
 private:
     ColorfulTuringGPUController* controller;

Controllers/CoolerMasterController/CMARGBcontroller.cpp

@@ -36,7 +36,10 @@ CMARGBController::CMARGBController(hid_device* dev_handle, char *_path, unsigned
 
 CMARGBController::~CMARGBController()
 {
-    hid_close(dev);
+    if(mutex_ptr.use_count() <= 1)
+    {
+        hid_close(dev);
+    }
 }
 
 void CMARGBController::GetStatus()

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;
+};
+