OpenRGB version 0.8

* Fixes crash when `language` not present in config

.gitlab-ci.yml

@@ -51,6 +51,9 @@ before_script:
   rules:
   - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
     when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
 
 #-----------------------------------------------------------------------#
 # Linux (AppImage) 32-bit Build Target                                  #
@@ -71,6 +74,13 @@ before_script:
     - README.md
     expire_in: 30 days
 
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
 #-----------------------------------------------------------------------#
 # Linux (AppImage) 64-bit Build Target                                  #
 #-----------------------------------------------------------------------#
@@ -100,7 +110,7 @@ before_script:
   script:
   - dpkg-architecture -l
   - dpkg-buildpackage --target-arch i386 -us -B
-  - rm -v ../openrgb-dbgsym*.deb
+  - rm -v ../openrgb-dbgsym*.*deb
   - mv -v ../openrgb*.deb ./
 
   artifacts:
@@ -108,9 +118,16 @@ before_script:
     paths:
     - openrgb*.deb
     exclude:
-    - openrgb-dbgsym*.deb
+    - openrgb-dbgsym*.*deb
     expire_in: 30 days
 
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
 #-----------------------------------------------------------------------#
 # Linux (.deb) Debian Buster (Legacy) 64-bit Build Target               #
 #-----------------------------------------------------------------------#
@@ -121,7 +138,7 @@ before_script:
   script:
   - dpkg-architecture -l
   - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.deb
+  - rm -v ../openrgb-dbgsym*.*deb
   - mv -v ../openrgb*.deb ./
 
   artifacts:
@@ -129,9 +146,16 @@ before_script:
     paths:
     - openrgb*.deb
     exclude:
-    - openrgb-dbgsym*.deb
+    - openrgb-dbgsym*.*deb
     expire_in: 30 days
 
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
 #-----------------------------------------------------------------------#
 # Linux (.deb) Debian Bullseye 32-bit Build Target                      #
 #-----------------------------------------------------------------------#
@@ -142,6 +166,62 @@ before_script:
   script:
   - dpkg-architecture -l
   - dpkg-buildpackage --target-arch i386 -us -B
+  - rm -v ../openrgb-dbgsym*.*deb
+  - mv -v ../openrgb*.deb ./
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.*deb
+    expire_in: 30 days
+
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
+#-----------------------------------------------------------------------#
+# Linux (.deb) Debian Bullseye 64-bit Build Target                      #
+#-----------------------------------------------------------------------#
+"Linux 64 .deb (Debian Bullseye)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
+  stage: build
+  script:
+  - dpkg-architecture -l
+  - dpkg-buildpackage -us -B
+  - rm -v ../openrgb-dbgsym*.*deb
+  - mv -v ../openrgb*.deb ./
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.*deb
+    expire_in: 30 days
+
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
+#-----------------------------------------------------------------------#
+# Linux (.deb) Debian Bookworm 32-bit Build Target                      #
+#-----------------------------------------------------------------------#
+"Linux 32 .deb (Debian Bookworm)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-32
+  stage: build
+  script:
+  - dpkg-architecture -l
+  - dpkg-buildpackage --target-arch i386 -us -B
   - rm -v ../openrgb-dbgsym*.deb
   - mv -v ../openrgb*.deb ./
 
@@ -153,12 +233,19 @@ before_script:
     - openrgb-dbgsym*.deb
     expire_in: 30 days
 
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
 #-----------------------------------------------------------------------#
-# Linux (.deb) Debian Bullseye 64-bit Build Target                      #
+# Linux (.deb) Debian Bookworm 64-bit Build Target                      #
 #-----------------------------------------------------------------------#
-"Linux 64 .deb (Debian Bullseye)":
+"Linux 64 .deb (Debian Bookworm)":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-64
   stage: build
   script:
   - dpkg-architecture -l
@@ -174,6 +261,13 @@ before_script:
     - openrgb-dbgsym*.deb
     expire_in: 30 days
 
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
 #-----------------------------------------------------------------------#
 # Linux (.rpm, f35) 64-bit Build Target                                 #
 #-----------------------------------------------------------------------#
@@ -201,6 +295,13 @@ before_script:
     - openrgb*.rpm
     expire_in: 30 days
 
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
 #-----------------------------------------------------------------------#
 # Linux (.rpm, f36) 64-bit Build Target                                 #
 #-----------------------------------------------------------------------#
@@ -228,6 +329,13 @@ before_script:
     - openrgb*.rpm
     expire_in: 30 days
 
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
 #-----------------------------------------------------------------------#
 # Debian 32 Buster test                                                 #
 #-----------------------------------------------------------------------#
@@ -296,6 +404,40 @@ before_script:
   needs:
   - "Linux 64 .deb (Debian Bullseye)"
 
+#-----------------------------------------------------------------------#
+# Debian 32 Bookworm test                                               #
+#-----------------------------------------------------------------------#
+"Debian 32 Bookworm":
+  image: i386/debian:bookworm
+  stage: test
+  script:
+  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
+  - openrgb --version
+  - openrgb -l
+  - apt remove -y openrgb
+  dependencies:
+  - "Linux 32 .deb (Debian Bookworm)"
+  needs:
+  - "Linux 32 .deb (Debian Bookworm)"
+
+#-----------------------------------------------------------------------#
+# Debian 64 Bookworm test                                               #
+#-----------------------------------------------------------------------#
+"Debian 64 Bookworm":
+  image: amd64/debian:bookworm
+  stage: test
+  script:
+  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
+  - openrgb --version
+  - openrgb -l
+  - apt remove -y openrgb
+  dependencies:
+  - "Linux 64 .deb (Debian Bookworm)"
+  needs:
+  - "Linux 64 .deb (Debian Bookworm)"
+
 #-----------------------------------------------------------------------#
 # Ubuntu 64 20.04LTS test                                               #
 #-----------------------------------------------------------------------#
@@ -314,10 +456,10 @@ before_script:
   - "Linux 64 .deb (Debian Buster)"
 
 #-----------------------------------------------------------------------#
-# Ubuntu 64 21.10 test                                                  #
+# Ubuntu 64 22.04 test                                                  #
 #-----------------------------------------------------------------------#
-"Ubuntu 64 21.10":
-  image: ubuntu:impish
+"Ubuntu 64 22.04LTS":
+  image: ubuntu:jammy
   stage: test
   script:
   - apt update
@@ -326,9 +468,9 @@ before_script:
   - openrgb -l
   - apt remove -y openrgb
   dependencies:
-  - "Linux 64 .deb (Debian Bullseye)"
+  - "Linux 64 .deb (Debian Bookworm)"
   needs:
-  - "Linux 64 .deb (Debian Bullseye)"
+  - "Linux 64 .deb (Debian Bookworm)"
 
 #-----------------------------------------------------------------------#
 # Fedora 64 v35 test                                                    #
@@ -387,9 +529,9 @@ before_script:
   - mkdir _qt
   - mkdir _qt_download
   - Push-Location _qt_download
-  - curl.exe -LJ -o qt-base.7z  'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z'
-  - curl.exe -LJ -o qt-tools.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z'
-  - curl.exe -LJ -o qt-jom.zip  'https://qt-mirror.dannhauer.de/official_releases/jom/jom.zip'
+  - curl.exe -LJ -o qt-base.7z  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610076/download'
+  - curl.exe -LJ -o qt-tools.7z 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610097/download'
+  - curl.exe -LJ -o qt-jom.zip  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610138/download'
   - _fold_final_
 
   - _fold_start_ 'extracting the downloaded qt binaries'
@@ -405,10 +547,6 @@ before_script:
   - Pop-Location
   - _fold_final_
 
-  - _fold_start_ 'Generate qm files'
-  - .\_qt\5.15.0\msvc2019\bin\lrelease OpenRGB.pro
-  - _fold_final_
-
   - _fold_start_ 'run qmake and generate the msvc nmake makefile'
   - mkdir _build; cd _build
   - ..\_qt\5.15.0\msvc2019\bin\qmake ..\OpenRGB.pro
@@ -435,6 +573,13 @@ before_script:
     - 'OpenRGB Windows 32-bit'
     expire_in: 30 days
 
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
 #-----------------------------------------------------------------------#
 # Windows (64-bit) Build Target                                         #
 #-----------------------------------------------------------------------#
@@ -460,9 +605,9 @@ before_script:
   - mkdir _qt
   - mkdir _qt_download
   - Push-Location _qt_download
-  - curl.exe -LJ -o qt-base.7z  'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z'
-  - curl.exe -LJ -o qt-tools.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z'
-  - curl.exe -LJ -o qt-jom.zip  'https://qt-mirror.dannhauer.de/official_releases/jom/jom.zip'
+  - curl.exe -LJ -o qt-base.7z  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610116/download'
+  - curl.exe -LJ -o qt-tools.7z 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610131/download'
+  - curl.exe -LJ -o qt-jom.zip  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610138/download'
   - _fold_final_
 
   - _fold_start_ 'extracting the downloaded qt binaries'
@@ -478,10 +623,6 @@ before_script:
   - Pop-Location
   - _fold_final_
 
-  - _fold_start_ 'Generate qm files'
-  - .\_qt\5.15.0\msvc2019_64\bin\lrelease OpenRGB.pro
-  - _fold_final_
-
   - _fold_start_ 'run qmake and generate the msvc nmake makefile'
   - mkdir _build; cd _build
   - ..\_qt\5.15.0\msvc2019_64\bin\qmake ..\OpenRGB.pro
@@ -532,6 +673,9 @@ before_script:
     when: on_success
   - if: '$BUILD_MACOS =~ /.+/'
     when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
 
 "MacOS Intel":
   tags:
@@ -554,3 +698,6 @@ before_script:
     when: on_success
   - if: '$BUILD_MACOS =~ /.+/'
     when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true

.gitlab/CODEOWNERS

@@ -10,8 +10,8 @@ CODEOWNERS @Calcprogrammer1
 #-----------------------------------------------------------------------------#
 [Controllers]
 /Controllers/AMDWraithPrismController/
-/Controllers/ASRockPolychromeSMBusController/
 /Controllers/ASRockPolychromeUSBController/
+/Controllers/ASRockSMBusController/
 /Controllers/AlienwareController/
 /Controllers/AlienwareKeyboardController/
 /Controllers/AnnePro2Controller/
@@ -40,8 +40,8 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/EKController/                                  @Dr_No
 /Controllers/ENESMBusController/
 /Controllers/EVGAAmpereGPUController/                       @TheRogueZeta
-/Controllers/EVGAGP102GPUController/                        
-/Controllers/EVGAPascalGPUController/                       
+/Controllers/EVGAGP102GPUController/
+/Controllers/EVGAPascalGPUController/
 /Controllers/EVGATuringGPUController/                       @TheRogueZeta
 /Controllers/EVGAUSBController/                             @Dr_No
 /Controllers/EVisionKeyboardController/
@@ -102,5 +102,7 @@ CODEOWNERS @Calcprogrammer1
 #   that is an exception to the above should be explicitly named here         #
 #-----------------------------------------------------------------------------#
 [Controllers]
-/Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.cpp            @TheRogueZeta
-/Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.h              @TheRogueZeta
+/Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.cpp          @TheRogueZeta
+/Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.h            @TheRogueZeta
+/Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.cpp      @TheRogueZeta
+/Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.h        @TheRogueZeta

.vscode/extensions.json

@@ -0,0 +1,10 @@
+{
+    // See http://go.microsoft.com/fwlink/?LinkId=827846
+    // for the documentation about the extensions.json format
+    "recommendations": [
+        "EditorConfig.EditorConfig"
+    ],
+    "unwantedRecommendations": [
+        "ms-vscode.cpptools-extension-pack"
+    ]
+}

CONTRIBUTING.md

@@ -12,6 +12,16 @@ To create a merge request, log into GitLab and fork the OpenRGB project.  Push y
 * Follow the Style Guidelines below when making your code changes.
 * Avoid using `git merge` when updating your fork.  The OpenRGB project uses a linear git history, meaning all changes are rebased onto the tip of master.  By using `git rebase` to update your fork, you will make it easier to accept merge requests.
 
+### Pipelines, Shared Runners and Quotas
+
+Since mid 2022 Gitlab has limited the usage of shared runners to all projects and whilst quite geneorous quotas are allowed
+ for open source projects it is possible to exhaust them. With that in mind not all jobs within the pipeline build are
+ triggered to automatically run with every push to your branch with the exception of the Windows 64bit and Linux Appimage 64bit
+ jobs. If you need to test or share another build you can still start it manually from your pipeline queue.
+ Once a merge request is created all architectures and platforms will be compiled to ensure that they are ready to merge.
+
+Please refer to the following link for [further information relating to minutes and quotas](https://docs.gitlab.com/ee/ci/pipelines/cicd_minutes.html).
+
 ## Style Guidelines
 
 OpenRGB is written in C++, uses the Qt framework for UI, and uses the QMake build system.  While OpenRGB does use C++, I am primarily a C programmer and prefer doing things "C Style" vs. C++ style.  C++'s object oriented programming features fit the needs of a program such as OpenRGB where there are many implementations of a single interface so I chose to write it in C++ over C.  Still, however, I prefer using C-style code where possible.  When making changes to existing code files, try to follow the existing style.  Merge requests that go out of their way to restyle code will not be accepted and will be sent back for rework.

Controllers/A4TechController/RGBController_BloodyMouse.cpp

@@ -168,11 +168,6 @@ void RGBController_BloodyMouse::UpdateSingleLED(int /*led*/)
     DeviceUpdateLEDs();
 }
 
-void RGBController_BloodyMouse::SetCustomMode()
-{
-    active_mode = 0;
-}
-
 void RGBController_BloodyMouse::DeviceUpdateMode()
 {
     /*---------------------------------------------------------*\

Controllers/A4TechController/RGBController_BloodyMouse.h

@@ -34,7 +34,6 @@ public:
     void                    UpdateZoneLEDs(int zone);
     void                    UpdateSingleLED(int led);
 
-    void                    SetCustomMode();
     void                    DeviceUpdateMode();
 
 private:

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -17,8 +17,6 @@ AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const
     dev         = dev_handle;
     location    = path;
 
-    strcpy(device_name, "AMD Wraith Prism");
-
     current_fan_mode            = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
     current_fan_speed           = 0xFF;
     current_fan_random_color    = false;
@@ -33,8 +31,6 @@ AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const
     current_ring_speed          = 0xFF;
     current_ring_direction      = false;
     current_ring_brightness     = 0xFF;
-
-    SendEnableCommand();
 }
 
 AMDWraithPrismController::~AMDWraithPrismController()
@@ -47,11 +43,6 @@ std::string AMDWraithPrismController::GetLocationString()
     return("HID: " + location);
 }
 
-char* AMDWraithPrismController::GetDeviceName()
-{
-    return device_name;
-}
-
 std::string AMDWraithPrismController::GetSerialString()
 {
     wchar_t serial_string[128];
@@ -68,41 +59,6 @@ std::string AMDWraithPrismController::GetSerialString()
     return(return_string);
 }
 
-std::string AMDWraithPrismController::GetEffectChannelString(unsigned char channel)
-{
-    std::string ret_string = "";
-
-    unsigned char usb_buf[] =
-    {
-        0x00,
-        0x40, 0x21, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-    };
-
-    usb_buf[0x03] = channel;
-
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
-
-    ret_string.append((char *)&usb_buf[0x08]);
-
-    return(ret_string);
-}
-
 std::string AMDWraithPrismController::GetFirmwareVersionString()
 {
     std::string ret_string = "";
@@ -232,7 +188,7 @@ void AMDWraithPrismController::SetRingEffectChannel(unsigned char channel)
     SendChannelRemap(channel, AMD_WRAITH_PRISM_EFFECT_CHANNEL_LOGO_LED, AMD_WRAITH_PRISM_EFFECT_CHANNEL_FAN_LED);
 }
 
-void AMDWraithPrismController::SendEnableCommand()
+void AMDWraithPrismController::SendEnableCommand(bool direct)
 {
     unsigned char usb_buf[] =
     {
@@ -255,6 +211,11 @@ void AMDWraithPrismController::SendEnableCommand()
         0x00, 0x00, 0x00, 0x00,
     };
 
+    if(direct)
+    {
+        usb_buf[0x02]   = 0x03;
+    }
+
     hid_write(dev, usb_buf, 65);
     hid_read(dev, usb_buf, 64);
 }
@@ -286,6 +247,48 @@ void AMDWraithPrismController::SendApplyCommand()
     hid_read(dev, usb_buf, 64);
 }
 
+void AMDWraithPrismController::SendDirectPacket
+    (
+    unsigned char   size,
+    unsigned char * led_ids,
+    RGBColor *      colors
+    )
+{
+    unsigned char usb_buf[] =
+    {
+        0x00,
+        0xC0, 0x01, size, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+    };
+
+    for(unsigned int led_idx = 0; led_idx < size; led_idx++)
+    {
+        unsigned int index  = led_idx * 4;
+
+        usb_buf[index + 5]  = led_ids[led_idx];
+        usb_buf[index + 6]  = RGBGetRValue(colors[led_idx]);
+        usb_buf[index + 7]  = RGBGetGValue(colors[led_idx]);
+        usb_buf[index + 8]  = RGBGetBValue(colors[led_idx]);
+    }
+
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
+}
+
 void AMDWraithPrismController::SendEffectChannelUpdate
     (
     unsigned char effect_channel,

Controllers/AMDWraithPrismController/AMDWraithPrismController.h

@@ -10,6 +10,8 @@
 #include <string>
 #include <hidapi/hidapi.h>
 
+#include "RGBController.h"
+
 #pragma once
 
 #define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX     0xFF
@@ -74,6 +76,7 @@ enum
     AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE       = 0x09, /* Chase effect channel         */
     AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL       = 0x0A, /* Swirl effect channel         */
     AMD_WRAITH_PRISM_EFFECT_CHANNEL_MORSE       = 0x0B, /* Morse code effect channel    */
+    AMD_WRAITH_PRISM_EFFECT_CHANNEL_DIRECT      = 0xFF, /* Value for direct mode        */
 };
 
 enum
@@ -91,29 +94,11 @@ public:
     AMDWraithPrismController(hid_device* dev_handle, const char* path);
     ~AMDWraithPrismController();
 
-    char* GetDeviceName();
-
     std::string GetEffectChannelString(unsigned char channel);
     std::string GetFirmwareVersionString();
     std::string GetLocationString();
     std::string GetSerialString();
 
-    void SetRingEffectChannel(unsigned char channel);
-
-    void SetFanMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
-    void SetFanColor(unsigned char red, unsigned char green, unsigned char blue);
-
-    void SetLogoMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
-    void SetLogoColor(unsigned char red, unsigned char green, unsigned char blue);
-
-    void SetRingMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool direction, bool random_color);
-    void SetRingColor(unsigned char red, unsigned char green, unsigned char blue);
-
-private:
-    char                    device_name[32];
-    hid_device*             dev;
-    std::string             location;
-
     unsigned char           current_fan_mode;
     unsigned char           current_fan_speed;
     unsigned char           current_fan_brightness;
@@ -130,10 +115,30 @@ private:
     bool                    current_ring_direction;
     bool                    current_ring_random_color;
 
-    void SendEnableCommand();
+    void SetFanMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
+    void SetFanColor(unsigned char red, unsigned char green, unsigned char blue);
+    void SetLogoMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
+    void SetLogoColor(unsigned char red, unsigned char green, unsigned char blue);
+    void SetRingMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool direction, bool random_color);
+    void SetRingColor(unsigned char red, unsigned char green, unsigned char blue);
+
+    void SendDirectPacket
+        (
+        unsigned char   size,
+        unsigned char * led_ids,
+        RGBColor *      colors
+        );
+
+    void SendEnableCommand(bool direct);
 
     void SendApplyCommand();
 
+private:
+    hid_device*             dev;
+    std::string             location;
+
+    void SetRingEffectChannel(unsigned char channel);
+
     void SendEffectChannelUpdate
         (
         unsigned char effect_channel,

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

@@ -33,33 +33,29 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
     description = "AMD Wraith Prism Device";
     version     = controller->GetFirmwareVersionString();
     location    = controller->GetLocationString();
-    /*-----------------------------------------------------*\
-    | Don't use HID serial string, it is inconsistent on my |
-    | Wraith Prism                                          |
-    \*-----------------------------------------------------*/
-    serial      = "";//controller->GetSerialString();
 
     mode Direct;
     Direct.name                 = "Direct";
-    Direct.value                = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
+    Direct.value                = AMD_WRAITH_PRISM_EFFECT_CHANNEL_DIRECT;
     Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
     Direct.brightness_min       = 0;
-    Direct.brightness_max       = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Direct.brightness           = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Direct.brightness_max       = 0;
+    Direct.brightness           = 0;
     Direct.color_mode           = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode Breathing;
     Breathing.name              = "Breathing";
     Breathing.value             = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
     Breathing.speed_min         = AMD_WRAITH_PRISM_SPEED_SLOWEST;
     Breathing.speed_max         = AMD_WRAITH_PRISM_SPEED_FASTEST;
     Breathing.brightness_min    = 0;
     Breathing.brightness_max    = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
     Breathing.brightness        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Breathing.color_mode        = MODE_COLORS_PER_LED;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
     Breathing.speed             = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Breathing.colors.resize(3);
     modes.push_back(Breathing);
 
     mode ColorCycle;
@@ -104,27 +100,29 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
     mode Chase;
     Chase.name                  = "Chase";
     Chase.value                 = AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE;
-    Chase.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Chase.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
     Chase.speed_min             = AMD_WRAITH_PRISM_SPEED_SLOWEST;
     Chase.speed_max             = AMD_WRAITH_PRISM_SPEED_FASTEST;
     Chase.brightness_min        = 0;
     Chase.brightness_max        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
     Chase.brightness            = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Chase.color_mode            = MODE_COLORS_PER_LED;
+    Chase.color_mode            = MODE_COLORS_MODE_SPECIFIC;
     Chase.speed                 = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Chase.colors.resize(3);
     modes.push_back(Chase);
 
     mode Swirl;
     Swirl.name                  = "Swirl";
     Swirl.value                 = AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL;
-    Swirl.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Swirl.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
     Swirl.speed_min             = AMD_WRAITH_PRISM_SPEED_SLOWEST;
     Swirl.speed_max             = AMD_WRAITH_PRISM_SPEED_FASTEST;
     Swirl.brightness_min        = 0;
     Swirl.brightness_max        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
     Swirl.brightness            = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Swirl.color_mode            = MODE_COLORS_PER_LED;
+    Swirl.color_mode            = MODE_COLORS_MODE_SPECIFIC;
     Swirl.speed                 = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Swirl.colors.resize(3);
     modes.push_back(Swirl);
 
     SetupZones();
@@ -137,6 +135,14 @@ RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
 
 void RGBController_AMDWraithPrism::SetupZones()
 {
+    /*---------------------------------------------------------*\
+    | LED maps                                                  |
+    \*---------------------------------------------------------*/
+    const unsigned int logo_leds[1] =   { 0x00 };
+    const unsigned int fan_leds[1] =    { 0x01 };
+    const unsigned int ring_leds[14] =  { 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x10, 0x0F,
+                                          0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09 };
+
     /*---------------------------------------------------------*\
     | Set up zones                                              |
     \*---------------------------------------------------------*/
@@ -160,27 +166,39 @@ void RGBController_AMDWraithPrism::SetupZones()
 
     zone ring_zone;
     ring_zone.name          = "Ring";
-    ring_zone.type          = ZONE_TYPE_SINGLE;
-    ring_zone.leds_min      = 1;
-    ring_zone.leds_max      = 1;
-    ring_zone.leds_count    = 1;
+    ring_zone.type          = ZONE_TYPE_LINEAR;
+    ring_zone.leds_min      = 14;
+    ring_zone.leds_max      = 14;
+    ring_zone.leds_count    = 14;
     ring_zone.matrix_map    = NULL;
     zones.push_back(ring_zone);
 
     /*---------------------------------------------------------*\
     | Set up LEDs                                               |
     \*---------------------------------------------------------*/
-    led logo_led;
-    logo_led.name = "Logo LED";
-    leds.push_back(logo_led);
+    for(unsigned int led_idx = 0; led_idx < 1; led_idx++)
+    {
+        led logo_led;
+        logo_led.name = "Logo LED";
+        logo_led.value = logo_leds[led_idx];
+        leds.push_back(logo_led);
+    }
 
-    led fan_led;
-    fan_led.name = "Fan LED";
-    leds.push_back(fan_led);
+    for(unsigned int led_idx = 0; led_idx < 1; led_idx++)
+    {
+        led fan_led;
+        fan_led.name = "Fan LED";
+        fan_led.value = fan_leds[led_idx];
+        leds.push_back(fan_led);
+    }
 
-    led ring_led;
-    ring_led.name = "Ring LED";
-    leds.push_back(ring_led);
+    for(unsigned int led_idx = 0; led_idx < 14; led_idx++)
+    {
+        led ring_led;
+        ring_led.name = "Ring LED";
+        ring_led.value = ring_leds[led_idx];
+        leds.push_back(ring_led);
+    }
 
     SetupColors();
 }
@@ -194,73 +212,95 @@ void RGBController_AMDWraithPrism::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
 {
-    unsigned char red = RGBGetRValue(colors[0]);
-    unsigned char grn = RGBGetGValue(colors[0]);
-    unsigned char blu = RGBGetBValue(colors[0]);
-    controller->SetLogoColor(red, grn, blu);
-
-    red = RGBGetRValue(colors[1]);
-    grn = RGBGetGValue(colors[1]);
-    blu = RGBGetBValue(colors[1]);
-    controller->SetFanColor(red, grn, blu);
-
-    red = RGBGetRValue(colors[2]);
-    grn = RGBGetGValue(colors[2]);
-    blu = RGBGetBValue(colors[2]);
-    controller->SetRingColor(red, grn, blu);
-}
-
-void RGBController_AMDWraithPrism::UpdateZoneLEDs(int zone)
-{
-    RGBColor      color = colors[zone];
-    unsigned char red   = RGBGetRValue(color);
-    unsigned char grn   = RGBGetGValue(color);
-    unsigned char blu   = RGBGetBValue(color);
-
-    if(zone == 0)
+    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
     {
+        unsigned char   led_ids[15];
+        RGBColor        color_buf[15];
+        unsigned int    leds_count = 0;
+
+        for(unsigned int led_idx = 0; led_idx < colors.size(); led_idx++)
+        {
+            led_ids[leds_count]     = (unsigned char)leds[led_idx].value;
+            color_buf[leds_count]   = colors[led_idx];
+
+            leds_count++;
+
+            if(leds_count >= 15)
+            {
+                controller->SendDirectPacket(15, led_ids, color_buf);
+                leds_count = 0;
+            }
+        }
+
+        if(leds_count > 0)
+        {
+            controller->SendDirectPacket(leds_count, led_ids, color_buf);
+        }
+    }
+    else if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        unsigned char red = RGBGetRValue(modes[active_mode].colors[0]);
+        unsigned char grn = RGBGetGValue(modes[active_mode].colors[0]);
+        unsigned char blu = RGBGetBValue(modes[active_mode].colors[0]);
         controller->SetLogoColor(red, grn, blu);
-    }
-    else if(zone == 1)
-    {
+
+        red = RGBGetRValue(modes[active_mode].colors[1]);
+        grn = RGBGetGValue(modes[active_mode].colors[1]);
+        blu = RGBGetBValue(modes[active_mode].colors[1]);
         controller->SetFanColor(red, grn, blu);
-    }
-    else if(zone == 2)
-    {
+
+        red = RGBGetRValue(modes[active_mode].colors[2]);
+        grn = RGBGetGValue(modes[active_mode].colors[2]);
+        blu = RGBGetBValue(modes[active_mode].colors[2]);
         controller->SetRingColor(red, grn, blu);
     }
+    else
+    {
+        controller->SetLogoColor(0, 0, 0);
+        controller->SetFanColor(0, 0, 0);
+        controller->SetRingColor(0, 0, 0);
+    }
 }
 
-void RGBController_AMDWraithPrism::UpdateSingleLED(int led)
+void RGBController_AMDWraithPrism::UpdateZoneLEDs(int /*zone*/)
 {
-    UpdateZoneLEDs(led);
+    DeviceUpdateLEDs();
 }
 
-void RGBController_AMDWraithPrism::SetCustomMode()
+void RGBController_AMDWraithPrism::UpdateSingleLED(int /*led*/)
 {
-    active_mode = 0;
+    DeviceUpdateLEDs();
 }
 
 void RGBController_AMDWraithPrism::DeviceUpdateMode()
 {
     bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
 
-    controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
-
     switch(modes[active_mode].value)
     {
+        case AMD_WRAITH_PRISM_EFFECT_CHANNEL_DIRECT:
+            controller->SendEnableCommand(true);
+            controller->SendApplyCommand();
+            break;
+
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE:
+            controller->SendEnableCommand(false);
+            controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
             controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
             controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
             break;
 
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW:
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE:
+            controller->SendEnableCommand(false);
+            controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
             controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
             controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
             break;
 
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING:
+            controller->SendEnableCommand(false);
+            controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
             controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);
             controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);
             break;
@@ -268,11 +308,15 @@ void RGBController_AMDWraithPrism::DeviceUpdateMode()
         default:
             if(random)
             {
+                controller->SendEnableCommand(false);
+                controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
                 controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
                 controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
             }
             else
             {
+                controller->SendEnableCommand(false);
+                controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
                 controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].brightness, random);
                 controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].brightness, random);
             }

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.h

@@ -25,7 +25,6 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
 
 private:

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -20,6 +20,18 @@
 #define POLYCHROME_USB_INIT             0xA4
 #define POLYCHROME_USB_COMMIT           0x12
 
+const char* polychrome_USB_zone_names[] =
+{
+    "RGB LED 1 Header",
+    "RGB LED 2 Header",
+    "Addressable Header 1",
+    "Addressable Header 2",
+    "PCH",
+    "IO Cover",
+    "PCB",
+    "Audio",
+};
+
 PolychromeUSBController::PolychromeUSBController(hid_device* dev_handle, const char* path)
 {
     DMIInfo       dmi;
@@ -165,6 +177,41 @@ void PolychromeUSBController::WriteZone
     hid_read(dev, usb_buf, 64);
 };
 
+void PolychromeUSBController::WriteAllZones
+    (
+    const std::vector<PolychromeZoneInfo>&  zones_info,
+    const std::vector<zone>&                zones
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
+    usb_buf[0x03] = 0x07;
+    usb_buf[0x04] = zones_info[0].mode;
+    usb_buf[0x04] = 0xE2;
+
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        usb_buf[0x05 + (3 * zone_idx)    ] = RGBGetRValue(zones[zone_idx].colors[0]);
+        usb_buf[0x05 + (3 * zone_idx) + 1] = RGBGetGValue(zones[zone_idx].colors[0]);
+        usb_buf[0x05 + (3 * zone_idx) + 2] = RGBGetBValue(zones[zone_idx].colors[0]);
+    }
+    
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
+}
+
 void PolychromeUSBController::WriteRGSwap
     (
     bool ahdr1,
@@ -262,7 +309,7 @@ PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
     g   = usb_buf[0x06];
     b   = usb_buf[0x07];
 
-    zoneinfo.mode   = usb_buf[0x04];
+    zoneinfo.mode   = usb_buf[0x04] != 0xE2 ? usb_buf[0x04] : 0x0F;
     zoneinfo.color  = ToRGBColor(r,g,b);  
     zoneinfo.speed  = usb_buf[0x08];
     zoneinfo.zone   = usb_buf[0x03];

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.h

@@ -16,7 +16,7 @@
 /*----------------------------------------------------------------------------------------------*\
 | Definitions for Polychrome USB                                                                 |
 \*----------------------------------------------------------------------------------------------*/
-#define POLYCHROME_USB_NUM_MODES            15          /* Number of Polychrome USB modes       */
+#define POLYCHROME_USB_NUM_MODES            16          /* Number of Polychrome USB modes       */
 
 enum
 {
@@ -35,6 +35,7 @@ enum
     POLYCHROME_USB_MODE_NEON                = 0x0C,     /* Neon effect mode                     */
     POLYCHROME_USB_MODE_WATER               = 0x0D,     /* Water effect mode                    */
     POLYCHROME_USB_MODE_RAINBOW             = 0x0E,     /* Rainbow effect mode                  */
+    POLYCHROME_USB_MODE_DIRECT              = 0x0F,     /* CHROMA CONNECT effect mode           */
 };
 
 enum
@@ -57,17 +58,7 @@ enum
     POLYCHROME_USB_ZONE_UNAVAILABLE         = 0x1E,     // Value from LEDCOUNT CFG if zone not present
 };
 
-static const char* polychrome_USB_zone_names[] =
-{
-    "RGB LED 1 Header",
-    "RGB LED 2 Header",
-    "Addressable Header 1",
-    "Addressable Header 2",
-    "PCH",
-    "IO Cover",
-    "PCB",
-    "Audio",
-};
+extern const char* polychrome_USB_zone_names[];
 
 enum
 {
@@ -127,6 +118,12 @@ public:
                                                     bool            allzone
                                                     );
 
+    void                                        WriteAllZones
+                                                    (
+                                                    const std::vector<PolychromeZoneInfo> &zones_info,
+                                                    const std::vector<zone> &zones
+                                                    );
+
     void                                        WriteHeader
                                                     (
                                                     unsigned char   cfg,

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -173,6 +173,13 @@ RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController
     Rainbow.color_mode          = MODE_COLORS_NONE;
     modes.push_back(Rainbow);
 
+    mode Direct;
+    Direct.name                = "Direct";
+    Direct.value               = POLYCHROME_USB_MODE_DIRECT;
+    Direct.flags               = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode          = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
     SetupZones();
 
     /*-------------------------------------------------*\
@@ -276,6 +283,11 @@ void RGBController_PolychromeUSB::ResizeZone(int zone, int new_size)
 
 void RGBController_PolychromeUSB::DeviceUpdateLEDs()
 {
+    if(POLYCHROME_USB_MODE_DIRECT == zones_info[0].mode )
+    {
+        controller->WriteAllZones(zones_info,zones);
+        return;
+    }
     for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
         unsigned char set_mode = zones_info[zone_idx].mode;
@@ -324,11 +336,6 @@ unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)
     return(active_mode);
 }
 
-void RGBController_PolychromeUSB::SetCustomMode()
-{
-    active_mode = POLYCHROME_USB_MODE_STATIC;
-}
-
 void RGBController_PolychromeUSB::DeviceUpdateMode()
 {
     for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h

@@ -25,7 +25,6 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
 
 private:

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.cpp

@@ -22,7 +22,6 @@ ASRockPolychromeV1SMBusController::ASRockPolychromeV1SMBusController(i2c_smbus_i
     this->dev = dev;
 
     DMIInfo dmi;
-
     device_name =   "ASRock " + dmi.getMainboard();
 
     ReadLEDConfiguration();
@@ -62,9 +61,9 @@ void ASRockPolychromeV1SMBusController::ReadLEDConfiguration()
     | The LED configuration register holds 6 bytes, so the first read should return 6   |
     | If not, set all zone sizes to zero                                                |
     \*---------------------------------------------------------------------------------*/
-    LOG_DEBUG("[%s] Reading LED config from controller", device_name.c_str());
+    LOG_DEBUG("[%s] Reading Zone sizes from controller", device_name.c_str());
     uint8_t asrock_zone_count[I2C_SMBUS_BLOCK_MAX] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
-    if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_LED_CONFIG, asrock_zone_count) == 0x06)
+    if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_ZONE_SIZE, asrock_zone_count) == 0x06)
     {
         zone_led_count[POLYCHROME_V1_ZONE_1]           = asrock_zone_count[0];
         zone_led_count[POLYCHROME_V1_ZONE_2]           = asrock_zone_count[1];
@@ -86,27 +85,156 @@ void ASRockPolychromeV1SMBusController::ReadLEDConfiguration()
     }
 }
 
-uint8_t ASRockPolychromeV1SMBusController::GetMode()
+uint8_t ASRockPolychromeV1SMBusController::GetARGBColorOrder()
 {
-    return(active_mode);
+    uint8_t temp[1] = { 0x00 };
+    LOG_TRACE("[%s] Reading ARGB color order config from the controller", device_name.c_str());
+
+    //Read the data
+    if(bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_ARGB_GRB, temp) == 0x01)
+    {
+        if(temp[0] == 1)
+        {
+            LOG_DEBUG("[%s] Color order is GRB for the ARGB header", device_name.c_str());
+        }
+        else
+        {
+            LOG_DEBUG("[%s] Color order is RGB for the ARGB header", device_name.c_str());
+        }
+        return temp[0];
+    }
+    else
+    {
+        return 0;
+    }
 }
 
-void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t led, uint8_t red, uint8_t green, uint8_t blue)
+RGBColor ASRockPolychromeV1SMBusController::GetZoneColor(uint8_t zone)
 {
-    uint8_t color_speed_pkt[4] = { red, green, blue, active_speed };
-    uint8_t select_led_pkt[1]  = { led };
-    
+    LOG_TRACE("[%s] Reading color from zone %02d", device_name.c_str(), zone);
+    return zone_config[zone].color;
+}
+
+uint8_t ASRockPolychromeV1SMBusController::GetZoneMode(uint8_t zone)
+{
+    LOG_TRACE("[%s] Retreving mode %02X from zone_modes for zone %02d", device_name.c_str(), zone_config[zone].mode, zone);
+    return(zone_config[zone].mode);
+}
+
+void ASRockPolychromeV1SMBusController::LoadZoneConfig()
+{
+    uint8_t zone[1] = { 0x00 };
+    uint8_t mode[1] = { 0xFF };
+    uint8_t color_speed_pkt[4] = { 0, 0, 0, 0 };
+
+    LOG_TRACE("[%s] Reading modes from all zones", device_name.c_str());
+    //Polychrome v1 supports per zone modes so we need to set the zone before we can read the mode.
+    //Write the zone index.
+
+    for(uint8_t zone_idx = 0 ; zone_idx < POLYCHROME_V1_ZONE_COUNT; zone_idx ++)
+    {
+        if(zone_led_count[zone_idx] > 0)
+        {
+            zone[0] = zone_idx;
+            bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ZONE_SELECT, 1, zone);
+
+            //Read the data back.
+            if(bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_ZONE_SELECT, zone) == 0x01)
+            {
+                //Validate that we changed correctly.
+                if(zone[0] == zone_idx)
+                {
+                    //Read the mode for the zone.
+                    if(bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_MODE, mode) == 0x01)
+                    {
+                        LOG_DEBUG("[%s] Mode 0x%02x for zone %02d", device_name.c_str(), mode[0], zone_idx);
+                        zone_config[zone_idx].mode = mode[0];
+
+                        bus->i2c_smbus_read_block_data(dev, zone_config[zone_idx].mode, color_speed_pkt);
+
+                        zone_config[zone_idx].color = color_speed_pkt[0] << 16 | color_speed_pkt[1] << 8 | color_speed_pkt[2];
+                        zone_config[zone_idx].speed = color_speed_pkt [3];
+
+                        LOG_TRACE("[%s] Mode config: %06X, %02X", device_name.c_str(), zone_config[zone_idx].color, zone_config[zone_idx].speed );
+                    }
+                }
+                else
+                {
+                    LOG_WARNING("[%s] Zone mode register failed to change!", device_name.c_str() );
+                }
+            }
+        }
+        else
+        {
+            zone_config[zone_idx].mode = 0;
+            zone_config[zone_idx].color = 0;
+            zone_config[zone_idx].speed = 0;
+        }
+    }
+}
+
+void ASRockPolychromeV1SMBusController::SetARGBColorOrder(bool value)
+{
+    uint8_t temp[1] = { 0x00 };
+
+    LOG_TRACE("[%s] Setting ARGB color order config to the controller", device_name.c_str());
+
+    temp[0] = (value) ? 0x01 : 0x00;
+    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ARGB_GRB, 1, temp);
+    GetARGBColorOrder();
+}
+
+bool ASRockPolychromeV1SMBusController::SetARGBSize(uint8_t new_size)
+{
+    LOG_DEBUG("[%s] Setting ARGB header to %02d.", device_name.c_str(), new_size);
+
+    uint8_t asrock_zone_count[6] = { 0x0 };
+    uint8_t new_asrock_zone_count[6] = { 0x0 };
+
+    //memcpy(new_asrock_zone_count, zone_led_count, sizeof(new_asrock_zone_count - 1));
+    new_asrock_zone_count[POLYCHROME_V1_ZONE_1] = zone_led_count[POLYCHROME_V1_ZONE_1];
+    new_asrock_zone_count[POLYCHROME_V1_ZONE_2] = zone_led_count[POLYCHROME_V1_ZONE_2];
+    new_asrock_zone_count[POLYCHROME_V1_ZONE_3] = zone_led_count[POLYCHROME_V1_ZONE_3];
+    new_asrock_zone_count[POLYCHROME_V1_ZONE_4] = zone_led_count[POLYCHROME_V1_ZONE_4];
+    new_asrock_zone_count[POLYCHROME_V1_ZONE_5] = zone_led_count[POLYCHROME_V1_ZONE_5];
+    new_asrock_zone_count[POLYCHROME_V1_ZONE_ADDRESSABLE] = new_size;
+
+    //Write the new config to the register
+    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ZONE_SIZE, 6, new_asrock_zone_count);
+
+    //Validate the write
+    if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_ZONE_SIZE, asrock_zone_count) == 0x06)
+    {
+        for (uint8_t i = 0; i < 6; i++)
+        {
+            if (new_asrock_zone_count[i] != asrock_zone_count[i])
+            {
+                LOG_WARNING("[%s] Failed to validate zone %02d size!", device_name.c_str(), i);
+                return false;
+            }
+        }
+        LOG_DEBUG("[%s] Zone configuration validation completed.", device_name.c_str());
+        return true;
+    }
+    return false;
+}
+
+void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t zone, uint8_t red, uint8_t green, uint8_t blue)
+{
+    LOG_TRACE("[%s] Updating color and speed for zone %02d: 0x%06X", device_name.c_str(), zone, (red << 16 | green << 8 | blue));
+    uint8_t color_speed_pkt[4] = { red, green, blue, zone_config[zone].speed };
+    uint8_t select_zone_pkt[1]  = { zone };
 
     /*-----------------------------------------------------*\
-    | Select LED                                            |
+    | Select Zone                                           |
     \*-----------------------------------------------------*/
-    if(active_mode != POLYCHROME_V1_MODE_OFF)
+    if(zone_config[zone].mode != POLYCHROME_V1_MODE_OFF)
     {
-        bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_LED_SELECT, 1, select_led_pkt);
+        bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ZONE_SELECT, 1, select_zone_pkt);
         std::this_thread::sleep_for(1ms);
     }
 
-    switch(active_mode)
+    switch(zone_config[zone].mode)
     {
         /*-----------------------------------------------------*\
         | These modes take 4 bytes in R/G/B/S order             |
@@ -122,7 +250,7 @@ void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t led, uint8_t r
         case POLYCHROME_V1_MODE_NEON:
         case POLYCHROME_V1_MODE_WATER:
 
-            bus->i2c_smbus_write_block_data(dev, active_mode, 4, color_speed_pkt);
+            bus->i2c_smbus_write_block_data(dev, zone_config[zone].mode, 4, color_speed_pkt);
             break;
 
         /*-----------------------------------------------------*\
@@ -131,7 +259,7 @@ void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t led, uint8_t r
         default:
         case POLYCHROME_V1_MODE_STATIC:
         case POLYCHROME_V1_MODE_MUSIC:
-            bus->i2c_smbus_write_block_data(dev, active_mode, 3, color_speed_pkt);
+            bus->i2c_smbus_write_block_data(dev, zone_config[zone].mode, 3, color_speed_pkt);
             break;
 
         /*-----------------------------------------------------*\
@@ -140,7 +268,7 @@ void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t led, uint8_t r
         case POLYCHROME_V1_MODE_RANDOM:
         case POLYCHROME_V1_MODE_WAVE:
         case POLYCHROME_V1_MODE_RAINBOW:
-            bus->i2c_smbus_write_block_data(dev, active_mode, 1, &active_speed);
+            bus->i2c_smbus_write_block_data(dev, zone_config[zone].mode, 1, &zone_config[zone].speed);
             break;
 
         /*-----------------------------------------------------*\
@@ -153,12 +281,12 @@ void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t led, uint8_t r
 
 }
 
-void ASRockPolychromeV1SMBusController::SetMode(uint8_t zone,uint8_t mode, uint8_t speed)
+void ASRockPolychromeV1SMBusController::SetMode(uint8_t zone, uint8_t mode, uint8_t speed)
 {
-    uint8_t led_count_pkt[1]  = { 0x00 };
-    active_zone                     = zone;
-    active_mode                     = mode;
-    active_speed                    = speed;
+    LOG_TRACE("[%s] Updating mode for zone %02d, Mode 0x%02X, Speed 0x%02X", device_name.c_str(), zone, mode, speed);
+    uint8_t led_count_pkt[1]    = { 0x00 };
+    zone_config[zone].mode      = mode;
+    zone_config[zone].speed     = speed;
 
     /*-----------------------------------------------------*\
     | Make sure set all register is set to 0                |
@@ -169,12 +297,12 @@ void ASRockPolychromeV1SMBusController::SetMode(uint8_t zone,uint8_t mode, uint8
     /*-----------------------------------------------------*\
     | Set the zone we are working on                        |
     \*-----------------------------------------------------*/
-    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_LED_SELECT, 1, &active_zone);
+    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ZONE_SELECT, 1, &zone);
     std::this_thread::sleep_for(1ms);
 
     /*-----------------------------------------------------*\
     | Write the mode                                        |
     \*-----------------------------------------------------*/
-    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_MODE, 1, &active_mode);
-    std::this_thread::sleep_for(1ms);    
+    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_MODE, 1, &zone_config[zone].mode);
+    std::this_thread::sleep_for(1ms);
 }

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.h

@@ -9,6 +9,7 @@
 \*-----------------------------------------*/
 
 #include "i2c_smbus.h"
+#include "RGBController.h"
 #include <string>
 
 #pragma once
@@ -24,22 +25,22 @@ enum
     \*------------------------------------------------------------------------------------------*/
     POLYCHROME_V1_REG_FIRMWARE_VER          = 0x00,     /* Firmware version Major.Minor         */
     POLYCHROME_V1_REG_MODE                  = 0x30,     /* Mode selection register              */
-    POLYCHROME_V1_REG_LED_SELECT            = 0x31,     /* LED selection register               */
+    POLYCHROME_V1_REG_ZONE_SELECT           = 0x31,     /* Zone selection register              */
     POLYCHROME_V1_REG_SET_ALL               = 0x32,     /* Set All register 0x1 = set all       */
-    POLYCHROME_V1_REG_LED_CONFIG            = 0x33,     /* LED configuration register           */
-    POLYCHROME_V1_REG_ARGB_GRB              = 0x35,     /* ARGB bistream reversing register     */
+    POLYCHROME_V1_REG_ZONE_SIZE             = 0x33,     /* Zone size configuration register     */
+    POLYCHROME_V1_REG_ARGB_GRB              = 0x35,     /* ARGB bitstream reversing register    */
 };
 
 enum
 {
     POLYCHROME_V1_ZONE_1                    = 0x00,     /* RGB LED 1 Header                     */
     POLYCHROME_V1_ZONE_2                    = 0x01,     /* RGB LED 2 Header                     */
-    POLYCHROME_V1_ZONE_3                    = 0x02,     /* Audio/PCH Zone LEDs                  */
-    POLYCHROME_V1_ZONE_4                    = 0x03,     /* Audio/PCH Zone LEDs                  */
-    POLYCHROME_V1_ZONE_5                    = 0x04,     /* IO Cover Zone LEDs                   */
+    POLYCHROME_V1_ZONE_3                    = 0x02,     /* PCH Zone                             */
+    POLYCHROME_V1_ZONE_4                    = 0x03,     /* IO Cover Zone                        */
+    POLYCHROME_V1_ZONE_5                    = 0x04,     /* Audio Zone LEDs                      */
     POLYCHROME_V1_ZONE_ADDRESSABLE          = 0x05,     /* Addressable LED header               */
     POLYCHROME_V1_ZONE_COUNT                = 0x06,     /* Total number of zones                */
-    POLYCHROME_V1_ZONE_ADDRESSABLE_MAX      = 0x64,     /* Maxinum number of ARGB LEDs          */
+    POLYCHROME_V1_ZONE_ADDRESSABLE_MAX      = 0x64,     /* Maximum number of ARGB LEDs          */
 };
 
 /*----------------------------------------------------------------------------------------------*\
@@ -51,7 +52,7 @@ enum
 {
     POLYCHROME_V1_MODE_OFF                  = 0x10,     /* OFF mode                             */
     POLYCHROME_V1_MODE_STATIC               = 0x11,     /* Static color mode                    */
-    POLYCHROME_V1_MODE_BREATHING            = 0x12,     /* Breating effect mode                 */
+    POLYCHROME_V1_MODE_BREATHING            = 0x12,     /* Breathing effect mode                */
     POLYCHROME_V1_MODE_STROBE               = 0x13,     /* Strobe effect mode                   */
     POLYCHROME_V1_MODE_SPECTRUM_CYCLE       = 0x14,     /* Spectrum Cycle effect mode           */
     POLYCHROME_V1_MODE_RANDOM               = 0x15,     /* Random effect mode                   */
@@ -119,6 +120,13 @@ enum
     POLYCHROME_V1_SPEED_MAX_ARGB            = 0x02,     /* Fastest speed                        */
 };
 
+struct zone_cfg
+{
+    uint8_t     mode;
+    uint8_t     speed;
+    RGBColor    color;
+};
+
 class ASRockPolychromeV1SMBusController
 {
 public:
@@ -128,20 +136,24 @@ public:
     std::string             GetDeviceLocation();
     std::string             GetDeviceName();
     std::string             GetFirmwareVersion();
-    uint8_t                 GetMode();
+
+    uint8_t                 GetARGBColorOrder();
+    RGBColor                GetZoneColor(uint8_t zone);
+    uint8_t                 GetZoneMode(uint8_t zone);
+    void                    LoadZoneConfig();
+    void                    SetARGBColorOrder(bool value);
+    bool                    SetARGBSize(uint8_t led_count);
     void                    SetColorsAndSpeed(uint8_t led, uint8_t red, uint8_t green, uint8_t blue);
     void                    SetMode(uint8_t zone, uint8_t mode, uint8_t speed);
 
     uint8_t                 zone_led_count[6];
+    zone_cfg                zone_config[6];
     uint16_t                fw_version;
-    
+
 private:
     std::string             device_name;
-    uint8_t                 active_zone;
-    uint8_t                 active_mode;
-    uint8_t                 active_speed;
     i2c_smbus_interface*    bus;
     polychrome_dev_id       dev;
 
-    void                ReadLEDConfiguration();
+    void                    ReadLEDConfiguration();
 };

Controllers/ASRockSMBusController/RGBController_ASRockASRRGBSMBus.cpp

@@ -26,14 +26,14 @@
 
 RGBController_ASRockASRRGBSMBus::RGBController_ASRockASRRGBSMBus(ASRockASRRGBSMBusController* controller_ptr)
 {
-    controller  = controller_ptr;
+    controller                  = controller_ptr;
 
-    name        = controller->GetDeviceName();
-    vendor      = "ASRock";
-    version     = controller->GetFirmwareVersion();
-    type        = DEVICE_TYPE_MOTHERBOARD;
-    description = "ASRock ASR RGB LED Device";
-    location    = controller->GetDeviceLocation();
+    name                        = controller->GetDeviceName();
+    vendor                      = "ASRock";
+    version                     = controller->GetFirmwareVersion();
+    type                        = DEVICE_TYPE_MOTHERBOARD;
+    description                 = "ASRock ASR RGB LED Device";
+    location                    = controller->GetDeviceLocation();
 
     mode Off;
     Off.name                    = "Off";
@@ -196,11 +196,6 @@ void RGBController_ASRockASRRGBSMBus::UpdateSingleLED(int led)
     controller->SetColorsAndSpeed(led, red, grn, blu);
 }
 
-void RGBController_ASRockASRRGBSMBus::SetCustomMode()
-{
-    active_mode = 1;
-}
-
 void RGBController_ASRockASRRGBSMBus::DeviceUpdateMode()
 {
 

Controllers/ASRockSMBusController/RGBController_ASRockASRRGBSMBus.h

@@ -26,7 +26,6 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
 
 private:

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.cpp

@@ -7,6 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 12/15/2019  |
 \*-----------------------------------------*/
 
+#include "LogManager.h"
 #include "RGBController_ASRockPolychromeV1SMBus.h"
 
 static const char* polychrome_v1_zone_names[] =
@@ -29,38 +30,42 @@ static const char* polychrome_v1_zone_names[] =
     @detectors DetectASRockSMBusControllers
     @comment ASRock Polychrome v1 controllers will save with each update.
         Per ARGB LED support is not possible with these devices.
+        ARGB size  and color order is set using the `ARGB Header Config mode`
+        `Right` = GRB mode that is needed for WS2812B ARGB devices and `Left` = RGB used for WS2811 strips
+        The modes speed slider will set the size of the header
+        Spectrum Cycles uses the RGB values to set the individual color brightness.
 \*-------------------------------------------------------------------*/
 
 RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASRockPolychromeV1SMBusController* controller_ptr)
 {
-    controller  = controller_ptr;
+    controller                  = controller_ptr;
 
-    name        = controller->GetDeviceName();
-    vendor      = "ASRock";
-    version     = controller->GetFirmwareVersion();
-    type        = DEVICE_TYPE_MOTHERBOARD;
-    description = "ASRock Polychrome v1 Device";
-    location    = controller->GetDeviceLocation();
+    name                        = controller->GetDeviceName();
+    vendor                      = "ASRock";
+    version                     = controller->GetFirmwareVersion();
+    type                        = DEVICE_TYPE_MOTHERBOARD;
+    description                 = "ASRock Polychrome v1 Device";
+    location                    = controller->GetDeviceLocation();
 
 
     mode Off;
     Off.name                    = "Off";
     Off.value                   = POLYCHROME_V1_MODE_OFF;
-    Off.flags                   = 0;
+    Off.flags                   = MODE_FLAG_AUTOMATIC_SAVE;
     Off.color_mode              = MODE_COLORS_NONE;
     modes.push_back(Off);
 
     mode Static;
     Static.name                 = "Static";
     Static.value                = POLYCHROME_V1_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
     Static.color_mode           = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     mode Breathing;
     Breathing.name              = "Breathing";
     Breathing.value             = POLYCHROME_V1_MODE_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
     Breathing.speed_min         = POLYCHROME_V1_SPEED_MIN_BREATHING;
     Breathing.speed_max         = POLYCHROME_V1_SPEED_MAX_BREATHING;
     Breathing.speed             = POLYCHROME_V1_SPEED_DEFAULT_BREATHING;
@@ -70,7 +75,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
     mode Strobe;
     Strobe.name                 = "Strobe";
     Strobe.value                = POLYCHROME_V1_MODE_STROBE;
-    Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
     Strobe.speed_min            = POLYCHROME_V1_SPEED_MIN_STROBE;
     Strobe.speed_max            = POLYCHROME_V1_SPEED_MAX_STROBE;
     Strobe.speed                = POLYCHROME_V1_SPEED_DEFAULT_STROBE;
@@ -80,17 +85,17 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
     mode SpectrumCycle;
     SpectrumCycle.name          = "Spectrum Cycle";
     SpectrumCycle.value         = POLYCHROME_V1_MODE_SPECTRUM_CYCLE;
-    SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED;
+    SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
     SpectrumCycle.speed_min     = POLYCHROME_V1_SPEED_MIN_CYCLE;
     SpectrumCycle.speed_max     = POLYCHROME_V1_SPEED_MAX_CYCLE;
     SpectrumCycle.speed         = POLYCHROME_V1_SPEED_DEFAULT_CYCLE;
-    SpectrumCycle.color_mode    = MODE_COLORS_NONE;
+    SpectrumCycle.color_mode    = MODE_COLORS_PER_LED;
     modes.push_back(SpectrumCycle);
 
     mode Random;
     Random.name                 = "Random";
     Random.value                = POLYCHROME_V1_MODE_RANDOM;
-    Random.flags                = MODE_FLAG_HAS_SPEED;
+    Random.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
     Random.speed_min            = POLYCHROME_V1_SPEED_MIN_RANDOM;
     Random.speed_max            = POLYCHROME_V1_SPEED_MAX_RANDOM;
     Random.speed                = POLYCHROME_V1_SPEED_DEFAULT_RANDOM;
@@ -98,16 +103,16 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
     modes.push_back(Random);
 
     mode Music;
-    Music.name                 = "Music";
-    Music.value                = POLYCHROME_V1_MODE_MUSIC;
-    Music.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-    Music.color_mode           = MODE_COLORS_PER_LED;
+    Music.name                  = "Music";
+    Music.value                 = POLYCHROME_V1_MODE_MUSIC;
+    Music.flags                 = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Music.color_mode            = MODE_COLORS_NONE;
     modes.push_back(Music);
 
     mode Wave;
     Wave.name                   = "Wave";
     Wave.value                  = POLYCHROME_V1_MODE_WAVE;
-    Wave.flags                  = MODE_FLAG_HAS_SPEED;
+    Wave.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
     Wave.speed_min              = POLYCHROME_V1_SPEED_MIN_WAVE;
     Wave.speed_max              = POLYCHROME_V1_SPEED_MAX_WAVE;
     Wave.speed                  = POLYCHROME_V1_SPEED_DEFAULT_WAVE;
@@ -121,7 +126,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
     mode Spring;
     Spring.name                 = "Spring";
     Spring.value                = POLYCHROME_V1_MODE_SPRING;
-    Spring.flags                = MODE_FLAG_HAS_SPEED;
+    Spring.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
     Spring.speed_min            = POLYCHROME_V1_SPEED_MIN_ARGB;
     Spring.speed_max            = POLYCHROME_V1_SPEED_MAX_ARGB;
     Spring.speed                = POLYCHROME_V1_SPEED_DEFAULT_SPRING;
@@ -131,7 +136,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
     mode Stack;
     Stack.name                  = "Stack";
     Stack.value                 = POLYCHROME_V1_MODE_STACK;
-    Stack.flags                 = MODE_FLAG_HAS_SPEED;
+    Stack.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
     Stack.speed_min             = POLYCHROME_V1_SPEED_MIN_ARGB;
     Stack.speed_max             = POLYCHROME_V1_SPEED_MAX_ARGB;
     Stack.speed                 = POLYCHROME_V1_SPEED_DEFAULT_STACK;
@@ -141,7 +146,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
     mode Cram;
     Cram.name                   = "Cram";
     Cram.value                  = POLYCHROME_V1_MODE_CRAM;
-    Cram.flags                  = MODE_FLAG_HAS_SPEED;
+    Cram.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
     Cram.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
     Cram.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
     Cram.speed                  = POLYCHROME_V1_SPEED_DEFAULT_CRAM;
@@ -151,7 +156,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
     mode Scan;
     Scan.name                   = "Scan";
     Scan.value                  = POLYCHROME_V1_MODE_SCAN;
-    Scan.flags                  = MODE_FLAG_HAS_SPEED;
+    Scan.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
     Scan.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
     Scan.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
     Scan.speed                  = POLYCHROME_V1_SPEED_DEFAULT_SCAN;
@@ -161,7 +166,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
     mode Neon;
     Neon.name                   = "Neon";
     Neon.value                  = POLYCHROME_V1_MODE_NEON;
-    Neon.flags                  = MODE_FLAG_HAS_SPEED;
+    Neon.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
     Neon.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
     Neon.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
     Neon.speed                  = POLYCHROME_V1_SPEED_DEFAULT_NEON;
@@ -171,7 +176,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
     mode Water;
     Water.name                  = "Water";
     Water.value                 = POLYCHROME_V1_MODE_WATER;
-    Water.flags                 = MODE_FLAG_HAS_SPEED;
+    Water.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
     Water.speed_min             = POLYCHROME_V1_SPEED_MIN_ARGB;
     Water.speed_max             = POLYCHROME_V1_SPEED_MAX_ARGB;
     Water.speed                 = POLYCHROME_V1_SPEED_DEFAULT_WATER;
@@ -181,7 +186,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
     mode Rainbow;
     Rainbow.name                = "Rainbow";
     Rainbow.value               = POLYCHROME_V1_MODE_RAINBOW;
-    Rainbow.flags               = MODE_FLAG_HAS_SPEED;
+    Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
     Rainbow.speed_min           = POLYCHROME_V1_SPEED_MIN_RAINBOW;
     Rainbow.speed_max           = POLYCHROME_V1_SPEED_MAX_RAINBOW;
     Rainbow.speed               = POLYCHROME_V1_SPEED_DEFAULT_RAINBOW;
@@ -189,7 +194,37 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
     modes.push_back(Rainbow);
     */
 
+    /*---------------------------------------------------------------------*\
+    | This ARGB_Config section is a hack to allow users to configure the    |
+    | RGB vs GRB mode using the direction of the mode as well as set the    |
+    | size of the devices connected to the header using the brightness      |
+    | value.                                                                |
+    |                                                                       |
+    | The mode should be removed onece the device settings are avaiable.    |
+    \*---------------------------------------------------------------------*/
+    mode ARGB_Config;
+    ARGB_Config.name            = "ARGB Header Config";
+    ARGB_Config.value           = POLYCHROME_V1_REG_ARGB_GRB;
+    ARGB_Config.flags           = MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_SPEED  | MODE_FLAG_AUTOMATIC_SAVE;
+    ARGB_Config.speed           = controller->zone_led_count[POLYCHROME_V1_ZONE_ADDRESSABLE];
+    ARGB_Config.speed_min       = 1;
+    ARGB_Config.speed_max       = POLYCHROME_V1_ZONE_ADDRESSABLE_MAX;
+    ARGB_Config.direction       = controller -> GetARGBColorOrder();
+    ARGB_Config.color_mode      = MODE_COLORS_NONE;
+    modes.push_back(ARGB_Config);
+
     SetupZones();
+
+    controller->LoadZoneConfig();
+    active_mode = getModeIndex(controller->zone_config[0].mode); // Hard coding zone 0 until per zone modes are available.
+
+    if(active_mode != POLYCHROME_V1_MODE_OFF)
+    {
+        for( uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
+        {
+            zones[zone_idx].colors[0] = controller->GetZoneColor(zoneIndexMap[zone_idx]);
+        }
+    }
 }
 
 RGBController_ASRockPolychromeV1SMBus::~RGBController_ASRockPolychromeV1SMBus()
@@ -197,6 +232,18 @@ RGBController_ASRockPolychromeV1SMBus::~RGBController_ASRockPolychromeV1SMBus()
     delete controller;
 }
 
+uint8_t RGBController_ASRockPolychromeV1SMBus::getModeIndex(uint8_t mode_value)
+{
+    for(uint8_t mode_index = 0; mode_index < modes.size(); mode_index++)
+    {
+        if (modes[mode_index].value == mode_value)
+        {
+            return mode_index;
+        }
+    }
+    return 0;
+}
+
 void RGBController_ASRockPolychromeV1SMBus::SetupZones()
 {
     /*---------------------------------------------------------*\
@@ -210,118 +257,92 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
     {
         if(controller->zone_led_count[zone_idx] > 0)
         {
-            zone* new_zone = new zone();
-
+            zone*   new_zone        = new zone();
             /*---------------------------------------------------------*\
             | Set zone name to channel name                             |
             \*---------------------------------------------------------*/
-
             new_zone->name          = polychrome_v1_zone_names[zone_idx];
-
+            new_zone->type          = ZONE_TYPE_SINGLE;
             new_zone->leds_min      = 1;
             new_zone->leds_max      = 1;
-            //new_zone->leds_count    = zone_led_count[zone_idx];
             new_zone->leds_count    = 1;
-
-            new_zone->type          = ZONE_TYPE_SINGLE;
-
             new_zone->matrix_map    = NULL;
 
+            if(zone_idx == POLYCHROME_V1_ZONE_ADDRESSABLE)
+            {
+                new_zone->leds_max  = POLYCHROME_V1_ZONE_ADDRESSABLE_MAX;
+            }
             /*---------------------------------------------------------*\
             | Push new zone to zones vector                             |
             \*---------------------------------------------------------*/
             zones.push_back(*new_zone);
-        }
-    }
 
-    uint8_t led_count = 0;
-    /*---------------------------------------------------------*\
-    | Set up LEDs                                               |
-    \*---------------------------------------------------------*/
-    for(uint8_t zone_idx = 0; zone_idx < POLYCHROME_V1_ZONE_COUNT; zone_idx++)
-    {
-        if(controller->zone_led_count[zone_idx] > 0)
-        {
-            for(uint8_t led_idx = 0; led_idx < controller->zone_led_count[zone_idx]; led_idx++)
-            {
-                /*---------------------------------------------------------*\
-                | Each zone only has one LED                                |
-                \*---------------------------------------------------------*/
-                led* new_led = new led();
+            /*---------------------------------------------------------*\
+            | Each zone only has one LED                                |
+            \*---------------------------------------------------------*/
+            led*    new_led         = new led();
 
-                new_led->name           = polychrome_v1_zone_names[zone_idx];
+            new_led->name           = polychrome_v1_zone_names[zone_idx];
+            new_led->value          = zone_idx;
 
-                new_led->name.append(" " + std::to_string(led_idx + 1));
-                new_led->value = 0;
-
-                new_led->value              = zone_idx;
-
-                /*---------------------------------------------------------*\
-                | Push new LED to LEDs vector                               |
-                \*---------------------------------------------------------*/
-                leds.push_back(*new_led);
-
-                led_count++;
-
-                if(zone_idx == POLYCHROME_V1_ZONE_ADDRESSABLE)
-                {
-                    break;
-                }
-            }
+            /*---------------------------------------------------------*\
+            | Push new LED to LEDs vector                               |
+            \*---------------------------------------------------------*/
+            leds.push_back(*new_led);
+            zoneIndexMap.push_back(zone_idx);
         }
     }
 
     SetupColors();
 }
 
-void RGBController_ASRockPolychromeV1SMBus::ResizeZone(int /*zone*/, int /*new_size*/)
+void RGBController_ASRockPolychromeV1SMBus::ResizeZone(int zone, int new_size)
 {
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
+    LOG_TRACE("[%s] ResizeZone(%02X, %02X)", name.c_str(), zone, new_size);
+    controller-> SetARGBSize(new_size & 0xFF);
+    zones[POLYCHROME_V1_ZONE_ADDRESSABLE].leds_count = 1;
 }
 
 void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateLEDs()
 {
-    for (std::size_t led = 0; led < colors.size(); led++)
+    LOG_TRACE("[%s] DeviceUpdateLEDs()", name.c_str());
+    for (uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
     {
-        UpdateSingleLED(led);
+        UpdateSingleLED(zone_idx);
     }
 }
 
 void RGBController_ASRockPolychromeV1SMBus::UpdateZoneLEDs(int /*zone*/)
 {
+    LOG_TRACE("[%s] UpdateZoneLEDs()", name.c_str());
     DeviceUpdateLEDs();
 }
 
-void RGBController_ASRockPolychromeV1SMBus::UpdateSingleLED(int led)
+void RGBController_ASRockPolychromeV1SMBus::UpdateSingleLED(int zone)
 {
-    unsigned char red = RGBGetRValue(colors[led]);
-    unsigned char grn = RGBGetGValue(colors[led]);
-    unsigned char blu = RGBGetBValue(colors[led]);
+    LOG_TRACE("[%s] UpdateSingleLED(%02X)", name.c_str(), zone);
 
-    /*---------------------------------------------------------*\
-    | If the LED value is non-zero, this LED overrides the LED  |
-    | index                                                     |
-    \*---------------------------------------------------------*/
-    if(leds[led].value != 0)
-    {
-        led = leds[led].value;
-    }
+    uint8_t red = RGBGetRValue(colors[zone]);
+    uint8_t grn = RGBGetGValue(colors[zone]);
+    uint8_t blu = RGBGetBValue(colors[zone]);
 
-    controller->SetColorsAndSpeed(led, red, grn, blu);
-}
-
-void RGBController_ASRockPolychromeV1SMBus::SetCustomMode()
-{
-    active_mode = 1;
+    controller->SetColorsAndSpeed(zoneIndexMap[zone], red, grn, blu);
 }
 
 void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateMode()
 {
-    for(uint8_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    LOG_TRACE("[%s] DeviceUpdateMode()", name.c_str());
+    if(modes[active_mode].value != POLYCHROME_V1_REG_ARGB_GRB)
     {
-        controller->SetMode(led_idx, modes[active_mode].value, modes[active_mode].speed);
+        for(uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
+        {
+            controller->SetMode(zoneIndexMap[zone_idx], modes[active_mode].value, modes[active_mode].speed);
+            UpdateSingleLED(zone_idx);
+        }
+    }
+    else
+    {
+        controller-> SetARGBColorOrder(modes[active_mode].direction);
+        controller-> SetARGBSize(modes[active_mode].speed);
     }
-    DeviceUpdateLEDs();
 }

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.h

@@ -26,9 +26,10 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
 
 private:
     ASRockPolychromeV1SMBusController* controller;
+    uint8_t                 getModeIndex(uint8_t mode_value);
+    std::vector<uint8_t>    zoneIndexMap;
 };

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV2SMBus.cpp

@@ -33,14 +33,14 @@ static const char* polychrome_v2_zone_names[] =
 
 RGBController_ASRockPolychromeV2SMBus::RGBController_ASRockPolychromeV2SMBus(ASRockPolychromeV2SMBusController* controller_ptr)
 {
-    controller  = controller_ptr;
+    controller                  = controller_ptr;
 
-    name        = controller->GetDeviceName();
-    vendor      = "ASRock";
-    version     = controller->GetFirmwareVersion();
-    type        = DEVICE_TYPE_MOTHERBOARD;
-    description = "ASRock Polychrome v2 Device";
-    location    = controller->GetDeviceLocation();
+    name                        = controller->GetDeviceName();
+    vendor                      = "ASRock";
+    version                     = controller->GetFirmwareVersion();
+    type                        = DEVICE_TYPE_MOTHERBOARD;
+    description                 = "ASRock Polychrome v2 Device";
+    location                    = controller->GetDeviceLocation();
 
 
     mode Off;
@@ -316,11 +316,6 @@ void RGBController_ASRockPolychromeV2SMBus::UpdateSingleLED(int led)
     controller->SetColorsAndSpeed(led, red, grn, blu);
 }
 
-void RGBController_ASRockPolychromeV2SMBus::SetCustomMode()
-{
-    active_mode = 1;
-}
-
 void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateMode()
 {
 

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV2SMBus.h

@@ -26,7 +26,6 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
 
 private:

Controllers/AlienwareController/AlienwareController.cpp

@@ -592,13 +592,14 @@ void AlienwareController::SetColor(uint8_t zone, RGBColor color)
 
 void AlienwareController::SetColor(uint8_t zone, RGBColor color1, RGBColor color2)
 {
-    dirty = ((color1 != zones[zone].color[0]) || (color2 != zones[zone].color[1]));
+    if ((color1 == zones[zone].color[0]) && (color2 == zones[zone].color[1]))
+    {
+        return;
+    }
 
-	if(dirty)
-	{
-		zones[zone].color[0] = color1;
-        zones[zone].color[1] = color2;
-	}
+    zones[zone].color[0] = color1;
+    zones[zone].color[1] = color2;
+    dirty = true;
 }
 
 void AlienwareController::SetPeriod(uint8_t zone, uint16_t period)

Controllers/AlienwareController/RGBController_Alienware.cpp

@@ -179,11 +179,6 @@ void RGBController_Alienware::UpdateSingleLED(int led)
     UpdateZoneLEDs(led);
 }
 
-void RGBController_Alienware::SetCustomMode()
-{
-    active_mode = 0;
-}
-
 static bool modes_eq(const mode& mode1, const mode& mode2)
 {
     return( ( mode1.name           == mode2.name       )

Controllers/AlienwareController/RGBController_Alienware.h

@@ -29,8 +29,6 @@ public:
 
     void        DeviceUpdateMode();
 
-    void        SetCustomMode();
-
 private:
     AlienwareController*                    controller;
     std::chrono::steady_clock::time_point   last_packet_ts;

Controllers/AlienwareKeyboardController/AlienwareAW510KController.cpp

@@ -172,7 +172,7 @@ void AlienwareAW510KController::SendInitialize()
 
 void AlienwareAW510KController::SetDirect
     (
-    unsigned char   zone,
+    unsigned char   /*zone*/,
     unsigned char   r,
     unsigned char   g,
     unsigned char   b
@@ -222,7 +222,7 @@ void AlienwareAW510KController::SendDirectOn
     | To Guarantee the data are always %4 =0 append   |
     | zeros at end of last packet                     |
     \*-----------------------------------------------*/
-    for(int i = 0; i < (frame_data.size() % 4); i++)
+    for(unsigned int i = 0; i < (frame_data.size() % 4); i++)
     {
         SelectedKeys key;
         key.idx     = 0x00;
@@ -358,7 +358,7 @@ void AlienwareAW510KController::UpdateSingleLED
 }
 void AlienwareAW510KController::SendMode
     (
-    unsigned char   zone,
+    unsigned char   /*zone*/,
     unsigned char   mode,
     unsigned short  speed,
     unsigned char   direction,

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.cpp

@@ -171,21 +171,21 @@ static const led_type led_names[] =
 
 RGBController_AlienwareAW510K::RGBController_AlienwareAW510K(AlienwareAW510KController* controller_ptr)
 {
-    controller  = controller_ptr;
+    controller                      = controller_ptr;
 
-    name        = "Alienware AW510K Keyboard Device";
-    vendor      = "Alienware";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "Alienware AW510K Keyboard Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
+    name                            = "Alienware AW510K Keyboard Device";
+    vendor                          = "Alienware";
+    type                            = DEVICE_TYPE_KEYBOARD;
+    description                     = "Alienware AW510K Keyboard Device";
+    location                        = controller->GetDeviceLocation();
+    serial                          = controller->GetSerialString();
 
-    mode Direct_Per_LED;
-    Direct_Per_LED.name             = "Direct";
-    Direct_Per_LED.value            = ALIENWARE_AW510K_MODE_DIRECT_PER_LED;
-    Direct_Per_LED.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct_Per_LED.color_mode       = MODE_COLORS_PER_LED;
-    modes.push_back(Direct_Per_LED);
+    mode Direct;
+    Direct.name                     = "Direct";
+    Direct.value                    = ALIENWARE_AW510K_MODE_DIRECT_PER_LED;
+    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode               = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
 
     mode Static;
     Static.name                     = "Static";
@@ -403,11 +403,6 @@ void RGBController_AlienwareAW510K::UpdateSingleLED(int led)
     controller->UpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
 }
 
-void RGBController_AlienwareAW510K::SetCustomMode()
-{
-    active_mode = 0;
-}
-
 void RGBController_AlienwareAW510K::DeviceUpdateMode()
 {
     if(active_mode == 0xFFFF)

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.h

@@ -26,7 +26,6 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
 
 private:

Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp

@@ -23,7 +23,7 @@ static unsigned int matrix_map[5][14] =
 
 static const char* zone_names[] =
 {
-    "Keyboard",
+    ZONE_EN_KEYBOARD,
 };
 
 static zone_type zone_types[] =
@@ -236,11 +236,6 @@ void RGBController_AnnePro2::UpdateSingleLED(int /*led*/)
     DeviceUpdateLEDs();
 }
 
-void RGBController_AnnePro2::SetCustomMode()
-{
-    active_mode = 0;
-}
-
 void RGBController_AnnePro2::DeviceUpdateMode()
 {
 

Controllers/AnnePro2Controller/RGBController_AnnePro2.h

@@ -24,7 +24,6 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
 
 private:

Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp

@@ -2,9 +2,12 @@
 #include "AsusAuraCoreController.h"
 #include "RGBController.h"
 #include "RGBController_AsusAuraCore.h"
+#include "RGBController_AsusAuraCoreLaptop.h"
 #include <hidapi/hidapi.h>
 
-#define AURA_CORE_VID 0x0B05
+#define AURA_CORE_VID                   0x0B05
+
+#define AURA_STRIX_SCAR_15_PID          0x19B6
 
 /******************************************************************************************\
 *                                                                                          *
@@ -14,13 +17,14 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string&)
+void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string& /*name*/)
 {
     hid_device* dev = hid_open_path(info->path);
-    if( dev )
+
+    if(dev)
     {
-        AuraCoreController*     controller     = new AuraCoreController(dev, info->path);
-        RGBController_AuraCore* rgb_controller = new RGBController_AuraCore(controller);
+        AuraCoreController*     controller                  = new AuraCoreController(dev, info->path);
+        RGBController_AuraCore* rgb_controller              = new RGBController_AuraCore(controller);
         // Constructor sets the name
         if(rgb_controller->type != DEVICE_TYPE_UNKNOWN)
         {
@@ -33,6 +37,21 @@ void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string&)
     }
 }
 
-REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1854);
-REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1866);
-REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1869);
+void DetectAsusAuraCoreLaptopControllers(hid_device_info* info, const std::string& /*name*/)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AsusAuraCoreLaptopController*     controller        = new AsusAuraCoreLaptopController(dev, info->path);
+        RGBController_AsusAuraCoreLaptop* rgb_controller    = new RGBController_AsusAuraCoreLaptop(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+
+REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1854);
+REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1866);
+REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1869);
+REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 15",      DetectAsusAuraCoreLaptopControllers,    AURA_CORE_VID, AURA_STRIX_SCAR_15_PID,  0xFF31, 0x79);

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController.cpp

@@ -0,0 +1,356 @@
+/*---------------------------------------------------------------------*\
+|  AsusAuraCoreLaptopController.cpp                                     |
+|                                                                       |
+|  Driver for Asus Aura Core Laptop USB Controller                      |
+|                                                                       |
+|  Chris M (Dr_No)          28 Jul 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/
+
+#include "AsusAuraCoreLaptopController.h"
+
+static uint8_t packet_map[ASUSAURACORELAPTOP_KEYCOUNT       +
+                          ASUSAURACORELAPTOP_LIGHTBARCOUNT  +
+                          ASUSAURACORELAPTOP_LIDCOUNT       ] =
+{
+/*00        ESC  F1   F2   F3   F4   F5   F6   F7   F8   F9  */
+            21,  23,  24,  25,  26,  28,  29,  30,  31,  33,
+
+/*10        F10  F11  F12  DEL   `    1    2    3    4    5  */
+            34,  35,  36,  37,  42,  43,  44,  45,  46,  47,
+
+/*20         6    7    8    9    0    -    =   BSP  BSP  BSP */
+            48,  49,  50,  51,  52,  53,  54,  55,  56,  57,
+
+/*30        PLY  TAB   Q    W    E    R    T    Y    U    I  */
+            58,  63,  64,  65,  66,  67,  68,  69,  70,  71,
+
+/*40         O    P    [    ]    \   STP  CAP   A    S    D  */
+            72,  73,  74,  75,  76,  79,  84,  85,  86,  87,
+
+/*50         F    G    H    J    K    L    ;    '   ENT  PRV */
+            88,  89,  90,  91,  92,  93,  94,  95,  98, 100,
+
+/*60        LSH   Z    X    C    V    B    N    M    ,    .  */
+           105, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+
+/*70         /   RSH  UP   NXT LCTL  LFN LWIN LALT  SPC RALT */
+           116, 119, 139, 121, 126, 127, 128, 129, 131, 135,
+
+/*80       RCTL  LFT  DWN  RGT  PRT KSTN  VDN  VUP MICM HPFN */
+           137, 159, 160, 161, 142, 175,   2,   3,   4,   5,
+
+/*90       ARMC  LB1  LB2  LB3  LB4  LB5  LB6 LOGO LIDL LIDR */
+             6, 174, 173, 172, 171, 170, 169, 167, 176, 177,
+
+};
+
+static std::string power_zones[ASUSAURACORELAPTOP_POWER_ZONES] =
+{
+    "Logo",
+    ZONE_EN_KEYBOARD,
+    "Lightbar",
+    "Lid Edges"
+};
+
+static std::string power_states[ASUSAURACORELAPTOP_POWER_STATES] =
+{
+    " when booting",
+    " when awake",
+    " when sleeping",
+    " when off",
+};
+
+AsusAuraCoreLaptopController::AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path)
+{
+    const uint8_t sz    = HID_MAX_STR;
+    wchar_t       tmp[sz];
+
+    dev                 = dev_handle;
+    location            = path;
+
+    hid_get_manufacturer_string(dev, tmp, sz);
+    std::wstring wName = std::wstring(tmp);
+    device_name = std::string(wName.begin(), wName.end());
+
+    hid_get_product_string(dev, tmp, sz);
+    wName = std::wstring(tmp);
+    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
+
+    SetPowerConfigFromJSON();
+}
+
+AsusAuraCoreLaptopController::~AsusAuraCoreLaptopController()
+{
+    hid_close(dev);
+}
+
+std::string AsusAuraCoreLaptopController::GetDeviceName()
+{
+    return device_name;
+}
+
+std::string AsusAuraCoreLaptopController::GetSerial()
+{
+    const uint8_t sz    = HID_MAX_STR;
+    wchar_t       tmp[sz];
+
+    int ret             = hid_get_serial_number_string(dev, tmp, sz);
+
+    if (ret != 0)
+    {
+        LOG_DEBUG("[%s] Get HID Serial string failed", device_name.c_str());
+        return("");
+    }
+
+    std::wstring w_tmp  = std::wstring(tmp);
+    std::string serial  = std::string(w_tmp.begin(), w_tmp.end());
+
+    return serial;
+}
+
+std::string AsusAuraCoreLaptopController::GetLocation()
+{
+    return("HID: " + location);
+}
+
+void AsusAuraCoreLaptopController::SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor color1, RGBColor color2, uint8_t random, uint8_t direction)
+{
+    bool needs_update       = !( (current_mode          == mode         )   &&
+                                 (current_speed         == speed        )   &&
+                                 (current_brightness    == brightness   )   &&
+                                 (current_c1            == color1       )   &&
+                                 (current_c2            == color2       )   &&
+                                 (current_random        == random       )   &&
+                                 (current_direction     == direction    )   );
+
+    if(needs_update)
+    {
+        current_mode        = mode;
+        current_speed       = speed;
+        current_brightness  = brightness;
+        current_c1          = color1;
+        current_c2          = color2;
+        current_random      = random;
+        current_direction   = direction;
+
+        SendUpdate();
+        SendBrightness();
+    }
+}
+
+void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor> colors)
+{
+    /*---------------------------------------------------------*\
+    | The keyboard zone is a set of 168 keys (indexed from 0)   |
+    |   sent in 11 packets of 16 triplets. The Lid and Lightbar |
+    |   zones are sent in one final packet afterwards.          |
+    \*---------------------------------------------------------*/
+    const uint8_t  key_set                                  = 167;
+    const uint8_t  led_count                                = 178;
+    const uint16_t map_size                                 = 3 * led_count;
+    const uint8_t leds_per_packet                           = 16;
+    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_DIRECT,
+                                                                0x00, 0x01, 0x01, 0x01, 0x00, leds_per_packet, 0x00 };
+    uint8_t key_buf[map_size];
+
+    memset(key_buf, 0, map_size);
+
+    for(size_t led_index = 0; led_index < colors.size(); led_index++)
+    {
+        uint16_t offset         = 3 * packet_map[led_index];
+
+        key_buf[offset]         = RGBGetRValue(colors[led_index]);
+        key_buf[offset + 1]     = RGBGetGValue(colors[led_index]);
+        key_buf[offset + 2]     = RGBGetBValue(colors[led_index]);
+    }
+
+    for(size_t i = 0; i < key_set; i+=leds_per_packet)
+    {
+        uint8_t leds_remaining  = key_set - i;
+
+        if(leds_remaining < leds_per_packet)
+        {
+            buffer[07]          = leds_remaining;
+        }
+
+        buffer[06]              = i;
+        memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * i], (3 * buffer[07]));
+
+        hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
+    }
+
+    buffer[4] = 0x04;
+    buffer[5] = 0x00;
+    buffer[6] = 0x00;
+    buffer[7] = 0x00;
+    memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * key_set], (3 * (led_count - key_set)));
+
+    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
+}
+
+void AsusAuraCoreLaptopController::SendBrightness()
+{
+    const uint8_t index                                     = 2;
+    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_BRIGHTNESS };
+
+    memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
+    buffer[4] = current_brightness;
+
+    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
+}
+
+void AsusAuraCoreLaptopController::SendUpdate()
+{
+    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_UPDATE };
+
+    buffer[ASUSAURACORELAPTOP_ZONE_BYTE]                    = 0;
+    buffer[ASUSAURACORELAPTOP_MODE_BYTE]                    = current_mode;
+    buffer[ASUSAURACORELAPTOP_R1_BYTE]                      = RGBGetRValue(current_c1);
+    buffer[ASUSAURACORELAPTOP_G1_BYTE]                      = RGBGetGValue(current_c1);
+    buffer[ASUSAURACORELAPTOP_B1_BYTE]                      = RGBGetBValue(current_c1);
+    buffer[ASUSAURACORELAPTOP_SPEED_BYTE]                   = current_speed;
+    buffer[ASUSAURACORELAPTOP_DIRECTION_BYTE]               = current_direction;
+    buffer[ASUSAURACORELAPTOP_DATA_BYTE]                    = current_random;
+    buffer[ASUSAURACORELAPTOP_R2_BYTE]                      = RGBGetRValue(current_c2);
+    buffer[ASUSAURACORELAPTOP_G2_BYTE]                      = RGBGetGValue(current_c2);
+    buffer[ASUSAURACORELAPTOP_B2_BYTE]                      = RGBGetBValue(current_c2);
+
+    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
+
+    SendApply();
+}
+
+void AsusAuraCoreLaptopController::SendApply()
+{
+    const uint8_t index                                     = 2;
+    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_APPLY };
+
+    memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
+
+    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
+}
+
+void AsusAuraCoreLaptopController::SendSet()
+{
+    const uint8_t index                                     = 2;
+    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_SET };
+
+    memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
+
+    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
+}
+
+std::vector<p_state> AsusAuraCoreLaptopController::PowerConfigArray()
+{
+    std::vector<p_state>    temp;
+
+    for(uint8_t zone_index = 0; zone_index < ASUSAURACORELAPTOP_POWER_ZONES; zone_index++)
+    {
+        for(uint8_t state_index = 0; state_index < ASUSAURACORELAPTOP_POWER_STATES; state_index++)
+        {
+            p_state new_state;
+
+            new_state.zone  = power_zones[zone_index] + power_states[state_index];
+            new_state.state = true;
+
+            temp.push_back(new_state);
+        }
+    }
+
+    return temp;
+}
+
+void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
+{
+    std::vector<p_state> power_config   = PowerConfigArray();
+    const std::string section_power     = "PowerConfig";
+    const std::string detector_name     = "Asus Aura Core Laptop";
+    SettingsManager* settings_manager   = ResourceManager::get()->GetSettingsManager();
+    json device_settings                = settings_manager->GetSettings(detector_name);
+
+    /*---------------------------------------------------------*\
+    | Get Power state config from the settings manager          |
+    |   If PowerConfig is not found then write it to settings   |
+    \*---------------------------------------------------------*/
+    if(!device_settings.contains(section_power))
+    {
+        json pcfg;
+
+        for(size_t i = 0; i < power_config.size(); i++)
+        {
+            pcfg[power_config[i].zone]  = power_config[i].state;
+        }
+
+        device_settings[section_power]  = pcfg;
+        settings_manager->SetSettings(detector_name, device_settings);
+        settings_manager->SaveSettings();
+    }
+    else
+    {
+        for(size_t i = 0; i < power_config.size(); i++)
+        {
+            std::string key_name        = power_config[i].zone;
+
+            if(device_settings[section_power].contains(key_name))
+            {
+                power_config[i].state   = device_settings[section_power][key_name];
+                LOG_DEBUG("[%s] Reading power config for %s: %s", device_name.c_str(), key_name.c_str(), ((power_config[i].state) ? "On" : "Off"));
+            }
+        }
+    }
+
+    /*-----------------------------------------------------------------------------*\
+    | Power state flags are packed in zones but the order is inconsistent.          |
+    |   With thanks to AsusCtl for helping to decipher the packet captures          |
+    |   https://gitlab.com/asus-linux/asusctl/-/blob/main/rog-aura/src/usb.rs#L150  |
+    \*-----------------------------------------------------------------------------*/
+    bool flag_array[] =
+    {
+        power_config[0].state,      power_config[4].state,
+        power_config[1].state,      power_config[5].state,
+        !power_config[2].state,     !power_config[6].state,
+        !power_config[3].state,     !power_config[7].state,
+
+        false,                      power_config[8].state,
+        power_config[9].state,      !power_config[10].state,
+        !power_config[11].state,    false,
+        false,                      false,
+
+        power_config[12].state,     power_config[13].state,
+        !power_config[14].state,    !power_config[15].state
+    };
+
+    uint32_t flags      = PackPowerFlags(flag_array);
+    LOG_DEBUG("[%s] Sending power config Logo+KB: %02X Lightbar: %02X Lid Edges: %02X Raw: %08X", device_name.c_str(), (flags & 0xFF), ((flags >> 8)  & 0xFF), ((flags >> 16)  & 0xFF), flags);
+    SendPowerConfig(flags);
+}
+
+void AsusAuraCoreLaptopController::SendPowerConfig(uint32_t flags)
+{
+    const uint8_t index                                     = 6;
+    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_POWER, 0x01, 0x00, 0x00, 0x0F };
+
+    memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
+
+    buffer[3] = flags           & 0xFF;
+    buffer[4] = (flags >> 8)    & 0xFF;
+    buffer[5] = (flags >> 16)   & 0xFF;
+
+    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
+}
+
+uint32_t AsusAuraCoreLaptopController::PackPowerFlags(bool flags[])
+{
+    uint32_t temp = {};
+    const uint8_t length = 32;
+
+    for (size_t i = 0; i < length; ++i)
+    {
+        uint32_t flag = {flags[i]};
+        flag <<= i;
+        temp |= flag;
+    }
+
+    return temp;
+}

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController.h

@@ -0,0 +1,135 @@
+/*---------------------------------------------------------------------*\
+|  AsusAuraCoreLaptopController.h                                       |
+|                                                                       |
+|  Driver for AsusAuraCoreLaptop USB Controller                         |
+|                                                                       |
+|  Chris M (Dr_No)          28 Jul 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/
+
+#include <string>
+#include <vector>
+#include <hidapi/hidapi.h>
+#include "LogManager.h"
+#include "RGBController.h"
+#include "ResourceManager.h"
+#include "SettingsManager.h"
+#include "RGBControllerKeyNames.h"
+
+#pragma once
+
+#define NA                                      0xFFFFFFFF
+#define HID_MAX_STR                             255
+#define ASUSAURACORELAPTOP_TIMEOUT              250
+#define ASUSAURACORELAPTOP_READ_PACKET_SIZE     64
+#define ASUSAURACORELAPTOP_WRITE_PACKET_SIZE    64   //Buffer requires a prepended ReportID hence + 1
+
+#define ASUSAURACORELAPTOP_KEYCOUNT             91
+#define ASUSAURACORELAPTOP_KEY_WIDTH            18
+#define ASUSAURACORELAPTOP_KEY_HEIGHT           7
+#define ASUSAURACORELAPTOP_LIGHTBARCOUNT        6
+#define ASUSAURACORELAPTOP_LIDCOUNT             3
+#define ASUSAURACORELAPTOP_POWER_ZONES          4
+#define ASUSAURACORELAPTOP_POWER_STATES         4
+#define ASUSAURACORELAPTOP_BRIGHTNESS_MIN       0
+#define ASUSAURACORELAPTOP_BRIGHTNESS_MAX       255
+
+enum
+{
+    ASUSAURACORELAPTOP_MODE_OFF                 = 0x00, //Turn off - All leds off
+    ASUSAURACORELAPTOP_MODE_DIRECT              = 0xFF, //Direct Led Control - Independently set LEDs in zone
+    ASUSAURACORELAPTOP_MODE_STATIC              = 0x00, //Static Mode - Set entire zone to a single color.
+    ASUSAURACORELAPTOP_MODE_BREATHING           = 0x01, //Breathing Mode - Fades between fully off and fully on.
+    ASUSAURACORELAPTOP_MODE_SPECTRUM            = 0x02, //Spectrum Cycle Mode - Cycles through the color spectrum on all lights on the device
+    ASUSAURACORELAPTOP_MODE_RAINBOW             = 0x03, //Rainbow Wave Mode - Cycle thru the color spectrum as a wave across all LEDs
+    ASUSAURACORELAPTOP_MODE_FLASHING            = 0x0A, //Flashing Mode - Abruptly changing between fully off and fully on.
+
+    /*-------------------------------------------------*\
+    | Modes not implemented in the Armoury Crate        |
+    |   OEM software that were discovered.              |
+    \*-------------------------------------------------*/
+    ASUSAURACORELAPTOP_MODE_STARRY_NIGHT        = 0x04, //Starry Night Mode
+    ASUSAURACORELAPTOP_MODE_RAIN                = 0x05, //Rain Mode
+    ASUSAURACORELAPTOP_MODE_REACT_FADE          = 0x06, //Reactive Fade Mode
+    ASUSAURACORELAPTOP_MODE_REACT_LASER         = 0x07, //Reactive Laser Mode
+    ASUSAURACORELAPTOP_MODE_REACT_RIPPLE        = 0x08, //Reactive Ripple Mode
+    ASUSAURACORELAPTOP_MODE_COMET               = 0x0B, //Comet Mode
+    ASUSAURACORELAPTOP_MODE_FLASHNDASH          = 0x0C, //Flash n Dash Mode
+    ASUSAURACORELAPTOP_MODE_KEYSTONE            = 0x0D, //Keystone Mode
+};
+
+enum
+{
+    ASUSAURACORELAPTOP_ZONE_BYTE                = 2,
+    ASUSAURACORELAPTOP_MODE_BYTE                = 3,
+    ASUSAURACORELAPTOP_R1_BYTE                  = 4,
+    ASUSAURACORELAPTOP_G1_BYTE                  = 5,
+    ASUSAURACORELAPTOP_B1_BYTE                  = 6,
+    ASUSAURACORELAPTOP_SPEED_BYTE               = 7,
+    ASUSAURACORELAPTOP_DIRECTION_BYTE           = 8,
+    ASUSAURACORELAPTOP_DATA_BYTE                = 9,
+    ASUSAURACORELAPTOP_R2_BYTE                  = 10,
+    ASUSAURACORELAPTOP_G2_BYTE                  = 11,
+    ASUSAURACORELAPTOP_B2_BYTE                  = 12,
+};
+
+enum
+{
+    ASUSAURACORELAPTOP_REPORT_ID                = 0x5D,
+    ASUSAURACORELAPTOP_CMD_BRIGHTNESS           = 0xBA,
+    ASUSAURACORELAPTOP_CMD_DIRECT               = 0xBC,
+    ASUSAURACORELAPTOP_CMD_POWER                = 0xBD,
+    ASUSAURACORELAPTOP_CMD_UPDATE               = 0xB3,
+    ASUSAURACORELAPTOP_CMD_APPLY                = 0xB4,
+    ASUSAURACORELAPTOP_CMD_SET                  = 0xB5,
+};
+
+enum
+{
+    ASUSAURACORELAPTOP_SPEED_SLOWEST            = 0xE1, // Slowest speed
+    ASUSAURACORELAPTOP_SPEED_NORMAL             = 0xEB, // Normal speed
+    ASUSAURACORELAPTOP_SPEED_FASTEST            = 0xF5, // Fastest speed
+};
+
+struct p_state
+{
+    std::string zone;
+    bool        state;
+};
+
+class AsusAuraCoreLaptopController
+{
+public:
+    AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path);
+    ~AsusAuraCoreLaptopController();
+
+    std::string             GetDeviceName();
+    std::string             GetSerial();
+    std::string             GetLocation();
+
+    void                    SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor color1, RGBColor color2, uint8_t random, uint8_t direction);
+    void                    SetLedsDirect(std::vector<RGBColor> colors);
+private:
+    std::string             device_name;
+    std::string             location;
+    hid_device*             dev;
+
+    uint8_t                 current_mode;
+    uint8_t                 current_speed;
+    uint8_t                 current_direction;
+
+    RGBColor                current_c1;
+    RGBColor                current_c2;
+    uint8_t                 current_brightness;
+    uint8_t                 current_random;
+
+    void                    SendApply();
+    void                    SendBrightness();
+    void                    SendSet();
+    void                    SendUpdate();
+
+    void                    SetPowerConfigFromJSON();
+    void                    SendPowerConfig(uint32_t flags);
+    uint32_t                PackPowerFlags(bool flags[]);
+    std::vector<p_state>    PowerConfigArray();
+};

Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.cpp

@@ -44,39 +44,39 @@ RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* controller_pt
 
 void RGBController_AuraCore::SetupKeyboard()
 {
-    name        = "ASUS Aura Keyboard";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "ASUS Aura Core Device";
+    name                    = "ASUS Aura Keyboard";
+    vendor                  = "ASUS";
+    type                    = DEVICE_TYPE_KEYBOARD;
+    description             = "ASUS Aura Core Device";
 
     mode Static;
-    Static.name       = "Static";
-    Static.value      = AURA_CORE_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode = MODE_COLORS_PER_LED;
+    Static.name             = "Static";
+    Static.value            = AURA_CORE_MODE_STATIC;
+    Static.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode       = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = AURA_CORE_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Breathing.color_mode = MODE_COLORS_PER_LED;
+    Breathing.name          = "Breathing";
+    Breathing.value         = AURA_CORE_MODE_BREATHING;
+    Breathing.flags         = MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.color_mode    = MODE_COLORS_PER_LED;
     modes.push_back(Breathing);
 
     mode ColorCycle;
-    ColorCycle.name       = "Color Cycle";
-    ColorCycle.value      = AURA_CORE_MODE_SPECTRUM_CYCLE;
-    ColorCycle.flags      = 0;
-    ColorCycle.color_mode = MODE_COLORS_NONE;
+    ColorCycle.name         = "Color Cycle";
+    ColorCycle.value        = AURA_CORE_MODE_SPECTRUM_CYCLE;
+    ColorCycle.flags        = 0;
+    ColorCycle.color_mode   = MODE_COLORS_NONE;
     modes.push_back(ColorCycle);
 }
 
 void RGBController_AuraCore::SetupGA15DH()
 {
-    name        = "ASUS Aura GA15DH";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_LEDSTRIP;
-    description = "ASUS Aura Core Device";
+    name                    = "ASUS Aura GA15DH";
+    vendor                  = "ASUS";
+    type                    = DEVICE_TYPE_LEDSTRIP;
+    description             = "ASUS Aura Core Device";
 
     mode Static;
     Static.name             = "Static";
@@ -160,10 +160,10 @@ void RGBController_AuraCore::SetupGA15DH()
     modes.push_back(Irradiation);
 
     mode Direct;
-    Static.name       = "Direct";
-    Static.value      = AURA_CORE_MODE_DIRECT;
-    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode = MODE_COLORS_PER_LED;
+    Static.name             = "Direct";
+    Static.value            = AURA_CORE_MODE_DIRECT;
+    Static.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode       = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 }
 
@@ -312,11 +312,6 @@ void RGBController_AuraCore::UpdateSingleLED(int led)
     controller->SendApply();
 }
 
-void RGBController_AuraCore::SetCustomMode()
-{
-    active_mode = 0;
-}
-
 void RGBController_AuraCore::DeviceUpdateMode()
 {
     if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)

Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.h

@@ -27,7 +27,6 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
 
 private:

Controllers/AsusAuraCoreController/RGBController_AsusAuraCoreLaptop.cpp

@@ -0,0 +1,491 @@
+/*---------------------------------------------------------------------*\
+|  RGBController_AsusAuraCoreLaptop.cpp                                 |
+|                                                                       |
+|  Driver for AsusAuraCoreLaptop USB Controller                         |
+|                                                                       |
+|  Chris M (Dr_No)          28 Jul 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/
+
+#include "RGBController_AsusAuraCoreLaptop.h"
+
+static unsigned int matrix_map[ASUSAURACORELAPTOP_KEY_HEIGHT][ASUSAURACORELAPTOP_KEY_WIDTH] =
+{
+    {  NA,  NA,  86,  87,  88,  89,  90,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
+    {   0,  NA,   1,   2,   3,   4,  NA,   5,   6,   7,   8,  NA,   9,  10,  11,  12,  13,  NA },
+    {  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  NA },
+    {  31,  NA,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  NA,  45,  NA },
+    {  46,  NA,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  NA,  58,  NA,  59,  NA },
+    {  60,  NA,  61,  62,  63,  64,  65,  66,  67,  68,  69,  70,  71,  NA,  72,  NA,  73,  NA },
+    {  74,  75,  76,  77,  NA,  NA,  NA,  78,  NA,  NA,  NA,  79,  80,  81,  82,  83,  84,  85 }
+};
+
+static const char *led_names[] =
+{
+    KEY_EN_ESCAPE,              //00
+    KEY_EN_F1,
+    KEY_EN_F2,
+    KEY_EN_F3,
+    KEY_EN_F4,
+    KEY_EN_F5,
+    KEY_EN_F6,
+    KEY_EN_F7,
+    KEY_EN_F8,
+    KEY_EN_F9,
+    KEY_EN_F10,                 //10
+    KEY_EN_F11,
+    KEY_EN_F12,
+    KEY_EN_DELETE,
+
+    KEY_EN_BACK_TICK,
+    KEY_EN_1,
+    KEY_EN_2,
+    KEY_EN_3,
+    KEY_EN_4,
+    KEY_EN_5,
+    KEY_EN_6,                   //20
+    KEY_EN_7,
+    KEY_EN_8,
+    KEY_EN_9,
+    KEY_EN_0,
+    KEY_EN_MINUS,
+    KEY_EN_EQUALS,
+    KEY_EN_BACKSPACE,
+    KEY_EN_BACKSPACE,
+    KEY_EN_BACKSPACE,
+    KEY_EN_MEDIA_PLAY_PAUSE,    //30
+
+    KEY_EN_TAB,
+    KEY_EN_Q,
+    KEY_EN_W,
+    KEY_EN_E,
+    KEY_EN_R,
+    KEY_EN_T,
+    KEY_EN_Y,
+    KEY_EN_U,
+    KEY_EN_I,
+    KEY_EN_O,                   //40
+    KEY_EN_P,
+    KEY_EN_LEFT_BRACKET,
+    KEY_EN_RIGHT_BRACKET,
+    KEY_EN_ANSI_BACK_SLASH,
+    KEY_EN_MEDIA_STOP,
+
+    KEY_EN_CAPS_LOCK,
+    KEY_EN_A,
+    KEY_EN_S,
+    KEY_EN_D,
+    KEY_EN_F,                   //50
+    KEY_EN_G,
+    KEY_EN_H,
+    KEY_EN_J,
+    KEY_EN_K,
+    KEY_EN_L,
+    KEY_EN_SEMICOLON,
+    KEY_EN_QUOTE,
+    KEY_EN_ANSI_ENTER,
+    KEY_EN_MEDIA_PREVIOUS,
+
+    KEY_EN_LEFT_SHIFT,          //60
+    KEY_EN_Z,
+    KEY_EN_X,
+    KEY_EN_C,
+    KEY_EN_V,
+    KEY_EN_B,
+    KEY_EN_N,
+    KEY_EN_M,
+    KEY_EN_COMMA,
+    KEY_EN_PERIOD,
+    KEY_EN_FORWARD_SLASH,       //70
+    KEY_EN_RIGHT_SHIFT,
+    KEY_EN_UP_ARROW,
+    KEY_EN_MEDIA_NEXT,
+
+    KEY_EN_LEFT_CONTROL,
+    KEY_EN_LEFT_FUNCTION,
+    KEY_EN_LEFT_WINDOWS,
+    KEY_EN_LEFT_ALT,
+    KEY_EN_SPACE,
+    KEY_EN_RIGHT_ALT,
+    KEY_EN_RIGHT_CONTROL,       //80
+    KEY_EN_LEFT_ARROW,
+    KEY_EN_DOWN_ARROW,
+    KEY_EN_RIGHT_ARROW,
+    KEY_EN_PRINT_SCREEN,
+    "Asus Keystone",
+
+    KEY_EN_MEDIA_VOLUME_DOWN,
+    KEY_EN_MEDIA_VOLUME_UP,
+    "Key: Mic On/Off",
+    "Key: HyperFan",
+    "Key: Armoury Crate",       //90
+
+    "Lightbar LED 1",
+    "Lightbar LED 2",
+    "Lightbar LED 3",
+    "Lightbar LED 4",
+    "Lightbar LED 5",
+    "Lightbar LED 6",
+
+    "Logo",
+    "Lid Left",
+    "Lid Right",                //99
+};
+
+/**------------------------------------------------------------------*\
+    @name AsusAuraCoreLaptop
+    @category DEVICE_TYPE_KEYBOARD
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAsusAuraCoreLaptopControllers
+    @comment Power profiles for this controller are set to `On` for all power
+        state and scan be adjusted in the JSON config file.
+
+        For each zone available LEDs can be set as `On = true` or `Off = false` when
+        * Booting
+        * Awake (Normal Usage)
+        * Sleeping
+        * Shutdown / Power Off
+\*-------------------------------------------------------------------*/
+
+RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreLaptopController *controller_ptr)
+{
+    controller                  = controller_ptr;
+
+    name                        = "Asus Aura Core Laptop";
+    vendor                      = "Asus";
+    type                        = DEVICE_TYPE_KEYBOARD;
+    description                 = controller->GetDeviceName();
+    serial                      = controller->GetSerial();
+    location                    = controller->GetLocation();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = ASUSAURACORELAPTOP_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                = ASUSAURACORELAPTOP_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       = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
+    Static.brightness_max       = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Static.brightness           = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Static.speed_min            = ASUSAURACORELAPTOP_SPEED_SLOWEST;
+    Static.speed_max            = ASUSAURACORELAPTOP_SPEED_FASTEST;
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Static.speed                = ASUSAURACORELAPTOP_SPEED_NORMAL;
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = ASUSAURACORELAPTOP_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 2;
+    Breathing.colors.resize(Breathing.colors_min);
+    Breathing.brightness_min    = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Breathing.brightness        = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Breathing.speed_min         = ASUSAURACORELAPTOP_SPEED_SLOWEST;
+    Breathing.speed_max         = ASUSAURACORELAPTOP_SPEED_FASTEST;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed             = ASUSAURACORELAPTOP_SPEED_NORMAL;
+    modes.push_back(Breathing);
+
+    mode Flashing;
+    Flashing.name               = "Flashing";
+    Flashing.value              = ASUSAURACORELAPTOP_MODE_FLASHING;
+    Flashing.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Flashing.colors_min         = 1;
+    Flashing.colors_max         = 1;
+    Flashing.colors.resize(Flashing.colors_max);
+    Flashing.brightness_min     = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
+    Flashing.brightness_max     = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Flashing.brightness         = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Flashing.speed_min          = ASUSAURACORELAPTOP_SPEED_SLOWEST;
+    Flashing.speed_max          = ASUSAURACORELAPTOP_SPEED_FASTEST;
+    Flashing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    Flashing.speed              = ASUSAURACORELAPTOP_SPEED_NORMAL;
+    modes.push_back(Flashing);
+
+    mode Spectrum;
+    Spectrum.name               = "Spectrum Cycle";
+    Spectrum.value              = ASUSAURACORELAPTOP_MODE_SPECTRUM;
+    Spectrum.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Spectrum.brightness_min     = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
+    Spectrum.brightness_max     = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Spectrum.brightness         = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Spectrum.speed_min          = ASUSAURACORELAPTOP_SPEED_SLOWEST;
+    Spectrum.speed_max          = ASUSAURACORELAPTOP_SPEED_FASTEST;
+    Spectrum.color_mode         = MODE_COLORS_NONE;
+    Spectrum.speed              = ASUSAURACORELAPTOP_SPEED_NORMAL;
+    modes.push_back(Spectrum);
+
+    mode Rainbow;
+    Rainbow.name                = "Rainbow Wave";
+    Rainbow.value               = ASUSAURACORELAPTOP_MODE_RAINBOW;
+    Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
+    Rainbow.brightness_min      = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
+    Rainbow.brightness_max      = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Rainbow.brightness          = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Rainbow.speed_min           = ASUSAURACORELAPTOP_SPEED_SLOWEST;
+    Rainbow.speed_max           = ASUSAURACORELAPTOP_SPEED_FASTEST;
+    Rainbow.color_mode          = MODE_COLORS_NONE;
+    Rainbow.speed               = ASUSAURACORELAPTOP_SPEED_NORMAL;
+    modes.push_back(Rainbow);
+
+    mode Starry;
+    Starry.name                 = "Starry Night";
+    Starry.value                = ASUSAURACORELAPTOP_MODE_STARRY_NIGHT;
+    Starry.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Starry.colors_min           = 1;
+    Starry.colors_max           = 2;
+    Starry.colors.resize(Starry.colors_min);
+    Starry.brightness_min       = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
+    Starry.brightness_max       = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Starry.brightness           = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Starry.speed_min            = ASUSAURACORELAPTOP_SPEED_SLOWEST;
+    Starry.speed_max            = ASUSAURACORELAPTOP_SPEED_FASTEST;
+    Starry.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Starry.speed                = ASUSAURACORELAPTOP_SPEED_NORMAL;
+    modes.push_back(Starry);
+
+    mode Rain;
+    Rain.name                   = "Rain";
+    Rain.value                  = ASUSAURACORELAPTOP_MODE_RAIN;
+    Rain.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Rain.brightness_min         = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
+    Rain.brightness_max         = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Rain.brightness             = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Rain.speed_min              = ASUSAURACORELAPTOP_SPEED_SLOWEST;
+    Rain.speed_max              = ASUSAURACORELAPTOP_SPEED_FASTEST;
+    Rain.color_mode             = MODE_COLORS_NONE;
+    Rain.speed                  = ASUSAURACORELAPTOP_SPEED_NORMAL;
+    modes.push_back(Rain);
+
+    mode ReactFade;
+    ReactFade.name              = "Reactive - Fade";
+    ReactFade.value             = ASUSAURACORELAPTOP_MODE_REACT_FADE;
+    ReactFade.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    ReactFade.colors_min        = 1;
+    ReactFade.colors_max        = 1;
+    ReactFade.colors.resize(ReactFade.colors_max);
+    ReactFade.brightness_min    = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
+    ReactFade.brightness_max    = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    ReactFade.brightness        = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    ReactFade.speed_min         = ASUSAURACORELAPTOP_SPEED_SLOWEST;
+    ReactFade.speed_max         = ASUSAURACORELAPTOP_SPEED_FASTEST;
+    ReactFade.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    ReactFade.speed             = ASUSAURACORELAPTOP_SPEED_NORMAL;
+    modes.push_back(ReactFade);
+
+    mode ReactLaser;
+    ReactLaser.name             = "Reactive - Laser";
+    ReactLaser.value            = ASUSAURACORELAPTOP_MODE_REACT_LASER;
+    ReactLaser.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    ReactLaser.colors_min       = 1;
+    ReactLaser.colors_max       = 1;
+    ReactLaser.colors.resize(ReactLaser.colors_max);
+    ReactLaser.brightness_min   = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
+    ReactLaser.brightness_max   = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    ReactLaser.brightness       = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    ReactLaser.speed_min        = ASUSAURACORELAPTOP_SPEED_SLOWEST;
+    ReactLaser.speed_max        = ASUSAURACORELAPTOP_SPEED_FASTEST;
+    ReactLaser.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    ReactLaser.speed            = ASUSAURACORELAPTOP_SPEED_NORMAL;
+    modes.push_back(ReactLaser);
+
+    mode ReactRipple;
+    ReactRipple.name            = "Reactive - Ripple";
+    ReactRipple.value           = ASUSAURACORELAPTOP_MODE_REACT_RIPPLE;
+    ReactRipple.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    ReactRipple.colors_min      = 1;
+    ReactRipple.colors_max      = 1;
+    ReactRipple.colors.resize(ReactRipple.colors_max);
+    ReactRipple.brightness_min  = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
+    ReactRipple.brightness_max  = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    ReactRipple.brightness      = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    ReactRipple.speed_min       = ASUSAURACORELAPTOP_SPEED_SLOWEST;
+    ReactRipple.speed_max       = ASUSAURACORELAPTOP_SPEED_FASTEST;
+    ReactRipple.color_mode      = MODE_COLORS_MODE_SPECIFIC;
+    ReactRipple.speed           = ASUSAURACORELAPTOP_SPEED_NORMAL;
+    modes.push_back(ReactRipple);
+
+    mode Comet;
+    Comet.name                  = "Comet";
+    Comet.value                 = ASUSAURACORELAPTOP_MODE_COMET;
+    Comet.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
+    Comet.colors_min            = 1;
+    Comet.colors_max            = 1;
+    Comet.colors.resize(Comet.colors_max);
+    Comet.brightness_min        = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
+    Comet.brightness_max        = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Comet.brightness            = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Comet.speed_min             = ASUSAURACORELAPTOP_SPEED_SLOWEST;
+    Comet.speed_max             = ASUSAURACORELAPTOP_SPEED_FASTEST;
+    Comet.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Comet.speed                 = ASUSAURACORELAPTOP_SPEED_NORMAL;
+    modes.push_back(Comet);
+
+    mode FlashNDash;
+    FlashNDash.name             = "Flash N Dash";
+    FlashNDash.value            = ASUSAURACORELAPTOP_MODE_FLASHNDASH;
+    FlashNDash.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
+    FlashNDash.colors_min       = 1;
+    FlashNDash.colors_max       = 1;
+    FlashNDash.colors.resize(FlashNDash.colors_max);
+    FlashNDash.brightness_min   = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
+    FlashNDash.brightness_max   = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    FlashNDash.brightness       = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    FlashNDash.speed_min        = ASUSAURACORELAPTOP_SPEED_SLOWEST;
+    FlashNDash.speed_max        = ASUSAURACORELAPTOP_SPEED_FASTEST;
+    FlashNDash.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    FlashNDash.speed            = ASUSAURACORELAPTOP_SPEED_NORMAL;
+    modes.push_back(FlashNDash);
+
+    mode Keystone;
+    Keystone.name               = "Keystone";
+    Keystone.value              = ASUSAURACORELAPTOP_MODE_KEYSTONE;
+    Keystone.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Keystone.colors_min         = 1;
+    Keystone.colors_max         = 1;
+    Keystone.colors.resize(Keystone.colors_max);
+    Keystone.brightness_min     = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
+    Keystone.brightness_max     = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Keystone.brightness         = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Keystone.speed_min          = ASUSAURACORELAPTOP_SPEED_SLOWEST;
+    Keystone.speed_max          = ASUSAURACORELAPTOP_SPEED_FASTEST;
+    Keystone.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    Keystone.speed              = ASUSAURACORELAPTOP_SPEED_NORMAL;
+    modes.push_back(Keystone);
+
+    mode Off;
+    Off.name                    = "Off";
+    Off.value                   = ASUSAURACORELAPTOP_MODE_OFF;
+    Off.color_mode              = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    Init_Controller();
+    SetupZones();
+}
+
+RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop()
+{
+    delete controller;
+}
+
+void RGBController_AsusAuraCoreLaptop::Init_Controller()
+{
+    /*-------------------------------------------------*\
+    | Create the keyboard zone and add the matix map    |
+    \*-------------------------------------------------*/
+    zone KB_zone;
+    KB_zone.name                = "Keyboard Zone";
+    KB_zone.type                = ZONE_TYPE_MATRIX;
+    KB_zone.leds_min            = ASUSAURACORELAPTOP_KEYCOUNT;
+    KB_zone.leds_max            = ASUSAURACORELAPTOP_KEYCOUNT;
+    KB_zone.leds_count          = ASUSAURACORELAPTOP_KEYCOUNT;
+
+    KB_zone.matrix_map          = new matrix_map_type;
+    KB_zone.matrix_map->height  = ASUSAURACORELAPTOP_KEY_HEIGHT;
+    KB_zone.matrix_map->width   = ASUSAURACORELAPTOP_KEY_WIDTH;
+    KB_zone.matrix_map->map     = (unsigned int *)&matrix_map;
+    zones.push_back(KB_zone);
+
+    zone lightbar;
+    lightbar.name               = "Lightbar Zone";
+    lightbar.type               = ZONE_TYPE_LINEAR;
+    lightbar.leds_min           = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
+    lightbar.leds_max           = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
+    lightbar.leds_count         = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
+    zones.push_back(lightbar);
+
+    zone lid;
+    lid.name                    = "Lid Zone";
+    lid.type                    = ZONE_TYPE_LINEAR;
+    lid.leds_min                = ASUSAURACORELAPTOP_LIDCOUNT;
+    lid.leds_max                = ASUSAURACORELAPTOP_LIDCOUNT;
+    lid.leds_count              = ASUSAURACORELAPTOP_LIDCOUNT;
+    zones.push_back(lid);
+}
+
+void RGBController_AsusAuraCoreLaptop::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
+    leds.clear();
+    colors.clear();
+
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    for(std::size_t zone_index = 0; zone_index < zones.size(); zone_index++)
+    {
+        int zone_offset = leds.size();
+
+        for(unsigned int led_index = 0; led_index < zones[zone_index].leds_count; led_index++)
+        {
+            led new_led;
+            new_led.value   = led_index + zone_offset;
+            new_led.name    = led_names[new_led.value];
+            leds.push_back(new_led);
+        }
+    }
+
+    SetupColors();
+}
+
+void RGBController_AsusAuraCoreLaptop::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AsusAuraCoreLaptop::DeviceUpdateLEDs()
+{
+    controller->SetLedsDirect(colors);
+}
+
+void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int zone)
+{
+    std::vector<RGBColor> colour;
+    for(size_t i = 0; i < zones[zone].leds_count; i++)
+    {
+        colour.push_back(zones[zone].colors[i]);
+    }
+
+    controller->SetLedsDirect(colour);
+}
+
+void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int led)
+{
+    std::vector<RGBColor> colour;
+    colour.push_back(colors[led]);
+
+    controller->SetLedsDirect(colour);
+}
+
+void RGBController_AsusAuraCoreLaptop::DeviceUpdateMode()
+{
+    mode set_mode       = modes[active_mode];
+
+    if(set_mode.value == ASUSAURACORELAPTOP_MODE_DIRECT)
+    {
+        return;
+    }
+    uint8_t random      = (set_mode.color_mode == MODE_COLORS_RANDOM) ? 0xFF : 0;
+    RGBColor color1     = (set_mode.colors.size() > 0) ? set_mode.colors[0] : 0;
+    RGBColor color2     = (set_mode.colors.size() > 1) ? set_mode.colors[1] : 0;
+
+    controller->SetMode(set_mode.value, set_mode.speed, set_mode.brightness, color1, color2, random, set_mode.direction );
+}

Controllers/AsusAuraCoreController/RGBController_AsusAuraCoreLaptop.h

@@ -0,0 +1,35 @@
+/*---------------------------------------------------------------------*\
+|  RGBController_AsusAuraCoreLaptop.h                                   |
+|                                                                       |
+|  Driver for AsusAuraCoreLaptop USB Controller                         |
+|                                                                       |
+|  Chris M (Dr_No)          28 Jul 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/
+
+#pragma once
+
+#include <vector>
+#include "RGBController.h"
+#include "AsusAuraCoreLaptopController.h"
+
+class RGBController_AsusAuraCoreLaptop : public RGBController
+{
+public:
+    RGBController_AsusAuraCoreLaptop(AsusAuraCoreLaptopController* controller_ptr);
+    ~RGBController_AsusAuraCoreLaptop();
+
+    void                SetupZones();
+    void                ResizeZone(int zone, int new_size);
+
+    void                DeviceUpdateLEDs();
+    void                UpdateZoneLEDs(int zone);
+    void                UpdateSingleLED(int led);
+
+    void                DeviceUpdateMode();
+
+private:
+    void                Init_Controller();
+
+    AsusAuraCoreLaptopController*      controller;
+};

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -66,6 +66,7 @@ void DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
 } /* DetectAsusAuraGPUControllers() */
 
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 O2G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI 4G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI O4G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI O4G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING_2,      0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1060 Strix 6G Gaming"             , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX_6G_GAMING,               0x29);
@@ -86,34 +87,38 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1650S OC 4G"            , DetectAs
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660S O6G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1660 Ti OC 6G"                , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_GTX1660TI_OC,                      0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 EVO Gaming 6G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming 6G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING_86D2,     0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G EVO Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S 8G Gaming 8G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G EVO Gaming 8G", DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S O8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming 8G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming 8G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S 8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G EVO Gaming"   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729,    0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S 8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G V2 Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_V2_GAMING,       0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_A8G_GAMING,         0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S O8G White"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_WHITE,          0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING_866C,   0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060 Ti 8G Gaming OC"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS AREZ Strix RX Vega 56 O8G"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS Vega 64 Strix"                        , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 5600XT Strix O6G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 5700XT Strix Gaming OC"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS RX 6800 TUF Gaming OC"                , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_RX6800_TUF_GAMING_OC,                  0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX470 O4G GAMING"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX480 Gaming OC"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX480_STRIX_GAMING_OC,                 0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX560 Gaming"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING,                 0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 570 Strix O4G Gaming OC"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29);

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp

@@ -183,11 +183,6 @@ void RGBController_AuraGPU::UpdateSingleLED(int /*led*/)
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraGPU::SetCustomMode()
-{
-    active_mode = 0;
-}
-
 void RGBController_AuraGPU::DeviceUpdateMode()
 {
     int new_mode       = modes[active_mode].value;

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.h

@@ -25,7 +25,6 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
 
 private:

Controllers/AsusAuraUSBController/AsusAuraMonitorController.h

@@ -16,6 +16,7 @@
 enum
 {
     AURA_ROG_STRIX_XG27AQ_PID    = 0x198C,
+    AURA_ROG_STRIX_XG27W_PID     = 0x1933,
     AURA_ROG_PG32UQ_PID          = 0x19B9,
 };
 

Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp

@@ -85,9 +85,9 @@ std::string AuraMouseController::GetVersion(bool wireless, int protocol)
 
         case 3:
             {
-                char version[9];
+                char version[16];
                 int offset = (wireless ? 13 : 4);
-                snprintf(version, 9, "%2d.%02d.%02d", usb_buf_out[offset + 1], usb_buf_out[offset + 2], usb_buf_out[offset + 3]);
+                snprintf(version, 16, "%2d.%02d.%02d", usb_buf_out[offset + 1], usb_buf_out[offset + 2], usb_buf_out[offset + 3]);
                 str = std::string(version);
             }
             break;

Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h

@@ -18,6 +18,7 @@
 #define AURA_ROG_GLADIUS_II_ORIGIN_COD_PID          0x18B1
 #define AURA_ROG_GLADIUS_II_WIRELESS_1_PID          0x189E
 #define AURA_ROG_GLADIUS_II_WIRELESS_2_PID          0x18A0
+#define AURA_ROG_GLADIUS_III_PID                    0x197B
 #define AURA_ROG_GLADIUS_III_WIRELESS_USB_PID       0x197D
 #define AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID       0x197F
 #define AURA_ROG_GLADIUS_III_WIRELESS_BT_PID        0x1981
@@ -174,6 +175,19 @@ static std::map<int,mouse_type> aura_mouse_devices =
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
     },
+    {
+        AURA_ROG_GLADIUS_III_PID, // ROG Gladius III
+        {
+            255,
+            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_GLADIUS_III_WIRELESS_USB_PID, // ROG Gladius III Wireless USB
         {

Controllers/AsusAuraUSBController/AsusAuraMousematController.cpp

@@ -110,7 +110,7 @@ void AuraMousematController::UpdateDevice
     usb_buf[0x08]   = pattern;
     usb_buf[0x09]   = 0x00;
 
-    for(int i = 0; i < colors.size(); i++)
+    for(unsigned int i = 0; i < colors.size(); i++)
     {
         usb_buf[0x0a + i * 3]   = RGBGetRValue(colors[i]);
         usb_buf[0x0b + i * 3]   = RGBGetGValue(colors[i]);

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController.cpp

@@ -12,9 +12,6 @@
 
 AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
 {
-	const int szTemp = ASUSAURARYUOAIOCONTROLLER_HID_MAX_STR;
-	wchar_t tmpName[szTemp];
-
 	/*-----------------------------------------------------*\
 	| Add addressable devices                               |
 	|    Manually adding device info for now                |
@@ -33,7 +30,7 @@ std::string AsusAuraRyuoAIOController::GetLocation()
 	return("HID: " + location);
 }
 
-void AsusAuraRyuoAIOController::SetMode(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu)
+void AsusAuraRyuoAIOController::SetMode(unsigned char /*channel*/, unsigned char /*mode*/, unsigned char /*red*/, unsigned char /*grn*/, unsigned char /*blu*/)
 {
 	/*---------------------------------------------------------*\
 	| This interface is not used in this controller however is  |
@@ -56,7 +53,7 @@ void AsusAuraRyuoAIOController::SetMode(unsigned char mode, unsigned char speed,
 	}
 }
 
-void AsusAuraRyuoAIOController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
+void AsusAuraRyuoAIOController::SetChannelLEDs(unsigned char /*channel*/, RGBColor* /*colors*/, unsigned int /*num_colors*/)
 {
 	/*---------------------------------------------------------*\
 	| This interface is not used in this controller however is  |

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp

@@ -17,11 +17,12 @@
 #include <string.h>
 #include <cmath>
 
-AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid)
+AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short rev_version)
 {
     dev         = dev_handle;
     location    = path;
     device_pid  = pid;
+    version     = rev_version;
 }
 
 AuraTUFKeyboardController::~AuraTUFKeyboardController()
@@ -52,44 +53,131 @@ std::string AuraTUFKeyboardController::GetSerialString()
 
 std::string AuraTUFKeyboardController::GetVersion()
 {
-    unsigned char usb_buf[65];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x12;
-    usb_buf[0x02]   = 0x00;
-
-    hid_write(dev, usb_buf, 65);
-
-    unsigned char usb_buf_out[65];
-    hid_read(dev, usb_buf_out, 65);
-
-    char version[9];
-    if (device_pid == AURA_TUF_K3_GAMING_PID)
+    if(device_pid != AURA_ROG_CLAYMORE_PID)
     {
-        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
+        unsigned char usb_buf[65];
+        memset(usb_buf, 0x00, sizeof(usb_buf));
+        usb_buf[0x00]   = 0x00;
+        usb_buf[0x01]   = 0x12;
+        usb_buf[0x02]   = 0x00;
+
+        ClearResponses();
+
+        hid_write(dev, usb_buf, 65);
+
+        unsigned char usb_buf_out[65];
+        hid_read(dev, usb_buf_out, 65);
+
+        char version[9];
+        if(device_pid == AURA_TUF_K3_GAMING_PID)
+        {
+            snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
+        }
+        else
+        {
+            snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
+        }
+
+        return std::string(version);
     }
     else
     {
-        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
+        unsigned char usb_buf[65];
+        memset(usb_buf, 0x00, sizeof(usb_buf));
+        usb_buf[0x00]   = 0x00;
+        usb_buf[0x01]   = 0x10;
+        usb_buf[0x02]   = 0x01;
+        usb_buf[0x03]   = 0x00;
+        usb_buf[0x04]   = 0x00;
+        usb_buf[0x05]   = 0x00; // set to 1 to get firmware version of numpad
+
+        ClearResponses();
+
+        hid_write(dev, usb_buf, 65);
+
+        AwaitResponse(20);
+
+        unsigned char usb_buf1[65];
+        memset(usb_buf1, 0x00, sizeof(usb_buf1));
+        usb_buf1[0x00]   = 0x00;
+        usb_buf1[0x01]   = 0x12;
+        usb_buf1[0x02]   = 0x22;
+
+        ClearResponses();
+        hid_write(dev, usb_buf1, 65);
+
+        unsigned char usb_buf_out[65];
+        hid_read(dev, usb_buf_out, 65);
+
+        char version[9];
+        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[8], usb_buf_out[9], usb_buf_out[10]);
+
+        return std::string(version);
     }
-    
-    return std::string(version);
 }
 
 int AuraTUFKeyboardController::GetLayout()
+{
+    if(device_pid != AURA_ROG_CLAYMORE_PID)
+    {
+        unsigned char usb_buf[65];
+        memset(usb_buf, 0x00, sizeof(usb_buf));
+
+        usb_buf[0x00]   = 0x00;
+        usb_buf[0x01]   = 0x12;
+        usb_buf[0x02]   = 0x12;
+
+        ClearResponses();
+        hid_write(dev, usb_buf, 65);
+
+        unsigned char usb_buf_out[65];
+        hid_read(dev, usb_buf_out, 65);
+
+        return(usb_buf_out[4] * 100 + usb_buf_out[5]);
+    }
+    else
+    {
+        char layout[4];
+
+        sprintf(layout, "%X", version);
+
+        int layoutnum = std::stoi(std::string(layout, 1));
+
+        switch(layoutnum)
+        {
+            case 1:
+                return 117;
+            case 2:
+                return 204;
+            case 3:
+                return 221;
+            case 4:
+                return 117;
+            default:
+                return 117;
+        }
+    }
+}
+
+/*---------------------------------------------------------*\
+| only needed for Claymore                                  |
+\*---------------------------------------------------------*/
+int AuraTUFKeyboardController::GetNumpadLocation()
 {
     unsigned char usb_buf[65];
     memset(usb_buf, 0x00, sizeof(usb_buf));
     usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x12;
-    usb_buf[0x02]   = 0x12;
+    usb_buf[0x01]   = 0x40;
+    usb_buf[0x02]   = 0x60;
+
+    ClearResponses();
 
     hid_write(dev, usb_buf, 65);
 
     unsigned char usb_buf_out[65];
     hid_read(dev, usb_buf_out, 65);
 
-    return(usb_buf_out[4] * 100 + usb_buf_out[5]);
+    return(usb_buf_out[5] * 2 + usb_buf_out[4]);
 }
 
 void AuraTUFKeyboardController::SaveMode()
@@ -102,7 +190,31 @@ void AuraTUFKeyboardController::SaveMode()
     usb_save_buf[0x01]   = 0x50;
     usb_save_buf[0x02]   = 0x55;
 
+    ClearResponses();
+
     hid_write(dev, usb_save_buf, 65);
+
+    AwaitResponse(60);
+}
+
+/*---------------------------------------------------------*\
+| only needed for Claymore                                  |
+\*---------------------------------------------------------*/
+void AuraTUFKeyboardController::AllowRemoteControl(unsigned char type)
+{
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x41;
+    usb_buf[0x02]   = type;
+
+    ClearResponses();
+
+    hid_write(dev, usb_buf, 65);
+
+    AwaitResponse(20);
 }
 
 void AuraTUFKeyboardController::UpdateSingleLed
@@ -121,7 +233,7 @@ void AuraTUFKeyboardController::UpdateSingleLed
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
     usb_buf[0] = 0x00;
-    usb_buf[1] = 0xc0;
+    usb_buf[1] = 0xC0;
     usb_buf[2] = 0x81;
     usb_buf[3] = 0x01;
     usb_buf[4] = 0x00;
@@ -129,70 +241,54 @@ void AuraTUFKeyboardController::UpdateSingleLed
     /*-----------------------------------------------------*\
     | Convert LED index                                     |
     \*-----------------------------------------------------*/
-    usb_buf[5] = floor(led/6)*8 + led%6;
+    usb_buf[5] = led;
     usb_buf[6] = red;
     usb_buf[7] = green;
     usb_buf[8] = blue;
 
+    ClearResponses();
+
     hid_write(dev, usb_buf, 65);
+
+    AwaitResponse(20);
 }
 
 void AuraTUFKeyboardController::UpdateLeds
     (
-    std::vector<RGBColor>    colors
+    std::vector<led_color>    colors
     )
 {
-    /*-----------------------------------------------------*\
-    | Loop over every column (optimisation needed)          |
-    \*-----------------------------------------------------*/
-    for(unsigned int i = 0; i < 192; i += 16)
+    int packets = ceil((float) colors.size() / 15);
+
+    for(int i = 0; i < packets; i++)
     {
-        unsigned char usb_buf[69];
+        unsigned char usb_buf[65];
 
         memset(usb_buf, 0x00, sizeof(usb_buf));
 
+        int remaining = colors.size() - i * 15;
+
+        int leds = (remaining > 0x0F) ? 0x0F : remaining;
+
         usb_buf[0] = 0x00;
-        usb_buf[1] = 0xc0;
+        usb_buf[1] = 0xC0;
         usb_buf[2] = 0x81;
-        usb_buf[3] = (138 - i / 16 * 12);
+        usb_buf[3] = leds;
         usb_buf[4] = 0x00;
 
-        for(unsigned int n = 0; n < 6; n++)
+        for(int j = 0; j < leds; j++)
         {
-            usb_buf[n * 4 + 5] = i + n;
-            usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n]);
-            usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n]);
-            usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n]);
+            usb_buf[j * 4 + 5] = colors[i * 15 + j].value;
+            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);
         }
 
-        for(unsigned int n = 6; n < 8; n++)
-        {
-            usb_buf[n * 4 + 5] = i + n;
-            usb_buf[n * 4 + 6] = 0;
-            usb_buf[n * 4 + 7] = 0;
-            usb_buf[n * 4 + 8] = 0;
-        }
+        ClearResponses();
 
-        if(i != 176)
-        {
-            for(unsigned int n = 8; n < 14; n++)
-            {
-                usb_buf[n * 4 + 5] = i + n;
-                usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n-2]);
-                usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n-2]);
-                usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n-2]);
-            }
+        hid_write(dev, usb_buf, 65);
 
-            for(unsigned int n = 14; n < 16; n++)
-            {
-                usb_buf[n * 4 + 5] = i + n;
-                usb_buf[n * 4 + 6] = 0;
-                usb_buf[n * 4 + 7] = 0;
-                usb_buf[n * 4 + 8] = 0;
-            }
-        }
-
-        hid_write(dev, usb_buf, 69);
+        AwaitResponse(20);
     }
 }
 
@@ -200,7 +296,7 @@ void AuraTUFKeyboardController::UpdateDevice
     (
     unsigned char           mode,
     std::vector<RGBColor>   colors,
-    unsigned char           dir,
+    unsigned char           direction,
     unsigned char           color_mode,
     unsigned char           speed,
     unsigned char           brightness
@@ -213,62 +309,167 @@ void AuraTUFKeyboardController::UpdateDevice
     usb_buf[0x00]   = 0x00;
     usb_buf[0x01]   = 0x51;
     usb_buf[0x02]   = 0x2C;
-    usb_buf[0x03]   = mode;
-    usb_buf[0x04]   = 0x00;
-    usb_buf[0x05]   = speed;
-    usb_buf[0x06]   = brightness;
-    usb_buf[0x07]   = color_mode;
-    usb_buf[0x08]   = dir;
-    usb_buf[0x09]   = 0x02;
 
-    if(mode == 4 || mode == 5)
+    if(device_pid != AURA_ROG_CLAYMORE_PID)
     {
-        /*-----------------------------------------------------*\
-        | If mode is Rainbow or Ripple                          |
-        \*-----------------------------------------------------*/
-        usb_buf[0x0A]   = colors.size();
+        usb_buf[0x03]   = mode;
+        usb_buf[0x04]   = 0x00;
+        usb_buf[0x05]   = speed;
+        usb_buf[0x06]   = brightness;
+        usb_buf[0x07]   = color_mode;
+        usb_buf[0x08]   = direction;
+        usb_buf[0x09]   = 0x02;
 
-        /*-----------------------------------------------------*\
-        | Loop over every color given                           |
-        \*-----------------------------------------------------*/
-        for(unsigned int i = 0; i / 4 < colors.size(); i += 4)
+        if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
         {
-            if(colors[i / 4])
+            usb_buf[0x0A]   = colors.size();
+
+            /*-----------------------------------------------------*\
+            | Loop over every color given                           |
+            \*-----------------------------------------------------*/
+            for(unsigned int i = 0; i < colors.size(); i ++)
             {
-                usb_buf[11 + i] = 100/(double)colors.size()*(i/4+1);
-                usb_buf[12 + i] = RGBGetRValue(colors[i/4]);
-                usb_buf[13 + i] = RGBGetGValue(colors[i/4]);
-                usb_buf[14 + i] = RGBGetBValue(colors[i/4]);
+                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 / 3 != colors.size(); i += 3)
+        usb_buf[0x03]   = 0x00;
+        usb_buf[0x04]   = 0x00;
+        usb_buf[0x05]   = mode;
+        usb_buf[0x06]   = speed;
+
+        bool random     = (color_mode == 1);
+        bool pattern    = (color_mode == 2);
+
+        usb_buf[0x07]   = random * 128 + pattern * 32 + direction;
+        usb_buf[0x08]   = 0xFF; // "byteExt1" unknown usage
+        usb_buf[0x09]   = 0xFF; // "byteExt2" unknown usage
+        usb_buf[0x0A]   = (mode == 2) ? 0x80 : 0xFF; // "Lightness" (not Brightness)
+
+        if(mode == 7)
         {
-            if(colors[i / 3])
+            UpdateQuicksandColors(colors);
+        }
+        else
+        {
+            if(mode == 4 && color_mode == 0)
             {
-                usb_buf[10 + i] = RGBGetRValue(colors[i/3]);
-                usb_buf[11 + i] = RGBGetGValue(colors[i/3]);
-                usb_buf[12 + i] = RGBGetBValue(colors[i/3]);
+                usb_buf[11] = 0xFF;
+                usb_buf[12] = 0xFF;
+                usb_buf[13] = 0xFF;
+            }
+
+            for(unsigned int i = 0; i < colors.size(); i ++)
+            {
+                if(colors[i])
+                {
+                    usb_buf[11 + i * 3] = RGBGetRValue(colors[i]);
+                    usb_buf[12 + i * 3] = RGBGetGValue(colors[i]);
+                    usb_buf[13 + i * 3] = RGBGetBValue(colors[i]);
+                }
             }
         }
-            
+
+        for(int i = 1; i < 5; i++)
+        {
+            usb_buf[5 + i * 12] = 0xFF;
+        }
     }
 
+    ClearResponses();
+
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
+
+    AwaitResponse(20);
 }
 
-void AuraTUFKeyboardController::AwaitResponse()
+/*---------------------------------------------------------*\
+| only needed for Claymore                                  |
+\*---------------------------------------------------------*/
+void AuraTUFKeyboardController::UpdateQuicksandColors
+    (
+    std::vector<RGBColor>   colors
+    )
+{
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x51;
+    usb_buf[0x02]   = 0x91;
+
+    for(unsigned int i = 0; i < 6; i++)
+    {
+        if(colors[i])
+        {
+            usb_buf[5 + i * 3] = RGBGetRValue(colors[i]);
+            usb_buf[6 + i * 3] = RGBGetGValue(colors[i]);
+            usb_buf[7 + i * 3] = RGBGetBValue(colors[i]);
+        }
+    }
+
+    ClearResponses();
+
+    hid_write(dev, usb_buf, 65);
+
+    AwaitResponse(20);
+}
+
+/*---------------------------------------------------------*\
+| only needed for Claymore                                  |
+\*---------------------------------------------------------*/
+void AuraTUFKeyboardController::UpdateMode(unsigned char mode)
+{
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x51;
+    usb_buf[0x02]   = 0x28;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = 0x00;
+    usb_buf[0x05]   = mode;
+
+    ClearResponses();
+
+    hid_write(dev, usb_buf, 65);
+
+    AwaitResponse(20);
+}
+
+void AuraTUFKeyboardController::AwaitResponse(int ms)
 {
     unsigned char usb_buf_out[65];
-    hid_read(dev, usb_buf_out, 65);
+    hid_read_timeout(dev, usb_buf_out, 65, ms);
 }
 
 void AuraTUFKeyboardController::ClearResponses()
@@ -277,7 +478,7 @@ void AuraTUFKeyboardController::ClearResponses()
     unsigned char usb_buf_flush[65];
     while(result > 0)
     {
-      result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
+        result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
     }
 }
 

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h

@@ -16,14 +16,6 @@
 
 #pragma once
 
-enum
-{
-    AURA_KEYBOARD_ZONE_LOGO         = 0,
-    AURA_KEYBOARD_ZONE_SCROLL       = 1,
-    AURA_KEYBOARD_ZONE_UNDERGLOW    = 2,
-    AURA_KEYBOARD_ZONE_ALL          = 3,
-};
-
 enum
 {
     AURA_KEYBOARD_MODE_STATIC       =  0,
@@ -43,20 +35,28 @@ enum
 {
     AURA_TUF_K7_GAMING_PID          = 0x18AA,
     AURA_TUF_K3_GAMING_PID          = 0x194B,
+    AURA_ROG_CLAYMORE_PID           = 0x184D,
 };
 
+struct led_color
+{
+    unsigned int    value;
+    RGBColor        color;
+};
 
 class AuraTUFKeyboardController
 {
 public:
-    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid);
+    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short rev_version);
     ~AuraTUFKeyboardController();
 
     std::string GetDeviceLocation();
     std::string GetSerialString();
     std::string GetVersion();
     int         GetLayout();
+    int         GetNumpadLocation();
     void        SaveMode();
+    void        AllowRemoteControl(unsigned char type);
 
     void UpdateSingleLed
         (
@@ -68,7 +68,7 @@ public:
 
     void UpdateLeds
         (
-        std::vector<RGBColor>    colors
+        std::vector<led_color>    colors
         );
 
     void UpdateDevice
@@ -80,7 +80,9 @@ public:
         unsigned char           speed,
         unsigned char           brightness
         );
-    void AwaitResponse();
+    void UpdateQuicksandColors(std::vector<RGBColor> colors);
+    void UpdateMode(unsigned char mode);
+    void AwaitResponse(int ms);
     void ClearResponses();
 
     uint16_t                    device_pid;
@@ -88,5 +90,6 @@ public:
 private:
     hid_device*                 dev;
     std::string                 location;
+    unsigned short              version;
 };
 

Controllers/AsusAuraUSBController/AsusAuraUSBController.cpp

@@ -26,6 +26,7 @@ AuraUSBController::~AuraUSBController()
 {
     hid_close(dev);
 }
+
 unsigned int AuraUSBController::GetChannelCount()
 {
     return(device_info.size());
@@ -104,7 +105,7 @@ void AuraUSBController::GetConfigTable()
         }
     }
     else
-    {       
+    {
         LOG_INFO("[%s] Could not read config table, can not add device", device_name);
         delete this;
     }

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -47,6 +47,8 @@
 #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_TKL_PNK_LTD_PID    0x1954
+#define AURA_ROG_CLAYMORE_PID                   0x184D
 #define AURA_TUF_K7_GAMING_PID                  0x18AA
 #define AURA_TUF_K3_GAMING_PID                  0x194B
 
@@ -67,6 +69,8 @@
 \*-----------------------------------------------------------------*/
 
 #define AURA_ROG_STRIX_XG27AQ_PID               0x198C
+#define AURA_ROG_STRIX_XG27AQM_PID              0x19BB
+#define AURA_ROG_STRIX_XG27W_PID                0x1933
 #define AURA_ROG_PG32UQ_PID                     0x19B9
 
 /*-----------------------------------------------------------------*\
@@ -99,6 +103,7 @@ AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
             return SCOPE_RX_LAYOUT;
 
         case AURA_ROG_STRIX_SCOPE_TKL_PID:
+        case AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID:
             return SCOPE_TKL_LAYOUT;
 
         case AURA_ROG_FALCHION_WIRED_PID:
@@ -257,7 +262,7 @@ void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name
 
     if(dev)
     {
-        AuraTUFKeyboardController*     controller           = new AuraTUFKeyboardController(dev, info->path, info->product_id);
+        AuraTUFKeyboardController*     controller           = new AuraTUFKeyboardController(dev, info->path, info->product_id, info->release_number);
         RGBController_AuraTUFKeyboard* rgb_controller       = new RGBController_AuraTUFKeyboard(controller);
         rgb_controller->name                                = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -298,6 +303,8 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",                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 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 TUF Gaming K7",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID,                       1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K3_GAMING_PID,                       1,  0xFF00);
 
@@ -311,6 +318,7 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD",          DetectAs
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD",              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_COD_PID,           2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID,           1,  0xFF13);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID,           2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III",                        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_PID,                     0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless USB",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_USB_PID,        0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless 2.4Ghz",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID,        0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless Bluetooth",     DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_BT_PID,         0,  0xFF01);
@@ -346,6 +354,8 @@ REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus Qi",                         DetectAs
 | MONITORS                                                          |
 \*-----------------------------------------------------------------*/
 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 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);
 
 /*-----------------------------------------------------------------*\

Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.cpp

@@ -177,12 +177,6 @@ void RGBController_AuraHeadsetStand::UpdateSingleLED(int /*led*/)
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraHeadsetStand::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-
 void RGBController_AuraHeadsetStand::DeviceUpdateMode()
 {
     unsigned char red = 0;

Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.h

@@ -35,7 +35,6 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
     void        DeviceSaveMode();
 

Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.cpp

@@ -405,7 +405,7 @@ void RGBController_AuraKeyboard::SetupZones()
         \*-----------------------------------------------------*/
         case SCOPE_LAYOUT:
             led_names = default_led_names;
-            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
+            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
 
             led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x15});
             led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x1D});
@@ -413,8 +413,8 @@ void RGBController_AuraKeyboard::SetupZones()
 
         case SCOPE_RX_LAYOUT:
             led_names = default_led_names;
-            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
-            led_zones.push_back({"Logo",        ZONE_TYPE_SINGLE, 1});
+            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
+            led_zones.push_back({"Logo",                ZONE_TYPE_SINGLE, 1, NULL});
 
             led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x15});
             led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x1D});
@@ -423,9 +423,9 @@ void RGBController_AuraKeyboard::SetupZones()
 
         case SCOPE_TKL_LAYOUT:
             led_names = default_tkl_led_names;
-            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 86, new matrix_map_type{6, 18, (unsigned int *)&scope_tkl_matrix_map}});
-            led_zones.push_back({"Logo",        ZONE_TYPE_LINEAR, 2});
-            led_zones.push_back({"Underglow",   ZONE_TYPE_LINEAR, 26});
+            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 86, new matrix_map_type{6, 18, (unsigned int *)&scope_tkl_matrix_map}});
+            led_zones.push_back({"Logo",                ZONE_TYPE_LINEAR, 2, NULL});
+            led_zones.push_back({"Underglow",           ZONE_TYPE_LINEAR, 26, NULL});
 
             led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x15});
             led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x1D});
@@ -433,9 +433,9 @@ void RGBController_AuraKeyboard::SetupZones()
 
         case FLARE_LAYOUT:
             led_names = default_led_names;
-            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&flare_matrix_map}});
-            led_zones.push_back({"Logo",        ZONE_TYPE_SINGLE, 1});
-            led_zones.push_back({"Underglow",   ZONE_TYPE_SINGLE, 2});
+            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&flare_matrix_map}});
+            led_zones.push_back({"Logo",                ZONE_TYPE_SINGLE, 1, NULL});
+            led_zones.push_back({"Underglow",           ZONE_TYPE_SINGLE, 2, NULL});
 
             led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x0D});
             led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x15});
@@ -447,7 +447,7 @@ void RGBController_AuraKeyboard::SetupZones()
 
         case FALCHION_LAYOUT:
             led_names = default_65pct_led_names;
-            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 68, new matrix_map_type{5, 16, (unsigned int *)&falchion_matrix_map}});
+            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 68, new matrix_map_type{5, 16, (unsigned int *)&falchion_matrix_map}});
             break;
     }
 
@@ -527,11 +527,6 @@ void RGBController_AuraKeyboard::UpdateSingleLED(int /*led*/)
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraKeyboard::SetCustomMode()
-{
-    active_mode = 0;
-}
-
 void RGBController_AuraKeyboard::DeviceUpdateMode()
 {
 

Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.h

@@ -48,7 +48,6 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
 
 private:

Controllers/AsusAuraUSBController/RGBController_AsusAuraMonitor.cpp

@@ -112,12 +112,6 @@ void RGBController_AuraMonitor::UpdateSingleLED(int led)
     controller->ApplyChanges();
 }
 
-void RGBController_AuraMonitor::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-
 void RGBController_AuraMonitor::DeviceUpdateMode()
 {
     /*---------------------------------------------------------*\

Controllers/AsusAuraUSBController/RGBController_AsusAuraMonitor.h

@@ -25,7 +25,6 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
     void        DeviceSaveMode();
 

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp

@@ -221,11 +221,6 @@ void RGBController_AuraMouse::UpdateSingleLED(int led)
     controller->SendUpdate(leds[led].value, modes[active_mode].value, red, grn, blu, 0, false, 0, modes[active_mode].brightness);
 }
 
-void RGBController_AuraMouse::SetCustomMode()
-{
-    active_mode = 0;
-}
-
 void RGBController_AuraMouse::DeviceUpdateMode()
 {
     if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.h

@@ -25,7 +25,6 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
     void        DeviceSaveMode();
 

Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.cpp

@@ -22,15 +22,15 @@
 
 RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* controller_ptr)
 {
-    controller  = controller_ptr;
+    controller                  = controller_ptr;
 
-    name        = "ASUS Aura Mousemat";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_MOUSEMAT;
-    description = "ASUS Aura Mousemat Device";
-    version     = controller->GetVersion();
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
+    name                        = "ASUS Aura Mousemat";
+    vendor                      = "ASUS";
+    type                        = DEVICE_TYPE_MOUSEMAT;
+    description                 = "ASUS Aura Mousemat Device";
+    version                     = controller->GetVersion();
+    location                    = controller->GetDeviceLocation();
+    serial                      = controller->GetSerialString();
 
     mode Direct;
     Direct.name                 = "Direct";
@@ -230,11 +230,6 @@ void RGBController_AuraMousemat::UpdateSingleLED(int /*led*/)
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraMousemat::SetCustomMode()
-{
-    active_mode = 0;
-}
-
 void RGBController_AuraMousemat::DeviceUpdateMode()
 {
     if(modes[active_mode].value == AURA_MOUSEMAT_MODE_DIRECT)

Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.h

@@ -43,7 +43,6 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
     void        DeviceSaveMode();
 

Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.cpp

@@ -169,7 +169,7 @@ void RGBController_AsusAuraRyuoAIO::SetupZones()
     SetupColors();
 }
 
-void RGBController_AsusAuraRyuoAIO::ResizeZone(int zone, int new_size)
+void RGBController_AsusAuraRyuoAIO::ResizeZone(int /*zone*/, int /*new_size*/)
 {
     /*---------------------------------------------------------*\
     | This device does not support resizing zones               |
@@ -194,11 +194,6 @@ void RGBController_AsusAuraRyuoAIO::UpdateSingleLED(int led)
     UpdateZoneLEDs(GetLED_Zone(led));
 }
 
-void RGBController_AsusAuraRyuoAIO::SetCustomMode()
-{
-    active_mode = 0;
-}
-
 void RGBController_AsusAuraRyuoAIO::DeviceUpdateMode()
 {
     RGBColor colour = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;

Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.h

@@ -27,8 +27,8 @@ public:
     void UpdateZoneLEDs(int zone);
     void UpdateSingleLED(int led);
 
-    void SetCustomMode();
     void DeviceUpdateMode();
+
 private:
     int  GetDeviceMode();
     int  GetLED_Zone(int led_idx);

Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.cpp

@@ -129,11 +129,6 @@ void RGBController_AuraStrixEvolve::UpdateSingleLED(int /*led*/)
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraStrixEvolve::SetCustomMode()
-{
-    active_mode = 0;
-}
-
 void RGBController_AuraStrixEvolve::DeviceUpdateMode()
 {
     unsigned char red = RGBGetRValue(colors[0]);

Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.h

@@ -32,7 +32,6 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
     void        DeviceSaveMode();
 

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -24,178 +24,312 @@
 
 RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* controller_ptr)
 {
-    controller  = controller_ptr;
+    controller = controller_ptr;
 
-    name        = "ASUS Aura Keyboard";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "ASUS Aura Keyboard Device";
-    version     = controller->GetVersion();
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
+    pid = controller->device_pid;
 
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
+    if(pid != AURA_ROG_CLAYMORE_PID)
+    {
+        name        = "ASUS Aura Keyboard";
+        vendor      = "ASUS";
+        type        = DEVICE_TYPE_KEYBOARD;
+        description = "ASUS Aura Keyboard Device";
+        version     = controller->GetVersion();
+        location    = controller->GetDeviceLocation();
+        serial      = controller->GetSerialString();
 
-    mode Static;
-    Static.name                 = "Static";
-    Static.value                = AURA_KEYBOARD_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Static.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Static.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors_min           = 1;
-    Static.colors_max           = 1;
-    Static.colors.resize(1);
-    modes.push_back(Static);
+        mode Direct;
+        Direct.name                 = "Direct";
+        Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
+        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+        Direct.color_mode           = MODE_COLORS_PER_LED;
+        modes.push_back(Direct);
 
-    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.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-    Breathing.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-    Breathing.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-    Breathing.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Breathing.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Breathing.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors_min        = 1;
-    Breathing.colors_max        = 2;
-    Breathing.colors.resize(1);
-    modes.push_back(Breathing);
+        mode Static;
+        Static.name                 = "Static";
+        Static.value                = AURA_KEYBOARD_MODE_STATIC;
+        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        Static.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
+        Static.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
+        Static.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Static.colors_min           = 1;
+        Static.colors_max           = 1;
+        Static.colors.resize(1);
+        modes.push_back(Static);
 
-    mode Color_Cycle;
-    Color_Cycle.name            = "Spectrum Cycle";
-    Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
-    Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Color_Cycle.speed_min       = AURA_KEYBOARD_SPEED_MIN;
-    Color_Cycle.speed_max       = AURA_KEYBOARD_SPEED_MAX;
-    Color_Cycle.speed           = AURA_KEYBOARD_SPEED_DEFAULT;
-    Color_Cycle.brightness_min  = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Color_Cycle.brightness_max  = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Color_Cycle.brightness      = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Color_Cycle.color_mode      = MODE_COLORS_NONE;
-    modes.push_back(Color_Cycle);
+        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.speed_min         = AURA_KEYBOARD_SPEED_MIN;
+        Breathing.speed_max         = AURA_KEYBOARD_SPEED_MAX;
+        Breathing.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
+        Breathing.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
+        Breathing.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
+        Breathing.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+        Breathing.colors_min        = 1;
+        Breathing.colors_max        = 2;
+        Breathing.colors.resize(1);
+        modes.push_back(Breathing);
 
-    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.speed_min              = AURA_KEYBOARD_SPEED_MIN;
-    Wave.speed_max              = AURA_KEYBOARD_SPEED_MAX;
-    Wave.speed                  = AURA_KEYBOARD_SPEED_DEFAULT;
-    Wave.brightness_min         = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Wave.brightness_max         = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    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);
-    modes.push_back(Wave);
+        mode Color_Cycle;
+        Color_Cycle.name            = "Spectrum Cycle";
+        Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
+        Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        Color_Cycle.speed_min       = AURA_KEYBOARD_SPEED_MIN;
+        Color_Cycle.speed_max       = AURA_KEYBOARD_SPEED_MAX;
+        Color_Cycle.speed           = AURA_KEYBOARD_SPEED_DEFAULT;
+        Color_Cycle.brightness_min  = AURA_KEYBOARD_BRIGHTNESS_MIN;
+        Color_Cycle.brightness_max  = AURA_KEYBOARD_BRIGHTNESS_MAX;
+        Color_Cycle.brightness      = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+        Color_Cycle.color_mode      = MODE_COLORS_NONE;
+        modes.push_back(Color_Cycle);
 
-    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 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.speed_min              = AURA_KEYBOARD_SPEED_MIN;
+        Wave.speed_max              = AURA_KEYBOARD_SPEED_MAX;
+        Wave.speed                  = AURA_KEYBOARD_SPEED_DEFAULT;
+        Wave.brightness_min         = AURA_KEYBOARD_BRIGHTNESS_MIN;
+        Wave.brightness_max         = AURA_KEYBOARD_BRIGHTNESS_MAX;
+        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);
+        modes.push_back(Wave);
 
-    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 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 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 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 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 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 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 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);
+    }
+    else
+    {
+
+        name        = "ASUS ROG Claymore";
+        vendor      = "ASUS";
+        type        = DEVICE_TYPE_KEYBOARD;
+        description = "ASUS Aura Keyboard Device";
+        version     = controller->GetVersion();
+        location    = controller->GetDeviceLocation();
+        serial      = controller->GetSerialString();
+
+        mode Direct;
+        Direct.name                 = "Direct";
+        Direct.value                = AURA_KEYBOARD_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                = AURA_KEYBOARD_MODE_STATIC;
+        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_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             = AURA_KEYBOARD_MODE_BREATHING;
+        Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+        Breathing.speed_min         = AURA_CLAYMORE_SPEED_MIN;
+        Breathing.speed_max         = AURA_CLAYMORE_SPEED_MAX;
+        Breathing.speed             = AURA_CLAYMORE_SPEED_DEFAULT_BREATHING;
+        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+        Breathing.colors_min        = 1;
+        Breathing.colors_max        = 2;
+        Breathing.colors.resize(2);
+        modes.push_back(Breathing);
+
+        mode Color_Cycle;
+        Color_Cycle.name            = "Spectrum Cycle";
+        Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
+        Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+        Color_Cycle.speed_min       = AURA_CLAYMORE_SPEED_MIN;
+        Color_Cycle.speed_max       = AURA_CLAYMORE_SPEED_MAX;
+        Color_Cycle.speed           = AURA_CLAYMORE_SPEED_DEFAULT_COLOR_CYCLE;
+        Color_Cycle.color_mode      = MODE_COLORS_NONE;
+        modes.push_back(Color_Cycle);
+
+        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_AUTOMATIC_SAVE;
+        Reactive.speed_min          = AURA_CLAYMORE_SPEED_MIN;
+        Reactive.speed_max          = AURA_CLAYMORE_SPEED_MAX;
+        Reactive.speed              = AURA_CLAYMORE_SPEED_DEFAULT_REACTIVE;
+        Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+        Reactive.colors_min         = 1;
+        Reactive.colors_max         = 2;
+        Reactive.colors.resize(2);
+        modes.push_back(Reactive);
+
+        mode Wave;
+        Wave.name                   = "Rainbow Wave";
+        Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
+        Wave.flags                  = MODE_COLORS_NONE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
+        Wave.speed_min              = AURA_CLAYMORE_SPEED_MIN;
+        Wave.speed_max              = AURA_CLAYMORE_SPEED_MAX;
+        Wave.speed                  = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
+        Wave.direction              = MODE_DIRECTION_LEFT;
+        Wave.color_mode             = MODE_COLORS_NONE;
+        modes.push_back(Wave);
+
+        mode Color_Wave;
+        Color_Wave.name             = "Color Wave";
+        Color_Wave.value            = AURA_KEYBOARD_MODE_WAVE;
+        Color_Wave.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
+        Color_Wave.speed_min        = AURA_CLAYMORE_SPEED_MIN;
+        Color_Wave.speed_max        = AURA_CLAYMORE_SPEED_MAX;
+        Color_Wave.speed            = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
+        Color_Wave.direction        = MODE_DIRECTION_LEFT;
+        Color_Wave.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+        Color_Wave.colors_min       = 1;
+        Color_Wave.colors_max       = 2;
+        Color_Wave.colors.resize(2);
+        modes.push_back(Color_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_AUTOMATIC_SAVE;
+        Ripple.speed_min            = AURA_CLAYMORE_SPEED_MIN;
+        Ripple.speed_max            = AURA_CLAYMORE_SPEED_MAX;
+        Ripple.speed                = AURA_CLAYMORE_SPEED_DEFAULT_RIPPLE;
+        Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Ripple.colors_min           = 1;
+        Ripple.colors_max           = 2;
+        Ripple.colors.resize(2);
+        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_AUTOMATIC_SAVE;
+        Starry_Night.speed_min      = AURA_CLAYMORE_SPEED_MIN;
+        Starry_Night.speed_max      = AURA_CLAYMORE_SPEED_MAX;
+        Starry_Night.speed          = AURA_CLAYMORE_SPEED_DEFAULT_STARRY_NIGHT;
+        Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+        Starry_Night.colors_min     = 1;
+        Starry_Night.colors_max     = 2;
+        Starry_Night.colors.resize(2);
+        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_AUTOMATIC_SAVE;
+        Quicksand.direction         = MODE_DIRECTION_DOWN;
+        Quicksand.speed_min         = AURA_CLAYMORE_SPEED_MIN;
+        Quicksand.speed_max         = AURA_CLAYMORE_SPEED_MAX;
+        Quicksand.speed             = AURA_CLAYMORE_SPEED_DEFAULT_QUICKSAND;
+        Quicksand.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+        Quicksand.colors_min        = 6;
+        Quicksand.colors_max        = 6;
+        Quicksand.colors.resize(6);
+        modes.push_back(Quicksand);
+    }
 
     SetupZones();
 }
@@ -207,10 +341,44 @@ RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
 
 void RGBController_AuraTUFKeyboard::SetupZones()
 {
-    int layout = controller->GetLayout();
+    unsigned char layout = controller->GetLayout();
 
-    if(AsusTUFK7Layouts.find(layout % 100) == AsusTUFK7Layouts.end())
+    std::map<int,layout_info> * keyboard_ptr;
+
+    switch(pid)
     {
+        case AURA_ROG_CLAYMORE_PID:
+            unsigned char numpad;
+            numpad = controller->GetNumpadLocation();
+            switch(numpad)
+            {
+                case 0:
+                    keyboard_ptr = &AsusClaymoreNoNumpadLayouts;
+                    break;
+                case 2:
+                    keyboard_ptr = &AsusClaymoreNumpadRightLayouts;
+                    break;
+                case 3:
+                    keyboard_ptr = &AsusClaymoreNumpadLeftLayouts;
+                    break;
+                default:
+                    keyboard_ptr = &AsusClaymoreNoNumpadLayouts;
+            }
+            break;
+        case AURA_TUF_K7_GAMING_PID:
+            keyboard_ptr = &AsusTUFK7Layouts;
+            break;
+        default:
+            keyboard_ptr = &AsusTUFK7Layouts;
+    }
+
+    std::map<int,layout_info> & keyboard = *keyboard_ptr;
+
+    if(keyboard.find(layout % 100) == keyboard.end())
+    {
+        /*---------------------------------------------------------*\
+        | If Layout not found, take uk or us                        |
+        \*---------------------------------------------------------*/
         layout = std::floor(layout/100) == 2 ? ASUS_TUF_K7_LAYOUT_UK : ASUS_TUF_K7_LAYOUT_US;
     }
     else
@@ -218,33 +386,32 @@ void RGBController_AuraTUFKeyboard::SetupZones()
         layout = layout % 100;
     }
 
-    unsigned int total_led_count = 0;
+    zone keyboard_zone;
+    keyboard_zone.name               = "Keyboard";
+    keyboard_zone.type               = ZONE_TYPE_MATRIX;
+    keyboard_zone.leds_min           = keyboard[layout].size;
+    keyboard_zone.leds_max           = keyboard[layout].size;
+    keyboard_zone.leds_count         = keyboard[layout].size;
+    keyboard_zone.matrix_map         = new matrix_map_type;
+    keyboard_zone.matrix_map->height = keyboard[layout].rows;
+    keyboard_zone.matrix_map->width  = keyboard[layout].cols;
+    keyboard_zone.matrix_map->map    = keyboard[layout].matrix_map;
+    zones.push_back(keyboard_zone);
 
-    int zone_size = 138;
-
-    zone keyboard;
-    keyboard.name               = "Keyboard";
-    keyboard.type               = ZONE_TYPE_MATRIX;
-    keyboard.leds_min           = zone_size;
-    keyboard.leds_max           = zone_size;
-    keyboard.leds_count         = zone_size;
-    keyboard.matrix_map         = new matrix_map_type;
-    keyboard.matrix_map->height = 6;
-    keyboard.matrix_map->width  = 23;
-    keyboard.matrix_map->map    = AsusTUFK7Layouts[layout].matrix_map;
-    zones.push_back(keyboard);
-
-    total_led_count += zone_size;
-
-
-    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
+    for(int led_id = 0; led_id < keyboard[layout].size; led_id++)
     {
         led new_led;
-        new_led.name = AsusTUFK7Layouts[layout].led_names[led_idx];
+        new_led.name  = keyboard[layout].led_names[led_id].name;
+        new_led.value = keyboard[layout].led_names[led_id].id;
         leds.push_back(new_led);
     }
 
     SetupColors();
+
+    /*---------------------------------------------------------*\
+    | sends the init packet for the default mode (direct)       |
+    \*---------------------------------------------------------*/
+    DeviceUpdateMode();
 }
 
 void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
@@ -254,12 +421,20 @@ void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
 {
-    DeviceUpdateMode();
+    std::vector<led_color> led_color_list = {};
+
+    for(unsigned int i = 0; i < colors.size(); i++)
+    {
+        led_color_list.push_back({ leds[i].value, colors[i] });
+    }
+
+    controller->UpdateLeds(led_color_list);
+
 }
 
 void RGBController_AuraTUFKeyboard::UpdateZoneLEDs(int /*zone*/)
 {
-    controller->UpdateLeds(colors);
+    DeviceUpdateLEDs();
 }
 
 void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
@@ -268,77 +443,100 @@ void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
     unsigned char green = RGBGetGValue(colors[led]);
     unsigned char blue  = RGBGetBValue(colors[led]);
 
-    controller->UpdateSingleLed(led, red, green, blue);
+    controller->UpdateSingleLed(leds[led].value, red, green, blue);
 }
 
-void RGBController_AuraTUFKeyboard::SetCustomMode()
+static const uint8_t direction_map[2][6] =
 {
-    active_mode = 0;
-}
+    { 4,  0,  6,  2,  8,  1 },          // Default directions Left, Right, Up, Down, Horizontal, Vertical
+    { 0,  4,  6,  2,  0xFF,  0xFF },    // AURA_ROG_CLAYMORE directions Left, Right, Up, Down
+};
 
 void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
 {
-    unsigned char color_mode;
-    std::vector<RGBColor> mode_colors;
+    if(pid == AURA_ROG_CLAYMORE_PID)
+    {
+        controller->AllowRemoteControl(1);
+    }
+
+    unsigned char color_mode    = 0;
+    unsigned char direction     = 0;
+    unsigned char brightness    = 0;
 
     if(modes[active_mode].value == AURA_KEYBOARD_MODE_DIRECT)
     {
-        controller->UpdateLeds(colors);
+        if(pid == AURA_ROG_CLAYMORE_PID) controller->AllowRemoteControl(3);
+        return;
+    };
+
+    if(pid != AURA_ROG_CLAYMORE_PID)
+    {
+        brightness = modes[active_mode].brightness * 25;
+
+        switch(modes[active_mode].value)
+        {
+            case AURA_KEYBOARD_MODE_BREATHING:
+            case AURA_KEYBOARD_MODE_REACTIVE:
+            case AURA_KEYBOARD_MODE_STARRY_NIGHT:
+            case AURA_KEYBOARD_MODE_CURRENT:
+            case AURA_KEYBOARD_MODE_RAIN_DROP:
+                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)
+                {
+                    color_mode = 16;
+                }
+                break;
+        }
+
+        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
+        {
+            color_mode = 1;
+        }
+
+        if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE)
+        {
+            /*----------------------------------------------------------*\
+            | converting openrgb direction value to keyboard directions  |
+            \*----------------------------------------------------------*/
+            direction  = direction_map[0][modes[active_mode].direction];
+        }
     }
     else
     {
-        bool mode_with_double = (modes[active_mode].value == 1 || modes[active_mode].value == 3 || modes[active_mode].value == 6 || modes[active_mode].value == 8 || modes[active_mode].value == 9);
-
-        if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && mode_with_double && modes[active_mode].colors.size() > 1)
+        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
         {
-            if(modes[active_mode].colors[1] == 000)
-            {
-                color_mode = 0;
-            }
-            else
-            {
-                color_mode = 16;
-            }
-        }
-        else
-        {
-            color_mode = modes[active_mode].color_mode == MODE_COLORS_RANDOM ? 1 : 0;
+            color_mode = 1;
         }
 
-        int direction = 0;
+        if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE) {
+            if (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) color_mode = 2;
 
-        switch (modes[active_mode].direction)
-        {
-            case MODE_DIRECTION_LEFT:
-                direction = 0;
-                break;
-            case MODE_DIRECTION_RIGHT:
-                direction = 4;
-                break;
-            case MODE_DIRECTION_UP:
-                direction = 6;
-                break;
-            case MODE_DIRECTION_DOWN:
-                direction = 2;
-                break;
-            case MODE_DIRECTION_HORIZONTAL:
-                direction = 8;
-                break;
-            case MODE_DIRECTION_VERTICAL:
-                direction = 1;
-                break;
+            /*----------------------------------------------------------*\
+            | converting openrgb direction value to keyboard directions  |
+            \*----------------------------------------------------------*/
+            direction = direction_map[1][modes[active_mode].direction];
         }
+    }
 
-        mode_colors = modes[active_mode].color_mode == MODE_COLORS_PER_LED ? std::vector<RGBColor>(colors) : std::vector<RGBColor>(modes[active_mode].colors);
+    controller->UpdateDevice(modes[active_mode].value, std::vector<RGBColor>(modes[active_mode].colors), direction, color_mode, modes[active_mode].speed, brightness);
 
-        controller->UpdateDevice(modes[active_mode].value, mode_colors, direction, color_mode, (15 - modes[active_mode].speed), modes[active_mode].brightness * 25);
+    if(pid == AURA_ROG_CLAYMORE_PID)
+    {
+        controller->UpdateMode(modes[active_mode].value);
+        controller->SaveMode();
+        controller->AllowRemoteControl(0);
     }
 }
 
 void RGBController_AuraTUFKeyboard::DeviceSaveMode()
 {
-    controller->ClearResponses();
-    DeviceUpdateMode();
-    controller->AwaitResponse();
-    controller->SaveMode();
+    /*----------------------------------------------------------*\
+    | not available for Claymore                                 |
+    \*----------------------------------------------------------*/
+    if(pid != AURA_ROG_CLAYMORE_PID)
+    {
+        DeviceUpdateMode();
+        controller->SaveMode();
+    }
 }

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h

@@ -13,12 +13,27 @@
 
 enum
 {
-    AURA_KEYBOARD_SPEED_MIN          = 0,
-    AURA_KEYBOARD_SPEED_MAX          = 15,
+    AURA_KEYBOARD_SPEED_MIN          = 15,
+    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
+    AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 4,
+};
+
+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,
+
 };
 
 class RGBController_AuraTUFKeyboard : public RGBController
@@ -35,10 +50,10 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
     void        DeviceSaveMode();
 
 private:
     AuraTUFKeyboardController*  controller;
+    uint16_t                    pid;
 };

Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

@@ -249,11 +249,6 @@ void RGBController_AuraUSB::UpdateSingleLED(int led)
     controller->SetChannelLEDs(channel, zones[channel].colors, zones[channel].leds_count);
 }
 
-void RGBController_AuraUSB::SetCustomMode()
-{
-
-}
-
 void RGBController_AuraUSB::DeviceUpdateMode()
 {
     initializedMode   = true;

Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.h

@@ -27,7 +27,6 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
 
 private:

Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.cpp

@@ -171,7 +171,7 @@ void RGBController_ROGStrixLC_Controller::SetupZones()
     SetupColors();
 }
 
-void RGBController_ROGStrixLC_Controller::ResizeZone(int zone, int new_size)
+void RGBController_ROGStrixLC_Controller::ResizeZone(int /*zone*/, int /*new_size*/)
 {
     /*---------------------------------------------------------*\
     | This device does not support resizing zones               |
@@ -196,18 +196,6 @@ void RGBController_ROGStrixLC_Controller::UpdateSingleLED(int led)
     UpdateZoneLEDs(GetLED_Zone(led));
 }
 
-void RGBController_ROGStrixLC_Controller::SetCustomMode()
-{
-    for(std::size_t mode_idx = 0; mode_idx < modes.size() ; mode_idx++)
-    {
-        if (modes[mode_idx].value == ROGSTRIXLC_CONTROLLER_MODE_DIRECT)
-        {
-            active_mode = mode_idx;
-            break;
-        }
-    }
-}
-
 void RGBController_ROGStrixLC_Controller::DeviceUpdateMode()
 {
     RGBColor colour         = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;

Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.h

@@ -27,7 +27,6 @@ public:
     void                UpdateZoneLEDs(int zone);
     void                UpdateSingleLED(int led);
 
-    void                SetCustomMode();
     void                DeviceUpdateMode();
 private:
     int                 GetDeviceMode();

Controllers/AsusAuraUSBController/ROGStrixLC_Controller.cpp

@@ -12,9 +12,6 @@
 
 ROGStrixLC_Controller::ROGStrixLC_Controller(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
 {
-    const int szTemp = HID_MAX_STR;
-    wchar_t tmpName[szTemp];
-
     /*-----------------------------------------------------*\
     | Add addressable devices                               |
     |    Manually adding device info for now                |
@@ -34,7 +31,7 @@ std::string ROGStrixLC_Controller::GetLocation()
     return("HID: " + location);
 }
 
-void ROGStrixLC_Controller::SetMode(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu)
+void ROGStrixLC_Controller::SetMode(unsigned char /*channel*/, unsigned char /*mode*/, unsigned char /*red*/, unsigned char /*grn*/, unsigned char /*blu*/)
 {
     /*---------------------------------------------------------*\
     | This interface is not used in this controller however is  |
@@ -58,7 +55,7 @@ void ROGStrixLC_Controller::SetMode(unsigned char mode, unsigned char speed, uns
     }
 }
 
-void ROGStrixLC_Controller::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
+void ROGStrixLC_Controller::SetChannelLEDs(unsigned char /*channel*/, RGBColor* /*colors*/, unsigned int /*num_colors*/)
 {
     /*---------------------------------------------------------*\
     | This interface is not used in this controller however is  |

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController.cpp

@@ -0,0 +1,198 @@
+/*-----------------------------------------*\
+|  AsusCerberusKeyboardController.cpp       |
+|                                           |
+|  Driver for ASUS Cerberus USB lighting    |
+|  controller                               |
+|                                           |
+|  Mola19 05/28/2022                        |
+\*-----------------------------------------*/
+
+#include "AsusCerberusKeyboardController.h"
+
+#include <cstring>
+#include <string>
+#include <vector>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+#include <cmath>
+
+#define ASUS_CERBERUS_KB_PACKET_SIZE 8
+
+AsusCerberusKeyboardController::AsusCerberusKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version)
+{
+    dev         = dev_handle;
+    location    = path;
+    version     = rev_version;
+}
+
+AsusCerberusKeyboardController::~AsusCerberusKeyboardController()
+{
+    hid_close(dev);
+}
+
+std::string AsusCerberusKeyboardController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AsusCerberusKeyboardController::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 AsusCerberusKeyboardController::GetVersion()
+{
+    char versionstr[5];
+    snprintf(versionstr, 3, "%X", version);
+    return(std::string(versionstr, 3));
+}
+
+void AsusCerberusKeyboardController::SetProfile
+    (
+    uint8_t           profile
+    )
+{
+    uint8_t usb_buf[ASUS_CERBERUS_KB_PACKET_SIZE];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00] = 0x07;
+    usb_buf[0x01] = 0x03;
+    usb_buf[0x02] = profile;
+
+    hid_send_feature_report(dev, usb_buf, ASUS_CERBERUS_KB_PACKET_SIZE);
+}
+
+void AsusCerberusKeyboardController::SetPerLEDColor
+    (
+    uint8_t           key,
+    uint8_t           red,
+    uint8_t           green,
+    uint8_t           blue
+    )
+{
+    uint8_t profile = 1;
+
+    uint8_t usb_buf[ASUS_CERBERUS_KB_PACKET_SIZE];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00] = 0x07;
+    usb_buf[0x01] = 0x0D;
+    usb_buf[0x02] = profile;
+    usb_buf[0x03] = key;
+    usb_buf[0x04] = red;
+    usb_buf[0x05] = green;
+    usb_buf[0x06] = blue;
+
+    hid_send_feature_report(dev, usb_buf, ASUS_CERBERUS_KB_PACKET_SIZE);
+}
+
+void AsusCerberusKeyboardController::SendPerLEDColorEnd()
+{
+    SetPerLEDColor(255, 0, 0, 0);
+}
+
+void AsusCerberusKeyboardController::SetPerLEDMode
+    (
+    uint8_t           mode
+    )
+{
+    /*------------------------------------------------------------------------------------------------------*\
+    | this device has 6 different profiles, but there is no way to fetch them from the device,               |
+    | hence this device always sends to the first profile until a better solution is implemented in OpenRGB  |
+    \*------------------------------------------------------------------------------------------------------*/
+    uint8_t profile = 1;
+
+    /*--------------------------------------------------------------------------------*\
+    | 8 booleans per byte, each boolean controls one key                               |
+    | 0 = static, 1 = breathing                                                        |
+    | since openrgb doesn't support per led modes, either all static or all breathing  |
+    \*--------------------------------------------------------------------------------*/
+
+    uint8_t modebyte = (mode == 1) ? 0xFF : 0x00;
+
+    for(int i = 0; i < 4; i++)
+    {
+        uint8_t usb_buf[ASUS_CERBERUS_KB_PACKET_SIZE];
+
+        memset(usb_buf, 0x00, sizeof(usb_buf));
+
+        usb_buf[0x00] = 0x07;
+        usb_buf[0x01] = 0x0E;
+        usb_buf[0x02] = profile;
+        usb_buf[0x03] = i;
+        usb_buf[0x04] = modebyte;
+        usb_buf[0x05] = modebyte;
+        usb_buf[0x06] = modebyte;
+        usb_buf[0x07] = modebyte;
+
+        hid_send_feature_report(dev, usb_buf, ASUS_CERBERUS_KB_PACKET_SIZE);
+    }
+}
+
+void AsusCerberusKeyboardController::SetMode
+    (
+    uint8_t           mode,
+    uint8_t           red,
+    uint8_t           green,
+    uint8_t           blue,
+    uint8_t           direction,
+    uint8_t           brightness
+    )
+{
+    /*------------------------------------------------------------------------------------------------------*\
+    | this device has 6 different profiles, but there is no way to fetch them from the device,               |
+    | hence this device always sends to the first profile until a better solution is implemented in OpenRGB  |
+    \*------------------------------------------------------------------------------------------------------*/
+    uint8_t profile = 1;
+
+    uint8_t usb_buf_1[ASUS_CERBERUS_KB_PACKET_SIZE];
+
+    memset(usb_buf_1, 0x00, sizeof(usb_buf_1));
+
+    usb_buf_1[0x00] = 0x07;
+    usb_buf_1[0x01] = 0x0A;
+    usb_buf_1[0x02] = profile;
+    usb_buf_1[0x03] = mode;
+    usb_buf_1[0x04] = direction;
+
+    hid_send_feature_report(dev, usb_buf_1, ASUS_CERBERUS_KB_PACKET_SIZE);
+
+    uint8_t usb_buf_2[ASUS_CERBERUS_KB_PACKET_SIZE];
+
+    memset(usb_buf_2, 0x00, sizeof(usb_buf_2));
+
+    usb_buf_2[0x00] = 0x07;
+    usb_buf_2[0x01] = 0x0B;
+    usb_buf_2[0x02] = profile;
+    usb_buf_2[0x03] = mode;
+    usb_buf_2[0x04] = red;
+    usb_buf_2[0x05] = green;
+    usb_buf_2[0x06] = blue;
+
+    hid_send_feature_report(dev, usb_buf_2, ASUS_CERBERUS_KB_PACKET_SIZE);
+
+    uint8_t usb_buf_3[ASUS_CERBERUS_KB_PACKET_SIZE];
+
+    memset(usb_buf_3, 0x00, sizeof(usb_buf_3));
+
+    usb_buf_3[0x00] = 0x07;
+    usb_buf_3[0x01] = 0x0C;
+    usb_buf_3[0x02] = profile;
+    usb_buf_3[0x03] = brightness;
+
+    hid_send_feature_report(dev, usb_buf_3, ASUS_CERBERUS_KB_PACKET_SIZE);
+}

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController.h

@@ -0,0 +1,51 @@
+/*-----------------------------------------*\
+|  AsusCerberusKeyboardController.h         |
+|                                           |
+|  Definitions and types for ASUS Cerberus  |
+|  USB RGB lighting controller              |
+|                                           |
+|  Mola19 03/03/2021                        |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    CERBERUS_KEYBOARD_MODE_STATIC       = 0,
+    CERBERUS_KEYBOARD_MODE_BREATHING    = 1,
+    CERBERUS_KEYBOARD_MODE_REACTIVE     = 2,
+    CERBERUS_KEYBOARD_MODE_EXPLOSION    = 3,
+    CERBERUS_KEYBOARD_MODE_COLOR_CYCLE  = 4,
+    CERBERUS_KEYBOARD_MODE_WAVE         = 6,
+    CERBERUS_KEYBOARD_MODE_CUSTOM       = 7,
+};
+
+
+class AsusCerberusKeyboardController
+{
+public:
+    AsusCerberusKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version);
+    ~AsusCerberusKeyboardController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+    std::string GetVersion();
+
+    void SetProfile(uint8_t profile);
+    void SetPerLEDColor(uint8_t key, uint8_t red, uint8_t green, uint8_t blue);
+    void SendPerLEDColorEnd();
+    void SetPerLEDMode(uint8_t mode);
+    void SetMode(uint8_t mode, uint8_t red, uint8_t green, uint8_t blue, uint8_t direction, uint8_t brightness);
+
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+    unsigned short              version;
+};

Controllers/AsusLegacyUSBController/AsusLegacyUSBControllerDetect.cpp

@@ -0,0 +1,44 @@
+#include "Detector.h"
+#include "AsusCerberusKeyboardController.h"
+#include "AsusStrixClawController.h"
+#include "RGBController.h"
+#include "RGBController_AsusCerberusKeyboard.h"
+#include "RGBController_AsusStrixClaw.h"
+#include <stdexcept>
+#include <hidapi/hidapi.h>
+#include "dependencies/dmiinfo.h"
+
+#define ASUS_LEGACY_USB_VID         0x195D
+
+#define ASUS_CERBERUS_MECH_PID      0x2047
+#define ASUS_ROG_STRIX_CLAW_PID     0x1016
+
+void DetectAsusCerberusMech(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AsusCerberusKeyboardController*     controller          = new AsusCerberusKeyboardController(dev, info->path, info->release_number);
+        RGBController_AsusCerberusKeyboard* rgb_controller      = new RGBController_AsusCerberusKeyboard(controller);
+        rgb_controller->name                                = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectAsusStrixClaw(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        StrixClawController*     controller          = new StrixClawController(dev, info->path);
+        RGBController_StrixClaw* rgb_controller      = new RGBController_StrixClaw(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR_IPU("ASUS Cerberus Mech",  DetectAsusCerberusMech,  ASUS_LEGACY_USB_VID, ASUS_CERBERUS_MECH_PID,  1, 0xFF01, 1);
+
+REGISTER_HID_DETECTOR_IPU("ASUS ROG Strix Claw", DetectAsusStrixClaw,     ASUS_LEGACY_USB_VID, ASUS_ROG_STRIX_CLAW_PID, 0, 0xFF01, 1);

Controllers/AsusLegacyUSBController/AsusStrixClawController.cpp

@@ -0,0 +1,97 @@
+/*-----------------------------------------*\
+|  AsusStrixClawController.cpp              |
+|                                           |
+|  Driver for ASUS Strix USB                |
+|  lighting controller                      |
+|                                           |
+|  Mola19 08/06/2022                        |
+\*-----------------------------------------*/
+
+#include "AsusStrixClawController.h"
+
+#include <cstring>
+#include <string>
+
+StrixClawController::StrixClawController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+StrixClawController::~StrixClawController()
+{
+    hid_close(dev);
+}
+
+std::string StrixClawController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string StrixClawController::GetSerialString()
+{
+    wchar_t serial_string[HID_MAX_STR];
+    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
+
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+std::string StrixClawController::GetVersion()
+{
+
+    // asking the device to prepare version information
+    unsigned char usb_buf_out[9];
+
+    memset(usb_buf_out, 0x00, 9);
+
+    usb_buf_out[0x00] = 0x07;
+    usb_buf_out[0x01] = 0x80;
+
+    hid_send_feature_report(dev, usb_buf_out, 9);
+
+    // retrieving the version information
+    unsigned char usb_buf_in[9];
+
+    memset(usb_buf_in, 0x00, 9);
+
+    usb_buf_in[0x00] = 0x07;
+
+    hid_get_feature_report(dev, usb_buf_in, 9);
+
+    return (std::to_string(usb_buf_in[1]) + std::to_string(usb_buf_in[2]));
+}
+
+void StrixClawController::SetScrollWheelLED(bool OnOff)
+{
+    unsigned char usb_buf[9];
+
+    memset(usb_buf, 0x00, 9);
+
+    usb_buf[0x00] = 0x07;
+    usb_buf[0x01] = 0x07;
+    usb_buf[0x02] = 0x01;
+    usb_buf[0x03] = OnOff;
+    hid_send_feature_report(dev, usb_buf, 9);
+}
+
+void StrixClawController::SetLogoLED(uint8_t brightness)
+{
+    unsigned char usb_buf[9];
+
+    memset(usb_buf, 0x00, 9);
+
+    usb_buf[0x00] = 0x07;
+    usb_buf[0x01] = 0x0a;
+    usb_buf[0x02] = 0x01;
+    usb_buf[0x03] = 0x00;
+    usb_buf[0x04] = brightness;
+    hid_send_feature_report(dev, usb_buf, 9);
+}

Controllers/AsusLegacyUSBController/AsusStrixClawController.h

@@ -0,0 +1,35 @@
+/*-----------------------------------------*\
+|  AsusStrixClawController.h                |
+|                                           |
+|  Definitions and types for ASUS           |
+|  Legacy USB RGB lighting controller       |
+|                                           |
+|  Mola19 08/06/2022                        |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+#define HID_MAX_STR 255
+
+class StrixClawController
+{
+public:
+    StrixClawController(hid_device* dev_handle, const char* path);
+    virtual ~StrixClawController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+    std::string GetVersion();
+
+    void SetScrollWheelLED(bool OnOff);
+    void SetLogoLED(uint8_t brightness);
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+};

Controllers/AsusLegacyUSBController/RGBController_AsusCerberusKeyboard.cpp

@@ -0,0 +1,391 @@
+/*-----------------------------------------*\
+|  RGBController_AsusCerberusKeyboard.cpp   |
+|                                           |
+|  Generic RGB Interface for Asus Cerberus  |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 05/28/2022                        |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusCerberusKeyboard.h"
+#include <vector>
+#include <cmath>
+#include "RGBControllerKeyNames.h"
+
+/**------------------------------------------------------------------*\
+    @name Asus Cerberus Mech Keyboard
+    @category Keyboard
+    @type USB
+    @save :robot:
+    @direct :x:
+    @effects :white_check_mark:
+    @detectors DetectAsusCerberusMech
+    @comment
+\*-------------------------------------------------------------------*/
+
+
+//0xFFFFFFFF indicates an unused entry in matrix
+#define NA  0xFFFFFFFF
+
+
+static unsigned int matrix_map[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 },
+    {   3,  NA,  12,  18,  23,  28,  32,  38,  43,  48,  53,  59,  65,  70,  73,  NA,  NA,  NA,  NA,  NA,  90,  95,  99,  NA },
+    {   4,   7,  13,  19,  24,  29,  33,  39,  44,  49,  54,  60,  NA,  71,  NA,  NA,  NA,  82,  NA,  NA,  91,  96, 100, 104 },
+    {   5,   8,  14,  NA,  NA,  NA,  34,  NA,  NA,  NA,  55,  61,  66,  NA,  74,  NA,  78,  83,  87,  NA,  92,  NA, 101,  NA }
+};
+
+struct led_value
+{
+    const char*     name;
+    uint8_t         id;
+};
+
+static const std::vector<led_value> led_names =
+{
+    { KEY_EN_ESCAPE,              0x0B },
+    { KEY_EN_BACK_TICK,           0x0E },
+    { KEY_EN_TAB,                 0x09 },
+    { KEY_EN_CAPS_LOCK,           0x11 },
+    { KEY_EN_LEFT_SHIFT,          0x79 },
+    { KEY_EN_LEFT_CONTROL,        0x06 },
+
+    { KEY_EN_1,                   0x0F },
+    { KEY_EN_ISO_BACK_SLASH,      0x13 },
+    { KEY_EN_LEFT_WINDOWS,        0x7C },
+
+    { KEY_EN_F1,                  0x16 },
+    { KEY_EN_2,                   0x17 },
+    { KEY_EN_Q,                   0x08 },
+    { KEY_EN_A,                   0x0A },
+    { KEY_EN_Z,                   0x0C },
+    { KEY_EN_LEFT_ALT,            0x4B },
+
+    { KEY_EN_F2,                  0x1E },
+    { KEY_EN_3,                   0x1F },
+    { KEY_EN_W,                   0x10 },
+    { KEY_EN_S,                   0x12 },
+    { KEY_EN_X,                   0x14 },
+
+    { KEY_EN_F3,                  0x19 },
+    { KEY_EN_4,                   0x27 },
+    { KEY_EN_E,                   0x18 },
+    { KEY_EN_D,                   0x1A },
+    { KEY_EN_C,                   0x1C },
+
+    { KEY_EN_F4,                  0x1B },
+    { KEY_EN_5,                   0x26 },
+    { KEY_EN_R,                   0x20 },
+    { KEY_EN_F,                   0x22 },
+    { KEY_EN_V,                   0x24 },
+
+    { KEY_EN_6,                   0x2E },
+    { KEY_EN_T,                   0x21 },
+    { KEY_EN_G,                   0x23 },
+    { KEY_EN_B,                   0x25 },
+    { KEY_EN_SPACE,               0x5B },
+
+    { KEY_EN_F5,                  0x07 },
+    { KEY_EN_7,                   0x2F },
+    { KEY_EN_Y,                   0x29 },
+    { KEY_EN_H,                   0x2B },
+    { KEY_EN_N,                   0x2D },
+
+    { KEY_EN_F6,                  0x33 },
+    { KEY_EN_8,                   0x37 },
+    { KEY_EN_U,                   0x28 },
+    { KEY_EN_J,                   0x2A },
+    { KEY_EN_M,                   0x2C },
+
+    { KEY_EN_F7,                  0x39 },
+    { KEY_EN_9,                   0x3F },
+    { KEY_EN_I,                   0x30 },
+    { KEY_EN_K,                   0x32 },
+    { KEY_EN_COMMA,               0x34 },
+
+    { KEY_EN_F8,                  0x3E },
+    { KEY_EN_0,                   0x47 },
+    { KEY_EN_O,                   0x38 },
+    { KEY_EN_L,                   0x3A },
+    { KEY_EN_PERIOD,              0x3C },
+    { KEY_EN_RIGHT_ALT,           0x4D },
+
+    { KEY_EN_F9,                  0x56 },
+    { KEY_EN_MINUS,               0x46 },
+    { KEY_EN_P,                   0x40 },
+    { KEY_EN_SEMICOLON,           0x42 },
+    { KEY_EN_FORWARD_SLASH,       0x45 },
+    { KEY_EN_RIGHT_FUNCTION,      0x7D },
+
+    { KEY_EN_F10,                 0x57 },
+    { KEY_EN_EQUALS,              0x36 },
+    { KEY_EN_LEFT_BRACKET,        0x41 },
+    { KEY_EN_QUOTE,               0x43 },
+    { KEY_EN_MENU,                0x3D },
+
+    { KEY_EN_F11,                 0x53 },
+    { KEY_EN_BACKSPACE,           0x51 },
+    { KEY_EN_RIGHT_BRACKET,       0x31 },
+    { KEY_EN_POUND,               0x44 },
+    { KEY_EN_RIGHT_SHIFT,         0x7A },
+
+    { KEY_EN_F12,                 0x55 },
+    { KEY_EN_ISO_ENTER,           0x54 },
+    { KEY_EN_RIGHT_CONTROL,       0x04 },
+    { KEY_EN_PRINT_SCREEN,        0x4F },
+
+    { KEY_EN_INSERT,              0x66 },
+    { KEY_EN_DELETE,              0x5E },
+    { KEY_EN_LEFT_ARROW,          0x75 },
+
+    { KEY_EN_SCROLL_LOCK,         0x48 },
+    { KEY_EN_HOME,                0x76 },
+    { KEY_EN_END,                 0x77 },
+    { KEY_EN_UP_ARROW,            0x73 },
+    { KEY_EN_DOWN_ARROW,          0x5D },
+
+    { KEY_EN_PAUSE_BREAK,         0x00 },
+    { KEY_EN_PAGE_UP,             0x6E },
+    { KEY_EN_PAGE_DOWN,           0x6F },
+    { KEY_EN_RIGHT_ARROW,         0x65 },
+
+    { KEY_EN_NUMPAD_LOCK,         0x5C },
+    { KEY_EN_NUMPAD_7,            0x58 },
+    { KEY_EN_NUMPAD_4,            0x59 },
+    { KEY_EN_NUMPAD_1,            0x5A },
+    { KEY_EN_NUMPAD_0,            0x63 },
+
+    { KEY_EN_NUMPAD_DIVIDE,       0x64 },
+    { KEY_EN_NUMPAD_8,            0x60 },
+    { KEY_EN_NUMPAD_5,            0x61 },
+    { KEY_EN_NUMPAD_2,            0x62 },
+
+    { KEY_EN_NUMPAD_TIMES,        0x6C },
+    { KEY_EN_NUMPAD_9,            0x68 },
+    { KEY_EN_NUMPAD_6,            0x69 },
+    { KEY_EN_NUMPAD_3,            0x6A },
+    { KEY_EN_NUMPAD_PERIOD,       0x6B },
+
+    { KEY_EN_NUMPAD_MINUS,        0x6D },
+    { KEY_EN_NUMPAD_PLUS,         0x70 },
+    { KEY_EN_NUMPAD_ENTER,        0x72 }
+};
+
+RGBController_AsusCerberusKeyboard::RGBController_AsusCerberusKeyboard(AsusCerberusKeyboardController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    /*------------------------------------------------------------------------------------------------------*\
+    | this device has 6 different profiles, but there is no way to fetch them from the device,               |
+    | hence this device always sends to the first profile until a better solution is implemented in OpenRGB  |
+    \*------------------------------------------------------------------------------------------------------*/
+
+    controller->SetProfile(1);
+
+    name        = "ASUS Cerberus Keyboard";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "ASUS Cerberus Keyboard Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
+    version     = controller->GetVersion();
+
+    mode Custom;
+    Custom.name                     = "Custom";
+    Custom.value                    = CERBERUS_KEYBOARD_MODE_STATIC;
+    Custom.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Custom.brightness_min           = CERBERUS_MECH_BRIGHTNESS_MIN;
+    Custom.brightness_max           = CERBERUS_MECH_BRIGHTNESS_MAX;
+    Custom.brightness               = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
+    Custom.color_mode               = MODE_COLORS_PER_LED;
+    modes.push_back(Custom);
+
+    mode Static;
+    Static.name                     = "Static";
+    Static.value                    = CERBERUS_KEYBOARD_MODE_STATIC;
+    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.brightness_min           = CERBERUS_MECH_BRIGHTNESS_MIN;
+    Static.brightness_max           = CERBERUS_MECH_BRIGHTNESS_MAX;
+    Static.brightness               = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
+    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min               = 1;
+    Static.colors_max               = 1;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name                  = "Breathing";
+    Breathing.value                 = CERBERUS_KEYBOARD_MODE_BREATHING;
+    Breathing.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.brightness_min        = CERBERUS_MECH_BRIGHTNESS_MIN;
+    Breathing.brightness_max        = CERBERUS_MECH_BRIGHTNESS_MAX;
+    Breathing.brightness            = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
+    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors_min            = 1;
+    Breathing.colors_max            = 1;
+    Breathing.colors.resize(1);
+    modes.push_back(Breathing);
+
+    mode Reactive;
+    Reactive.name                   = "Reactive";
+    Reactive.value                  = CERBERUS_KEYBOARD_MODE_REACTIVE;
+    Reactive.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Reactive.brightness_min         = CERBERUS_MECH_BRIGHTNESS_MIN;
+    Reactive.brightness_max         = CERBERUS_MECH_BRIGHTNESS_MAX;
+    Reactive.brightness             = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
+    Reactive.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Reactive.colors_min             = 1;
+    Reactive.colors_max             = 1;
+    Reactive.colors.resize(1);
+    modes.push_back(Reactive);
+
+    mode Explosion;
+    Explosion.name                  = "Explosion";
+    Explosion.value                 = CERBERUS_KEYBOARD_MODE_EXPLOSION;
+    Explosion.flags                 = MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Explosion.brightness_min        = CERBERUS_MECH_BRIGHTNESS_MIN;
+    Explosion.brightness_max        = CERBERUS_MECH_BRIGHTNESS_MAX;
+    Explosion.brightness            = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
+    Explosion.direction             = MODE_DIRECTION_VERTICAL;
+    Explosion.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Explosion.colors_min            = 1;
+    Explosion.colors_max            = 1;
+    Explosion.colors.resize(1);
+    modes.push_back(Explosion);
+
+    mode Color_Cycle;
+    Color_Cycle.name                = "Spectrum Cycle";
+    Color_Cycle.value               = CERBERUS_KEYBOARD_MODE_COLOR_CYCLE;
+    Color_Cycle.flags               = MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Color_Cycle.brightness_min      = CERBERUS_MECH_BRIGHTNESS_MIN;
+    Color_Cycle.brightness_max      = CERBERUS_MECH_BRIGHTNESS_MAX;
+    Color_Cycle.brightness          = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
+    Color_Cycle.direction           = MODE_DIRECTION_HORIZONTAL;
+    Color_Cycle.color_mode          = MODE_COLORS_NONE;
+    modes.push_back(Color_Cycle);
+
+    mode Wave;
+    Wave.name                       = "Rainbow Wave";
+    Wave.value                      = CERBERUS_KEYBOARD_MODE_WAVE;
+    Wave.flags                      = MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Wave.brightness_min             = CERBERUS_MECH_BRIGHTNESS_MIN;
+    Wave.brightness_max             = CERBERUS_MECH_BRIGHTNESS_MAX;
+    Wave.brightness                 = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
+    Wave.direction                  = MODE_DIRECTION_LEFT;
+    Wave.color_mode                 = MODE_COLORS_NONE;
+    modes.push_back(Wave);
+
+    SetupZones();
+}
+
+RGBController_AsusCerberusKeyboard::~RGBController_AsusCerberusKeyboard()
+{
+    delete controller;
+}
+
+void RGBController_AsusCerberusKeyboard::SetupZones()
+{
+    int zone_size = 105;
+
+    zone keyboard;
+    keyboard.name               = "Keyboard";
+    keyboard.type               = ZONE_TYPE_MATRIX;
+    keyboard.leds_min           = zone_size;
+    keyboard.leds_max           = zone_size;
+    keyboard.leds_count         = zone_size;
+    keyboard.matrix_map         = new matrix_map_type;
+    keyboard.matrix_map->height = 6;
+    keyboard.matrix_map->width  = 24;
+    keyboard.matrix_map->map    = *matrix_map;
+    zones.push_back(keyboard);
+
+    for(int led_id = 0; led_id < zone_size; led_id++)
+    {
+        led new_led;
+        new_led.name  = led_names[led_id].name;
+        new_led.value = led_names[led_id].id;
+
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AsusCerberusKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
+void RGBController_AsusCerberusKeyboard::DeviceUpdateLEDs()
+{
+    for(unsigned int i = 0; i < colors.size(); i++)
+    {
+        uint8_t red   = RGBGetRValue(colors[i]);
+        uint8_t green = RGBGetGValue(colors[i]);
+        uint8_t blue  = RGBGetBValue(colors[i]);
+
+        controller->SetPerLEDColor(led_names[i].id, red, green, blue);
+    }
+    controller->SendPerLEDColorEnd();
+}
+
+void RGBController_AsusCerberusKeyboard::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AsusCerberusKeyboard::UpdateSingleLED(int led)
+{
+    uint8_t red   = RGBGetRValue(colors[led]);
+    uint8_t green = RGBGetGValue(colors[led]);
+    uint8_t blue  = RGBGetBValue(colors[led]);
+
+
+    controller->SetPerLEDColor(led_names[led].id, red, green, blue);
+    controller->SendPerLEDColorEnd();
+}
+
+void RGBController_AsusCerberusKeyboard::DeviceUpdateMode()
+{
+    uint8_t direction   = 0;
+    uint8_t red         = 0;
+    uint8_t green       = 0;
+    uint8_t blue        = 0;
+
+    uint8_t mode        = modes[active_mode].value;
+
+
+    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
+    {
+        mode        = CERBERUS_KEYBOARD_MODE_CUSTOM;
+        direction   = 1;
+
+        controller->SetPerLEDMode(modes[active_mode].value);
+    }
+
+    switch(modes[active_mode].value)
+    {
+        case CERBERUS_KEYBOARD_MODE_EXPLOSION:
+            direction = (modes[active_mode].direction == MODE_DIRECTION_HORIZONTAL) ? 1 : 0;
+            break;
+
+        case CERBERUS_KEYBOARD_MODE_COLOR_CYCLE:
+            direction = (modes[active_mode].direction == MODE_DIRECTION_HORIZONTAL) ? 0 : 1;
+            break;
+
+        case CERBERUS_KEYBOARD_MODE_WAVE:
+            direction = modes[active_mode].direction;
+            break;
+    }
+
+    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        red     = RGBGetRValue(modes[active_mode].colors[0]);
+        green   = RGBGetGValue(modes[active_mode].colors[0]);
+        blue    = RGBGetBValue(modes[active_mode].colors[0]);
+    }
+
+    controller->SetMode(mode, red, green, blue, direction, modes[active_mode].brightness);
+}

Controllers/AsusLegacyUSBController/RGBController_AsusCerberusKeyboard.h

@@ -0,0 +1,39 @@
+/*-----------------------------------------*\
+|  RGBController_AsusCerberusKeyboard.h     |
+|                                           |
+|  Generic RGB Interface for Asus Cerberus  |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 03/03/2021                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusCerberusKeyboardController.h"
+
+enum
+{
+    CERBERUS_MECH_BRIGHTNESS_MIN     = 0,
+    CERBERUS_MECH_BRIGHTNESS_MAX     = 4,
+    CERBERUS_MECH_BRIGHTNESS_DEFAULT = 4
+};
+
+class RGBController_AsusCerberusKeyboard : public RGBController
+{
+public:
+    RGBController_AsusCerberusKeyboard(AsusCerberusKeyboardController* controller_ptr);
+    ~RGBController_AsusCerberusKeyboard();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AsusCerberusKeyboardController*  controller;
+};

Controllers/AsusLegacyUSBController/RGBController_AsusStrixClaw.cpp

@@ -0,0 +1,132 @@
+/*-----------------------------------------*\
+|  RGBController_AsusStrixClaw.cpp          |
+|                                           |
+|  Generic RGB Interface for Asus           |
+|  Legacy USB controller driver             |
+|                                           |
+|  Mola19 08/06/2022                        |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusStrixClaw.h"
+
+/**------------------------------------------------------------------*\
+    @name Asus Strix Claw
+    @category Mouse
+    @type USB
+    @save :robot:
+    @direct :x:
+    @effects :tools:
+    @detectors DetectAsusStrixClaw
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_StrixClaw::RGBController_StrixClaw(StrixClawController* controller_ptr)
+{
+    controller   = controller_ptr;
+
+    name         = "ASUS ROG Strix Claw";
+    vendor       = "ASUS";
+    type         = DEVICE_TYPE_MOUSE;
+    description  = "ASUS Legacy Mouse Device";
+    version      = controller->GetVersion();
+    location     = controller->GetDeviceLocation();
+    serial       = controller->GetSerialString();
+
+    mode Off;
+    Off.name        = "Off";
+    Off.value       = 0;
+    Off.flags       = MODE_FLAG_AUTOMATIC_SAVE;
+    Off.color_mode  = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode On;
+    On.name         = "On";
+    On.value        = 1;
+    On.flags        = MODE_FLAG_AUTOMATIC_SAVE;
+    On.color_mode   = MODE_COLORS_NONE;
+    modes.push_back(On);
+
+    SetupZones();
+}
+
+RGBController_StrixClaw::~RGBController_StrixClaw()
+{
+    delete controller;
+}
+
+void RGBController_StrixClaw::SetupZones()
+{
+    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 LED";
+    scroll_wheel_led.value         = 1;
+
+    leds.push_back(scroll_wheel_led);
+
+    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 LED";
+    logo_led.value         = 1;
+
+    leds.push_back(logo_led);
+
+    SetupColors();
+}
+
+void RGBController_StrixClaw::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
+void RGBController_StrixClaw::DeviceUpdateLEDs()
+{
+    
+}
+
+void RGBController_StrixClaw::UpdateZoneLEDs(int /*zone*/)
+{
+    
+}
+
+void RGBController_StrixClaw::UpdateSingleLED(int /*led*/)
+{
+    
+}
+
+void RGBController_StrixClaw::DeviceUpdateMode()
+{
+    if(modes[active_mode].value == 0)
+    {
+        controller->SetScrollWheelLED(false);
+        controller->SetLogoLED(0);
+
+    }
+    else if(modes[active_mode].value == 1)
+    {
+        controller->SetScrollWheelLED(true);
+        controller->SetLogoLED(255);
+    }
+}
+

Controllers/AsusLegacyUSBController/RGBController_AsusStrixClaw.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_AsusStrixClaw.h            |
+|                                           |
+|  Generic RGB Interface for Asus           |
+|  Legacy USB controller driver             |
+|                                           |
+|  Mola19 08/06/2022                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusStrixClawController.h"
+
+
+class RGBController_StrixClaw : public RGBController
+{
+public:
+    RGBController_StrixClaw(StrixClawController* controller_ptr);
+    ~RGBController_StrixClaw();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    StrixClawController*  controller;
+};

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopWMI.cpp

@@ -141,11 +141,6 @@ void RGBController_AsusTUFLaptopWMI::UpdateSingleLED(int /*led*/)
     DeviceUpdateLEDs();
 }
 
-void RGBController_AsusTUFLaptopWMI::SetCustomMode()
-{
-    SetMode(0);
-}
-
 void RGBController_AsusTUFLaptopWMI::DeviceUpdateMode()
 {
     DeviceUpdateLEDs();

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopWMI.h

@@ -20,8 +20,6 @@ public:
     void UpdateSingleLED(int led) override;
 
     void DeviceUpdateMode() override;
-
-    void SetCustomMode() override;
 };
 
 #endif

Controllers/BlinkyTapeController/RGBController_BlinkyTape.cpp

@@ -137,11 +137,6 @@ void RGBController_BlinkyTape::UpdateSingleLED(int /*led*/)
     controller->SetLEDs(colors);
 }
 
-void RGBController_BlinkyTape::SetCustomMode()
-{
-
-}
-
 void RGBController_BlinkyTape::DeviceUpdateMode()
 {
 

Controllers/BlinkyTapeController/RGBController_BlinkyTape.h

@@ -25,7 +25,6 @@ public:
     void        UpdateZoneLEDs(int zone);
     void        UpdateSingleLED(int led);
 
-    void        SetCustomMode();
     void        DeviceUpdateMode();
 
 private:

Controllers/ColorfulGPUController/ColorfulGPUController.cpp

@@ -0,0 +1,44 @@
+#include "ColorfulGPUController.h"
+#include <cstring>
+
+ColorfulGPUController::ColorfulGPUController(i2c_smbus_interface* bus, colorful_gpu_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+}
+
+ColorfulGPUController::~ColorfulGPUController()
+{
+
+}
+
+std::string ColorfulGPUController::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);
+}
+
+void ColorfulGPUController::SetDirect(RGBColor color)
+{
+    uint8_t r = RGBGetRValue(color);
+    uint8_t g = RGBGetGValue(color);
+    uint8_t b = RGBGetBValue(color);
+
+    uint8_t data_pkt[COLORFUL_PACKET_LENGTH] = { 0xAA, 0xEF, 0x12, 0x03, 0x01, 0xFF, r, g, b};
+
+    int crc = 0;
+
+    for (int i = 0; i < COLORFUL_PACKET_LENGTH - 2; ++i)
+    {
+        crc += data_pkt[i];
+    }
+
+    data_pkt[COLORFUL_PACKET_LENGTH - 2] = crc & 0xFF;
+    data_pkt[COLORFUL_PACKET_LENGTH - 1] = crc >> 8;
+
+    bus->i2c_write_block(dev, COLORFUL_PACKET_LENGTH, data_pkt);
+}

Controllers/ColorfulGPUController/ColorfulGPUController.h

@@ -0,0 +1,24 @@
+#include <string>
+#include "i2c_smbus.h"
+#include "RGBController.h"
+
+#pragma once
+
+typedef unsigned char colorful_gpu_dev_id;
+
+#define COLORFUL_PACKET_LENGTH 11
+
+class ColorfulGPUController
+{
+public:
+    ColorfulGPUController(i2c_smbus_interface* bus, colorful_gpu_dev_id dev);
+    ~ColorfulGPUController();
+
+    std::string GetDeviceLocation();
+    void        SetDirect(RGBColor color);
+
+
+private:
+    i2c_smbus_interface *   bus;
+    colorful_gpu_dev_id     dev;
+};

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -0,0 +1,43 @@
+#include "Detector.h"
+#include "ColorfulGPUController.h"
+#include "RGBController.h"
+#include "RGBController_ColorfulGPU.h"
+#include "i2c_smbus.h"
+#include "pci_ids.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+bool TestForColorfulGPU(i2c_smbus_interface* bus, uint8_t i2c_addr)
+{
+    int pktsz;
+    const int read_sz  = 0x40;
+    const int write_sz = 6;
+
+    uint8_t data_pkt[write_sz] = { 0xAA, 0xEF, 0x81, 0x02, 0x1C, 0x02};
+    bus->i2c_write_block(i2c_addr, write_sz, data_pkt);
+
+    uint8_t read_pkt[read_sz] = {};
+    pktsz = read_sz;
+
+    int res = bus->i2c_read_block(i2c_addr, &pktsz, read_pkt);
+
+    return res == 0 && (read_pkt[0] == 0xAA && read_pkt[1] == 0xEF && read_pkt[2] == 0x81);
+}
+
+void DetectColorfulGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+{
+    if(TestForColorfulGPU(bus, i2c_addr))
+    {
+        ColorfulGPUController*     controller     = new ColorfulGPUController(bus, i2c_addr);
+        RGBController_ColorfulGPU* rgb_controller = new RGBController_ColorfulGPU(controller);
+        rgb_controller->name                      = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+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 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 Ti Advanced OC-V",   DetectColorfulGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,   COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_3070_TI_ADVANCED_OCV2,  0x61);

Controllers/ColorfulGPUController/RGBController_ColorfulGPU.cpp

@@ -0,0 +1,82 @@
+#include "RGBController_ColorfulGPU.h"
+#include <array>
+
+/**------------------------------------------------------------------*\
+    @name Colorful GPU
+    @category GPU
+    @type I2C
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectColorfulGPUControllers
+    @comment This card only supports direct mode
+\*-------------------------------------------------------------------*/
+
+RGBController_ColorfulGPU::RGBController_ColorfulGPU(ColorfulGPUController * colorful_gpu_ptr)
+{
+    controller  = colorful_gpu_ptr;
+    name        = "Colorful GPU Device";
+    vendor      = "Colorful";
+    type        = DEVICE_TYPE_GPU;
+    description = name;
+    location    = controller->GetDeviceLocation();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+
+}
+
+RGBController_ColorfulGPU::~RGBController_ColorfulGPU()
+{
+    delete controller;
+}
+
+void RGBController_ColorfulGPU::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_ColorfulGPU::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
+void RGBController_ColorfulGPU::DeviceUpdateLEDs()
+{
+    controller->SetDirect(colors[0]);
+}
+
+void RGBController_ColorfulGPU::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_ColorfulGPU::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_ColorfulGPU::DeviceUpdateMode()
+{
+    DeviceUpdateLEDs();
+}

Controllers/ColorfulGPUController/RGBController_ColorfulGPU.h

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

Controllers/CoolerMasterController/CMARGBGen2A1controller.cpp

@@ -0,0 +1,373 @@
+/*-------------------------------------------------------------------*\
+|  CMARGBGen2A1controller.cpp                                         |
+|                                                                     |
+|  Driver for Coolermaster ARGB Gen 2 A1 USB Controller               |
+|                                                                     |
+|  morg (Morgan Guimard) 6/26/2022                                    |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "CMARGBGen2A1controller.h"
+#include <cstring>
+
+CMARGBGen2A1controller::CMARGBGen2A1controller(hid_device* dev_handle, const hid_device_info& info)
+{
+    dev                 = dev_handle;
+    location            = info.path;
+
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        serial_number = "";
+    }
+    else
+    {
+        std::wstring return_wstring = serial_string;
+        serial_number = std::string(return_wstring.begin(), return_wstring.end());
+    }
+
+    /*---------------------------------------------*\
+    | Setup direct mode on start                    |
+    \*---------------------------------------------*/
+    SetupDirectMode();
+}
+
+CMARGBGen2A1controller::~CMARGBGen2A1controller()
+{
+    hid_close(dev);
+}
+
+std::string CMARGBGen2A1controller::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string CMARGBGen2A1controller::GetSerialString()
+{
+    return(serial_number);
+}
+
+void CMARGBGen2A1controller::SaveToFlash()
+{
+    unsigned char usb_buf[CM_ARGB_GEN2_A1_PACKET_LENGTH];
+
+    memset(usb_buf, 0x00, CM_ARGB_GEN2_A1_PACKET_LENGTH);
+
+    usb_buf[1] = CM_ARGB_GEN2_A1_COMMAND;
+    usb_buf[2] = CM_ARGB_GEN2_A1_FLASH;
+    usb_buf[3] = CM_ARGB_GEN2_A1_WRITE;
+
+    hid_write(dev, usb_buf, CM_ARGB_GEN2_A1_PACKET_LENGTH);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+}
+
+void CMARGBGen2A1controller::SetupDirectMode()
+{
+    unsigned char usb_buf[CM_ARGB_GEN2_A1_PACKET_LENGTH];
+
+    /*---------------------------------------------*\
+    | Swith to direct mode                          |
+    \*---------------------------------------------*/
+    memset(usb_buf, 0x00, CM_ARGB_GEN2_A1_PACKET_LENGTH);
+
+    usb_buf[1] = CM_ARGB_GEN2_A1_COMMAND;
+    usb_buf[2] = CM_ARGB_GEN2_A1_LIGHTNING_CONTROL;
+    usb_buf[3] = CM_ARGB_GEN2_A1_WRITE;
+    usb_buf[4] = 0x01; // channel???
+
+    hid_write(dev, usb_buf, CM_ARGB_GEN2_A1_PACKET_LENGTH);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+
+    software_mode_activated = true;
+}
+
+void CMARGBGen2A1controller::SetupZoneSize(unsigned int zone_id, unsigned int size)
+{
+    /*---------------------------------------------*\
+    | Set the mode sequence to full static          |
+    | (01 for static)                               |
+    |                                               |
+    | This device stores 2 distinct values          |
+    | - effect speed                                |
+    | - approximated zone size                      |
+    |                                               |
+    | It's probably based on standard ARGB sizes    |
+    | Still, the 06 value has some mystery.         |
+    |                                               |
+    | ES= effect speed                              |
+    | LC= LEDs count                                |
+    |                                               |
+    | ES LC                                         |
+    | -----                                         |
+    | 0a 06                                         |
+    | 09 06                                         |
+    | 08 07                                         |
+    | 07 08                                         |
+    | 06 0a                                         |
+    | 05 0c                                         |
+    | 04 0f                                         |
+    | 03 14                                         |
+    | 02 1e                                         |
+    | 01 3c                                         |
+    \*---------------------------------------------*/
+
+    const unsigned char gaps[10] =
+    {
+        0x05, 0x06, 0x07, 0x08, 0x0A, 0x0C, 0x0F, 0x14, 0x1E, 0x3C
+    };
+
+    unsigned char speed = 0x0A;
+
+    for(unsigned int g = 0; g < 10; g++)
+    {
+        if(size <= gaps[g])
+        {
+            break;
+        }
+
+        speed--;
+    }
+
+    unsigned char usb_buf[CM_ARGB_GEN2_A1_PACKET_LENGTH];
+
+    memset(usb_buf, 0x00, CM_ARGB_GEN2_A1_PACKET_LENGTH);
+
+    usb_buf[1] = CM_ARGB_GEN2_A1_COMMAND;
+    usb_buf[2] = CM_ARGB_GEN2_A1_SIZES;
+    usb_buf[3] = CM_ARGB_GEN2_A1_WRITE;
+    usb_buf[4] = 1 << zone_id;
+
+    usb_buf[5] = speed;
+    usb_buf[6] = size;
+
+    hid_write(dev, usb_buf, CM_ARGB_GEN2_A1_PACKET_LENGTH);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+}
+
+void CMARGBGen2A1controller::SendDirectChannel(unsigned int zone_id, std::vector<RGBColor> colors)
+{
+    /*---------------------------------------------*\
+    | Create the color data array                   |
+    \*---------------------------------------------*/
+    std::vector<unsigned char> color_data = CreateColorData(colors);
+
+    std::vector<unsigned char>::iterator it = color_data.begin();
+
+    unsigned char usb_buf[CM_ARGB_GEN2_A1_PACKET_LENGTH];
+
+    unsigned int offset;
+
+    unsigned char packet_start[CM_ARGB_GEN2_A1_PACKETS_PER_CHANNEL] =
+    {
+        0x00, 0x01, 0x82
+    };
+
+    /*---------------------------------------------*\
+    | Send 3 packets for the zone                   |
+    \*---------------------------------------------*/
+    for(unsigned int p = 0; p < CM_ARGB_GEN2_A1_PACKETS_PER_CHANNEL; p++)
+    {
+        memset(usb_buf, 0x00, CM_ARGB_GEN2_A1_PACKET_LENGTH);
+
+        usb_buf[1] = packet_start[p];
+        usb_buf[2] = 0x09;
+
+        if(p == 0)
+        {
+            usb_buf[3] = 1 << zone_id;
+            usb_buf[5] = 0x3C;
+
+            offset = 6;
+        }
+        else
+        {
+            offset = 3;
+        }
+
+        while(offset < CM_ARGB_GEN2_A1_PACKET_LENGTH && it != color_data.end())
+        {
+            usb_buf[offset] = *it;
+            offset++;
+            it++;
+        }
+
+        hid_write(dev, usb_buf, CM_ARGB_GEN2_A1_PACKET_LENGTH);
+
+        /*---------------------------------------------*\
+        | This device needs some delay before we send   |
+        | any other packet                              |
+        \*---------------------------------------------*/
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+
+    /*---------------------------------------------*\
+    | Next channel needs some delay as well         |
+    \*---------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
+}
+
+void CMARGBGen2A1controller::SetMode(unsigned int mode_value, unsigned char speed, unsigned char brightness, RGBColor color, bool random)
+{
+    unsigned char usb_buf[CM_ARGB_GEN2_A1_PACKET_LENGTH];
+
+    /*---------------------------------------------*\
+    | Switch to hardware mode if needed             |
+    \*---------------------------------------------*/
+    if(software_mode_activated)
+    {
+        memset(usb_buf, 0x00, CM_ARGB_GEN2_A1_PACKET_LENGTH);
+
+        usb_buf[1] = CM_ARGB_GEN2_A1_COMMAND;
+        usb_buf[2] = CM_ARGB_GEN2_A1_LIGHTNING_CONTROL;
+        usb_buf[3] = CM_ARGB_GEN2_A1_WRITE;
+
+        hid_write(dev, usb_buf, CM_ARGB_GEN2_A1_PACKET_LENGTH);
+
+        software_mode_activated = false;
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+
+    /*---------------------------------------------*\
+    | Set the mode values and write to the device   |
+    \*---------------------------------------------*/
+    memset(usb_buf, 0x00, CM_ARGB_GEN2_A1_PACKET_LENGTH);
+
+    usb_buf[1] = CM_ARGB_GEN2_A1_COMMAND;
+    usb_buf[2] = CM_ARGB_GEN2_A1_HW_MODE_SETUP;
+    usb_buf[3] = CM_ARGB_GEN2_A1_WRITE;
+
+    usb_buf[4] = 0xFF;
+    usb_buf[5] = 0xFF;
+
+    usb_buf[6] = mode_value;
+
+    bool is_custom_mode = mode_value == CM_ARGB_GEN2_A1_CUSTOM_MODE;
+
+    if(is_custom_mode)
+    {
+        usb_buf[8] = 0xFF;
+    }
+    else
+    {
+        usb_buf[7]  = speed;
+        usb_buf[8]  = brightness;
+        usb_buf[9]  = RGBGetRValue(color);
+        usb_buf[10] = RGBGetGValue(color);
+        usb_buf[11] = RGBGetBValue(color);
+        usb_buf[12] = random;
+    }
+
+
+    hid_write(dev, usb_buf, CM_ARGB_GEN2_A1_PACKET_LENGTH);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+
+    if(is_custom_mode)
+    {
+        for(unsigned int channel = 0; channel < CM_ARGB_GEN2_A1_CHANNEL_COUNT; channel++)
+        {
+            SetCustomSequence(channel);
+        }
+    }
+}
+
+std::vector<unsigned char> CMARGBGen2A1controller::CreateColorData(std::vector<RGBColor> colors)
+{
+    std::vector<unsigned char> color_data;
+
+    for(unsigned int c = 0; c < colors.size(); c++)
+    {
+        color_data.push_back(RGBGetRValue(colors[c]));
+        color_data.push_back(RGBGetGValue(colors[c]));
+        color_data.push_back(RGBGetBValue(colors[c]));
+    }
+
+    return color_data;
+}
+
+
+void CMARGBGen2A1controller::SetCustomColors(unsigned int zone_id, std::vector<RGBColor> colors)
+{
+    unsigned char usb_buf[CM_ARGB_GEN2_A1_PACKET_LENGTH];
+
+    /*---------------------------------------------*\
+    | Create the color data array                   |
+    \*---------------------------------------------*/
+    std::vector<unsigned char> color_data = CreateColorData(colors);
+
+    std::vector<unsigned char>::iterator it = color_data.begin();
+
+    unsigned char packet_start[5] =
+    {
+        CM_ARGB_GEN2_A1_COMMAND, 0x00, 0x01, 0x02, 0x83
+    };
+
+    /*---------------------------------------------*\
+    | Send the 5 packets of colors                  |
+    \*---------------------------------------------*/
+    for(unsigned int p = 0; p < 5; p++)
+    {
+        memset(usb_buf, 0x00, CM_ARGB_GEN2_A1_PACKET_LENGTH);
+
+        usb_buf[1] = packet_start[p];
+
+        /*----------------------------------------------*\
+        | This part isnt well understood                 |
+        | 1st packet starts with CM_ARGB_GEN2_A1_COMMAND |
+        | Looks like it is a read command                |
+        \*----------------------------------------------*/
+        usb_buf[2] = p == 0 ? 0x06 : 0x08; // 0x08 custom data, 0x06 sizes?
+        usb_buf[3] = p == 0 ? 0x01 : 0x02; // read/write has no meaning here
+
+        usb_buf[4] = 1 << zone_id;
+
+        unsigned int offset = 6;
+
+        while(p > 0 && offset < CM_ARGB_GEN2_A1_PACKET_LENGTH && it != color_data.end())
+        {
+            usb_buf[offset] = *it;
+            offset++;
+            it++;
+        }
+
+        hid_write(dev, usb_buf, CM_ARGB_GEN2_A1_PACKET_LENGTH);
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(20));
+    }
+
+}
+
+void CMARGBGen2A1controller::SetCustomSequence(unsigned int zone_id)
+{
+    unsigned char usb_buf[CM_ARGB_GEN2_A1_PACKET_LENGTH];
+
+    const unsigned char static_seq = 0x01;
+
+    /*---------------------------------------------*\
+    | Set the mode sequence to full static          |
+    | (01 for static)                               |
+    \*---------------------------------------------*/
+    memset(usb_buf, 0x00, CM_ARGB_GEN2_A1_PACKET_LENGTH);
+
+    usb_buf[1]  = CM_ARGB_GEN2_A1_COMMAND;
+    usb_buf[2]  = CM_ARGB_GEN2_A1_CUSTOM_SEQUENCES;
+    usb_buf[3]  = CM_ARGB_GEN2_A1_WRITE;
+    usb_buf[4]  = 1 << zone_id;
+
+    usb_buf[5]  = static_seq;
+    usb_buf[6]  = static_seq;
+    usb_buf[7]  = static_seq;
+    usb_buf[8]  = static_seq;
+    usb_buf[9]  = static_seq;
+    usb_buf[10] = static_seq;
+
+    hid_write(dev, usb_buf, CM_ARGB_GEN2_A1_PACKET_LENGTH);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+}

Controllers/CoolerMasterController/CMARGBGen2A1controller.h

@@ -0,0 +1,89 @@
+/*-------------------------------------------------------------------*\
+|  CMARGBGen2A1controller.h                                           |
+|                                                                     |
+|  Driver for Coolermaster ARGB Gen 2 A1 USB Controller               |
+|                                                                     |
+|  morg (Morgan Guimard) 6/26/2022                                    |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "RGBController.h"
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+#define CM_ARGB_GEN2_A1_PACKET_LENGTH 65
+#define CM_ARGB_GEN2_A1_CHANNEL_MAX_SIZE 48
+#define CM_ARGB_GEN2_A1_CHANNEL_COUNT 3
+#define CM_ARGB_GEN2_A1_PACKETS_PER_CHANNEL 3
+
+enum
+{
+    CM_ARGB_GEN2_A1_DIRECT_MODE         = 0xFF,
+    CM_ARGB_GEN2_A1_SPECTRUM_MODE       = 0x00,
+    CM_ARGB_GEN2_A1_STATIC_MODE         = 0x01,
+    CM_ARGB_GEN2_A1_RELOAD_MODE         = 0x02,
+    CM_ARGB_GEN2_A1_RECOIL_MODE         = 0x03,
+    CM_ARGB_GEN2_A1_BREATHING_MODE      = 0x04,
+    CM_ARGB_GEN2_A1_REFILL_MODE         = 0x05,
+    CM_ARGB_GEN2_A1_DEMO_MODE           = 0x06,
+    CM_ARGB_GEN2_A1_FILL_FLOW_MODE      = 0x07,
+    CM_ARGB_GEN2_A1_RAINBOW_MODE        = 0x08,
+    CM_ARGB_GEN2_A1_CUSTOM_MODE         = 0xC0,
+    CM_ARGB_GEN2_A1_OFF_MODE            = 0x09
+};
+
+enum
+{
+    CM_ARGB_GEN2_A1_BRIGHTNESS_MAX      = 0xFF,
+    CM_ARGB_GEN2_A1_BRIGHTNESS_MIN      = 0x00,
+    CM_ARGB_GEN2_A1_SPEED_MAX           = 0x04,
+    CM_ARGB_GEN2_A1_SPEED_MIN           = 0x00,
+};
+
+enum
+{
+    CM_ARGB_GEN2_A1_COMMAND             = 0x80,
+    CM_ARGB_GEN2_A1_READ                = 0x01,
+    CM_ARGB_GEN2_A1_WRITE               = 0x02,
+    CM_ARGB_GEN2_A1_RESPONSE            = 0x03
+};
+
+enum
+{
+    CM_ARGB_GEN2_A1_SIZES               = 0x06,
+    CM_ARGB_GEN2_A1_FLASH               = 0x0B,
+    CM_ARGB_GEN2_A1_IDENTIFY            = 0x0A,
+    CM_ARGB_GEN2_A1_LIGHTNING_CONTROL   = 0x01,
+    CM_ARGB_GEN2_A1_HW_MODE_SETUP       = 0x03,
+    CM_ARGB_GEN2_A1_CUSTOM_SEQUENCES    = 0x10,
+    CM_ARGB_GEN2_A1_CUSTOM_SPEED        = 0x11
+
+};
+
+class CMARGBGen2A1controller
+{
+public:
+    CMARGBGen2A1controller(hid_device* dev_handle, const hid_device_info& info);
+    ~CMARGBGen2A1controller();
+
+    std::string                 GetSerialString();
+    std::string                 GetDeviceLocation();
+
+    void                        SendDirectChannel(unsigned int zone_id, std::vector<RGBColor> colors);
+    void                        SetupZoneSize(unsigned int zone_id, unsigned int size);
+    void                        SetupDirectMode();
+    void                        SetMode(unsigned int mode_value, unsigned char speed, unsigned char brightness, RGBColor color, bool random);
+    void                        SetCustomColors(unsigned int zone_id, std::vector<RGBColor> colors);
+    void                        SaveToFlash();
+
+private:
+    std::string                 serial_number;
+    std::string                 location;
+    bool                        software_mode_activated = false;
+    hid_device*                 dev;
+
+    void                        SetCustomSequence(unsigned int zone_id);
+    std::vector<unsigned char>  CreateColorData(std::vector<RGBColor> colors);
+};

Controllers/CoolerMasterController/CMMMController.h

@@ -28,6 +28,7 @@ enum
     CM_MM531_PID                 = 0x0097,
     CM_MM711_PID                 = 0x0101,
     CM_MM720_PID                 = 0x0141,
+    CM_MM730_PID                 = 0x0165,
 };
 
 enum

Controllers/CoolerMasterController/CMR6000Controller.cpp

@@ -9,10 +9,11 @@
 #include "CMR6000Controller.h"
 #include <cstring>
 
-CMR6000Controller::CMR6000Controller(hid_device* dev_handle, char *_path)
+CMR6000Controller::CMR6000Controller(hid_device* dev_handle, char *_path, uint16_t _pid)
 {
     dev             = dev_handle;
     location        = _path;
+    pid             = _pid;
 
     const int szTemp = 256;
     wchar_t tmpName[szTemp];
@@ -59,21 +60,6 @@ unsigned char CMR6000Controller::GetMode()
     return current_mode;
 }
 
-unsigned char CMR6000Controller::GetLedRed()
-{
-    return current_red;
-}
-
-unsigned char CMR6000Controller::GetLedGreen()
-{
-    return current_green;
-}
-
-unsigned char CMR6000Controller::GetLedBlue()
-{
-    return current_blue;
-}
-
 unsigned char CMR6000Controller::GetLedSpeed()
 {
     return current_speed;
@@ -89,13 +75,17 @@ bool CMR6000Controller::GetRandomColours()
     return current_random;
 }
 
-void CMR6000Controller::SetMode(unsigned char mode, unsigned char speed, unsigned char red, unsigned char green, unsigned char blue, unsigned char random, unsigned char brightness)
+uint16_t CMR6000Controller::GetPID()
+{
+    return pid;
+}
+
+void CMR6000Controller::SetMode(unsigned char mode, unsigned char speed, RGBColor color1, RGBColor color2, unsigned char random, unsigned char brightness)
 {
     current_mode        = mode;
     current_speed       = speed;
-    current_red         = red;
-    current_green       = green;
-    current_blue        = blue;
+    primary             = color1;
+    secondary           = color2;
     current_random      = random;
     current_brightness  = brightness;
 
@@ -103,7 +93,7 @@ void CMR6000Controller::SetMode(unsigned char mode, unsigned char speed, unsigne
 }
 
 void CMR6000Controller::SendUpdate()
-{    
+{
     if(current_mode == CM_MR6000_MODE_OFF)
     {
         unsigned char buffer[CM_6K_PACKET_SIZE] = { 0x00, 0x41, 0x43 };
@@ -114,6 +104,11 @@ void CMR6000Controller::SendUpdate()
     {
         SendEnableCommand();
 
+        if(pid == COOLERMASTER_RADEON_6900_PID)
+        {
+            SendSecondColour();
+        }
+
         unsigned char buffer[CM_6K_PACKET_SIZE] = { 0x00 };
         int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
         memset(buffer, 0xFF, buffer_size);
@@ -124,18 +119,39 @@ void CMR6000Controller::SendUpdate()
         buffer[0x03] = 0x01;
         buffer[0x04] = 0x00;
         buffer[0x05] = current_mode;
-        buffer[0x06] = (current_mode == CM_MR6000_MODE_DIRECT) ? 0xFF: current_speed;
-        buffer[0x07] = (current_mode == CM_MR6000_MODE_BREATHE)? current_random : 0x00; //random (A0)
-        buffer[0x08] = (current_mode == CM_MR6000_MODE_BREATHE)? 0x03 : 0xFF;
+        buffer[0x06] = current_speed;
+        buffer[0x07] = current_random; //random (A0)
         //buffer[0x09] = 0xFF;
         buffer[0x0A] = current_brightness;
-        buffer[0x0B] = (current_mode == CM_MR6000_MODE_COLOR_CYCLE) ? 0xFF : current_red;
-        buffer[0x0C] = (current_mode == CM_MR6000_MODE_COLOR_CYCLE) ? 0xFF : current_green;
-        buffer[0x0D] = (current_mode == CM_MR6000_MODE_COLOR_CYCLE) ? 0xFF : current_blue;
+        buffer[0x0B] = (current_mode == CM_MR6000_MODE_COLOR_CYCLE) ? 0xFF : RGBGetRValue(primary);
+        buffer[0x0C] = (current_mode == CM_MR6000_MODE_COLOR_CYCLE) ? 0xFF : RGBGetGValue(primary);
+        buffer[0x0D] = (current_mode == CM_MR6000_MODE_COLOR_CYCLE) ? 0xFF : RGBGetBValue(primary);
         buffer[0x0E] = 0x00;
         buffer[0x0F] = 0x00;
         buffer[0x10] = 0x00;
 
+        /*-----------------------------------------------------------------*\
+        | Index 0x08 looks to be mode specific flags / options              |
+        \*-----------------------------------------------------------------*/
+        switch(current_mode)
+        {
+            case CM_MR6000_MODE_BREATHE:
+                buffer[0x08] = 0x03;
+                break;
+            case CM_MR6000_MODE_RAINBOW:
+                buffer[0x08] = 0x05;
+                break;
+            case CM_MR6000_MODE_CHASE:
+                buffer[0x08] = 0xC3;
+                break;
+            case CM_MR6000_MODE_SWIRL:
+                buffer[0x08] = 0x4A;
+                break;
+            default:
+                buffer[0x08] = 0xFF;
+        }
+
+
         hid_write(dev, buffer, buffer_size);
 
         SendColourConfig();
@@ -174,3 +190,18 @@ void CMR6000Controller::SendColourConfig()
     hid_write(dev, buffer, buffer_size);
     hid_read_timeout(dev, buffer, buffer_size, CM_6K_INTERRUPT_TIMEOUT);
 }
+
+void CMR6000Controller::SendSecondColour()
+{
+    unsigned char buffer[CM_6K_PACKET_SIZE] = { 0x00, 0x51, 0x9C, 0x01, 0x00 };
+
+    buffer[5]   = RGBGetRValue(primary);
+    buffer[6]   = RGBGetGValue(primary);
+    buffer[7]   = RGBGetBValue(primary);
+    buffer[8]   = RGBGetRValue(secondary);
+    buffer[9]   = RGBGetGValue(secondary);
+    buffer[10]  = RGBGetBValue(secondary);
+
+    hid_write(dev, buffer, CM_6K_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_6K_PACKET_SIZE, CM_6K_INTERRUPT_TIMEOUT);
+}

Controllers/CoolerMasterController/CMR6000Controller.h

@@ -9,21 +9,31 @@
 #include <string>
 #include <array>
 #include <hidapi/hidapi.h>
+#include "RGBController.h"
 
 #pragma once
 
-#define CM_6K_PACKET_SIZE       65  //Includes extra first byte for non HID Report packets
-#define CM_6K_INTERRUPT_TIMEOUT 250
-#define CM_6K_DEVICE_NAME_SIZE  (sizeof(device_name) / sizeof(device_name[ 0 ]))
-#define CM_6K_SERIAL_SIZE       (sizeof(serial) / sizeof(serial[ 0 ]))
-#define HID_MAX_STR             255
+#define COOLERMASTER_RADEON_6000_PID            0x014D
+#define COOLERMASTER_RADEON_6900_PID            0x015B
+
+#define CM_6K_PACKET_SIZE           65  //Includes extra first byte for non HID Report packets
+#define CM_6K_INTERRUPT_TIMEOUT     250
+#define CM_6K_DEVICE_NAME_SIZE      (sizeof(device_name) / sizeof(device_name[ 0 ]))
+#define CM_6K_SERIAL_SIZE           (sizeof(serial) / sizeof(serial[ 0 ]))
+#define HID_MAX_STR                 255
 
 enum
 {
-    CM_MR6000_MODE_DIRECT        = 0x00, //Direct Mode
-    CM_MR6000_MODE_BREATHE       = 0x01, //Breathe Mode
-    CM_MR6000_MODE_COLOR_CYCLE   = 0x02, //Color cycle
-    CM_MR6000_MODE_OFF           = 0xFF, //Off
+    CM_MR6000_MODE_DIRECT           = 0x00, //Direct Mode
+    CM_MR6000_MODE_BREATHE          = 0x01, //Breathe Mode
+    CM_MR6000_MODE_COLOR_CYCLE      = 0x02, //Color cycle
+
+    CM_MR6000_MODE_RAINBOW          = 0x07, //Rainbow
+    CM_MR6000_MODE_BOUNCE           = 0x08, //Bounce
+    CM_MR6000_MODE_CHASE            = 0x09, //Chase
+    CM_MR6000_MODE_SWIRL            = 0x0A, //Swirl
+
+    CM_MR6000_MODE_OFF              = 0xFF, //Off
 };
 
 enum
@@ -34,6 +44,10 @@ enum
     MR6000_CYCLE_SPEED_FAST                 = 0x6E, /* Fast speed                   */
     MR6000_CYCLE_SPEED_FASTEST              = 0x68, /* Fastest speed                */
 
+    MR6000_RAINBOW_SPEED_SLOWEST            = 0x78, /* Slowest speed                */
+    MR6000_RAINBOW_SPEED_NORMAL             = 0x6B, /* Normal speed                */
+    MR6000_RAINBOW_SPEED_FASTEST            = 0x60, /* Fastest speed                */
+
     MR6000_BREATHE_SPEED_SLOWEST            = 0x3C, /* Slowest speed                */
     MR6000_BREATHE_SPEED_SLOW               = 0x37, /* Slow speed                   */
     MR6000_BREATHE_SPEED_NORMAL             = 0x31, /* Normal speed                 */
@@ -44,39 +58,39 @@ enum
 class CMR6000Controller
 {
 public:
-    CMR6000Controller(hid_device* dev_handle, char *_path);
+    CMR6000Controller(hid_device* dev_handle, char *_path, uint16_t _pid);
     ~CMR6000Controller();
 
-    std::string   GetDeviceName();
-    std::string   GetSerial();
-    std::string   GetLocation();
+    std::string     GetDeviceName();
+    std::string     GetSerial();
+    std::string     GetLocation();
 
-    unsigned char GetMode();
-    unsigned char GetLedRed();
-    unsigned char GetLedGreen();
-    unsigned char GetLedBlue();
-    unsigned char GetLedSpeed();
-    unsigned char GetBrightness();
-    bool          GetRandomColours();
-    void          SetMode(unsigned char mode, unsigned char speed, unsigned char red, unsigned char green, unsigned char blue, unsigned char random, unsigned char brightness);
+    unsigned char   GetMode();
+    unsigned char   GetLedSpeed();
+    unsigned char   GetBrightness();
+    bool            GetRandomColours();
+    uint16_t        GetPID();
+
+    void            SetMode(unsigned char mode, unsigned char speed, RGBColor color1, RGBColor color2, unsigned char random, unsigned char brightness);
 
 private:
-    std::string             device_name;
-    std::string             serial;
-    std::string             location;
-    hid_device*             dev;
+    std::string     device_name;
+    std::string     serial;
+    std::string     location;
+    hid_device*     dev;
+    uint16_t        pid;
 
-    unsigned char           current_mode;
-    unsigned char           current_speed;
-    unsigned char           current_random;
+    unsigned char   current_mode;
+    unsigned char   current_speed;
+    unsigned char   current_random;
 
-    unsigned char           current_red;
-    unsigned char           current_green;
-    unsigned char           current_blue;
-    unsigned char           current_brightness;
+    unsigned char   current_brightness;
+    RGBColor        primary;
+    RGBColor        secondary;
 
-    void SendUpdate();
-    void SendEnableCommand();
-    void SendApplyCommand();
-    void SendColourConfig();
+    void            SendUpdate();
+    void            SendEnableCommand();
+    void            SendApplyCommand();
+    void            SendColourConfig();
+    void            SendSecondColour();
 };

Controllers/CoolerMasterController/CMSmallARGBController.cpp

@@ -12,6 +12,11 @@
 #include "CMSmallARGBController.h"
 #include <cstring>
 
+cm_small_argb_headers cm_small_argb_header_data[1] =
+{
+    { "CM Small ARGB",  0x01, true,  12 }
+};
+
 CMSmallARGBController::CMSmallARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx)
 {
     const int szTemp = 256;
@@ -215,7 +220,7 @@ void CMSmallARGBController::SendUpdate()
 
     buffer[CM_SMALL_ARGB_COMMAND_BYTE]                  = 0x0b;
     buffer[CM_SMALL_ARGB_FUNCTION_BYTE]                 = (false) ? 0x01 : 0x02; //This controls custom mode TODO
-    buffer[CM_SMALL_ARGB_ZONE_BYTE]                     = small_argb_header_data[zone_index].header;
+    buffer[CM_SMALL_ARGB_ZONE_BYTE]                     = cm_small_argb_header_data[zone_index].header;
     buffer[CM_SMALL_ARGB_MODE_BYTE]                     = current_mode;
     buffer[CM_SMALL_ARGB_SPEED_BYTE]                    = current_speed;
     buffer[CM_SMALL_ARGB_COLOUR_INDEX_BYTE]             = (bool_random) ? 0x00 : 0x10; //This looks to still be the colour index and controls random colours

Controllers/CoolerMasterController/CMSmallARGBController.h

@@ -34,7 +34,7 @@ enum
     CM_SMALL_ARGB_BLUE_BYTE             = 11,
 };
 
-struct _argb_headers
+struct cm_small_argb_headers
 {
     const char*     name;
     unsigned char   header;
@@ -42,10 +42,7 @@ struct _argb_headers
     unsigned int    count;
 };
 
-static _argb_headers small_argb_header_data[1] =
-{
-    { "CM Small ARGB",  0x01, true,  12 }
-};
+extern cm_small_argb_headers cm_small_argb_header_data[1];
 
 enum
 {

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -1,41 +1,68 @@
+/*-----------------------------------------------------*\
+| OpenRGB includes                                      |
+\*-----------------------------------------------------*/
+#include <hidapi/hidapi.h>
 #include "Detector.h"
-#include "CMMM711Controller.h"
-#include "CMMP750Controller.h"
-#include "CMARGBcontroller.h"
-#include "CMSmallARGBController.h"
-#include "CMRGBController.h"
-#include "CMR6000Controller.h"
-#include "CMMKController.h"
+#include "LogManager.h"
 #include "RGBController.h"
+
+/*-----------------------------------------------------*\
+| Coolermaster specific includes                        |
+\*-----------------------------------------------------*/
 #include "RGBController_CMMMController.h"
 #include "RGBController_CMMM711Controller.h"
 #include "RGBController_CMMP750Controller.h"
 #include "RGBController_CMARGBController.h"
 #include "RGBController_CMSmallARGBController.h"
+#include "RGBController_CMARGBGen2A1Controller.h"
 #include "RGBController_CMRGBController.h"
 #include "RGBController_CMR6000Controller.h"
 #include "RGBController_CMMKController.h"
-#include <hidapi/hidapi.h>
 
-#define COOLERMASTER_VID                        0x2516
+/*-----------------------------------------------------*\
+| Coolermaster USB vendor ID                            |
+\*-----------------------------------------------------*/
+#define COOLERMASTER_VID                            0x2516
 
-#define COOLERMASTER_MM530_PID                  0x0065
-#define COOLERMASTER_MM531_PID                  0x0097
-#define COOLERMASTER_MM711_PID                  0x0101
-#define COOLERMASTER_MM720_PID                  0x0141
-#define COOLERMASTER_MP750_XL_PID               0x0109
-#define COOLERMASTER_MP750_L_PID                0x0107
-#define COOLERMASTER_MP750_MEDIUM_PID           0x0105
-#define COOLERMASTER_ARGB_PID                   0x1011
-#define COOLERMASTER_SMALL_ARGB_PID             0x1000
-#define COOLERMASTER_RGB_PID                    0x004F
-#define COOLERMASTER_RADEON_6000_PID            0x014D
-#define COOLERMASTER_MASTERKEYS_PRO_L_PID       0x003B
-#define COOLERMASTER_MASTERKEYS_PRO_L_WHITE_PID 0x0047
-#define COOLERMASTER_MASTERKEYS_PRO_S_PID       0x003C
-#define COOLERMASTER_MASTERKEYS_MK750_PID       0x0067
-#define COOLERMASTER_MASTERKEYS_SK630_PID       0x0089
-#define COOLERMASTER_MASTERKEYS_SK650_PID       0x008D
+/*-----------------------------------------------------*\
+| Coolermaster Keyboards                                |
+\*-----------------------------------------------------*/
+#define COOLERMASTER_MASTERKEYS_PRO_L_PID           0x003B
+#define COOLERMASTER_MASTERKEYS_PRO_L_WHITE_PID     0x0047
+#define COOLERMASTER_MASTERKEYS_PRO_S_PID           0x003C
+#define COOLERMASTER_MASTERKEYS_MK750_PID           0x0067
+#define COOLERMASTER_MASTERKEYS_SK630_PID           0x0089
+#define COOLERMASTER_MASTERKEYS_SK650_PID           0x008D
+
+/*-----------------------------------------------------*\
+| Coolermaster GPUs                                     |
+|   PIDs defined in `CMR6000Controller.h`               |
+\*-----------------------------------------------------*/
+
+/*-----------------------------------------------------*\
+| Coolermaster LEDstrip controllers                     |
+\*-----------------------------------------------------*/
+#define COOLERMASTER_ARGB_PID                       0x1011
+#define COOLERMASTER_ARGB_GEN2_A1_PID               0x0173
+#define COOLERMASTER_ARGB_GEN2_A1_V2_PID            0x01C9
+#define COOLERMASTER_SMALL_ARGB_PID                 0x1000
+#define COOLERMASTER_RGB_PID                        0x004F
+
+/*-----------------------------------------------------*\
+| Coolermaster Mice                                     |
+\*-----------------------------------------------------*/
+#define COOLERMASTER_MM530_PID                      0x0065
+#define COOLERMASTER_MM531_PID                      0x0097
+#define COOLERMASTER_MM711_PID                      0x0101
+#define COOLERMASTER_MM720_PID                      0x0141
+#define COOLERMASTER_MM730_PID                      0x0165
+
+/*-----------------------------------------------------*\
+| Coolermaster Mousemats                                |
+\*-----------------------------------------------------*/
+#define COOLERMASTER_MP750_XL_PID                   0x0109
+#define COOLERMASTER_MP750_L_PID                    0x0107
+#define COOLERMASTER_MP750_MEDIUM_PID               0x0105
 
 /******************************************************************************************\
 *                                                                                          *
@@ -67,13 +94,26 @@ void DetectCoolerMasterARGB(hid_device_info* info, const std::string&)
     }
 }
 
+void DetectCoolerMasterARGBGen2A1(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        CMARGBGen2A1controller*               controller     = new CMARGBGen2A1controller(dev, *info);
+        RGBController_CMARGBGen2A1Controller* rgb_controller = new RGBController_CMARGBGen2A1Controller(controller);
+        rgb_controller->name                                 = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 void DetectCoolerMasterGPU(hid_device_info* info, const std::string&)
 {
     hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
-        CMR6000Controller*               controller     = new CMR6000Controller(dev, info->path);
+        CMR6000Controller*               controller     = new CMR6000Controller(dev, info->path, info->product_id);
         RGBController_CMR6000Controller* rgb_controller = new RGBController_CMR6000Controller(controller);
         // Constructor sets the name
         ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -99,21 +139,32 @@ void DetectCoolerMasterMouse(hid_device_info* info, const std::string& name)
 
     if(dev)
     {
-        if(info->product_id == COOLERMASTER_MM530_PID || info->product_id == COOLERMASTER_MM531_PID)
+        switch(info->product_id)
         {
-            CMMMController* controller                      = new CMMMController(dev, info->path, info->product_id);
-            RGBController_CMMMController* rgb_controller    = new RGBController_CMMMController(controller);
-            rgb_controller->name                            = name;
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
-        }
-        else if(info->product_id == COOLERMASTER_MM711_PID)
-        {
-            CMMM711Controller*               controller     = new CMMM711Controller(dev, info->path);
-            RGBController_CMMM711Controller* rgb_controller = new RGBController_CMMM711Controller(controller);
-            // Constructor sets the name
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
-        }
+            case COOLERMASTER_MM530_PID:
+            case COOLERMASTER_MM531_PID:
+            case COOLERMASTER_MM720_PID:
+            case COOLERMASTER_MM730_PID:
+                {
+                    CMMMController*               controller        = new CMMMController(dev, info->path, info->product_id);
+                    RGBController_CMMMController* rgb_controller    = new RGBController_CMMMController(controller);
+                    rgb_controller->name                            = name;
+                    ResourceManager::get()->RegisterRGBController(rgb_controller);
+                }
+                break;
 
+            case COOLERMASTER_MM711_PID:
+                {
+                    CMMM711Controller*               controller     = new CMMM711Controller(dev, info->path);
+                    RGBController_CMMM711Controller* rgb_controller = new RGBController_CMMM711Controller(controller);
+                    // Constructor sets the name
+                    ResourceManager::get()->RegisterRGBController(rgb_controller);
+                }
+                break;
+
+            default:
+                LOG_DEBUG("[%s] Controller not created as the product ID %04X is missing from detector switch", name.c_str(), info->product_id);
+         }
     }
 }
 
@@ -156,20 +207,44 @@ void DetectCoolerMasterSmallARGB(hid_device_info* info, const std::string&)
     }
 }
 
+/*-----------------------------------------------------*\
+| Coolermaster Keyboards                                |
+\*-----------------------------------------------------*/
+REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L",         DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_L_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L White",   DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_L_WHITE_PID,    1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro S",         DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_S_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master MK750",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_MK750_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master SK630",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_SK630_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master SK650",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_SK650_PID,          1,      0xFF00, 1);
+
+/*-----------------------------------------------------*\
+| Coolermaster LEDstrip controllers                     |
+\*-----------------------------------------------------*/
+REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB",                     DetectCoolerMasterARGB,         COOLERMASTER_VID,   COOLERMASTER_ARGB_PID,                      0,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB Gen 2 A1",            DetectCoolerMasterARGBGen2A1,   COOLERMASTER_VID,   COOLERMASTER_ARGB_GEN2_A1_PID,              1,      0xFF01, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB Gen 2 A1 V2",         DetectCoolerMasterARGBGen2A1,   COOLERMASTER_VID,   COOLERMASTER_ARGB_GEN2_A1_V2_PID,           1,      0xFF01, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master RGB",                      DetectCoolerMasterRGB,          COOLERMASTER_VID,   COOLERMASTER_RGB_PID,                       1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master Small ARGB",               DetectCoolerMasterSmallARGB,    COOLERMASTER_VID,   COOLERMASTER_SMALL_ARGB_PID,                0,      0xFF00, 1);
+
+/*-----------------------------------------------------*\
+| Coolermaster Mice                                     |
+\*-----------------------------------------------------*/
 REGISTER_HID_DETECTOR_IPU("Cooler Master MM530",                    DetectCoolerMasterMouse,        COOLERMASTER_VID,   COOLERMASTER_MM530_PID,                     1,      0xFF00, 1);
 //REGISTER_HID_DETECTOR_IPU("Cooler Master MM531",                  DetectCoolerMasterMouse,        COOLERMASTER_VID,   COOLERMASTER_MM531_PID,                     1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MM711",                    DetectCoolerMasterMouse,        COOLERMASTER_VID,   COOLERMASTER_MM711_PID,                     1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MM720",                    DetectCoolerMasterMouse,        COOLERMASTER_VID,   COOLERMASTER_MM720_PID,                     1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master MM730",                    DetectCoolerMasterMouse,        COOLERMASTER_VID,   COOLERMASTER_MM730_PID,                     1,      0xFF00, 1);
+
+/*-----------------------------------------------------*\
+| Coolermaster Mousemats                                |
+\*-----------------------------------------------------*/
 REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 XL",                 DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_XL_PID,                          0xFF00, 1);
 REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 Large",              DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_L_PID,                           0xFF00, 1);
 REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 Medium",             DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_MEDIUM_PID,                      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L",         DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_L_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L White",   DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_L_WHITE_PID,    1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro S",         DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_S_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master MK570",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_MK750_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master SK630",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_SK630_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master SK650",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_SK650_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB",                     DetectCoolerMasterARGB,         COOLERMASTER_VID,   COOLERMASTER_ARGB_PID,                      0,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master Small ARGB",               DetectCoolerMasterSmallARGB,    COOLERMASTER_VID,   COOLERMASTER_SMALL_ARGB_PID,                0,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master RGB",                      DetectCoolerMasterRGB,          COOLERMASTER_VID,   COOLERMASTER_RGB_PID,                       1,      0xFF00, 1);
+
+/*-----------------------------------------------------*\
+| Coolermaster GPUs                                     |
+|   PIDs defined in `CMR6000Controller.h`               |
+\*-----------------------------------------------------*/
 REGISTER_HID_DETECTOR_I  ("Cooler Master Radeon 6000 GPU",          DetectCoolerMasterGPU,          COOLERMASTER_VID,   COOLERMASTER_RADEON_6000_PID,               1                );
+REGISTER_HID_DETECTOR_I  ("Cooler Master Radeon 6900 GPU",          DetectCoolerMasterGPU,          COOLERMASTER_VID,   COOLERMASTER_RADEON_6900_PID,               1                );

Controllers/CoolerMasterController/RGBController_CMARGBGen2A1Controller.cpp

@@ -0,0 +1,305 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMARGBGen2A1Controller.cpp                           |
+|                                                                     |
+|  Driver for Coolermaster ARGB Gen 2 A1 USB Controller               |
+|                                                                     |
+|  morg (Morgan Guimard) 6/26/2022                                    |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "RGBController_CMARGBGen2A1Controller.h"
+
+#include <thread>
+#include <chrono>
+
+/**------------------------------------------------------------------*\
+    @name Coolermaster ARGB A1
+    @category LEDStrip
+    @type USB
+    @save :white_check_mark:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectCoolerMasterARGBGen2A1
+    @comment This device does not have Gen 2 support in OpenRGB yet.
+
+    Gen2 has auto-resize feature and parallel to serial magical stuff.<
+\*-------------------------------------------------------------------*/
+
+RGBController_CMARGBGen2A1Controller::RGBController_CMARGBGen2A1Controller(CMARGBGen2A1controller* controller_ptr)
+{
+    controller                  = controller_ptr;
+    name                        = "CoolerMaster LED Controller A1";
+    vendor                      = "CoolerMaster";
+    type                        = DEVICE_TYPE_LEDSTRIP;
+    description                 = name;
+    location                    = controller->GetDeviceLocation();
+    serial                      = controller->GetSerialString();
+    version                     = "";
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = CM_ARGB_GEN2_A1_DIRECT_MODE;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Spectrum;
+    Spectrum.name               = "Spectrum";
+    Spectrum.value              = CM_ARGB_GEN2_A1_SPECTRUM_MODE;
+    Spectrum.flags              = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    Spectrum.color_mode         = MODE_COLORS_NONE;
+    Spectrum.brightness         = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    Spectrum.brightness_min     = CM_ARGB_GEN2_A1_BRIGHTNESS_MIN;
+    Spectrum.brightness_max     = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    Spectrum.speed              = CM_ARGB_GEN2_A1_SPEED_MAX/2;
+    Spectrum.speed_min          = CM_ARGB_GEN2_A1_SPEED_MIN;
+    Spectrum.speed_max          = CM_ARGB_GEN2_A1_SPEED_MAX;
+    modes.push_back(Spectrum);
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = CM_ARGB_GEN2_A1_STATIC_MODE;
+    Static.flags                = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Static.brightness           = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    Static.brightness_min       = CM_ARGB_GEN2_A1_BRIGHTNESS_MIN;
+    Static.brightness_max       = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Reload;
+    Reload.name                 = "Reload";
+    Reload.value                = CM_ARGB_GEN2_A1_RELOAD_MODE;
+    Reload.flags                = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Reload.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Reload.brightness           = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    Reload.brightness_min       = CM_ARGB_GEN2_A1_BRIGHTNESS_MIN;
+    Reload.brightness_max       = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    Reload.speed                = CM_ARGB_GEN2_A1_SPEED_MAX/2;
+    Reload.speed_min            = CM_ARGB_GEN2_A1_SPEED_MIN;
+    Reload.speed_max            = CM_ARGB_GEN2_A1_SPEED_MAX;
+    Reload.colors.resize(1);
+    modes.push_back(Reload);
+
+    mode Recoil;
+    Recoil.name                 = "Recoil";
+    Recoil.value                = CM_ARGB_GEN2_A1_RECOIL_MODE;
+    Recoil.flags                = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Recoil.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Recoil.brightness           = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    Recoil.brightness_min       = CM_ARGB_GEN2_A1_BRIGHTNESS_MIN;
+    Recoil.brightness_max       = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    Recoil.speed                = CM_ARGB_GEN2_A1_SPEED_MAX/2;
+    Recoil.speed_min            = CM_ARGB_GEN2_A1_SPEED_MIN;
+    Recoil.speed_max            = CM_ARGB_GEN2_A1_SPEED_MAX;
+    Recoil.colors.resize(1);
+    modes.push_back(Recoil);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = CM_ARGB_GEN2_A1_BREATHING_MODE;
+    Breathing.flags             = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.brightness        = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    Breathing.brightness_min    = CM_ARGB_GEN2_A1_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    Breathing.speed             = CM_ARGB_GEN2_A1_SPEED_MAX/2;
+    Breathing.speed_min         = CM_ARGB_GEN2_A1_SPEED_MIN;
+    Breathing.speed_max         = CM_ARGB_GEN2_A1_SPEED_MAX;
+    Breathing.colors.resize(1);
+    modes.push_back(Breathing);
+
+
+    mode Refill;
+    Refill.name                 = "Refill";
+    Refill.value                = CM_ARGB_GEN2_A1_REFILL_MODE;
+    Refill.flags                = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Refill.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Refill.brightness           = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    Refill.brightness_min       = CM_ARGB_GEN2_A1_BRIGHTNESS_MIN;
+    Refill.brightness_max       = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    Refill.speed                = CM_ARGB_GEN2_A1_SPEED_MAX/2;
+    Refill.speed_min            = CM_ARGB_GEN2_A1_SPEED_MIN;
+    Refill.speed_max            = CM_ARGB_GEN2_A1_SPEED_MAX;
+    Refill.colors.resize(1);
+    modes.push_back(Refill);
+
+    mode Demo;
+    Demo.name                   = "Demo";
+    Demo.value                  = CM_ARGB_GEN2_A1_DEMO_MODE;
+    Demo.flags                  = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Demo.color_mode             = MODE_COLORS_NONE;
+    Demo.brightness             = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    Demo.brightness_min         = CM_ARGB_GEN2_A1_BRIGHTNESS_MIN;
+    Demo.brightness_max         = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    modes.push_back(Demo);
+
+    mode FillFlow;
+    FillFlow.name               = "Fill Flow";
+    FillFlow.value              = CM_ARGB_GEN2_A1_FILL_FLOW_MODE;
+    FillFlow.flags              = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;;
+    FillFlow.color_mode         = MODE_COLORS_NONE;
+    FillFlow.brightness         = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    FillFlow.brightness_min     = CM_ARGB_GEN2_A1_BRIGHTNESS_MIN;
+    FillFlow.brightness_max     = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    FillFlow.speed              = CM_ARGB_GEN2_A1_SPEED_MAX/2;
+    FillFlow.speed_min          = CM_ARGB_GEN2_A1_SPEED_MIN;
+    FillFlow.speed_max          = CM_ARGB_GEN2_A1_SPEED_MAX;
+    modes.push_back(FillFlow);
+
+    mode Rainbow;
+    Rainbow.name               = "Rainbow";
+    Rainbow.value              = CM_ARGB_GEN2_A1_RAINBOW_MODE;
+    Rainbow.flags              = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;;
+    Rainbow.color_mode         = MODE_COLORS_NONE;
+    Rainbow.brightness         = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    Rainbow.brightness_min     = CM_ARGB_GEN2_A1_BRIGHTNESS_MIN;
+    Rainbow.brightness_max     = CM_ARGB_GEN2_A1_BRIGHTNESS_MAX;
+    Rainbow.speed              = CM_ARGB_GEN2_A1_SPEED_MAX/2;
+    Rainbow.speed_min          = CM_ARGB_GEN2_A1_SPEED_MIN;
+    Rainbow.speed_max          = CM_ARGB_GEN2_A1_SPEED_MAX;
+    modes.push_back(Rainbow);
+
+    mode Custom;
+    Custom.name                 = "Custom";
+    Custom.value                = CM_ARGB_GEN2_A1_CUSTOM_MODE;
+    Custom.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Custom.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Custom);
+
+    mode Off;
+    Off.name                    = "Off";
+    Off.value                   = CM_ARGB_GEN2_A1_OFF_MODE;
+    Off.flags                   = MODE_FLAG_MANUAL_SAVE;
+    Off.color_mode              = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    SetupZones();
+}
+
+RGBController_CMARGBGen2A1Controller::~RGBController_CMARGBGen2A1Controller()
+{
+    delete controller;
+}
+
+void RGBController_CMARGBGen2A1Controller::SetupZones()
+{
+    unsigned int total_leds = 0;
+
+    for(unsigned int channel = 0; channel < CM_ARGB_GEN2_A1_CHANNEL_COUNT; channel++)
+    {
+        zone new_zone;
+
+        new_zone.name       = "Channel " + std::to_string(channel + 1);
+        new_zone.type       = ZONE_TYPE_LINEAR;
+        new_zone.leds_min   = 0;
+        new_zone.leds_max   = CM_ARGB_GEN2_A1_CHANNEL_MAX_SIZE;
+        new_zone.leds_count = 0;
+        new_zone.matrix_map = nullptr;
+
+        zones.push_back(new_zone);
+
+        total_leds += new_zone.leds_count;
+    }
+
+    leds.resize(total_leds);
+
+    for(unsigned int i = 0; i < total_leds; i++)
+    {
+        leds[i].name = "LED " + std::to_string(i + 1);
+    }
+
+    SetupColors();
+}
+
+void RGBController_CMARGBGen2A1Controller::ResizeZone(int zone, int new_size)
+{
+    zones[zone].leds_count = new_size;
+
+    // todo: refactor with above code
+    unsigned int total_leds = 0;
+
+    for(unsigned int channel = 0; channel < CM_ARGB_GEN2_A1_CHANNEL_COUNT; channel++)
+    {
+        total_leds += zones[channel].leds_count;
+    }
+
+    leds.resize(total_leds);
+
+    for(unsigned int i = 0; i < total_leds; i++)
+    {
+        leds[i].name = "LED " + std::to_string(i + 1);
+    }
+
+    controller->SetupZoneSize(zone, new_size);
+
+    SetupColors();
+}
+
+void RGBController_CMARGBGen2A1Controller::DeviceUpdateLEDs()
+{
+    for(unsigned int channel = 0; channel < CM_ARGB_GEN2_A1_CHANNEL_COUNT; channel ++)
+    {
+        UpdateZoneLEDs(channel);
+    }
+}
+
+void RGBController_CMARGBGen2A1Controller::UpdateZoneLEDs(int zone)
+{    
+    if(zones[zone].leds_count > 0)
+    {
+        unsigned int start = zones[zone].start_idx;
+        unsigned int end = start + zones[zone].leds_count;
+
+        std::vector<RGBColor> zone_colors(colors.begin() + start , colors.begin() + end);
+
+        if(modes[active_mode].value == CM_ARGB_GEN2_A1_DIRECT_MODE)
+        {
+            controller->SendDirectChannel(zone, zone_colors);
+        }
+        else
+        {
+            controller->SetCustomColors(zone, zone_colors);
+        }
+    }
+}
+
+void RGBController_CMARGBGen2A1Controller::UpdateSingleLED(int /*led*/)
+{    
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CMARGBGen2A1Controller::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_CMARGBGen2A1Controller::DeviceUpdateMode()
+{
+    const mode& active = modes[active_mode];
+
+    if(active.value == CM_ARGB_GEN2_A1_DIRECT_MODE)
+    {
+        controller->SetupDirectMode();
+    }
+    else
+    {
+        RGBColor color = active.color_mode == MODE_COLORS_MODE_SPECIFIC ?
+                    active.colors[0] : 0;
+
+        controller->SetMode
+                (
+                    active.value,
+                    active.speed,
+                    active.brightness,
+                    color,
+                    active.color_mode == MODE_COLORS_RANDOM
+                );
+    }
+}
+
+void RGBController_CMARGBGen2A1Controller::DeviceSaveMode()
+{
+    controller->SaveToFlash();
+}
+

Controllers/CoolerMasterController/RGBController_CMARGBGen2A1Controller.h

@@ -0,0 +1,32 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMARGBGen2A1Controller.h                             |
+|                                                                     |
+|  Driver for Coolermaster ARGB Controller                            |
+|                                                                     |
+|  morg (Morgan Guimard) 6/26/2022                                    |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "CMARGBGen2A1controller.h"
+#include <vector>
+
+class RGBController_CMARGBGen2A1Controller : public RGBController
+{
+public:
+    RGBController_CMARGBGen2A1Controller(CMARGBGen2A1controller* controller_ptr);
+    ~RGBController_CMARGBGen2A1Controller();
+
+    void SetupZones();
+    void ResizeZone(int zone, int new_size);
+    void DeviceUpdateLEDs();
+    void UpdateZoneLEDs(int zone);
+    void UpdateSingleLED(int led);
+    void SetCustomMode();
+    void DeviceUpdateMode();
+    void DeviceSaveMode();
+
+private:   
+    CMARGBGen2A1controller*   controller;
+};

Controllers/CoolerMasterController/RGBController_CMMM711Controller.cpp

@@ -25,7 +25,6 @@
 RGBController_CMMM711Controller::RGBController_CMMM711Controller(CMMM711Controller* controller_ptr)
 {
     controller                      = controller_ptr;
-    uint8_t speed                   = controller->GetLedSpeed();
 
     name                            = controller->GetDeviceName();
     vendor                          = "Cooler Master";