ENE Mode 14 test

+ Adding PID for the Leviathan V2 X
+ Registered detectors
+ Added metadata to RazerDevices.cpp
+ Added capabilities to RazerController.cpp
+ Resolves #3450

.gitignore

@@ -6,6 +6,8 @@ OpenRGB
 openrgb
 OpenRGB-x86_64.AppImage
 60-openrgb.rules
+debian/changelog
+fedora/OpenRGB.spec
 
 # Directories
 .build/
@@ -116,4 +118,3 @@ compile_commands.json
 
 # Generated i18n files
 *.qm
-

.gitlab-ci.yml

@@ -109,6 +109,7 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
   stage: build
   script:
+  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage --target-arch i386 -us -B
   - rm -v ../openrgb-dbgsym*.*deb
@@ -137,6 +138,7 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
   stage: build
   script:
+  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage -us -B
   - rm -v ../openrgb-dbgsym*.*deb
@@ -165,6 +167,7 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-32
   stage: build
   script:
+  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage --target-arch i386 -us -B
   - rm -v ../openrgb-dbgsym*.*deb
@@ -193,6 +196,7 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
   stage: build
   script:
+  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage -us -B
   - rm -v ../openrgb-dbgsym*.*deb
@@ -221,6 +225,7 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-32
   stage: build
   script:
+  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage --target-arch i386 -us -B
   - rm -v ../openrgb-dbgsym*.deb
@@ -249,6 +254,7 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-64
   stage: build
   script:
+  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage -us -B
   - rm -v ../openrgb-dbgsym*.deb
@@ -278,6 +284,7 @@ before_script:
   script:
   - dnf install rpmdevtools dnf-plugins-core -y
   - rpmdev-setuptree
+  - ./scripts/build-package-files.sh fedora/OpenRGB.spec
   - ls /root/
   - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
   - cp ../OpenRGB /root/rpmbuild/SOURCES/ -r
@@ -310,8 +317,9 @@ before_script:
   image: fedora:36
   stage: build
   script:
-  - dnf install rpmdevtools dnf-plugins-core libcurl-devel -y
+  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel -y
   - rpmdev-setuptree
+  - ./scripts/build-package-files.sh fedora/OpenRGB.spec
   - ls /root/
   - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
   - cp ../OpenRGB /root/rpmbuild/SOURCES/ -r
@@ -562,6 +570,8 @@ before_script:
     name: "${CI_PROJECT_NAME}_Windows_32_${CI_COMMIT_SHORT_SHA}"
     paths:
     - 'OpenRGB Windows 32-bit'
+    exclude:
+    - 'OpenRGB Windows 32-bit\*.qm'
     expire_in: 30 days
 
   rules:
@@ -638,6 +648,8 @@ before_script:
     name: "${CI_PROJECT_NAME}_Windows_64_${CI_COMMIT_SHORT_SHA}"
     paths:
     - 'OpenRGB Windows 64-bit'
+    exclude:
+    - 'OpenRGB Windows 64-bit\*.qm'
     expire_in: 30 days
 
 #-----------------------------------------------------------------------#

Controllers/AOCKeyboardController/AOCKeyboardController.cpp

@@ -0,0 +1,211 @@
+/*-----------------------------------------*\
+|  AOCKeyboardController.cpp                |
+|                                           |
+|  Driver for AOC Keyboard lighting         |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/10/2023   |
+\*-----------------------------------------*/
+
+#include "AOCKeyboardController.h"
+
+#include <cstring>
+#include <chrono>
+#include <thread>
+
+using namespace std::chrono_literals;
+
+AOCKeyboardController::AOCKeyboardController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+AOCKeyboardController::~AOCKeyboardController()
+{
+    hid_close(dev);
+}
+
+std::string AOCKeyboardController::GetDeviceLocation()
+{
+    return("HID " + location);
+}
+
+std::string AOCKeyboardController::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 AOCKeyboardController::SetLightingConfig
+    (
+    unsigned char   mode,
+    unsigned char   random,
+    unsigned char   brightness,
+    unsigned char   speed,
+    unsigned char   direction,
+    RGBColor*       color_data
+    )
+{
+    SendStartPacket();
+    std::this_thread::sleep_for(5ms);
+
+    SendLightingConfigPacket(mode, random, brightness, speed, direction, color_data);
+    std::this_thread::sleep_for(5ms);
+
+    SendEndPacket();
+    std::this_thread::sleep_for(10ms);
+}
+
+void AOCKeyboardController::SetCustom
+    (
+    RGBColor*       color_data
+    )
+{
+    SendStartPacket();
+    std::this_thread::sleep_for(5ms);
+
+    SendCustomPacket(color_data);
+    std::this_thread::sleep_for(5ms);
+
+    SendEndPacket();
+    std::this_thread::sleep_for(5ms);
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void AOCKeyboardController::SendStartPacket()
+{
+    unsigned char buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up start packet                                   |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x09;
+    buf[0x01]   = 0x21;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, buf, sizeof(buf));
+}
+
+void AOCKeyboardController::SendEndPacket()
+{
+    unsigned char buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up end packet                                     |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x09;
+    buf[0x01]   = 0x22;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, buf, sizeof(buf));
+}
+
+void AOCKeyboardController::SendCustomPacket
+    (
+    RGBColor*       color_data
+    )
+{
+    unsigned char buf[361];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up custom lighting packet                         |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x20;
+
+    /*-----------------------------------------------------*\
+    | Copy in color data                                    |
+    \*-----------------------------------------------------*/
+    for(unsigned int color_idx = 0; color_idx < 120; color_idx++)
+    {
+        buf[color_idx + 1]      = RGBGetRValue(color_data[color_idx]);
+        buf[color_idx + 121]    = RGBGetGValue(color_data[color_idx]);
+        buf[color_idx + 241]    = RGBGetBValue(color_data[color_idx]);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, buf, sizeof(buf));
+}
+
+void AOCKeyboardController::SendLightingConfigPacket
+    (
+    unsigned char   mode,
+    unsigned char   random,
+    unsigned char   brightness,
+    unsigned char   speed,
+    unsigned char   direction,
+    RGBColor*       color_data
+    )
+{
+    unsigned char buf[117];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up lighting configuration packet                  |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x14;
+    buf[0x01]   = 0x01;
+
+    buf[0x06]   = mode;
+
+    buf[0x07 + (9 * mode) + 0] = RGBGetRValue(color_data[0]);
+    buf[0x07 + (9 * mode) + 1] = RGBGetGValue(color_data[0]);
+    buf[0x07 + (9 * mode) + 2] = RGBGetBValue(color_data[0]);
+    buf[0x07 + (9 * mode) + 3] = random;
+    buf[0x07 + (9 * mode) + 4] = direction;
+    buf[0x07 + (9 * mode) + 5] = speed;
+    buf[0x07 + (9 * mode) + 6] = brightness;
+
+    unsigned short checksum = 0x4A9E;
+
+    for(unsigned int buf_idx = 0; buf_idx < 115; buf_idx++)
+    {
+        checksum += buf[buf_idx];
+    }
+
+    buf[115]    = checksum & 0xFF;
+    buf[116]    = checksum >> 8;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, buf, 117);
+}

Controllers/AOCKeyboardController/AOCKeyboardController.h

@@ -0,0 +1,107 @@
+/*-----------------------------------------*\
+|  AOCKeyboardController.h                  |
+|                                           |
+|  Definitions and types for AOC keyboard   |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/10/2023   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>
+
+#pragma once
+
+/*-----------------------------------------*\
+| AOC Keyboard Modes                        |
+\*-----------------------------------------*/
+enum
+{
+    AOC_KEYBOARD_MODE_STATIC                    = 0x00,     /* Static mode                  */
+    AOC_KEYBOARD_MODE_BREATHING                 = 0x01,     /* Breathing mode               */
+    AOC_KEYBOARD_MODE_REACT                     = 0x02,     /* React mode                   */
+    AOC_KEYBOARD_MODE_RIPPLE                    = 0x04,     /* Ripple mode                  */
+    AOC_KEYBOARD_MODE_RADAR                     = 0x05,     /* Radar mode                   */
+    AOC_KEYBOARD_MODE_FIREWORKS                 = 0x06,     /* Fireworks mode               */
+    AOC_KEYBOARD_MODE_BLINK                     = 0x07,     /* Blink mode                   */
+    AOC_KEYBOARD_MODE_WAVE                      = 0x08,     /* Wave mode                    */
+    AOC_KEYBOARD_MODE_CUSTOM                    = 0x09,     /* Custom mode                  */
+    AOC_KEYBOARD_MODE_CONCENTRIC_CIRCLES        = 0x0A,     /* Concentric Circles mode      */
+    AOC_KEYBOARD_MODE_W_WAVE                    = 0x0B,     /* W Wave mode                  */
+};
+
+enum
+{
+    AOC_KEYBOARD_SPEED_SLOW                     = 0x03,     /* Slowest speed                */
+    AOC_KEYBOARD_SPEED_MEDIUM                   = 0x02,     /* Medium speed                 */
+    AOC_KEYBOARD_SPEED_FAST                     = 0x01,     /* Fastest speed                */
+};
+
+enum
+{
+    AOC_KEYBOARD_BRIGHTNESS_OFF                 = 0x00,     /* Lowest brightness (off)      */
+    AOC_KEYBOARD_BRIGHTNESS_LOW                 = 0x01,     /* Low brightness               */
+    AOC_KEYBOARD_BRIGHTNESS_MEDIUM              = 0x02,     /* Medium brightness            */
+    AOC_KEYBOARD_BRIGHTNESS_HIGH                = 0x03,     /* Highest brightness           */
+};
+
+enum
+{
+    AOC_KEYBOARD_SINGLE_COLOR                   = 0x00,     /* Single color mode            */
+    AOC_KEYBOARD_RANDOM                         = 0x01,     /* Random color mode            */
+};
+
+enum
+{
+    AOC_KEYBOARD_DIRECTION_CLOCKWISE            = 0x00,     /* Clockwise direction          */
+    AOC_KEYBOARD_DIRECTION_COUNTERCLOCKWISE     = 0x01,     /* Counter-clockwise direction  */
+};
+
+
+class AOCKeyboardController
+{
+public:
+    AOCKeyboardController(hid_device* dev_handle, const char* path);
+    ~AOCKeyboardController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void SetLightingConfig
+            (
+            unsigned char   mode,
+            unsigned char   random,
+            unsigned char   brightness,
+            unsigned char   speed,
+            unsigned char   direction,
+            RGBColor*       color_data
+            );
+
+    void SetCustom
+            (
+            RGBColor*       color_data
+            );
+
+private:
+    hid_device*             dev;
+    std::string             location;
+
+    void SendStartPacket();
+    void SendEndPacket();
+
+    void SendCustomPacket
+            (
+            RGBColor*       color_data
+            );
+
+    void SendLightingConfigPacket
+            (
+            unsigned char   mode,
+            unsigned char   random,
+            unsigned char   brightness,
+            unsigned char   speed,
+            unsigned char   direction,
+            RGBColor*       color_data
+            );
+};

Controllers/AOCKeyboardController/AOCKeyboardControllerDetect.cpp

@@ -0,0 +1,34 @@
+#include "Detector.h"
+#include "AOCKeyboardController.h"
+#include "RGBController.h"
+#include "RGBController_AOCKeyboard.h"
+
+/*-----------------------------------------------------*\
+| AOC Mousemat IDs                                      |
+\*-----------------------------------------------------*/
+#define AOC_VID                                     0x3938
+#define AOC_GK500_PID                               0x1178
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAOCKeyboardControllers                                                           *
+*                                                                                          *
+*       Tests the USB address to see if an AOC Keyboard controller exists there.           *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AOCKeyboardController*     controller     = new AOCKeyboardController(dev, info->path);
+        RGBController_AOCKeyboard* rgb_controller = new RGBController_AOCKeyboard(controller);
+        rgb_controller->name                      = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID,   0xFF19, 0xFF19);

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.cpp

@@ -0,0 +1,370 @@
+/*-----------------------------------------*\
+|  RGBController_AOCKeyboard.cpp            |
+|                                           |
+|  Generic RGB Interface for AOC keyboard   |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/10/2023   |
+\*-----------------------------------------*/
+
+#include "RGBController_AOCKeyboard.h"
+#include "KeyboardLayoutManager.h"
+
+/**--------------------------------------------------------------------*\
+    @name AOC Keyboard
+    @category Keyboard
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAOCKeyboardControllers
+    @comment
+\*---------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------*\
+|  AOC Keyboard KLM Layout                                              |
+\*---------------------------------------------------------------------*/
+layout_values aoc_keyboard_offset_values =
+{
+    {
+        /* ESC          F1    F2    F3    F4    F5    F6    F7    F8    F9   F10   F11   F12   PRSC  SCLK  PSBK                         */
+            90,         92,   77,   63,   79,   94,   81,   96,   82,   83,   98,   40,   55,   85,  100,  104,
+        /* BKTK    1     2     3     4     5     6     7     8     9     0     -     =   BSPC  INS   HOME  PGUP  NLCK   NP/   NP*  NP-  */
+            75,   76,   91,   62,   48,   64,   50,   65,   66,   67,   97,   68,   84,   70,   59,   74,   89,    58,   73,   88,  103,
+        /* TAB     Q     W     E     R     T     Y     U     I     O     P     [     ]     \   DEL   END   PGDN   NP7   NP8   NP9   NP+ */
+            60,   61,   47,   78,   33,   49,   35,   80,   51,   52,   53,   69,   99,   25,   44,   29,   14,    43,   28,   13,  102,
+        /* CPLK    A     S     D     F     G     H     J     K     L     ;     "   ENTR                           NP4   NP5   NP6       */
+            45,   46,   32,   93,   18,   34,   20,   95,   36,   37,   38,   54,   10,                            57,   72,   87,
+        /* LSFT    Z     X     C     V     B     N     M     ,     .     /   RSFT                   ARWU          NP1   NP2   NP3  NPEN */
+            30,   31,   17,    2,    3,   19,    5,    6,   21,   22,   23,   39,                     11,          42,   27,   12,  101,
+        /* LCTL  LWIN  LALT               SPC              RALT  RFNC  RMNU  RCTL              ARWL ARWD   ARWR   NP0         NP.       */
+            15,    0,    1,                4,                7,    8,   24,    9,               26,   41,   56,    71,         86
+    },
+    {
+        /* Add more regional layout fixes here */
+    }
+};
+
+
+RGBController_AOCKeyboard::RGBController_AOCKeyboard(AOCKeyboardController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "AOC Keyboard Device";
+    vendor      = "AOC";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "AOC Keyboard Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
+
+    mode Static;
+    Static.name                     = "Static";
+    Static.value                    = AOC_KEYBOARD_MODE_STATIC;
+    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+    Static.brightness_min           = AOC_KEYBOARD_BRIGHTNESS_OFF;
+    Static.brightness_max           = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    Static.brightness               = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    Static.colors_min               = 1;
+    Static.colors_max               = 1;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode SpectrumCycle;
+    SpectrumCycle.name              = "Spectrum Cycle";
+    SpectrumCycle.value             = AOC_KEYBOARD_MODE_STATIC;
+    SpectrumCycle.flags             = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    SpectrumCycle.color_mode        = MODE_COLORS_RANDOM;
+    SpectrumCycle.brightness_min    = AOC_KEYBOARD_BRIGHTNESS_OFF;
+    SpectrumCycle.brightness_max    = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    SpectrumCycle.brightness        = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    SpectrumCycle.speed_min         = AOC_KEYBOARD_SPEED_SLOW;
+    SpectrumCycle.speed_max         = AOC_KEYBOARD_SPEED_FAST;
+    SpectrumCycle.speed             = AOC_KEYBOARD_SPEED_MEDIUM;
+    modes.push_back(SpectrumCycle);
+
+    mode Breathing;
+    Breathing.name                  = "Breathing";
+    Breathing.value                 = AOC_KEYBOARD_MODE_BREATHING;
+    Breathing.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.brightness_min        = AOC_KEYBOARD_BRIGHTNESS_OFF;
+    Breathing.brightness_max        = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    Breathing.brightness            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    Breathing.speed_min             = AOC_KEYBOARD_SPEED_SLOW;
+    Breathing.speed_max             = AOC_KEYBOARD_SPEED_FAST;
+    Breathing.speed                 = AOC_KEYBOARD_SPEED_MEDIUM;
+    Breathing.colors_min            = 1;
+    Breathing.colors_max            = 1;
+    Breathing.colors.resize(1);
+    modes.push_back(Breathing);
+
+    mode React;
+    React.name                      = "React";
+    React.value                     = AOC_KEYBOARD_MODE_REACT;
+    React.flags                     = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    React.color_mode                = MODE_COLORS_MODE_SPECIFIC;
+    React.brightness_min            = AOC_KEYBOARD_BRIGHTNESS_OFF;
+    React.brightness_max            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    React.brightness                = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    React.speed_min                 = AOC_KEYBOARD_SPEED_SLOW;
+    React.speed_max                 = AOC_KEYBOARD_SPEED_FAST;
+    React.speed                     = AOC_KEYBOARD_SPEED_MEDIUM;
+    React.colors_min                = 1;
+    React.colors_max                = 1;
+    React.colors.resize(1);
+    modes.push_back(React);
+
+    mode Ripple;
+    Ripple.name                     = "Ripple";
+    Ripple.value                    = AOC_KEYBOARD_MODE_RIPPLE;
+    Ripple.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Ripple.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+    Ripple.brightness_min           = AOC_KEYBOARD_BRIGHTNESS_OFF;
+    Ripple.brightness_max           = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    Ripple.brightness               = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    Ripple.speed_min                = AOC_KEYBOARD_SPEED_SLOW;
+    Ripple.speed_max                = AOC_KEYBOARD_SPEED_FAST;
+    Ripple.speed                    = AOC_KEYBOARD_SPEED_MEDIUM;
+    Ripple.colors_min               = 1;
+    Ripple.colors_max               = 1;
+    Ripple.colors.resize(1);
+    modes.push_back(Ripple);
+
+    mode Radar;
+    Radar.name                      = "Radar";
+    Radar.value                     = AOC_KEYBOARD_MODE_RADAR;
+    Radar.flags                     = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    Radar.color_mode                = MODE_COLORS_MODE_SPECIFIC;
+    Radar.brightness_min            = AOC_KEYBOARD_BRIGHTNESS_OFF;
+    Radar.brightness_max            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    Radar.brightness                = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    Radar.speed_min                 = AOC_KEYBOARD_SPEED_SLOW;
+    Radar.speed_max                 = AOC_KEYBOARD_SPEED_FAST;
+    Radar.speed                     = AOC_KEYBOARD_SPEED_MEDIUM;
+    Radar.colors_min                = 1;
+    Radar.colors_max                = 1;
+    Radar.colors.resize(1);
+    modes.push_back(Radar);
+
+    mode Fireworks;
+    Fireworks.name                  = "Fireworks";
+    Fireworks.value                 = AOC_KEYBOARD_MODE_FIREWORKS;
+    Fireworks.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Fireworks.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Fireworks.brightness_min        = AOC_KEYBOARD_BRIGHTNESS_OFF;
+    Fireworks.brightness_max        = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    Fireworks.brightness            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    Fireworks.speed_min             = AOC_KEYBOARD_SPEED_SLOW;
+    Fireworks.speed_max             = AOC_KEYBOARD_SPEED_FAST;
+    Fireworks.speed                 = AOC_KEYBOARD_SPEED_MEDIUM;
+    Fireworks.colors_min            = 1;
+    Fireworks.colors_max            = 1;
+    Fireworks.colors.resize(1);
+    modes.push_back(Fireworks);
+
+    mode Blink;
+    Blink.name                      = "Flashing";
+    Blink.value                     = AOC_KEYBOARD_MODE_BLINK;
+    Blink.flags                     = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Blink.color_mode                = MODE_COLORS_MODE_SPECIFIC;
+    Blink.brightness_min            = AOC_KEYBOARD_BRIGHTNESS_OFF;
+    Blink.brightness_max            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    Blink.brightness                = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    Blink.speed_min                 = AOC_KEYBOARD_SPEED_SLOW;
+    Blink.speed_max                 = AOC_KEYBOARD_SPEED_FAST;
+    Blink.speed                     = AOC_KEYBOARD_SPEED_MEDIUM;
+    Blink.colors_min                = 1;
+    Blink.colors_max                = 1;
+    Blink.colors.resize(1);
+    modes.push_back(Blink);
+
+    mode Wave;
+    Wave.name                       = "Wave";
+    Wave.value                      = AOC_KEYBOARD_MODE_WAVE;
+    Wave.flags                      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    Wave.color_mode                 = MODE_COLORS_MODE_SPECIFIC;
+    Wave.brightness_min             = AOC_KEYBOARD_BRIGHTNESS_OFF;
+    Wave.brightness_max             = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    Wave.brightness                 = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    Wave.speed_min                  = AOC_KEYBOARD_SPEED_SLOW;
+    Wave.speed_max                  = AOC_KEYBOARD_SPEED_FAST;
+    Wave.speed                      = AOC_KEYBOARD_SPEED_MEDIUM;
+    Wave.colors_min                 = 1;
+    Wave.colors_max                 = 1;
+    Wave.colors.resize(1);
+    modes.push_back(Wave);
+
+    mode RainbowWave;
+    RainbowWave.name                = "Rainbow Wave";
+    RainbowWave.value               = AOC_KEYBOARD_MODE_WAVE;
+    RainbowWave.flags               = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    RainbowWave.color_mode          = MODE_COLORS_RANDOM;
+    RainbowWave.brightness_min      = AOC_KEYBOARD_BRIGHTNESS_OFF;
+    RainbowWave.brightness_max      = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    RainbowWave.brightness          = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    RainbowWave.speed_min           = AOC_KEYBOARD_SPEED_SLOW;
+    RainbowWave.speed_max           = AOC_KEYBOARD_SPEED_FAST;
+    RainbowWave.speed               = AOC_KEYBOARD_SPEED_MEDIUM;
+    modes.push_back(RainbowWave);
+
+    mode ConcentricCircles;
+    ConcentricCircles.name          = "Concentric Circles";
+    ConcentricCircles.value         = AOC_KEYBOARD_MODE_CONCENTRIC_CIRCLES;
+    ConcentricCircles.flags         = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    ConcentricCircles.color_mode    = MODE_COLORS_MODE_SPECIFIC;
+    ConcentricCircles.brightness_min= AOC_KEYBOARD_BRIGHTNESS_OFF;
+    ConcentricCircles.brightness_max= AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    ConcentricCircles.brightness    = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    ConcentricCircles.speed_min     = AOC_KEYBOARD_SPEED_SLOW;
+    ConcentricCircles.speed_max     = AOC_KEYBOARD_SPEED_FAST;
+    ConcentricCircles.speed         = AOC_KEYBOARD_SPEED_MEDIUM;
+    ConcentricCircles.colors_min    = 1;
+    ConcentricCircles.colors_max    = 1;
+    ConcentricCircles.colors.resize(1);
+    modes.push_back(ConcentricCircles);
+
+    mode WWave;
+    WWave.name                      = "W Wave";
+    WWave.value                     = AOC_KEYBOARD_MODE_W_WAVE;
+    WWave.flags                     = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    WWave.color_mode                = MODE_COLORS_MODE_SPECIFIC;
+    WWave.brightness_min            = AOC_KEYBOARD_BRIGHTNESS_OFF;
+    WWave.brightness_max            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    WWave.brightness                = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    WWave.speed_min                 = AOC_KEYBOARD_SPEED_SLOW;
+    WWave.speed_max                 = AOC_KEYBOARD_SPEED_FAST;
+    WWave.speed                     = AOC_KEYBOARD_SPEED_MEDIUM;
+    WWave.colors_min                = 1;
+    WWave.colors_max                = 1;
+    WWave.colors.resize(1);
+    modes.push_back(WWave);
+
+    mode Direct;
+    Direct.name                     = "Direct";
+    Direct.value                    = AOC_KEYBOARD_MODE_CUSTOM;
+    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.color_mode               = MODE_COLORS_PER_LED;
+    Direct.brightness_min           = AOC_KEYBOARD_BRIGHTNESS_OFF;
+    Direct.brightness_max           = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    Direct.brightness               = AOC_KEYBOARD_BRIGHTNESS_HIGH;
+    modes.push_back(Direct);
+
+    SetupZones();
+};
+
+RGBController_AOCKeyboard::~RGBController_AOCKeyboard()
+{
+    delete controller;
+}
+
+void RGBController_AOCKeyboard::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Create the keyboard zone usiung Keyboard Layout Manager   |
+    \*---------------------------------------------------------*/
+    zone new_zone;
+    new_zone.name               = ZONE_EN_KEYBOARD;
+    new_zone.type               = ZONE_TYPE_MATRIX;
+
+    KeyboardLayoutManager new_kb(KEYBOARD_LAYOUT_ANSI_QWERTY, KEYBOARD_SIZE_FULL, aoc_keyboard_offset_values);
+
+    matrix_map_type * new_map   = new matrix_map_type;
+    new_zone.matrix_map         = new_map;
+    new_zone.matrix_map->height = new_kb.GetRowCount();
+    new_zone.matrix_map->width  = new_kb.GetColumnCount();
+
+    new_zone.matrix_map->map    = new unsigned int[new_map->height * new_map->width];
+    new_zone.leds_count         = new_kb.GetKeyCount();
+    new_zone.leds_min           = new_zone.leds_count;
+    new_zone.leds_max           = new_zone.leds_count;
+
+    /*---------------------------------------------------------*\
+    | Matrix map still uses declared zone rows and columns      |
+    |   as the packet structure depends on the matrix map       |
+    \*---------------------------------------------------------*/
+    new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT, new_map->height, new_map->width);
+
+    /*---------------------------------------------------------*\
+    | Create LEDs for the Matrix zone                           |
+    |   Place keys in the layout to populate the matrix         |
+    \*---------------------------------------------------------*/
+    for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
+    {
+        led new_led;
+
+        new_led.name                = new_kb.GetKeyNameAt(led_idx);
+        new_led.value               = new_kb.GetKeyValueAt(led_idx);
+        leds.push_back(new_led);
+    }
+
+    zones.push_back(new_zone);
+
+
+
+    SetupColors();
+}
+
+void RGBController_AOCKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AOCKeyboard::DeviceUpdateLEDs()
+{
+    if(modes[active_mode].value == AOC_KEYBOARD_MODE_CUSTOM)
+    {
+        RGBColor color_buf[120];
+
+        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
+        {
+            color_buf[leds[led_idx].value] = colors[led_idx];
+        }
+
+        controller->SetCustom(&color_buf[0]);
+    }
+    else
+    {
+        DeviceUpdateMode();
+    }
+}
+
+void RGBController_AOCKeyboard::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AOCKeyboard::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AOCKeyboard::DeviceUpdateMode()
+{
+    unsigned char   aoc_direction   = AOC_KEYBOARD_DIRECTION_CLOCKWISE;
+    unsigned char   aoc_random      = AOC_KEYBOARD_SINGLE_COLOR;
+    RGBColor*       aoc_colors      = &colors[0];
+
+    if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
+    {
+        aoc_direction = AOC_KEYBOARD_DIRECTION_COUNTERCLOCKWISE;
+    }
+
+    if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
+    {
+        aoc_random = AOC_KEYBOARD_RANDOM;
+    }
+
+    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        aoc_colors = &modes[active_mode].colors[0];
+    }
+
+    controller->SetLightingConfig(modes[active_mode].value,
+                                  aoc_random,
+                                  modes[active_mode].brightness,
+                                  modes[active_mode].speed,
+                                  aoc_direction,
+                                  aoc_colors);
+}

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.h

@@ -0,0 +1,32 @@
+/*-----------------------------------------*\
+|  RGBController_AOCKeyboard.h              |
+|                                           |
+|  Generic RGB Interface for AOC keyboard   |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/10/2023   |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AOCKeyboardController.h"
+
+class RGBController_AOCKeyboard : public RGBController
+{
+public:
+    RGBController_AOCKeyboard(AOCKeyboardController* controller_ptr);
+    ~RGBController_AOCKeyboard();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AOCKeyboardController*  controller;
+};

Controllers/AOCMouseController/AOCMouseController.cpp

@@ -0,0 +1,130 @@
+/*-----------------------------------------*\
+|  AOCMouseController.cpp                   |
+|                                           |
+|  Driver for AOC Mouse lighting controller |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/20/2023   |
+\*-----------------------------------------*/
+
+#include "AOCMouseController.h"
+
+#include <cstring>
+
+AOCMouseController::AOCMouseController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+AOCMouseController::~AOCMouseController()
+{
+    hid_close(dev);
+}
+
+std::string AOCMouseController::GetDeviceLocation()
+{
+    return("HID " + location);
+}
+
+std::string AOCMouseController::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);
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void AOCMouseController::SendDirect
+    (
+    RGBColor*       color_data
+    )
+{
+    SendPacket(AOC_MOUSE_MODE_STATIC_SINGLE_COLOR,
+               AOC_MOUSE_BRIGHTNESS_HIGH,
+               AOC_MOUSE_SPEED_MEDIUM,
+               AOC_MOUSE_DIRECTION_CLOCKWISE,
+               color_data);
+}
+
+void AOCMouseController::SendPacket
+    (
+    unsigned char   mode,
+    unsigned char   brightness,
+    unsigned char   speed,
+    unsigned char   direction,
+    RGBColor*       color_data
+    )
+{
+    unsigned char buf[60];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up packet                                         |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x20;
+    buf[0x01]   = 0x03;
+    buf[0x02]   = 0x01;
+    buf[0x03]   = mode;
+    buf[0x04]   = speed;
+    buf[0x05]   = brightness;
+    buf[0x06]   = direction;
+    buf[0x07]   = 0x01;
+    buf[0x08]   = 0x02;
+    buf[0x09]   = 0xFF;
+    buf[0x0D]   = 0x01;
+    buf[0x0E]   = 0x03;
+    buf[0x0F]   = 0xFF;
+    buf[0x10]   = 0x7F;
+    buf[0x13]   = 0x01;
+    buf[0x14]   = 0x04;
+    buf[0x17]   = 0xFF;
+    buf[0x19]   = 0x01;
+    buf[0x1A]   = 0x05;
+    buf[0x1C]   = 0xFF;
+    buf[0x1F]   = 0x01;
+    buf[0x20]   = 0x06;
+    buf[0x21]   = 0xFF;
+    buf[0x23]   = 0xFF;
+    buf[0x25]   = 0x01;
+    buf[0x26]   = 0x07;
+    buf[0x27]   = 0xFF;
+    buf[0x28]   = 0xFF;
+    buf[0x2C]   = 0x0A;
+    buf[0x2D]   = 0x0A;
+    buf[0x30]   = 0x14;
+    buf[0x31]   = 0x08;
+    buf[0x3A]   = 0x32;
+    buf[0x3B]   = 0x32;
+
+    /*-----------------------------------------------------*\
+    | Copy in color                                         |
+    \*-----------------------------------------------------*/
+    buf[0x33]   = RGBGetRValue(color_data[0]);
+    buf[0x34]   = RGBGetGValue(color_data[0]);
+    buf[0x35]   = RGBGetBValue(color_data[0]);
+
+    buf[0x36]   = RGBGetRValue(color_data[1]);
+    buf[0x37]   = RGBGetGValue(color_data[1]);
+    buf[0x38]   = RGBGetBValue(color_data[1]);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, buf, 60);
+}

Controllers/AOCMouseController/AOCMouseController.h

@@ -0,0 +1,80 @@
+/*-----------------------------------------*\
+|  AOCMouseController.h                     |
+|                                           |
+|  Definitions and types for AOC mouse      |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/20/2023   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>
+
+#pragma once
+
+/*-----------------------------------------*\
+| AOC Mousemat Modes                        |
+|   Note: The 0x80 bit is the random flag   |
+\*-----------------------------------------*/
+enum
+{
+    AOC_MOUSE_MODE_STATIC_SINGLE_COLOR          = 0x00,     /* Static single color mode     */
+    AOC_MOUSE_MODE_STATIC_RANDOM                = 0x80,     /* Static random color mode     */
+    AOC_MOUSE_MODE_BREATHING_SINGLE_COLOR       = 0x01,     /* Breathing single color mode  */
+    AOC_MOUSE_MODE_BREATHING_RANDOM             = 0x81,     /* Breathing random color mode  */
+    AOC_MOUSE_MODE_BLINK_SINGLE_COLOR           = 0x02,     /* Blink single color mode      */
+    AOC_MOUSE_MODE_BLINK_RANDOM                 = 0x82,     /* Blink random color mode      */
+    AOC_MOUSE_MODE_WAVE_SINGLE_COLOR            = 0x03,     /* Wave single color mode       */
+    AOC_MOUSE_MODE_WAVE_RANDOM                  = 0x83,     /* Wave random color mode       */
+    AOC_MOUSE_MODE_DPI                          = 0x04,     /* DPI mode                     */
+};
+
+enum
+{
+    AOC_MOUSE_SPEED_SLOW                        = 0x03,     /* Slowest speed                */
+    AOC_MOUSE_SPEED_MEDIUM                      = 0x02,     /* Medium speed                 */
+    AOC_MOUSE_SPEED_FAST                        = 0x01,     /* Fastest speed                */
+};
+
+enum
+{
+    AOC_MOUSE_BRIGHTNESS_OFF                    = 0x00,     /* Lowest brightness (off)      */
+    AOC_MOUSE_BRIGHTNESS_LOW                    = 0x01,     /* Low brightness               */
+    AOC_MOUSE_BRIGHTNESS_MEDIUM                 = 0x02,     /* Medium brightness            */
+    AOC_MOUSE_BRIGHTNESS_HIGH                   = 0x03,     /* Highest brightness           */
+};
+
+enum
+{
+    AOC_MOUSE_DIRECTION_CLOCKWISE               = 0x00,     /* Clockwise direction          */
+    AOC_MOUSE_DIRECTION_COUNTERCLOCKWISE        = 0x01,     /* Counter-clockwise direction  */
+};
+
+class AOCMouseController
+{
+public:
+    AOCMouseController(hid_device* dev_handle, const char* path);
+    ~AOCMouseController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void SendDirect
+            (
+            RGBColor*       color_data
+            );
+
+    void SendPacket
+            (
+            unsigned char   mode,
+            unsigned char   brightness,
+            unsigned char   speed,
+            unsigned char   direction,
+            RGBColor*       color_data
+            );
+
+private:
+    hid_device*             dev;
+    std::string             location;
+};

Controllers/AOCMouseController/AOCMouseControllerDetect.cpp

@@ -0,0 +1,34 @@
+#include "Detector.h"
+#include "AOCMouseController.h"
+#include "RGBController.h"
+#include "RGBController_AOCMouse.h"
+
+/*-----------------------------------------------------*\
+| AOC Mousemat IDs                                      |
+\*-----------------------------------------------------*/
+#define AOC_VID                                     0x3938
+#define AOC_GM500_PID                               0x1179
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAOCMouseControllers                                                              *
+*                                                                                          *
+*       Tests the USB address to see if an AOC Mouse controller exists there.              *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAOCMouseControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AOCMouseController*     controller     = new AOCMouseController(dev, info->path);
+        RGBController_AOCMouse* rgb_controller = new RGBController_AOCMouse(controller);
+        rgb_controller->name                   = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR_IPU("AOC GM500",  DetectAOCMouseControllers,  AOC_VID,    AOC_GM500_PID,  1,  0xFF19, 0xFF19);

Controllers/AOCMouseController/RGBController_AOCMouse.cpp

@@ -0,0 +1,215 @@
+/*-----------------------------------------*\
+|  RGBController_AOCMouse.cpp               |
+|                                           |
+|  Generic RGB Interface for AOC mouse      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/20/2023   |
+\*-----------------------------------------*/
+
+#include "RGBController_AOCMouse.h"
+
+/**------------------------------------------------------------------*\
+    @name AOC Mouse
+    @category Mouse
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAOCMouseControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AOCMouse::RGBController_AOCMouse(AOCMouseController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "AOC Mouse Device";
+    vendor      = "AOC";
+    type        = DEVICE_TYPE_MOUSE;
+    description = "AOC Mouse Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name                     = "Direct";
+    Direct.value                    = AOC_MOUSE_MODE_STATIC_SINGLE_COLOR;
+    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.color_mode               = MODE_COLORS_PER_LED;
+    Direct.brightness_min           = AOC_MOUSE_BRIGHTNESS_OFF;
+    Direct.brightness_max           = AOC_MOUSE_BRIGHTNESS_HIGH;
+    Direct.brightness               = AOC_MOUSE_BRIGHTNESS_HIGH;
+    modes.push_back(Direct);
+
+    mode SpectrumCycle;
+    SpectrumCycle.name              = "Spectrum Cycle";
+    SpectrumCycle.value             = AOC_MOUSE_MODE_STATIC_RANDOM;
+    SpectrumCycle.flags             = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    SpectrumCycle.color_mode        = MODE_COLORS_RANDOM;
+    SpectrumCycle.brightness_min    = AOC_MOUSE_BRIGHTNESS_OFF;
+    SpectrumCycle.brightness_max    = AOC_MOUSE_BRIGHTNESS_HIGH;
+    SpectrumCycle.brightness        = AOC_MOUSE_BRIGHTNESS_HIGH;
+    SpectrumCycle.speed_min         = AOC_MOUSE_SPEED_SLOW;
+    SpectrumCycle.speed_max         = AOC_MOUSE_SPEED_FAST;
+    SpectrumCycle.speed             = AOC_MOUSE_SPEED_MEDIUM;
+    modes.push_back(SpectrumCycle);
+
+    mode Breathing;
+    Breathing.name                  = "Breathing";
+    Breathing.value                 = AOC_MOUSE_MODE_BREATHING_SINGLE_COLOR;
+    Breathing.flags                 = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode            = MODE_COLORS_PER_LED;
+    Breathing.brightness_min        = AOC_MOUSE_BRIGHTNESS_OFF;
+    Breathing.brightness_max        = AOC_MOUSE_BRIGHTNESS_HIGH;
+    Breathing.brightness            = AOC_MOUSE_BRIGHTNESS_HIGH;
+    Breathing.speed_min             = AOC_MOUSE_SPEED_SLOW;
+    Breathing.speed_max             = AOC_MOUSE_SPEED_FAST;
+    Breathing.speed                 = AOC_MOUSE_SPEED_MEDIUM;
+    modes.push_back(Breathing);
+
+    mode Blink;
+    Blink.name                      = "Flashing";
+    Blink.value                     = AOC_MOUSE_MODE_BLINK_SINGLE_COLOR;
+    Blink.flags                     = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Blink.color_mode                = MODE_COLORS_PER_LED;
+    Blink.brightness_min            = AOC_MOUSE_BRIGHTNESS_OFF;
+    Blink.brightness_max            = AOC_MOUSE_BRIGHTNESS_HIGH;
+    Blink.brightness                = AOC_MOUSE_BRIGHTNESS_HIGH;
+    Blink.speed_min                 = AOC_MOUSE_SPEED_SLOW;
+    Blink.speed_max                 = AOC_MOUSE_SPEED_FAST;
+    Blink.speed                     = AOC_MOUSE_SPEED_MEDIUM;
+    modes.push_back(Blink);
+
+    mode Wave;
+    Wave.name                       = "Wave";
+    Wave.value                      = AOC_MOUSE_MODE_WAVE_SINGLE_COLOR;
+    Wave.flags                      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    Wave.color_mode                 = MODE_COLORS_PER_LED;
+    Wave.brightness_min             = AOC_MOUSE_BRIGHTNESS_OFF;
+    Wave.brightness_max             = AOC_MOUSE_BRIGHTNESS_HIGH;
+    Wave.brightness                 = AOC_MOUSE_BRIGHTNESS_HIGH;
+    Wave.speed_min                  = AOC_MOUSE_SPEED_SLOW;
+    Wave.speed_max                  = AOC_MOUSE_SPEED_FAST;
+    Wave.speed                      = AOC_MOUSE_SPEED_MEDIUM;
+    modes.push_back(Wave);
+
+    mode RainbowWave;
+    RainbowWave.name                = "Rainbow Wave";
+    RainbowWave.value               = AOC_MOUSE_MODE_WAVE_RANDOM;
+    RainbowWave.flags               = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    RainbowWave.color_mode          = MODE_COLORS_RANDOM;
+    RainbowWave.brightness_min      = AOC_MOUSE_BRIGHTNESS_OFF;
+    RainbowWave.brightness_max      = AOC_MOUSE_BRIGHTNESS_HIGH;
+    RainbowWave.brightness          = AOC_MOUSE_BRIGHTNESS_HIGH;
+    RainbowWave.speed_min           = AOC_MOUSE_SPEED_SLOW;
+    RainbowWave.speed_max           = AOC_MOUSE_SPEED_FAST;
+    RainbowWave.speed               = AOC_MOUSE_SPEED_MEDIUM;
+    modes.push_back(RainbowWave);
+
+    mode DPI;
+    DPI.name                        = "DPI";
+    DPI.value                       = AOC_MOUSE_MODE_DPI;
+    DPI.flags                       = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    DPI.color_mode                  = MODE_COLORS_RANDOM;
+    DPI.brightness_min              = AOC_MOUSE_BRIGHTNESS_OFF;
+    DPI.brightness_max              = AOC_MOUSE_BRIGHTNESS_HIGH;
+    DPI.brightness                  = AOC_MOUSE_BRIGHTNESS_HIGH;
+    modes.push_back(DPI);
+
+    SetupZones();
+};
+
+RGBController_AOCMouse::~RGBController_AOCMouse()
+{
+    delete controller;
+}
+
+void RGBController_AOCMouse::SetupZones()
+{
+    zone logo_zone;
+    logo_zone.name                  = "Logo";
+    logo_zone.type                  = ZONE_TYPE_SINGLE;
+    logo_zone.leds_min              = 1;
+    logo_zone.leds_max              = 1;
+    logo_zone.leds_count            = 1;
+    logo_zone.matrix_map            = NULL;
+    zones.push_back(logo_zone);
+
+    led logo_led;
+    logo_led.name                   = "Logo";
+    leds.push_back(logo_led);
+
+    zone scroll_wheel_zone;
+    scroll_wheel_zone.name          = "Scroll Wheel";
+    scroll_wheel_zone.type          = ZONE_TYPE_SINGLE;
+    scroll_wheel_zone.leds_min      = 1;
+    scroll_wheel_zone.leds_max      = 1;
+    scroll_wheel_zone.leds_count    = 1;
+    scroll_wheel_zone.matrix_map    = NULL;
+    zones.push_back(scroll_wheel_zone);
+
+    led scroll_wheel_led;
+    scroll_wheel_led.name           = "Scroll Wheel";
+    leds.push_back(scroll_wheel_led);
+
+    SetupColors();
+}
+
+void RGBController_AOCMouse::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AOCMouse::DeviceUpdateLEDs()
+{
+    DeviceUpdateMode();
+}
+
+void RGBController_AOCMouse::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AOCMouse::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AOCMouse::DeviceUpdateMode()
+{
+    if(modes[active_mode].value == AOC_MOUSE_MODE_STATIC_SINGLE_COLOR)
+    {
+        controller->SendDirect(&colors[0]);
+    }
+    else
+    {
+        unsigned char   aoc_direction   = AOC_MOUSE_DIRECTION_CLOCKWISE;
+        unsigned int    aoc_mode        = modes[active_mode].value;
+
+        if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
+        {
+            aoc_direction = AOC_MOUSE_DIRECTION_COUNTERCLOCKWISE;
+        }
+
+        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
+        {
+            switch(modes[active_mode].value)
+            {
+                case AOC_MOUSE_MODE_BREATHING_SINGLE_COLOR:
+                    aoc_mode = AOC_MOUSE_MODE_BREATHING_RANDOM;
+                    break;
+
+                case AOC_MOUSE_MODE_BLINK_SINGLE_COLOR:
+                    aoc_mode = AOC_MOUSE_MODE_BLINK_RANDOM;
+                    break;
+            }
+        }
+
+        controller->SendPacket(aoc_mode,
+                               modes[active_mode].brightness,
+                               modes[active_mode].speed,
+                               aoc_direction,
+                               &colors[0]);
+    }
+}

Controllers/AOCMouseController/RGBController_AOCMouse.h

@@ -0,0 +1,32 @@
+/*-----------------------------------------*\
+|  RGBController_AOCMouse.h                 |
+|                                           |
+|  Generic RGB Interface for AOC mouse      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/20/2023   |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AOCMouseController.h"
+
+class RGBController_AOCMouse : public RGBController
+{
+public:
+    RGBController_AOCMouse(AOCMouseController* controller_ptr);
+    ~RGBController_AOCMouse();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AOCMouseController*  controller;
+};

Controllers/AOCMousematController/AOCMousematController.cpp

@@ -0,0 +1,112 @@
+/*-----------------------------------------*\
+|  AOCMousematController.cpp                |
+|                                           |
+|  Driver for AOC Mousemat lighting         |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/15/2023   |
+\*-----------------------------------------*/
+
+#include "AOCMousematController.h"
+
+#include <cstring>
+
+AOCMousematController::AOCMousematController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+AOCMousematController::~AOCMousematController()
+{
+    hid_close(dev);
+}
+
+std::string AOCMousematController::GetDeviceLocation()
+{
+    return("HID " + location);
+}
+
+std::string AOCMousematController::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);
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void AOCMousematController::SendDirect
+    (
+    RGBColor*       color_data
+    )
+{
+    SendPacket(AOC_MOUSEMAT_MODE_STATIC_SINGLE_COLOR,
+               AOC_MOUSEMAT_BRIGHTNESS_HIGH,
+               AOC_MOUSEMAT_SPEED_MEDIUM,
+               AOC_MOUSEMAT_DIRECTION_CLOCKWISE,
+               color_data);
+}
+
+void AOCMousematController::SendPacket
+    (
+    unsigned char   mode,
+    unsigned char   brightness,
+    unsigned char   speed,
+    unsigned char   direction,
+    RGBColor*       color_data
+    )
+{
+    unsigned char buf[32];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up packet                                         |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x20;
+    buf[0x01]   = brightness;
+    buf[0x02]   = speed;
+    buf[0x03]   = direction;
+    buf[0x04]   = 0x01;
+    buf[0x05]   = mode;
+    buf[0x09]   = 0xFF;
+    buf[0x0C]   = 0xFF;
+    buf[0x0D]   = 0x3F;
+    buf[0x0F]   = 0xFF;
+    buf[0x10]   = 0xFF;
+    buf[0x13]   = 0xFF;
+    buf[0x17]   = 0xFF;
+    buf[0x19]   = 0xFF;
+    buf[0x1A]   = 0xFF;
+    buf[0x1B]   = 0xFF;
+    buf[0x1D]   = 0xFF;
+    buf[0x1E]   = 0x32;
+    buf[0x1F]   = 0x32;
+
+    /*-----------------------------------------------------*\
+    | Copy in color                                         |
+    \*-----------------------------------------------------*/
+    buf[0x06]   = RGBGetRValue(color_data[0]);
+    buf[0x07]   = RGBGetGValue(color_data[0]);
+    buf[0x08]   = RGBGetBValue(color_data[0]);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, buf, 32);
+}

Controllers/AOCMousematController/AOCMousematController.h

@@ -0,0 +1,79 @@
+/*-----------------------------------------*\
+|  AOCMousematController.h                  |
+|                                           |
+|  Definitions and types for AOC mousemat   |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/15/2023   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>
+
+#pragma once
+
+/*-----------------------------------------*\
+| AOC Mousemat Modes                        |
+|   Note: The 0x80 bit is the random flag   |
+\*-----------------------------------------*/
+enum
+{
+    AOC_MOUSEMAT_MODE_STATIC_SINGLE_COLOR       = 0x00,     /* Static single color mode     */
+    AOC_MOUSEMAT_MODE_STATIC_RANDOM             = 0x80,     /* Static random color mode     */
+    AOC_MOUSEMAT_MODE_BREATHING_SINGLE_COLOR    = 0x01,     /* Breathing single color mode  */
+    AOC_MOUSEMAT_MODE_BREATHING_RANDOM          = 0x81,     /* Breathing random color mode  */
+    AOC_MOUSEMAT_MODE_BLINK_SINGLE_COLOR        = 0x02,     /* Blink single color mode      */
+    AOC_MOUSEMAT_MODE_BLINK_RANDOM              = 0x82,     /* Blink random color mode      */
+    AOC_MOUSEMAT_MODE_WAVE_SINGLE_COLOR         = 0x03,     /* Wave single color mode       */
+    AOC_MOUSEMAT_MODE_WAVE_RANDOM               = 0x83,     /* Wave random color mode       */
+};
+
+enum
+{
+    AOC_MOUSEMAT_SPEED_SLOW                     = 0x03,     /* Slowest speed                */
+    AOC_MOUSEMAT_SPEED_MEDIUM                   = 0x02,     /* Medium speed                 */
+    AOC_MOUSEMAT_SPEED_FAST                     = 0x01,     /* Fastest speed                */
+};
+
+enum
+{
+    AOC_MOUSEMAT_BRIGHTNESS_OFF                 = 0x00,     /* Lowest brightness (off)      */
+    AOC_MOUSEMAT_BRIGHTNESS_LOW                 = 0x01,     /* Low brightness               */
+    AOC_MOUSEMAT_BRIGHTNESS_MEDIUM              = 0x02,     /* Medium brightness            */
+    AOC_MOUSEMAT_BRIGHTNESS_HIGH                = 0x03,     /* Highest brightness           */
+};
+
+enum
+{
+    AOC_MOUSEMAT_DIRECTION_CLOCKWISE            = 0x00,     /* Clockwise direction          */
+    AOC_MOUSEMAT_DIRECTION_COUNTERCLOCKWISE     = 0x01,     /* Counter-clockwise direction  */
+};
+
+class AOCMousematController
+{
+public:
+    AOCMousematController(hid_device* dev_handle, const char* path);
+    ~AOCMousematController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void SendDirect
+            (
+            RGBColor*       color_data
+            );
+
+    void SendPacket
+            (
+            unsigned char   mode,
+            unsigned char   brightness,
+            unsigned char   speed,
+            unsigned char   direction,
+            RGBColor*       color_data
+            );
+
+private:
+    hid_device*             dev;
+    std::string             location;
+};

Controllers/AOCMousematController/AOCMousematControllerDetect.cpp

@@ -0,0 +1,34 @@
+#include "Detector.h"
+#include "AOCMousematController.h"
+#include "RGBController.h"
+#include "RGBController_AOCMousemat.h"
+
+/*-----------------------------------------------------*\
+| AOC Mousemat IDs                                      |
+\*-----------------------------------------------------*/
+#define AOC_VID                                     0x3938
+#define AOC_AMM700_PID                              0x1162
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAOCMousematControllers                                                           *
+*                                                                                          *
+*       Tests the USB address to see if an AOC Mousemat controller exists there.           *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAOCMousematControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AOCMousematController*     controller     = new AOCMousematController(dev, info->path);
+        RGBController_AOCMousemat* rgb_controller = new RGBController_AOCMousemat(controller);
+        rgb_controller->name                      = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR_IPU("AOC AGON AMM700",    DetectAOCMousematControllers,   AOC_VID,    AOC_AMM700_PID, 1,  0xFF19,  0xFF19);

Controllers/AOCMousematController/RGBController_AOCMousemat.cpp

@@ -0,0 +1,192 @@
+/*-----------------------------------------*\
+|  RGBController_AOCMousemat.cpp            |
+|                                           |
+|  Generic RGB Interface for AOC mousemat   |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/15/2023   |
+\*-----------------------------------------*/
+
+#include "RGBController_AOCMousemat.h"
+
+/**------------------------------------------------------------------*\
+    @name AOC Mousemat
+    @category Mousemat
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAOCMousematControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AOCMousemat::RGBController_AOCMousemat(AOCMousematController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "AOC Mousemat Device";
+    vendor      = "AOC";
+    type        = DEVICE_TYPE_MOUSEMAT;
+    description = "AOC Mousemat Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name                     = "Direct";
+    Direct.value                    = AOC_MOUSEMAT_MODE_STATIC_SINGLE_COLOR;
+    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.color_mode               = MODE_COLORS_PER_LED;
+    Direct.brightness_min           = AOC_MOUSEMAT_BRIGHTNESS_OFF;
+    Direct.brightness_max           = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
+    Direct.brightness               = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
+    modes.push_back(Direct);
+
+    mode SpectrumCycle;
+    SpectrumCycle.name              = "Spectrum Cycle";
+    SpectrumCycle.value             = AOC_MOUSEMAT_MODE_STATIC_RANDOM;
+    SpectrumCycle.flags             = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    SpectrumCycle.color_mode        = MODE_COLORS_RANDOM;
+    SpectrumCycle.brightness_min    = AOC_MOUSEMAT_BRIGHTNESS_OFF;
+    SpectrumCycle.brightness_max    = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
+    SpectrumCycle.brightness        = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
+    SpectrumCycle.speed_min         = AOC_MOUSEMAT_SPEED_SLOW;
+    SpectrumCycle.speed_max         = AOC_MOUSEMAT_SPEED_FAST;
+    SpectrumCycle.speed             = AOC_MOUSEMAT_SPEED_MEDIUM;
+    modes.push_back(SpectrumCycle);
+
+    mode Breathing;
+    Breathing.name                  = "Breathing";
+    Breathing.value                 = AOC_MOUSEMAT_MODE_BREATHING_SINGLE_COLOR;
+    Breathing.flags                 = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode            = MODE_COLORS_PER_LED;
+    Breathing.brightness_min        = AOC_MOUSEMAT_BRIGHTNESS_OFF;
+    Breathing.brightness_max        = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
+    Breathing.brightness            = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
+    Breathing.speed_min             = AOC_MOUSEMAT_SPEED_SLOW;
+    Breathing.speed_max             = AOC_MOUSEMAT_SPEED_FAST;
+    Breathing.speed                 = AOC_MOUSEMAT_SPEED_MEDIUM;
+    modes.push_back(Breathing);
+
+    mode Blink;
+    Blink.name                      = "Flashing";
+    Blink.value                     = AOC_MOUSEMAT_MODE_BLINK_SINGLE_COLOR;
+    Blink.flags                     = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Blink.color_mode                = MODE_COLORS_PER_LED;
+    Blink.brightness_min            = AOC_MOUSEMAT_BRIGHTNESS_OFF;
+    Blink.brightness_max            = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
+    Blink.brightness                = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
+    Blink.speed_min                 = AOC_MOUSEMAT_SPEED_SLOW;
+    Blink.speed_max                 = AOC_MOUSEMAT_SPEED_FAST;
+    Blink.speed                     = AOC_MOUSEMAT_SPEED_MEDIUM;
+    modes.push_back(Blink);
+
+    mode Wave;
+    Wave.name                       = "Wave";
+    Wave.value                      = AOC_MOUSEMAT_MODE_WAVE_SINGLE_COLOR;
+    Wave.flags                      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    Wave.color_mode                 = MODE_COLORS_PER_LED;
+    Wave.brightness_min             = AOC_MOUSEMAT_BRIGHTNESS_OFF;
+    Wave.brightness_max             = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
+    Wave.brightness                 = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
+    Wave.speed_min                  = AOC_MOUSEMAT_SPEED_SLOW;
+    Wave.speed_max                  = AOC_MOUSEMAT_SPEED_FAST;
+    Wave.speed                      = AOC_MOUSEMAT_SPEED_MEDIUM;
+    modes.push_back(Wave);
+
+    mode RainbowWave;
+    RainbowWave.name                = "Rainbow Wave";
+    RainbowWave.value               = AOC_MOUSEMAT_MODE_WAVE_RANDOM;
+    RainbowWave.flags               = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    RainbowWave.color_mode          = MODE_COLORS_RANDOM;
+    RainbowWave.brightness_min      = AOC_MOUSEMAT_BRIGHTNESS_OFF;
+    RainbowWave.brightness_max      = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
+    RainbowWave.brightness          = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
+    RainbowWave.speed_min           = AOC_MOUSEMAT_SPEED_SLOW;
+    RainbowWave.speed_max           = AOC_MOUSEMAT_SPEED_FAST;
+    RainbowWave.speed               = AOC_MOUSEMAT_SPEED_MEDIUM;
+    modes.push_back(RainbowWave);
+
+    SetupZones();
+};
+
+RGBController_AOCMousemat::~RGBController_AOCMousemat()
+{
+    delete controller;
+}
+
+void RGBController_AOCMousemat::SetupZones()
+{
+    zone mousemat_zone;
+    mousemat_zone.name          = "Mousemat";
+    mousemat_zone.type          = ZONE_TYPE_SINGLE;
+    mousemat_zone.leds_min      = 1;
+    mousemat_zone.leds_max      = 1;
+    mousemat_zone.leds_count    = 1;
+    mousemat_zone.matrix_map    = NULL;
+    zones.push_back(mousemat_zone);
+
+    led mousemat_led;
+    mousemat_led.name           = "Mousemat";
+    leds.push_back(mousemat_led);
+
+    SetupColors();
+}
+
+void RGBController_AOCMousemat::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AOCMousemat::DeviceUpdateLEDs()
+{
+    DeviceUpdateMode();
+}
+
+void RGBController_AOCMousemat::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AOCMousemat::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AOCMousemat::DeviceUpdateMode()
+{
+    if(modes[active_mode].value == AOC_MOUSEMAT_MODE_STATIC_SINGLE_COLOR)
+    {
+        controller->SendDirect(&colors[0]);
+    }
+    else
+    {
+        unsigned char   aoc_direction   = AOC_MOUSEMAT_DIRECTION_CLOCKWISE;
+        unsigned int    aoc_mode        = modes[active_mode].value;
+
+        if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
+        {
+            aoc_direction = AOC_MOUSEMAT_DIRECTION_COUNTERCLOCKWISE;
+        }
+
+        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
+        {
+            switch(modes[active_mode].value)
+            {
+                case AOC_MOUSEMAT_MODE_BREATHING_SINGLE_COLOR:
+                    aoc_mode = AOC_MOUSEMAT_MODE_BREATHING_RANDOM;
+                    break;
+
+                case AOC_MOUSEMAT_MODE_BLINK_SINGLE_COLOR:
+                    aoc_mode = AOC_MOUSEMAT_MODE_BLINK_RANDOM;
+                    break;
+            }
+        }
+
+        controller->SendPacket(aoc_mode,
+                               modes[active_mode].brightness,
+                               modes[active_mode].speed,
+                               aoc_direction,
+                               &colors[0]);
+    }
+}

Controllers/AOCMousematController/RGBController_AOCMousemat.h

@@ -0,0 +1,32 @@
+/*-----------------------------------------*\
+|  RGBController_AOCMousemat.h              |
+|                                           |
+|  Generic RGB Interface for AOC mousemat   |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/15/2023   |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AOCMousematController.h"
+
+class RGBController_AOCMousemat : public RGBController
+{
+public:
+    RGBController_AOCMousemat(AOCMousematController* controller_ptr);
+    ~RGBController_AOCMousemat();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AOCMousematController*  controller;
+};

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -76,7 +76,7 @@ std::string PolychromeUSBController::GetSerialString()
     {
         return("");
     }
-    
+
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());
 
@@ -213,13 +213,13 @@ void PolychromeUSBController::WriteZone
     unsigned char   zone,
     unsigned char   mode,
     unsigned char   speed,
-    RGBColor        rgb, 
+    RGBColor        rgb,
     bool            allzone = false
     )
 {
 
 	/*----------------------------------------------------*\
-    | Get the device info so we can look up the zone type. | 
+    | Get the device info so we can look up the zone type. |
 	\*----------------------------------------------------*/
     PolychromeDeviceInfo device_info = GetPolychromeDevices()[zone];
 
@@ -234,7 +234,7 @@ void PolychromeUSBController::WriteZone
     | Set up message packet with leading 00                  |
     \*-----------------------------------------------------*/
 	usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
-    usb_buf[0x03] = device_info.zone_type; 
+    usb_buf[0x03] = device_info.zone_type;
 	usb_buf[0x04] = mode;
 
     if(device_info.rgswap)
@@ -262,7 +262,7 @@ void PolychromeUSBController::WriteZone
 
 void PolychromeUSBController::WriteAllZones
     (
-    const std::vector<PolychromeZoneInfo>&  zones_info,
+    const std::vector<PolychromeZoneInfo>&  /*zones_info*/,
     const std::vector<zone>&                zones
     )
 {
@@ -434,7 +434,7 @@ PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
     | Set up config table request packet                    |
     \*-----------------------------------------------------*/
     usb_buf[0x01]   = POLYCHROME_USB_READ_ZONE_CONFIG;
-    usb_buf[0x03]   = device_info.zone_type; 
+    usb_buf[0x03]   = device_info.zone_type;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
@@ -446,7 +446,7 @@ PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
     \*-----------------------------------------------------*/
     memset(usb_buf, 0x00, sizeof(usb_buf));
     hid_read(dev, usb_buf, 64);
-    
+
     r   = usb_buf[0x05];
     g   = usb_buf[0x06];
     b   = usb_buf[0x07];

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -131,5 +131,6 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX470 O4G Gaming"           , DetectAs
 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);

Controllers/AsusAuraUSBController/AsusAuraMonitorController.cpp

@@ -83,17 +83,19 @@ void AuraMonitorController::UpdateLed
     usb_buf[0x02]   = 0xA1;
     usb_buf[0x03]   = 0x80;
 
-    usb_buf[0x04]   = 16 + led * 3;
+    unsigned char offset = (device_pid == AURA_ROG_STRIX_XG279Q_PID) ? 0 : 16;
+
+    usb_buf[0x04]   = offset + led * 3;
     usb_buf[0x05]   = red;
     
     hid_send_feature_report(dev, usb_buf, 8);
 
-    usb_buf[0x04]   = 16 + led * 3 + 1;
+    usb_buf[0x04]   = offset + led * 3 + 1;
     usb_buf[0x05]   = blue;
     
     hid_send_feature_report(dev, usb_buf, 8);
 
-    usb_buf[0x04]   = 16 + led * 3 + 2;
+    usb_buf[0x04]   = offset + led * 3 + 2;
     usb_buf[0x05]   = green;
     
     hid_send_feature_report(dev, usb_buf, 8);

Controllers/AsusAuraUSBController/AsusAuraMonitorController.h

@@ -15,9 +15,11 @@
 
 enum
 {
-    AURA_ROG_STRIX_XG27AQ_PID    = 0x198C,
-    AURA_ROG_STRIX_XG27W_PID     = 0x1933,
-    AURA_ROG_PG32UQ_PID          = 0x19B9,
+    AURA_ROG_STRIX_XG27AQ_PID   = 0x198C,
+    AURA_ROG_STRIX_XG27AQM_PID  = 0x19BB,
+    AURA_ROG_STRIX_XG279Q_PID   = 0x1919,
+    AURA_ROG_STRIX_XG27W_PID    = 0x1933,
+    AURA_ROG_PG32UQ_PID         = 0x19B9,
 };
 
 

Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h

@@ -27,6 +27,8 @@
 #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
@@ -44,12 +46,15 @@
 #define AURA_TUF_M3_PID                             0x1910
 #define AURA_TUF_M5_PID                             0x1898
 
+#define AURA_ROG_SPATHA_X_DOCK_FAKE_PID             0xFFFF
+
 enum
 {
     AURA_MOUSE_ZONE_LOGO        = 0,
     AURA_MOUSE_ZONE_SCROLL      = 1,
     AURA_MOUSE_ZONE_UNDERGLOW   = 2,
     AURA_MOUSE_ZONE_ALL         = 3,
+    AURA_MOUSE_ZONE_DOCK        = 4,
 };
 
 enum
@@ -271,12 +276,12 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_ROG_CHAKRAM_X_USB_PID, // ROG Chakram X USB
         {
-            0,
-            0,
-            0,
-            4,
-            false,
+            15, // technically until 255, but unusably slow after 15
             1,
+            0,
+            64,
+            false,
+            2,
             { 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 }
         }
@@ -284,7 +289,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_ROG_CHAKRAM_X_2_4_PID, // ROG Chakram X 2.4GHz Dongle
         {
-            255,
+            15, // technically until 255, but unusably slow after 15
             1,
             0,
             64,
@@ -294,6 +299,32 @@ static std::map<int,mouse_type> aura_mouse_devices =
             { 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_SPATHA_X_USB_PID, // ROG Spatha X USB
+        {
+            15, // technically until 255, but unusably slow after 15
+            1,
+            0,
+            64,
+            false,
+            1,
+            { 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_SPATHA_X_2_4_PID, // ROG Spatha X 2.4GHz Dock
+        {
+            15, // technically until 255, but unusably slow after 15
+            1,
+            0,
+            64,
+            true,
+            1,
+            { 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_PUGIO_PID, // ROG Pugio
         {
@@ -343,7 +374,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             false,
             4,
             { AURA_MOUSE_ZONE_LOGO },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM }
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE }
         }
     },
     {
@@ -502,4 +533,17 @@ static std::map<int,mouse_type> aura_mouse_devices =
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
     },
+    {
+        AURA_ROG_SPATHA_X_DOCK_FAKE_PID, // Asus ROG Spatha X Dock (only in wireless mode)
+        {
+            0,
+            0,
+            0,
+            100,
+            false,
+            1,
+            { 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 }
+        }
+    },
 };

Controllers/AsusAuraUSBController/AsusAuraMousematController.cpp

@@ -55,8 +55,8 @@ std::string AuraMousematController::GetVersion()
     unsigned char usb_buf_out[65];
     hid_read(dev, usb_buf_out, 65);
 
-    char version[5];
-    snprintf(version, 5, "%04X", (usb_buf_out[6] << 8) | usb_buf_out[7]);
+    char version[9];
+    snprintf(version, 9, "%X.%02X.%02X", usb_buf_out[6], usb_buf_out[7], usb_buf_out[8]);
     return std::string(version);
 }
 
@@ -116,7 +116,7 @@ void AuraMousematController::UpdateDevice
         usb_buf[0x0b + i * 3]   = RGBGetGValue(colors[i]);
         usb_buf[0x0c + i * 3]   = RGBGetBValue(colors[i]);
     }
-    
+
     hid_write(dev, usb_buf, 65);
 }
 
@@ -128,7 +128,7 @@ void AuraMousematController::SaveMode()
 
     usb_save_buf[0x00]   = 0xEE;
     usb_save_buf[0x01]   = 0x50;
-    usb_save_buf[0x02]   = 0x55;
+    usb_save_buf[0x02]   = 0x03;
 
     hid_write(dev, usb_save_buf, 65);
 }

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp

@@ -17,12 +17,14 @@
 #include <string.h>
 #include <cmath>
 
-AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short rev_version)
+AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version)
 {
     dev         = dev_handle;
     location    = path;
     device_pid  = pid;
-    version     = rev_version;
+    rev_version = version;
+
+    is_per_led_keyboard = (pid != AURA_TUF_K1_GAMING_PID && pid != AURA_TUF_K5_GAMING_PID);
 }
 
 AuraTUFKeyboardController::~AuraTUFKeyboardController()
@@ -136,13 +138,7 @@ int AuraTUFKeyboardController::GetLayout()
     }
     else
     {
-        char layout[4];
-
-        snprintf(layout, 4, "%X", version);
-
-        int layoutnum = std::stoi(std::string(layout, 1));
-
-        switch(layoutnum)
+        switch(rev_version >> 0b1100)
         {
             case 1:
                 return 117;
@@ -267,17 +263,63 @@ void AuraTUFKeyboardController::UpdateLeds
 
         for(int j = 0; j < leds; j++)
         {
-            usb_buf[j * 4 + 5] = colors[i * 15 + j].value;
+            usb_buf[j * 4 + 5] = (is_per_led_keyboard) ? colors[i * 15 + j].value : 0x00;
             usb_buf[j * 4 + 6] = RGBGetRValue(colors[i * 15 + j].color);
             usb_buf[j * 4 + 7] = RGBGetGValue(colors[i * 15 + j].color);
             usb_buf[j * 4 + 8] = RGBGetBValue(colors[i * 15 + j].color);
         }
+
         ClearResponses();
         hid_write(dev, usb_buf, 65);
         AwaitResponse(20);
     }
 }
 
+void AuraTUFKeyboardController::UpdateK1Wave
+    (
+    std::vector<RGBColor>   colors,
+    unsigned char           direction,
+    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]   = 0x03;
+    usb_buf[0x04]   = 0x00;
+    usb_buf[0x05]   = speed;
+    usb_buf[0x06]   = brightness;
+    usb_buf[0x07]   = 0x00;
+    usb_buf[0x08]   = direction;
+    usb_buf[0x09]   = 0x00;
+
+    usb_buf[10] = 5;
+    usb_buf[11] = RGBGetRValue(colors[4]);
+    usb_buf[12] = RGBGetGValue(colors[4]);
+    usb_buf[13] = RGBGetBValue(colors[4]);
+
+    ClearResponses();
+    hid_write(dev, usb_buf, 65);
+    AwaitResponse(20);
+
+    for(unsigned int i = 0; i < 4; i ++)
+    {
+        usb_buf[10 + i * 4] = i + 1;
+        usb_buf[11 + i * 4] = RGBGetRValue(colors[i]);
+        usb_buf[12 + i * 4] = RGBGetGValue(colors[i]);
+        usb_buf[13 + i * 4] = RGBGetBValue(colors[i]);
+    }
+
+    ClearResponses();
+    hid_write(dev, usb_buf, 65);
+    AwaitResponse(20);
+}
+
 void AuraTUFKeyboardController::UpdateDevice
     (
     unsigned char           mode,
@@ -288,6 +330,11 @@ void AuraTUFKeyboardController::UpdateDevice
     unsigned char           brightness
     )
 {
+    if(device_pid == AURA_TUF_K1_GAMING_PID && mode == AURA_KEYBOARD_MODE_WAVE)
+    {
+        return UpdateK1Wave(colors, direction, speed, brightness);
+    }
+
     unsigned char usb_buf[65];
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
@@ -303,41 +350,79 @@ void AuraTUFKeyboardController::UpdateDevice
         usb_buf[0x06]   = brightness;
         usb_buf[0x07]   = color_mode;
         usb_buf[0x08]   = direction;
-        usb_buf[0x09]   = 0x02;
 
-        if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
+        if(is_per_led_keyboard)
         {
-            usb_buf[0x0A]   = colors.size();
+            usb_buf[0x09]   = 0x02;
 
-            /*-----------------------------------------------------*\
-            | Loop over every color given                           |
-            \*-----------------------------------------------------*/
-            for(unsigned int i = 0; i < colors.size(); i ++)
+            if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
             {
-                if(colors[i])
+                usb_buf[0x0A]   = colors.size();
+
+                /*-----------------------------------------------------*\
+                | Loop over every color given                           |
+                \*-----------------------------------------------------*/
+                for(unsigned int i = 0; i < colors.size(); i ++)
                 {
-                    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]);
+                    if(colors[i])
+                    {
+                        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]);
+                    }
                 }
             }
+            else
+            {
+                /*-----------------------------------------------------*\
+                | Loop over Color1, Color2 and Background if there      |
+                \*-----------------------------------------------------*/
+                for(unsigned int i = 0; i != colors.size(); i++)
+                {
+                    if(colors[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]);
+                    }
+                }
+                    
+            }
         }
         else
         {
-            /*-----------------------------------------------------*\
-            | Loop over Color1, Color2 and Background if there      |
-            \*-----------------------------------------------------*/
-            for(unsigned int i = 0; i != colors.size(); i++)
+            /*-----------------------------------------------------------------*\
+            | Only handles K5 Rainbow.                                          |
+            | K1 is filtered out earlier and is executed in `UpdateK1Wave()`    |
+            \*-----------------------------------------------------------------*/
+            if(mode == AURA_KEYBOARD_MODE_WAVE)
             {
-                if(colors[i])
+                usb_buf[0x09]   = 0x05;
+
+                for(unsigned int i = 0; i < 5; 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]);
+                    usb_buf[10 + i * 4] = i + 1;
+                    usb_buf[11 + i * 4] = RGBGetRValue(colors[i]);
+                    usb_buf[12 + i * 4] = RGBGetGValue(colors[i]);
+                    usb_buf[13 + i * 4] = RGBGetBValue(colors[i]);
+                }
+            }
+            else
+            {
+                /*-----------------------------------------------------*\
+                | Loop over Color1, Color2 and Background if there      |
+                \*-----------------------------------------------------*/
+                for(unsigned int i = 0; i != colors.size(); i++)
+                {
+                    if(colors[i])
+                    {
+                        usb_buf[ 9 + i * 3] = RGBGetRValue(colors[i]);
+                        usb_buf[10 + i * 3] = RGBGetGValue(colors[i]);
+                        usb_buf[11 + i * 3] = RGBGetBValue(colors[i]);
+                    }
                 }
             }
-
         }
     }
     else

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h

@@ -35,8 +35,10 @@ enum
 {
     AURA_ROG_FALCHION_WIRED_PID     = 0x193C,
     AURA_ROG_FALCHION_WIRELESS_PID  = 0x193E,
-    AURA_TUF_K7_GAMING_PID          = 0x18AA,
+    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,
 };
 
@@ -49,7 +51,7 @@ struct led_color
 class AuraTUFKeyboardController
 {
 public:
-    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short rev_version);
+    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version);
     ~AuraTUFKeyboardController();
 
     std::string GetDeviceLocation();
@@ -73,11 +75,19 @@ public:
         std::vector<led_color>    colors
         );
 
+    void UpdateK1Wave
+        (
+        std::vector<RGBColor>   colors,
+        unsigned char           direction,
+        unsigned char           speed,
+        unsigned char           brightness
+        );
+
     void UpdateDevice
         (
         unsigned char           mode,
         std::vector<RGBColor>   colors,
-        unsigned char           dir,
+        unsigned char           direction,
         unsigned char           color_mode,
         unsigned char           speed,
         unsigned char           brightness
@@ -88,10 +98,11 @@ public:
     void ClearResponses();
 
     uint16_t                    device_pid;
+    bool                        is_per_led_keyboard;
 
 private:
     hid_device*                 dev;
     std::string                 location;
-    unsigned short              version;
+    unsigned short              rev_version;
 };
 

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardLayouts.h

@@ -60,7 +60,8 @@ struct layout_info
     std::vector<led_value>      led_names;
 };
 
-static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_US[6][24] = {
+static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_US[6][24] =
+{
     {   0,  NA,   8,  14,  19,  24,  NA,  34,  39,  44,  49,  55,  61,  66,  70,  NA,  74,  78,  83,  NA,  NA,  NA,  NA,  NA },
     {   1,   6,   9,  15,  20,  25,  29,  35,  40,  45,  50,  56,  62,  67,  NA,  NA,  75,  79,  84,  NA,  87,  92,  96, 101 },
     {   2,  NA,  10,  16,  21,  26,  30,  36,  41,  46,  51,  57,  63,  68,  71,  NA,  76,  80,  85,  NA,  88,  93,  97, 102 },
@@ -70,7 +71,8 @@ static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_US[6][24] = {
 };
 
 
-static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_UK[6][24] = {
+static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_UK[6][24] =
+{
     {   0,  NA,   9,  15,  20,  25,  NA,  35,  40,  45,  50,  56,  62,  67,  72,  NA,  75,  79,  84,  NA,  NA,  NA,  NA,  NA },
     {   1,   6,  10,  16,  21,  26,  30,  36,  41,  46,  51,  57,  63,  68,  NA,  NA,  76,  80,  85,  NA,  88,  93,  97, 102 },
     {   2,  NA,  11,  17,  22,  27,  31,  37,  42,  47,  52,  58,  64,  69,  NA,  NA,  77,  81,  86,  NA,  89,  94,  98, 103 },
@@ -79,7 +81,8 @@ static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_UK[6][24] = {
     {   5,   8,  14,  NA,  NA,  NA,  34,  NA,  NA,  NA,  55,  61,  66,  NA,  74,  NA,  78,  83,  87,  NA,  92,  NA, 101,  NA }
 };
 
-static unsigned int ASUS_FALCHION_LAYOUT_KEYS_US[5][16] = {
+static unsigned int ASUS_FALCHION_LAYOUT_KEYS_US[5][16] =
+{
     {   0,   5,   7,  12,  16,  20,  24,  29,  33,  37,  41,  46,  51,  56,  NA,  63 },
     {   1,  NA,   8,  13,  17,  21,  25,  30,  34,  38,  42,  47,  52,  57,  59,  64 },
     {   2,  NA,   9,  14,  18,  22,  26,  31,  35,  39,  43,  48,  53,  NA,  60,  65 }, 
@@ -87,7 +90,8 @@ static unsigned int ASUS_FALCHION_LAYOUT_KEYS_US[5][16] = {
     {   4,   6,  11,  NA,  NA,  NA,  28,  NA,  NA,  NA,  45,  50,  55,  58,  62,  67 }
 };
 
-static unsigned int ASUS_FALCHION_LAYOUT_KEYS_UK[5][16] = {
+static unsigned int ASUS_FALCHION_LAYOUT_KEYS_UK[5][16] =
+{
     {   0,   5,   8,  13,  17,  21,  25,  30,  34,  38,  42,  47,  52,  57,  NA,  64 },
     {   1,  NA,   9,  14,  18,  22,  26,  31,  35,  39,  43,  48,  53,  58,  61,  65 },
     {   2,  NA,  10,  15,  19,  23,  27,  32,  36,  40,  44,  49,  54,  59,  NA,  66 }, 
@@ -95,7 +99,8 @@ static unsigned int ASUS_FALCHION_LAYOUT_KEYS_UK[5][16] = {
     {   4,   7,  12,  NA,  NA,  NA,  29,  NA,  NA,  NA,  46,  51,  56,  60,  63,  68 }
 };
 
-static unsigned int ASUS_CLAYMORE_NO_NUMPAD_LAYOUT_KEYS_US[7][19] = {
+static unsigned int ASUS_CLAYMORE_NO_NUMPAD_LAYOUT_KEYS_US[7][19] =
+{
     {   0,  NA,   8,  14,  19,  24,  NA,  34,  39,  45,  50,  56,  62,  67,  71,  NA,  75,  79,  84 },
     {   1,   6,   9,  15,  20,  25,  29,  35,  40,  46,  51,  57,  63,  68,  NA,  NA,  76,  80,  85 },
     {   2,  NA,  10,  16,  21,  26,  30,  36,  41,  47,  52,  58,  64,  69,  72,  NA,  77,  81,  86 },
@@ -105,7 +110,8 @@ static unsigned int ASUS_CLAYMORE_NO_NUMPAD_LAYOUT_KEYS_US[7][19] = {
     {  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  44,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA }
 };
 
-static unsigned int ASUS_CLAYMORE_NO_NUMPAD_LAYOUT_KEYS_UK[7][19] = {
+static unsigned int ASUS_CLAYMORE_NO_NUMPAD_LAYOUT_KEYS_UK[7][19] =
+{
     {   0,  NA,   9,  15,  20,  25,  NA,  35,  40,  46,  51,  57,  63,  68,  73,  NA,  76,  80,  85 },
     {   1,   6,  10,  16,  21,  26,  30,  36,  41,  47,  52,  58,  64,  69,  NA,  NA,  77,  81,  86 },
     {   2,  NA,  11,  17,  22,  27,  31,  37,  42,  48,  53,  59,  65,  70,  NA,  NA,  78,  82,  87 },
@@ -115,7 +121,8 @@ static unsigned int ASUS_CLAYMORE_NO_NUMPAD_LAYOUT_KEYS_UK[7][19] = {
     {  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  45,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA }
 };
 
-static unsigned int ASUS_CLAYMORE_NUMPAD_RIGHT_LAYOUT_KEYS_US[7][24] = {
+static unsigned int ASUS_CLAYMORE_NUMPAD_RIGHT_LAYOUT_KEYS_US[7][24] =
+{
     {   0,  NA,   8,  14,  19,  24,  NA,  34,  39,  45,  50,  56,  62,  67,  71,  NA,  75,  79,  84,  NA,  NA,  NA,  NA,  NA },
     {   1,   6,   9,  15,  20,  25,  29,  35,  40,  46,  51,  57,  63,  68,  NA,  NA,  76,  80,  85,  NA,  88,  93,  97, 102 },
     {   2,  NA,  10,  16,  21,  26,  30,  36,  41,  47,  52,  58,  64,  69,  72,  NA,  77,  81,  86,  NA,  89,  94,  98, 103 },
@@ -125,7 +132,8 @@ static unsigned int ASUS_CLAYMORE_NUMPAD_RIGHT_LAYOUT_KEYS_US[7][24] = {
     {  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  44,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA }
 };
 
-static unsigned int ASUS_CLAYMORE_NUMPAD_RIGHT_LAYOUT_KEYS_UK[7][24] = {
+static unsigned int ASUS_CLAYMORE_NUMPAD_RIGHT_LAYOUT_KEYS_UK[7][24] =
+{
     {   0,  NA,   9,  15,  20,  25,  NA,  35,  40,  46,  51,  57,  63,  68,  73,  NA,  76,  80,  85,  NA,  NA,  NA,  NA,  NA },
     {   1,   6,  10,  16,  21,  26,  30,  36,  41,  47,  52,  58,  64,  69,  NA,  NA,  77,  81,  86,  NA,  89,  94,  98, 103 },
     {   2,  NA,  11,  17,  22,  27,  31,  37,  42,  48,  53,  59,  65,  70,  NA,  NA,  78,  82,  87,  NA,  90,  95,  99, 104 },
@@ -135,7 +143,8 @@ static unsigned int ASUS_CLAYMORE_NUMPAD_RIGHT_LAYOUT_KEYS_UK[7][24] = {
     {  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  45,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA }
 };
 
-static unsigned int ASUS_CLAYMORE_NUMPAD_LEFT_LAYOUT_KEYS_US[7][24] = {
+static unsigned int ASUS_CLAYMORE_NUMPAD_LEFT_LAYOUT_KEYS_US[7][24] =
+{
     {  NA,  NA,  NA,  NA,  NA,  17,  NA,  25,  31,  36,  41,  NA,  51,  56,  62,  67,  73,  79,  84,  88,  NA,  92,  96, 101 },
     {   0,   5,   9,  14,  NA,  18,  23,  26,  32,  37,  42,  46,  52,  57,  63,  68,  74,  80,  85,  NA,  NA,  93,  97, 102 },
     {   1,   6,  10,  15,  NA,  19,  NA,  27,  33,  38,  43,  47,  53,  58,  64,  69,  75,  81,  86,  89,  NA,  94,  98, 103 },
@@ -145,7 +154,8 @@ static unsigned int ASUS_CLAYMORE_NUMPAD_LEFT_LAYOUT_KEYS_US[7][24] = {
     {  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  61,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA }
 };
 
-static unsigned int ASUS_CLAYMORE_NUMPAD_LEFT_LAYOUT_KEYS_UK[7][24] = {
+static unsigned int ASUS_CLAYMORE_NUMPAD_LEFT_LAYOUT_KEYS_UK[7][24] =
+{
     {  NA,  NA,  NA,  NA,  NA,  17,  NA,  26,  32,  37,  42,  NA,  52,  57,  63,  68,  74,  80,  85,  90,  NA,  93,  97, 102 },
     {   0,   5,   9,  14,  NA,  18,  23,  27,  33,  38,  43,  47,  53,  58,  64,  69,  75,  81,  86,  NA,  NA,  94,  98, 103 },
     {   1,   6,  10,  15,  NA,  19,  NA,  28,  34,  39,  44,  48,  54,  59,  65,  70,  76,  82,  87,  NA,  NA,  95,  99, 104 },
@@ -155,6 +165,11 @@ static unsigned int ASUS_CLAYMORE_NUMPAD_LEFT_LAYOUT_KEYS_UK[7][24] = {
     {  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  62,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA }
 };
 
+static unsigned int ASUS_TUF_K1_LAYOUT_KEYS[1][5] =
+{
+    {  0,  1,  2,  3,  4 },
+};
+
 static std::map<int,layout_info> AsusTUFK7Layouts =
 {
     {
@@ -1302,3 +1317,39 @@ static std::map<int,layout_info> AsusClaymoreNumpadLeftLayouts =
         }
     },
 };
+
+static std::map<int,layout_info> AsusTufK1Layouts =
+{
+    {
+        ASUS_TUF_K7_LAYOUT_UK,
+        {
+            *ASUS_TUF_K1_LAYOUT_KEYS,
+            5,
+            1,
+            5,
+            {
+                { "Keyboard LED 1",             0x00 },
+                { "Keyboard LED 2",             0x01 },
+                { "Keyboard LED 3",             0x02 },
+                { "Keyboard LED 4",             0x03 },
+                { "Keyboard LED 5",             0x04 },
+            }
+        }
+    },
+    {
+        ASUS_TUF_K7_LAYOUT_US,
+        {
+            *ASUS_TUF_K1_LAYOUT_KEYS,
+            5,
+            1,
+            5,
+            {
+                { "Keyboard LED 1",             0x00 },
+                { "Keyboard LED 2",             0x01 },
+                { "Keyboard LED 3",             0x02 },
+                { "Keyboard LED 4",             0x03 },
+                { "Keyboard LED 5",             0x04 },
+            }
+        }
+    },
+};

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -6,6 +6,7 @@
 #include "AsusAuraMainboardController.h"
 #include "AsusAuraMouseController.h"
 #include "AsusAuraMousematController.h"
+#include "AsusROGAllyController.h"
 #include "AsusAuraStrixEvolveController.h"
 #include "AsusAuraMonitorController.h"
 #include "AsusAuraRyuoAIOController.h"
@@ -16,6 +17,7 @@
 #include "RGBController_AsusAuraTUFKeyboard.h"
 #include "RGBController_AsusAuraMouse.h"
 #include "RGBController_AsusAuraMousemat.h"
+#include "RGBController_AsusROGAlly.h"
 #include "RGBController_ROGStrixLC_Controller.h"
 #include "RGBController_AsusAuraStrixEvolve.h"
 #include "RGBController_AsusAuraMonitor.h"
@@ -48,10 +50,13 @@
 #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_K7_GAMING_PID                  0x18AA
+#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                         |
@@ -71,6 +76,7 @@
 
 #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
 
@@ -88,6 +94,7 @@
 #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)
 {
@@ -105,6 +112,7 @@ AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
             return SCOPE_RX_LAYOUT;
 
         case AURA_ROG_STRIX_SCOPE_TKL_PID:
+        case AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID:
         case AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID:
             return SCOPE_TKL_LAYOUT;
 
@@ -186,6 +194,15 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
         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);
+        }
     }
 }
 
@@ -280,6 +297,19 @@ void DetectAsusAuraUSBMonitor(hid_device_info* info, const std::string& name)
     }
 }
 
+void DetectAsusROGAlly(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        ROGAllyController*         controller           = new ROGAllyController(dev, info->path);
+        RGBController_AsusROGAlly* rgb_controller       = new RGBController_AsusROGAlly(controller);
+        rgb_controller->name                            = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 /*-----------------------------------------------------------------*\
 |  MOTHERBOARDS                                                     |
 \*-----------------------------------------------------------------*/
@@ -300,12 +330,15 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare CoD Black Ops 4 Edition",DetectAs
 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 TUF Gaming K7",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_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                                                             |
@@ -326,10 +359,12 @@ REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",                    DetectAs
 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,                    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);
@@ -356,6 +391,7 @@ REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus Qi",                         DetectAs
 \*-----------------------------------------------------------------*/
 REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQ",                       DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27AQ_PID,                    0xFFA0, 1);
 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 PG32UQ",                             DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_PG32UQ_PID,                          0xFFA0, 1);
 
@@ -368,3 +404,4 @@ REGISTER_HID_DETECTOR_PU ("ASUS ROG Ryuo AIO",                          DetectAs
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne",                            DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_PID,                          0);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI",                         DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_PID,                       0);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI GUNDAM",                  DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_GUNDAM_PID,                0);
+REGISTER_HID_DETECTOR_IPU("ASUS ROG Ally",                              DetectAsusROGAlly,              AURA_USB_VID, ASUS_ROG_ALLY_PID,                            2,  0xFF31, 0x0076);

Controllers/AsusAuraUSBController/AsusROGAllyController.cpp

@@ -0,0 +1,127 @@
+/*-----------------------------------------*\
+|  AsusROGAllyController.cpp                |
+|                                           |
+|  Driver for ASUS ROG Ally lighting        |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/12/2023   |
+\*-----------------------------------------*/
+
+#include "AsusROGAllyController.h"
+#include <cstring>
+
+ROGAllyController::ROGAllyController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+ROGAllyController::~ROGAllyController()
+{
+    hid_close(dev);
+}
+
+std::string ROGAllyController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string ROGAllyController::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);
+}
+
+std::string ROGAllyController::GetVersion()
+{
+    return("");
+}
+
+void ROGAllyController::UpdateLeds
+    (
+    std::vector<RGBColor>    colors
+    )
+{
+    unsigned char usb_buf[64];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x5A;
+    usb_buf[0x01]   = 0xD1;
+    usb_buf[0x02]   = 0x08;
+    usb_buf[0x03]   = 0x0C;
+
+    for(unsigned int color_idx = 0; color_idx < colors.size(); color_idx++)
+    {
+        usb_buf[color_idx * 3 + 4]  = RGBGetRValue(colors[color_idx]);
+        usb_buf[color_idx * 3 + 5]  = RGBGetGValue(colors[color_idx]);
+        usb_buf[color_idx * 3 + 6]  = RGBGetBValue(colors[color_idx]);
+    }
+
+    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
+}
+
+void ROGAllyController::UpdateDevice
+    (
+    unsigned char           mode,
+    std::vector<RGBColor>   colors,
+    unsigned char           speed,
+    unsigned char           /*brightness*/,
+    unsigned char           direction
+    )
+{
+    unsigned char usb_buf[64];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x5A;
+    usb_buf[0x01]   = 0xB3;
+    usb_buf[0x02]   = 0x00;
+    usb_buf[0x03]   = mode;
+    if(colors.size() > 0)
+    {
+        usb_buf[0x04]   = RGBGetRValue(colors[0]);
+        usb_buf[0x05]   = RGBGetGValue(colors[0]);
+        usb_buf[0x06]   = RGBGetBValue(colors[0]);
+    }
+    usb_buf[0x07]   = speed;
+    usb_buf[0x08]   = direction;
+    if(colors.size() > 1)
+    {
+        usb_buf[0x0A]   = RGBGetRValue(colors[1]);
+        usb_buf[0x0B]   = RGBGetGValue(colors[1]);
+        usb_buf[0x0C]   = RGBGetBValue(colors[1]);
+    }
+
+    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x5A;
+    usb_buf[0x01]   = 0xB5;
+
+    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
+}
+
+void ROGAllyController::SaveMode()
+{
+    unsigned char usb_buf[64];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x5A;
+    usb_buf[0x01]   = 0xB4;
+
+    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
+}
+

Controllers/AsusAuraUSBController/AsusROGAllyController.h

@@ -0,0 +1,67 @@
+/*-----------------------------------------*\
+|  AsusROGAllyController.h                  |
+|                                           |
+|  Definitions and types for ASUS ROG Ally  |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/12/2023   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    ROG_ALLY_MODE_STATIC           = 0,
+    ROG_ALLY_MODE_BREATHING        = 1,
+    ROG_ALLY_MODE_COLOR_CYCLE      = 2,
+    ROG_ALLY_MODE_RAINBOW          = 3,
+    ROG_ALLY_MODE_STROBING         = 10,
+    ROG_ALLY_MODE_DIRECT           = 0xFF,
+};
+
+enum
+{
+    ROG_ALLY_SPEED_MIN              = 0xE1,
+    ROG_ALLY_SPEED_MED              = 0xEB,
+    ROG_ALLY_SPEED_MAX              = 0xF5
+};
+
+enum
+{
+    ROG_ALLY_DIRECTION_RIGHT        = 0x00,
+    ROG_ALLY_DIRECTION_LEFT         = 0x01
+};
+
+class ROGAllyController
+{
+public:
+    ROGAllyController(hid_device* dev_handle, const char* path);
+    virtual ~ROGAllyController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+    std::string GetVersion();
+
+    void UpdateLeds
+        (
+            std::vector<RGBColor>    colors
+            );
+
+    void UpdateDevice
+        (
+            unsigned char           mode,
+            std::vector<RGBColor>   colors,
+            unsigned char           speed,
+            unsigned char           brightness,
+            unsigned char           direction
+            );
+
+    void SaveMode();
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+};

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp

@@ -9,11 +9,12 @@
 
 #include "RGBController_AsusAuraMouse.h"
 
-static std::string aura_mouse_zone_names[3]
+static std::string aura_mouse_zone_names[4]
 {
     "Logo",
     "Scroll Wheel",
-    "Underglow"
+    "Underglow",
+    "Dock"
 };
 
 /**------------------------------------------------------------------*\
@@ -205,7 +206,7 @@ void RGBController_AuraMouse::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_AuraMouse::UpdateZoneLEDs(int zone)
+void RGBController_AuraMouse::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
@@ -238,7 +239,22 @@ void RGBController_AuraMouse::DeviceUpdateMode()
             blu = RGBGetBValue(modes[active_mode].colors[0]);
         }
 
-        controller->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
+
+        if(pid == AURA_ROG_SPATHA_X_DOCK_FAKE_PID)
+        {
+            controller->SendUpdate(AURA_MOUSE_ZONE_DOCK, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
+        }
+        else if(pid == AURA_ROG_STRIX_IMPACT_PID)
+        {
+            /*-----------------------------------------------------------------*\
+            | The ROG Impact doesn't accept AURA_MOUSE_ZONE_ALL                 |
+            \*-----------------------------------------------------------------*/
+            controller->SendUpdate(AURA_MOUSE_ZONE_LOGO, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
+        }
+        else
+        {
+            controller->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
+        }
     }
 }
 

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -28,8 +28,6 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
 
     pid = controller->device_pid;
 
-    const unsigned char AURA_KEYBOARD_SPEED_MIN = (pid == AURA_ROG_FALCHION_WIRED_PID || pid == AURA_ROG_FALCHION_WIRELESS_PID) ? 255 : 15;
-
     if(pid != AURA_ROG_CLAYMORE_PID)
     {
         name        = "ASUS Aura Keyboard";
@@ -40,6 +38,40 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
         location    = controller->GetDeviceLocation();
         serial      = controller->GetSerialString();
 
+        unsigned char AURA_KEYBOARD_SPEED_MIN     = 0;
+        unsigned char AURA_KEYBOARD_SPEED_MAX     = 0;
+        unsigned char AURA_KEYBOARD_SPEED_DEFAULT = 0;
+
+        switch(pid)
+        {
+            case AURA_TUF_K1_GAMING_PID:
+                AURA_KEYBOARD_SPEED_MIN          = 0;
+                AURA_KEYBOARD_SPEED_MAX          = 2;
+                AURA_KEYBOARD_SPEED_DEFAULT      = 1;
+                break;
+            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_FALCHION_WIRED_PID:
+            case AURA_ROG_FALCHION_WIRELESS_PID:
+                AURA_KEYBOARD_SPEED_MIN          = 255;
+                AURA_KEYBOARD_SPEED_MAX          = 0;
+                AURA_KEYBOARD_SPEED_DEFAULT      = 8;
+                break;
+            default:
+                AURA_KEYBOARD_SPEED_MIN          = 15;
+                AURA_KEYBOARD_SPEED_MAX          = 0;
+                AURA_KEYBOARD_SPEED_DEFAULT      = 8;
+        }
+
         mode Direct;
         Direct.name                 = "Direct";
         Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
@@ -63,7 +95,9 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
         mode Breathing;
         Breathing.name              = "Breathing";
         Breathing.value             = AURA_KEYBOARD_MODE_BREATHING;
-        Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        if(controller->is_per_led_keyboard) Breathing.flags |= MODE_FLAG_HAS_RANDOM_COLOR;
+
         Breathing.speed_min         = AURA_KEYBOARD_SPEED_MIN;
         Breathing.speed_max         = AURA_KEYBOARD_SPEED_MAX;
         Breathing.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
@@ -92,7 +126,9 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
         mode Wave;
         Wave.name                   = "Rainbow Wave";
         Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
-        Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        if(controller->is_per_led_keyboard) Wave.flags |= MODE_FLAG_HAS_DIRECTION_UD;
+        
         Wave.speed_min              = AURA_KEYBOARD_SPEED_MIN;
         Wave.speed_max              = AURA_KEYBOARD_SPEED_MAX;
         Wave.speed                  = AURA_KEYBOARD_SPEED_DEFAULT;
@@ -101,107 +137,120 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
         Wave.brightness             = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
         Wave.direction              = MODE_DIRECTION_LEFT;
         Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-        Wave.colors_min             = 1;
-        Wave.colors_max             = 7;
-        Wave.colors.resize(7);
+
+        if(!controller->is_per_led_keyboard)
+        {
+            Wave.colors_min             = 5;
+            Wave.colors_max             = 5;
+        }
+        else
+        {
+            Wave.colors_min             = 1;
+            Wave.colors_max             = 7;
+        }
+
+        Wave.colors.resize(Wave.colors_max);
         modes.push_back(Wave);
 
-        mode Ripple;
-        Ripple.name                 = "Ripple";
-        Ripple.value                = AURA_KEYBOARD_MODE_RIPPLE;
-        Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Ripple.speed_min            = AURA_KEYBOARD_SPEED_MIN;
-        Ripple.speed_max            = AURA_KEYBOARD_SPEED_MAX;
-        Ripple.speed                = AURA_KEYBOARD_SPEED_DEFAULT;
-        Ripple.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Ripple.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Ripple.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Ripple.colors_min           = 1;
-        Ripple.colors_max           = 8;
-        Ripple.colors.resize(7);
-        modes.push_back(Ripple);
+        if(controller->is_per_led_keyboard)
+        {
+            mode Reactive;
+            Reactive.name               = "Reactive";
+            Reactive.value              = AURA_KEYBOARD_MODE_REACTIVE;
+            Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+            Reactive.speed_min          = AURA_KEYBOARD_SPEED_MIN;
+            Reactive.speed_max          = AURA_KEYBOARD_SPEED_MAX;
+            Reactive.speed              = AURA_KEYBOARD_SPEED_DEFAULT;
+            Reactive.brightness_min     = AURA_KEYBOARD_BRIGHTNESS_MIN;
+            Reactive.brightness_max     = AURA_KEYBOARD_BRIGHTNESS_MAX;
+            Reactive.brightness         = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+            Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+            Reactive.colors_min         = 1;
+            Reactive.colors_max         = 2;
+            Reactive.colors.resize(1);
+            modes.push_back(Reactive);
 
-        mode Reactive;
-        Reactive.name               = "Reactive";
-        Reactive.value              = AURA_KEYBOARD_MODE_REACTIVE;
-        Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Reactive.speed_min          = AURA_KEYBOARD_SPEED_MIN;
-        Reactive.speed_max          = AURA_KEYBOARD_SPEED_MAX;
-        Reactive.speed              = AURA_KEYBOARD_SPEED_DEFAULT;
-        Reactive.brightness_min     = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Reactive.brightness_max     = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Reactive.brightness         = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-        Reactive.colors_min         = 1;
-        Reactive.colors_max         = 2;
-        Reactive.colors.resize(1);
-        modes.push_back(Reactive);
+            mode Ripple;
+            Ripple.name                 = "Ripple";
+            Ripple.value                = AURA_KEYBOARD_MODE_RIPPLE;
+            Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+            Ripple.speed_min            = AURA_KEYBOARD_SPEED_MIN;
+            Ripple.speed_max            = AURA_KEYBOARD_SPEED_MAX;
+            Ripple.speed                = AURA_KEYBOARD_SPEED_DEFAULT;
+            Ripple.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
+            Ripple.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
+            Ripple.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+            Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+            Ripple.colors_min           = 1;
+            Ripple.colors_max           = 8;
+            Ripple.colors.resize(7);
+            modes.push_back(Ripple);
 
-        mode Starry_Night;
-        Starry_Night.name           = "Starry Night";
-        Starry_Night.value          = AURA_KEYBOARD_MODE_STARRY_NIGHT;
-        Starry_Night.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Starry_Night.speed_min      = AURA_KEYBOARD_SPEED_MIN;
-        Starry_Night.speed_max      = AURA_KEYBOARD_SPEED_MAX;
-        Starry_Night.speed          = AURA_KEYBOARD_SPEED_DEFAULT;
-        Starry_Night.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Starry_Night.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Starry_Night.brightness     = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-        Starry_Night.colors_min     = 1;
-        Starry_Night.colors_max     = 3;
-        Starry_Night.colors.resize(1);
-        modes.push_back(Starry_Night);
+            mode Starry_Night;
+            Starry_Night.name           = "Starry Night";
+            Starry_Night.value          = AURA_KEYBOARD_MODE_STARRY_NIGHT;
+            Starry_Night.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+            Starry_Night.speed_min      = AURA_KEYBOARD_SPEED_MIN;
+            Starry_Night.speed_max      = AURA_KEYBOARD_SPEED_MAX;
+            Starry_Night.speed          = AURA_KEYBOARD_SPEED_DEFAULT;
+            Starry_Night.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
+            Starry_Night.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
+            Starry_Night.brightness     = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+            Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+            Starry_Night.colors_min     = 1;
+            Starry_Night.colors_max     = 3;
+            Starry_Night.colors.resize(1);
+            modes.push_back(Starry_Night);
 
-        mode Quicksand;
-        Quicksand.name              = "Quicksand";
-        Quicksand.value             = AURA_KEYBOARD_MODE_QUICKSAND;
-        Quicksand.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Quicksand.direction         = MODE_DIRECTION_DOWN;
-        Quicksand.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-        Quicksand.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-        Quicksand.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-        Quicksand.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Quicksand.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Quicksand.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Quicksand.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Quicksand.colors_min        = 6;
-        Quicksand.colors_max        = 6;
-        Quicksand.colors.resize(6);
-        modes.push_back(Quicksand);
+            mode Quicksand;
+            Quicksand.name              = "Quicksand";
+            Quicksand.value             = AURA_KEYBOARD_MODE_QUICKSAND;
+            Quicksand.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+            Quicksand.direction         = MODE_DIRECTION_DOWN;
+            Quicksand.speed_min         = AURA_KEYBOARD_SPEED_MIN;
+            Quicksand.speed_max         = AURA_KEYBOARD_SPEED_MAX;
+            Quicksand.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
+            Quicksand.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
+            Quicksand.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
+            Quicksand.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+            Quicksand.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+            Quicksand.colors_min        = 6;
+            Quicksand.colors_max        = 6;
+            Quicksand.colors.resize(6);
+            modes.push_back(Quicksand);
 
-        mode Current;
-        Current.name                = "Current";
-        Current.value               = AURA_KEYBOARD_MODE_CURRENT;
-        Current.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Current.speed_min           = AURA_KEYBOARD_SPEED_MIN;
-        Current.speed_max           = AURA_KEYBOARD_SPEED_MAX;
-        Current.speed               = AURA_KEYBOARD_SPEED_DEFAULT;
-        Current.brightness_min      = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Current.brightness_max      = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Current.brightness          = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Current.color_mode          = MODE_COLORS_MODE_SPECIFIC;
-        Current.colors_min          = 1;
-        Current.colors_max          = 3;
-        Current.colors.resize(1);
-        modes.push_back(Current);
+            mode Current;
+            Current.name                = "Current";
+            Current.value               = AURA_KEYBOARD_MODE_CURRENT;
+            Current.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+            Current.speed_min           = AURA_KEYBOARD_SPEED_MIN;
+            Current.speed_max           = AURA_KEYBOARD_SPEED_MAX;
+            Current.speed               = AURA_KEYBOARD_SPEED_DEFAULT;
+            Current.brightness_min      = AURA_KEYBOARD_BRIGHTNESS_MIN;
+            Current.brightness_max      = AURA_KEYBOARD_BRIGHTNESS_MAX;
+            Current.brightness          = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+            Current.color_mode          = MODE_COLORS_MODE_SPECIFIC;
+            Current.colors_min          = 1;
+            Current.colors_max          = 3;
+            Current.colors.resize(1);
+            modes.push_back(Current);
 
-        mode Rain_Drop;
-        Rain_Drop.name              = "Rain Drop";
-        Rain_Drop.value             = AURA_KEYBOARD_MODE_RAIN_DROP;
-        Rain_Drop.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Rain_Drop.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-        Rain_Drop.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-        Rain_Drop.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-        Rain_Drop.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Rain_Drop.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Rain_Drop.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Rain_Drop.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Rain_Drop.colors_min        = 1;
-        Rain_Drop.colors_max        = 3;
-        Rain_Drop.colors.resize(1);
-        modes.push_back(Rain_Drop);
+            mode Rain_Drop;
+            Rain_Drop.name              = "Rain Drop";
+            Rain_Drop.value             = AURA_KEYBOARD_MODE_RAIN_DROP;
+            Rain_Drop.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+            Rain_Drop.speed_min         = AURA_KEYBOARD_SPEED_MIN;
+            Rain_Drop.speed_max         = AURA_KEYBOARD_SPEED_MAX;
+            Rain_Drop.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
+            Rain_Drop.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
+            Rain_Drop.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
+            Rain_Drop.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+            Rain_Drop.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+            Rain_Drop.colors_min        = 1;
+            Rain_Drop.colors_max        = 3;
+            Rain_Drop.colors.resize(1);
+            modes.push_back(Rain_Drop);
+        }
     }
     else
     {
@@ -343,12 +392,11 @@ RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
 
 void RGBController_AuraTUFKeyboard::SetupZones()
 {
-    unsigned char layout = controller->GetLayout();
-
     std::map<int,layout_info> * keyboard_ptr;
 
     switch(pid)
     {
+        case AURA_TUF_K3_GAMING_PID:
         case AURA_TUF_K7_GAMING_PID:
             keyboard_ptr = &AsusTUFK7Layouts;
             break;
@@ -374,12 +422,18 @@ void RGBController_AuraTUFKeyboard::SetupZones()
                     keyboard_ptr = &AsusClaymoreNoNumpadLayouts;
             }
             break;
+        case AURA_TUF_K1_GAMING_PID:
+        case AURA_TUF_K5_GAMING_PID:
+            keyboard_ptr = &AsusTufK1Layouts;
+            break;
         default:
             keyboard_ptr = &AsusTUFK7Layouts;
     }
 
     std::map<int,layout_info> & keyboard = *keyboard_ptr;
 
+    unsigned char layout = controller->GetLayout();
+
     if(keyboard.find(layout % 100) == keyboard.end())
     {
         /*---------------------------------------------------------*\
@@ -429,7 +483,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
 {
     std::vector<led_color> led_color_list = {};
 
-    for(int i = 0; i < colors.size(); i++)
+    for(size_t i = 0; i < colors.size(); i++)
     {
         led_color_list.push_back({ leds[i].value, colors[i] });
     }
@@ -444,6 +498,11 @@ void RGBController_AuraTUFKeyboard::UpdateZoneLEDs(int /*zone*/)
 
 void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
 {
+    if(!controller->is_per_led_keyboard)
+    {
+        return DeviceUpdateLEDs();
+    }
+
     unsigned char red   = RGBGetRValue(colors[led]);
     unsigned char green = RGBGetGValue(colors[led]);
     unsigned char blue  = RGBGetBValue(colors[led]);
@@ -485,6 +544,12 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
             case AURA_KEYBOARD_MODE_STARRY_NIGHT:
             case AURA_KEYBOARD_MODE_CURRENT:
             case AURA_KEYBOARD_MODE_RAIN_DROP:
+                if(!controller->is_per_led_keyboard && modes[active_mode].colors.size() > 1)
+                {
+                    color_mode = 1;
+                    break;
+                }
+
                 bool color_is_black = (modes[active_mode].colors.size() > 1 && modes[active_mode].colors[1] == 000);
 
                 if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && !color_is_black)
@@ -524,6 +589,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
         }
     }
 
+
     controller->UpdateDevice(modes[active_mode].value, std::vector<RGBColor>(modes[active_mode].colors), direction, color_mode, modes[active_mode].speed, brightness);
 
     if(pid == AURA_ROG_CLAYMORE_PID)

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h

@@ -13,8 +13,6 @@
 
 enum
 {
-    AURA_KEYBOARD_SPEED_MAX          = 0,
-    AURA_KEYBOARD_SPEED_DEFAULT      = 8,
     AURA_KEYBOARD_BRIGHTNESS_MIN     = 0,
     AURA_KEYBOARD_BRIGHTNESS_MAX     = 4,
     AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 4,
@@ -22,17 +20,16 @@ enum
 
 enum
 {
-    AURA_CLAYMORE_SPEED_MIN                    = 254,
-    AURA_CLAYMORE_SPEED_MAX                    = 0,
-    AURA_CLAYMORE_SPEED_DEFAULT_STATIC         = 0,
-    AURA_CLAYMORE_SPEED_DEFAULT_BREATHING      = 107,
-    AURA_CLAYMORE_SPEED_DEFAULT_COLOR_CYCLE    = 121,
-    AURA_CLAYMORE_SPEED_DEFAULT_REACTIVE       = 56,
-    AURA_CLAYMORE_SPEED_DEFAULT_WAVE           = 50,
-    AURA_CLAYMORE_SPEED_DEFAULT_RIPPLE         = 108,
-    AURA_CLAYMORE_SPEED_DEFAULT_STARRY_NIGHT   = 54,
-    AURA_CLAYMORE_SPEED_DEFAULT_QUICKSAND      = 103,
-
+    AURA_CLAYMORE_SPEED_MIN                     = 254,
+    AURA_CLAYMORE_SPEED_MAX                     = 0,
+    AURA_CLAYMORE_SPEED_DEFAULT_STATIC          = 0,
+    AURA_CLAYMORE_SPEED_DEFAULT_BREATHING       = 107,
+    AURA_CLAYMORE_SPEED_DEFAULT_COLOR_CYCLE     = 121,
+    AURA_CLAYMORE_SPEED_DEFAULT_REACTIVE        = 56,
+    AURA_CLAYMORE_SPEED_DEFAULT_WAVE            = 50,
+    AURA_CLAYMORE_SPEED_DEFAULT_RIPPLE          = 108,
+    AURA_CLAYMORE_SPEED_DEFAULT_STARRY_NIGHT    = 54,
+    AURA_CLAYMORE_SPEED_DEFAULT_QUICKSAND       = 103
 };
 
 class RGBController_AuraTUFKeyboard : public RGBController

Controllers/AsusAuraUSBController/RGBController_AsusROGAlly.cpp

@@ -0,0 +1,196 @@
+/*-----------------------------------------*\
+|  RGBController_AsusROGAlly.cpp            |
+|                                           |
+|  Generic RGB Interface for Asus ROG Ally  |
+|  controller driver                        |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/12/2023   |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusROGAlly.h"
+
+/**------------------------------------------------------------------*\
+    @name Asus ROG Ally
+    @category Gamepad
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectAsusROGAlly
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AsusROGAlly::RGBController_AsusROGAlly(ROGAllyController* controller_ptr)
+{
+    controller                  = controller_ptr;
+
+    name                        = "ASUS ROG Ally";
+    vendor                      = "ASUS";
+    type                        = DEVICE_TYPE_GAMEPAD;
+    description                 = "ASUS ROG Ally Device";
+    version                     = controller->GetVersion();
+    location                    = controller->GetDeviceLocation();
+    serial                      = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = ROG_ALLY_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                = ROG_ALLY_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = ROG_ALLY_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed_min         = ROG_ALLY_SPEED_MIN;
+    Breathing.speed_max         = ROG_ALLY_SPEED_MAX;
+    Breathing.speed             = ROG_ALLY_SPEED_MED;
+    Breathing.colors_min        = 2;
+    Breathing.colors_max        = 2;
+    Breathing.colors.resize(2);
+    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.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;
+    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.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;
+    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.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    Strobing.colors_min         = 1;
+    Strobing.colors_max         = 1;
+    Strobing.colors.resize(1);
+    modes.push_back(Strobing);
+
+    SetupZones();
+}
+
+RGBController_AsusROGAlly::~RGBController_AsusROGAlly()
+{
+    delete controller;
+}
+
+void RGBController_AsusROGAlly::SetupZones()
+{
+    zone left_stick_zone;
+
+    left_stick_zone.name         = "Left Stick";
+    left_stick_zone.type         = ZONE_TYPE_SINGLE;
+    left_stick_zone.leds_min     = 2;
+    left_stick_zone.leds_max     = 2;
+    left_stick_zone.leds_count   = 2;
+    left_stick_zone.matrix_map   = NULL;
+
+    zones.push_back(left_stick_zone);
+
+    for(unsigned int i = 0; i < 2; i++)
+    {
+        led left_stick_led;
+
+        left_stick_led.name      = "Left Stick LED " + std::to_string(i);
+
+        leds.push_back(left_stick_led);
+    }
+
+    zone right_stick_zone;
+
+    right_stick_zone.name         = "Right Stick";
+    right_stick_zone.type         = ZONE_TYPE_SINGLE;
+    right_stick_zone.leds_min     = 2;
+    right_stick_zone.leds_max     = 2;
+    right_stick_zone.leds_count   = 2;
+    right_stick_zone.matrix_map   = NULL;
+
+    zones.push_back(right_stick_zone);
+
+    for(unsigned int i = 0; i < 2; i++)
+    {
+        led right_stick_led;
+
+        right_stick_led.name      = "Right Stick LED " + std::to_string(i);
+
+        leds.push_back(right_stick_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AsusROGAlly::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AsusROGAlly::DeviceUpdateLEDs()
+{
+    if(modes[active_mode].value == ROG_ALLY_MODE_DIRECT)
+    {
+        controller->UpdateLeds(std::vector<RGBColor>(colors));
+    }
+}
+
+void RGBController_AsusROGAlly::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AsusROGAlly::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AsusROGAlly::DeviceUpdateMode()
+{
+    if(modes[active_mode].value == ROG_ALLY_MODE_DIRECT)
+    {
+        DeviceUpdateLEDs();
+    }
+    else
+    {
+        unsigned int rog_ally_direction = ROG_ALLY_DIRECTION_RIGHT;
+
+        if((modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR) && (modes[active_mode].direction == MODE_DIRECTION_LEFT))
+        {
+            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);
+    }
+}
+
+void RGBController_AsusROGAlly::DeviceSaveMode()
+{
+    DeviceUpdateMode();
+    controller->SaveMode();
+}

Controllers/AsusAuraUSBController/RGBController_AsusROGAlly.h

@@ -0,0 +1,34 @@
+/*-----------------------------------------*\
+|  RGBController_AsusROGAlly.cpp            |
+|                                           |
+|  Generic RGB Interface for Asus ROG Ally  |
+|  controller driver                        |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/12/2023   |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AsusROGAllyController.h"
+
+class RGBController_AsusROGAlly : public RGBController
+{
+public:
+    RGBController_AsusROGAlly(ROGAllyController* controller_ptr);
+    ~RGBController_AsusROGAlly();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+    void        DeviceSaveMode();
+
+private:
+    ROGAllyController* controller;
+};

Controllers/AsusAuraUSBController/ROGStrixLC_Controller.cpp

@@ -23,7 +23,7 @@ ROGStrixLC_Controller::ROGStrixLC_Controller(hid_device* dev_handle, const char*
 
 ROGStrixLC_Controller::~ROGStrixLC_Controller()
 {
-    hid_close(dev);
+    // Device will close at AuraUSBController destructor
 }
 
 std::string ROGStrixLC_Controller::GetLocation()

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController.cpp

@@ -55,8 +55,8 @@ std::string AsusCerberusKeyboardController::GetSerialString()
 std::string AsusCerberusKeyboardController::GetVersion()
 {
     char versionstr[5];
-    snprintf(versionstr, 3, "%X", version);
-    return(std::string(versionstr, 3));
+    snprintf(versionstr, 5, "%X", version);
+    return(std::string(versionstr));
 }
 
 void AsusCerberusKeyboardController::SetProfile

Controllers/AsusTUFLaptopController/AsusTUFLaptopController.cpp

@@ -0,0 +1,330 @@
+#ifdef _WIN32
+
+#include "AsusTUFLaptopController.h"
+
+#include <Objbase.h>
+#include <setupapi.h>
+#include <comdef.h>
+#include <Wbemidl.h>
+
+#include <cstdint>
+#include <cstring>
+#include <cstdio>
+
+static bool coInitialized = 0;
+
+static GUID CLSID_GUID_DEVCLASS_SYSTEM = { 0x4D36E97D, 0xE325, 0x11CE, {0xBF, 0xC1, 0x08, 0x00, 0x2B, 0xE1, 0x03, 0x18 } };
+
+int AsusTUFLaptopController::checkWMIType()
+{
+    int n;
+    int v6;
+    int result = 0;
+    struct _SP_DEVINFO_DATA DeviceInfoData;
+    const int bufsize = 260;
+    wchar_t PropertyBuffer[bufsize];
+
+    HDEVINFO devinfo = SetupDiGetClassDevsW(&CLSID_GUID_DEVCLASS_SYSTEM, 0, 0, 2u);
+    if ( devinfo == HDEVINFO(-1) )
+    {
+        return 0;
+    }
+    n = 0;
+    DeviceInfoData.cbSize = sizeof(DeviceInfoData);
+
+    while ( SetupDiEnumDeviceInfo(devinfo, n, &DeviceInfoData) ) // Invalid buffer
+    {
+        if ( SetupDiGetDeviceRegistryPropertyW(devinfo,
+                                               &DeviceInfoData,
+                                               SPDRP_ENUMERATOR_NAME,
+                                               NULL,
+                                               PBYTE(PropertyBuffer),
+                                               sizeof(PropertyBuffer),
+                                               0) )
+        {
+            // If we found property "ACPI"
+            if(!wcscmp(PropertyBuffer, L"ACPI"))
+            {
+                memset(PropertyBuffer, 0, sizeof(PropertyBuffer));
+                if ( SetupDiGetDeviceInstanceIdW(devinfo, &DeviceInfoData, PropertyBuffer, bufsize, 0) )
+                {
+                    _wcsupr_s(PropertyBuffer, bufsize);
+                    if(wcsstr(PropertyBuffer, L"ACPI\\ATK0100"))
+                    {
+                        result = 1;
+                        break;
+                    }
+                    if(!wcscmp(PropertyBuffer, L"ACPI\\PNP0C14\\ATK"))
+                    {
+                        result = 2;
+                        break;
+                    }
+                }
+            }
+        }
+        ++n;
+    }
+    SetupDiDestroyDeviceInfoList(devinfo);
+    return result;
+}
+
+AsusTUFLaptopController::AsusTUFLaptopController()
+{
+    hDevice = CreateFileW(L"\\\\.\\ATKACPI", 0xC0000000, 3u, 0, 3u, 0, 0);
+}
+
+AsusTUFLaptopController* AsusTUFLaptopController::checkAndCreate()
+{
+    // This might cause issues when coInitialize() is used in multiple places
+    HRESULT init = CoInitializeEx(0, COINIT_APARTMENTTHREADED);
+    if ( init < 0 && init != 0x80010106 )
+        return 0;
+    coInitialized = 1;
+
+    int type = checkWMIType();
+    if ( type == 2 )
+    {
+        AsusTUFLaptopController* controller = new AsusTUFLaptopController();
+        if(controller->hDevice != HANDLE(-1))
+        {
+            return controller;
+        }
+        delete controller;
+    }
+    return nullptr;
+}
+
+AsusTUFLaptopController::~AsusTUFLaptopController()
+{
+    if ( hDevice && hDevice != HANDLE(-1) )
+    {
+        CloseHandle(hDevice);
+        hDevice = 0;
+    }
+    // This might cause issues when coInitialize() is used in multiple places
+    if ( coInitialized )
+    {
+        CoUninitialize();
+        coInitialized = 0;
+    }
+
+}
+
+bool AsusTUFLaptopController::deviceIoControlWrapper(const void *dataIn, int commandIndex, int dataSizeIn, void *dataOut, int *dataSizeOut)
+{
+    size_t BytesReturned;
+    const int bufsize = 1024;
+    char outBuffer[bufsize];
+
+    LPDWORD inBuffer = LPDWORD(malloc(dataSizeIn + 8));
+    inBuffer[0] = commandIndex;
+    inBuffer[1] = dataSizeIn;
+    memmove(inBuffer + 2, dataIn, dataSizeIn);
+    memset(outBuffer, 0, bufsize);
+    BytesReturned = 0;
+    bool result = DeviceIoControl(
+                hDevice,
+                0x22240Cu,
+                inBuffer,
+                dataSizeIn + 8,
+                outBuffer,
+                bufsize,
+                LPDWORD(&BytesReturned),
+                0);
+    if ( result )
+    {
+        if ( *dataSizeOut < BytesReturned )
+        {
+            BytesReturned = *dataSizeOut;
+        }
+        memmove(dataOut, outBuffer, BytesReturned);
+    }
+    free(inBuffer);
+    return result;
+}
+
+bool AsusTUFLaptopController::deviceControl(int a1, int a2)
+{
+    if ( hDevice && hDevice != HANDLE(-1) )
+    {
+        int data[2];
+        data[0] = a1;
+        data[1] = a2;
+        int result;
+        int outBufSize = 4;
+        if ( deviceIoControlWrapper(&data, 1398162756, 8, &result, &outBufSize) )
+        {
+            if(outBufSize < 4)
+            {
+                result = 0;
+            }
+            if ( result == 1 )
+            {
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
+bool AsusTUFLaptopController::deviceControl(int a1, int a2, int a3)
+{
+    unsigned int data[3];
+    data[0] = a1;
+    data[1] = a2;
+    data[2] = a3;
+    int outBuf;
+    int outBufSize = 4;
+
+    if ( hDevice && hDevice != HANDLE(-1) )
+    {
+        if ( deviceIoControlWrapper(data, 0x53564544, 12, &outBuf, &outBufSize) )
+        {
+            if(outBufSize < 4)
+            {
+                outBuf = 0;
+            }
+            if ( outBuf == 1 )
+            {
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
+bool AsusTUFLaptopController::getStatus(int a1, int *out)
+{
+    int status;
+    int statusSize = 4;
+
+    if ( !hDevice || hDevice == HANDLE(-1) || (!deviceIoControlWrapper(&a1, 1398035268, 4, &status, &statusSize)) )
+    {
+        return 0;
+    }
+    if(statusSize < 4)
+    {
+        status = 0;
+    }
+    *out = status;
+    return 1;
+}
+
+bool AsusTUFLaptopController::getStatusExtended(int a1, int a2, int *status1, int *status2, int* status3)
+{
+    int commandData[2];
+    commandData[0] = a1;
+    commandData[1] = a2;
+    int statusBuffer[3];
+    int statusSize = 12;
+
+    if ( hDevice && hDevice != HANDLE(-1)
+         && deviceIoControlWrapper(commandData, 1398035268, 8, statusBuffer, &statusSize) )
+    {
+        *status1 = statusBuffer[0];
+        *status2 = statusBuffer[1];
+        *status3 = statusBuffer[2];
+        return 1;
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+void AsusTUFLaptopController::setMode(unsigned char red,
+                                      unsigned char green,
+                                      unsigned char blue,
+                                      unsigned char mode,
+                                      unsigned char speed,
+                                      bool save)
+{
+
+    /*--------------------------------------------------------*\
+    | Use switch case since our speed values are magic numbers |
+    | Default to Medium/Normal speed                           |
+    \*--------------------------------------------------------*/
+    unsigned char speed_val;
+
+    switch(speed)
+    {
+    case(1):
+        speed_val = ASUS_WMI_KEYBOARD_SPEED_SLOW;
+        break;
+    default:
+    case(2):
+        speed_val = ASUS_WMI_KEYBOARD_SPEED_NORMAL;
+        break;
+    case(3):
+        speed_val = ASUS_WMI_KEYBOARD_SPEED_FAST;
+        break;
+    }
+
+
+    /*----------------------------------------------------------*\
+    | We need to use a magic value to save to firmware in order  |
+    | To persist reboots. Save is normal op with different magic |
+    \*---------------------------------------------------------*/
+    unsigned char save_val = ASUS_WMI_KEYBOARD_MAGIC_USE;
+
+    if (save)
+    {
+        save_val = ASUS_WMI_KEYBOARD_MAGIC_SAVE;
+    }
+
+    // B3 is store value
+    unsigned int high = save_val | (mode<<8) | (red<<16) | (green<<24);
+    unsigned int low  = blue | (speed_val<<8);
+
+    deviceControl(ASUS_WMI_DEVID_TUF_RGB_MODE, high, low);
+
+}
+
+unsigned char AsusTUFLaptopController::getBrightness()
+{
+    int backlight_state = 0;
+    getStatus(ASUS_WMI_DEVID_KBD_BACKLIGHT, &backlight_state);
+
+    /*----------------------------------------------*\
+    | Only lowest two bits indicate brightness level |
+    \*----------------------------------------------*/
+    return backlight_state & 0x7F;
+}
+
+void AsusTUFLaptopController::setBrightness(unsigned char brightness)
+{
+    /*-----------------------------------------------------*\
+    | Only calls in this format persistently set brightness |
+    \*-----------------------------------------------------*/
+    int ctrl_param = 0x80 | (brightness & 0x7F);
+    deviceControl(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param);
+}
+
+/*-----------------------------------------------------------*\
+| These settings will not persist a reboot unless save is set |
+\*-----------------------------------------------------------*/
+void AsusTUFLaptopController::setPowerState(bool boot,
+                                            bool awake,
+                                            bool sleep,
+                                            bool shutdown,
+                                            bool save)
+{
+    unsigned int state = 0xBD;
+
+    if (boot)     state = state | ASUS_WMI_KEYBOARD_POWER_BOOT;
+    if (awake)    state = state | ASUS_WMI_KEYBOARD_POWER_AWAKE;
+    if (sleep)    state = state | ASUS_WMI_KEYBOARD_POWER_SLEEP;
+    if (shutdown) state = state | ASUS_WMI_KEYBOARD_POWER_SHUTDOWN;
+
+    if (save)     state = state | ASUS_WMI_KEYBOARD_POWER_SAVE;
+
+    deviceControl(ASUS_WMI_DEVID_TUF_RGB_STATE, state);
+}
+
+void AsusTUFLaptopController::setFanMode(int mode)
+{
+    deviceControl(ASUS_WMI_DEVID_FAN_BOOST_MODE, mode);
+}
+
+
+#endif

Controllers/AsusTUFLaptopController/AsusTUFLaptopController.h

@@ -0,0 +1,82 @@
+#ifndef ASUSTUFLAPTOPCONTROLLER_H
+#define ASUSTUFLAPTOPCONTROLLER_H
+
+#ifdef _WIN32
+
+#include <windows.h>
+
+#define ASUS_WMI_DEVID_KBD_BACKLIGHT      0x00050021
+#define ASUS_WMI_DEVID_TUF_RGB_MODE       0x00100056
+#define ASUS_WMI_DEVID_TUF_RGB_STATE      0x00100057
+
+#define ASUS_WMI_DEVID_FAN_BOOST_MODE     0x00110018
+#define ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY 0x00120075
+
+#define ASUS_WMI_KEYBOARD_SPEED_SLOW      0xE1
+#define ASUS_WMI_KEYBOARD_SPEED_NORMAL    0xEB
+#define ASUS_WMI_KEYBOARD_SPEED_FAST      0xF5
+
+#define ASUS_WMI_KEYBOARD_SPEED_MIN       1
+#define ASUS_WMI_KEYBOARD_SPEED_MAX       3
+
+#define ASUS_WMI_KEYBOARD_MODE_STATIC     0x00
+#define ASUS_WMI_KEYBOARD_MODE_BREATHING  0x01
+#define ASUS_WMI_KEYBOARD_MODE_COLORCYCLE 0x02
+#define ASUS_WMI_KEYBOARD_MODE_STROBING   0x0A
+
+#define ASUS_WMI_KEYBOARD_BRIGHTNESS_MIN  0
+#define ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX  3
+
+#define ASUS_WMI_KEYBOARD_MAGIC_USE       0xB3
+#define ASUS_WMI_KEYBOARD_MAGIC_SAVE      0xB4
+
+#define ASUS_WMI_KEYBOARD_POWER_BOOT      0x03<<16
+#define ASUS_WMI_KEYBOARD_POWER_AWAKE     0x0C<<16
+#define ASUS_WMI_KEYBOARD_POWER_SLEEP     0x30<<16
+#define ASUS_WMI_KEYBOARD_POWER_SHUTDOWN  0xC0<<16
+
+#define ASUS_WMI_KEYBOARD_POWER_SAVE      0x01<<8
+
+#define ASUS_WMI_FAN_SPEED_NORMAL         0
+#define ASUS_WMI_FAN_SPEED_TURBO          1
+#define ASUS_WMI_FAN_SPEED_SILENT         2
+
+class AsusTUFLaptopController
+{
+private:
+    HANDLE hDevice;
+    static int checkWMIType();
+    AsusTUFLaptopController();
+
+    bool deviceIoControlWrapper(const void *dataIn, int commandIndex, int dataSizeIn, void *dataOut, int *dataSizeOut);
+    bool deviceControl(int a1, int a2);
+    bool deviceControl(int a1, int a2, int a3);
+    bool getStatus(int a1, int *out);
+    bool getStatusExtended(int a1, int a2, int *status1, int *status2, int* status3);
+
+public:
+    static AsusTUFLaptopController * checkAndCreate();
+    ~AsusTUFLaptopController();
+
+    void            setMode(unsigned char red,
+                            unsigned char green,
+                            unsigned char blue,
+                            unsigned char mode,
+                            unsigned char speed,
+                            bool save);
+
+    unsigned char   getBrightness();
+    void            setBrightness(unsigned char brightness);
+
+    void            setPowerState(bool boot,
+                                  bool awake,
+                                  bool sleep,
+                                  bool shutdown,
+                                  bool save);
+
+    void            setFanMode(int mode);
+};
+
+#endif
+
+#endif // ASUSTUFLAPTOPCONTROLLER_H

Controllers/AsusTUFLaptopController/AsusTUFLaptopLinuxDetect.cpp

@@ -25,4 +25,4 @@ static void DetectAsusTUFLaptopLinuxControllers()
     return;
 }
 
-REGISTER_DETECTOR("ASUS TUF Laptop Linux WMI", DetectAsusTUFLaptopLinuxControllers);
+REGISTER_DETECTOR("ASUS TUF Laptop", DetectAsusTUFLaptopLinuxControllers);

Controllers/AsusTUFLaptopController/AsusTUFLaptopWMIDetect.cpp

@@ -1,8 +1,8 @@
 #ifdef _WIN32
 
+#include "AsusTUFLaptopController.h"
 #include "RGBController_AsusTUFLaptopWMI.h"
 
-#include "acpiwmi.h"
 #include "Detector.h"
 #include "wmi.h"
 #include <string>
@@ -29,19 +29,21 @@ static void DetectAsusTUFLaptopWMIControllers()
         return;
     }
     std::string& name = systemProduct[0]["Name"];
+
     if(name.find("TUF Gaming") == name.npos)
     {
         return;
     }
 
-    if(AsWMI_Open())
+    AsusTUFLaptopController* controller = AsusTUFLaptopController::checkAndCreate();
+    if(controller)
     {
-        RGBController* new_controller = new RGBController_AsusTUFLaptopWMI();
-        ResourceManager::get()->RegisterRGBController(new_controller);
-        // Success! No more if's
-    }
-}   /* DetectFaustusControllers() */
+        RGBController* new_controller = new RGBController_AsusTUFLaptopWMI(controller);
 
-REGISTER_DETECTOR("TUF Laptop WMI", DetectAsusTUFLaptopWMIControllers);
+        ResourceManager::get()->RegisterRGBController(new_controller);
+    }
+}   /* DetectAsusTUFLaptopWMIControllers() */
+
+REGISTER_DETECTOR("ASUS TUF Laptop", DetectAsusTUFLaptopWMIControllers);
 
 #endif

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopWMI.cpp

@@ -2,12 +2,6 @@
 
 #include "RGBController_AsusTUFLaptopWMI.h"
 
-#include "acpiwmi.h"
-#include "ResourceManager.h"
-#include "Detector.h"
-#include "wmi.h"
-#include <string>
-
 using namespace std::chrono_literals;
 
 /**------------------------------------------------------------------*\
@@ -21,72 +15,91 @@ using namespace std::chrono_literals;
     @comment
 \*-------------------------------------------------------------------*/
 
-RGBController_AsusTUFLaptopWMI::RGBController_AsusTUFLaptopWMI()
+RGBController_AsusTUFLaptopWMI::RGBController_AsusTUFLaptopWMI(AsusTUFLaptopController* controller_ptr)
 {
-    name        = "ASUS TUF Keyboard";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "WMI Device";
-    location    = "\\\\.\\ATKACPI";
+    name                        = "ASUS TUF Keyboard";
+    vendor                      = "ASUS";
+    type                        = DEVICE_TYPE_KEYBOARD;
+    description                 = "WMI Device";
+    location                    = "\\\\.\\ATKACPI";
 
-    modes.resize(5);
-    modes[0].name       = "Direct";
-    modes[0].value      = 4;
-    modes[0].flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    modes[0].color_mode = MODE_COLORS_PER_LED;
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = ASUS_WMI_KEYBOARD_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Static.color_mode           = MODE_COLORS_PER_LED;
+    Static.brightness_max       = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
+    Static.brightness_min       = ASUS_WMI_KEYBOARD_BRIGHTNESS_MIN;
+    Static.brightness           = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
+    modes.push_back(Static);
 
-    modes[1].name       = "Static";
-    modes[1].value      = 0;
-    modes[1].flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    modes[1].color_mode = MODE_COLORS_PER_LED;
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = ASUS_WMI_KEYBOARD_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Breathing.color_mode        = MODE_COLORS_PER_LED;
+    Breathing.speed_min         = ASUS_WMI_KEYBOARD_SPEED_MIN;
+    Breathing.speed_max         = ASUS_WMI_KEYBOARD_SPEED_MAX;
+    Breathing.speed             = 2;
+    Breathing.brightness_max    = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
+    Breathing.brightness_min    = ASUS_WMI_KEYBOARD_BRIGHTNESS_MIN;
+    Breathing.brightness        = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
+    modes.push_back(Breathing);
 
-    modes[2].name       = "Breathing";
-    modes[2].value      = 1;
-    modes[2].flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    modes[2].speed_min  = 0;
-    modes[2].speed_max  = 2;
-    modes[2].color_mode = MODE_COLORS_PER_LED;
-    modes[2].speed      = 1;
+    mode ColorCycle;
+    ColorCycle.name             = "Color Cycle";
+    ColorCycle.value            = ASUS_WMI_KEYBOARD_MODE_COLORCYCLE;
+    ColorCycle.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    ColorCycle.color_mode       = MODE_COLORS_NONE;
+    ColorCycle.speed_min        = ASUS_WMI_KEYBOARD_SPEED_MIN;
+    ColorCycle.speed_max        = ASUS_WMI_KEYBOARD_SPEED_MAX;
+    ColorCycle.speed            = 2;
+    ColorCycle.brightness_max   = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
+    ColorCycle.brightness_min   = ASUS_WMI_KEYBOARD_BRIGHTNESS_MIN;
+    ColorCycle.brightness       = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
+    modes.push_back(ColorCycle);
 
-    modes[3].name       = "Color Cycle";
-    modes[3].value      = 2;
-    modes[3].flags      = MODE_FLAG_HAS_SPEED;
-    modes[3].speed_min  = 0;
-    modes[3].speed_max  = 2;
-    modes[3].color_mode = MODE_COLORS_NONE;
-    modes[3].speed      = 1;
-
-    modes[4].name       = "Strobe";
-    modes[4].value      = 0x0A;
-    modes[4].flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    modes[4].color_mode = MODE_COLORS_PER_LED;
+    mode Strobing;
+    Strobing.name               = "Strobing";
+    Strobing.value              = ASUS_WMI_KEYBOARD_MODE_STROBING;
+    Strobing.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Strobing.color_mode         = MODE_COLORS_PER_LED;
+    Strobing.brightness_max     = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
+    Strobing.brightness_min     = ASUS_WMI_KEYBOARD_BRIGHTNESS_MIN;
+    Strobing.brightness         = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
+    modes.push_back(Strobing);
 
     SetupZones();
+
+    controller = controller_ptr;
+
+    ReadConfiguration();
 }
 
 RGBController_AsusTUFLaptopWMI::~RGBController_AsusTUFLaptopWMI()
 {
-    AsWMI_Close();
+    delete controller;
 }
 
 void RGBController_AsusTUFLaptopWMI::SetupZones()
 {
     /*---------------------------------------------------------*\
-    | Set up zone                                               |
+    | Device only has one zone and one led                      |
     \*---------------------------------------------------------*/
-    zones.resize(1);
-    zones[0].type           = ZONE_TYPE_SINGLE;
-    zones[0].name           = "Keyboard Backlight zone";
-    zones[0].leds_min       = 1;
-    zones[0].leds_max       = 1;
-    zones[0].leds_count     = 1;
-    zones[0].matrix_map     = NULL;
+    zone* new_zone = new zone();
+    led*  new_led  = new led();
 
-    /*---------------------------------------------------------*\
-    | Set up LED                                                |
-    \*---------------------------------------------------------*/
-    leds.resize(1);
-    leds[0].name = "Keyboard Backlight LED";
+    new_zone->type           = ZONE_TYPE_SINGLE;
+    new_zone->name           = "Keyboard Backlight zone";
+    new_zone->leds_min       = 1;
+    new_zone->leds_max       = 1;
+    new_zone->leds_count     = 1;
+    new_zone->matrix_map     = NULL;
+
+    new_led->name            = "Keyboard Backlight LED";
+
+    zones.push_back(*new_zone);
+    leds.push_back(*new_led);
 
     SetupColors();
 }
@@ -98,52 +111,66 @@ void RGBController_AsusTUFLaptopWMI::ResizeZone(int /*zone*/, int /*new_size*/)
     \*---------------------------------------------------------*/
 }
 
+/*---------------------------------------------------------*\
+| Break this function off since we have to call save in the |
+  same operation as doing everything else.                  |
+\*---------------------------------------------------------*/
+void RGBController_AsusTUFLaptopWMI::ControllerSetMode(bool save)
+{
+    unsigned char red   = RGBGetRValue(colors[0]);
+    unsigned char green = RGBGetGValue(colors[0]);
+    unsigned char blue  = RGBGetBValue(colors[0]);
+
+    unsigned char mode  = (unsigned char)modes[(unsigned int)active_mode].value;
+
+    /*------------------------------------------------------------*\
+    | Use speed only if the mode supports it. Otherwise set normal |
+    \*------------------------------------------------------------*/
+    unsigned char speed = ASUS_WMI_KEYBOARD_SPEED_NORMAL;
+
+    if (modes[(unsigned int)active_mode].flags & MODE_FLAG_HAS_SPEED)
+    {
+        speed = (unsigned char)modes[(unsigned int)active_mode].speed;
+    }
+
+    controller->setMode(red, green, blue, mode, speed, save);
+}
+
 void RGBController_AsusTUFLaptopWMI::DeviceUpdateLEDs()
 {
-    uint8_t red   = RGBGetRValue(colors[0]);
-    uint8_t green = RGBGetGValue(colors[0]);
-    uint8_t blue  = RGBGetBValue(colors[0]);
-    uint8_t speed_byte = 0;
-    uint8_t mode = modes[active_mode].value;
-    uint8_t inv = 0;
-    if(mode == 4)
-    {
-        mode = 1;
-        inv = 4; // Any invalid mode, i.e. anything other than 0, 1, 2 and 10
-    }
-    if(mode == 1 || mode == 2)
-    {
-        switch(modes[active_mode].speed)
-        {
-        case 0: speed_byte = 0xE1; break;
-        case 1: speed_byte = 0xEB; break;
-        case 2: speed_byte = 0xF5; break;
-        }
-    }
-    int high = ((mode | ((red | (green << 8)) << 8)) << 8) | 0xB3;
-    int low = blue | (speed_byte << 8);
-    AsWMI_NB_DeviceControl_2arg(0x100056, high, low);
-    if(inv)
-    {
-        //std::this_thread::sleep_for(10ms);
-        high = ((inv | ((red | (green << 8)) << 8)) << 8) | 0xB3;
-        AsWMI_NB_DeviceControl_2arg(0x100056, high, low);
-    }
+    ControllerSetMode(false);
 }
 
 void RGBController_AsusTUFLaptopWMI::UpdateZoneLEDs(int /*zone*/)
 {
-    DeviceUpdateLEDs();
+    ControllerSetMode(false);
 }
 
 void RGBController_AsusTUFLaptopWMI::UpdateSingleLED(int /*led*/)
 {
-    DeviceUpdateLEDs();
+    ControllerSetMode(false);
 }
 
 void RGBController_AsusTUFLaptopWMI::DeviceUpdateMode()
 {
-    DeviceUpdateLEDs();
+    if (modes[(unsigned int)active_mode].flags & MODE_FLAG_HAS_BRIGHTNESS)
+    {
+        controller->setBrightness((unsigned char)modes[(unsigned int)active_mode].brightness);
+    }
+    ControllerSetMode(false);
+}
+
+void RGBController_AsusTUFLaptopWMI::ReadConfiguration()
+{
+    if (modes[(unsigned int)active_mode].flags & MODE_FLAG_HAS_BRIGHTNESS)
+    {
+        modes[(unsigned int)active_mode].brightness = controller->getBrightness();
+    }
+}
+
+void RGBController_AsusTUFLaptopWMI::DeviceSaveMode()
+{
+    ControllerSetMode(true);
 }
 
 #endif

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopWMI.h

@@ -1,27 +1,35 @@
+#ifdef _WIN32
+
 #ifndef RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
 #define RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
 
-#ifdef _WIN32
-
+#include "AsusTUFLaptopController.h"
 #include "RGBController.h"
 
 class RGBController_AsusTUFLaptopWMI : public RGBController
 {
 public:
-    RGBController_AsusTUFLaptopWMI();
+    RGBController_AsusTUFLaptopWMI(AsusTUFLaptopController* controller_ptr);
     virtual ~RGBController_AsusTUFLaptopWMI();
 
-    void SetupZones() override;
+    void SetupZones();
 
-    void ResizeZone(int zone, int new_size) override;
+    void ResizeZone(int zone, int new_size);
 
-    void DeviceUpdateLEDs() override;
-    void UpdateZoneLEDs(int zone) override;
-    void UpdateSingleLED(int led) override;
+    void DeviceUpdateLEDs();
+    void UpdateZoneLEDs(int zone);
+    void UpdateSingleLED(int led);
 
-    void DeviceUpdateMode() override;
+    void DeviceUpdateMode();
+    void DeviceSaveMode();
+
+private:
+    AsusTUFLaptopController* controller;
+
+    void ReadConfiguration();
+    void ControllerSetMode(bool save);
 };
 
-#endif
-
 #endif // RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
+
+#endif // _WIN32

Controllers/CherryKeyboardController/CherryKeyboardController.cpp

@@ -0,0 +1,262 @@
+/*-----------------------------------------*\
+|  CherryKeyboardController.cpp             |
+|                                           |
+|  Driver for Cherry RGB keyboard lighting  |
+|  controller                               |
+|                                           |
+|  Sebastian Kraus 12/25/2021               |
+\*-----------------------------------------*/
+
+#include "CherryKeyboardController.h"
+
+#include <cstring>
+
+CherryKeyboardController::CherryKeyboardController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+CherryKeyboardController::~CherryKeyboardController()
+{
+    hid_close(dev);
+}
+
+std::string CherryKeyboardController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string CherryKeyboardController::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 CherryKeyboardController::SetKeyboardColors
+    (
+    unsigned char *     color_data,
+    unsigned int        size
+    )
+{
+    unsigned int    packet_size = 0;
+    unsigned int    packet_offset = 0;
+
+    while(size > 0)
+    {
+        if(size >= CHERRY_KB_MAX_PACKET_SIZE)
+        {
+            packet_size     = CHERRY_KB_MAX_PACKET_SIZE;
+        }
+        else
+        {
+            packet_size     = size;
+        }
+        
+        SendKeyboardData
+            (
+            &color_data[packet_offset],
+            packet_size,
+            packet_offset
+            );
+
+        size           -= packet_size;
+        packet_offset  += packet_size;
+    }
+}
+
+void CherryKeyboardController::SendKeyboardMode
+    (
+    unsigned char       mode
+    )
+{
+    SendKeyboardParameter(CHERRY_KB_PARAMETER_MODE, 1, &mode);
+}
+
+void CherryKeyboardController::SendKeyboardModeEx
+    (
+    unsigned char       mode,
+    unsigned char       brightness,
+    unsigned char       speed,
+    unsigned char       direction,
+    unsigned char       random_flag,
+    unsigned char       red,
+    unsigned char       green,
+    unsigned char       blue
+    )
+{
+    unsigned char parameter_data[8];
+
+    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;
+
+    SendKeyboardParameter(0, 8, parameter_data);
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void CherryKeyboardController::ComputeChecksum
+    (
+    char                usb_buf[CHERRY_KB_PACKET_SIZE]
+    )
+{
+    unsigned short checksum = 0;
+
+    for(unsigned int byte_idx = 0x03; byte_idx < CHERRY_KB_PACKET_SIZE; byte_idx++)
+    {
+        checksum += usb_buf[byte_idx];
+    }
+
+    usb_buf[0x01] = checksum & 0xFF;
+    usb_buf[0x02] = checksum >> 8;
+}
+
+void CherryKeyboardController::SendKeyboardBegin()
+{
+    unsigned char usb_buf[CHERRY_KB_PACKET_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Keyboard Begin (0x01) packet                   |
+    |   Note: Not computing checksum as packet contents are |
+    |         fixed                                         |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x04;
+    usb_buf[0x01]           = CHERRY_KB_COMMAND_BEGIN;
+    usb_buf[0x02]           = 0x00;
+    usb_buf[0x03]           = CHERRY_KB_COMMAND_BEGIN;
+    
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, CHERRY_KB_PACKET_SIZE);
+    hid_read(dev, usb_buf, CHERRY_KB_PACKET_SIZE);
+}
+
+void CherryKeyboardController::SendKeyboardEnd()
+{
+    char usb_buf[CHERRY_KB_PACKET_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Keyboard End (0x02) packet                     |
+    |   Note: Not computing checksum as packet contents are |
+    |         fixed                                         |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x04;
+    usb_buf[0x01]           = CHERRY_KB_COMMAND_END;
+    usb_buf[0x02]           = 0x00;
+    usb_buf[0x03]           = CHERRY_KB_COMMAND_END;
+    
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
+    hid_read(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
+}
+
+void CherryKeyboardController::SendKeyboardData
+    (
+    unsigned char *     data,
+    unsigned char       data_size,
+    unsigned short      data_offset
+    )
+{
+    char usb_buf[CHERRY_KB_PACKET_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Keyboard Color Data (0x0B) packet              |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x04;
+    usb_buf[0x03]           = CHERRY_KB_COMMAND_WRITE_CUSTOM_COLOR_DATA;
+
+    usb_buf[0x04]           = data_size;
+    usb_buf[0x05]           = data_offset & 0x00FF;
+    usb_buf[0x06]           = data_offset >> 8;
+
+    /*-----------------------------------------------------*\
+    | Copy in data bytes                                    |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x08], data, data_size);
+    
+    /*-----------------------------------------------------*\
+    | Compute Checksum                                      |
+    \*-----------------------------------------------------*/
+    ComputeChecksum(usb_buf);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
+    hid_read(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
+}
+
+void CherryKeyboardController::SendKeyboardParameter
+    (
+    unsigned char       parameter,
+    unsigned char       parameter_size,
+    unsigned char*      parameter_data
+    )
+{
+    char usb_buf[CHERRY_KB_PACKET_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Keyboard Parameter (0x06) packet               |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x04;
+    usb_buf[0x03]           = CHERRY_KB_COMMAND_SET_PARAMETER;
+    usb_buf[0x04]           = parameter_size;
+    usb_buf[0x05]           = parameter;
+
+    /*-----------------------------------------------------*\
+    | Copy in data bytes                                    |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x09], parameter_data, parameter_size);
+
+    /*-----------------------------------------------------*\
+    | Compute Checksum                                      |
+    \*-----------------------------------------------------*/
+    ComputeChecksum(usb_buf);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
+    hid_read(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
+}

Controllers/CherryKeyboardController/CherryKeyboardController.h

@@ -0,0 +1,150 @@
+/*-----------------------------------------*\
+|  CherryKeyboardController.h               |
+|                                           |
+|  Definitions and types for Cherry RGB     |
+|  keyboard lighting controller             |
+|                                           |
+|  Sebastian Kraus 12/25/2021               |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+#define CHERRY_KB_PACKET_SIZE                        64
+#define CHERRY_KB_MAX_PACKET_SIZE                  ( 0x36 )/* max packet size for color*/
+                                                            /* update packets           */
+enum
+{
+    CHERRY_KB_COMMAND_BEGIN                        = 0x01, /* Begin packet command     */
+    CHERRY_KB_COMMAND_END                          = 0x02, /* End packet command       */
+    CHERRY_KB_COMMAND_SET_PARAMETER                = 0x06, /* Set parameter command    */
+    CHERRY_KB_COMMAND_READ_CUSTOM_COLOR_DATA       = 0x1B, /* Read custom color data   */
+    CHERRY_KB_COMMAND_WRITE_CUSTOM_COLOR_DATA      = 0x0B, /* Write custom color data  */
+};
+
+enum
+{
+    CHERRY_KB_PARAMETER_MODE                       = 0x00, /* Mode parameter           */
+    CHERRY_KB_PARAMETER_BRIGHTNESS                 = 0x01, /* Brightness parameter     */
+    CHERRY_KB_PARAMETER_SPEED                      = 0x02, /* Speed parameter          */
+    CHERRY_KB_PARAMETER_DIRECTION                  = 0x03, /* Direction parameter      */
+    CHERRY_KB_PARAMETER_RANDOM_COLOR_FLAG          = 0x04, /* Random color parameter   */
+    CHERRY_KB_PARAMETER_MODE_COLOR                 = 0x05, /* Mode color (RGB)         */
+    CHERRY_KB_PARAMETER_POLLING_RATE               = 0x0F, /* Polling rate             */
+    CHERRY_KB_PARAMETER_SURMOUNT_MODE_COLOR        = 0x11, /* Surmount mode color      */
+};
+
+enum
+{
+    CHERRY_KB_MODE_WAVE                            = 0x00,
+    CHERRY_KB_MODE_SPECTRUM                        = 0x01,
+    CHERRY_KB_MODE_BREATHING                       = 0x02,
+    CHERRY_KB_MODE_STATIC                          = 0x03,
+    CHERRY_KB_MODE_RADAR                           = 0x04,
+    CHERRY_KB_MODE_VORTEX                          = 0x05,
+    CHERRY_KB_MODE_FIRE                            = 0x06,
+    CHERRY_KB_MODE_STARS                           = 0x07,
+    CHERRY_KB_MODE_CUSTOM                          = 0x08,
+    CHERRY_KB_MODE_ROLLING                         = 0x0A,
+    CHERRY_KB_MODE_RAIN                            = 0x0B,
+    CHERRY_KB_MODE_CURVE                           = 0x0C,
+    CHERRY_KB_MODE_WAVE_MID                        = 0x0E,
+    CHERRY_KB_MODE_SCAN                            = 0x0F,
+    CHERRY_KB_MODE_RADIATION                       = 0x12,
+    CHERRY_KB_MODE_RIPPLES                         = 0x13,
+    CHERRY_KB_MODE_SINGLE_KEY                      = 0x15,
+    
+};
+
+enum
+{
+    CHERRY_KB_BRIGHTNESS_LOWEST                    = 0x00, /* Lowest brightness (off)  */
+    CHERRY_KB_BRIGHTNESS_HIGHEST                   = 0x04, /* Highest brightness       */
+};
+
+enum
+{
+    CHERRY_KB_SPEED_SLOWEST                        = 0x04, /* Slowest speed setting    */
+    CHERRY_KB_SPEED_NORMAL                         = 0x02, /* Normal speed setting     */
+    CHERRY_KB_SPEED_FASTEST                        = 0x00, /* Fastest speed setting    */
+};
+
+enum
+{
+    CHERRY_KB_SURMOUNT_MODE_COLOR_RED              = 0x01, /* Red surmount color       */
+    CHERRY_KB_SURMOUNT_MODE_COLOR_YELLOW           = 0x02, /* Yellow surmount color    */
+    CHERRY_KB_SURMOUNT_MODE_COLOR_GREEN            = 0x03, /* Green surmount color     */
+    CHERRY_KB_SURMOUNT_MODE_COLOR_BLUE             = 0x04, /* Blue surmount color      */
+};
+
+enum
+{
+    CHERRY_KB_POLLING_RATE_125HZ                   = 0x00, /* 125Hz polling rate       */
+    CHERRY_KB_POLLING_RATE_250HZ                   = 0x01, /* 250Hz polling rate       */
+    CHERRY_KB_POLLING_RATE_500HZ                   = 0x02, /* 500Hz polling rate       */
+    CHERRY_KB_POLLING_RATE_1000HZ                  = 0x03, /* 1000Hz polling rate      */
+};
+
+class CherryKeyboardController
+{
+public:
+    CherryKeyboardController(hid_device* dev_handle, const char* path);
+    ~CherryKeyboardController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void        SetKeyboardColors
+                    (
+                    unsigned char *     color_data,
+                    unsigned int        size
+                    );
+
+    void        SendKeyboardBegin();
+
+    void        SendKeyboardMode
+                    (
+                    unsigned char       mode
+                    );
+
+    void        SendKeyboardModeEx
+                    (
+                    unsigned char       mode,
+                    unsigned char       brightness,
+                    unsigned char       speed,
+                    unsigned char       direction,
+                    unsigned char       random_flag,
+                    unsigned char       red,
+                    unsigned char       green,
+                    unsigned char       blue
+                    );
+
+    void        SendKeyboardData
+                    (
+                    unsigned char *     data,
+                    unsigned char       data_size,
+                    unsigned short      data_offset
+                    );
+
+    void        SendKeyboardEnd();
+
+private:
+    hid_device*             dev;
+    std::string             location;
+
+    void        ComputeChecksum
+                    (
+                    char                usb_buf[CHERRY_KB_PACKET_SIZE]
+                    );
+
+    void        SendKeyboardParameter
+                    (
+                    unsigned char       parameter,
+                    unsigned char       parameter_size,
+                    unsigned char*      parameter_data
+                    );
+};

Controllers/CherryKeyboardController/CherryKeyboardControllerDetect.cpp

@@ -0,0 +1,80 @@
+#include "Detector.h"
+#include "CherryKeyboardController.h"
+#include "RGBController.h"
+#include "RGBController_CherryKeyboard.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+/*-----------------------------------------------------*\
+| Keyboard product IDs                                  |
+\*-----------------------------------------------------*/
+#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
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectCherryKeyboards                                                                 *
+*                                                                                          *
+*       Tests the USB address to see if an Cherry RGB Keyboard controller exists there.   *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectCherryKeyboards(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
+    {
+        CherryKeyboardController* controller = new CherryKeyboardController(dev, info->path);
+        RGBController_CherryKeyboard* rgb_controller = new RGBController_CherryKeyboard(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+/*---------------------------------------------------------------------------------------------------------------------------------------------*\
+| Keyboards                                                                                                                                     |
+\*---------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 3.0S FL NBL",        DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_3_0S_FL_NBL_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 3.0S FL RGB",        DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_3_0S_FL_RGB_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 3.0S FL RGB KOREAN", DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_3_0S_FL_RGB_KOR_PID, 1, CHERRY_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX 1.0 FL BL",                DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_1_0_FL_BL_PID            , 1, CHERRY_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 1.0 TKL RGB",        DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_1_0_TKL_RGB_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 8.0 TKL RGB",        DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_8_0_TKL_RGB_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 10.0 FL RGB",        DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_10_0_FL_RGB_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000 TKL NBL",            DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   G80_3000_TKL_NBL_PID        , 1, CHERRY_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 2.0S FL RGB",        DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_2_0S_FL_RGB_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000 TKL RGB",            DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   G80_3000_TKL_RGB_PID        , 1, CHERRY_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Cherry Keyboard MV BOARD 3.0 FL RGB",         DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MV_BOARD_3_0FL_RGB_PID      , 1, CHERRY_KEYBOARD_USAGE_PAGE);
+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 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 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

@@ -0,0 +1,358 @@
+/*-----------------------------------------*\
+|  RGBController_CherryKeyboard.cpp         |
+|                                           |
+|  Generic RGB Interface for Cherry RGB     |
+|  Keyboard                                 |
+|                                           |
+|  Sebastian Kraus 12/25/2021               |
+\*-----------------------------------------*/
+
+#include "RGBController_CherryKeyboard.h"
+
+//0xFFFFFFFF indicates an unused entry in matrix
+#define NA  0xFFFFFFFF
+
+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 } };
+
+/**------------------------------------------------------------------*\
+    @name Cherry Keyboard
+    @category Keyboard
+    @type USB
+    @save :robot:
+    @direct :rotating_light:
+    @effects :white_check_mark:
+    @detectors DetectCherryKeyboards
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_CherryKeyboard::RGBController_CherryKeyboard(CherryKeyboardController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "Cherry Keyboard Device";
+    vendor      = "Cherry";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "Cherry Keyboard Device";
+    location    = controller->GetDeviceLocation();
+    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;
+    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.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.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.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.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.colors.resize(1);
+    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.colors.resize(1);
+    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.colors.resize(1);
+    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.colors.resize(1);
+    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.colors.resize(1);
+    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;
+    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.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.colors.resize(1);
+    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.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.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.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.colors.resize(1);
+    modes.push_back(SingleKey);
+
+    SetupZones();
+}
+
+RGBController_CherryKeyboard::~RGBController_CherryKeyboard()
+{
+    /*---------------------------------------------------------*\
+    | 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_CherryKeyboard::SetupZones()
+{
+    zone new_zone;
+
+    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.matrix_map         = new matrix_map_type;
+    new_zone.matrix_map->height = 6;
+    new_zone.matrix_map->width  = 23;
+    new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+    
+    zones.push_back(new_zone);
+
+    for(int led_idx = 0; led_idx < 126; led_idx++)
+    {
+        led new_led;
+
+        new_led.name = "Keyboard LED ";
+        new_led.name.append(std::to_string(led_idx));
+
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_CherryKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_CherryKeyboard::DeviceUpdateLEDs()
+{
+    unsigned char color_data[7*CHERRY_KB_MAX_PACKET_SIZE];
+
+    for(int led_idx = 0; led_idx < 126; led_idx++)
+    {
+        color_data[(3 * led_idx) + 0] = RGBGetRValue(colors[led_idx]);
+        color_data[(3 * led_idx) + 1] = RGBGetGValue(colors[led_idx]);
+        color_data[(3 * led_idx) + 2] = RGBGetBValue(colors[led_idx]);
+    }
+
+    controller->SetKeyboardColors
+                    (
+                    color_data,
+                    CHERRY_KB_MAX_PACKET_SIZE * 7
+                    );
+}
+
+void RGBController_CherryKeyboard::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CherryKeyboard::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CherryKeyboard::SetCustomMode()
+{
+
+}
+
+void RGBController_CherryKeyboard::DeviceUpdateMode()
+{
+    unsigned char red    = 0x00;
+    unsigned char grn    = 0x00;
+    unsigned char blu    = 0x00;
+    unsigned char random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+
+    if(modes[active_mode].colors.size() > 0)
+    {
+        red = RGBGetRValue(modes[active_mode].colors[0]);
+        grn = RGBGetGValue(modes[active_mode].colors[0]);
+        blu = RGBGetBValue(modes[active_mode].colors[0]);
+    }
+
+    controller->SendKeyboardModeEx
+                    (
+                    modes[active_mode].value,
+                    CHERRY_KB_BRIGHTNESS_HIGHEST,
+                    modes[active_mode].speed,
+                    0,
+                    random,
+                    red,
+                    grn,
+                    blu
+                    );
+}

Controllers/CherryKeyboardController/RGBController_CherryKeyboard.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_CherryKeyboard.h           |
+|                                           |
+|  Generic RGB Interface for Cherry RGB     |
+|  Keyboard                                 |
+|                                           |
+|  Sebastian Kraus 12/25/2021               |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "CherryKeyboardController.h"
+
+class RGBController_CherryKeyboard : public RGBController
+{
+public:
+    RGBController_CherryKeyboard(CherryKeyboardController* controller_ptr);
+    ~RGBController_CherryKeyboard();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+    
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    CherryKeyboardController*  controller;
+};

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -37,10 +37,16 @@ void DetectColorfulGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
     }
 }
 
-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 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 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 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 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_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 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 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);

Controllers/ColorfulTuringGPUController/ColorfulTuringGPUController.cpp

@@ -0,0 +1,144 @@
+#include "ColorfulTuringGPUController.h"
+#include <cstring>
+
+ColorfulTuringGPUController::ColorfulTuringGPUController(i2c_smbus_interface* bus, colorful_gpu_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+}
+
+ColorfulTuringGPUController::~ColorfulTuringGPUController()
+{
+
+}
+
+std::string ColorfulTuringGPUController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+int ColorfulTuringGPUController::GetMode()
+{
+    uint8_t data_pkt[COLORFUL_MODE_PACKET_LENGTH];
+    int size = COLORFUL_MODE_PACKET_LENGTH;
+    bus->i2c_read_block(dev, &size, data_pkt);
+
+    int mode = data_pkt[2]<<16 | data_pkt[3]<<8 | data_pkt[4];
+
+    return mode;
+}
+
+RGBColor ColorfulTuringGPUController::GetColor()
+{
+    uint8_t data_pkt[COLORFUL_MODE_PACKET_LENGTH];
+    int size = COLORFUL_MODE_PACKET_LENGTH;
+    bus->i2c_read_block(dev, &size, data_pkt);
+
+    RGBColor color = ToRGBColor(data_pkt[5], data_pkt[6], data_pkt[7]);
+
+    return color;
+}
+
+void ColorfulTuringGPUController::SetStateDisplay(RGBColor color)
+{
+    uint8_t r = RGBGetRValue(color);
+    uint8_t g = RGBGetGValue(color);
+    uint8_t b = RGBGetBValue(color);
+    uint8_t data_pkt[COLORFUL_COLOR_PACKET_LENGTH] = { 0x08, 0x01, 0x32, 0x04, r, g, b};
+
+    int crc = 1;
+
+    for(int i = 0; i < COLORFUL_COLOR_PACKET_LENGTH - 1; ++i)
+    {
+        crc += data_pkt[i];
+    }
+    crc &= 0xFF;
+    crc = 256-crc;
+
+    data_pkt[COLORFUL_COLOR_PACKET_LENGTH - 1] = crc & 0xFF;
+
+    bus->i2c_write_block(dev, COLORFUL_COLOR_PACKET_LENGTH, data_pkt);
+}
+
+void ColorfulTuringGPUController::SetDirect(RGBColor color)
+{
+    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};
+
+    int crc = 1;
+
+    for(int i = 0; i < COLORFUL_COLOR_PACKET_LENGTH - 1; ++i)
+    {
+        crc += data_pkt[i];
+    }
+    crc &= 0xFF;
+    crc = 256-crc;
+
+    data_pkt[COLORFUL_COLOR_PACKET_LENGTH - 1] = crc & 0xFF;
+
+    bus->i2c_write_block(dev, COLORFUL_COLOR_PACKET_LENGTH, data_pkt);
+}
+
+void ColorfulTuringGPUController::SetBreathing(RGBColor color)
+{
+    uint8_t r = RGBGetRValue(color);
+    uint8_t g = RGBGetGValue(color);
+    uint8_t b = RGBGetBValue(color);
+    uint8_t data_pkt[COLORFUL_COLOR_PACKET_LENGTH] = { 0x88, 0x01, 0x32, 0x02, r, g, b};
+
+    int crc = 1;
+
+    for(int i = 0; i < COLORFUL_COLOR_PACKET_LENGTH - 1; ++i)
+    {
+        crc += data_pkt[i];
+    }
+    crc &= 0xFF;
+    crc = 256-crc;
+
+    data_pkt[COLORFUL_COLOR_PACKET_LENGTH - 1] = crc & 0xFF;
+
+    bus->i2c_write_block(dev, COLORFUL_COLOR_PACKET_LENGTH, data_pkt);
+}
+
+void ColorfulTuringGPUController::SetOff()
+{
+    uint8_t data_pkt[COLORFUL_NON_COLOR_PACKET_LENGTH] = { 0x85, 0x00, 0x00, 0x0A };
+
+    int crc = 1;
+
+    for(int i = 0; i < COLORFUL_NON_COLOR_PACKET_LENGTH - 1; ++i)
+    {
+        crc += data_pkt[i];
+    }
+    crc &= 0xFF;
+    crc = 256-crc;
+
+    data_pkt[COLORFUL_NON_COLOR_PACKET_LENGTH - 1] = crc & 0xFF;
+
+    bus->i2c_write_block(dev, COLORFUL_NON_COLOR_PACKET_LENGTH, data_pkt);
+}
+
+void ColorfulTuringGPUController::SetRainbow()
+{
+    uint8_t data_pkt[COLORFUL_NON_COLOR_PACKET_LENGTH] = { 0x85, 0x04, 0x32, 0x02 };
+
+    int crc = 1;
+
+    for(int i = 0; i < COLORFUL_NON_COLOR_PACKET_LENGTH - 1; ++i)
+    {
+        crc += data_pkt[i];
+    }
+    crc &= 0xFF;
+    crc = 256-crc;
+
+    data_pkt[COLORFUL_NON_COLOR_PACKET_LENGTH - 1] = crc & 0xFF;
+
+    bus->i2c_write_block(dev, COLORFUL_NON_COLOR_PACKET_LENGTH, data_pkt);
+}

Controllers/ColorfulTuringGPUController/ColorfulTuringGPUController.h

@@ -0,0 +1,41 @@
+#include <string>
+#include "i2c_smbus.h"
+#include "RGBController.h"
+
+#pragma once
+
+typedef unsigned char colorful_gpu_dev_id;
+
+#define COLORFUL_COLOR_PACKET_LENGTH 8
+#define COLORFUL_NON_COLOR_PACKET_LENGTH 5
+#define COLORFUL_MODE_PACKET_LENGTH 0x1B
+
+enum
+{
+    COLORFUL_TURING_GPU_RGB_MODE_STATE_DISPLAY      = 0x013204,
+    COLORFUL_TURING_GPU_RGB_MODE_OFF                = 0x00000A,
+    COLORFUL_TURING_GPU_RGB_MODE_STATIC             = 0x023202,
+    COLORFUL_TURING_GPU_RGB_MODE_RAINBOW            = 0x043202,
+    COLORFUL_TURING_GPU_RGB_MODE_BREATHING          = 0x013202,
+};
+
+class ColorfulTuringGPUController
+{
+public:
+    ColorfulTuringGPUController(i2c_smbus_interface* bus, colorful_gpu_dev_id dev);
+    ~ColorfulTuringGPUController();
+
+    std::string             GetDeviceLocation();
+    int                     GetMode();
+    RGBColor                GetColor();
+    void                    SetDirect(RGBColor color);
+    void                    SetStateDisplay(RGBColor color);
+    void                    SetBreathing(RGBColor color);
+    void                    SetOff();
+    void                    SetRainbow();
+
+
+private:
+    i2c_smbus_interface *   bus;
+    colorful_gpu_dev_id     dev;
+};

Controllers/ColorfulTuringGPUController/ColorfulTuringGPUControllerDetect.cpp

@@ -0,0 +1,23 @@
+#include "Detector.h"
+#include "ColorfulTuringGPUController.h"
+#include "RGBController.h"
+#include "RGBController_ColorfulTuringGPU.h"
+#include "i2c_smbus.h"
+#include "pci_ids.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+void DetectColorfulTuringGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+{
+    if(bus->port_id == 1)
+    {
+        ColorfulTuringGPUController* controller         = new ColorfulTuringGPUController(bus, i2c_addr);
+        RGBController_ColorfulTuringGPU* rgb_controller = new RGBController_ColorfulTuringGPU(controller);
+        rgb_controller->name                            = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+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);

Controllers/ColorfulTuringGPUController/RGBController_ColorfulTuringGPU.cpp

@@ -0,0 +1,145 @@
+#include "RGBController_ColorfulTuringGPU.h"
+#include <array>
+
+/**------------------------------------------------------------------*\
+    @name Colorful GPU
+    @category GPU
+    @type I2C
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectColorfulTuringGPUControllers
+    @comment This card supports off, direct, rainbow and pulse mode.
+\*-------------------------------------------------------------------*/
+
+RGBController_ColorfulTuringGPU::RGBController_ColorfulTuringGPU(ColorfulTuringGPUController * colorful_gpu_ptr)
+{
+    controller              = colorful_gpu_ptr;
+    name                    = "Colorful GPU Device";
+    vendor                  = "Colorful";
+    type                    = DEVICE_TYPE_GPU;
+    description             = name;
+    location                = controller->GetDeviceLocation();
+
+    mode Off;
+    Off.name                = "Off";
+    Off.value               = COLORFUL_TURING_GPU_RGB_MODE_OFF;
+    Off.flags               = 0;
+    Off.color_mode          = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Direct;
+    Direct.name             = "Direct";
+    Direct.value            = COLORFUL_TURING_GPU_RGB_MODE_STATIC;
+    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode StateDisplay;
+    StateDisplay.name       = "State Display";
+    StateDisplay.value      = COLORFUL_TURING_GPU_RGB_MODE_STATE_DISPLAY;
+    StateDisplay.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    StateDisplay.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(StateDisplay);
+
+    mode Rainbow;
+    Rainbow.name            = "Spectrum Cycle";
+    Rainbow.value           = COLORFUL_TURING_GPU_RGB_MODE_RAINBOW;
+    Rainbow.color_mode      = MODE_COLORS_NONE;
+    modes.push_back(Rainbow);
+
+    mode Breathing;
+    Breathing.name          = "Breathing";
+    Breathing.value         = COLORFUL_TURING_GPU_RGB_MODE_BREATHING;
+    Breathing.flags         = MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.color_mode    = MODE_COLORS_PER_LED;
+    modes.push_back(Breathing);
+
+    SetupZones();
+
+    // Initialize active mode
+    active_mode             = getModeIndex(controller->GetMode());
+    colors[0]               = controller->GetColor();
+
+}
+
+RGBController_ColorfulTuringGPU::~RGBController_ColorfulTuringGPU()
+{
+    delete controller;
+}
+
+int RGBController_ColorfulTuringGPU::getModeIndex(int mode_value)
+{
+    for(std::size_t mode_index = 0; mode_index < modes.size(); mode_index++)
+    {
+        if (modes[mode_index].value == mode_value)
+        {
+            return mode_index;
+        }
+    }
+
+    return 0;
+}
+
+void RGBController_ColorfulTuringGPU::SetupZones()
+{
+    zone new_zone;
+
+    new_zone.name       = "GPU";
+    new_zone.type       = ZONE_TYPE_LINEAR;
+    new_zone.leds_min   = 1;
+    new_zone.leds_max   = 1;
+    new_zone.leds_count = 1;
+    new_zone.matrix_map = nullptr;
+
+    zones.emplace_back(new_zone);
+
+    leds.resize(new_zone.leds_count);
+    leds[0].name = "GPU LED";
+
+    SetupColors();
+}
+
+void RGBController_ColorfulTuringGPU::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
+void RGBController_ColorfulTuringGPU::DeviceUpdateLEDs()
+{
+    switch(modes[active_mode].value)
+    {
+        case COLORFUL_TURING_GPU_RGB_MODE_BREATHING:
+            controller->SetBreathing(colors[0]);
+            break;
+        case COLORFUL_TURING_GPU_RGB_MODE_OFF:
+            controller->SetOff();
+            break;
+        case COLORFUL_TURING_GPU_RGB_MODE_RAINBOW:
+            controller->SetRainbow();
+            break;
+        case COLORFUL_TURING_GPU_RGB_MODE_STATE_DISPLAY:
+            controller->SetStateDisplay(colors[0]);
+            break;
+        case COLORFUL_TURING_GPU_RGB_MODE_STATIC:
+            controller->SetDirect(colors[0]);
+            break;
+        default:
+            controller->SetDirect(colors[0]);
+    }
+}
+
+void RGBController_ColorfulTuringGPU::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_ColorfulTuringGPU::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_ColorfulTuringGPU::DeviceUpdateMode()
+{
+    DeviceUpdateLEDs();
+}

Controllers/ColorfulTuringGPUController/RGBController_ColorfulTuringGPU.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "RGBController.h"
+#include "ColorfulTuringGPUController.h"
+
+class RGBController_ColorfulTuringGPU : public RGBController
+{
+public:
+    RGBController_ColorfulTuringGPU(ColorfulTuringGPUController* colorful_gpu_ptr);
+    ~RGBController_ColorfulTuringGPU();
+
+    void                         SetupZones();
+    void                         ResizeZone(int zone, int new_size);
+    void                         DeviceUpdateLEDs();
+    void                         UpdateZoneLEDs(int zone);
+    void                         UpdateSingleLED(int led);
+    void                         DeviceUpdateMode();
+
+private:
+    ColorfulTuringGPUController* controller;
+    int                          getModeIndex(int mode_value);
+
+};
+
+

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreController.cpp

@@ -14,7 +14,7 @@
 
 using namespace std::chrono_literals;
 
-CorsairCommanderCoreController::CorsairCommanderCoreController(hid_device* dev_handle, const char* path)
+CorsairCommanderCoreController::CorsairCommanderCoreController(hid_device* dev_handle, const char* path, int pid)
 {
     dev                     = dev_handle;
     location                = path;
@@ -22,6 +22,7 @@ CorsairCommanderCoreController::CorsairCommanderCoreController(hid_device* dev_h
     controller_ready        = 0;
     packet_size             = CORSAIR_COMMANDER_CORE_PACKET_SIZE_V2;
     command_res_size        = packet_size - 4;
+    this->pid               = pid;
 
     /*-----------------------------------------------------*\
     | Initialize controller                                 |
@@ -62,11 +63,15 @@ void CorsairCommanderCoreController::InitController()
     version[2] = res[2];
     delete[] res;
 
-    if(version[0] == 1)
+    if (pid == 0x0C1C && version[0] == 1)
     {
         packet_size = CORSAIR_COMMANDER_CORE_PACKET_SIZE_V1;
         command_res_size = packet_size - 4;
     }
+    else if (pid == 0x0C32)
+    {
+        packet_size = CORSAIR_COMMANDER_CORE_PACKET_SIZE_V3;
+    }
 
     /*-----------------------------------------------------*\
     | Wake up device                                        |

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreController.h

@@ -17,6 +17,8 @@
 
 #define CORSAIR_COMMANDER_CORE_PACKET_SIZE_V1   1025 // First bit is the report bit
 #define CORSAIR_COMMANDER_CORE_PACKET_SIZE_V2   97   // First bit is the report bit
+#define CORSAIR_COMMANDER_CORE_PACKET_SIZE_V3   65   // First bit is the report bit
+
 #define CORSAIR_COMMANDER_CORE_RGB_DATA_LENGTH  699
 #define CORSAIR_QL_FAN_ZONE_OFFSET              102
 #define CORSAIR_COMMANDER_CORE_NUM_CHANNELS     6
@@ -29,7 +31,7 @@ enum
 class CorsairCommanderCoreController
 {
 public:
-    CorsairCommanderCoreController(hid_device* dev_handle, const char* path);
+    CorsairCommanderCoreController(hid_device* dev_handle, const char* path, int pid);
     ~CorsairCommanderCoreController();
 
     std::string GetFirmwareString();
@@ -55,6 +57,7 @@ private:
     unsigned short int      version[3] = {0, 0, 0};
     int                     packet_size;
     int                     command_res_size;
+    int                     pid;
     std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
 
     void        SendCommand(unsigned char command[2], unsigned char data[], unsigned short int data_len, unsigned char res[]);

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreControllerDetect.cpp

@@ -14,6 +14,7 @@
 | Commander Core product IDs                            |
 \*-----------------------------------------------------*/
 #define CORSAIR_COMMANDER_CORE_PID          0x0C1C
+#define CORSAIR_COMMANDER_CORE2_PID         0x0C32
 
 /******************************************************************************************\
 *                                                                                          *
@@ -29,7 +30,7 @@ void DetectCorsairCapellixHIDControllers(hid_device_info* info, const std::strin
 
     if(dev)
     {
-        CorsairCommanderCoreController*     controller     = new CorsairCommanderCoreController(dev, info->path);
+        CorsairCommanderCoreController*     controller     = new CorsairCommanderCoreController(dev, info->path, info->product_id);
         RGBController_CorsairCommanderCore* rgb_controller = new RGBController_CorsairCommanderCore(controller);
 
         rgb_controller->name = name;
@@ -38,4 +39,5 @@ void DetectCorsairCapellixHIDControllers(hid_device_info* info, const std::strin
     }
 }
 
-REGISTER_HID_DETECTOR_IPU("Corsair Commander Core",  DetectCorsairCapellixHIDControllers, CORSAIR_VID, CORSAIR_COMMANDER_CORE_PID, 0x00, 0xFF42, 0x01);
+REGISTER_HID_DETECTOR_IPU("Corsair Commander Core", DetectCorsairCapellixHIDControllers, CORSAIR_VID, CORSAIR_COMMANDER_CORE_PID, 0x00, 0xFF42, 0x01);
+REGISTER_HID_DETECTOR_IPU("Corsair Commander Core", DetectCorsairCapellixHIDControllers, CORSAIR_VID, CORSAIR_COMMANDER_CORE2_PID, 0x00, 0xFF42, 0x01);

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumController.cpp

@@ -13,22 +13,22 @@
 
 using namespace std::chrono_literals;
 
-CorsairDominatorPlatinumController::CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev)
+CorsairDominatorPlatinumController::CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev, unsigned int leds_count)
 {
-    this->bus = bus;
-    this->dev = dev;
+    this->bus           = bus;
+    this->dev           = dev;
+    this->leds_count    = leds_count;
 
     led_data[0] = 0xc;
 }
 
 CorsairDominatorPlatinumController::~CorsairDominatorPlatinumController()
 {
-
 }
 
-std::string CorsairDominatorPlatinumController::GetDeviceName()
+unsigned int CorsairDominatorPlatinumController::GetLEDCount()
 {
-    return "Corsair Dominator Platinum RGB";
+    return leds_count;
 }
 
 std::string CorsairDominatorPlatinumController::GetDeviceLocation()
@@ -48,7 +48,7 @@ void CorsairDominatorPlatinumController::SetAllColors
     unsigned char   blue
     )
 {
-    for(unsigned int led = 0; led < CORSAIR_PLAT_LED_COUNT; led++)
+    for(unsigned int led = 0; led < leds_count; led++)
     {
         SetLEDColor(led, red, green, blue);
     }
@@ -62,7 +62,7 @@ void CorsairDominatorPlatinumController::SetLEDColor
     unsigned char   blue
     )
 {
-    if(led >= CORSAIR_PLAT_LED_COUNT)
+    if(led >= leds_count)
     {
         return;
     }

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumController.h

@@ -10,35 +10,31 @@
 
 #include <string>
 #include "i2c_smbus.h"
+#define CORSAIR_DOMINATOR_PLATINUM_DATA_SIZE 38
 
 #pragma once
 
 typedef unsigned char corsair_dev_id;
 
-#define CORSAIR_DOMINATOR_PLATINUM_NAME "Corsair Dominator Platinum"
-
 class CorsairDominatorPlatinumController
 {
 public:
-    CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev);
+    CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev, unsigned int leds_count);
     ~CorsairDominatorPlatinumController();
 
-    std::string GetDeviceName();
     std::string GetDeviceLocation();
+    unsigned int GetLEDCount();
 
-    size_t GetLEDCount() { return CORSAIR_PLAT_LED_COUNT; }
     void SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
     void SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
     void ApplyColors();
     bool WaitReady();
 
 private:
-    static constexpr size_t CORSAIR_PLAT_LED_COUNT = 12;
-
-    unsigned char led_data[CORSAIR_PLAT_LED_COUNT * 3 + 2];
-
+    unsigned char           led_data[CORSAIR_DOMINATOR_PLATINUM_DATA_SIZE];
     i2c_smbus_interface*    bus;
     corsair_dev_id          dev;
+    unsigned int            leds_count;
 
     static unsigned char crc8(unsigned char init, unsigned char poly, unsigned char *data, unsigned char len);
 };

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumControllerDetect.cpp

@@ -11,6 +11,40 @@
 
 using namespace std::chrono_literals;
 
+json corsair_dominator_models =
+{
+    {
+        "CMT",
+        {
+            {"name",  "Corsair Dominator Platinum"},
+            {"leds",  12}
+        }
+    },
+    {
+        "CMH",
+        {
+            {"name",  "Corsair Vengeance Pro SL"},
+            {"leds",  10}
+        }
+    },
+    {
+        "CMN",
+        {
+            {"name",  "Corsair Vengeance RGB RT"},
+            {"leds",  10}
+        }
+    },
+    {
+        "CMG",
+        {
+            {"name",  "Corsair Vengeance RGB RS"},
+            {"leds",  6}
+        }
+    }
+};
+
+#define CORSAIR_DOMINATOR_PLATINUM_NAME "Corsair Dominator Platinum"
+
 bool TestForCorsairDominatorPlatinumController(i2c_smbus_interface *bus, unsigned char address)
 {
     int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
@@ -55,32 +89,65 @@ bool TestForCorsairDominatorPlatinumController(i2c_smbus_interface *bus, unsigne
 
 void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *> &busses)
 {
+    SettingsManager* settings_manager = ResourceManager::get()->GetSettingsManager();
+
+    json corsair_dominator_settings = settings_manager->GetSettings("CorsairDominatorSettings");
+
+    if(!corsair_dominator_settings.contains("model"))
+    {
+        // Set default value
+        corsair_dominator_settings["model"] = "CMT";
+        settings_manager->SetSettings("CorsairDominatorSettings", corsair_dominator_settings);
+        settings_manager->SaveSettings();
+    }
+
+    std::string model = corsair_dominator_settings["model"];
+
     for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
         IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
             LOG_DEBUG("[%s] Testing bus %d", CORSAIR_DOMINATOR_PLATINUM_NAME, bus);
 
+            std::vector<unsigned char> addresses;
+
             for(unsigned char addr = 0x58; addr <= 0x5F; addr++)
             {
-                if(TestForCorsairDominatorPlatinumController(busses[bus], addr))
-                {
-                    CorsairDominatorPlatinumController*     new_controller    = new CorsairDominatorPlatinumController(busses[bus], addr);
-                    RGBController_CorsairDominatorPlatinum* new_rgbcontroller = new RGBController_CorsairDominatorPlatinum(new_controller);
-                    
-                    ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
-                }
-                std::this_thread::sleep_for(10ms);
+                addresses.push_back(addr);
             }
+
             for(unsigned char addr = 0x18; addr <= 0x1F; addr++)
+            {
+                addresses.push_back(addr);
+            }
+
+            for(unsigned char addr : addresses)
             {
                 if(TestForCorsairDominatorPlatinumController(busses[bus], addr))
                 {
-                    CorsairDominatorPlatinumController*     new_controller    = new CorsairDominatorPlatinumController(busses[bus], addr);
-                    RGBController_CorsairDominatorPlatinum* new_rgbcontroller = new RGBController_CorsairDominatorPlatinum(new_controller);
-                    
-                    ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
+                    unsigned int leds;
+                    std::string name;
+
+                    if(corsair_dominator_models.contains(model))
+                    {
+                        leds = corsair_dominator_models[model]["leds"];
+                        name = corsair_dominator_models[model]["name"];
+                    }
+                    else
+                    {
+                        leds = corsair_dominator_models["CMT"]["leds"];
+                        name = corsair_dominator_models["CMT"]["name"];
+                    }
+
+                    LOG_DEBUG("[%s] Model: %s, Leds: %d", CORSAIR_DOMINATOR_PLATINUM_NAME, name.c_str(), leds);
+
+                    CorsairDominatorPlatinumController*     controller    = new CorsairDominatorPlatinumController(busses[bus], addr, leds);
+                    RGBController_CorsairDominatorPlatinum* rgbcontroller = new RGBController_CorsairDominatorPlatinum(controller);
+                    rgbcontroller->name = name;
+
+                    ResourceManager::get()->RegisterRGBController(rgbcontroller);
                 }
+
                 std::this_thread::sleep_for(10ms);
             }
         }
@@ -91,4 +158,4 @@ void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *
     }
 }   /* DetectCorsairDominatorPlatinumControllers() */
 
-REGISTER_I2C_DETECTOR("Corsair Dominator Platinum", DetectCorsairDominatorPlatinumControllers);
+REGISTER_I2C_DETECTOR(CORSAIR_DOMINATOR_PLATINUM_NAME, DetectCorsairDominatorPlatinumControllers);

Controllers/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.cpp

@@ -23,10 +23,9 @@ RGBController_CorsairDominatorPlatinum::RGBController_CorsairDominatorPlatinum(C
 {
     controller  = controller_ptr;
 
-    name        = controller->GetDeviceName();
     vendor      = "Corsair";
     type        = DEVICE_TYPE_DRAM;
-    description = "Corsair Dominator Platinum RGB Device";
+    description = "Corsair RAM RGB Device";
     location    = controller->GetDeviceLocation();
 
     mode Direct;
@@ -55,7 +54,7 @@ void RGBController_CorsairDominatorPlatinum::SetupZones()
     | Set up zone                                               |
     \*---------------------------------------------------------*/
     zone new_zone;
-    new_zone.name       = "Corsair Platinum Zone";
+    new_zone.name       = "Corsair RAM Zone";
     new_zone.type       = ZONE_TYPE_LINEAR;
     new_zone.leds_min   = controller->GetLEDCount();
     new_zone.leds_max   = controller->GetLEDCount();
@@ -68,10 +67,10 @@ void RGBController_CorsairDominatorPlatinum::SetupZones()
     \*---------------------------------------------------------*/
     for(std::size_t led_idx = 0; led_idx < zones[0].leds_count; led_idx++)
     {
-        led *new_led    = new led();
-        new_led->name   = "Corsair Platinum LED ";
-        new_led->name.append(std::to_string(led_idx));
-        leds.push_back(*new_led);
+        led new_led;
+        new_led.name   = "Corsair RAM LED ";
+        new_led.name.append(std::to_string(led_idx));
+        leds.push_back(new_led);
     }
 
     SetupColors();

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.cpp

@@ -9,6 +9,8 @@
 
 #include "CorsairPeripheralV2Controller.h"
 
+using namespace std::chrono_literals;
+
 CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_handle, const char* path, std::string /*name*/, uint16_t pid)
 {
     const uint8_t sz    = HID_MAX_STR;
@@ -33,14 +35,29 @@ CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_han
             | Set device ID                                             |
             \*---------------------------------------------------------*/
             device_index    = i;
-            write_cmd       = CORSAIR_V2_WRITE_ID + corsair_v2_device_list[device_index]->wireless;
         }
     }
 
     /*---------------------------------------------------------*\
-    | Possibly is Wireless connected?                           |
+    | NB: If the device is not found in the device list         |
+    |   then wireless mode may not work reliably                |
+    \*---------------------------------------------------------*/
+    bool wireless = corsair_v2_device_list[device_index]->wireless;
+    if(wireless)
+    {
+        write_cmd = CORSAIR_V2_WRITE_WIRELESS_ID;
+    }
+    LOG_DEBUG("[%s] Setting write CMD to %02X for %s mode", device_name.c_str(),
+              write_cmd, (wireless) ? "wireless" : "wired" );
+
+    /*---------------------------------------------------------*\
+    | Get VID                                                   |
     \*---------------------------------------------------------*/
     GetAddress(0x11);
+    /*---------------------------------------------------------*\
+    | Get PID                                                   |
+    \*---------------------------------------------------------*/
+    GetAddress(0x12);
 }
 
 CorsairPeripheralV2Controller::~CorsairPeripheralV2Controller()
@@ -102,6 +119,7 @@ void CorsairPeripheralV2Controller::SetRenderMode(corsair_v2_device_mode mode)
     buffer[5]   = mode;
 
     hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
+    hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
 }
 
 void CorsairPeripheralV2Controller::LightingControl(uint8_t opt1, uint8_t opt2)
@@ -121,6 +139,7 @@ void CorsairPeripheralV2Controller::LightingControl(uint8_t opt1, uint8_t opt2)
     buffer[5]   = 0x00;
 
     hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
+    hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
 
     /*---------------------------------------------------------*\
     | Open a RGB lighting handle                                |
@@ -131,9 +150,15 @@ void CorsairPeripheralV2Controller::LightingControl(uint8_t opt1, uint8_t opt2)
     buffer[5]   = opt2;
 
     hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
+    hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
 }
 
-void CorsairPeripheralV2Controller::GetAddress(uint8_t address)
+unsigned int CorsairPeripheralV2Controller::GetKeyboardLayout()
+{
+    return GetAddress(0x41);
+}
+
+unsigned int CorsairPeripheralV2Controller::GetAddress(uint8_t address)
 {
     uint8_t buffer[CORSAIR_V2_WRITE_SIZE];
     uint8_t read[CORSAIR_V2_WRITE_SIZE];
@@ -146,10 +171,20 @@ void CorsairPeripheralV2Controller::GetAddress(uint8_t address)
     buffer[3]   = address;
 
     hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
-    hid_read(dev, read, CORSAIR_V2_WRITE_SIZE);
+    hid_read_timeout(dev, read, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
 
+    unsigned int temp = (unsigned int)(read[6] << 24 | read[5] << 16 | read[4] << 8 | read[3]);
     LOG_DEBUG("[%s] GetAddress %02X - %02X %02X - %02X %02X %02X %02X   %02X %02X %02X %02X", device_name.c_str(),
               address, read[0], read[1], read[2], read[3], read[4], read[5], read[6], read[7], read[8], read[9]);
+
+    uint8_t result = read[2];
+    if(result > 0)
+    {
+        LOG_DEBUG("[%s] An error occurred! Get Address %02X failed - %d %s", device_name.c_str(),
+                  address, result, (result == 5) ? "unsupported" : "");
+        return -1;
+    }
+    return temp;
 }
 
 void CorsairPeripheralV2Controller::StartTransaction(uint8_t opt1)
@@ -164,6 +199,7 @@ void CorsairPeripheralV2Controller::StartTransaction(uint8_t opt1)
     buffer[4]   = 0x01;
 
     hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
+    hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
 }
 
 void CorsairPeripheralV2Controller::StopTransaction(uint8_t opt1)
@@ -178,6 +214,7 @@ void CorsairPeripheralV2Controller::StopTransaction(uint8_t opt1)
     buffer[4]   = opt1;
 
     hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
+    hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
 }
 
 void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
@@ -211,6 +248,7 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
     memcpy(&buffer[offset1], &data[0], copy_bytes);
 
     hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
+    hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT_SHORT);
 
     remaining              -= copy_bytes;
     buffer[2]               = CORSAIR_V2_CMD_BLK_WN;
@@ -231,6 +269,7 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
         memcpy(&buffer[offset2], &data[index], copy_bytes);
 
         hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
+        hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT_SHORT);
 
         remaining          -= copy_bytes;
     }

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.h

@@ -16,48 +16,51 @@
 #include "RGBController.h"
 #include "CorsairPeripheralV2Devices.h"
 
-#define NA                          0xFFFFFFFF
-#define HID_MAX_STR                 255
+#define NA                              0xFFFFFFFF
+#define HID_MAX_STR                     255
 
-#define CORSAIR_V2_WRITE_ID         8
-#define CORSAIR_V2_VALUE_MODE       3
-#define CORSAIR_V2_WRITE_SIZE       65
+#define CORSAIR_V2_TIMEOUT              50
+#define CORSAIR_V2_TIMEOUT_SHORT        3
+#define CORSAIR_V2_VALUE_MODE           3
+#define CORSAIR_V2_WRITE_WIRED_ID       8
+#define CORSAIR_V2_WRITE_WIRELESS_ID    9
+#define CORSAIR_V2_WRITE_SIZE           65
 
-#define CORSAIR_V2_BRIGHTNESS_MIN   0
-#define CORSAIR_V2_BRIGHTNESS_MAX   0xFF
+#define CORSAIR_V2_BRIGHTNESS_MIN       0
+#define CORSAIR_V2_BRIGHTNESS_MAX       0xFF
 
 enum corsair_v2_cmd
 {
-    CORSAIR_V2_CMD_SET              = 0x01,     /* Command for setting values       */
-    CORSAIR_V2_CMD_GET              = 0x02,     /* Command for getting values       */
-    CORSAIR_V2_CMD_STOP_TX          = 0x05,     /* Finish Transaction               */
-    CORSAIR_V2_CMD_BLK_W1           = 0x06,     /* Block write packet 1             */
-    CORSAIR_V2_CMD_BLK_WN           = 0x07,     /* Block write remaining packets    */
-    CORSAIR_V2_CMD_START_TX         = 0x0D,     /* Start Transaction                */
+    CORSAIR_V2_CMD_SET                  = 0x01,     /* Command for setting values       */
+    CORSAIR_V2_CMD_GET                  = 0x02,     /* Command for getting values       */
+    CORSAIR_V2_CMD_STOP_TX              = 0x05,     /* Finish Transaction               */
+    CORSAIR_V2_CMD_BLK_W1               = 0x06,     /* Block write packet 1             */
+    CORSAIR_V2_CMD_BLK_WN               = 0x07,     /* Block write remaining packets    */
+    CORSAIR_V2_CMD_START_TX             = 0x0D,     /* Start Transaction                */
 };
 
 enum corsair_v2_mode
 {
-    CORSAIR_V2_MODE_DIRECT          = 0x0000,
-    CORSAIR_V2_MODE_STATIC          = 0x207E,
-    CORSAIR_V2_MODE_FLASHING        = 0xAD4F,
-    CORSAIR_V2_MODE_BREATHING       = 0xA5FA,
-    CORSAIR_V2_MODE_SPECTRUM        = 0x7BFF,
-    CORSAIR_V2_MODE_RAINBOW         = 0xB94C,
-    CORSAIR_V2_MODE_RAIN            = 0xA07E,
-    CORSAIR_V2_MODE_SPIRAL          = 0xAB87,
-    CORSAIR_V2_MODE_WATERCOLOR      = 0x0022,
-    CORSAIR_V2_MODE_REACTIVE        = 0xB1F9,
-    CORSAIR_V2_MODE_RIPPLE          = 0x09A2,
-    CORSAIR_V2_MODE_VISOR           = 0x90C0
+    CORSAIR_V2_MODE_DIRECT              = 0x0012,
+    CORSAIR_V2_MODE_STATIC              = 0x207E,
+    CORSAIR_V2_MODE_FLASHING            = 0xAD4F,
+    CORSAIR_V2_MODE_BREATHING           = 0xA5FA,
+    CORSAIR_V2_MODE_SPECTRUM            = 0x7BFF,
+    CORSAIR_V2_MODE_RAINBOW             = 0xB94C,
+    CORSAIR_V2_MODE_RAIN                = 0xA07E,
+    CORSAIR_V2_MODE_SPIRAL              = 0xAB87,
+    CORSAIR_V2_MODE_WATERCOLOR          = 0x0022,
+    CORSAIR_V2_MODE_REACTIVE            = 0xB1F9,
+    CORSAIR_V2_MODE_RIPPLE              = 0x09A2,
+    CORSAIR_V2_MODE_VISOR               = 0x90C0
 };
 
 enum corsair_v2_color
 {
-    CORSAIR_V2_COLOR_NONE          = 0x00,
-    CORSAIR_V2_COLOR_SPECIFIC      = 0x01,
-    CORSAIR_V2_COLOR_RANDOM        = 0x02,
-    CORSAIR_V2_COLOR_UNKNOWN       = 0x03
+    CORSAIR_V2_COLOR_NONE               = 0x00,
+    CORSAIR_V2_COLOR_SPECIFIC           = 0x01,
+    CORSAIR_V2_COLOR_RANDOM             = 0x02,
+    CORSAIR_V2_COLOR_UNKNOWN            = 0x03
 };
 
 
@@ -72,6 +75,7 @@ public:
     std::string                     GetName();
     std::string                     GetSerialString();
     const corsair_v2_device*        GetDeviceData();
+    unsigned int                    GetKeyboardLayout();
 
     void                            SetRenderMode(corsair_v2_device_mode mode);
     void                            LightingControl(uint8_t opt1, uint8_t opt2);
@@ -80,16 +84,19 @@ public:
                                                  uint8_t direction, uint8_t brightness, std::vector<RGBColor> colors);
 
     virtual void                    SetLedsDirect(std::vector<RGBColor *> colors)                   = 0;
+
+protected:
+    uint16_t                        device_index;
+    std::string                     device_name;
+
 private:
-    void                            GetAddress(uint8_t address);
+    unsigned int                    GetAddress(uint8_t address);
     void                            StartTransaction(uint8_t opt1);
     void                            StopTransaction(uint8_t opt1);
 
     hid_device*                     dev;
 
-    uint8_t                         write_cmd;
-    uint16_t                        device_index;
+    uint8_t                         write_cmd           = CORSAIR_V2_WRITE_WIRED_ID;
     std::string                     firmware_version;
     std::string                     location;
-    std::string                     device_name;
 };

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2ControllerDetect.cpp

@@ -10,6 +10,7 @@
 | Corsair Peripheral specific includes                  |
 \*-----------------------------------------------------*/
 #include "CorsairPeripheralV2Devices.h"
+#include "RGBController_CorsairV2Hardware.h"
 #include "RGBController_CorsairV2Software.h"
 
 #define CORSAIR_PERIPHERAL_CONTROLLER_NAME "Corsair V2 Peripheral"
@@ -19,6 +20,19 @@
 \*-----------------------------------------------------*/
 #define CORSAIR_VID                                 0x1B1C
 
+void DetectCorsairV2HardwareControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        CorsairPeripheralV2HWController*    controller      = new CorsairPeripheralV2HWController(dev, info->path, name, info->product_id);
+        RGBController_CorsairV2HW*          rgb_controller  = new RGBController_CorsairV2HW(controller);
+        rgb_controller->name                                = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}   /* DetectCorsairV2SoftwareControllers() */
+
 void DetectCorsairV2SoftwareControllers(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -36,11 +50,18 @@ void DetectCorsairV2SoftwareControllers(hid_device_info* info, const std::string
 /*-----------------------------------------------------------------------------------------------------*\
 | Keyboards                                                                                             |
 \*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO",             DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_K55_RGB_PRO_PID,       1, 0xFF42);
-REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO",             DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_K60_RGB_PRO_PID,       1, 0xFF42);
-REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO Low Profile", DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_K60_RGB_PRO_LP_PID,    1, 0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO",                 DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_K55_RGB_PRO_PID,               1, 0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO",                 DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_K60_RGB_PRO_PID,               1, 0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO Low Profile",     DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_K60_RGB_PRO_LP_PID,            1, 0xFF42);
+
+/*-----------------------------------------------------------------------------------------------------*\
+| Mice                                                                                                  |
+\*-----------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("Corsair Ironclaw Wireless",           DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_IRONCLAW_WIRELESS_PID,         1, 0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair Ironclaw Wireless (Wired)",   DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_IRONCLAW_WIRELESS_WIRED_PID,   1, 0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair M55 RGB PRO",             DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_M55_RGB_PRO_PID,           1, 0xFF42);
 
 /*-----------------------------------------------------------------------------------------------------*\
 | Mousemat                                                                                              |
 \*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Corsair MM700",                   DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_MM700_PID,             1, 0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair MM700",                       DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_MM700_PID,                     1, 0xFF42);

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.cpp

@@ -1,127 +1,147 @@
 #include "CorsairPeripheralV2Devices.h"
 
+/*-------------------------------------------------------------------------*\
+|  Corsair Key Values                                                       |
+\*-------------------------------------------------------------------------*/
+
+std::vector<unsigned int> corsair_full_size_values =
+{
+    /* ESC          F1    F2    F3    F4    F5    F6    F7    F8    F9   F10   F11   F12   PRSC  SCLK  PSBK                         */
+        41,         58,   59,   60,   61,   62,   63,   64,   65,   66,   67,   68,   69,   70,   71,   72,
+    /* BKTK    1     2     3     4     5     6     7     8     9     0     -     =   BSPC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI */
+        53,   30,   31,   32,   33,   34,   35,   36,   37,   38,   39,   45,   46,   42,   73,   74,   75,   83,   84,   85,   86,
+    /* TAB     Q     W     E     R     T     Y     U     I     O     P     [     ]     \   DEL   END   PGDN  NM7   NM8   NM9   NMPL */
+        43,   20,   26,    8,   21,   23,   28,   24,   12,   18,   19,   47,   48,   49,   76,   77,   78,   95,   96,   97,   87,
+    /* CPLK    A     S     D     F     G     H     J     K     L     ;     "   ENTR                          NM4   NM5   NM6        */
+        57,    4,   22,    7,    9,   10,   11,   13,   14,   15,   51,   52,   40,                           92,   93,   94,
+    /* LSFT    Z     X     C     V     B     N     M     ,     .     /   RSFT                    ARWU        NM1   NM2   NM3   NMER */
+       106,   29,   27,    6,   25,    5,   17,   16,   54,   55,   56,  110,                     82,         89,   90,   91,   88,
+    /* LCTL  LWIN  LALT               SPC              RALT  RFNC  RMNU  RCTL              ARWR  ARWD  ARWR  NM0         NMPD       */
+       105,  108,  107,               44,              111,  122,  101,  109,               80,   81,   79,   98,         99,
+};
+
 /*-------------------------------------------------------------------------*\
 |  KEYMAPS                                                                  |
 \*-------------------------------------------------------------------------*/
-#define K60_KEYMAP_SIZE (sizeof(K60_keymap) / sizeof(K60_keymap[0]))
-
-static const corsair_v2_led K60_keymap[] =
+keyboard_keymap_overlay_values corsair_K60_layout
 {
-    /*---------------------------------------------------------------------*\
-    |   Zone,   Row,    Column,     Index,      Name                        |
-    \*---------------------------------------------------------------------*/
-    {   0,      0,       0,          41,        KEY_EN_ESCAPE               },
-    {   0,      0,       2,          58,        KEY_EN_F1                   },
-    {   0,      0,       3,          59,        KEY_EN_F2                   },
-    {   0,      0,       4,          60,        KEY_EN_F3                   },
-    {   0,      0,       5,          61,        KEY_EN_F4                   },
-    {   0,      0,       6,          62,        KEY_EN_F5                   },
-    {   0,      0,       7,          63,        KEY_EN_F6                   },
-    {   0,      0,       8,          64,        KEY_EN_F7                   },
-    {   0,      0,       9,          65,        KEY_EN_F8                   },
-    {   0,      0,      10,          66,        KEY_EN_F9                   },
-    {   0,      0,      11,          67,        KEY_EN_F10                  },
-    {   0,      0,      12,          68,        KEY_EN_F11                  },
-    {   0,      0,      13,          69,        KEY_EN_F12                  },
-    {   0,      0,      14,          70,        KEY_EN_PRINT_SCREEN         },
-    {   0,      0,      15,          71,        KEY_EN_SCROLL_LOCK          },
-    {   0,      0,      16,          72,        KEY_EN_PAUSE_BREAK          },
-    {   0,      1,       0,          53,        KEY_EN_BACK_TICK            },
-    {   0,      1,       1,          30,        KEY_EN_1                    },
-    {   0,      1,       2,          31,        KEY_EN_2                    },
-    {   0,      1,       3,          32,        KEY_EN_3                    },
-    {   0,      1,       4,          33,        KEY_EN_4                    },
-    {   0,      1,       5,          34,        KEY_EN_5                    },
-    {   0,      1,       6,          35,        KEY_EN_6                    },
-    {   0,      1,       7,          36,        KEY_EN_7                    },
-    {   0,      1,       8,          37,        KEY_EN_8                    },
-    {   0,      1,       9,          38,        KEY_EN_9                    },
-    {   0,      1,      10,          39,        KEY_EN_0                    },
-    {   0,      1,      11,          45,        KEY_EN_MINUS                },
-    {   0,      1,      12,          46,        KEY_EN_EQUALS               },
-    {   0,      1,      13,          42,        KEY_EN_BACKSPACE            },
-    {   0,      1,      14,          73,        KEY_EN_INSERT               },
-    {   0,      1,      15,          74,        KEY_EN_HOME                 },
-    {   0,      1,      16,          75,        KEY_EN_PAGE_UP              },
-    {   0,      1,      17,          83,        KEY_EN_NUMPAD_LOCK          },
-    {   0,      1,      18,          84,        KEY_EN_NUMPAD_DIVIDE        },
-    {   0,      1,      19,          85,        KEY_EN_NUMPAD_TIMES         },
-    {   0,      1,      20,          86,        KEY_EN_NUMPAD_MINUS         },
-    {   0,      2,       0,          43,        KEY_EN_TAB                  },
-    {   0,      2,       1,          20,        KEY_EN_Q                    },
-    {   0,      2,       2,          26,        KEY_EN_W                    },
-    {   0,      2,       3,           8,        KEY_EN_E                    },
-    {   0,      2,       4,          21,        KEY_EN_R                    },
-    {   0,      2,       5,          23,        KEY_EN_T                    },
-    {   0,      2,       6,          28,        KEY_EN_Y                    },
-    {   0,      2,       7,          24,        KEY_EN_U                    },
-    {   0,      2,       8,          12,        KEY_EN_I                    },
-    {   0,      2,       9,          18,        KEY_EN_O                    },
-    {   0,      2,      10,          19,        KEY_EN_P                    },
-    {   0,      2,      11,          47,        KEY_EN_LEFT_BRACKET         },
-    {   0,      2,      12,          48,        KEY_EN_RIGHT_BRACKET        },
-    {   0,      2,      13,          49,        KEY_EN_ANSI_BACK_SLASH      },
-    {   0,      2,      14,          76,        KEY_EN_DELETE               },
-    {   0,      2,      15,          77,        KEY_EN_END                  },
-    {   0,      2,      16,          78,        KEY_EN_PAGE_DOWN            },
-    {   0,      2,      17,          95,        KEY_EN_NUMPAD_7             },
-    {   0,      2,      18,          96,        KEY_EN_NUMPAD_8             },
-    {   0,      2,      19,          97,        KEY_EN_NUMPAD_9             },
-    {   0,      2,      20,          87,        KEY_EN_NUMPAD_PLUS          },
-    {   0,      3,       0,          57,        KEY_EN_CAPS_LOCK            },
-    {   0,      3,       1,           4,        KEY_EN_A                    },
-    {   0,      3,       2,          22,        KEY_EN_S                    },
-    {   0,      3,       3,           7,        KEY_EN_D                    },
-    {   0,      3,       4,           9,        KEY_EN_F                    },
-    {   0,      3,       5,          10,        KEY_EN_G                    },
-    {   0,      3,       6,          11,        KEY_EN_H                    },
-    {   0,      3,       7,          13,        KEY_EN_J                    },
-    {   0,      3,       8,          14,        KEY_EN_K                    },
-    {   0,      3,       9,          15,        KEY_EN_L                    },
-    {   0,      3,      10,          51,        KEY_EN_SEMICOLON            },
-    {   0,      3,      11,          52,        KEY_EN_QUOTE                },
-    {   0,      3,      12,          50,        KEY_EN_POUND                },
-    {   0,      3,      13,          40,        KEY_EN_ANSI_ENTER           },
-    {   0,      3,      17,          92,        KEY_EN_NUMPAD_4             },
-    {   0,      3,      18,          93,        KEY_EN_NUMPAD_5             },
-    {   0,      3,      19,          94,        KEY_EN_NUMPAD_6             },
-    {   0,      4,       0,         106,        KEY_EN_LEFT_SHIFT           },
-    {   0,      4,       1,         100,        KEY_EN_ISO_BACK_SLASH       },
-    {   0,      4,       2,          29,        KEY_EN_Z                    },
-    {   0,      4,       3,          27,        KEY_EN_X                    },
-    {   0,      4,       4,           6,        KEY_EN_C                    },
-    {   0,      4,       5,          25,        KEY_EN_V                    },
-    {   0,      4,       6,           5,        KEY_EN_B                    },
-    {   0,      4,       7,          17,        KEY_EN_N                    },
-    {   0,      4,       8,          16,        KEY_EN_M                    },
-    {   0,      4,       9,          54,        KEY_EN_COMMA                },
-    {   0,      4,      10,          55,        KEY_EN_PERIOD               },
-    {   0,      4,      11,          56,        KEY_EN_FORWARD_SLASH        },
-    {   0,      4,      13,         110,        KEY_EN_RIGHT_SHIFT          },
-    {   0,      4,      15,          82,        KEY_EN_UP_ARROW             },
-    {   0,      4,      17,          89,        KEY_EN_NUMPAD_1             },
-    {   0,      4,      18,          90,        KEY_EN_NUMPAD_2             },
-    {   0,      4,      19,          91,        KEY_EN_NUMPAD_3             },
-    {   0,      4,      20,          88,        KEY_EN_NUMPAD_ENTER         },
-    {   0,      5,       0,         105,        KEY_EN_LEFT_CONTROL         },
-    {   0,      5,       1,         108,        KEY_EN_LEFT_WINDOWS         },
-    {   0,      5,       2,         107,        KEY_EN_LEFT_ALT             },
-    {   0,      5,       6,          44,        KEY_EN_SPACE                },
-    {   0,      5,      10,         111,        KEY_EN_RIGHT_ALT            },
-    {   0,      5,      11,         122,        KEY_EN_RIGHT_FUNCTION       },
-    {   0,      5,      12,         101,        KEY_EN_MENU                 },
-    {   0,      5,      13,         109,        KEY_EN_RIGHT_CONTROL        },
-    {   0,      5,      14,          80,        KEY_EN_LEFT_ARROW           },
-    {   0,      5,      15,          81,        KEY_EN_DOWN_ARROW           },
-    {   0,      5,      16,          79,        KEY_EN_RIGHT_ARROW          },
-    {   0,      5,      18,          98,        KEY_EN_NUMPAD_0             },
-    {   0,      5,      19,          99,        KEY_EN_NUMPAD_PERIOD        },
+    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
+    {
+        corsair_full_size_values,
+        {
+            {
+                KEYBOARD_LAYOUT_ISO_QWERTY,
+                {
+                    /*---------------------------------------------------------------------------------------------------------*\
+                    | Edit Keys                                                                                                 |
+                    |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+                    \*---------------------------------------------------------------------------------------------------------*/
+                    {   0,      3,      12,        50,          KEY_EN_POUND,               KEYBOARD_OPCODE_SWAP_ONLY,          },
+                    {   0,      4,      1,        100,          KEY_EN_ISO_BACK_SLASH,      KEYBOARD_OPCODE_SWAP_ONLY,          },
+                }
+            },
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+    }
 };
 
 /*-------------------------------------------------------------------------*\
 |  CORSAIR DEVICES                                                          |
 \*-------------------------------------------------------------------------*/
 
+/*-------------------------------------------------------------*\
+|  Corsair Ironclaw Wireless         1B1C:1B66                  |
+|  Corsair Ironclaw Wireless (Wired) 1B1C:1B4C                  |
+|                                                               |
+|  Zone "Logo"                                                  |
+|       Single                                                  |
+|                                                               |
+|  Zone "Scroll Wheel"                                          |
+|       Single                                                  |
+|                                                               |
+|  Zone "Buttons"                                               |
+|       Single                                                  |
+|                                                               |
+|  Zone "Side"                                                  |
+|       Linear                                                  |
+|       1 Row, 3 Columns                                        |
+\*-------------------------------------------------------------*/
+static const corsair_v2_zone ironclaw_logo_zone =
+{
+    "Logo",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const corsair_v2_zone ironclaw_scroll_zone =
+{
+    "Scroll Wheel",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const corsair_v2_zone ironclaw_button_zone =
+{
+    "Buttons",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const corsair_v2_zone ironclaw_side_zone =
+{
+    "Side Zone",
+    ZONE_TYPE_LINEAR,
+    1,
+    3
+};
+
+static const corsair_v2_device ironclaw_wired_device =
+{
+    CORSAIR_IRONCLAW_WIRELESS_WIRED_PID,
+    false,
+    DEVICE_TYPE_MOUSE,
+    CORSAIR_V2_TYPE_SW_COLOUR_BLOCK,
+    1,
+    6,
+    {
+        &ironclaw_logo_zone,
+        &ironclaw_scroll_zone,
+        &ironclaw_button_zone,
+        &ironclaw_side_zone,
+        nullptr,
+        nullptr
+    },
+    nullptr
+};
+
+static const corsair_v2_device ironclaw_wireless_device =
+{
+    CORSAIR_IRONCLAW_WIRELESS_PID,
+    true,
+    DEVICE_TYPE_MOUSE,
+    CORSAIR_V2_TYPE_SW_COLOUR_BLOCK,
+    1,
+    6,
+    {
+        &ironclaw_logo_zone,
+        &ironclaw_scroll_zone,
+        &ironclaw_button_zone,
+        &ironclaw_side_zone,
+        nullptr,
+        nullptr
+    },
+    nullptr
+};
+
 /*-------------------------------------------------------------*\
 |  Corsair K55 RGB Pro 1B1C:1BA4                                |
 |                                                               |
@@ -142,7 +162,7 @@ static const corsair_v2_device k55_rgb_pro_device =
     CORSAIR_K55_RGB_PRO_PID,
     false,
     DEVICE_TYPE_KEYBOARD,
-    CORSAIR_V2_MODE_SW,
+    CORSAIR_V2_TYPE_SW_COLOUR_BLOCK,
     1,
     6,
     {
@@ -153,8 +173,7 @@ static const corsair_v2_device k55_rgb_pro_device =
         nullptr,
         nullptr
     },
-    nullptr,
-    0
+    nullptr
 };
 
 /*-------------------------------------------------------------*\
@@ -177,7 +196,7 @@ static const corsair_v2_device k60_rgb_pro_device =
     CORSAIR_K60_RGB_PRO_PID,
     false,
     DEVICE_TYPE_KEYBOARD,
-    CORSAIR_V2_MODE_SW,
+    CORSAIR_V2_TYPE_SW_COLOUR_BLOCK,
     6,
     21,
     {
@@ -188,8 +207,7 @@ static const corsair_v2_device k60_rgb_pro_device =
         nullptr,
         nullptr
     },
-    K60_keymap,
-    K60_KEYMAP_SIZE
+    &corsair_K60_layout
 };
 
 /*-------------------------------------------------------------*\
@@ -212,7 +230,7 @@ static const corsair_v2_device k60_rgb_pro_lp_device =
     CORSAIR_K60_RGB_PRO_LP_PID,
     false,
     DEVICE_TYPE_KEYBOARD,
-    CORSAIR_V2_MODE_SW,
+    CORSAIR_V2_TYPE_SW_COLOUR_BLOCK,
     6,
     21,
     {
@@ -223,8 +241,52 @@ static const corsair_v2_device k60_rgb_pro_lp_device =
         nullptr,
         nullptr
     },
-    K60_keymap,
-    K60_KEYMAP_SIZE
+    &corsair_K60_layout
+};
+
+/*-------------------------------------------------------------*\
+|  Corsair M55 1B1C:1B70                                        |
+|                                                               |
+|  Zone "Logo"                                                  |
+|       Single                                                  |
+|                                                               |
+|  Zone "Edge"                                                  |
+|       Linear                                                  |
+|       1 Row, 2 Columns                                        |
+\*-------------------------------------------------------------*/
+static const corsair_v2_zone m55_mid_zone =
+{
+    "Middle Button",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const corsair_v2_zone m55_logo_zone =
+{
+    "Logo",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const corsair_v2_device m55_device =
+{
+    CORSAIR_M55_RGB_PRO_PID,
+    false,
+    DEVICE_TYPE_MOUSE,
+    CORSAIR_V2_TYPE_SW_COLOUR_BLOCK,
+    1,
+    2,
+    {
+        &m55_mid_zone,
+        &m55_logo_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    },
+    nullptr
 };
 
 /*-------------------------------------------------------------*\
@@ -266,7 +328,7 @@ static const corsair_v2_device mm700_device =
     CORSAIR_MM700_PID,
     false,
     DEVICE_TYPE_MOUSEMAT,
-    CORSAIR_V2_MODE_SW,
+    CORSAIR_V2_TYPE_SW_COLOUR_BLOCK,
     1,
     3,
     {
@@ -277,8 +339,7 @@ static const corsair_v2_device mm700_device =
         nullptr,
         nullptr
     },
-    nullptr,
-    0
+    nullptr
 };
 
 /*-------------------------------------------------------------------------*\
@@ -293,6 +354,13 @@ const corsair_v2_device* corsair_v2_device_list_data[] =
     &k60_rgb_pro_device,
     &k60_rgb_pro_lp_device,
 
+/*-----------------------------------------------------------------*\
+|  MICE                                                             |
+\*-----------------------------------------------------------------*/
+    &ironclaw_wired_device,
+    &ironclaw_wireless_device,
+    &m55_device,
+
 /*-----------------------------------------------------------------*\
 |  MOUSEMATS                                                        |
 \*-----------------------------------------------------------------*/

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.h

@@ -3,43 +3,59 @@
 #include <string>
 #include "RGBController.h"
 #include "RGBControllerKeyNames.h"
+#include "KeyboardLayoutManager.h"
 
-#define CORSAIR_ZONES_MAX   6
+#define CORSAIR_ZONES_MAX               6
 
 enum corsair_v2_device_mode
 {
-    CORSAIR_V2_MODE_HW              = 0x01,     /* Hardware RGB mode                */
-    CORSAIR_V2_MODE_SW              = 0x02,     /* Software RGB mode                */
+    CORSAIR_V2_MODE_HW                  = 0x01,     /* Hardware RGB mode                */
+    CORSAIR_V2_MODE_SW                  = 0x02,     /* Software RGB mode                */
+};
+
+enum corsair_v2_supports
+{
+    CORSAIR_V2_TYPE_SW_COLOUR_BLOCK     = 1,
+    CORSAIR_V2_TYPE_HW_COLOUR_BLOCK     = 2,
+    CORSAIR_V2_TYPE_SW_TRIPLETS         = 3,
+    CORSAIR_V2_TYPE_HW_TRIPLETS         = 4,
+};
+
+enum corsair_v2_kb_layout
+{
+    CORSAIR_V2_KB_LAYOUT_ANSI           = 0x01,     /* US ANSI Layout                   */
+    CORSAIR_V2_KB_LAYOUT_ISO            = 0x02,     /* EURO ISO Layout                  */
+    CORSAIR_V2_KB_LAYOUT_ABNT           = 0x03,     /* Brazilian Layout                 */
+    CORSAIR_V2_KB_LAYOUT_JIS            = 0x04,     /* Japanese Layout                  */
 };
 
 typedef struct
 {
-    std::string             name;
-    zone_type               type;
-    uint8_t                 rows;
-    uint8_t                 cols;
+    std::string                         name;
+    zone_type                           type;
+    uint8_t                             rows;
+    uint8_t                             cols;
 }   corsair_v2_zone;
 
 typedef struct
 {
-    uint8_t                 zone;
-    uint8_t                 row;
-    uint8_t                 col;
-    uint8_t                 index;
-    const char*             name;
+    uint8_t                             zone;
+    uint8_t                             row;
+    uint8_t                             col;
+    uint8_t                             index;
+    const char*                         name;
 }   corsair_v2_led;
 
 typedef struct
 {
-    uint16_t                pid;
-    bool                    wireless;
-    device_type             type;
-    uint8_t                 supports;
-    uint8_t                 rows;
-    uint8_t                 cols;
-    const corsair_v2_zone*  zones[CORSAIR_ZONES_MAX];
-    const corsair_v2_led*   layout;
-    uint16_t                layout_size;
+    uint16_t                            pid;
+    bool                                wireless;
+    device_type                         type;
+    corsair_v2_supports                 protocol;
+    uint8_t                             rows;
+    uint8_t                             cols;
+    const corsair_v2_zone*              zones[CORSAIR_ZONES_MAX];
+    keyboard_keymap_overlay_values*     layout_new;
 }   corsair_v2_device;
 
 /*-----------------------------------------------------*\
@@ -49,6 +65,13 @@ typedef struct
 #define CORSAIR_K60_RGB_PRO_PID                     0x1BA0
 #define CORSAIR_K60_RGB_PRO_LP_PID                  0x1BAD
 
+/*-----------------------------------------------------*\
+| Corsair V2 Protocol Mice                              |
+\*-----------------------------------------------------*/
+#define CORSAIR_IRONCLAW_WIRELESS_PID               0x1BA6
+#define CORSAIR_IRONCLAW_WIRELESS_WIRED_PID         0x1B4C
+#define CORSAIR_M55_RGB_PRO_PID                     0x1B70
+
 /*-----------------------------------------------------*\
 | Corsair V2 Protocol Mousemats                         |
 \*-----------------------------------------------------*/

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2HardwareController.cpp

@@ -0,0 +1,89 @@
+/*---------------------------------------------------------------------*\
+|  CorsairPeripheralV2HardwareController.cpp                            |
+|                                                                       |
+|  Driver for the newer Corsair peripherals that use the '08'           |
+|    based USB protocol and support hardware lighting modes.            |
+|                                                                       |
+|  Chris M (Dr_No)          07 Dec 2022                                 |
+\*---------------------------------------------------------------------*/
+
+#include "LogManager.h"
+#include "CorsairPeripheralV2HardwareController.h"
+
+CorsairPeripheralV2HWController::CorsairPeripheralV2HWController(hid_device* dev_handle, const char* path, std::string name, uint16_t pid) : CorsairPeripheralV2Controller(dev_handle, path, name, pid)
+{
+    SetRenderMode(CORSAIR_V2_MODE_SW);
+    LightingControl(0x5F, 0x00);
+}
+
+CorsairPeripheralV2HWController::~CorsairPeripheralV2HWController()
+{
+
+}
+
+void CorsairPeripheralV2HWController::SetLedsDirect(std::vector<RGBColor *>colors)
+{
+    switch(corsair_v2_device_list[device_index]->protocol)
+    {
+        case CORSAIR_V2_TYPE_HW_TRIPLETS:
+            SetLedsDirectTriplets(colors);
+            break;
+        case CORSAIR_V2_TYPE_HW_COLOUR_BLOCK:
+            SetLedsDirectColourBlocks(colors);
+            break;
+        default:
+            LOG_ERROR("[%s] Error setting Direct mode: Device supportes returned %i", device_name.c_str(),
+                       corsair_v2_device_list[device_index]->protocol);
+            break;
+    }
+}
+
+void CorsairPeripheralV2HWController::SetLedsDirectColourBlocks(std::vector<RGBColor *>colors)
+{
+    uint16_t count          = colors.size();
+    uint16_t green          = count         + CORSAIR_V2HW_DATA_OFFSET;
+    uint16_t blue           = (count * 2)   + CORSAIR_V2HW_DATA_OFFSET;
+    uint16_t length         = (count * 3)   + CORSAIR_V2HW_DATA_OFFSET;
+    uint8_t* buffer         = new uint8_t[length];
+
+    memset(buffer, 0, length);
+
+    buffer[0]               = CORSAIR_V2_MODE_DIRECT & 0xFF;
+    buffer[1]               = CORSAIR_V2_MODE_DIRECT >> 8;
+    for(std::size_t i = 0; i < count; i++)
+    {
+        RGBColor color      = *colors[i];
+        std::size_t idx     = i + CORSAIR_V2HW_DATA_OFFSET;
+
+        buffer[idx]         = RGBGetRValue(color);
+        buffer[idx + green] = RGBGetGValue(color);
+        buffer[idx + blue]  = RGBGetBValue(color);
+    }
+
+    SetLEDs(buffer, length);
+    delete[] buffer;
+}
+
+void CorsairPeripheralV2HWController::SetLedsDirectTriplets(std::vector<RGBColor *>colors)
+{
+    uint16_t count          = colors.size();
+    uint16_t length         = (count * 3)   + CORSAIR_V2HW_DATA_OFFSET;
+    uint8_t* buffer         = new uint8_t[length];
+
+    memset(buffer, 0, length);
+
+    buffer[0]               = CORSAIR_V2_MODE_DIRECT & 0xFF;
+    buffer[1]               = CORSAIR_V2_MODE_DIRECT >> 8;
+    for(std::size_t i = 0; i < count; i++)
+    {
+        RGBColor color      = *colors[i];
+        std::size_t idx     = (i * 3) + CORSAIR_V2HW_DATA_OFFSET;
+
+        buffer[idx]         = RGBGetRValue(color);
+        buffer[idx + 1]     = RGBGetGValue(color);
+        buffer[idx + 2]     = RGBGetBValue(color);
+    }
+
+    SetLEDs(buffer, length);
+    delete[] buffer;
+}

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2HardwareController.h

@@ -0,0 +1,32 @@
+/*---------------------------------------------------------------------*\
+|  CorsairPeripheralV2HardwareController.h                              |
+|                                                                       |
+|  Driver for the newer Corsair peripherals that use the '08'           |
+|    based USB protocol and support hardware lighting modes.            |
+|                                                                       |
+|  Chris M (Dr_No)          07 Dec 2022                                 |
+\*---------------------------------------------------------------------*/
+#pragma once
+
+#include "RGBController.h"
+#include "CorsairPeripheralV2Controller.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#undef  CORSAIR_V2_WRITE_SIZE
+#define CORSAIR_V2_WRITE_SIZE       1025
+#define CORSAIR_V2HW_DATA_OFFSET    2
+
+class CorsairPeripheralV2HWController : public CorsairPeripheralV2Controller
+{
+public:
+    CorsairPeripheralV2HWController(hid_device* dev_handle, const char* path, std::string name, uint16_t pid);
+    ~CorsairPeripheralV2HWController();
+
+    void    SetLedsDirect(std::vector<RGBColor *> colors);
+
+private:
+    void    SetLedsDirectColourBlocks(std::vector<RGBColor *> colors);
+    void    SetLedsDirectTriplets(std::vector<RGBColor *> colors);
+};

Controllers/CorsairPeripheralV2Controller/RGBController_CorsairV2Hardware.cpp

@@ -0,0 +1,268 @@
+/*---------------------------------------------------------------------*\
+|  RGBController_CorsairV2HardwareController.cpp                        |
+|                                                                       |
+|  Driver for the newer Corsair peripherals that use the '08'           |
+|    based USB protocol and support hardware lighting modes.            |
+|                                                                       |
+|  Chris M (Dr_No)          10 Dec 2022                                 |
+\*---------------------------------------------------------------------*/
+#include "LogManager.h"
+#include "RGBController_CorsairV2Hardware.h"
+
+using namespace std::chrono_literals;
+
+/**------------------------------------------------------------------*\
+    @name Corsair Peripherals V2 Hardware
+    @category Keyboard
+    @type USB
+    @save :robot:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectCorsairV2HardwareControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_CorsairV2HW::RGBController_CorsairV2HW(CorsairPeripheralV2Controller *controller_ptr)
+{
+    controller                          = controller_ptr;
+    const corsair_v2_device* corsair    = controller->GetDeviceData();
+
+    vendor                              = "Corsair";
+    description                         = controller->GetName();
+    type                                = corsair->type;
+    version                             = controller->GetFirmwareString();
+    location                            = controller->GetDeviceLocation();
+    serial                              = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name                         = "Direct";
+    Direct.value                        = CORSAIR_V2_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                        = CORSAIR_V2_MODE_STATIC;
+    Static.flags                        = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.colors_min                   = 1;
+    Static.colors_max                   = 1;
+    Static.colors.resize(Static.colors_max);
+    Static.brightness_min               = CORSAIR_V2_BRIGHTNESS_MIN;
+    Static.brightness_max               = CORSAIR_V2_BRIGHTNESS_MAX;
+    Static.brightness                   = CORSAIR_V2_BRIGHTNESS_MAX;
+    Static.color_mode                   = MODE_COLORS_MODE_SPECIFIC;
+    modes.push_back(Static);
+
+    SetupZones();
+    /*-----------------------------------------------------*\
+    | The Corsair K55 RGB PRO requires a packet within      |
+    | 1 minutes of sending the lighting change in order     |
+    | to not revert back into rainbow mode.  Start a thread |
+    | to continuously send a keepalive packet every 50 sec  |
+    \*-----------------------------------------------------*/
+    keepalive_thread_run                = true;
+    keepalive_thread                    = new std::thread(&RGBController_CorsairV2HW::KeepaliveThread, this);
+}
+
+RGBController_CorsairV2HW::~RGBController_CorsairV2HW()
+{
+    /*-----------------------------------------------------*\
+    | Close keepalive thread                                |
+    \*-----------------------------------------------------*/
+    keepalive_thread_run = false;
+    keepalive_thread->join();
+    delete keepalive_thread;
+
+    /*---------------------------------------------------------*\
+    | Delete the matrix map                                     |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    {
+        if(zones[zone_index].type == ZONE_TYPE_MATRIX)
+        {
+            delete zones[zone_index].matrix_map;
+        }
+    }
+
+    delete controller;
+}
+
+void RGBController_CorsairV2HW::SetupZones()
+{
+    std::string physical_size;
+    KEYBOARD_LAYOUT new_layout;
+    unsigned int max_led_value              = 0;
+    const corsair_v2_device* corsair        = controller->GetDeviceData();
+    unsigned int layout                     = controller->GetKeyboardLayout();
+
+    switch(layout)
+    {
+        case CORSAIR_V2_KB_LAYOUT_ISO:
+            new_layout = KEYBOARD_LAYOUT_ISO_QWERTY;
+            break;
+
+        case CORSAIR_V2_KB_LAYOUT_JIS:
+            new_layout = KEYBOARD_LAYOUT_JIS;
+            break;
+
+        case CORSAIR_V2_KB_LAYOUT_ANSI:
+        case CORSAIR_V2_KB_LAYOUT_ABNT:
+        default:
+            new_layout = KEYBOARD_LAYOUT_ANSI_QWERTY;
+            break;
+    }
+
+    /*---------------------------------------------------------*\
+    | Fill in zones from the device data                        |
+    \*---------------------------------------------------------*/
+    for(size_t i = 0; i < CORSAIR_ZONES_MAX; i++)
+    {
+        if(corsair->zones[i] == NULL)
+        {
+            break;
+        }
+        else
+        {
+            zone new_zone;
+
+            new_zone.name                   = corsair->zones[i]->name;
+            new_zone.type                   = corsair->zones[i]->type;
+
+            if(new_zone.type == ZONE_TYPE_MATRIX)
+            {
+                KeyboardLayoutManager new_kb(new_layout, corsair->layout_new->base_size, corsair->layout_new->key_values);
+
+                matrix_map_type * new_map   = new matrix_map_type;
+                new_zone.matrix_map         = new_map;
+
+                new_map->height             = corsair->zones[i]->rows;
+                new_map->width              = corsair->zones[i]->cols;
+                new_map->map                = new unsigned int[new_map->height * new_map->width];
+
+                if(corsair->layout_new->base_size != KEYBOARD_SIZE_EMPTY)
+                {
+                    /*---------------------------------------------------------*\
+                    | Minor adjustments to keyboard layout                      |
+                    \*---------------------------------------------------------*/
+                    new_zone.leds_count                     = new_kb.GetKeyCount();
+                    keyboard_keymap_overlay_values* temp    = corsair->layout_new;
+                    new_kb.ChangeKeys(*temp);
+
+                    /*---------------------------------------------------------*\
+                    | Matrix map still uses declared zone rows and columns      |
+                    |   as the packet structure depends on the matrix map       |
+                    \*---------------------------------------------------------*/
+                    new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT, new_map->height, new_map->width);
+
+                    /*---------------------------------------------------------*\
+                    | Create LEDs for the Matrix zone                           |
+                    |   Place keys in the layout to populate the matrix         |
+                    \*---------------------------------------------------------*/
+                    for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
+                    {
+                        led new_led;
+
+                        new_led.name                = new_kb.GetKeyNameAt(led_idx);
+                        new_led.value               = new_kb.GetKeyValueAt(led_idx);
+                        max_led_value               = std::max(max_led_value, new_led.value);
+                        leds.push_back(new_led);
+                    }
+                }
+
+                /*---------------------------------------------------------*\
+                | Add 1 the max_led_value to account for the 0th index      |
+                \*---------------------------------------------------------*/
+                max_led_value++;
+            }
+            else
+            {
+                new_zone.leds_count             = corsair->zones[i]->rows * corsair->zones[i]->cols;
+                new_zone.matrix_map             = NULL;
+
+                /*---------------------------------------------------------*\
+                | Create LEDs for the Linear / Single zone                  |
+                \*---------------------------------------------------------*/
+                for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
+                {
+                    led new_led;
+
+                    new_led.name                = new_zone.name + " ";
+                    new_led.name.append(std::to_string( led_idx ));
+                    new_led.value               = leds.size();
+
+                    leds.push_back(new_led);
+                }
+
+                max_led_value                   = std::max(max_led_value, (unsigned int)leds.size());
+            }
+
+            LOG_DEBUG("[%s] Creating a %s zone: %s with %d LEDs", name.c_str(),
+                      ((new_zone.type == ZONE_TYPE_MATRIX) ? "matrix": "linear"),
+                      new_zone.name.c_str(), new_zone.leds_count);
+            new_zone.leds_min                   = new_zone.leds_count;
+            new_zone.leds_max                   = new_zone.leds_count;
+            zones.push_back(new_zone);
+        }
+    }
+
+    SetupColors();
+
+    /*---------------------------------------------------------*\
+    | Create a buffer map of pointers which contains the        |
+    |   layout order of colors the device expects.              |
+    \*---------------------------------------------------------*/
+    for(size_t led_idx = 0; led_idx < max_led_value; led_idx++)
+    {
+        buffer_map.push_back(&null_color);
+    }
+
+    for(size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        buffer_map[leds[led_idx].value] = &colors[led_idx];
+    }
+}
+
+void RGBController_CorsairV2HW::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_CorsairV2HW::DeviceUpdateLEDs()
+{
+    last_update_time = std::chrono::steady_clock::now();
+
+    controller->SetLedsDirect(buffer_map);
+}
+
+void RGBController_CorsairV2HW::UpdateZoneLEDs(int /*zone*/)
+{
+    controller->SetLedsDirect(buffer_map);
+}
+
+void RGBController_CorsairV2HW::UpdateSingleLED(int /*led*/)
+{
+    controller->SetLedsDirect(buffer_map);
+}
+
+void RGBController_CorsairV2HW::DeviceUpdateMode()
+{
+
+}
+
+void RGBController_CorsairV2HW::KeepaliveThread()
+{
+    while(keepalive_thread_run.load())
+    {
+        if(active_mode == 0)
+        {
+            if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50000))
+            {
+                DeviceUpdateLEDs();
+            }
+        }
+        std::this_thread::sleep_for(30000ms);
+    }
+}

Controllers/CorsairPeripheralV2Controller/RGBController_CorsairV2Hardware.h

@@ -0,0 +1,42 @@
+/*---------------------------------------------------------------------*\
+|  RGBController_CorsairV2HardwareController.h                          |
+|                                                                       |
+|  Driver for the newer Corsair peripherals that use the '08'           |
+|    based USB protocol and support hardware lighting modes.            |
+|                                                                       |
+|  Chris M (Dr_No)          10 Dec 2022                                 |
+\*---------------------------------------------------------------------*/
+#pragma once
+
+#include "RGBController.h"
+#include "CorsairPeripheralV2Controller.h"
+#include "CorsairPeripheralV2HardwareController.h"
+
+class RGBController_CorsairV2HW : public RGBController
+{
+public:
+    RGBController_CorsairV2HW(CorsairPeripheralV2Controller* controller_ptr);
+    ~RGBController_CorsairV2HW();
+
+    void SetupZones();
+    void ResizeZone(int zone, int new_size);
+
+    void DeviceUpdateLEDs();
+    void UpdateZoneLEDs(int zone);
+    void UpdateSingleLED(int led);
+
+    void DeviceUpdateMode();
+    void KeepaliveThread();
+
+private:
+    CorsairPeripheralV2Controller*          controller;
+
+    RGBColor                                null_color              = 0;
+    std::vector<RGBColor *>                 buffer_map;
+
+    std::thread*                            keepalive_thread;
+    std::atomic<bool>                       keepalive_thread_run;
+    std::chrono::time_point
+        <std::chrono::steady_clock>         last_update_time;
+
+};

Controllers/CorsairPeripheralV2Controller/RGBController_CorsairV2Software.cpp

@@ -13,7 +13,7 @@
 using namespace std::chrono_literals;
 
 /**------------------------------------------------------------------*\
-    @name Corsair K55 RGB Pro
+    @name Corsair Peripherals V2 Software
     @category Keyboard
     @type USB
     @save :x:
@@ -35,7 +35,7 @@ RGBController_CorsairV2SW::RGBController_CorsairV2SW(CorsairPeripheralV2Controll
     location                            = controller->GetDeviceLocation();
     serial                              = controller->GetSerialString();
 
-    if(corsair->supports & CORSAIR_V2_MODE_SW)
+    if(corsair->protocol & CORSAIR_V2_TYPE_SW_COLOUR_BLOCK)
     {
         mode Direct;
         Direct.name                     = "Direct";
@@ -43,10 +43,7 @@ RGBController_CorsairV2SW::RGBController_CorsairV2SW(CorsairPeripheralV2Controll
         Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR;
         Direct.color_mode               = MODE_COLORS_PER_LED;
         modes.push_back(Direct);
-    }
 
-    if(corsair->supports & CORSAIR_V2_MODE_HW)
-    {
         mode Static;
         Static.name                     = "Static";
         Static.value                    = CORSAIR_V2_MODE_STATIC;
@@ -97,8 +94,28 @@ RGBController_CorsairV2SW::~RGBController_CorsairV2SW()
 
 void RGBController_CorsairV2SW::SetupZones()
 {
+    std::string physical_size;
+    KEYBOARD_LAYOUT new_layout;
     unsigned int max_led_value              = 0;
     const corsair_v2_device* corsair        = controller->GetDeviceData();
+    unsigned int layout                     = controller->GetKeyboardLayout();
+
+    switch(layout)
+    {
+        case CORSAIR_V2_KB_LAYOUT_ISO:
+            new_layout = KEYBOARD_LAYOUT_ISO_QWERTY;
+            break;
+
+        case CORSAIR_V2_KB_LAYOUT_JIS:
+            new_layout = KEYBOARD_LAYOUT_JIS;
+            break;
+
+        case CORSAIR_V2_KB_LAYOUT_ANSI:
+        case CORSAIR_V2_KB_LAYOUT_ABNT:
+        default:
+            new_layout = KEYBOARD_LAYOUT_ANSI_QWERTY;
+            break;
+    }
 
     /*---------------------------------------------------------*\
     | Fill in zones from the device data                        |
@@ -118,44 +135,45 @@ void RGBController_CorsairV2SW::SetupZones()
 
             if(new_zone.type == ZONE_TYPE_MATRIX)
             {
-                new_zone.leds_count         = corsair->layout_size;
+                KeyboardLayoutManager new_kb(new_layout, corsair->layout_new->base_size, corsair->layout_new->key_values);
+
                 matrix_map_type * new_map   = new matrix_map_type;
                 new_zone.matrix_map         = new_map;
 
                 new_map->height             = corsair->zones[i]->rows;
                 new_map->width              = corsair->zones[i]->cols;
+                new_map->map                = new unsigned int[new_map->height * new_map->width];
 
-                new_map->map = new unsigned int[new_map->height * new_map->width];
-
-                /*---------------------------------------------------------*\
-                | Create an empty matrix                                    |
-                \*---------------------------------------------------------*/
-                for(unsigned int y = 0; y < new_map->height; y++)
+                if(corsair->layout_new->base_size != KEYBOARD_SIZE_EMPTY)
                 {
-                    for(unsigned int x = 0; x < new_map->width; x++)
+                    /*---------------------------------------------------------*\
+                    | Minor adjustments to keyboard layout                      |
+                    \*---------------------------------------------------------*/
+                    new_zone.leds_count                     = new_kb.GetKeyCount();
+                    keyboard_keymap_overlay_values* temp    = corsair->layout_new;
+                    new_kb.ChangeKeys(*temp);
+
+                    /*---------------------------------------------------------*\
+                    | Matrix map still uses declared zone rows and columns      |
+                    |   as the packet structure depends on the matrix map       |
+                    \*---------------------------------------------------------*/
+                    new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT, new_map->height, new_map->width);
+
+                    /*---------------------------------------------------------*\
+                    | Create LEDs for the Matrix zone                           |
+                    |   Place keys in the layout to populate the matrix         |
+                    \*---------------------------------------------------------*/
+                    for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
                     {
-                        new_map->map[(y * new_map->width) + x] = NA;
+                        led new_led;
+
+                        new_led.name                = new_kb.GetKeyNameAt(led_idx);
+                        new_led.value               = new_kb.GetKeyValueAt(led_idx);
+                        max_led_value               = std::max(max_led_value, new_led.value);
+                        leds.push_back(new_led);
                     }
                 }
 
-                /*---------------------------------------------------------*\
-                | Create LEDs for the Matrix zone                           |
-                |   Place keys in the layout to populate the matrix         |
-                \*---------------------------------------------------------*/
-                for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
-                {
-                    led new_led;
-
-                    new_led.name                = corsair->layout[led_idx].name;
-                    new_led.value               = corsair->layout[led_idx].index;
-                    max_led_value               = std::max(max_led_value, new_led.value);
-                    leds.push_back(new_led);
-
-                    uint8_t layout_index        = (corsair->layout[led_idx].row * new_map->width)
-                                                +  corsair->layout[led_idx].col;
-                    new_map->map[layout_index]  = led_idx;
-                }
-
                 /*---------------------------------------------------------*\
                 | Add 1 the max_led_value to account for the 0th index      |
                 \*---------------------------------------------------------*/
@@ -249,6 +267,6 @@ void RGBController_CorsairV2SW::KeepaliveThread()
                 DeviceUpdateLEDs();
             }
         }
-        std::this_thread::sleep_for(3000ms);
+        std::this_thread::sleep_for(30000ms);
     }
 }

Controllers/CorsairPeripheralV2Controller/RGBController_CorsairV2Software.h

@@ -10,6 +10,7 @@
 
 #include "RGBController.h"
 #include "CorsairPeripheralV2Controller.h"
+#include "CorsairPeripheralV2HardwareController.h"
 #include "CorsairPeripheralV2SoftwareController.h"
 
 class RGBController_CorsairV2SW : public RGBController

Controllers/CrucialController/RGBController_Crucial.cpp

@@ -197,6 +197,7 @@ void RGBController_Crucial::DeviceUpdateMode()
     if(modes[active_mode].value == 0xFFFF)
     {
         controller->SetMode(CRUCIAL_MODE_STATIC);
+        controller->SetAllColorsEffect(&colors[0]);
         return;
     }
 

Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiController.cpp

@@ -0,0 +1,234 @@
+/*---------------------------------------------------------*\
+|  Processing Code for Cryorig H7 Quad Lumi                 |
+|                                                           |
+|  Adam Honse ([email protected]), 4/15/2023        |
+\*---------------------------------------------------------*/
+
+#include "CryorigH7QuadLumiController.h"
+#include "LogManager.h"
+
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <cstring>
+
+CryorigH7QuadLumiController::CryorigH7QuadLumiController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+
+    SendFirmwareRequest();
+}
+
+CryorigH7QuadLumiController::~CryorigH7QuadLumiController()
+{
+    hid_close(dev);
+}
+
+std::string CryorigH7QuadLumiController::GetLocation()
+{
+    return("HID: " + location);
+}
+
+std::string CryorigH7QuadLumiController::GetFirmwareVersion()
+{
+    return(firmware_version);
+}
+
+std::string CryorigH7QuadLumiController::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 CryorigH7QuadLumiController::SetChannelEffect
+    (
+    unsigned char   channel,
+    unsigned char   mode,
+    unsigned char   speed,
+    bool            direction,
+    RGBColor *      colors,
+    unsigned int    num_colors
+    )
+{
+    unsigned char color_data[120];
+
+    /*-----------------------------------------------------*\
+    | If mode requires no colors, send packet               |
+    \*-----------------------------------------------------*/
+    if(num_colors == 0)
+    {
+        /*-----------------------------------------------------*\
+        | Send mode without color data                          |
+        \*-----------------------------------------------------*/
+        SendPacket(channel, mode, direction, 0, speed, 0, NULL);
+    }
+    /*-----------------------------------------------------*\
+    | If mode requires indexed colors, send color index     |
+    | packets for each mode color                           |
+    \*-----------------------------------------------------*/
+    else if(num_colors <= 8)
+    {
+        for(std::size_t color_idx = 0; color_idx < num_colors; color_idx++)
+        {
+            /*-----------------------------------------------------*\
+            | Fill in color data (5 entries per color)              |
+            \*-----------------------------------------------------*/
+            for (std::size_t idx = 0; idx < 40; idx++)
+            {
+                int pixel_idx = idx * 3;
+                RGBColor color = colors[color_idx];
+                color_data[pixel_idx + 0x00] = RGBGetGValue(color);
+                color_data[pixel_idx + 0x01] = RGBGetRValue(color);
+                color_data[pixel_idx + 0x02] = RGBGetBValue(color);
+            }
+
+            /*-----------------------------------------------------*\
+            | Send mode and color data                              |
+            \*-----------------------------------------------------*/
+            SendPacket(channel, mode, direction, color_idx, speed, 5, &color_data[0]);
+        }
+    }
+    /*-----------------------------------------------------*\
+    | If mode requires per-LED colors, fill colors array    |
+    \*-----------------------------------------------------*/
+    else
+    {
+        /*-----------------------------------------------------*\
+        | Fill in color data (up to 40 colors)                  |
+        \*-----------------------------------------------------*/
+        for (std::size_t idx = 0; idx < num_colors; idx++)
+        {
+            int pixel_idx = idx * 3;
+            RGBColor color = colors[idx];
+            color_data[pixel_idx + 0x00] = RGBGetGValue(color);
+            color_data[pixel_idx + 0x01] = RGBGetRValue(color);
+            color_data[pixel_idx + 0x02] = RGBGetBValue(color);
+        }
+
+        /*-----------------------------------------------------*\
+        | Send mode and color data                              |
+        \*-----------------------------------------------------*/
+        SendPacket(channel, mode, direction, 0, speed, num_colors, &color_data[0]);
+    }
+}
+
+void CryorigH7QuadLumiController::SetChannelLEDs
+    (
+    unsigned char   channel,
+    RGBColor *      colors,
+    unsigned int    num_colors
+    )
+{
+    unsigned char color_data[120];
+
+    /*-----------------------------------------------------*\
+    | Fill in color data (up to 40 colors)                  |
+    \*-----------------------------------------------------*/
+    for (std::size_t idx = 0; idx < num_colors; idx++)
+    {
+        int pixel_idx = idx * 3;
+        RGBColor color = colors[idx];
+        color_data[pixel_idx + 0x00] = RGBGetGValue(color);
+        color_data[pixel_idx + 0x01] = RGBGetRValue(color);
+        color_data[pixel_idx + 0x02] = RGBGetBValue(color);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send color data                                       |
+    \*-----------------------------------------------------*/
+    SendPacket(channel, CRYORIG_H7_QUAD_LUMI_MODE_FIXED, false, 0, 0, num_colors, &color_data[0]);
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void CryorigH7QuadLumiController::SendPacket
+    (
+    unsigned char   channel,
+    unsigned char   mode,
+    bool            direction,
+    unsigned char   color_idx,
+    unsigned char   speed,
+    unsigned char   color_count,
+    unsigned char*  color_data
+    )
+{
+    unsigned char   usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up RGB packet                                     |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]       = 0x02;
+    usb_buf[0x01]       = 0x4C;
+
+    /*-----------------------------------------------------*\
+    | Set channel and direction in RGB packet               |
+    \*-----------------------------------------------------*/
+    usb_buf[0x02]       = (channel + 1) | (direction ? (1 << 4) : 0);
+
+    /*-----------------------------------------------------*\
+    | Set mode in RGB packet                                |
+    \*-----------------------------------------------------*/
+    usb_buf[0x03]       = mode;
+
+    /*-----------------------------------------------------*\
+    | Set color index and speed in RGB packet               |
+    \*-----------------------------------------------------*/
+    usb_buf[0x04]       = ( color_idx << 5 ) | speed;
+
+    /*-----------------------------------------------------*\
+    | Copy in color data bytes                              |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x05 + (channel * 15)], color_data, color_count * 3);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+}
+
+void CryorigH7QuadLumiController::SendFirmwareRequest()
+{
+    unsigned char   usb_buf[17];
+    unsigned int    ret_val = 0;
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Firmware Request packet                        |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x02;
+    usb_buf[0x01]   = 0x5C;
+
+    hid_write(dev, usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Receive packets until 0x11 0x01 is received           |
+    \*-----------------------------------------------------*/
+    do
+    {
+        ret_val = hid_read(dev, usb_buf, sizeof(usb_buf));
+    } while( (ret_val != 17) );
+
+    snprintf(firmware_version, 16, "%u.%u", usb_buf[0x0D], usb_buf[0x0E]);
+}

Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiController.h

@@ -0,0 +1,88 @@
+/*---------------------------------------------------------*\
+|  Definitions for Cryorig H7 Quad Lumi                     |
+|                                                           |
+|  Adam Honse ([email protected]), 4/15/2023        |
+\*---------------------------------------------------------*/
+
+#include "RGBController.h"
+#include <string>
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    CRYORIG_H7_QUAD_LUMI_CHANNEL_ALL    = 0x00,     /* All channels                 */
+    CRYORIG_H7_QUAD_LUMI_CHANNEL_1      = 0x01,     /* Channel 1                    */
+    CRYORIG_H7_QUAD_LUMI_CHANNEL_2      = 0x02,     /* Channel 2                    */
+    CRYORIG_H7_QUAD_LUMI_NUM_CHANNELS   = 0x02      /* Number of channels           */
+};
+
+enum
+{
+    CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST  = 0x00,     /* Slowest speed                */
+    CRYORIG_H7_QUAD_LUMI_SPEED_SLOW     = 0x01,     /* Slow speed                   */
+    CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL   = 0x02,     /* Normal speed                 */
+    CRYORIG_H7_QUAD_LUMI_SPEED_FAST     = 0x03,     /* Fast speed                   */
+    CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST  = 0x04,     /* Fastest speed                */
+};
+
+enum
+{
+    CRYORIG_H7_QUAD_LUMI_MODE_FIXED         = 0x00, /* Fixed colors mode            */
+    CRYORIG_H7_QUAD_LUMI_MODE_FADING        = 0x01, /* Fading mode                  */
+    CRYORIG_H7_QUAD_LUMI_MODE_SPECTRUM      = 0x02, /* Spectrum cycle mode          */
+    CRYORIG_H7_QUAD_LUMI_MODE_MARQUEE       = 0x03, /* Marquee mode                 */
+    CRYORIG_H7_QUAD_LUMI_MODE_COVER_MARQUEE = 0x04, /* Cover marquee mode           */
+    CRYORIG_H7_QUAD_LUMI_MODE_ALTERNATING   = 0x05, /* Alternating mode             */
+    CRYORIG_H7_QUAD_LUMI_MODE_BREATHING     = 0x06, /* Breathing mode               */
+    CRYORIG_H7_QUAD_LUMI_MODE_PULSING       = 0x07, /* Pulsing mode                 */
+};
+
+class CryorigH7QuadLumiController
+{
+public:
+    CryorigH7QuadLumiController(hid_device* dev_handle, const char* path);
+    ~CryorigH7QuadLumiController();
+
+    std::string     GetFirmwareVersion();
+    std::string     GetLocation();
+    std::string     GetSerialString();
+
+    void            SetChannelEffect
+                        (
+                        unsigned char   channel,
+                        unsigned char   mode,
+                        unsigned char   speed,
+                        bool            direction,
+                        RGBColor *      colors,
+                        unsigned int    num_colors
+                        );
+
+    void            SetChannelLEDs
+                        (
+                        unsigned char   channel,
+                        RGBColor *      colors,
+                        unsigned int    num_colors
+                        );
+
+private:
+    hid_device*     dev;
+
+    char            firmware_version[16];
+    std::string     location;
+
+    void            SendPacket
+                        (
+                        unsigned char   channel,
+                        unsigned char   mode,
+                        bool            direction,
+                        unsigned char   color_idx,
+                        unsigned char   speed,
+                        unsigned char   color_count,
+                        unsigned char*  color_data
+                        );
+
+    void            SendFirmwareRequest();
+};

Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiControllerDetect.cpp

@@ -0,0 +1,27 @@
+#include "Detector.h"
+#include "CryorigH7QuadLumiController.h"
+#include "RGBController.h"
+#include "RGBController_CryorigH7QuadLumi.h"
+#include <hidapi/hidapi.h>
+
+/*-----------------------------------------------------*\
+| CRYORIG/NZXT USB IDs                                  |
+\*-----------------------------------------------------*/
+#define NZXT_VID                    0x1E71
+#define CRYORIG_H7_QUAD_LUMI_PID    0x1712
+
+static void DetectCryorigH7QuadLumi(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        CryorigH7QuadLumiController*     controller     = new CryorigH7QuadLumiController(dev, info->path);
+        RGBController_CryorigH7QuadLumi* rgb_controller = new RGBController_CryorigH7QuadLumi(controller);
+        rgb_controller->name                            = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR("CRYORIG H7 Quad Lumi",   DetectCryorigH7QuadLumi, NZXT_VID,   CRYORIG_H7_QUAD_LUMI_PID);

Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.cpp

@@ -0,0 +1,237 @@
+/*-----------------------------------------*\
+|  RGBController_CryorigH7QuadLumi.cpp      |
+|                                           |
+|  Generic RGB Interface for Cryorig H7     |
+|  Quad Lumi                                |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/15/2023   |
+\*-----------------------------------------*/
+
+#include "RGBController_CryorigH7QuadLumi.h"
+
+
+RGBController_CryorigH7QuadLumi::RGBController_CryorigH7QuadLumi(CryorigH7QuadLumiController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "CRYORIG H7 Quad Lumi";
+    vendor      = "CRYORIG";
+    type        = DEVICE_TYPE_COOLER;
+    description = "CRYORIG H7 Quad Lumi Device";
+    version     = controller->GetFirmwareVersion();
+    location    = controller->GetLocation();
+    serial      = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = CRYORIG_H7_QUAD_LUMI_MODE_FIXED;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Fading;
+    Fading.name       = "Fading";
+    Fading.value      = CRYORIG_H7_QUAD_LUMI_MODE_FADING;
+    Fading.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Fading.speed_min  = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
+    Fading.speed_max  = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
+    Fading.colors_min = 1;
+    Fading.colors_max = 8;
+    Fading.speed      = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
+    Fading.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Fading.colors.resize(2);
+    modes.push_back(Fading);
+
+    mode SpectrumCycle;
+    SpectrumCycle.name       = "Rainbow Wave";
+    SpectrumCycle.value      = CRYORIG_H7_QUAD_LUMI_MODE_SPECTRUM;
+    SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    SpectrumCycle.speed_min  = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
+    SpectrumCycle.speed_max  = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
+    SpectrumCycle.speed      = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
+    SpectrumCycle.direction  = MODE_DIRECTION_RIGHT;
+    SpectrumCycle.color_mode = MODE_COLORS_NONE;
+    modes.push_back(SpectrumCycle);
+
+    mode Marquee;
+    Marquee.name             = "Marquee";
+    Marquee.value            = CRYORIG_H7_QUAD_LUMI_MODE_MARQUEE;
+    Marquee.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Marquee.speed_min        = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
+    Marquee.speed_max        = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
+    Marquee.colors_min       = 1;
+    Marquee.colors_max       = 1;
+    Marquee.speed            = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
+    Marquee.direction        = MODE_DIRECTION_RIGHT;
+    Marquee.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    Marquee.colors.resize(1);
+    modes.push_back(Marquee);
+
+    mode CoverMarquee;
+    CoverMarquee.name        = "Cover Marquee";
+    CoverMarquee.value       = CRYORIG_H7_QUAD_LUMI_MODE_COVER_MARQUEE;
+    CoverMarquee.flags       = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    CoverMarquee.speed_min   = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
+    CoverMarquee.speed_max   = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
+    CoverMarquee.colors_min  = 1;
+    CoverMarquee.colors_max  = 8;
+    CoverMarquee.speed       = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
+    CoverMarquee.direction   = MODE_DIRECTION_RIGHT;
+    CoverMarquee.color_mode  = MODE_COLORS_MODE_SPECIFIC;
+    CoverMarquee.colors.resize(2);
+    modes.push_back(CoverMarquee);
+
+    mode Alternating;
+    Alternating.name         = "Alternating";
+    Alternating.value        = CRYORIG_H7_QUAD_LUMI_MODE_ALTERNATING;
+    Alternating.flags        = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Alternating.speed_min    = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
+    Alternating.speed_max    = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
+    Alternating.colors_min   = 1;
+    Alternating.colors_max   = 2;
+    Alternating.speed        = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
+    Alternating.direction    = MODE_DIRECTION_RIGHT;
+    Alternating.color_mode   = MODE_COLORS_MODE_SPECIFIC;
+    Alternating.colors.resize(2);
+    modes.push_back(Alternating);
+
+    mode Pulsing;
+    Pulsing.name             = "Pulsing";
+    Pulsing.value            = CRYORIG_H7_QUAD_LUMI_MODE_PULSING;
+    Pulsing.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Pulsing.speed_min        = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
+    Pulsing.speed_max        = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
+    Pulsing.colors_min       = 1;
+    Pulsing.colors_max       = 8;
+    Pulsing.speed            = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
+    Pulsing.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    Pulsing.colors.resize(2) ;
+    modes.push_back(Pulsing);
+
+    mode Breathing;
+    Breathing.name           = "Breathing";
+    Breathing.value          = CRYORIG_H7_QUAD_LUMI_MODE_BREATHING;
+    Breathing.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.speed_min      = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
+    Breathing.speed_max      = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
+    Breathing.colors_min     = 1;
+    Breathing.colors_max     = 8;
+    Breathing.speed          = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
+    Breathing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors.resize(2);
+    modes.push_back(Breathing);
+
+    SetupZones();
+}
+
+RGBController_CryorigH7QuadLumi::~RGBController_CryorigH7QuadLumi()
+{
+    delete controller;
+}
+
+void RGBController_CryorigH7QuadLumi::SetupZones()
+{
+    const char* zone_names[] = { "Logo", "Underglow" };
+
+    /*-------------------------------------------------*\
+    | Set up zones                                      |
+    \*-------------------------------------------------*/
+    for(unsigned int zone_idx = 0; zone_idx < 2; zone_idx++)
+    {
+        zone* new_zone = new zone;
+
+        new_zone->name          = zone_names[zone_idx];
+        new_zone->type          = ZONE_TYPE_LINEAR;
+        new_zone->leds_min      = 5;
+        new_zone->leds_max      = 5;
+        new_zone->leds_count    = 5;
+        new_zone->matrix_map    = NULL;
+
+        zones.push_back(*new_zone);
+    }
+
+    /*-------------------------------------------------*\
+    | Set up LEDs                                       |
+    \*-------------------------------------------------*/
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
+        {
+            led new_led;
+            new_led.name = zone_names[zone_idx];
+            new_led.name.append(", LED ");
+            new_led.name.append(std::to_string(led_idx + 1));
+            new_led.value = zone_idx;
+
+            leds.push_back(new_led);
+        }
+    }
+
+    SetupColors();
+}
+
+void RGBController_CryorigH7QuadLumi::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
+void RGBController_CryorigH7QuadLumi::DeviceUpdateLEDs()
+{
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        controller->SetChannelLEDs(zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
+    }
+}
+
+void RGBController_CryorigH7QuadLumi::UpdateZoneLEDs(int zone)
+{
+    controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count);
+}
+
+void RGBController_CryorigH7QuadLumi::UpdateSingleLED(int led)
+{
+    unsigned int zone_idx = leds[led].value;
+
+    controller->SetChannelLEDs(zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
+}
+
+void RGBController_CryorigH7QuadLumi::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_CryorigH7QuadLumi::DeviceUpdateMode()
+{
+    if(modes[active_mode].value == CRYORIG_H7_QUAD_LUMI_MODE_FIXED)
+    {
+        DeviceUpdateLEDs();
+    }
+    else
+    {
+        for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+        {
+            RGBColor*   colors      = NULL;
+            bool        direction   = false;
+
+            if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
+            {
+                direction = true;
+            }
+
+            if(modes[active_mode].colors.size() > 0)
+            {
+                colors = &modes[active_mode].colors[0];
+            }
+
+            controller->SetChannelEffect
+                    (
+                    zone_idx,
+                    modes[active_mode].value,
+                    modes[active_mode].speed,
+                    direction,
+                    colors,
+                    modes[active_mode].colors.size()
+                    );
+        }
+    }
+}

Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.h

@@ -0,0 +1,35 @@
+/*-----------------------------------------*\
+|  RGBController_CryorigH7QuadLumi.h        |
+|                                           |
+|  Generic RGB Interface for Cryorig H7     |
+|  Quad Lumi                                |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/15/2023   |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "CryorigH7QuadLumiController.h"
+
+class RGBController_CryorigH7QuadLumi : public RGBController
+{
+public:
+    RGBController_CryorigH7QuadLumi(CryorigH7QuadLumiController* controller_ptr);
+    ~RGBController_CryorigH7QuadLumi();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    CryorigH7QuadLumiController*    controller;
+    std::vector<unsigned int>       leds_channel;
+    std::vector<unsigned int>       zones_channel;
+};

Controllers/DMXController/DMXControllerDetect.cpp

@@ -0,0 +1,142 @@
+#include "Detector.h"
+#include "RGBController.h"
+#include "RGBController_DMX.h"
+#include "SettingsManager.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <fcntl.h>
+#include <string.h>
+#include <fstream>
+#include <iostream>
+#include <string>
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectDMXControllers                                                                   *
+*                                                                                          *
+*       Detect devices supported by the DMX driver                                         *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectDMXControllers()
+{
+    json                dmx_settings;
+
+    std::vector<std::vector<DMXDevice>> device_lists;
+	DMXDevice dev;
+
+    /*-------------------------------------------------*\
+    | Get DMX settings from settings manager            |
+    \*-------------------------------------------------*/
+    dmx_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("DMXDevices");
+
+    /*-------------------------------------------------*\
+    | If the DMX settings contains devices, process     |
+    \*-------------------------------------------------*/
+    if(dmx_settings.contains("devices"))
+    {
+        for(unsigned int device_idx = 0; device_idx < dmx_settings["devices"].size(); device_idx++)
+        {
+            /*-------------------------------------------------*\
+            | Clear DMX device data                             |
+            \*-------------------------------------------------*/
+            dev.name           = "";
+            dev.keepalive_time = 0;
+
+            if(dmx_settings["devices"][device_idx].contains("name"))
+            {
+                dev.name = dmx_settings["devices"][device_idx]["name"];
+            }
+
+            if(dmx_settings["devices"][device_idx].contains("port"))
+            {
+                dev.port = dmx_settings["devices"][device_idx]["port"];
+            }
+
+            if(dmx_settings["devices"][device_idx].contains("keepalive_time"))
+            {
+                dev.keepalive_time = dmx_settings["devices"][device_idx]["keepalive_time"];
+            }
+
+            if(dmx_settings["devices"][device_idx].contains("red_channel"))
+            {
+                dev.red_channel = dmx_settings["devices"][device_idx]["red_channel"];
+            }
+
+            if(dmx_settings["devices"][device_idx].contains("green_channel"))
+            {
+                dev.green_channel = dmx_settings["devices"][device_idx]["green_channel"];
+            }
+
+            if(dmx_settings["devices"][device_idx].contains("blue_channel"))
+            {
+                dev.blue_channel = dmx_settings["devices"][device_idx]["blue_channel"];
+            }
+
+            if(dmx_settings["devices"][device_idx].contains("brightness_channel"))
+            {
+                dev.brightness_channel = dmx_settings["devices"][device_idx]["brightness_channel"];
+            }
+
+            /*---------------------------------------------------------*\
+            | Determine whether to create a new list or add this device |
+            | to an existing list.  A device is added to an existing    |
+            | list if both devices share one or more universes for the  |
+            | same output destination                                   |
+            \*---------------------------------------------------------*/
+            bool device_added_to_existing_list = false;
+
+            /*---------------------------------------------------------*\
+            | Track grouping for all controllers.                       |
+            \*---------------------------------------------------------*/
+            for(unsigned int list_idx = 0; list_idx < device_lists.size(); list_idx++)
+            {
+                for(unsigned int device_idx = 0; device_idx < device_lists[list_idx].size(); device_idx++)
+                {
+                    /*---------------------------------------------------------*\
+                    | Check if the port used by this new device is the same as  |
+                    | in the existing device.  If so, add the new device to the |
+                    | existing list.                                            |
+                    \*---------------------------------------------------------*/
+                    if(1)
+                    {
+                        device_lists[list_idx].push_back(dev);
+                        device_added_to_existing_list = true;
+                        break;
+                    }
+                }
+
+                if(device_added_to_existing_list)
+                {
+                    break;
+                }
+            }
+
+            /*---------------------------------------------------------*\
+            | If the device did not overlap with existing devices,      |
+            | create a new list for it                                  |
+            \*---------------------------------------------------------*/
+            if(!device_added_to_existing_list)
+            {
+                std::vector<DMXDevice> new_list;
+
+                new_list.push_back(dev);
+
+                device_lists.push_back(new_list);
+            }
+        }
+
+
+        for(unsigned int list_idx = 0; list_idx < device_lists.size(); list_idx++)
+        {
+            RGBController_DMX* rgb_controller;
+            rgb_controller = new RGBController_DMX(device_lists[list_idx]);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+    }
+
+}   /* DetectDMXControllers() */
+
+REGISTER_DETECTOR("DMX", DetectDMXControllers);

Controllers/DMXController/RGBController_DMX.cpp

@@ -0,0 +1,231 @@
+/*-----------------------------------------*\
+|  RGBController_DMX.cpp                    |
+|                                           |
+|  Generic RGB Interface for OpenAuraSDK    |
+|  DMX interface                            |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/30/2023   |
+\*-----------------------------------------*/
+
+#include "RGBController_DMX.h"
+#include <math.h>
+
+#include "LogManager.h"
+
+using namespace std::chrono_literals;
+
+/**------------------------------------------------------------------*\
+    @name DMX Devices
+    @category LEDStrip
+    @type Serial
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectDMXControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_DMX::RGBController_DMX(std::vector<DMXDevice> device_list)
+{
+    devices     = device_list;
+
+    name        = "DMX Device Group";
+    type        = DEVICE_TYPE_LEDSTRIP;
+    description = "DMX Device";
+    location    = "DMX: " + devices[0].port;
+
+    /*-----------------------------------------*\
+    | If this controller only represents a      |
+    | single device, use the device name for the|
+    | controller name                           |
+    \*-----------------------------------------*/
+    if(devices.size() == 1)
+    {
+        name    = devices[0].name;
+    }
+
+    /*-----------------------------------------*\
+    | Open OpenDMX port                         |
+    \*-----------------------------------------*/
+    port = new serial_port(devices[0].port.c_str(), 250000, SERIAL_PORT_PARITY_NONE, SERIAL_PORT_SIZE_8, SERIAL_PORT_STOP_BITS_2, false);
+
+    /*-----------------------------------------*\
+    | Clear the RTS signal, which enables the   |
+    | OpenDMX RS-485 drive enable               |
+    \*-----------------------------------------*/
+    port->serial_set_rts(false);
+
+    /*-----------------------------------------*\
+    | Set up modes                              |
+    \*-----------------------------------------*/
+    mode Direct;
+    Direct.name             = "Direct";
+    Direct.value            = 0;
+    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.color_mode       = MODE_COLORS_PER_LED;
+    Direct.brightness       = 255;
+    Direct.brightness_min   = 0;
+    Direct.brightness_max   = 255;
+    modes.push_back(Direct);
+
+    keepalive_delay = 0ms;
+
+    SetupZones();
+
+    for (std::size_t device_idx = 0; device_idx < devices.size(); device_idx++)
+    {
+        /*-----------------------------------------*\
+        | Update keepalive delay                    |
+        \*-----------------------------------------*/
+        if(devices[device_idx].keepalive_time > 0)
+        {
+            if(keepalive_delay.count() == 0 || keepalive_delay.count() > devices[device_idx].keepalive_time)
+            {
+                keepalive_delay = std::chrono::milliseconds(devices[device_idx].keepalive_time);
+            }
+        }
+    }
+
+    if(keepalive_delay.count() > 0)
+    {
+        keepalive_thread_run = 1;
+        keepalive_thread = new std::thread(&RGBController_DMX::KeepaliveThreadFunction, this);
+    }
+    else
+    {
+        keepalive_thread_run = 0;
+        keepalive_thread = nullptr;
+    }
+}
+
+RGBController_DMX::~RGBController_DMX()
+{
+    if(keepalive_thread != nullptr)
+    {
+        keepalive_thread_run = 0;
+        keepalive_thread->join();
+        delete keepalive_thread;
+    }
+
+    /*---------------------------------------------------------*\
+    | Delete the matrix map                                     |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    {
+        if(zones[zone_index].matrix_map != NULL)
+        {
+            if(zones[zone_index].matrix_map->map != NULL)
+            {
+                delete zones[zone_index].matrix_map->map;
+            }
+
+            delete zones[zone_index].matrix_map;
+        }
+    }
+}
+
+void RGBController_DMX::SetupZones()
+{
+    /*-----------------------------------------*\
+    | Add Zones                                 |
+    \*-----------------------------------------*/
+    for(std::size_t zone_idx = 0; zone_idx < devices.size(); zone_idx++)
+    {
+        zone led_zone;
+        led_zone.name           = devices[zone_idx].name;
+        led_zone.type           = ZONE_TYPE_SINGLE;
+        led_zone.leds_min       = 1;
+        led_zone.leds_max       = 1;
+        led_zone.leds_count     = 1;
+        led_zone.matrix_map     = NULL;
+
+        zones.push_back(led_zone);
+    }
+
+    /*-----------------------------------------*\
+    | Add LEDs                                  |
+    \*-----------------------------------------*/
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
+        {
+            led new_led;
+
+            new_led.name = zones[zone_idx].name + " LED ";
+            new_led.name.append(std::to_string(led_idx));
+
+            leds.push_back(new_led);
+        }
+    }
+
+    SetupColors();
+}
+
+void RGBController_DMX::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_DMX::DeviceUpdateLEDs()
+{
+    last_update_time = std::chrono::steady_clock::now();
+
+    unsigned char dmx_data[513];
+
+    memset(dmx_data, 0, sizeof(dmx_data));
+
+    for(unsigned int device_idx = 0; device_idx < devices.size(); device_idx++)
+    {
+        if(devices[device_idx].brightness_channel > 0)
+        {
+            dmx_data[devices[device_idx].brightness_channel] = modes[0].brightness;
+        }
+
+        if(devices[device_idx].red_channel > 0)
+        {
+            dmx_data[devices[device_idx].red_channel]        = RGBGetRValue(colors[device_idx]);
+        }
+
+        if(devices[device_idx].green_channel > 0)
+        {
+            dmx_data[devices[device_idx].green_channel]      = RGBGetGValue(colors[device_idx]);
+        }
+
+        if(devices[device_idx].blue_channel > 0)
+        {
+            dmx_data[devices[device_idx].blue_channel]       = RGBGetBValue(colors[device_idx]);
+        }
+    }
+
+    port->serial_break();
+    port->serial_write((char*)&dmx_data, sizeof(dmx_data));
+}
+
+void RGBController_DMX::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_DMX::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_DMX::DeviceUpdateMode()
+{
+
+}
+
+void RGBController_DMX::KeepaliveThreadFunction()
+{
+    while(keepalive_thread_run.load())
+    {
+        if((std::chrono::steady_clock::now() - last_update_time) > ( keepalive_delay * 0.95f ) )
+        {
+            UpdateLEDs();
+        }
+        std::this_thread::sleep_for(keepalive_delay / 2);
+    }
+}

Controllers/DMXController/RGBController_DMX.h

@@ -0,0 +1,52 @@
+/*-----------------------------------------*\
+|  RGBController_DMX.h                      |
+|                                           |
+|  Generic RGB Interface for OpenAuraSDK    |
+|  DMX interface                            |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/30/2023   |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "serial_port.h"
+#include <chrono>
+#include <thread>
+
+struct DMXDevice
+{
+    std::string name;
+    std::string port;
+    unsigned int keepalive_time;
+    unsigned int red_channel;
+    unsigned int green_channel;
+    unsigned int blue_channel;
+    unsigned int brightness_channel;
+};
+
+class RGBController_DMX : public RGBController
+{
+public:
+    RGBController_DMX(std::vector<DMXDevice> device_list);
+    ~RGBController_DMX();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+    void        KeepaliveThreadFunction();
+
+private:
+	std::vector<DMXDevice> 	                            devices;
+    serial_port *                                       port;
+    std::thread *                                       keepalive_thread;
+    std::atomic<bool>                                   keepalive_thread_run;
+    std::chrono::milliseconds                           keepalive_delay;
+    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
+};

Controllers/DebugController/DebugControllerDetect.cpp

@@ -3,6 +3,7 @@
 #include "RGBController_Debug.h"
 #include "RGBController_Dummy.h"
 #include "RGBControllerKeyNames.h"
+#include "KeyboardLayoutManager.h"
 #include "SettingsManager.h"
 #include <vector>
 #include <stdio.h>
@@ -18,181 +19,11 @@
 //0xFFFFFFFF indicates an unused entry in matrix
 #define NA  0xFFFFFFFF
 
-static unsigned int debug_keyboard_matrix_map[6][23] =
-    { {   0,  NA,  16,  30,  44,  54,  NA,  65,  75,  84,  95,  NA,   8,  23,  38,   6,  22,  36,  49,  NA,  NA,  NA,  NA },
-      {   1,  17,  31,  45,  55,  66,  76,  85,  96,   9,  24,  NA,  39,   7,  37,  NA,  60,  70,  80,  52,  63,  73,  82 },
-      {   2,  NA,  18,  32,  46,  56,  NA,  67,  77,  86,  97,  10,  25,  40,  90, 101,  50,  61,  71,  51,  62,  72,  93 },
-      {   3,  NA,  19,  33,  47,  57,  NA,  68,  78,  87,  98,  11,  26,  41,  28,  14,  NA,  NA,  NA,  92, 103,  53,  NA },
-      {   4,  20,  34,  48,  58,  69,  NA,  79,  NA,  88,  99,  12,  27,  42,  81,  NA,  NA, 102,  NA,  64,  74,  83, 104 },
-      {   5,  21,  35,  NA,  NA,  NA,  NA,  59,  NA,  NA,  NA,  NA,  89, 100,  13,  91,  15,  29,  43,  94,  NA, 105,  NA } };
-
 static unsigned int dummy_keyboard_underglow_map[3][10] =
     { {    0,   1,   2,   3,   4,   5,   6,   7,   8,   9 },
       {   10,  11,  12,  13,  14,  15,  16,  17,  18,  19 },
       {   20,  21,  22,  23,  24,  25,  26,  27,  28,  29 } };
 
-static const char *led_names[] =
-{
-    KEY_EN_ESCAPE,
-    KEY_EN_BACK_TICK,
-    KEY_EN_TAB,
-    KEY_EN_CAPS_LOCK,
-    KEY_EN_LEFT_SHIFT,
-    KEY_EN_LEFT_CONTROL,
-    KEY_EN_F12,
-    KEY_EN_EQUALS,
-    KEY_EN_F9,
-    KEY_EN_9,
-    KEY_EN_O,
-    KEY_EN_L,
-    KEY_EN_COMMA,
-    KEY_EN_MENU,
-    KEY_EN_ISO_ENTER,
-    KEY_EN_LEFT_ARROW,
-    KEY_EN_F1,
-    KEY_EN_1,
-    KEY_EN_Q,
-    KEY_EN_A,
-    KEY_EN_ISO_BACK_SLASH,
-    KEY_EN_LEFT_WINDOWS,
-    KEY_EN_PRINT_SCREEN,
-    KEY_EN_F10,
-    KEY_EN_0,
-    KEY_EN_P,
-    KEY_EN_SEMICOLON,
-    KEY_EN_PERIOD,
-    KEY_EN_ANSI_ENTER,
-    KEY_EN_DOWN_ARROW,
-    KEY_EN_F2,
-    KEY_EN_2,
-    KEY_EN_W,
-    KEY_EN_S,
-    KEY_EN_Z,
-    KEY_EN_LEFT_ALT,
-    KEY_EN_SCROLL_LOCK,
-    KEY_EN_BACKSPACE,
-    KEY_EN_F11,
-    KEY_EN_MINUS,
-    KEY_EN_LEFT_BRACKET,
-    KEY_EN_QUOTE,
-    KEY_EN_FORWARD_SLASH,
-    KEY_EN_RIGHT_ARROW,
-    KEY_EN_F3,
-    KEY_EN_3,
-    KEY_EN_E,
-    KEY_EN_D,
-    KEY_EN_X,
-    KEY_EN_PAUSE_BREAK,
-    KEY_EN_DELETE,
-    KEY_EN_NUMPAD_7,
-    KEY_EN_NUMPAD_LOCK,
-    KEY_EN_NUMPAD_6,
-    KEY_EN_F4,
-    KEY_EN_4,
-    KEY_EN_R,
-    KEY_EN_F,
-    KEY_EN_C,
-    KEY_EN_SPACE,
-    KEY_EN_INSERT,
-    KEY_EN_END,
-    KEY_EN_NUMPAD_8,
-    KEY_EN_NUMPAD_DIVIDE,
-    KEY_EN_NUMPAD_1,
-    KEY_EN_F5,
-    KEY_EN_5,
-    KEY_EN_T,
-    KEY_EN_G,
-    KEY_EN_V,
-    KEY_EN_HOME,
-    KEY_EN_PAGE_DOWN,
-    KEY_EN_NUMPAD_9,
-    KEY_EN_NUMPAD_TIMES,
-    KEY_EN_NUMPAD_2,
-    KEY_EN_F6,
-    KEY_EN_6,
-    KEY_EN_Y,
-    KEY_EN_H,
-    KEY_EN_B,
-    KEY_EN_PAGE_UP,
-    KEY_EN_RIGHT_SHIFT,
-    KEY_EN_NUMPAD_MINUS,
-    KEY_EN_NUMPAD_3,
-    KEY_EN_F7,
-    KEY_EN_7,
-    KEY_EN_U,
-    KEY_EN_J,
-    KEY_EN_N,
-    KEY_EN_RIGHT_ALT,
-    KEY_EN_RIGHT_BRACKET,
-    KEY_EN_RIGHT_CONTROL,
-    KEY_EN_NUMPAD_4,
-    KEY_EN_NUMPAD_PLUS,
-    KEY_EN_NUMPAD_0,
-    KEY_EN_F8,
-    KEY_EN_8,
-    KEY_EN_I,
-    KEY_EN_K,
-    KEY_EN_M,
-    KEY_EN_RIGHT_WINDOWS,
-    KEY_EN_ANSI_BACK_SLASH,
-    KEY_EN_UP_ARROW,
-    KEY_EN_NUMPAD_5,
-    KEY_EN_NUMPAD_ENTER,
-    KEY_EN_NUMPAD_PERIOD,
-    "RGB Strip 1",
-    "RGB Strip 2",
-    "RGB Strip 3",
-    "RGB Strip 4",
-    "RGB Strip 5",
-    "RGB Strip 6",
-    "RGB Strip 7",
-    "RGB Strip 8",
-    "RGB Strip 9",
-    "RGB Strip 10",
-    "RGB Strip 11",
-    "RGB Strip 12",
-    "RGB Strip 13",
-    "RGB Strip 14",
-    "RGB Strip 15",
-    "RGB Strip 16",
-    "RGB Strip 17",
-    "RGB Strip 18",
-    KEY_EN_MEDIA_PREVIOUS,
-    KEY_EN_MEDIA_PLAY_PAUSE,
-    KEY_EN_MEDIA_NEXT,
-    KEY_EN_MEDIA_MUTE,
-    "Underglow LED 1",
-    "Underglow LED 2",
-    "Underglow LED 3",
-    "Underglow LED 4",
-    "Underglow LED 5",
-    "Underglow LED 6",
-    "Underglow LED 7",
-    "Underglow LED 8",
-    "Underglow LED 9",
-    "Underglow LED 10",
-    "Underglow LED 11",
-    "Underglow LED 12",
-    "Underglow LED 13",
-    "Underglow LED 14",
-    "Underglow LED 15",
-    "Underglow LED 16",
-    "Underglow LED 17",
-    "Underglow LED 18",
-    "Underglow LED 19",
-    "Underglow LED 20",
-    "Underglow LED 21",
-    "Underglow LED 22",
-    "Underglow LED 23",
-    "Underglow LED 24",
-    "Underglow LED 25",
-    "Underglow LED 26",
-    "Underglow LED 27",
-    "Underglow LED 28",
-    "Underglow LED 29",
-    "Underglow LED 30"
-};
-
 /******************************************************************************************\
 *                                                                                          *
 *   DetectDebugControllers                                                                 *
@@ -454,14 +285,72 @@ void DetectDebugControllers()
             }
             else if(type == "keyboard")
             {
+                json json_kbd           = debug_settings["devices"][device_idx];
+                KEYBOARD_LAYOUT layout  = KEYBOARD_LAYOUT::KEYBOARD_LAYOUT_ANSI_QWERTY;
+                KEYBOARD_SIZE   size    = KEYBOARD_SIZE::KEYBOARD_SIZE_FULL;
+
+                if(json_kbd.contains("layout"))
+                {
+                    layout = json_kbd["layout"];
+                }
+
+                if(json_kbd.contains("size"))
+                {
+                    size = json_kbd["size"];
+                }
+
                 /*---------------------------------------------------------*\
                 | Create a dummy Keyboard                                   |
                 \*---------------------------------------------------------*/
                 RGBController_Dummy* dummy_keyboard = new RGBController_Dummy();
+                KeyboardLayoutManager new_kb(layout, size);
 
-                dummy_keyboard->name                             = "Debug Keyboard";
+                /*---------------------------------------------------------*\
+                | Check for custom key inserts and swaps                    |
+                \*---------------------------------------------------------*/
+                std::vector<keyboard_led> change;
+
+                if(json_kbd.contains("insert"))
+                {
+
+                    for(size_t i = 0; i < json_kbd["insert"].size(); i++)
+                    {
+                        keyboard_led* key = new keyboard_led;
+
+                        key->zone    = json_kbd["insert"][i]["Zone"];
+                        key->row     = json_kbd["insert"][i]["Row"];
+                        key->col     = json_kbd["insert"][i]["Col"];
+                        key->value   = json_kbd["insert"][i]["Val"];
+                        key->name    = json_kbd["insert"][i]["Name"].get_ref<const std::string&>().c_str();
+                        key->opcode  = KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT;
+
+                        change.push_back(*key);
+                    }
+                }
+
+                if(json_kbd.contains("swap"))
+                {
+                    for(size_t i = 0; i < json_kbd["swap"].size(); i++)
+                    {
+                        keyboard_led* key = new keyboard_led;
+
+                        key->zone   = json_kbd["swap"][i]["Zone"];
+                        key->row    = json_kbd["swap"][i]["Row"];
+                        key->col    = json_kbd["swap"][i]["Col"];
+                        key->value  = json_kbd["swap"][i]["Val"];
+                        key->name   = json_kbd["swap"][i]["Name"].get_ref<const std::string&>().c_str();
+                        key->opcode = KEYBOARD_OPCODE_SWAP_ONLY;
+
+                        change.push_back(*key);
+                    }
+                }
+
+                new_kb.ChangeKeys(change);
+
+                dummy_keyboard->name                             = new_kb.GetName();
                 dummy_keyboard->type                             = DEVICE_TYPE_KEYBOARD;
-                dummy_keyboard->description                      = "Debug Keyboard Device";
+                dummy_keyboard->description                      = dummy_keyboard->name;
+                dummy_keyboard->description.append(" Debug Keyboard");
                 dummy_keyboard->location                         = "Debug Keyboard Location";
                 dummy_keyboard->version                          = "Debug Keyboard Version";
                 dummy_keyboard->serial                           = "Debug Keyboard Serial";
@@ -485,52 +374,88 @@ void DetectDebugControllers()
 
                 dummy_keyboard_matrix_zone.name                  = "Keyboard Matrix Zone";
                 dummy_keyboard_matrix_zone.type                  = ZONE_TYPE_MATRIX;
-                dummy_keyboard_matrix_zone.leds_min              = 106;
-                dummy_keyboard_matrix_zone.leds_max              = 106;
-                dummy_keyboard_matrix_zone.leds_count            = 106;
+                dummy_keyboard_matrix_zone.leds_min              = new_kb.GetKeyCount();
+                dummy_keyboard_matrix_zone.leds_max              = new_kb.GetKeyCount();
+                dummy_keyboard_matrix_zone.leds_count            = new_kb.GetKeyCount();
                 dummy_keyboard_matrix_zone.matrix_map            = new matrix_map_type;
-                dummy_keyboard_matrix_zone.matrix_map->height    = 6;
-                dummy_keyboard_matrix_zone.matrix_map->width     = 23;
-                dummy_keyboard_matrix_zone.matrix_map->map       = (unsigned int*)&debug_keyboard_matrix_map;
+                dummy_keyboard_matrix_zone.matrix_map->height    = new_kb.GetRowCount();
+                dummy_keyboard_matrix_zone.matrix_map->width     = new_kb.GetColumnCount();
+                dummy_keyboard_matrix_zone.matrix_map->map       = new unsigned int[dummy_keyboard_matrix_zone.matrix_map->height
+                                                                                  * dummy_keyboard_matrix_zone.matrix_map->width];
+                new_kb.GetKeyMap(dummy_keyboard_matrix_zone.matrix_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT);
 
                 dummy_keyboard->zones.push_back(dummy_keyboard_matrix_zone);
 
+                for(std::size_t led_idx = 0; led_idx < dummy_keyboard_matrix_zone.leds_count; led_idx++)
+                {
+                    led dummy_keyboard_led;
+                    dummy_keyboard_led.name = new_kb.GetKeyNameAt(led_idx);
+                    dummy_keyboard->leds.push_back(dummy_keyboard_led);
+                }
+
                 /*-----------------------------------------------------------------*\
                 | Add another matrix zone so that is can resemble a huntsman elite  |
                 \*-----------------------------------------------------------------*/
-                zone dummy_keyboard_underglow_matrix_zone;
+                bool underglow = true;
+                if(json_kbd.contains("underglow"))
+                {
+                    underglow = json_kbd["underglow"];
+                }
 
-                dummy_keyboard_underglow_matrix_zone.name               = "Underglow";
-                dummy_keyboard_underglow_matrix_zone.type               = ZONE_TYPE_MATRIX;
-                dummy_keyboard_underglow_matrix_zone.leds_min           = 30;
-                dummy_keyboard_underglow_matrix_zone.leds_max           = 30;
-                dummy_keyboard_underglow_matrix_zone.leds_count         = 30;
-                dummy_keyboard_underglow_matrix_zone.matrix_map         = new matrix_map_type;
-                dummy_keyboard_underglow_matrix_zone.matrix_map->height = 3;
-                dummy_keyboard_underglow_matrix_zone.matrix_map->width  = 10;
-                dummy_keyboard_underglow_matrix_zone.matrix_map->map    = (unsigned int*)&dummy_keyboard_underglow_map;
+                if(underglow)
+                {
+                    zone dummy_keyboard_underglow_matrix_zone;
 
-                dummy_keyboard->zones.push_back(dummy_keyboard_underglow_matrix_zone);
+                    dummy_keyboard_underglow_matrix_zone.name               = "Underglow";
+                    dummy_keyboard_underglow_matrix_zone.type               = ZONE_TYPE_MATRIX;
+                    dummy_keyboard_underglow_matrix_zone.leds_min           = 30;
+                    dummy_keyboard_underglow_matrix_zone.leds_max           = 30;
+                    dummy_keyboard_underglow_matrix_zone.leds_count         = 30;
+                    dummy_keyboard_underglow_matrix_zone.matrix_map         = new matrix_map_type;
+                    dummy_keyboard_underglow_matrix_zone.matrix_map->height = 3;
+                    dummy_keyboard_underglow_matrix_zone.matrix_map->width  = 10;
+                    dummy_keyboard_underglow_matrix_zone.matrix_map->map    = (unsigned int*)&dummy_keyboard_underglow_map;
+
+                    dummy_keyboard->zones.push_back(dummy_keyboard_underglow_matrix_zone);
+
+                    for(std::size_t led_idx = 0; led_idx < dummy_keyboard_underglow_matrix_zone.leds_count; led_idx++)
+                    {
+                        led dummy_keyboard_led;
+                        dummy_keyboard_led.name = dummy_keyboard_underglow_matrix_zone.name + " LED ";
+                        dummy_keyboard_led.name.append(std::to_string(led_idx));
+                        dummy_keyboard->leds.push_back(dummy_keyboard_led);
+                    }
+                }
 
                 /*---------------------------------------------------------*\
-                | Create a linear zone for the dummy GPU                    |
+                | Create a linear zone for the dummy Keyboard               |
                 \*---------------------------------------------------------*/
-                zone dummy_keyboard_linear_zone;
-
-                dummy_keyboard_linear_zone.name                  = "Linear Zone";
-                dummy_keyboard_linear_zone.type                  = ZONE_TYPE_LINEAR;
-                dummy_keyboard_linear_zone.leds_min              = 18;
-                dummy_keyboard_linear_zone.leds_max              = 18;
-                dummy_keyboard_linear_zone.leds_count            = 18;
-                dummy_keyboard_linear_zone.matrix_map            = NULL;
-
-                dummy_keyboard->zones.push_back(dummy_keyboard_linear_zone);
-
-                for(std::size_t led_idx = 0; led_idx < 154; led_idx++)
+                bool linear = true;
+                if(json_kbd.contains("linear"))
                 {
-                    led dummy_keyboard_led;
-                    dummy_keyboard_led.name = led_names[led_idx];
-                    dummy_keyboard->leds.push_back(dummy_keyboard_led);
+                    linear = json_kbd["linear"];
+                }
+
+                if(linear)
+                {
+                    zone dummy_keyboard_linear_zone;
+
+                    dummy_keyboard_linear_zone.name                  = "Linear Zone";
+                    dummy_keyboard_linear_zone.type                  = ZONE_TYPE_LINEAR;
+                    dummy_keyboard_linear_zone.leds_min              = 18;
+                    dummy_keyboard_linear_zone.leds_max              = 18;
+                    dummy_keyboard_linear_zone.leds_count            = 18;
+                    dummy_keyboard_linear_zone.matrix_map            = NULL;
+
+                    dummy_keyboard->zones.push_back(dummy_keyboard_linear_zone);
+
+                    for(std::size_t led_idx = 0; led_idx < dummy_keyboard_linear_zone.leds_count; led_idx++)
+                    {
+                        led dummy_keyboard_led;
+                        dummy_keyboard_led.name = "RGB Strip ";
+                        dummy_keyboard_led.name.append(std::to_string(led_idx));
+                        dummy_keyboard->leds.push_back(dummy_keyboard_led);
+                    }
                 }
 
                 dummy_keyboard->SetupColors();

Controllers/ENESMBusController/ENESMBusController.cpp

@@ -132,6 +132,28 @@ ENESMBusController::ENESMBusController(ENESMBusInterface* interface, ene_dev_id
         // Read LED count from configuration table
         led_count = config_table[ENE_CONFIG_LED_COUNT_0107];
     }
+    // AUMA0-E6K5-1110 - Third generation GPU controller?
+    // found an ASUS ROG Strix 4080 OC, seems to be equal to AUMA0-E6K5-0107
+    else if (strcmp(device_name, "AUMA0-E6K5-1110") == 0)
+    {
+        direct_reg  = ENE_REG_COLORS_DIRECT_V2;
+        effect_reg  = ENE_REG_COLORS_EFFECT_V2;
+        channel_cfg = ENE_CONFIG_CHANNEL_V2;
+
+        // Read LED count from configuration table
+        led_count = config_table[ENE_CONFIG_LED_COUNT_1110];
+    }
+    // AUMA0-E6K5-1107 - Second generation GPU controller
+    // Found on ASUS TUF 4070 TI OC, seems to be equal to AUMA0-E6K5-0107
+    else if (strcmp(device_name, "AUMA0-E6K5-1107") == 0)
+    {
+        direct_reg  = ENE_REG_COLORS_DIRECT_V2;
+        effect_reg  = ENE_REG_COLORS_EFFECT_V2;
+        channel_cfg = ENE_CONFIG_CHANNEL_V2;
+
+        // Read LED count from configuration table
+        led_count = config_table[ENE_CONFIG_LED_COUNT_0107];
+    }
     // Assume first generation controller if string does not match
     else
     {
@@ -163,14 +185,9 @@ std::string ENESMBusController::GetDeviceLocation()
     return(return_string);
 }
 
-unsigned char ENESMBusController::GetChannel(unsigned int led)
+const char * ENESMBusController::GetChannelName(unsigned int cfg_zone)
 {
-    return(config_table[channel_cfg + led]);
-}
-
-const char * ENESMBusController::GetChannelName(unsigned int led)
-{
-    switch (config_table[channel_cfg + led])
+    switch(config_table[channel_cfg + cfg_zone])
     {
     case (unsigned char)ENE_LED_CHANNEL_AUDIO:
         return(ene_channels[0]);
@@ -219,9 +236,9 @@ const char * ENESMBusController::GetChannelName(unsigned int led)
     }
 }
 
-unsigned int ENESMBusController::GetLEDCount()
+unsigned int ENESMBusController::GetLEDCount(unsigned int cfg_zone)
 {
-    return(led_count);
+    return(config_table[0x03 + cfg_zone]);
 }
 
 unsigned char ENESMBusController::GetLEDRed(unsigned int led)

Controllers/ENESMBusController/ENESMBusController.h

@@ -18,7 +18,7 @@
 
 #define ENE_APPLY_VAL                   0x01        /* Value for Apply Changes Register     */
 #define ENE_SAVE_VAL                    0xAA        /* Value for Save Changes               */
-
+#define ENE_NUM_ZONES                   8           /* Number of ENE config table zones     */
 enum
 {
     ENE_REG_DEVICE_NAME                 = 0x1000,   /* Device String 16 bytes               */
@@ -90,6 +90,7 @@ enum
 {
     ENE_CONFIG_LED_COUNT                = 0x02,     /* LED Count configuration offset       */
     ENE_CONFIG_LED_COUNT_0107           = 0x03,     /* LED Count configuration offset       */
+    ENE_CONFIG_LED_COUNT_1110           = 0x03,     /* LED Count configuration offset       */
     ENE_CONFIG_CHANNEL_V1               = 0x13,     /* LED Channel configuration offset     */
     ENE_CONFIG_CHANNEL_V2               = 0x1B,     /* LED Channel V2 configuration offset  */
 };
@@ -102,9 +103,8 @@ public:
 
     std::string   GetDeviceName();
     std::string   GetDeviceLocation();
-    unsigned char GetChannel(unsigned int led);
-    const char*   GetChannelName(unsigned int led);
-    unsigned int  GetLEDCount();
+    const char*   GetChannelName(unsigned int cfg_zone);
+    unsigned int  GetLEDCount(unsigned int cfg_zone);
     unsigned char GetLEDRed(unsigned int led);
     unsigned char GetLEDGreen(unsigned int led);
     unsigned char GetLEDBlue(unsigned int led);

Controllers/ENESMBusController/ENESMBusControllerDetect.cpp

@@ -345,6 +345,7 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060 O12G GAMING",            DetectEN
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060 O12G V2 GAMING",         DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060_O12G_LHR_GAMING,    0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3060 O12G V2 GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_LHR_DEV,     ASUS_SUB_VEN,   ASUS_KO_RTX_3060_O12G_V2_GAMING,            0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3060Ti O8G V2 GAMING",           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_KO_RTX3060TI_O8G_V2_GAMING,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060Ti O8G",                    DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_GDDR6X_DEV,ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G,                   0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3060Ti O8G GAMING",              DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_DEV,       ASUS_SUB_VEN,   ASUS_KO_RTX3060TI_O8G_GAMING,               0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060Ti O8G OC",                 DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060Ti O8G OC",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_3060_TI_O8G_OC,              0x67);
@@ -361,9 +362,11 @@ REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3070 O8G V2 GAMING",             DetectEN
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070 O8G V2 GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,   ASUS_TUF_RTX_3070_O8G_V2_GAMING,            0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070Ti O8G GAMING",           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070TI_O8G_GAMING,       0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070Ti O8G V2 GAMING",          DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3070TI_O8G_V2_GAMING,          0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070Ti O8G V2 GAMING",          DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070TI_GA102_DEV, ASUS_SUB_VEN,   ASUS_TUF_RTX_3070TI_O8G_V2_GAMING_2,        0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070Ti O8G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3070TI_O8G_GAMING,             0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 10G GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_10G_GAMING_PD,            0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 10G GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_10G_GAMING,               0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RTX 3080 10G GUNDAM EDITION",       DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_10G_GUNDAM_EDITION,       0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 O10G OC",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_O10G_OC,                  0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080 10G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_10G_GAMING,         0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080 O10G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O10G_GAMING,        0x67);
@@ -376,6 +379,7 @@ REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 O10G V2 GAMING",           DetectEN
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 O12G GAMING",              DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_12G_LHR_DEV, ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_O12G_GAMING,              0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 3080 12G",                DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_12G_LHR_DEV, ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_12G,                0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 3080 O12G",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_12G_LHR_DEV, ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O12G_OC,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 3080 O12G EVA EDITION",   DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_12G_LHR_DEV, ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O12G_EVA,            0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080Ti 12G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3080TI_12G_GAMING,             0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080Ti O12G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3080TI_O12G_GAMING,            0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080Ti O12G GAMING",          DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080TI_O12G_GAMING,      0x67);
@@ -387,9 +391,15 @@ REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3090 O24G",                     DetectEN
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3090 O24G OC",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3090_O24G_OC,                  0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3090Ti O24G OC GAMING",         DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3090TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3090TI_O24G_OC_GAMING,         0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 4070 Ti 12G Gaming",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_4070TI_12G_GAMING,             0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 4070 Ti O12G Gaming",           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_4070TI_O12G_GAMING,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 4080 16G GAMING",         DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_4080_16G_GAMING,         0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 4080 O16G GAMING",        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_4080_O16G_GAMING,        0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 4080 O16G GAMING",              DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_4080_O16G_GAMING,              0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 4080 O16G OC",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_4080_O16G_OC_GAMING,           0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 4090 O24G OC",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_4090_O24G_OC_GAMING,           0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 4090 O24G",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_4090_O24G_GAMING,              0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 4090 O24G GAMING",        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_4090_O24G_GAMING,        0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 4090 24G GAMING",         DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_4090_24G_GAMING,         0x67);
 
 /*-----------------------------------------*\
 |  AMD GPUs                                 |
@@ -402,6 +412,8 @@ REGISTER_I2C_PCI_DETECTOR("ASUS RX 6800 TUF Gaming OC",                 DetectEN
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 6800 O16G Gaming",         DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_ROG_STRIX_RX_6800_O16G_GAMING,         0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RX 6800XT O16G GAMING",             DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_TUF_RX_6800XT_O16G_GAMING,             0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX LC RX 6800XT O16G GAMING",    DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_ROG_STRIX_LC_RX6800XT_O16G_GAMING,     0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX LC RX 6900XT O16G GAMING",    DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_ROG_STRIX_LC_RX6900XT_O16G_GAMING,     0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX LC RX 6900XT O16G GAMING TOP",DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV2,            ASUS_SUB_VEN,   ASUS_ROG_STRIX_LC_RX6900XT_O16G_GAMING_TOP, 0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RX 6900XT O16G GAMING",             DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_TUF_RX_6900XT_O16G_GAMING,             0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RX 6900XT T16G GAMING",             DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV2,            ASUS_SUB_VEN,   ASUS_TUF_RX_6900XT_T16G_GAMING,             0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RX 6950XT O16G GAMING",             DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV3,            ASUS_SUB_VEN,   ASUS_TUF_RX_6950XT_016G_GAMING,             0x67);

Controllers/ENESMBusController/ENESMBusInterface/ENESMBusInterface_SpectrixS40G.cpp

@@ -10,6 +10,7 @@
 #include "ENESMBusInterface_SpectrixS40G.h"
 #include <sys/ioctl.h>
 #include <cstring>
+#include <cstdint>
 
 /*---------------------------------------------------------------------*\
 | Functions for submitting NVME admin passthrough command taken from    |

Controllers/ENESMBusController/RGBController_ENESMBus.cpp

@@ -7,6 +7,7 @@
 \*-----------------------------------------*/
 
 #include "RGBController_ENESMBus.h"
+#include "LogManager.h"
 
 /**------------------------------------------------------------------*\
     @name ENE SMBus Device
@@ -46,99 +47,112 @@ RGBController_ENESMBus::RGBController_ENESMBus(ENESMBusController * controller_p
     description = "ENE SMBus Device";
 
     mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0xFFFF;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name                 = "Direct";
+    Direct.value                = 0xFFFF;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode Off;
-    Off.name       = "Off";
-    Off.value      = ENE_MODE_OFF;
-    Off.flags      = MODE_FLAG_MANUAL_SAVE;
-    Off.color_mode = MODE_COLORS_NONE;
+    Off.name                    = "Off";
+    Off.value                   = ENE_MODE_OFF;
+    Off.flags                   = MODE_FLAG_MANUAL_SAVE;
+    Off.color_mode              = MODE_COLORS_NONE;
     modes.push_back(Off);
 
     mode Static;
-    Static.name       = "Static";
-    Static.value      = ENE_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
-    Static.color_mode = MODE_COLORS_PER_LED;
+    Static.name                 = "Static";
+    Static.value                = ENE_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Static.color_mode           = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = ENE_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
-    Breathing.color_mode = MODE_COLORS_PER_LED;
-    Breathing.speed_min  = ENE_SPEED_SLOWEST;
-    Breathing.speed_max  = ENE_SPEED_FASTEST;
-    Breathing.speed      = ENE_SPEED_NORMAL;
+    Breathing.name              = "Breathing";
+    Breathing.value             = ENE_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    Breathing.color_mode        = MODE_COLORS_PER_LED;
+    Breathing.speed_min         = ENE_SPEED_SLOWEST;
+    Breathing.speed_max         = ENE_SPEED_FASTEST;
+    Breathing.speed             = ENE_SPEED_NORMAL;
     modes.push_back(Breathing);
 
     mode Flashing;
-    Flashing.name       = "Flashing";
-    Flashing.value      = ENE_MODE_FLASHING;
-    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
-    Flashing.color_mode = MODE_COLORS_PER_LED;
-    Flashing.speed_min  = ENE_SPEED_SLOWEST;
-    Flashing.speed_max  = ENE_SPEED_FASTEST;
-    Flashing.speed      = ENE_SPEED_NORMAL;
+    Flashing.name               = "Flashing";
+    Flashing.value              = ENE_MODE_FLASHING;
+    Flashing.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    Flashing.color_mode         = MODE_COLORS_PER_LED;
+    Flashing.speed_min          = ENE_SPEED_SLOWEST;
+    Flashing.speed_max          = ENE_SPEED_FASTEST;
+    Flashing.speed              = ENE_SPEED_NORMAL;
     modes.push_back(Flashing);
 
     mode SpectrumCycle;
-    SpectrumCycle.name       = "Spectrum Cycle";
-    SpectrumCycle.value      = ENE_MODE_SPECTRUM_CYCLE;
-    SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
-    SpectrumCycle.color_mode = MODE_COLORS_NONE;
-    SpectrumCycle.speed_min  = ENE_SPEED_SLOWEST;
-    SpectrumCycle.speed_max  = ENE_SPEED_FASTEST;
-    SpectrumCycle.speed      = ENE_SPEED_NORMAL;
+    SpectrumCycle.name          = "Spectrum Cycle";
+    SpectrumCycle.value         = ENE_MODE_SPECTRUM_CYCLE;
+    SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    SpectrumCycle.color_mode    = MODE_COLORS_NONE;
+    SpectrumCycle.speed_min     = ENE_SPEED_SLOWEST;
+    SpectrumCycle.speed_max     = ENE_SPEED_FASTEST;
+    SpectrumCycle.speed         = ENE_SPEED_NORMAL;
     modes.push_back(SpectrumCycle);
 
     mode Rainbow;
-    Rainbow.name       = "Rainbow";
-    Rainbow.value      = ENE_MODE_RAINBOW;
-    Rainbow.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
-    Rainbow.color_mode = MODE_COLORS_NONE;
-    Rainbow.speed_min  = ENE_SPEED_SLOWEST;
-    Rainbow.speed_max  = ENE_SPEED_FASTEST;
-    Rainbow.speed      = ENE_SPEED_NORMAL;
-    Rainbow.direction  = MODE_DIRECTION_LEFT;
+    Rainbow.name                = "Rainbow";
+    Rainbow.value               = ENE_MODE_RAINBOW;
+    Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
+    Rainbow.color_mode          = MODE_COLORS_NONE;
+    Rainbow.speed_min           = ENE_SPEED_SLOWEST;
+    Rainbow.speed_max           = ENE_SPEED_FASTEST;
+    Rainbow.speed               = ENE_SPEED_NORMAL;
+    Rainbow.direction           = MODE_DIRECTION_LEFT;
     modes.push_back(Rainbow);
 
     mode ChaseFade;
-    ChaseFade.name       = "Chase Fade";
-    ChaseFade.value      = ENE_MODE_CHASE_FADE;
-    ChaseFade.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
-    ChaseFade.color_mode = MODE_COLORS_PER_LED;
-    ChaseFade.speed_min  = ENE_SPEED_SLOWEST;
-    ChaseFade.speed_max  = ENE_SPEED_FASTEST;
-    ChaseFade.speed      = ENE_SPEED_NORMAL;
-    ChaseFade.direction  = MODE_DIRECTION_LEFT;
+    ChaseFade.name              = "Chase Fade";
+    ChaseFade.value             = ENE_MODE_CHASE_FADE;
+    ChaseFade.flags             = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
+    ChaseFade.color_mode        = MODE_COLORS_PER_LED;
+    ChaseFade.speed_min         = ENE_SPEED_SLOWEST;
+    ChaseFade.speed_max         = ENE_SPEED_FASTEST;
+    ChaseFade.speed             = ENE_SPEED_NORMAL;
+    ChaseFade.direction         = MODE_DIRECTION_LEFT;
     modes.push_back(ChaseFade);
 
     mode Chase;
-    Chase.name       = "Chase";
-    Chase.value      = ENE_MODE_CHASE;
-    Chase.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
-    Chase.color_mode = MODE_COLORS_PER_LED;
-    Chase.speed_min  = ENE_SPEED_SLOWEST;
-    Chase.speed_max  = ENE_SPEED_FASTEST;
-    Chase.speed      = ENE_SPEED_NORMAL;
-    ChaseFade.direction  = MODE_DIRECTION_LEFT;
+    Chase.name                  = "Chase";
+    Chase.value                 = ENE_MODE_CHASE;
+    Chase.flags                 = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
+    Chase.color_mode            = MODE_COLORS_PER_LED;
+    Chase.speed_min             = ENE_SPEED_SLOWEST;
+    Chase.speed_max             = ENE_SPEED_FASTEST;
+    Chase.speed                 = ENE_SPEED_NORMAL;
+    ChaseFade.direction         = MODE_DIRECTION_LEFT;
     modes.push_back(Chase);
 
     mode RandomFlicker;
-    RandomFlicker.name       = "Random Flicker";
-    RandomFlicker.value      = ENE_MODE_RANDOM_FLICKER;
-    RandomFlicker.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
-    RandomFlicker.color_mode = MODE_COLORS_NONE;
-    RandomFlicker.speed_min  = ENE_SPEED_SLOWEST;
-    RandomFlicker.speed_max  = ENE_SPEED_FASTEST;
-    RandomFlicker.speed      = ENE_SPEED_NORMAL;
+    RandomFlicker.name          = "Random Flicker";
+    RandomFlicker.value         = ENE_MODE_RANDOM_FLICKER;
+    RandomFlicker.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    RandomFlicker.color_mode    = MODE_COLORS_NONE;
+    RandomFlicker.speed_min     = ENE_SPEED_SLOWEST;
+    RandomFlicker.speed_max     = ENE_SPEED_FASTEST;
+    RandomFlicker.speed         = ENE_SPEED_NORMAL;
     modes.push_back(RandomFlicker);
 
+    if(1)
+    {
+        mode Mode14;
+        Mode14.name             = "Mode 14";
+        Mode14.value            = 14;
+        Mode14.flags            = MODE_FLAG_HAS_SPEED;
+        Mode14.color_mode       = MODE_COLORS_NONE;
+        Mode14.speed_min        = ENE_SPEED_SLOWEST;
+        Mode14.speed_max        = ENE_SPEED_FASTEST;
+        Mode14.speed            = ENE_SPEED_NORMAL;
+        modes.push_back(Mode14);
+    }
+
     SetupZones();
 
     /*-------------------------------------------------*\
@@ -162,6 +176,8 @@ int RGBController_ENESMBus::GetDeviceMode()
     int speed       = controller->ENERegisterRead(ENE_REG_SPEED);
     int direction   = controller->ENERegisterRead(ENE_REG_DIRECTION);
 
+    LOG_TRACE("[%s] ENE mode: %02d", name.c_str(), dev_mode);
+
     if(controller->ENERegisterRead(ENE_REG_DIRECT))
     {
         dev_mode = 0xFFFF;
@@ -295,94 +311,103 @@ void RGBController_ENESMBus::UpdateSingleLED(int led)
 
 void RGBController_ENESMBus::SetupZones()
 {
-    std::vector<int>    led_map;
-
     /*---------------------------------------------------------*\
     | Search through all LEDs and create zones for each channel |
     | type                                                      |
     \*---------------------------------------------------------*/
-    for(std::size_t led_idx = 0; led_idx < controller->GetLEDCount(); led_idx++)
+    for(std::size_t cfg_zone_idx = 0; cfg_zone_idx < ENE_NUM_ZONES; cfg_zone_idx++)
     {
-        bool matched = false;
-
         /*---------------------------------------------------------*\
-        | Search through existing zones to make sure we don't       |
-        | create a duplicate zone                                   |
+        | Get the number of LEDs in the zone                        |
         \*---------------------------------------------------------*/
-        for(std::size_t existing_zone_idx = 0; existing_zone_idx < zones.size(); existing_zone_idx++)
+        unsigned int leds_in_zone = controller->GetLEDCount(cfg_zone_idx);
+
+        if(leds_in_zone > 0)
         {
-            if(controller->GetChannelName(led_idx) == zones[existing_zone_idx].name)
-            {
-                matched = true;
-            }
-        }
-
-        /*---------------------------------------------------------*\
-        | If zone does not already exist, create it                 |
-        \*---------------------------------------------------------*/
-        if(matched == false)
-        {
-            zone* new_zone = new zone();
-
             /*---------------------------------------------------------*\
-            | Set zone name to channel name                             |
+            | Search through existing zones to make sure we don't       |
+            | create a duplicate zone                                   |
             \*---------------------------------------------------------*/
-            new_zone->name = controller->GetChannelName(led_idx);
+            bool matched                    = false;
+            std::size_t existing_zone_idx   = 0;
 
-            new_zone->leds_count = 0;
-
-            /*---------------------------------------------------------*\
-            | Find all LEDs with this channel type and add them to zone |
-            \*---------------------------------------------------------*/
-            for(std::size_t zone_led_idx = 0; zone_led_idx < controller->GetLEDCount(); zone_led_idx++)
+            for(existing_zone_idx = 0; existing_zone_idx < zones.size(); existing_zone_idx++)
             {
-                if(controller->GetChannelName(zone_led_idx) == new_zone->name)
+                if(controller->GetChannelName(cfg_zone_idx) == zones[existing_zone_idx].name)
                 {
-                    new_zone->leds_count++;
-                    led_map.push_back(zone_led_idx);
+                    matched = true;
+                    break;
                 }
             }
 
             /*---------------------------------------------------------*\
-            | Zones have fixed size, so set min and max to count        |
+            | If zone does not already exist, create it                 |
             \*---------------------------------------------------------*/
-            new_zone->leds_min = new_zone->leds_count;
-            new_zone->leds_max = new_zone->leds_count;
-
-            /*---------------------------------------------------------*\
-            | If this zone has more than one LED, mark it as linear type|
-            \*---------------------------------------------------------*/
-            if(new_zone->leds_count > 1)
+            if(matched == false)
             {
-                new_zone->type = ZONE_TYPE_LINEAR;
+                zone* new_zone = new zone();
+
+                /*---------------------------------------------------------*\
+                | Set zone name to channel name                             |
+                \*---------------------------------------------------------*/
+                new_zone->name = controller->GetChannelName(cfg_zone_idx);
+
+                /*---------------------------------------------------------*\
+                | Set zone LED count to LEDs in zone                        |
+                \*---------------------------------------------------------*/
+                new_zone->leds_count = leds_in_zone;
+
+                /*---------------------------------------------------------*\
+                | Push new zone to zones vector                             |
+                \*---------------------------------------------------------*/
+                zones.push_back(*new_zone);
             }
+            /*---------------------------------------------------------*\
+            | Otherwise, add the number of LEDs from this zone to the   |
+            | existing one.                                             |
+            \*---------------------------------------------------------*/
             else
             {
-                new_zone->type = ZONE_TYPE_SINGLE;
+                zones[existing_zone_idx].leds_count += leds_in_zone;
             }
-
-            new_zone->matrix_map = NULL;
-
-            /*---------------------------------------------------------*\
-            | Push new zone to zones vector                             |
-            \*---------------------------------------------------------*/
-            zones.push_back(*new_zone);
         }
     }
 
+    /*---------------------------------------------------------*\
+    | Finish setting up the zones                               |
+    \*---------------------------------------------------------*/
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        zones[zone_idx].leds_min    = zones[zone_idx].leds_count;
+        zones[zone_idx].leds_max    = zones[zone_idx].leds_count;
+
+        if(zones[zone_idx].leds_count > 1)
+        {
+            zones[zone_idx].type    = ZONE_TYPE_LINEAR;
+        }
+        else
+        {
+            zones[zone_idx].type    = ZONE_TYPE_SINGLE;
+        }
+
+        zones[zone_idx].matrix_map  = NULL;
+    }
+
     /*---------------------------------------------------------*\
     | Create LED entries for each zone                          |
     \*---------------------------------------------------------*/
+    std::size_t led_idx = 0;
     for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
-        for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
+        for(std::size_t zone_led_idx = 0; zone_led_idx < zones[zone_idx].leds_count; zone_led_idx++)
         {
             led* new_led = new led();
 
             new_led->name = zones[zone_idx].name + " LED ";
-            new_led->name.append(std::to_string(led_idx + 1));
+            new_led->name.append(std::to_string(zone_led_idx + 1));
 
-            new_led->value = led_map[led_idx];
+            new_led->value = led_idx;
+            led_idx++;
 
             leds.push_back(*new_led);
         }

Controllers/EVGAAmpereGPUController/EVGAAmpereGPUControllerDetect.cpp

@@ -97,5 +97,6 @@ REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 FTW3 Ultra Hybrid"
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 FTW3 Ultra Hydro Copper"       , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         EVGA_SUB_VEN,   EVGA_RTX3090_FTW3_ULTRA_HC_SUB_DEV,             0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 K|NGP|N Hybrid"                , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         EVGA_SUB_VEN,   EVGA_RTX3090_KINGPIN_HYBRID_SUB_DEV,            0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 K|NGP|N Hydro Copper"          , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         EVGA_SUB_VEN,   EVGA_RTX3090_KINGPIN_HC_SUB_DEV,                0x2D);
+REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090Ti FTW3 Black Gaming"           , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3090TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3090TI_FTW3_BLACK_SUB_DEV,              0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090Ti FTW3 Gaming"                 , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3090TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3090TI_FTW3_GAMING_SUB_DEV,             0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090Ti FTW3 Ultra Gaming"           , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3090TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3090TI_FTW3_ULTRA_GAMING_SUB_DEV,       0x2D);

Controllers/EVGATuringGPUController/EVGATuringGPUControllerDetect.cpp

@@ -36,6 +36,7 @@ void DetectEVGATuringGPUControllers(i2c_smbus_interface* bus, uint8_t address, c
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 XC Black"                        , DetectEVGATuringGPUControllers, NVIDIA_VEN,     NVIDIA_RTX2070_DEV,     EVGA_SUB_VEN,   EVGA_RTX2070_XC_BLACK_SUB_DEV,             0x49);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 XC Gaming"                       , DetectEVGATuringGPUControllers, NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,  EVGA_SUB_VEN,   EVGA_RTX2070_XC_GAMING_SUB_DEV,            0x49);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 XC OC"                           , DetectEVGATuringGPUControllers, NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,  EVGA_SUB_VEN,   EVGA_RTX2070_XC_OC_SUB_DEV,                0x49);
+REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 SUPER XC Gaming"                 , DetectEVGATuringGPUControllers, NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV, EVGA_SUB_VEN,   EVGA_RTX2070S_XC_GAMING_SUB_DEV,           0x49);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 SUPER XC Ultra"                  , DetectEVGATuringGPUControllers, NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV, EVGA_SUB_VEN,   EVGA_RTX2070S_XC_ULTRA_SUB_DEV,            0x49);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 SUPER XC Ultra+"                 , DetectEVGATuringGPUControllers, NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV, EVGA_SUB_VEN,   EVGA_RTX2070S_XC_ULTRA_PLUS_SUB_DEV,       0x49);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 SUPER FTW3 Ultra"                , DetectEVGATuringGPUControllers, NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV, EVGA_SUB_VEN,   EVGA_RTX2070S_FTW3_ULTRA_OC_SUB_DEV,       0x49);

Controllers/EVGAUSBController/EVGAUSBControllerDetect.cpp

@@ -16,6 +16,7 @@
 #define Z15_ISO_PID                             0x260E
 #define Z15_ANSI_PID                            0x2608
 #define Z20_ANSI_PID                            0x260A
+#define Z20_UK_PID                              0x2610
 
 /*-----------------------------------------------------*\
 | Mouse product IDs                                     |
@@ -65,6 +66,7 @@ void DetectWirelessEVGAMouse(hid_device_info* info, const std::string &name)
 REGISTER_HID_DETECTOR_IPU("EVGA Z15 Keyboard",     DetectEVGAKeyboardControllers,   EVGA_USB_VID,   Z15_ISO_PID,                1,  0x08,   0x4B);
 REGISTER_HID_DETECTOR_IPU("EVGA Z15 Keyboard",     DetectEVGAKeyboardControllers,   EVGA_USB_VID,   Z15_ANSI_PID,               1,  0x08,   0x4B);
 REGISTER_HID_DETECTOR_IPU("EVGA Z20 Keyboard",     DetectEVGAKeyboardControllers,   EVGA_USB_VID,   Z20_ANSI_PID,               1,  0x08,   0x4B);
+REGISTER_HID_DETECTOR_IPU("EVGA Z20 Keyboard",     DetectEVGAKeyboardControllers,   EVGA_USB_VID,   Z20_UK_PID,                 1,  0x08,   0x4B);
 
 REGISTER_HID_DETECTOR_IPU("EVGA X20 Gaming Mouse",  DetectWiredEVGAMouse,           EVGA_USB_VID,   X20_WIRED_PID,              2,  0xFFFF, 0);
 REGISTER_HID_DETECTOR_IPU("EVGA X20 USB Receiver",  DetectWirelessEVGAMouse,        EVGA_USB_VID,   X20_WIRELESS_ADAPTER_PID,   2,  0xFFFF, 0);

Controllers/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp

@@ -9,10 +9,12 @@
 | Keyboard product IDs                                  |
 \*-----------------------------------------------------*/
 #define EVISION_KEYBOARD_VID            0x0C45
-#define WOMIER_K87_VID                  0x320F
+#define EVISION_KEYBOARD2_VID           0x320F
 #define EVISION_KEYBOARD_USAGE_PAGE     0xFF1C
+#define GLORIOUS_GMMK_TKL_PID           0x5064
 #define REDRAGON_K550_PID               0x5204
 #define REDRAGON_K552_PID               0x5104
+#define REDRAGON_K552_V2_PID            0x5000
 #define REDRAGON_K556_PID               0x5004
 #define TECWARE_PHANTOM_ELITE_PID       0x652F
 #define WARRIOR_KANE_TC235              0x8520
@@ -45,8 +47,10 @@ void DetectEVisionKeyboards(hid_device_info* info, const std::string& /*name*/)
 \*---------------------------------------------------------------------------------------------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5204",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   REDRAGON_K550_PID,         1, EVISION_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5104",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   REDRAGON_K552_PID,         1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5000",  DetectEVisionKeyboards, EVISION_KEYBOARD2_VID,  REDRAGON_K552_V2_PID,     1, EVISION_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5004",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   REDRAGON_K556_PID,         1, EVISION_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:652F",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   TECWARE_PHANTOM_ELITE_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:8520",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   WARRIOR_KANE_TC235,        1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:502A",  DetectEVisionKeyboards, WOMIER_K87_VID,         WOMIER_K87_PID,            1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:502A",  DetectEVisionKeyboards, EVISION_KEYBOARD2_VID,  WOMIER_K87_PID,            1, EVISION_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:7698",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   WOMIER_K66_PID,            1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5064",  DetectEVisionKeyboards, EVISION_KEYBOARD2_VID,  GLORIOUS_GMMK_TKL_PID,     1, EVISION_KEYBOARD_USAGE_PAGE);

Controllers/EVisionKeyboardController/RGBController_EVisionKeyboard.cpp

@@ -43,176 +43,254 @@ RGBController_EVisionKeyboard::RGBController_EVisionKeyboard(EVisionKeyboardCont
     serial      = controller->GetSerialString();
 
     mode Custom;
-    Custom.name       = "Custom";
-    Custom.value      = EVISION_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          = EVISION_KB_MODE_CUSTOM;
+    Custom.flags          = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Custom.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
+    Custom.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Custom.brightness     = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Custom.color_mode     = MODE_COLORS_PER_LED;
     modes.push_back(Custom);
 
     mode ColorWave;
-    ColorWave.name       = "Color Wave";
-    ColorWave.value      = EVISION_KB_MODE_COLOR_WAVE_LONG;
-    ColorWave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    ColorWave.speed_min  = EVISION_KB_SPEED_SLOWEST;
-    ColorWave.speed_max  = EVISION_KB_SPEED_FASTEST;
-    ColorWave.speed      = EVISION_KB_SPEED_NORMAL;
-    ColorWave.colors_min = 1;
-    ColorWave.colors_max = 1;
-    ColorWave.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorWave.name           = "Color Wave";
+    ColorWave.value          = EVISION_KB_MODE_COLOR_WAVE_LONG;
+    ColorWave.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_AUTOMATIC_SAVE;
+    ColorWave.speed_min      = EVISION_KB_SPEED_SLOWEST;
+    ColorWave.speed_max      = EVISION_KB_SPEED_FASTEST;
+    ColorWave.speed          = EVISION_KB_SPEED_NORMAL;
+    ColorWave.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
+    ColorWave.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
+    ColorWave.brightness     = EVISION_KB_BRIGHTNESS_HIGHEST;
+    ColorWave.direction      = MODE_DIRECTION_LEFT;
+    ColorWave.colors_min     = 1;
+    ColorWave.colors_max     = 1;
+    ColorWave.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     ColorWave.colors.resize(1);
     modes.push_back(ColorWave);
 
+    mode ColorWaveShort;
+    ColorWaveShort.name           = "Color Wave (Short)";
+    ColorWaveShort.value          = EVISION_KB_MODE_COLOR_WAVE_SHORT;
+    ColorWaveShort.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_AUTOMATIC_SAVE;
+    ColorWaveShort.speed_min      = EVISION_KB_SPEED_SLOWEST;
+    ColorWaveShort.speed_max      = EVISION_KB_SPEED_FASTEST;
+    ColorWaveShort.speed          = EVISION_KB_SPEED_NORMAL;
+    ColorWaveShort.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
+    ColorWaveShort.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
+    ColorWaveShort.brightness     = EVISION_KB_BRIGHTNESS_HIGHEST;
+    ColorWaveShort.direction      = MODE_DIRECTION_LEFT;
+    ColorWaveShort.colors_min     = 1;
+    ColorWaveShort.colors_max     = 1;
+    ColorWaveShort.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    ColorWaveShort.colors.resize(1);
+    modes.push_back(ColorWaveShort);
+
     mode ColorWheel;
-    ColorWheel.name       = "Color Wheel";
-    ColorWheel.value      = EVISION_KB_MODE_COLOR_WHEEL;
-    ColorWheel.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    ColorWheel.speed_min  = EVISION_KB_SPEED_SLOWEST;
-    ColorWheel.speed_max  = EVISION_KB_SPEED_FASTEST;
-    ColorWheel.speed      = EVISION_KB_SPEED_NORMAL;
-    ColorWheel.colors_min = 1;
-    ColorWheel.colors_max = 1;
-    ColorWheel.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorWheel.name           = "Color Wheel";
+    ColorWheel.value          = EVISION_KB_MODE_COLOR_WHEEL;
+    ColorWheel.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_AUTOMATIC_SAVE;
+    ColorWheel.speed_min      = EVISION_KB_SPEED_SLOWEST;
+    ColorWheel.speed_max      = EVISION_KB_SPEED_FASTEST;
+    ColorWheel.speed          = EVISION_KB_SPEED_NORMAL;
+    ColorWheel.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
+    ColorWheel.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
+    ColorWheel.brightness     = EVISION_KB_BRIGHTNESS_HIGHEST;
+    ColorWheel.direction      = MODE_DIRECTION_LEFT;
+    ColorWheel.colors_min     = 1;
+    ColorWheel.colors_max     = 1;
+    ColorWheel.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     ColorWheel.colors.resize(1);
     modes.push_back(ColorWheel);
 
     mode SpectrumCycle;
-    SpectrumCycle.name       = "Spectrum Cycle";
-    SpectrumCycle.value      = EVISION_KB_MODE_SPECTRUM_CYCLE;
-    SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-    SpectrumCycle.speed_min  = EVISION_KB_SPEED_SLOWEST;
-    SpectrumCycle.speed_max  = EVISION_KB_SPEED_FASTEST;
-    SpectrumCycle.speed      = EVISION_KB_SPEED_NORMAL;
-    SpectrumCycle.color_mode = MODE_COLORS_NONE;
+    SpectrumCycle.name           = "Spectrum Cycle";
+    SpectrumCycle.value          = EVISION_KB_MODE_SPECTRUM_CYCLE;
+    SpectrumCycle.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    SpectrumCycle.speed_min      = EVISION_KB_SPEED_SLOWEST;
+    SpectrumCycle.speed_max      = EVISION_KB_SPEED_FASTEST;
+    SpectrumCycle.speed          = EVISION_KB_SPEED_NORMAL;
+    SpectrumCycle.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
+    SpectrumCycle.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
+    SpectrumCycle.brightness     = EVISION_KB_BRIGHTNESS_HIGHEST;
+    SpectrumCycle.color_mode     = MODE_COLORS_NONE;
     modes.push_back(SpectrumCycle);
 
     mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = EVISION_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  = EVISION_KB_SPEED_SLOWEST;
-    Breathing.speed_max  = EVISION_KB_SPEED_FASTEST;
-    Breathing.speed      = EVISION_KB_SPEED_NORMAL;
-    Breathing.colors_min = 1;
-    Breathing.colors_max = 1;
-    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.name           = "Breathing";
+    Breathing.value          = EVISION_KB_MODE_BREATHING;
+    Breathing.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Breathing.speed_min      = EVISION_KB_SPEED_SLOWEST;
+    Breathing.speed_max      = EVISION_KB_SPEED_FASTEST;
+    Breathing.speed          = EVISION_KB_SPEED_NORMAL;
+    Breathing.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
+    Breathing.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Breathing.brightness     = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Breathing.colors_min     = 1;
+    Breathing.colors_max     = 1;
+    Breathing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Breathing.colors.resize(1);
     modes.push_back(Breathing);
 
     mode Hurricane;
-    Hurricane.name       = "Hurricane";
-    Hurricane.value      = EVISION_KB_MODE_HURRICANE;
-    Hurricane.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Hurricane.speed_min  = EVISION_KB_SPEED_SLOWEST;
-    Hurricane.speed_max  = EVISION_KB_SPEED_FASTEST;
-    Hurricane.speed      = EVISION_KB_SPEED_NORMAL;
-    Hurricane.colors_min = 1;
-    Hurricane.colors_max = 1;
-    Hurricane.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Hurricane.name           = "Hurricane";
+    Hurricane.value          = EVISION_KB_MODE_HURRICANE;
+    Hurricane.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Hurricane.speed_min      = EVISION_KB_SPEED_SLOWEST;
+    Hurricane.speed_max      = EVISION_KB_SPEED_FASTEST;
+    Hurricane.speed          = EVISION_KB_SPEED_NORMAL;
+    Hurricane.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
+    Hurricane.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Hurricane.brightness     = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Hurricane.colors_min     = 1;
+    Hurricane.colors_max     = 1;
+    Hurricane.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Hurricane.colors.resize(1);
     modes.push_back(Hurricane);
 
     mode Accumulate;
-    Accumulate.name       = "Accumulate";
-    Accumulate.value      = EVISION_KB_MODE_ACCUMULATE;
-    Accumulate.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Accumulate.speed_min  = EVISION_KB_SPEED_SLOWEST;
-    Accumulate.speed_max  = EVISION_KB_SPEED_FASTEST;
-    Accumulate.speed      = EVISION_KB_SPEED_NORMAL;
-    Accumulate.colors_min = 1;
-    Accumulate.colors_max = 1;
-    Accumulate.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Accumulate.name           = "Accumulate";
+    Accumulate.value          = EVISION_KB_MODE_ACCUMULATE;
+    Accumulate.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Accumulate.speed_min      = EVISION_KB_SPEED_SLOWEST;
+    Accumulate.speed_max      = EVISION_KB_SPEED_FASTEST;
+    Accumulate.speed          = EVISION_KB_SPEED_NORMAL;
+    Accumulate.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
+    Accumulate.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Accumulate.brightness     = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Accumulate.colors_min     = 1;
+    Accumulate.colors_max     = 1;
+    Accumulate.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Accumulate.colors.resize(1);
     modes.push_back(Accumulate);
 
     mode Starlight;
-    Starlight.name       = "Starlight";
-    Starlight.value      = EVISION_KB_MODE_STARLIGHT_FAST;
-    Starlight.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Starlight.speed_min  = EVISION_KB_SPEED_SLOWEST;
-    Starlight.speed_max  = EVISION_KB_SPEED_FASTEST;
-    Starlight.speed      = EVISION_KB_SPEED_NORMAL;
-    Starlight.colors_min = 1;
-    Starlight.colors_max = 1;
-    Starlight.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Starlight.name           = "Starlight";
+    Starlight.value          = EVISION_KB_MODE_STARLIGHT_FAST;
+    Starlight.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Starlight.speed_min      = EVISION_KB_SPEED_SLOWEST;
+    Starlight.speed_max      = EVISION_KB_SPEED_FASTEST;
+    Starlight.speed          = EVISION_KB_SPEED_NORMAL;
+    Starlight.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
+    Starlight.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Starlight.brightness     = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Starlight.colors_min     = 1;
+    Starlight.colors_max     = 1;
+    Starlight.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Starlight.colors.resize(1);
     modes.push_back(Starlight);
 
     mode Visor;
-    Visor.name       = "Visor";
-    Visor.value      = EVISION_KB_MODE_VISOR;
-    Visor.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Visor.speed_min  = EVISION_KB_SPEED_SLOWEST;
-    Visor.speed_max  = EVISION_KB_SPEED_FASTEST;
-    Visor.speed      = EVISION_KB_SPEED_NORMAL;
-    Visor.colors_min = 1;
-    Visor.colors_max = 1;
-    Visor.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Visor.name           = "Visor";
+    Visor.value          = EVISION_KB_MODE_VISOR;
+    Visor.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Visor.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
+    Visor.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Visor.brightness     = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Visor.colors_min     = 1;
+    Visor.colors_max     = 1;
+    Visor.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Visor.colors.resize(1);
     modes.push_back(Visor);
 
     mode Static;
-    Static.name       = "Static";
-    Static.value      = EVISION_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          = EVISION_KB_MODE_STATIC;
+    Static.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Static.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
+    Static.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Static.brightness     = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Static.colors_min     = 1;
+    Static.colors_max     = 1;
+    Static.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Static.colors.resize(1);
     modes.push_back(Static);
 
     mode RainbowCircle;
-    RainbowCircle.name       = "Rainbow Circle";
-    RainbowCircle.value      = EVISION_KB_MODE_RAINBOW_WAVE_CIRCLE;
-    RainbowCircle.flags      = MODE_FLAG_AUTOMATIC_SAVE;
-    RainbowCircle.color_mode = MODE_COLORS_NONE;
+    RainbowCircle.name           = "Rainbow Circle";
+    RainbowCircle.value          = EVISION_KB_MODE_RAINBOW_WAVE_CIRCLE;
+    RainbowCircle.flags          = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    RainbowCircle.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
+    RainbowCircle.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
+    RainbowCircle.brightness     = EVISION_KB_BRIGHTNESS_HIGHEST;
+    RainbowCircle.color_mode     = MODE_COLORS_RANDOM;
     modes.push_back(RainbowCircle);
 
+    mode VerticalRainbow;
+    VerticalRainbow.name           = "Vertical Rainbow";
+    VerticalRainbow.value          = EVISION_KB_MODE_RAINBOW_WAVE_VERTICAL;
+    VerticalRainbow.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
+    VerticalRainbow.speed_min      = EVISION_KB_SPEED_SLOWEST;
+    VerticalRainbow.speed_max      = EVISION_KB_SPEED_FASTEST;
+    VerticalRainbow.speed          = EVISION_KB_SPEED_NORMAL;
+    VerticalRainbow.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
+    VerticalRainbow.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
+    VerticalRainbow.brightness     = EVISION_KB_BRIGHTNESS_HIGHEST;
+    VerticalRainbow.direction      = MODE_DIRECTION_UP;
+    VerticalRainbow.colors_min     = 1;
+    VerticalRainbow.colors_max     = 1;
+    VerticalRainbow.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    VerticalRainbow.colors.resize(1);
+    modes.push_back(VerticalRainbow);
+
     mode Blooming;
-    Blooming.name       = "Blooming";
-    Blooming.value      = EVISION_KB_MODE_BLOOMING;
-    Blooming.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-    Blooming.speed_min  = EVISION_KB_SPEED_SLOWEST;
-    Blooming.speed_max  = EVISION_KB_SPEED_FASTEST;
-    Blooming.speed      = EVISION_KB_SPEED_NORMAL;
-    Blooming.color_mode = MODE_COLORS_NONE;
+    Blooming.name           = "Blooming";
+    Blooming.value          = EVISION_KB_MODE_BLOOMING;
+    Blooming.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Blooming.speed_min      = EVISION_KB_SPEED_SLOWEST;
+    Blooming.speed_max      = EVISION_KB_SPEED_FASTEST;
+    Blooming.speed          = EVISION_KB_SPEED_NORMAL;
+    Blooming.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
+    Blooming.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Blooming.brightness     = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Blooming.color_mode     = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
     modes.push_back(Blooming);
 
     mode Reactive;
-    Reactive.name       = "Reactive";
-    Reactive.value      = EVISION_KB_MODE_REACTIVE;
-    Reactive.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Reactive.speed_min  = EVISION_KB_SPEED_SLOWEST;
-    Reactive.speed_max  = EVISION_KB_SPEED_FASTEST;
-    Reactive.speed      = EVISION_KB_SPEED_NORMAL;
-    Reactive.colors_min = 1;
-    Reactive.colors_max = 1;
-    Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Reactive.name           = "Reactive";
+    Reactive.value          = EVISION_KB_MODE_REACTIVE;
+    Reactive.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Reactive.speed_min      = EVISION_KB_SPEED_SLOWEST;
+    Reactive.speed_max      = EVISION_KB_SPEED_FASTEST;
+    Reactive.speed          = EVISION_KB_SPEED_NORMAL;
+    Reactive.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
+    Reactive.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Reactive.brightness     = EVISION_KB_BRIGHTNESS_HIGHEST;
+    Reactive.colors_min     = 1;
+    Reactive.colors_max     = 1;
+    Reactive.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Reactive.colors.resize(1);
     modes.push_back(Reactive);
 
     mode ReactiveRipple;
-    ReactiveRipple.name       = "Reactive Ripple";
-    ReactiveRipple.value      = EVISION_KB_MODE_REACTIVE_RIPPLE;
-    ReactiveRipple.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    ReactiveRipple.speed_min  = EVISION_KB_SPEED_SLOWEST;
-    ReactiveRipple.speed_max  = EVISION_KB_SPEED_FASTEST;
-    ReactiveRipple.speed      = EVISION_KB_SPEED_NORMAL;
-    ReactiveRipple.colors_min = 1;
-    ReactiveRipple.colors_max = 1;
-    ReactiveRipple.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ReactiveRipple.name           = "Reactive Ripple";
+    ReactiveRipple.value          = EVISION_KB_MODE_REACTIVE_RIPPLE;
+    ReactiveRipple.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    ReactiveRipple.speed_min      = EVISION_KB_SPEED_SLOWEST;
+    ReactiveRipple.speed_max      = EVISION_KB_SPEED_FASTEST;
+    ReactiveRipple.speed          = EVISION_KB_SPEED_NORMAL;
+    ReactiveRipple.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
+    ReactiveRipple.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
+    ReactiveRipple.brightness     = EVISION_KB_BRIGHTNESS_HIGHEST;
+    ReactiveRipple.colors_min     = 1;
+    ReactiveRipple.colors_max     = 1;
+    ReactiveRipple.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     ReactiveRipple.colors.resize(1);
     modes.push_back(ReactiveRipple);
 
     mode ReactiveLine;
-    ReactiveLine.name       = "Reactive Line";
-    ReactiveLine.value      = EVISION_KB_MODE_REACTIVE_LINE;
-    ReactiveLine.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    ReactiveLine.speed_min  = EVISION_KB_SPEED_SLOWEST;
-    ReactiveLine.speed_max  = EVISION_KB_SPEED_FASTEST;
-    ReactiveLine.speed      = EVISION_KB_SPEED_NORMAL;
-    ReactiveLine.colors_min = 1;
-    ReactiveLine.colors_max = 1;
-    ReactiveLine.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ReactiveLine.name           = "Reactive Line";
+    ReactiveLine.value          = EVISION_KB_MODE_REACTIVE_LINE;
+    ReactiveLine.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    ReactiveLine.speed_min      = EVISION_KB_SPEED_SLOWEST;
+    ReactiveLine.speed_max      = EVISION_KB_SPEED_FASTEST;
+    ReactiveLine.speed          = EVISION_KB_SPEED_NORMAL;
+    ReactiveLine.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
+    ReactiveLine.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
+    ReactiveLine.brightness     = EVISION_KB_BRIGHTNESS_HIGHEST;
+    ReactiveLine.colors_min     = 1;
+    ReactiveLine.colors_max     = 1;
+    ReactiveLine.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     ReactiveLine.colors.resize(1);
     modes.push_back(ReactiveLine);
 
@@ -314,14 +392,14 @@ void RGBController_EVisionKeyboard::DeviceUpdateMode()
     }
 
     controller->SendKeyboardModeEx
-                    (
-                    modes[active_mode].value,
-                    EVISION_KB_BRIGHTNESS_HIGHEST,
-                    modes[active_mode].speed,
-                    0,
-                    random,
-                    red,
-                    grn,
-                    blu
-                    );
+            (
+            modes[active_mode].value,
+            modes[active_mode].brightness,
+            modes[active_mode].speed,
+            modes[active_mode].direction,
+            random,
+            red,
+            grn,
+            blu
+            );
 }

Controllers/EpomakerController/EpomakerController.cpp

@@ -0,0 +1,128 @@
+/*-------------------------------------------------------------------*\
+|  EpomakerController.cpp                                             |
+|                                                                     |
+|  Driver for Epomaker Keyboard                                       |
+|                                                                     |
+|  Alvaro Munoz (alvaromunoz)          2023-06-05                     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "EpomakerController.h"
+#include <math.h>
+
+EpomakerController::EpomakerController(hid_device* dev_handle, char *_path)
+{
+    const int szTemp = 256;
+    wchar_t tmpName[szTemp];
+
+    dev = dev_handle;
+
+    hid_get_manufacturer_string(dev, tmpName, szTemp);
+    std::wstring wName = std::wstring(tmpName);
+    device_name = std::string(wName.begin(), wName.end());
+
+    hid_get_product_string(dev, tmpName, szTemp);
+    wName = std::wstring(tmpName);
+    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
+
+    hid_get_serial_number_string(dev, tmpName, szTemp);
+    wName = std::wstring(tmpName);
+    serial = std::string(wName.begin(), wName.end());
+
+    location = _path;
+
+    current_mode  = Epomaker_MODE_ALWAYS_ON;
+    current_speed = Epomaker_SPEED_DEFAULT;
+    current_brightness = Epomaker_BRIGHTNESS_DEFAULT;
+    current_dazzle = Epomaker_OPTION_DAZZLE_OFF;
+    current_option = Epomaker_OPTION_DEFAULT;
+
+}
+
+EpomakerController::~EpomakerController()
+{
+    hid_close(dev);
+}
+
+std::string EpomakerController::GetDeviceName()
+{
+    return (device_name);
+}
+
+std::string EpomakerController::GetSerial()
+{
+    return (serial);
+}
+
+std::string EpomakerController::GetLocation()
+{
+    return ("HID: " + location);
+}
+
+void EpomakerController::SetMode(unsigned char mode, unsigned char speed, unsigned char brightness)
+{
+    current_mode  = mode;
+    current_speed = speed;
+    current_brightness = brightness;
+
+    SendUpdate();
+}
+
+void EpomakerController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    current_red   = red;
+    current_green = green;
+    current_blue  = blue;
+
+    SendUpdate();
+}
+
+void EpomakerController::SetDazzle(bool is_dazzle)
+{
+    if(is_dazzle)
+    {
+        current_dazzle = Epomaker_OPTION_DAZZLE_ON;
+    }
+    else
+    {
+        current_dazzle = Epomaker_OPTION_DAZZLE_OFF;
+    }
+}
+
+void EpomakerController::SetOption(unsigned char option)
+{
+    current_option = option;
+}
+
+void EpomakerController::SendUpdate()
+{
+    unsigned char command[Epomaker_PACKET_LENGTH] = { 0x00 };
+    command[0] = 0xf6;
+    command[1] = 0x0a;
+
+    unsigned char buffer[Epomaker_PACKET_LENGTH] = { 0x00 };
+    int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
+
+    buffer[Epomaker_BYTE_COMMAND]    = Epomaker_COMMAND_RGB;
+    buffer[Epomaker_BYTE_MODE]       = current_mode;
+    buffer[Epomaker_BYTE_SPEED]      = current_speed;
+    buffer[Epomaker_BYTE_BRIGHTNESS] = current_brightness;
+    buffer[Epomaker_BYTE_FLAGS]      = current_option | current_dazzle;
+    buffer[Epomaker_BYTE_RED]        = current_red;
+    buffer[Epomaker_BYTE_GREEN]      = current_green;
+    buffer[Epomaker_BYTE_BLUE]       = current_blue;
+
+    int sum_bits = 0;
+    for (int i=Epomaker_BYTE_COMMAND; i<=Epomaker_BYTE_BLUE; i++)
+    {
+        sum_bits += buffer[i];
+    }
+
+    int next_pow2 = pow(2, ceil(log2(sum_bits)));
+    int filler = next_pow2 - sum_bits - 1;
+
+    buffer[Epomaker_BYTE_FILLER]     = filler;
+
+    hid_send_feature_report(dev, command, buffer_size);
+    hid_send_feature_report(dev, buffer, buffer_size);
+}

Controllers/EpomakerController/EpomakerController.h

@@ -0,0 +1,126 @@
+/*-------------------------------------------------------------------*\
+|  EpomakerController.h                                               |
+|                                                                     |
+|  Driver for Epomaker Keyboard                                       |
+|                                                                     |
+|  Alvaro Munoz (alvaromunoz)          2023-06-05                     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#ifndef EpomakerCONTROLLER_H
+#define EpomakerCONTROLLER_H
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#define Epomaker_PACKET_LENGTH 0x40
+#define Epomaker_COMMAND_RGB   0x07
+#define Epomaker_COMMAND_SET   0xf60a
+#define Epomaker_COMMAND_PING  0xf7
+
+enum
+{
+    Epomaker_BYTE_COMMAND                           = 0,
+    Epomaker_BYTE_MODE                              = 1,
+    Epomaker_BYTE_SPEED                             = 2,
+    Epomaker_BYTE_BRIGHTNESS                        = 3,
+    Epomaker_BYTE_FLAGS                             = 4,
+    Epomaker_BYTE_RED                               = 5,
+    Epomaker_BYTE_GREEN                             = 6,
+    Epomaker_BYTE_BLUE                              = 7,
+    Epomaker_BYTE_FILLER                            = 8
+};
+
+enum
+{
+    Epomaker_MODE_ALWAYS_ON                         = 0x01,
+    Epomaker_MODE_DYNAMIC_BREATHING                 = 0x02,
+    Epomaker_MODE_SPECTRUM_CYCLE                    = 0x03,
+    Epomaker_MODE_DRIFT                             = 0x04,
+    Epomaker_MODE_WAVES_RIPPLE                      = 0x05,
+    Epomaker_MODE_STARS_TWINKLE                     = 0x06,
+    Epomaker_MODE_STEADY_STREAM                     = 0x07,
+    Epomaker_MODE_SHADOWING                         = 0x08,
+    Epomaker_MODE_PEAKS_RISING_ONE_AFTER_ANOTHER    = 0x09,
+    Epomaker_MODE_SINE_WAVE                         = 0x0a,
+    Epomaker_MODE_CAISPRING_SURGING                 = 0x0b,
+    Epomaker_MODE_FLOWERS_BLOOMING                  = 0x0c,
+    Epomaker_MODE_LASER                             = 0x0e,
+    Epomaker_MODE_PEAK_TURN                         = 0x0f,
+    Epomaker_MODE_INCLINED_RAIN                     = 0x10,
+    Epomaker_MODE_SNOW                              = 0x11,
+    Epomaker_MODE_METEOR                            = 0x12,
+    Epomaker_MODE_THROUGH_THE_SNOW_NON_TRACE        = 0x13,
+    Epomaker_MODE_LIGHT_SHADOW                      = 0x15
+};
+
+enum
+{
+    Epomaker_SPEED_MIN                              = 0x00,
+    Epomaker_SPEED_MAX                              = 0x05,
+    Epomaker_SPEED_MAX_SPECIAL                      = 0x04,
+    Epomaker_SPEED_DEFAULT                          = 0x04
+};
+
+enum
+{
+    Epomaker_BRIGHTNESS_MIN                         = 0x00,
+    Epomaker_BRIGHTNESS_MAX                         = 0x04,
+    Epomaker_BRIGHTNESS_DEFAULT                     = 0x04
+};
+
+enum
+{
+    Epomaker_OPTION_DAZZLE_OFF                      = 0x07,
+    Epomaker_OPTION_DAZZLE_ON                       = 0x08,
+    Epomaker_OPTION_DEFAULT                         = 0x00,
+    Epomaker_OPTION_DRIFT_RIGHT                     = 0X00,
+    Epomaker_OPTION_DRIFT_LEFT                      = 0X10,
+    Epomaker_OPTION_DRIFT_DOWN                      = 0X20,
+    Epomaker_OPTION_DRIFT_UP                        = 0X30,
+    Epomaker_OPTION_STEADY_STREAM_ZIG_ZAG           = 0x00,
+    Epomaker_OPTION_STEADY_STREAM_RETURN            = 0x10,
+    Epomaker_OPTION_CAISPRING_SURGING_OUT           = 0x00,
+    Epomaker_OPTION_CAISPRING_SURGING_IN            = 0x10,
+    Epomaker_OPTION_FLOWERS_BLOOMING_RIGHT          = 0x00,
+    Epomaker_OPTION_FLOWERS_BLOOMING_LEFT           = 0x10,
+    Epomaker_OPTION_PEAK_TURN_ANTI_CLOCKWISE        = 0x00,
+    Epomaker_OPTION_PEAK_TURN_CLOCKWISE             = 0x10,
+};
+
+class EpomakerController
+{
+public:
+    EpomakerController(hid_device* dev_handle, char *_path);
+    ~EpomakerController();
+
+    std::string GetDeviceName();
+    std::string GetSerial();
+    std::string GetLocation();
+
+    void SetDazzle(bool is_dazzle);
+    void SetOption(unsigned char option);
+
+    void SetMode(unsigned char mode, unsigned char speed, unsigned char brightness);
+    void SetColor(unsigned char red, unsigned char green, unsigned char blue);
+
+private:
+    std::string             device_name;
+    std::string             serial;
+    std::string             location;
+    hid_device*             dev;
+
+    unsigned char           current_mode;
+    unsigned char           current_speed;
+    unsigned char           current_brightness;
+    unsigned char           current_dazzle;
+    unsigned char           current_option;
+
+    unsigned char           current_red;
+    unsigned char           current_green;
+    unsigned char           current_blue;
+
+    void SendUpdate();
+};
+
+#endif // EpomakerCONTROLLER_H

Controllers/EpomakerController/EpomakerControllerDetect.cpp

@@ -0,0 +1,39 @@
+#include "Detector.h"
+#include "EpomakerController.h"
+#include "RGBController.h"
+#include "RGBController_EpomakerController.h"
+#include <hidapi/hidapi.h>
+
+#define Epomaker_VID                    0x3151
+#define Epomaker_TH80_Pro_USB_PID       0x4010
+#define Epomaker_TH80_Pro_Dongle_PID    0x4011
+#define Epomaker_TH80_Pro_BT_PID        0x4013
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectEpomakerControllers                                                              *
+*                                                                                          *
+*       Tests the USB address to see if any Epomaker Controllers exists there.             *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectEpomakerControllers(hid_device_info* info, const std::string&)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        EpomakerController*               controller     = new EpomakerController(dev, info->path);
+        RGBController_EpomakerController* rgb_controller = new RGBController_EpomakerController(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}   /* DetectEpomakerControllers() */
+
+REGISTER_HID_DETECTOR_IPU("Epomaker TH80 Pro (USB Cable)", DetectEpomakerControllers, Epomaker_VID, Epomaker_TH80_Pro_USB_PID, 1, 1, 2);
+REGISTER_HID_DETECTOR_IPU("Epomaker TH80 Pro (USB Dongle)", DetectEpomakerControllers, Epomaker_VID, Epomaker_TH80_Pro_Dongle_PID, 1, 1, 2);
+
+/*---------------------------------------------------------*\
+| Bluetooth Not implemented                                 |
+\*---------------------------------------------------------*/
+//REGISTER_HID_DETECTOR("Epomaker TH80 Pro (Bluetooth)", DetectEpomakerControllers, Epomaker_VID, Epomaker_TH80_Pro_BT_PID);

Controllers/EpomakerController/RGBController_EpomakerController.cpp

@@ -0,0 +1,411 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_EpomakerController.cpp                               |
+|                                                                     |
+|  Driver for Epomaker Keyboard                                       |
+|                                                                     |
+|  Alvaro Munoz (alvaromunoz)          2023-06-05                     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "RGBControllerKeyNames.h"
+#include "RGBController_EpomakerController.h"
+
+/**------------------------------------------------------------------*\
+    @name Epomaker TH80 Pro
+    @category Keyboard
+    @type USB
+    @save :robot:
+    @direct :x:
+    @effects :white_check_mark:
+    @detectors EpomakerControllerDetect
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_EpomakerController::RGBController_EpomakerController(EpomakerController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = controller->GetDeviceName();
+    vendor      = "Epomaker";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = controller->GetDeviceName();
+    serial      = controller->GetSerial();
+    location    = controller->GetLocation();
+
+    mode Off;
+    Off.name                                    = "Off";
+    Off.value                                   = 0;
+    Off.flags                                   = 0;
+    Off.color_mode                              = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Always_on;
+    Always_on.name                              = "Static";
+    Always_on.value                             = Epomaker_MODE_ALWAYS_ON;
+    Always_on.flags                             = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Always_on.color_mode                        = MODE_COLORS_PER_LED | MODE_COLORS_RANDOM;
+    Always_on.brightness_min                    = Epomaker_BRIGHTNESS_MIN;
+    Always_on.brightness_max                    = Epomaker_BRIGHTNESS_MAX;
+    Always_on.brightness                        = Epomaker_BRIGHTNESS_DEFAULT;
+    modes.push_back(Always_on);
+
+    mode Dynamic_breathing;
+    Dynamic_breathing.name                      = "Breathing";
+    Dynamic_breathing.value                     = Epomaker_MODE_DYNAMIC_BREATHING;
+    Dynamic_breathing.flags                     = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Dynamic_breathing.color_mode                = MODE_COLORS_PER_LED;
+    Dynamic_breathing.brightness_min            = Epomaker_BRIGHTNESS_MIN;
+    Dynamic_breathing.brightness_max            = Epomaker_BRIGHTNESS_MAX;
+    Dynamic_breathing.brightness                = Epomaker_BRIGHTNESS_DEFAULT;
+    Dynamic_breathing.speed_min                 = Epomaker_SPEED_MIN;
+    Dynamic_breathing.speed_max                 = Epomaker_SPEED_MAX;
+    Dynamic_breathing.speed                     = Epomaker_SPEED_DEFAULT;
+    modes.push_back(Dynamic_breathing);
+
+    mode Spectrum_cycle;
+    Spectrum_cycle.name                         = "Spectrum Cycle";
+    Spectrum_cycle.value                        = Epomaker_MODE_SPECTRUM_CYCLE;
+    Spectrum_cycle.flags                        = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Spectrum_cycle.color_mode                   = MODE_COLORS_NONE;
+    Spectrum_cycle.brightness_min               = Epomaker_BRIGHTNESS_MIN;
+    Spectrum_cycle.brightness_max               = Epomaker_BRIGHTNESS_MAX;
+    Spectrum_cycle.brightness                   = Epomaker_BRIGHTNESS_DEFAULT;
+    Spectrum_cycle.speed_min                    = Epomaker_SPEED_MIN;
+    Spectrum_cycle.speed_max                    = Epomaker_SPEED_MAX_SPECIAL;
+    Spectrum_cycle.speed                        = Epomaker_SPEED_DEFAULT;
+    modes.push_back(Spectrum_cycle);
+
+    mode Drift;
+    Drift.name                                  = "Drift";
+    Drift.value                                 = Epomaker_MODE_DRIFT;
+    Drift.flags                                 = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
+    Drift.color_mode                            = MODE_COLORS_PER_LED | MODE_COLORS_RANDOM;
+    Drift.brightness_min                        = Epomaker_BRIGHTNESS_MIN;
+    Drift.brightness_max                        = Epomaker_BRIGHTNESS_MAX;
+    Drift.brightness                            = Epomaker_BRIGHTNESS_DEFAULT;
+    Drift.speed_min                             = Epomaker_SPEED_MIN;
+    Drift.speed_max                             = Epomaker_SPEED_MAX;
+    Drift.speed                                 = Epomaker_SPEED_DEFAULT;
+    modes.push_back(Drift);
+
+    mode Waves_ripple;
+    Waves_ripple.name                           = "Waves ripple";
+    Waves_ripple.value                          = Epomaker_MODE_WAVES_RIPPLE;
+    Waves_ripple.flags                          = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Waves_ripple.color_mode                     = MODE_COLORS_PER_LED | MODE_COLORS_RANDOM;
+    Waves_ripple.brightness_min                 = Epomaker_BRIGHTNESS_MIN;
+    Waves_ripple.brightness_max                 = Epomaker_BRIGHTNESS_MAX;
+    Waves_ripple.brightness                     = Epomaker_BRIGHTNESS_DEFAULT;
+    modes.push_back(Waves_ripple);
+
+    mode Stars_twinkle;
+    Stars_twinkle.name                          = "Stars twinkle";
+    Stars_twinkle.value                         = Epomaker_MODE_STARS_TWINKLE;
+    Stars_twinkle.flags                         = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Stars_twinkle.color_mode                    = MODE_COLORS_PER_LED | MODE_COLORS_RANDOM;
+    Stars_twinkle.brightness_min                = Epomaker_BRIGHTNESS_MIN;
+    Stars_twinkle.brightness_max                = Epomaker_BRIGHTNESS_MAX;
+    Stars_twinkle.brightness                    = Epomaker_BRIGHTNESS_DEFAULT;
+    Stars_twinkle.speed_min                     = Epomaker_SPEED_MIN;
+    Stars_twinkle.speed_max                     = Epomaker_SPEED_MAX;
+    Stars_twinkle.speed                         = Epomaker_SPEED_DEFAULT;
+    modes.push_back(Stars_twinkle);
+
+    mode Steady_stream;
+    Steady_stream.name                          = "Steady stream";
+    Steady_stream.value                         = Epomaker_MODE_STEADY_STREAM;
+    Steady_stream.flags                         = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Steady_stream.color_mode                    = MODE_COLORS_PER_LED | MODE_COLORS_RANDOM;
+    Steady_stream.brightness_min                = Epomaker_BRIGHTNESS_MIN;
+    Steady_stream.brightness_max                = Epomaker_BRIGHTNESS_MAX;
+    Steady_stream.brightness                    = Epomaker_BRIGHTNESS_DEFAULT;
+    Steady_stream.speed_min                     = Epomaker_SPEED_MIN;
+    Steady_stream.speed_max                     = Epomaker_SPEED_MAX;
+    Steady_stream.speed                         = Epomaker_SPEED_DEFAULT;
+    modes.push_back(Steady_stream);
+
+    mode Shadowing;
+    Shadowing.name                              = "Reactive";
+    Shadowing.value                             = Epomaker_MODE_SHADOWING;
+    Shadowing.flags                             = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Shadowing.color_mode                        = MODE_COLORS_PER_LED | MODE_COLORS_RANDOM;
+    Shadowing.brightness_min                    = Epomaker_BRIGHTNESS_MIN;
+    Shadowing.brightness_max                    = Epomaker_BRIGHTNESS_MAX;
+    Shadowing.brightness                        = Epomaker_BRIGHTNESS_DEFAULT;
+    Shadowing.speed_min                         = Epomaker_SPEED_MIN;
+    Shadowing.speed_max                         = Epomaker_SPEED_MAX;
+    Shadowing.speed                             = Epomaker_SPEED_DEFAULT;
+    modes.push_back(Shadowing);
+
+    mode Peaks_rising;
+    Peaks_rising.name                           = "Peaks rising one after another";
+    Peaks_rising.value                          = Epomaker_MODE_PEAKS_RISING_ONE_AFTER_ANOTHER;
+    Peaks_rising.flags                          = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Peaks_rising.color_mode                     = MODE_COLORS_PER_LED | MODE_COLORS_RANDOM;
+    Peaks_rising.brightness_min                 = Epomaker_BRIGHTNESS_MIN;
+    Peaks_rising.brightness_max                 = Epomaker_BRIGHTNESS_MAX;
+    Peaks_rising.brightness                     = Epomaker_BRIGHTNESS_DEFAULT;
+    Peaks_rising.speed_min                      = Epomaker_SPEED_MIN;
+    Peaks_rising.speed_max                      = Epomaker_SPEED_MAX;
+    Peaks_rising.speed                          = Epomaker_SPEED_DEFAULT;
+    modes.push_back(Peaks_rising);
+
+    mode Sine_wave;
+    Sine_wave.name                              = "Sine wave";
+    Sine_wave.value                             = Epomaker_MODE_SINE_WAVE;
+    Sine_wave.flags                             = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Sine_wave.color_mode                        = MODE_COLORS_PER_LED | MODE_COLORS_RANDOM;
+    Sine_wave.brightness_min                    = Epomaker_BRIGHTNESS_MIN;
+    Sine_wave.brightness_max                    = Epomaker_BRIGHTNESS_MAX;
+    Sine_wave.brightness                        = Epomaker_BRIGHTNESS_DEFAULT;
+    Sine_wave.speed_min                         = Epomaker_SPEED_MIN;
+    Sine_wave.speed_max                         = Epomaker_SPEED_MAX;
+    Sine_wave.speed                             = Epomaker_SPEED_DEFAULT;
+    modes.push_back(Sine_wave);
+
+    mode Caispring;
+    Caispring.name                              = "Caispring Surging";
+    Caispring.value                             = Epomaker_MODE_CAISPRING_SURGING;
+    Caispring.flags                             = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Caispring.color_mode                        = MODE_COLORS_PER_LED | MODE_COLORS_RANDOM;
+    Caispring.brightness_min                    = Epomaker_BRIGHTNESS_MIN;
+    Caispring.brightness_max                    = Epomaker_BRIGHTNESS_MAX;
+    Caispring.brightness                        = Epomaker_BRIGHTNESS_DEFAULT;
+    Caispring.speed_min                         = Epomaker_SPEED_MIN;
+    Caispring.speed_max                         = Epomaker_SPEED_MAX;
+    Caispring.speed                             = Epomaker_SPEED_DEFAULT;
+    modes.push_back(Caispring);
+
+    mode Flowers_blooming;
+    Flowers_blooming.name                       = "Flowers blooming";
+    Flowers_blooming.value                      = Epomaker_MODE_FLOWERS_BLOOMING;
+    Flowers_blooming.flags                      = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Flowers_blooming.color_mode                 = MODE_COLORS_PER_LED | MODE_COLORS_RANDOM;
+    Flowers_blooming.brightness_min             = Epomaker_BRIGHTNESS_MIN;
+    Flowers_blooming.brightness_max             = Epomaker_BRIGHTNESS_MAX;
+    Flowers_blooming.brightness                 = Epomaker_BRIGHTNESS_DEFAULT;
+    Flowers_blooming.speed_min                  = Epomaker_SPEED_MIN;
+    Flowers_blooming.speed_max                  = Epomaker_SPEED_MAX;
+    Flowers_blooming.speed                      = Epomaker_SPEED_DEFAULT;
+    modes.push_back(Flowers_blooming);
+
+    mode Laser;
+    Laser.name                                  = "Laser";
+    Laser.value                                 = Epomaker_MODE_LASER;
+    Laser.flags                                 = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Laser.color_mode                            = MODE_COLORS_PER_LED | MODE_COLORS_RANDOM;
+    Laser.brightness_min                        = Epomaker_BRIGHTNESS_MIN;
+    Laser.brightness_max                        = Epomaker_BRIGHTNESS_MAX;
+    Laser.brightness                            = Epomaker_BRIGHTNESS_DEFAULT;
+    Laser.speed_min                             = Epomaker_SPEED_MIN;
+    Laser.speed_max                             = Epomaker_SPEED_MAX;
+    Laser.speed                                 = Epomaker_SPEED_DEFAULT;
+    modes.push_back(Laser);
+
+    mode Peak_turn;
+    Peak_turn.name                              = "Peak turn";
+    Peak_turn.value                             = Epomaker_MODE_PEAK_TURN;
+    Peak_turn.flags                             = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Peak_turn.color_mode                        = MODE_COLORS_PER_LED | MODE_COLORS_RANDOM;
+    Peak_turn.brightness_min                    = Epomaker_BRIGHTNESS_MIN;
+    Peak_turn.brightness_max                    = Epomaker_BRIGHTNESS_MAX;
+    Peak_turn.brightness                        = Epomaker_BRIGHTNESS_DEFAULT;
+    Peak_turn.speed_min                         = Epomaker_SPEED_MIN;
+    Peak_turn.speed_max                         = Epomaker_SPEED_MAX_SPECIAL;
+    Peak_turn.speed                             = Epomaker_SPEED_DEFAULT;
+    modes.push_back(Peak_turn);
+
+    mode Inclined_rain;
+    Inclined_rain.name                          = "Inclined Rain";
+    Inclined_rain.value                         = Epomaker_MODE_INCLINED_RAIN;
+    Inclined_rain.flags                         = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Inclined_rain.color_mode                    = MODE_COLORS_PER_LED | MODE_COLORS_RANDOM;
+    Inclined_rain.brightness_min                = Epomaker_BRIGHTNESS_MIN;
+    Inclined_rain.brightness_max                = Epomaker_BRIGHTNESS_MAX;
+    Inclined_rain.brightness                    = Epomaker_BRIGHTNESS_DEFAULT;
+    Inclined_rain.speed_min                     = Epomaker_SPEED_MIN;
+    Inclined_rain.speed_max                     = Epomaker_SPEED_MAX;
+    Inclined_rain.speed                         = Epomaker_SPEED_DEFAULT;
+    modes.push_back(Inclined_rain);
+
+    mode Snow;
+    Snow.name                                   = "Snow";
+    Snow.value                                  = Epomaker_MODE_SNOW;
+    Snow.flags                                  = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Snow.color_mode                             = MODE_COLORS_PER_LED | MODE_COLORS_RANDOM;
+    Snow.brightness_min                         = Epomaker_BRIGHTNESS_MIN;
+    Snow.brightness_max                         = Epomaker_BRIGHTNESS_MAX;
+    Snow.brightness                             = Epomaker_BRIGHTNESS_DEFAULT;
+    Snow.speed_min                              = Epomaker_SPEED_MIN;
+    Snow.speed_max                              = Epomaker_SPEED_MAX_SPECIAL;
+    Snow.speed                                  = Epomaker_SPEED_DEFAULT;
+    modes.push_back(Snow);
+
+    mode Meteor;
+    Meteor.name                                 = "Meteor";
+    Meteor.value                                = Epomaker_MODE_METEOR;
+    Meteor.flags                                = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Meteor.color_mode                           = MODE_COLORS_PER_LED | MODE_COLORS_RANDOM;
+    Meteor.brightness_min                       = Epomaker_BRIGHTNESS_MIN;
+    Meteor.brightness_max                       = Epomaker_BRIGHTNESS_MAX;
+    Meteor.brightness                           = Epomaker_BRIGHTNESS_DEFAULT;
+    Meteor.speed_min                            = Epomaker_SPEED_MIN;
+    Meteor.speed_max                            = Epomaker_SPEED_MAX_SPECIAL;
+    Meteor.speed                                = Epomaker_SPEED_DEFAULT;
+    modes.push_back(Meteor);
+
+    mode Through_the_snow;
+    Through_the_snow.name                       = "Through the snow (non trace)";
+    Through_the_snow.value                      = Epomaker_MODE_THROUGH_THE_SNOW_NON_TRACE;
+    Through_the_snow.flags                      = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Through_the_snow.color_mode                 = MODE_COLORS_PER_LED | MODE_COLORS_RANDOM;
+    Through_the_snow.brightness_min             = Epomaker_BRIGHTNESS_MIN;
+    Through_the_snow.brightness_max             = Epomaker_BRIGHTNESS_MAX;
+    Through_the_snow.brightness                 = Epomaker_BRIGHTNESS_DEFAULT;
+    Through_the_snow.speed_min                  = Epomaker_SPEED_MIN;
+    Through_the_snow.speed_max                  = Epomaker_SPEED_MAX_SPECIAL;
+    Through_the_snow.speed                      = Epomaker_SPEED_DEFAULT;
+    modes.push_back(Through_the_snow);
+
+    SetupZones();
+}
+
+RGBController_EpomakerController::~RGBController_EpomakerController()
+{
+    delete controller;
+}
+
+void RGBController_EpomakerController::DeviceUpdateLEDs()
+{
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+
+    controller->SetDazzle(modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+    controller->SetColor(red, grn, blu);
+}
+
+void RGBController_EpomakerController::DeviceUpdateMode()
+{
+    if(modes[active_mode].value == Epomaker_MODE_DRIFT)
+    {
+        if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
+        {
+            controller->SetOption(Epomaker_OPTION_DRIFT_LEFT);
+        }
+        else if(modes[active_mode].direction == MODE_DIRECTION_RIGHT)
+        {
+            controller->SetOption(Epomaker_OPTION_DRIFT_RIGHT);
+        }
+        else if(modes[active_mode].direction == MODE_DIRECTION_UP)
+        {
+            controller->SetOption(Epomaker_OPTION_DRIFT_UP);
+        }
+        else if(modes[active_mode].direction == MODE_DIRECTION_DOWN)
+        {
+            controller->SetOption(Epomaker_OPTION_DRIFT_DOWN);
+        }
+    }
+    else if(modes[active_mode].value == Epomaker_MODE_STEADY_STREAM)
+    {
+        /*---------------------------------------------------------*\
+        | TODO: These OPTIONS (zig-zag, return) should not          |
+        |   be DIRECTIONS (left, right)                             |
+        \*---------------------------------------------------------*/
+        if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
+        {
+            controller->SetOption(Epomaker_OPTION_STEADY_STREAM_ZIG_ZAG);
+        }
+        else if(modes[active_mode].direction == MODE_DIRECTION_RIGHT)
+        {
+            controller->SetOption(Epomaker_OPTION_STEADY_STREAM_RETURN);
+        }
+    }
+    else if(modes[active_mode].value == Epomaker_MODE_CAISPRING_SURGING)
+    {
+        /*---------------------------------------------------------*\
+        | TODO: These OPTIONS (in, out) should not                  |
+        |   be DIRECTIONS (left, right)                             |
+        \*---------------------------------------------------------*/
+        if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
+        {
+            controller->SetOption(Epomaker_OPTION_CAISPRING_SURGING_OUT);
+        }
+        else if(modes[active_mode].direction == MODE_DIRECTION_RIGHT)
+        {
+            controller->SetOption(Epomaker_OPTION_CAISPRING_SURGING_IN);
+        }
+    }
+    else if(modes[active_mode].value == Epomaker_MODE_FLOWERS_BLOOMING)
+    {
+        if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
+        {
+            controller->SetOption(Epomaker_OPTION_FLOWERS_BLOOMING_LEFT);
+        }
+        else if(modes[active_mode].direction == MODE_DIRECTION_RIGHT)
+        {
+            controller->SetOption(Epomaker_OPTION_FLOWERS_BLOOMING_RIGHT);
+        }
+    }
+    else if(modes[active_mode].value == Epomaker_MODE_PEAK_TURN)
+    {
+        /*---------------------------------------------------------*\
+        | TODO: These OPTIONS (clockwise, anti-clockwise)           |
+        |   should not be DIRECTIONS (left, right)                  |
+        \*---------------------------------------------------------*/
+        if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
+        {
+            controller->SetOption(Epomaker_OPTION_PEAK_TURN_ANTI_CLOCKWISE);
+        }
+        else if(modes[active_mode].direction == MODE_DIRECTION_RIGHT)
+        {
+            controller->SetOption(Epomaker_OPTION_PEAK_TURN_CLOCKWISE);
+        }
+    }
+    else
+    {
+        controller->SetOption(Epomaker_OPTION_DEFAULT);
+    }
+
+    controller->SetDazzle(modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+
+    controller->SetMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness);
+}
+
+void RGBController_EpomakerController::SetupZones()
+{
+    zone new_zone;
+    new_zone.name          = "Keyboard";
+    new_zone.type          = ZONE_TYPE_SINGLE;
+    new_zone.leds_min      = 1;
+    new_zone.leds_max      = 1;
+    new_zone.leds_count    = 1;
+    new_zone.matrix_map    = NULL;
+
+    zones.push_back(new_zone);
+
+    led keyboard_led;
+    keyboard_led.name = "Keyboard LEDs";
+    keyboard_led.value = 0x00;
+    leds.push_back(keyboard_led);
+
+    SetupColors();
+}
+
+
+void RGBController_EpomakerController::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | Not implemented                                           |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_EpomakerController::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_EpomakerController::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}

Controllers/EpomakerController/RGBController_EpomakerController.h

@@ -0,0 +1,36 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_EpomakerController.h                                 |
+|                                                                     |
+|  Driver for Epomaker Keyboard                                       |
+|                                                                     |
+|  Alvaro Munoz (alvaromunoz)          2023-06-05                     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#ifndef RGBCONTROLLER_EpomakerCONTROLLER_H
+#define RGBCONTROLLER_EpomakerCONTROLLER_H
+
+#include "RGBController.h"
+#include "Controllers/EpomakerController/EpomakerController.h"
+
+class RGBController_EpomakerController : public RGBController
+{
+public:
+    RGBController_EpomakerController(EpomakerController* controller_ptr);
+    ~RGBController_EpomakerController();
+
+
+    void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    EpomakerController* controller;
+};
+
+#endif // RGBCONTROLLER_EpomakerCONTROLLER_H