Changed "Set All Devices"

* Changed `Apply Colors` to contextual
* Changed `Set All Devices` to `Apply To All Devices`
* Added a tooltip to `Apply to All`
* Added Black and White quick colour swatches and left them "not flat" to
ensure visibility in Light and Dark mode.

Commit amended to fix display issues on Windows and to group buttons in layout by Adam Honse <[email protected]>

.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: CalcProgrammer1
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.gitlab-ci.yml

@@ -29,7 +29,7 @@ before_script:
 #-----------------------------------------------------------------------#
 # Linux (AppImage) 32-bit Build Target                                  #
 #-----------------------------------------------------------------------#
-build_linux_32:
+"Linux 32 AppImage":
   <<: *ccache_init
   image: i386/ubuntu:bionic
   stage: build
@@ -38,6 +38,7 @@ build_linux_32:
   - ./scripts/build-appimage.sh
   
   artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_32_${CI_COMMIT_SHORT_SHA}"
     paths:
     - OpenRGB-i386.AppImage
     - 60-openrgb.rules
@@ -47,7 +48,7 @@ build_linux_32:
 #-----------------------------------------------------------------------#
 # Linux (AppImage) 64-bit Build Target                                  #
 #-----------------------------------------------------------------------#
-build_linux_64:
+"Linux 64 AppImage":
   <<: *ccache_init
   image: ubuntu:bionic
   stage: build
@@ -56,6 +57,7 @@ build_linux_64:
   - ./scripts/build-appimage.sh
   
   artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_64_${CI_COMMIT_SHORT_SHA}"
     paths:
     - OpenRGB-x86_64.AppImage
     - 60-openrgb.rules
@@ -65,7 +67,7 @@ build_linux_64:
 #-----------------------------------------------------------------------#
 # Linux (.deb) 32-bit Build Target                                      #
 #-----------------------------------------------------------------------#
-build_linux_deb32:
+"Linux 32 deb":
   <<: *ccache_init
   image: i386/ubuntu:bionic
   stage: build
@@ -77,6 +79,7 @@ build_linux_deb32:
   - mv -v ../openrgb*.deb ./
 
   artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
     paths:
     - openrgb*.deb
     exclude:
@@ -86,7 +89,7 @@ build_linux_deb32:
 #-----------------------------------------------------------------------#
 # Linux (.deb) 64-bit Build Target                                      #
 #-----------------------------------------------------------------------#
-build_linux_deb64:
+"Linux 64 deb":
   <<: *ccache_init
   image: ubuntu:bionic
   stage: build
@@ -98,6 +101,7 @@ build_linux_deb64:
   - mv -v ../openrgb*.deb ./
 
   artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
     paths:
     - openrgb*.deb
     exclude:
@@ -107,7 +111,7 @@ build_linux_deb64:
 #-----------------------------------------------------------------------#
 # Windows (32-bit) Build Target                                         #
 #-----------------------------------------------------------------------#
-build_windows_32:
+"Windows 32":
   extends:
   - .shared_windows_runners
   stage: build
@@ -129,9 +133,9 @@ build_windows_32:
   - mkdir _qt
   - mkdir _qt_download
   - Push-Location _qt_download
-  - curl.exe -LJ -o qt-base.7z  'https://download.qt.io/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://download.qt.io/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://download.qt.io/official_releases/jom/jom.zip'
+  - 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'
   - _fold_final_
   
   - _fold_start_ 'extracting the downloaded qt binaries'
@@ -160,26 +164,23 @@ build_windows_32:
   - ..\_qt\5.15.0\msvc2019\bin\windeployqt --no-angle --no-translations --no-opengl-sw --no-system-d3d-compiler --no-compiler-runtime --no-webkit2 .\release\
   - _fold_final_
   
-  - _fold_start_ 'compressing the release folder so that we can upload it as artifact'
-  - mv release 'OpenRGB Windows 32-bit'
-  - ${datetime} = Get-Date ([datetime]::UtcNow) -Format "yyyy-MM-ddTHH-mm-ss"
-  - ${revision} = ((git rev-parse --short HEAD) | Out-String).Trim()
-  - ${rversion} = (((Get-Content '..\OpenRGB.pro' | Select-String -Pattern "VERSION     =") | Out-String).Trim().Split("="))[1].Trim()
-  - 7z a -mx9 -r -y "OpenRGB_${rversion}_32_${revision}_nightly_${datetime}.7z" 'OpenRGB Windows 32-bit'
+  - _fold_start_ 'Moving results for upload'
+  - mv release ../'OpenRGB Windows 32-bit'
   - _fold_final_
 #  cache:
 #    key: same-key
 #    paths:
 #    - C:\vcpkg\installed\
   artifacts:
+    name: "${CI_PROJECT_NAME}_Windows_32_${CI_COMMIT_SHORT_SHA}"
     paths:
-    - _build/*.7z
+    - 'OpenRGB Windows 32-bit'
     expire_in: 30 days
 
 #-----------------------------------------------------------------------#
 # Windows (64-bit) Build Target                                         #
 #-----------------------------------------------------------------------#
-build_windows_64:
+"Windows 64":
   extends:
   - .shared_windows_runners
   stage: build
@@ -201,9 +202,9 @@ build_windows_64:
   - mkdir _qt
   - mkdir _qt_download
   - Push-Location _qt_download
-  - curl.exe -LJ -o qt-base.7z  'https://download.qt.io/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://download.qt.io/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://download.qt.io/official_releases/jom/jom.zip'
+  - 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'
   - _fold_final_
   
   - _fold_start_ 'extracting the downloaded qt binaries'
@@ -232,18 +233,62 @@ build_windows_64:
   - ..\_qt\5.15.0\msvc2019_64\bin\windeployqt --no-angle --no-translations --no-opengl-sw --no-system-d3d-compiler --no-compiler-runtime --no-webkit2 .\release\
   - _fold_final_
   
-  - _fold_start_ 'compressing the release folder so that we can upload it as artifact'
-  - mv release 'OpenRGB Windows 64-bit'
-  - ${datetime} = Get-Date ([datetime]::UtcNow) -Format "yyyy-MM-ddTHH-mm-ss"
-  - ${revision} = ((git rev-parse --short HEAD) | Out-String).Trim()
-  - ${rversion} = (((Get-Content '..\OpenRGB.pro' | Select-String -Pattern "VERSION     =") | Out-String).Trim().Split("="))[1].Trim()
-  - 7z a -mx9 -r -y "OpenRGB_${rversion}_64_${revision}_nightly_${datetime}.7z" 'OpenRGB Windows 64-bit'
+  - _fold_start_ 'Moving results for upload'
+  - mv release ../'OpenRGB Windows 64-bit'
   - _fold_final_
 #  cache:
 #    key: same-key
 #    paths:
 #    - C:\vcpkg\installed\
   artifacts:
+    name: "${CI_PROJECT_NAME}_Windows_64_${CI_COMMIT_SHORT_SHA}"
     paths:
-    - _build/*.7z
+    - 'OpenRGB Windows 64-bit'
     expire_in: 30 days
+
+#-----------------------------------------------------------------------#
+# MacOS Build Target                                                    #
+#-----------------------------------------------------------------------#
+"MacOS ARM64":
+  tags:
+  - macos
+  stage: build
+  script:
+  - eval $(/opt/homebrew/bin/brew shellenv)
+  - qmake OpenRGB.pro
+  - make -j16
+  - macdeployqt OpenRGB.app -codesign=OpenRGB
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_MacOS_ARM64_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - OpenRGB.app
+    expire_in: 30 days
+
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: '$BUILD_MACOS =~ /.+/'
+    when: on_success
+
+"MacOS Intel":
+  tags:
+  - macos
+  stage: build
+  script:
+  - eval $(/usr/local/bin/brew shellenv)
+  - arch -x86_64 /usr/local/bin/qmake OpenRGB.pro
+  - arch -x86_64 make -j16
+  - arch -x86_64 macdeployqt OpenRGB.app -codesign=OpenRGB
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_MacOS_Intel_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - OpenRGB.app
+    expire_in: 30 days
+
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: '$BUILD_MACOS =~ /.+/'
+    when: on_success

.gitlab/issue_templates/Bug Report.md

@@ -1,14 +1,19 @@
 <!-- 
-Found a bug?  Something isn't working as expected?  To help us keep track of the requests please start the title with [Bug Report]
+Found a bug?  Something isn't working as expected?
+To help us keep track of the requests please start the title with [Bug Report]
 -->
 
 ### Description of Bug
 <!--
-Please describe the bug.  Explain steps taken to reproduce the bug and what you expect the correct behavior to be.
+Please describe the bug.
+Explain any steps taken to reproduce the bug
+and what you expect the correct behavior to be.
 -->
 
 
 ### Hardware Configuration
 <!--
-Please list the RGB hardware that you are using with OpenRGB.  If your bug does not relate to any one particular device or device type, or if the bug is in a part of the code not directly interacting with hardware, this is optional.
--->
+Please list the RGB hardware that you are using with OpenRGB.
+If your bug does not relate to any one particular device or device type,
+or if the bug is in a part of the code not directly interacting with hardware, this is optional.
+-->

.gitlab/issue_templates/Feature Request.md

@@ -5,5 +5,7 @@ To help us keep track of the requests please start the title with [Feature Reque
 
 ### Feature Request
 <!--
-Please explain the new feature you would like to see added in detail.  Explain how you think it should work and provide any mock-ups, code snippets, etc. that you think will help explain the feature.
+Please explain the new feature you would like to see added in detail.
+Explain how you think it should work and provide any mock-ups,
+code snippets, etc. that you think will help explain the feature.
 -->

.gitlab/issue_templates/New Device.md

@@ -1,7 +1,7 @@
 <!-- 
 When naming the support request please title the request as 
 `[New Device] <Name of new device>` 
-Please open one issue per device you would lke to add
+Please open one issue per device you would like to add
 -->
 
 ### Name of device:
@@ -12,27 +12,43 @@ Please put the name of the product, including manufacturer, beneath this line
 
 ### Link to manufacturer's product page:
 <!--
-Please link us to the manufacturer's product page beneath this line
+Please add a link to the manufacturer's product page beneath this line
 -->
 
 
 ### Please select what type of device/interface the device uses:
-<!--
-Place an x between the brackets to check the box
--->
-- [ ] Motherboard (SMBus)
-- [ ] Motherboard (USB)
-- [ ] RAM (SMBus)
-- [ ] GPU (I2C)
-- [ ] External USB (Peripheral, lighting controller, etc)
-- [ ] Internal USB (lighting controller, cooler, fan hub, etc)
-- [ ] I don't know (we can help you determine this)
+<!-- Please select from one of the following
+ This determines how the device connects to the PC -->
+
+~"DeviceType::IDK" <!-- I Don't know -->
+~"DeviceType::USB" <!-- The device connects to an internal header or external usb port -->
+~"DeviceType::GPU::AMD" <!-- The device is an AMD GPU -->
+~"DeviceType::GPU::NVidia" <!-- The device is a NVidia GPU -->
+~"DeviceType::SMBus" <!-- The device is connected to the SMBus eg. RAM -->
+~"DeviceType::WMI"  <!-- The device is controlled thru Windows Management Instrumentation -->
+
+<!-- Please delete any lines that are not relevant -->
 
 ### ID information:
 <!--
 For PCI (GPU) devices we will need the Vendor ID, Device ID, Sub-Vendor ID and Sub-Device IDs
-In Windows this can be found under the device manager and on Linux this can be found with lspci -vv
+To get the Device ID formation for a GPU on Windows run the following command in Powershell:
+
+wmic path Win32_VideoController get name,PNPDeviceID
+
+Linux this can be found using the terminal:
+
+lspci -d 1002: -nnvm | head -6 | tail -n 4 && lspci -d 10DE: -nnvm | head -6 | tail -n 4
+-->
+
+<!--
 For USB devices we will need the USB VID and PID
+Windows Powershell:
+
+gwmi Win32_USBControllerDevice |%{[wmi]($_.Dependent)} | Sort Manufacturer,Description,DeviceID | Ft -GroupBy Manufacturer Description,Service,DeviceID
+
+Linux Terminal:
+lsusb
 -->
 
 
@@ -43,6 +59,28 @@ Screenshots of the official control software should show lists of supported mode
 
 
 ### Please attach device captures here:
-<!--
-For information on how to capture device packets please see https://gitlab.com/Dr_No/OpenRGB/-/wikis/OpenRGB-doesn%27t-have-my-device
+<!-- If you have code examples from other projects please link them here or alternatively
+for information on how to capture device packets please refer to the wiki article
+https://gitlab.com/Dr_No/OpenRGB/-/wikis/OpenRGB-doesn%27t-have-my-device
 -->
+
+
+
+
+
+
+
+
+
+<!-- For admin purposes: Please leave this section as is -->
+/label ~"Issue Type - New Device"
+/label ~"NewDevice::Step0 - Unconfirmed"
+
+# Checklist for Step2
+- [ ] Name of device
+- [ ] A link to the vendors product page has been included
+- [ ] The transport bus has been identified and the appropriate label added to the issue.
+- [ ] The device ID's have been included for [USB](https://gitlab.com/Dr_No/OpenRGB/-/wikis/USB-Vendor-Identification-and-Product-Identification) or PCI
+- [ ] Screenshots of the OEM Application are included
+- [ ] There is either, appropriate code examples linked or suitable device captures attached
+<!-- For admin purposes: Please leave this section as is -->

60-openrgb.rules

@@ -9,6 +9,11 @@
 #---------------------------------------------------------------#
 KERNEL=="i2c-[0-99]*", TAG+="uaccess"
 
+#---------------------------------------------------------------#
+#  Super I/O Access                                             #
+#---------------------------------------------------------------#
+KERNEL=="port", TAG+="uaccess"
+
 #---------------------------------------------------------------#
 #  User hidraw Access                                           #
 #---------------------------------------------------------------#
@@ -24,6 +29,15 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0051", TAG+="uacces
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1044", ATTR{idProduct}=="7a42", TAG+="uaccess"
 
+#---------------------------------------------------------------#
+#  ASRock Devices                                               #
+#                                                               #
+#   ASRock Polychrome USB                                       #
+#   ASRock Deskmini Addressable LED Strip                       #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="26CE", ATTR{idProduct}=="01A2", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="26CE", ATTR{idProduct}=="01A6", TAG+="uaccess"
+
 #---------------------------------------------------------------#
 #  ASUS Aura Core Devices                                       #
 #---------------------------------------------------------------#
@@ -40,6 +54,17 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1889", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a3", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18f3", TAG+="uaccess"
 
+#---------------------------------------------------------------#
+#  ASUS TUF Laptops (faustus)                                   #
+#---------------------------------------------------------------#
+ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_blue"
+ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_flags"
+ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_green"
+ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_mode"
+ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_red"
+ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_set"
+ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_speed"
+
 #---------------------------------------------------------------#
 #  Cooler Master Peripheral Devices                             #
 #                                                               #
@@ -147,6 +172,11 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16be", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16d3", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="1705", TAG+="uaccess"
 
+#---------------------------------------------------------------#
+#  Lian Li Uni Hub                                              #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0cf2", ATTR{idProduct}=="7750", TAG+="uaccess"
+
 #---------------------------------------------------------------#
 #  Logitech Peripheral Devices                                  #
 #                                                               #
@@ -189,6 +219,12 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c088", TAG+="uacces
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c53a", TAG+="uaccess"
 
+#---------------------------------------------------------------#
+#  Metadot Das Keyboard 4Q + 5Q                                 #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="24f0", ATTR{idProduct}=="2037", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="24f0", ATTR{idProduct}=="202b", TAG+="uaccess"
+
 #---------------------------------------------------------------#
 #  MSI Mysticlight                                              #
 #---------------------------------------------------------------#
@@ -332,3 +368,11 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1229", TAG+="uacces
 #  Thermaltake Poseidon Z RGB Keyboard                          #
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="3006", TAG+="uaccess"
+
+#---------------------------------------------------------------#
+#  Thermaltake Riing Controllers                                #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1FA[5-9]", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1FA[A-F]", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1FB[0-5]", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="226[0-3]", TAG+="uaccess"

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -36,7 +36,7 @@ AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const
 
 AMDWraithPrismController::~AMDWraithPrismController()
 {
-
+    hid_close(dev);
 }
 
 std::string AMDWraithPrismController::GetLocationString()

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

@@ -97,7 +97,7 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
 
 RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
 {
-
+    delete wraith;
 }
 
 void RGBController_AMDWraithPrism::SetupZones()

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusControllerDetect.cpp

@@ -44,7 +44,7 @@ bool TestForPolychromeSMBusController(i2c_smbus_interface* bus, unsigned char ad
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
+void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
 {
     PolychromeController* new_polychrome;
     RGBController_Polychrome* new_controller;
@@ -61,7 +61,7 @@ void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses,
                 if(new_polychrome->GetASRockType() != ASROCK_TYPE_UNKNOWN)
                 {
                     new_controller = new RGBController_Polychrome(new_polychrome);
-                    rgb_controllers.push_back(new_controller);
+                    ResourceManager::get()->RegisterRGBController(new_controller);
                 }
                 else
                 {

Controllers/ASRockPolychromeSMBusController/RGBController_ASRockPolychromeSMBus.cpp

@@ -49,74 +49,74 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
                 description = "ASRock ASR LED Device";
 
                 mode Off;
-                Off.name       = "Off";
-                Off.value      = ASRLED_MODE_OFF;
-                Off.flags      = 0;
-                Off.color_mode = MODE_COLORS_NONE;
+                Off.name                    = "Off";
+                Off.value                   = ASRLED_MODE_OFF;
+                Off.flags                   = 0;
+                Off.color_mode              = MODE_COLORS_NONE;
                 modes.push_back(Off);
 
                 mode Static;
-                Static.name       = "Static";
-                Static.value      = ASRLED_MODE_STATIC;
-                Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-                Static.color_mode = MODE_COLORS_PER_LED;
+                Static.name                 = "Static";
+                Static.value                = ASRLED_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      = ASRLED_MODE_BREATHING;
-                Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Breathing.speed_min  = ASRLED_SPEED_MIN;
-                Breathing.speed_max  = ASRLED_SPEED_MAX;
-                Breathing.speed      = ASRLED_SPEED_DEFAULT;
-                Breathing.color_mode = MODE_COLORS_PER_LED;
+                Breathing.name              = "Breathing";
+                Breathing.value             = ASRLED_MODE_BREATHING;
+                Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+                Breathing.speed_min         = ASRLED_SPEED_MIN;
+                Breathing.speed_max         = ASRLED_SPEED_MAX;
+                Breathing.speed             = ASRLED_SPEED_DEFAULT;
+                Breathing.color_mode        = MODE_COLORS_PER_LED;
                 modes.push_back(Breathing);
 
                 mode Strobe;
-                Strobe.name       = "Strobe";
-                Strobe.value      = ASRLED_MODE_STROBE;
-                Strobe.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Strobe.speed_min  = ASRLED_SPEED_MIN;
-                Strobe.speed_max  = ASRLED_SPEED_MAX;
-                Strobe.speed      = ASRLED_SPEED_DEFAULT;
-                Strobe.color_mode = MODE_COLORS_PER_LED;
+                Strobe.name                 = "Strobe";
+                Strobe.value                = ASRLED_MODE_STROBE;
+                Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+                Strobe.speed_min            = ASRLED_SPEED_MIN;
+                Strobe.speed_max            = ASRLED_SPEED_MAX;
+                Strobe.speed                = ASRLED_SPEED_DEFAULT;
+                Strobe.color_mode           = MODE_COLORS_PER_LED;
                 modes.push_back(Strobe);
 
                 mode SpectrumCycle;
-                SpectrumCycle.name       = "Spectrum Cycle";
-                SpectrumCycle.value      = ASRLED_MODE_SPECTRUM_CYCLE;
-                SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED;
-                SpectrumCycle.speed_min  = ASRLED_SPEED_MIN;
-                SpectrumCycle.speed_max  = ASRLED_SPEED_MAX;
-                SpectrumCycle.speed      = ASRLED_SPEED_DEFAULT;
-                SpectrumCycle.color_mode = MODE_COLORS_NONE;
+                SpectrumCycle.name          = "Spectrum Cycle";
+                SpectrumCycle.value         = ASRLED_MODE_SPECTRUM_CYCLE;
+                SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED;
+                SpectrumCycle.speed_min     = ASRLED_SPEED_MIN;
+                SpectrumCycle.speed_max     = ASRLED_SPEED_MAX;
+                SpectrumCycle.speed         = ASRLED_SPEED_DEFAULT;
+                SpectrumCycle.color_mode    = MODE_COLORS_NONE;
                 modes.push_back(SpectrumCycle);
 
                 mode Random;
-                Random.name       = "Random";
-                Random.value      = ASRLED_MODE_RANDOM;
-                Random.flags      = MODE_FLAG_HAS_SPEED;
-                Random.speed_min  = ASRLED_SPEED_MIN;
-                Random.speed_max  = ASRLED_SPEED_MAX;
-                Random.speed      = ASRLED_SPEED_DEFAULT;
-                Random.color_mode = MODE_COLORS_NONE;
+                Random.name                 = "Random";
+                Random.value                = ASRLED_MODE_RANDOM;
+                Random.flags                = MODE_FLAG_HAS_SPEED;
+                Random.speed_min            = ASRLED_SPEED_MIN;
+                Random.speed_max            = ASRLED_SPEED_MAX;
+                Random.speed                = ASRLED_SPEED_DEFAULT;
+                Random.color_mode           = MODE_COLORS_NONE;
                 modes.push_back(Random);
 
                 mode Music;
-                Music.name       = "Music";
-                Music.value      = ASRLED_MODE_MUSIC;
-                Music.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-                Music.color_mode = MODE_COLORS_PER_LED;
+                Music.name                  = "Music";
+                Music.value                 = ASRLED_MODE_MUSIC;
+                Music.flags                 = MODE_FLAG_HAS_PER_LED_COLOR;
+                Music.color_mode            = MODE_COLORS_PER_LED;
                 modes.push_back(Music);
 
                 mode Wave;
-                Wave.name       = "Wave";
-                Wave.value      = ASRLED_MODE_WAVE;
-                Wave.flags      = MODE_FLAG_HAS_SPEED;
-                Wave.speed_min  = ASRLED_SPEED_MIN;
-                Wave.speed_max  = ASRLED_SPEED_MAX;
-                Wave.speed      = ASRLED_SPEED_DEFAULT;
-                Wave.color_mode = MODE_COLORS_NONE;
+                Wave.name                   = "Wave";
+                Wave.value                  = ASRLED_MODE_WAVE;
+                Wave.flags                  = MODE_FLAG_HAS_SPEED;
+                Wave.speed_min              = ASRLED_SPEED_MIN;
+                Wave.speed_max              = ASRLED_SPEED_MAX;
+                Wave.speed                  = ASRLED_SPEED_DEFAULT;
+                Wave.color_mode             = MODE_COLORS_NONE;
                 modes.push_back(Wave);
             }
             break;
@@ -199,75 +199,77 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
                 /*---------------------------------------------------------------------*\
                 | Comment out until per zone modes are working. These are only for ARGB |
                 \*---------------------------------------------------------------------*/
-//                mode Spring;
-//                Spring.name                 = "Spring";
-//                Spring.value                = POLYCHROME_V1_MODE_SPRING;
-//                Spring.flags                = MODE_FLAG_HAS_SPEED;
-//                Spring.speed_min            = POLYCHROME_V1_SPEED_MIN_ARGB;
-//                Spring.speed_max            = POLYCHROME_V1_SPEED_MAX_ARGB;
-//                Spring.speed                = POLYCHROME_V1_SPEED_DEFAULT_SPRING;
-//                Spring.color_mode           = MODE_COLORS_PER_LED;
-//                modes.push_back(Spring);
+                /*
+                mode Spring;
+                Spring.name                 = "Spring";
+                Spring.value                = POLYCHROME_V1_MODE_SPRING;
+                Spring.flags                = MODE_FLAG_HAS_SPEED;
+                Spring.speed_min            = POLYCHROME_V1_SPEED_MIN_ARGB;
+                Spring.speed_max            = POLYCHROME_V1_SPEED_MAX_ARGB;
+                Spring.speed                = POLYCHROME_V1_SPEED_DEFAULT_SPRING;
+                Spring.color_mode           = MODE_COLORS_PER_LED;
+                modes.push_back(Spring);
 
-//                mode Stack;
-//                Stack.name                  = "Stack";
-//                Stack.value                 = POLYCHROME_V1_MODE_STACK;
-//                Stack.flags                 = MODE_FLAG_HAS_SPEED;
-//                Stack.speed_min             = POLYCHROME_V1_SPEED_MIN_ARGB;
-//                Stack.speed_max             = POLYCHROME_V1_SPEED_MAX_ARGB;
-//                Stack.speed                 = POLYCHROME_V1_SPEED_DEFAULT_STACK;
-//                Stack.color_mode            = MODE_COLORS_PER_LED;
-//                modes.push_back(Stack);
+                mode Stack;
+                Stack.name                  = "Stack";
+                Stack.value                 = POLYCHROME_V1_MODE_STACK;
+                Stack.flags                 = MODE_FLAG_HAS_SPEED;
+                Stack.speed_min             = POLYCHROME_V1_SPEED_MIN_ARGB;
+                Stack.speed_max             = POLYCHROME_V1_SPEED_MAX_ARGB;
+                Stack.speed                 = POLYCHROME_V1_SPEED_DEFAULT_STACK;
+                Stack.color_mode            = MODE_COLORS_PER_LED;
+                modes.push_back(Stack);
 
-//                mode Cram;
-//                Cram.name                   = "Cram";
-//                Cram.value                  = POLYCHROME_V1_MODE_CRAM;
-//                Cram.flags                  = MODE_FLAG_HAS_SPEED;
-//                Cram.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
-//                Cram.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
-//                Cram.speed                  = POLYCHROME_V1_SPEED_DEFAULT_CRAM;
-//                Cram.color_mode             = MODE_COLORS_PER_LED;
-//                modes.push_back(Cram);
+                mode Cram;
+                Cram.name                   = "Cram";
+                Cram.value                  = POLYCHROME_V1_MODE_CRAM;
+                Cram.flags                  = MODE_FLAG_HAS_SPEED;
+                Cram.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
+                Cram.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
+                Cram.speed                  = POLYCHROME_V1_SPEED_DEFAULT_CRAM;
+                Cram.color_mode             = MODE_COLORS_PER_LED;
+                modes.push_back(Cram);
 
-//                mode Scan;
-//                Scan.name                   = "Scan";
-//                Scan.value                  = POLYCHROME_V1_MODE_SCAN;
-//                Scan.flags                  = MODE_FLAG_HAS_SPEED;
-//                Scan.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
-//                Scan.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
-//                Scan.speed                  = POLYCHROME_V1_SPEED_DEFAULT_SCAN;
-//                Scan.color_mode             = MODE_COLORS_PER_LED;
-//                modes.push_back(Scan);
+                mode Scan;
+                Scan.name                   = "Scan";
+                Scan.value                  = POLYCHROME_V1_MODE_SCAN;
+                Scan.flags                  = MODE_FLAG_HAS_SPEED;
+                Scan.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
+                Scan.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
+                Scan.speed                  = POLYCHROME_V1_SPEED_DEFAULT_SCAN;
+                Scan.color_mode             = MODE_COLORS_PER_LED;
+                modes.push_back(Scan);
 
-//                mode Neon;
-//                Neon.name                   = "Neon";
-//                Neon.value                  = POLYCHROME_V1_MODE_NEON;
-//                Neon.flags                  = MODE_FLAG_HAS_SPEED;
-//                Neon.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
-//                Neon.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
-//                Neon.speed                  = POLYCHROME_V1_SPEED_DEFAULT_NEON;
-//                Neon.color_mode             = MODE_COLORS_PER_LED;
-//                modes.push_back(Neon);
+                mode Neon;
+                Neon.name                   = "Neon";
+                Neon.value                  = POLYCHROME_V1_MODE_NEON;
+                Neon.flags                  = MODE_FLAG_HAS_SPEED;
+                Neon.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
+                Neon.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
+                Neon.speed                  = POLYCHROME_V1_SPEED_DEFAULT_NEON;
+                Neon.color_mode             = MODE_COLORS_PER_LED;
+                modes.push_back(Neon);
 
-//                mode Water;
-//                Water.name                  = "Water";
-//                Water.value                 = POLYCHROME_V1_MODE_WATER;
-//                Water.flags                 = MODE_FLAG_HAS_SPEED;
-//                Water.speed_min             = POLYCHROME_V1_SPEED_MIN_ARGB;
-//                Water.speed_max             = POLYCHROME_V1_SPEED_MAX_ARGB;
-//                Water.speed                 = POLYCHROME_V1_SPEED_DEFAULT_WATER;
-//                Water.color_mode            = MODE_COLORS_PER_LED;
-//                modes.push_back(Water);
+                mode Water;
+                Water.name                  = "Water";
+                Water.value                 = POLYCHROME_V1_MODE_WATER;
+                Water.flags                 = MODE_FLAG_HAS_SPEED;
+                Water.speed_min             = POLYCHROME_V1_SPEED_MIN_ARGB;
+                Water.speed_max             = POLYCHROME_V1_SPEED_MAX_ARGB;
+                Water.speed                 = POLYCHROME_V1_SPEED_DEFAULT_WATER;
+                Water.color_mode            = MODE_COLORS_PER_LED;
+                modes.push_back(Water);
 
-//                mode Rainbow;
-//                Rainbow.name                = "Rainbow";
-//                Rainbow.value               = POLYCHROME_V1_MODE_RAINBOW;
-//                Rainbow.flags               = MODE_FLAG_HAS_SPEED;
-//                Rainbow.speed_min           = POLYCHROME_V1_SPEED_MIN_RAINBOW;
-//                Rainbow.speed_max           = POLYCHROME_V1_SPEED_MAX_RAINBOW;
-//                Rainbow.speed               = POLYCHROME_V1_SPEED_DEFAULT_RAINBOW;
-//                Rainbow.color_mode          = MODE_COLORS_NONE;
-//                modes.push_back(Rainbow);
+                mode Rainbow;
+                Rainbow.name                = "Rainbow";
+                Rainbow.value               = POLYCHROME_V1_MODE_RAINBOW;
+                Rainbow.flags               = MODE_FLAG_HAS_SPEED;
+                Rainbow.speed_min           = POLYCHROME_V1_SPEED_MIN_RAINBOW;
+                Rainbow.speed_max           = POLYCHROME_V1_SPEED_MAX_RAINBOW;
+                Rainbow.speed               = POLYCHROME_V1_SPEED_DEFAULT_RAINBOW;
+                Rainbow.color_mode          = MODE_COLORS_NONE;
+                modes.push_back(Rainbow);
+                */
             }
             break;
 
@@ -276,134 +278,134 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
                 description = "ASRock Polychrome v2 Device";
 
                 mode Off;
-                Off.name       = "Off";
-                Off.value      = POLYCHROME_V2_MODE_OFF;
-                Off.flags      = 0;
-                Off.color_mode = MODE_COLORS_NONE;
+                Off.name                    = "Off";
+                Off.value                   = POLYCHROME_V2_MODE_OFF;
+                Off.flags                   = 0;
+                Off.color_mode              = MODE_COLORS_NONE;
                 modes.push_back(Off);
 
                 mode Static;
-                Static.name       = "Static";
-                Static.value      = POLYCHROME_V2_MODE_STATIC;
-                Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-                Static.color_mode = MODE_COLORS_PER_LED;
+                Static.name                 = "Static";
+                Static.value                = POLYCHROME_V2_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      = POLYCHROME_V2_MODE_BREATHING;
-                Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Breathing.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Breathing.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Breathing.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Breathing.color_mode = MODE_COLORS_PER_LED;
+                Breathing.name              = "Breathing";
+                Breathing.value             = POLYCHROME_V2_MODE_BREATHING;
+                Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+                Breathing.speed_min         = POLYCHROME_V2_SPEED_MIN;
+                Breathing.speed_max         = POLYCHROME_V2_SPEED_MAX;
+                Breathing.speed             = POLYCHROME_V2_SPEED_DEFAULT;
+                Breathing.color_mode        = MODE_COLORS_PER_LED;
                 modes.push_back(Breathing);
 
                 mode Strobe;
-                Strobe.name       = "Strobe";
-                Strobe.value      = POLYCHROME_V2_MODE_STROBE;
-                Strobe.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Strobe.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Strobe.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Strobe.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Strobe.color_mode = MODE_COLORS_PER_LED;
+                Strobe.name                 = "Strobe";
+                Strobe.value                = POLYCHROME_V2_MODE_STROBE;
+                Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+                Strobe.speed_min            = POLYCHROME_V2_SPEED_MIN;
+                Strobe.speed_max            = POLYCHROME_V2_SPEED_MAX;
+                Strobe.speed                = POLYCHROME_V2_SPEED_DEFAULT;
+                Strobe.color_mode           = MODE_COLORS_PER_LED;
                 modes.push_back(Strobe);
 
                 mode SpectrumCycle;
-                SpectrumCycle.name       = "Spectrum Cycle";
-                SpectrumCycle.value      = POLYCHROME_V2_MODE_SPECTRUM_CYCLE;
-                SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED;
-                SpectrumCycle.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                SpectrumCycle.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                SpectrumCycle.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                SpectrumCycle.color_mode = MODE_COLORS_NONE;
+                SpectrumCycle.name          = "Spectrum Cycle";
+                SpectrumCycle.value         = POLYCHROME_V2_MODE_SPECTRUM_CYCLE;
+                SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED;
+                SpectrumCycle.speed_min     = POLYCHROME_V2_SPEED_MIN;
+                SpectrumCycle.speed_max     = POLYCHROME_V2_SPEED_MAX;
+                SpectrumCycle.speed         = POLYCHROME_V2_SPEED_DEFAULT;
+                SpectrumCycle.color_mode    = MODE_COLORS_NONE;
                 modes.push_back(SpectrumCycle);
 
                 mode Random;
-                Random.name       = "Random";
-                Random.value      = POLYCHROME_V2_MODE_RANDOM;
-                Random.flags      = MODE_FLAG_HAS_SPEED;
-                Random.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Random.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Random.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Random.color_mode = MODE_COLORS_NONE;
+                Random.name                 = "Random";
+                Random.value                = POLYCHROME_V2_MODE_RANDOM;
+                Random.flags                = MODE_FLAG_HAS_SPEED;
+                Random.speed_min            = POLYCHROME_V2_SPEED_MIN;
+                Random.speed_max            = POLYCHROME_V2_SPEED_MAX;
+                Random.speed                = POLYCHROME_V2_SPEED_DEFAULT;
+                Random.color_mode           = MODE_COLORS_NONE;
                 modes.push_back(Random);
 
                 mode Wave;
-                Wave.name       = "Wave";
-                Wave.value      = POLYCHROME_V2_MODE_WAVE;
-                Wave.flags      = MODE_FLAG_HAS_SPEED;
-                Wave.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Wave.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Wave.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Wave.color_mode = MODE_COLORS_NONE;
+                Wave.name                   = "Wave";
+                Wave.value                  = POLYCHROME_V2_MODE_WAVE;
+                Wave.flags                  = MODE_FLAG_HAS_SPEED;
+                Wave.speed_min              = POLYCHROME_V2_SPEED_MIN;
+                Wave.speed_max              = POLYCHROME_V2_SPEED_MAX;
+                Wave.speed                  = POLYCHROME_V2_SPEED_DEFAULT;
+                Wave.color_mode             = MODE_COLORS_NONE;
                 modes.push_back(Wave);
 
                 mode Spring;
-                Spring.name       = "Spring";
-                Spring.value      = POLYCHROME_V2_MODE_SPRING;
-                Spring.flags      = MODE_FLAG_HAS_SPEED;
-                Spring.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Spring.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Spring.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Spring.color_mode = MODE_COLORS_NONE;
+                Spring.name                 = "Spring";
+                Spring.value                = POLYCHROME_V2_MODE_SPRING;
+                Spring.flags                = MODE_FLAG_HAS_SPEED;
+                Spring.speed_min            = POLYCHROME_V2_SPEED_MIN;
+                Spring.speed_max            = POLYCHROME_V2_SPEED_MAX;
+                Spring.speed                = POLYCHROME_V2_SPEED_DEFAULT;
+                Spring.color_mode           = MODE_COLORS_NONE;
                 modes.push_back(Spring);
 
                 mode Stack;
-                Stack.name       = "Stack";
-                Stack.value      = POLYCHROME_V2_MODE_STACK;
-                Stack.flags      = MODE_FLAG_HAS_SPEED;
-                Stack.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Stack.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Stack.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Stack.color_mode = MODE_COLORS_NONE;
+                Stack.name                  = "Stack";
+                Stack.value                 = POLYCHROME_V2_MODE_STACK;
+                Stack.flags                 = MODE_FLAG_HAS_SPEED;
+                Stack.speed_min             = POLYCHROME_V2_SPEED_MIN;
+                Stack.speed_max             = POLYCHROME_V2_SPEED_MAX;
+                Stack.speed                 = POLYCHROME_V2_SPEED_DEFAULT;
+                Stack.color_mode            = MODE_COLORS_NONE;
                 modes.push_back(Stack);
 
                 mode Cram;
-                Cram.name       = "Cram";
-                Cram.value      = POLYCHROME_V2_MODE_CRAM;
-                Cram.flags      = MODE_FLAG_HAS_SPEED;
-                Cram.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Cram.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Cram.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Cram.color_mode = MODE_COLORS_NONE;
+                Cram.name                   = "Cram";
+                Cram.value                  = POLYCHROME_V2_MODE_CRAM;
+                Cram.flags                  = MODE_FLAG_HAS_SPEED;
+                Cram.speed_min              = POLYCHROME_V2_SPEED_MIN;
+                Cram.speed_max              = POLYCHROME_V2_SPEED_MAX;
+                Cram.speed                  = POLYCHROME_V2_SPEED_DEFAULT;
+                Cram.color_mode             = MODE_COLORS_NONE;
                 modes.push_back(Cram);
 
                 mode Scan;
-                Scan.name       = "Scan";
-                Scan.value      = POLYCHROME_V2_MODE_SCAN;
-                Scan.flags      = MODE_FLAG_HAS_SPEED;
-                Scan.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Scan.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Scan.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Scan.color_mode = MODE_COLORS_NONE;
+                Scan.name                   = "Scan";
+                Scan.value                  = POLYCHROME_V2_MODE_SCAN;
+                Scan.flags                  = MODE_FLAG_HAS_SPEED;
+                Scan.speed_min              = POLYCHROME_V2_SPEED_MIN;
+                Scan.speed_max              = POLYCHROME_V2_SPEED_MAX;
+                Scan.speed                  = POLYCHROME_V2_SPEED_DEFAULT;
+                Scan.color_mode             = MODE_COLORS_NONE;
                 modes.push_back(Scan);
 
                 mode Neon;
-                Neon.name       = "Neon";
-                Neon.value      = POLYCHROME_V2_MODE_NEON;
-                Neon.flags      = 0;
-                Neon.color_mode = MODE_COLORS_NONE;
+                Neon.name                   = "Neon";
+                Neon.value                  = POLYCHROME_V2_MODE_NEON;
+                Neon.flags                  = 0;
+                Neon.color_mode             = MODE_COLORS_NONE;
                 modes.push_back(Neon);
 
                 mode Water;
-                Water.name       = "Water";
-                Water.value      = POLYCHROME_V2_MODE_WATER;
-                Water.flags      = MODE_FLAG_HAS_SPEED;
-                Water.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Water.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Water.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Water.color_mode = MODE_COLORS_NONE;
+                Water.name                  = "Water";
+                Water.value                 = POLYCHROME_V2_MODE_WATER;
+                Water.flags                 = MODE_FLAG_HAS_SPEED;
+                Water.speed_min             = POLYCHROME_V2_SPEED_MIN;
+                Water.speed_max             = POLYCHROME_V2_SPEED_MAX;
+                Water.speed                 = POLYCHROME_V2_SPEED_DEFAULT;
+                Water.color_mode            = MODE_COLORS_NONE;
                 modes.push_back(Water);
 
                 mode Rainbow;
-                Rainbow.name       = "Rainbow";
-                Rainbow.value      = POLYCHROME_V2_MODE_RAINBOW;
-                Rainbow.flags      = MODE_FLAG_HAS_SPEED;
-                Rainbow.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Rainbow.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Rainbow.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Rainbow.color_mode = MODE_COLORS_NONE;
+                Rainbow.name                = "Rainbow";
+                Rainbow.value               = POLYCHROME_V2_MODE_RAINBOW;
+                Rainbow.flags               = MODE_FLAG_HAS_SPEED;
+                Rainbow.speed_min           = POLYCHROME_V2_SPEED_MIN;
+                Rainbow.speed_max           = POLYCHROME_V2_SPEED_MAX;
+                Rainbow.speed               = POLYCHROME_V2_SPEED_DEFAULT;
+                Rainbow.color_mode          = MODE_COLORS_NONE;
                 modes.push_back(Rainbow);
             }
             break;
@@ -412,6 +414,11 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
     SetupZones();
 }
 
+RGBController_Polychrome::~RGBController_Polychrome()
+{
+    delete polychrome;
+}
+
 void RGBController_Polychrome::SetupZones()
 {
     switch(polychrome->GetASRockType())

Controllers/ASRockPolychromeSMBusController/RGBController_ASRockPolychromeSMBus.h

@@ -16,6 +16,7 @@ class RGBController_Polychrome : public RGBController
 {
 public:
     RGBController_Polychrome(PolychromeController* polychrome_ptr);
+    ~RGBController_Polychrome();
 
     void        SetupZones();
 

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -0,0 +1,355 @@
+/*-----------------------------------------*\
+|  ASRockPolychromeUSBController.cpp        |
+|                                           |
+|  Driver for ASRock Polychrome USB         |
+|  lighting controller                      |
+|                                           |
+|  Ed Kambulow (dredvard) 12/20/2020        |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include "ASRockPolychromeUSBController.h"
+#include <cstring>
+#include <stdio.h>
+#include "dependencies/dmiinfo.h"
+
+#define POLYCHROME_USB_READ_ZONE_CONFIG 0x11
+#define POLYCHROME_USB_READ_HEADER      0x14
+#define POLYCHROME_USB_WRITE_HEADER     0x15
+#define POLYCHROME_USB_SET_ZONE         0x10
+#define POLYCHROME_USB_INIT             0xA4
+#define POLYCHROME_USB_COMMIT           0x12
+
+PolychromeUSBController::PolychromeUSBController(hid_device* dev_handle, const char* path)
+{
+    DMIInfo       dmi;
+
+    dev         = dev_handle;
+    device_name = "ASRock " + dmi.getMainboard();
+    location    = path;
+
+    SetDeviceInfo();
+}
+
+PolychromeUSBController::~PolychromeUSBController()
+{
+
+}
+
+unsigned int PolychromeUSBController::GetChannelCount()
+{
+    return(device_info.size());
+}
+
+std::string PolychromeUSBController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string PolychromeUSBController::GetDeviceName()
+{
+    return(device_name);
+}
+
+std::string PolychromeUSBController::GetSerialString()
+{
+    wchar_t serial_string[128];
+    hid_get_serial_number_string(dev, serial_string, 128);
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+void PolychromeUSBController::SetDeviceInfo()
+{
+    PolychromeDeviceInfo newdev_info;
+    ReadConfigTables();
+
+    for (unsigned int zonecnt = 0; zonecnt < POLYCHROME_USB_ZONE_MAX_NUM; zonecnt++)
+    {
+        if(configtable[zonecnt] == 0x1E)
+        {
+            break;
+        }
+
+        newdev_info.num_leds = configtable[zonecnt];
+
+        switch (zonecnt)
+        {
+            /*-----------------------------------------*\
+            | Type: Addressable, configurable           |
+            \*-----------------------------------------*/
+            case POLYCHROME_USB_ZONE_ARGB1:
+            case POLYCHROME_USB_ZONE_ARGB2:
+                newdev_info.device_type = PolychromeDeviceType::ADDRESSABLE;
+                break;
+
+            /*-----------------------------------------*\
+            | Type: Addressable, not configurable       |
+            \*-----------------------------------------*/
+            case POLYCHROME_USB_ZONE_PCH:
+            case POLYCHROME_USB_ZONE_IOCOVER:
+            case POLYCHROME_USB_ZONE_PCB:
+            case POLYCHROME_USB_ZONE_AUDIO:
+                newdev_info.device_type = PolychromeDeviceType::FIXED;
+                break;
+            
+            /*-----------------------------------------*\
+            | Type: Fixed                               |
+            \*-----------------------------------------*/
+            case POLYCHROME_USB_ZONE_RGB1:
+            case POLYCHROME_USB_ZONE_RGB2:
+            default:
+                newdev_info.device_type = PolychromeDeviceType::FIXED;
+                break;
+        }
+
+        device_info.push_back(newdev_info);
+    }
+}
+
+void PolychromeUSBController::WriteZone
+    (
+    unsigned char   zone,
+    unsigned char   mode,
+    unsigned char   speed,
+    RGBColor        rgb, 
+    bool            allzone = false
+    )
+{
+    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] = zone;
+	usb_buf[0x04] = mode;
+	usb_buf[0x05] = RGBGetRValue(rgb);
+	usb_buf[0x06] = RGBGetGValue(rgb);
+	usb_buf[0x07] = RGBGetBValue(rgb);
+	usb_buf[0x08] = speed;
+	usb_buf[0x09] = 0xFF;
+	usb_buf[0x10] = allzone;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
+};
+
+void PolychromeUSBController::WriteRGSwap
+    (
+    bool ahdr1,
+    bool ahdr0,
+    bool hdr1,
+    bool hdr0
+    )
+{
+    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_WRITE_HEADER;
+
+    usb_buf[0x04] = POLYCHROME_USB_RGSWAP_CFG;
+	usb_buf[0x05] = ((ahdr1 << 3) & (ahdr0 << 2) & (hdr1 << 1) & hdr0) & 0x40;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
+}
+
+void PolychromeUSBController::WriteHeader
+    (
+    unsigned char   cfg,
+    unsigned char   configstring[]
+    )
+{
+    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_WRITE_HEADER;
+	usb_buf[0x03] = cfg;
+    memcpy(&usb_buf[4], configstring, sizeof(configstring));
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
+}
+
+PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
+{
+    unsigned char       usb_buf[65];
+    PolychromeZoneInfo  zoneinfo;
+    unsigned char       all;
+    unsigned char       r;
+    unsigned char       g;
+    unsigned char       b;
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up config table request packet                    |
+    \*-----------------------------------------------------*/
+    usb_buf[0x01]   = POLYCHROME_USB_READ_ZONE_CONFIG;
+    usb_buf[0x03]   = zone; 
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Read response                                         |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    hid_read(dev, usb_buf, 64);
+    
+    r   = usb_buf[0x05];
+    g   = usb_buf[0x06];
+    b   = usb_buf[0x07];
+
+    zoneinfo.mode   = usb_buf[0x04];
+    zoneinfo.color  = ToRGBColor(r,g,b);  
+    zoneinfo.speed  = usb_buf[0x08];
+    zoneinfo.zone   = usb_buf[0x03];
+    all             = usb_buf[0x10];
+
+    return(zoneinfo);
+}
+
+void PolychromeUSBController::ReadConfigTables()
+{
+    unsigned char usb_buf[65];
+    unsigned char maxzoneleds[8];
+    unsigned char rgbswap;
+    unsigned char header1;
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up max led config table request packet            |
+    \*-----------------------------------------------------*/
+    usb_buf[0x01]   = POLYCHROME_USB_READ_HEADER;
+    usb_buf[0x03]   = POLYCHROME_USB_LEDCOUNT_CFG;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Read response                                         |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    hid_read(dev, usb_buf, 64);
+
+    /*-----------------------------------------------------*\
+    | Reads in format: RGB1, RGB2, ARGB1, ARGB2, PCH, IO,   |
+    | PCB, AUDIO                                            |
+    \*-----------------------------------------------------*/
+    memcpy(&maxzoneleds,&usb_buf[0x04],8);
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up RGB Swap table request packet                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x01]   = POLYCHROME_USB_READ_HEADER;
+    usb_buf[0x03]   = POLYCHROME_USB_RGSWAP_CFG;
+
+    hid_write(dev, usb_buf, 65);
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    hid_read(dev, usb_buf, 64);
+
+    /*-----------------------------------------------------*\
+    | Reads bitwise in format: AUDIO, PCB, IO, PCH, ARGB2,  |
+    | ARGB1, RGB2, RGB1 if available                        |
+    \*-----------------------------------------------------*/
+    rgbswap=usb_buf[4];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Header1 config table request packet            |
+    \*-----------------------------------------------------*/
+    usb_buf[0x01]   = POLYCHROME_USB_READ_HEADER;
+    usb_buf[0x03]   = 0x01;
+
+    hid_write(dev, usb_buf, 64);
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    hid_read(dev, usb_buf, 64);
+    header1=usb_buf[4];
+
+    memcpy(configtable,&maxzoneleds,8);
+    configtable[8]=rgbswap;
+    configtable[9]=header1;
+    return;
+}
+
+void PolychromeUSBController::Commit()
+{
+    /*-----------------------------------------------------*\
+    | Saves all Writes in Device -  Will keep after powerup |
+    \*-----------------------------------------------------*/
+    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_COMMIT;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
+};
+
+const std::vector<PolychromeDeviceInfo>& PolychromeUSBController::GetPolychromeDevices() const
+{
+    return(device_info);
+};

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.h

@@ -0,0 +1,150 @@
+/*-----------------------------------------*\
+|  ASRockPolychromeUSBController.h          |
+|                                           |
+|  Driver for ASRock Polychrome USB         |
+|  lighting controller                      |
+|                                           |
+|  Ed Kambulow (dredvard) 12/20/2020        |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>
+
+#pragma once
+
+/*----------------------------------------------------------------------------------------------*\
+| Definitions for Polychrome USB                                                                 |
+\*----------------------------------------------------------------------------------------------*/
+#define POLYCHROME_USB_NUM_MODES            15          /* Number of Polychrome USB modes       */
+
+enum
+{
+    POLYCHROME_USB_MODE_OFF                 = 0x00,     /* OFF mode                             */
+    POLYCHROME_USB_MODE_STATIC              = 0x01,     /* Static color mode                    */
+    POLYCHROME_USB_MODE_BREATHING           = 0x02,     /* Breathing effect mode                */
+    POLYCHROME_USB_MODE_STROBE              = 0x03,     /* Strobe effect mode                   */
+    POLYCHROME_USB_MODE_SPECTRUM_CYCLE      = 0x04,     /* Spectrum Cycle effect mode           */
+    POLYCHROME_USB_MODE_RANDOM              = 0x05,     /* Random effect mode                   */
+    POLYCHROME_USB_MODE_MUSIC               = 0x06,     /* Random effect mode                   */
+    POLYCHROME_USB_MODE_WAVE                = 0x07,     /* Wave effect mode                     */
+    POLYCHROME_USB_MODE_SPRING              = 0x08,     /* Spring effect mode                   */
+    POLYCHROME_USB_MODE_STACK               = 0x09,     /* Stack effect mode                    */
+    POLYCHROME_USB_MODE_CRAM                = 0x0A,     /* Cram effect mode                     */
+    POLYCHROME_USB_MODE_SCAN                = 0x0B,     /* Scan effect mode                     */
+    POLYCHROME_USB_MODE_NEON                = 0x0C,     /* Neon effect mode                     */
+    POLYCHROME_USB_MODE_WATER               = 0x0D,     /* Water effect mode                    */
+    POLYCHROME_USB_MODE_RAINBOW             = 0x0E,     /* Rainbow effect mode                  */
+};
+
+enum
+{
+    POLYCHROME_USB_SPEED_MIN                = 0xFF,     /* Slowest speed                        */
+    POLYCHROME_USB_SPEED_DEFAULT            = 0xE0,     /* Default speed                        */
+    POLYCHROME_USB_SPEED_MAX                = 0x00,     /* Fastest speed                        */
+};
+
+enum
+{
+    POLYCHROME_USB_ZONE_MAX_NUM             = 0x08,     /* Total Max number of zones            */
+    POLYCHROME_USB_ZONE_ADDRESSABLE_MAX     = 0x64,     /* Maxinum number of ARGB LEDs          */
+};
+
+enum
+{
+    POLYCHROME_USB_LEDCOUNT_CFG             = 0x02,     // Config for LED Count
+    POLYCHROME_USB_RGSWAP_CFG               = 0x03,     // Config for RGSWAP
+    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",
+};
+
+enum
+{
+    POLYCHROME_USB_ZONE_RGB1         = 0x00,  // RGB Header 1
+    POLYCHROME_USB_ZONE_RGB2         = 0X01,  // RGB Header 2
+    POLYCHROME_USB_ZONE_ARGB1        = 0X02,  // ARGB Header 1
+    POLYCHROME_USB_ZONE_ARGB2        = 0X03,  // ARGB Header 2
+    POLYCHROME_USB_ZONE_PCH          = 0X04,  // PCH
+    POLYCHROME_USB_ZONE_IOCOVER      = 0X05,  // IOCOVER
+    POLYCHROME_USB_ZONE_PCB          = 0X06,  // PCB - Could be mixed swapped with 0x07
+    POLYCHROME_USB_ZONE_AUDIO        = 0X07   // AUDIO
+};
+
+enum class PolychromeDeviceType
+{
+    FIXED,
+    ADDRESSABLE,
+};
+
+struct PolychromeZoneInfo
+{
+    unsigned char   mode;
+    unsigned char   zone;
+    unsigned char   speed;
+    RGBColor        color;
+};
+
+struct PolychromeDeviceInfo
+{
+    unsigned char           effect_channel;
+    unsigned char           num_leds;
+    PolychromeDeviceType    device_type;
+};
+
+class PolychromeUSBController
+{
+public:
+    unsigned char   zone_led_count[8];
+
+    PolychromeUSBController(hid_device* dev_handle, const char* path);
+    ~PolychromeUSBController();
+
+    unsigned int                                GetChannelCount();
+    std::string                                 GetDeviceLocation();
+    std::string                                 GetDeviceName();
+    const std::vector<PolychromeDeviceInfo>&    GetPolychromeDevices() const;
+    std::string                                 GetSerialString();
+    PolychromeZoneInfo                          GetZoneConfig (unsigned char zone);
+
+    void                                        WriteZone
+                                                    (
+                                                    unsigned char   zone,
+                                                    unsigned char   mode,
+                                                    unsigned char   speed,
+                                                    RGBColor        rgb,
+                                                    bool            allzone
+                                                    );
+
+    void                                        WriteHeader
+                                                    (
+                                                    unsigned char cfg,
+                                                    unsigned char configstring []
+                                                    );
+
+protected:
+    hid_device*                         dev;
+    std::vector<PolychromeDeviceInfo>   device_info;
+    std::string                         location;
+
+    void WriteRGSwap(bool ahdr1, bool ahdr0, bool hdr1, bool hdr0);
+
+private:
+    unsigned int  led_count;
+    std::string   device_name;
+    unsigned char configtable[12];
+
+    void SetDeviceInfo();    
+    void ReadConfigTables();
+    void Commit();
+};

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBControllerDetect.cpp

@@ -0,0 +1,36 @@
+#include "Detector.h"
+#include "ASRockPolychromeUSBController.h"
+#include "RGBController.h"
+#include "RGBController_ASRockPolychromeUSB.h"
+#include "i2c_smbus.h"
+#include "pci_ids.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+#include <hidapi/hidapi.h>
+
+/*---------------------------------------------------------*\
+| ASRock vendor ID                                          |
+\*---------------------------------------------------------*/
+#define ASROCK_VID                                  0x26CE
+
+/*---------------------------------------------------------*\
+| ASRock product ID                                         |
+\*---------------------------------------------------------*/
+#define ASROCK_MOTHERBOARD_1_PID                    0x01A2
+#define ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID   0x01A6
+
+void DetectPolychromeUSBControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        PolychromeUSBController*     controller     = new PolychromeUSBController(dev, info->path);
+        RGBController_PolychromeUSB* rgb_controller = new RGBController_PolychromeUSB(controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR("ASRock Polychrome USB", DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_MOTHERBOARD_1_PID);
+REGISTER_HID_DETECTOR("ASRock Deskmini Addressable LED Strip", DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID);

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -0,0 +1,350 @@
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeUSB.cpp    |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock Polychrome USB Driver             |
+|                                           |
+|  Ed Kambulow (Dredvard) 12/26/2020        |
+\*-----------------------------------------*/
+
+#include "RGBController_ASRockPolychromeUSB.h"
+#include <string.h>
+
+#define ASROCK_USB_MAX_ZONES        8
+#define ASROCK_ADDRESSABLE_MAX_LEDS 100
+
+RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController* polychrome_ptr)
+{
+    polychrome                  = polychrome_ptr;
+
+    name                        = polychrome->GetDeviceName();
+    description                 = "ASRock Polychrome USB Device";
+    vendor                      = "ASRock";
+    type                        = DEVICE_TYPE_MOTHERBOARD;
+    location                    = polychrome->GetDeviceLocation();
+
+    mode Off;
+    Off.name                    = "Off";
+    Off.value                   = POLYCHROME_USB_MODE_OFF;
+    Off.flags                   = 0;
+    Off.color_mode              = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = POLYCHROME_USB_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             = POLYCHROME_USB_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.speed_min         = POLYCHROME_USB_SPEED_MIN;
+    Breathing.speed_max         = POLYCHROME_USB_SPEED_MAX;
+    Breathing.speed             = POLYCHROME_USB_SPEED_DEFAULT;
+    Breathing.color_mode        = MODE_COLORS_PER_LED;
+    modes.push_back(Breathing);
+
+    mode Strobe;
+    Strobe.name                 = "Strobe";
+    Strobe.value                = POLYCHROME_USB_MODE_STROBE;
+    Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Strobe.speed_min            = POLYCHROME_USB_SPEED_MIN;
+    Strobe.speed_max            = POLYCHROME_USB_SPEED_MAX;
+    Strobe.speed                = POLYCHROME_USB_SPEED_DEFAULT;
+    Strobe.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Strobe);
+
+    mode SpectrumCycle;
+    SpectrumCycle.name          = "Spectrum Cycle";
+    SpectrumCycle.value         = POLYCHROME_USB_MODE_SPECTRUM_CYCLE;
+    SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED;
+    SpectrumCycle.speed_min     = POLYCHROME_USB_SPEED_MIN;
+    SpectrumCycle.speed_max     = POLYCHROME_USB_SPEED_MAX;
+    SpectrumCycle.speed         = POLYCHROME_USB_SPEED_DEFAULT;
+    SpectrumCycle.color_mode    = MODE_COLORS_NONE;
+    modes.push_back(SpectrumCycle);
+
+    mode Random;
+    Random.name                 = "Random";
+    Random.value                = POLYCHROME_USB_MODE_RANDOM;
+    Random.flags                = MODE_FLAG_HAS_SPEED;
+    Random.speed_min            = POLYCHROME_USB_SPEED_MIN;
+    Random.speed_max            = POLYCHROME_USB_SPEED_MAX;
+    Random.speed                = POLYCHROME_USB_SPEED_DEFAULT;
+    Random.color_mode           = MODE_COLORS_NONE;
+    modes.push_back(Random);
+
+    mode Music;
+    Random.name                 = "Music";
+    Random.value                = POLYCHROME_USB_MODE_RANDOM;
+    Random.flags                = MODE_FLAG_HAS_BRIGHTNESS;
+    Random.color_mode           = MODE_COLORS_NONE;
+    modes.push_back(Random);
+
+    mode Wave;
+    Wave.name                   = "Wave";
+    Wave.value                  = POLYCHROME_USB_MODE_WAVE;
+    Wave.flags                  = MODE_FLAG_HAS_SPEED;
+    Wave.speed_min              = POLYCHROME_USB_SPEED_MIN;
+    Wave.speed_max              = POLYCHROME_USB_SPEED_MAX;
+    Wave.speed                  = POLYCHROME_USB_SPEED_DEFAULT;
+    Wave.color_mode             = MODE_COLORS_NONE;
+    modes.push_back(Wave);
+
+    mode Spring;
+    Spring.name                 = "Spring";
+    Spring.value                = POLYCHROME_USB_MODE_SPRING;
+    Spring.flags                = MODE_FLAG_HAS_SPEED;
+    Spring.speed_min            = POLYCHROME_USB_SPEED_MIN;
+    Spring.speed_max            = POLYCHROME_USB_SPEED_MAX;
+    Spring.speed                = POLYCHROME_USB_SPEED_DEFAULT;
+    Spring.color_mode           = MODE_COLORS_NONE;
+    modes.push_back(Spring);
+
+    mode Stack;
+    Stack.name                  = "Stack";
+    Stack.value                 = POLYCHROME_USB_MODE_STACK;
+    Stack.flags                 = MODE_FLAG_HAS_SPEED;
+    Stack.speed_min             = POLYCHROME_USB_SPEED_MIN;
+    Stack.speed_max             = POLYCHROME_USB_SPEED_MAX;
+    Stack.speed                 = POLYCHROME_USB_SPEED_DEFAULT;
+    Stack.color_mode            = MODE_COLORS_NONE;
+    modes.push_back(Stack);
+
+    mode Cram;
+    Cram.name                   = "Cram";
+    Cram.value                  = POLYCHROME_USB_MODE_CRAM;
+    Cram.flags                  = MODE_FLAG_HAS_SPEED;
+    Cram.speed_min              = POLYCHROME_USB_SPEED_MIN;
+    Cram.speed_max              = POLYCHROME_USB_SPEED_MAX;
+    Cram.speed                  = POLYCHROME_USB_SPEED_DEFAULT;
+    Cram.color_mode             = MODE_COLORS_NONE;
+    modes.push_back(Cram);
+
+    mode Scan;
+    Scan.name                   = "Scan";
+    Scan.value                  = POLYCHROME_USB_MODE_SCAN;
+    Scan.flags                  = MODE_FLAG_HAS_SPEED;
+    Scan.speed_min              = POLYCHROME_USB_SPEED_MIN;
+    Scan.speed_max              = POLYCHROME_USB_SPEED_MAX;
+    Scan.speed                  = POLYCHROME_USB_SPEED_DEFAULT;
+    Scan.color_mode             = MODE_COLORS_NONE;
+    modes.push_back(Scan);
+
+    mode Neon;
+    Neon.name                   = "Neon";
+    Neon.value                  = POLYCHROME_USB_MODE_NEON;
+    Neon.flags                  = 0;
+    Neon.color_mode             = MODE_COLORS_NONE;
+    modes.push_back(Neon);
+
+    mode Water;
+    Water.name                  = "Water";
+    Water.value                 = POLYCHROME_USB_MODE_WATER;
+    Water.flags                 = MODE_FLAG_HAS_SPEED;
+    Water.speed_min             = POLYCHROME_USB_SPEED_MIN;
+    Water.speed_max             = POLYCHROME_USB_SPEED_MAX;
+    Water.speed                 = POLYCHROME_USB_SPEED_DEFAULT;
+    Water.color_mode            = MODE_COLORS_NONE;
+    modes.push_back(Water);
+
+    mode Rainbow;
+    Rainbow.name                = "Rainbow";
+    Rainbow.value               = POLYCHROME_USB_MODE_RAINBOW;
+    Rainbow.flags               = MODE_FLAG_HAS_SPEED;
+    Rainbow.speed_min           = POLYCHROME_USB_SPEED_MIN;
+    Rainbow.speed_max           = POLYCHROME_USB_SPEED_MAX;
+    Rainbow.speed               = POLYCHROME_USB_SPEED_DEFAULT;
+    Rainbow.color_mode          = MODE_COLORS_NONE;
+    modes.push_back(Rainbow);
+
+    SetupZones();
+
+    /*-------------------------------------------------*\
+    | Initialize active mode                            |
+    \*-------------------------------------------------*/
+    active_mode = GetDeviceMode(1);
+}
+
+void RGBController_PolychromeUSB::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Only set LED count on the first run               |
+    \*-------------------------------------------------*/
+    bool first_run = false;
+
+    if(zones.size() == 0)
+    {
+        first_run = true;
+    }
+
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
+    leds.clear();
+    colors.clear();
+    zones.resize(polychrome->GetChannelCount());
+
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    int addressableCounter = 1;
+    for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+    {
+        PolychromeDeviceInfo device_info = polychrome->GetPolychromeDevices()[channel_idx];
+
+        zones[channel_idx].type     = ZONE_TYPE_LINEAR;
+
+        if(device_info.device_type== PolychromeDeviceType::ADDRESSABLE)
+        {
+            zones[channel_idx].name       = polychrome_USB_zone_names[channel_idx];
+            zones[channel_idx].leds_min   = 0;
+            zones[channel_idx].leds_max   = ASROCK_ADDRESSABLE_MAX_LEDS;
+            zones[channel_idx].leds_count = device_info.num_leds; 
+        }
+        else if(device_info.device_type==PolychromeDeviceType::FIXED) 
+        {
+            zones[channel_idx].name       = polychrome_USB_zone_names[channel_idx];
+            zones[channel_idx].leds_min   = device_info.num_leds;
+            zones[channel_idx].leds_max   = device_info.num_leds;
+            zones[channel_idx].leds_count = device_info.num_leds; 
+        }       
+
+
+        for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
+        {
+            led new_led;
+            new_led.name = zones[channel_idx].name;
+            new_led.name.append(", LED ");
+            new_led.name.append(std::to_string(led_ch_idx + 1));
+            new_led.value = channel_idx;
+
+            leds.push_back(new_led);
+        }
+
+        zones[channel_idx].matrix_map = NULL;
+    }
+
+    SetupColors();
+
+    /*---------------------------------------------------------*\
+    | Initialize colors for each LED                            |
+    \*---------------------------------------------------------*/
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        unsigned char led = (unsigned char)leds[led_idx].value;
+
+        colors[led_idx] = polychrome->GetZoneConfig(led).color;     // TODO Get addressable instead of zone idx
+    }
+
+    /*---------------------------------------------------------*\
+    | Initialize zone info to track zone, speed, mode           |
+    | B550 Boards have modes, speed for each zone               |
+    \*---------------------------------------------------------*/
+     for (unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+    {
+        PolychromeZoneInfo zoneinfo;
+        zoneinfo = polychrome->GetZoneConfig(channel_idx); 
+        zones_info.push_back(zoneinfo);
+    }
+
+}
+
+void RGBController_PolychromeUSB::ResizeZone(int zone, int new_size)
+{
+     unsigned char zonecfg[ASROCK_USB_MAX_ZONES];
+
+    /*---------------------------------------------------------*\
+    | This device does not currently support resizing zones     |
+    \*---------------------------------------------------------*/
+    zones[zone].leds_count = (unsigned char) new_size;
+
+    memset(zonecfg, POLYCHROME_USB_ZONE_UNAVAILABLE, ASROCK_USB_MAX_ZONES);
+
+    for(unsigned int i = 0; i < zones.size(); i++)
+    {
+        zonecfg[i]=zones[i].leds_count;
+    }
+
+    unsigned char zonecmd = POLYCHROME_USB_LEDCOUNT_CFG;
+    // WriteHeader(zonecmd, zonecfg);
+}
+
+void RGBController_PolychromeUSB::DeviceUpdateLEDs()
+{
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        unsigned char set_mode = zones_info[zone_idx].mode;
+
+        if (set_mode>modes.size())
+        {
+            set_mode = active_mode;
+        }
+
+        polychrome->WriteZone(zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);
+    }
+}
+
+void RGBController_PolychromeUSB::UpdateZoneLEDs(int zone)
+{
+    unsigned char set_mode=zones_info[zone].mode;
+
+    if(set_mode > modes.size())
+    {
+        set_mode = active_mode;
+    }
+
+    polychrome->WriteZone(zone, set_mode, zones_info[zone].speed, zones[zone].colors[0], false);
+}
+
+void RGBController_PolychromeUSB::UpdateSingleLED(int led)
+{
+    unsigned int  channel  = leds[led].value;
+    unsigned char set_mode = zones_info[channel].mode;
+
+    if(set_mode > modes.size())
+    {
+        set_mode = active_mode;
+    }
+
+    polychrome->WriteZone(channel, set_mode, zones_info[channel].speed, zones[channel].colors[0], false);
+}
+
+unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)
+{
+    int dev_mode;
+    int color_mode = MODE_COLORS_PER_LED;
+
+    dev_mode    = polychrome->GetZoneConfig(zone).mode;
+    active_mode = dev_mode;
+
+    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++)
+    {
+        if(zones[zone_idx].leds_count > 0)
+        {
+            unsigned char set_mode      =(unsigned char) modes[active_mode].value;
+            zones_info[zone_idx].mode   =(unsigned char) modes[active_mode].value;
+            zones_info[zone_idx].speed  =(unsigned char) modes[active_mode].speed;
+            
+            if(set_mode > modes.size())
+            {
+                set_mode = active_mode;                    
+            }
+
+            polychrome->WriteZone(zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);
+        }
+    }
+}

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h

@@ -0,0 +1,37 @@
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeUSB.h      |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock Polychrome USB Driver             |
+|                                           |
+|  Ed Kambulow (Dredvard) 12/26/2020        |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "ASRockPolychromeUSBController.h"
+
+class RGBController_PolychromeUSB : public RGBController
+{
+public:
+    RGBController_PolychromeUSB(PolychromeUSBController* polychrome_ptr);
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    bool                            initializedMode;
+    PolychromeUSBController*        polychrome;
+    std::vector<PolychromeZoneInfo> zones_info;
+
+    unsigned char GetDeviceMode(unsigned char zone);
+};

Controllers/AsusAuraCoreController/AsusAuraCoreController.cpp

@@ -10,15 +10,26 @@
 #include "AsusAuraCoreController.h"
 #include <cstring>
 
+#define AURA_CORE_MAX_MESSAGE_SIZE  64
+
 AuraCoreController::AuraCoreController(hid_device* dev_handle, const char* path)
 {
-    dev         = dev_handle;
-    location    = path;
+    dev                         = dev_handle;
+    location                    = path;
+
+    aura_device.aura_type       = AURA_CORE_DEVICE_UNKNOWN;
+    aura_device.buff_size       = 0;
+    aura_device.report_id       = 0x5D;
+    aura_device.num_leds        = 4;
+    aura_device.supports_direct = false;
+
+    IdentifyDevice();
+    Handshake();
 }
 
 AuraCoreController::~AuraCoreController()
 {
-
+    hid_close(dev);
 }
 
 std::string AuraCoreController::GetDeviceLocation()
@@ -42,26 +53,29 @@ void AuraCoreController::SendBrightness
     unsigned char   brightness
     )
 {
-    unsigned char usb_buf[17];
+    unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
 
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
+    if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
+    {
+        /*-----------------------------------------------------*\
+        | Zero out buffer                                       |
+        \*-----------------------------------------------------*/
+        memset(usb_buf, 0x00, sizeof(usb_buf));
 
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x5A;
-    usb_buf[0x01]   = AURA_CORE_COMMAND_BRIGHTNESS;
-    usb_buf[0x02]   = 0xC5;
-    usb_buf[0x03]   = 0xC4;
-    usb_buf[0x04]   = brightness;
+        /*-----------------------------------------------------*\
+        | Set up message packet                                 |
+        \*-----------------------------------------------------*/
+        usb_buf[0x00]   = 0x5A;
+        usb_buf[0x01]   = AURA_CORE_COMMAND_BRIGHTNESS;
+        usb_buf[0x02]   = 0xC5;
+        usb_buf[0x03]   = 0xC4;
+        usb_buf[0x04]   = brightness;
 
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, usb_buf, 17);
+        /*-----------------------------------------------------*\
+        | Send packet                                           |
+        \*-----------------------------------------------------*/
+        hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
+    }
 }
 
 void AuraCoreController::SendUpdate
@@ -69,60 +83,280 @@ void AuraCoreController::SendUpdate
     unsigned char   zone,
     unsigned char   mode,
     unsigned char   speed,
+    unsigned char   dir,
     unsigned char   red,
     unsigned char   green,
     unsigned char   blue
     )
 {
-    unsigned char usb_buf[17];
+    unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
 
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
+    if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
+    {
+        if(aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
+        {
+            zone += 1;
+        }
 
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x5D;
-    usb_buf[0x01]   = AURA_CORE_COMMAND_UPDATE;
-    usb_buf[0x02]   = zone;
-    usb_buf[0x03]   = mode;
-    usb_buf[0x04]   = red;
-    usb_buf[0x05]   = green;
-    usb_buf[0x06]   = blue;
-    usb_buf[0x07]   = speed;
+        /*-----------------------------------------------------*\
+        | Zero out buffer                                       |
+        \*-----------------------------------------------------*/
+        memset(usb_buf, 0x00, sizeof(usb_buf));
 
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, usb_buf, 17);
+        /*-----------------------------------------------------*\
+        | Set up message packet                                 |
+        \*-----------------------------------------------------*/
+        usb_buf[0x00]   = aura_device.report_id;
+        usb_buf[0x01]   = AURA_CORE_COMMAND_UPDATE;
+        usb_buf[0x02]   = zone;
+        usb_buf[0x03]   = mode;
+        usb_buf[0x04]   = red;
+        usb_buf[0x05]   = green;
+        usb_buf[0x06]   = blue;
+        usb_buf[0x07]   = speed;
+        usb_buf[0x08]   = dir;
+
+        /*-----------------------------------------------------*\
+        | Send packet                                           |
+        \*-----------------------------------------------------*/
+        hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
+    }
 }
 
 void AuraCoreController::SendSet()
 {
-    unsigned char usb_buf[17];
+    unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
 
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
+    if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
+    {
+        /*-----------------------------------------------------*\
+        | Zero out buffer                                       |
+        \*-----------------------------------------------------*/
+        memset(usb_buf, 0x00, sizeof(usb_buf));
 
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x5D;
-    usb_buf[0x01]   = AURA_CORE_COMMAND_SET;
+        /*-----------------------------------------------------*\
+        | Set up message packet                                 |
+        \*-----------------------------------------------------*/
+        usb_buf[0x00]   = aura_device.report_id;
+        usb_buf[0x01]   = AURA_CORE_COMMAND_SET;
 
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, usb_buf, 17);
+        /*-----------------------------------------------------*\
+        | Send packet                                           |
+        \*-----------------------------------------------------*/
+        hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
+    }
 }
 
 void AuraCoreController::SendApply()
 {
-    unsigned char usb_buf[17];
+    unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
+
+    if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
+    {
+        /*-----------------------------------------------------*\
+        | Zero out buffer                                       |
+        \*-----------------------------------------------------*/
+        memset(usb_buf, 0x00, sizeof(usb_buf));
+
+        /*-----------------------------------------------------*\
+        | Set up message packet                                 |
+        \*-----------------------------------------------------*/
+        usb_buf[0x00]   = aura_device.report_id;
+        usb_buf[0x01]   = AURA_CORE_COMMAND_APPLY;
+
+        /*-----------------------------------------------------*\
+        | Send packet                                           |
+        \*-----------------------------------------------------*/
+        hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
+    }
+}
+
+void AuraCoreController::InitDirectMode()
+{
+    unsigned char   usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
+    unsigned char   msg_num   = 0;
+    int             led_count = aura_device.num_leds;
+
+    if(aura_device.supports_direct)
+    {
+        /*-----------------------------------------------------*\
+        | Zero out buffer                                       |
+        \*-----------------------------------------------------*/
+        memset(usb_buf, 0x00, sizeof(usb_buf));
+
+        /*-----------------------------------------------------*\
+        | Set up message packet                                 |
+        \*-----------------------------------------------------*/
+        usb_buf[0x00]   = aura_device.report_id;
+        usb_buf[0x01]   = AURA_CORE_COMMAND_DIRECT;
+        usb_buf[0x02]   = 0xD0;
+
+        /*-----------------------------------------------------*\
+        | Send packet                                           |
+        \*-----------------------------------------------------*/
+        hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
+
+        while(led_count > 0)
+        {
+            /*-----------------------------------------------------*\
+            | Set up second message packet                         |
+            \*-----------------------------------------------------*/
+            usb_buf[0x03]   = 0x01;
+            usb_buf[0x04]   = 0x02;
+            usb_buf[0x05]   = 0x00;
+            usb_buf[0x06]   = msg_num++;
+            usb_buf[0x07]   = (led_count > aura_device.max_leds_per_message) ? aura_device.max_leds_per_message : led_count;
+            usb_buf[0x08]   = 0x00;
+
+            /*-----------------------------------------------------*\
+            | Send packet 2                                         |
+            \*-----------------------------------------------------*/
+            hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
+
+            led_count -= aura_device.max_leds_per_message;
+        }
+    }
+}
+
+void AuraCoreController::UpdateDirect(std::vector<AuraColor>& color_set)
+{
+    unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
+    unsigned char msg_num       = 0;
+    unsigned char color_index   = 0;
+    unsigned char set_count     = 0;
+    int           led_count     = aura_device.num_leds;
+
+    if(aura_device.supports_direct)
+    {
+        while(led_count > 0)
+        {
+            unsigned char msg_index = 0x09;
+
+            /*-----------------------------------------------------*\
+            | Zero out buffer                                       |
+            \*-----------------------------------------------------*/
+            memset(usb_buf, 0x00, sizeof(usb_buf));
+
+            /*-----------------------------------------------------*\
+            | Set up message packet                                 |
+            \*-----------------------------------------------------*/
+            usb_buf[0x00]   = aura_device.report_id;
+            usb_buf[0x01]   = AURA_CORE_COMMAND_DIRECT;
+            usb_buf[0x02]   = 0xD0;
+            usb_buf[0x03]   = 0x01;
+            usb_buf[0x04]   = 0x02;
+            usb_buf[0x05]   = 0x00;
+            usb_buf[0x06]   = msg_num++;
+            usb_buf[0x07]   = (led_count > aura_device.max_leds_per_message) ? aura_device.max_leds_per_message : led_count;
+            usb_buf[0x08]   = 0x00;
+
+            set_count = 0;
+
+            while( (msg_index < sizeof(usb_buf)                 ) &&
+                   (led_count > 0                               ) &&
+                   (set_count < aura_device.max_leds_per_message)    )
+            {
+                if(color_index < color_set.size())
+                {
+                    usb_buf[msg_index++] = color_set[color_index].red;
+                    usb_buf[msg_index++] = color_set[color_index].green;
+                    usb_buf[msg_index++] = color_set[color_index].blue;
+                }
+                else
+                {
+                    usb_buf[msg_index++] = 0;
+                    usb_buf[msg_index++] = 0;
+                    usb_buf[msg_index++] = 0;
+                }
+
+                led_count--;
+                color_index++;
+                set_count++;
+            }
+
+            /*-----------------------------------------------------*\
+            | Send packet                                           |
+            \*-----------------------------------------------------*/
+            hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
+        }
+    }
+}
+
+void AuraCoreController::IdentifyDevice()
+{
+    unsigned char   usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
+    int             num_bytes       = 0;
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | First, attempt to read the report from the Keyboard   |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = aura_device.report_id;
+
+    num_bytes = hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Currently, there is no need to attempt to read the    |
+    | returned data.  If the device responded,to the report,|
+    | we're good.                                           |
+    \*-----------------------------------------------------*/
+    if(num_bytes > 0)
+    {
+        aura_device.aura_type                   = AURA_CORE_DEVICE_KEYBOARD;
+        aura_device.buff_size                   = 17;
+        aura_device.report_id                   = 0x5D;
+        aura_device.num_leds                    = 4;
+        aura_device.supports_direct             = false;
+    }
+    else if(num_bytes == -1)
+    {
+        /*-------------------------------------------------*\
+        | First, attempt to read the report from the        |
+        | Keyboard                                          |
+        \*-------------------------------------------------*/
+        usb_buf[0]                              = 0x5E;
+        num_bytes                               = hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
+
+        if(num_bytes > 0)
+        {
+            /*---------------------------------------------*\
+            | Currently, there is no need to attempt to     |
+            | read the returned data.  If the device        |
+            | responded,to the report, we're good.          |
+            \*---------------------------------------------*/
+            aura_device.aura_type               = AURA_CORE_DEVICE_GA15DH;
+            aura_device.buff_size               = 64;
+            aura_device.report_id               = 0x5E;
+            aura_device.num_leds                = 20;
+            aura_device.max_leds_per_message    = 16;
+            aura_device.supports_direct         = true;
+        }
+    }
+}
+
+void AuraCoreController::Handshake()
+{
+    unsigned char     usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
+
+
+    if(aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
+    {
+        usb_buf[0] = 0x5E;
+        SendIdString();
+        hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
+        SendQuery();
+        hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
+    }
+}
+
+void AuraCoreController::SendIdString()
+{
+    unsigned char   usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
+    const char      id[] = "ASUS Tech.Inc.";
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -132,11 +366,40 @@ void AuraCoreController::SendApply()
     /*-----------------------------------------------------*\
     | Set up message packet                                 |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x5D;
-    usb_buf[0x01]   = AURA_CORE_COMMAND_APPLY;
+    usb_buf[0x00]   = aura_device.report_id;
+
+    /*-----------------------------------------------------*\
+    | Copy in string data                                   |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x01], id, sizeof(id));
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, usb_buf, 17);
+    hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
+}
+
+void AuraCoreController::SendQuery()
+{
+    unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = aura_device.report_id;
+    usb_buf[0x01]   = 0x05;
+    usb_buf[0x02]   = 0x20;
+    usb_buf[0x03]   = 0x31;
+    usb_buf[0x04]   = 0x00;
+    usb_buf[0x05]   = 0x10;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
 }

Controllers/AsusAuraCoreController/AsusAuraCoreController.h

@@ -14,11 +14,24 @@
 
 #pragma once
 
+enum AuraCoreDeviceType
+{
+    AURA_CORE_DEVICE_UNKNOWN            = 0,
+    AURA_CORE_DEVICE_KEYBOARD           = 1,
+    AURA_CORE_DEVICE_GA15DH             = 2
+};
+
 enum
 {
-    AURA_CORE_MODE_STATIC               = 0,        /* Static color mode                    */
-    AURA_CORE_MODE_BREATHING            = 1,        /* Breathing effect mode                */
-    AURA_CORE_MODE_SPECTRUM_CYCLE       = 2,        /* Spectrum Cycle mode                  */
+    AURA_CORE_MODE_STATIC               =   0,      /* Static color mode                    */
+    AURA_CORE_MODE_BREATHING            =   1,      /* Breathing effect mode                */
+    AURA_CORE_MODE_SPECTRUM_CYCLE       =   2,      /* Spectrum Cycle mode                  */
+    AURA_CORE_MODE_RAINBOW              =   3,      /* Rainbow mode                         */
+    AURA_CORE_MODE_STROBE               =  10,      /* Strobe mode                          */
+    AURA_CORE_MODE_COMET                =  11,      /* Comet mode                           */
+    AURA_CORE_MODE_FLASHNDASH           =  12,      /* Flash & Dash mode                    */
+    AURA_CORE_MODE_IRRADIATION          =  17,      /* Irradiation mode                     */
+    AURA_CORE_MODE_DIRECT               = 255       /* Not a real mode - but need a way to differentiate */
 };
 
 enum
@@ -27,6 +40,7 @@ enum
     AURA_CORE_COMMAND_SET               = 0xB5,     /* Set command                          */
     AURA_CORE_COMMAND_APPLY             = 0xB4,     /* Apply command                        */
     AURA_CORE_COMMAND_BRIGHTNESS        = 0xBA,     /* Brightness command                   */
+    AURA_CORE_COMMAND_DIRECT            = 0xBC      /* Set LEDs directly                    */
 };
 
 enum
@@ -45,9 +59,28 @@ enum
     AURA_CORE_SPEED_FAST                = 0xF5,     /* Fastest speed                        */
 };
 
+struct AuraDeviceDescriptor
+{
+    AuraCoreDeviceType  aura_type;
+    unsigned char       buff_size;
+    unsigned char       report_id;
+    unsigned char       num_leds;
+    unsigned char       max_leds_per_message;
+    bool                supports_direct;
+};
+
+struct AuraColor
+{
+    unsigned char   red;
+    unsigned char   green;
+    unsigned char   blue;
+};
+
 class AuraCoreController
 {
 public:
+    AuraDeviceDescriptor    aura_device;
+
     AuraCoreController(hid_device* dev_handle, const char* path);
     ~AuraCoreController();
 
@@ -64,6 +97,7 @@ public:
                 unsigned char   zone,
                 unsigned char   mode,
                 unsigned char   speed,
+                unsigned char   dir,
                 unsigned char   red,
                 unsigned char   green,
                 unsigned char   blue
@@ -73,8 +107,17 @@ public:
 
     void    SendApply();
 
+    void    InitDirectMode();
+
+    void    UpdateDirect(std::vector<AuraColor>& color_set);
+
 private:
     hid_device*             dev;
     std::string             location;
 
+    void    IdentifyDevice();
+    void    Handshake();
+    void    SendIdString();
+    void    SendQuery();
+
 };

Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp

@@ -19,10 +19,13 @@ void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string&)
     hid_device* dev = hid_open_path(info->path);
     if( dev )
     {
-        AuraCoreController* controller = new AuraCoreController(dev, info->path);
+        AuraCoreController*     controller     = new AuraCoreController(dev, info->path);
         RGBController_AuraCore* rgb_controller = new RGBController_AuraCore(controller);
         // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        if(rgb_controller->type != DEVICE_TYPE_UNKNOWN)
+        {
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
     }
 }
 

Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.cpp

@@ -10,14 +10,33 @@
 
 RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* aura_ptr)
 {
-    aura = aura_ptr;
+    aura        = aura_ptr;
 
-    name        = "ASUS Aura Core";
+    name        = "ASUS Aura Core Device";
+    vendor      = "ASUS";
+    location    = aura->GetDeviceLocation();
+    serial      = aura->GetSerialString();    
+    description = "ASUS Aura Core Device";
+    type        = DEVICE_TYPE_UNKNOWN;
+
+    if(aura->aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
+    {
+        SetupKeyboard();
+    }
+    else if(aura->aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
+    {
+        SetupGA15DH();
+    }
+
+    SetupZones();
+}
+
+void RGBController_AuraCore::SetupKeyboard()
+{
+    name        = "ASUS Aura Keyboard";
     vendor      = "ASUS";
     type        = DEVICE_TYPE_KEYBOARD;
     description = "ASUS Aura Core Device";
-    location    = aura->GetDeviceLocation();
-    serial      = aura->GetSerialString();
 
     mode Static;
     Static.name       = "Static";
@@ -39,25 +58,142 @@ RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* aura_ptr)
     ColorCycle.flags      = 0;
     ColorCycle.color_mode = MODE_COLORS_NONE;
     modes.push_back(ColorCycle);
+}
 
-    SetupZones();
+void RGBController_AuraCore::SetupGA15DH()
+{
+    name        = "ASUS Aura GA15DH";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_LEDSTRIP;
+    description = "ASUS Aura Core Device";
+
+    mode Static;
+    Static.name             = "Static";
+    Static.value            = AURA_CORE_MODE_STATIC;
+    Static.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min       = 1;
+    Static.colors_max       = 1;
+    Static.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name          = "Breathing";
+    Breathing.value         = AURA_CORE_MODE_BREATHING;
+    Breathing.flags         = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Breathing.speed_min     = AURA_CORE_SPEED_SLOW;
+    Breathing.speed_max     = AURA_CORE_SPEED_FAST;
+    Breathing.speed         = AURA_CORE_SPEED_NORMAL;
+    Breathing.colors_min    = 1;
+    Breathing.colors_max    = 2;
+    Breathing.color_mode    = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors.resize(2);
+    modes.push_back(Breathing);
+
+    mode ColorCycle;
+    ColorCycle.name         = "Color Cycle";
+    ColorCycle.value        = AURA_CORE_MODE_SPECTRUM_CYCLE;
+    ColorCycle.flags        = MODE_FLAG_HAS_SPEED;
+    ColorCycle.speed_min    = AURA_CORE_SPEED_SLOW;
+    ColorCycle.speed_max    = AURA_CORE_SPEED_FAST;
+    ColorCycle.speed        = AURA_CORE_SPEED_NORMAL;
+    ColorCycle.color_mode   = MODE_COLORS_NONE;
+    modes.push_back(ColorCycle);
+
+    mode Rainbow;
+    Rainbow.name            = "Rainbow";
+    Rainbow.value           = AURA_CORE_MODE_RAINBOW;
+    Rainbow.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    Rainbow.speed_min       = AURA_CORE_SPEED_SLOW;
+    Rainbow.speed_max       = AURA_CORE_SPEED_FAST;
+    Rainbow.speed           = AURA_CORE_SPEED_NORMAL;
+    Rainbow.direction       = MODE_DIRECTION_RIGHT;
+    Rainbow.color_mode      = MODE_COLORS_NONE;
+    modes.push_back(Rainbow);
+
+    mode Strobe;
+    Strobe.name             = "Strobe";
+    Strobe.value            = AURA_CORE_MODE_STROBE;
+    Strobe.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Strobe.colors_min       = 1;
+    Strobe.colors_max       = 1;
+    Strobe.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    Strobe.colors.resize(1);
+    modes.push_back(Strobe);
+
+    mode Comet;
+    Comet.name              = "Comet";
+    Comet.value             = AURA_CORE_MODE_COMET;
+    Comet.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Comet.colors_min        = 1;
+    Comet.colors_max        = 1;
+    Comet.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Comet.colors.resize(1);
+    modes.push_back(Comet);
+
+    mode Flash;
+    Flash.name              = "Flash & Dash";
+    Flash.value             = AURA_CORE_MODE_FLASHNDASH;
+    Flash.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Flash.colors_min        = 1;
+    Flash.colors_max        = 1;
+    Flash.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Flash.colors.resize(1);
+    modes.push_back(Flash);
+
+    mode Irradiation;
+    Irradiation.name        = "Irradiation";
+    Irradiation.value       = AURA_CORE_MODE_IRRADIATION;
+    Irradiation.flags       = 0;
+    Irradiation.color_mode  = MODE_COLORS_NONE;
+    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;
+    modes.push_back(Static);
+}
+
+RGBController_AuraCore::~RGBController_AuraCore()
+{
+    delete aura;
 }
 
 void RGBController_AuraCore::SetupZones()
 {
-    zone Keyboard;
-    Keyboard.name       = "Keyboard";
-    Keyboard.type       = ZONE_TYPE_SINGLE;
-    Keyboard.leds_min   = 4;
-    Keyboard.leds_max   = 4;
-    Keyboard.leds_count = 4;
-    Keyboard.matrix_map = NULL;
-    zones.push_back(Keyboard);
+    zone auraZone;
 
-    for(unsigned int led_idx = 0; led_idx < Keyboard.leds_count; led_idx++)
+    if(aura->aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
+    {
+        auraZone.name       = "Keyboard";
+        auraZone.type       = ZONE_TYPE_SINGLE;
+        auraZone.leds_min   = 4;
+        auraZone.leds_max   = 4;
+        auraZone.leds_count = 4;
+        auraZone.matrix_map = NULL;
+    }
+    else if(aura->aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
+    {
+        auraZone.name       = "GA15DH";
+        auraZone.type       = ZONE_TYPE_LINEAR;
+        auraZone.leds_min   = 20;
+        auraZone.leds_max   = 20;
+        auraZone.leds_count = 20;
+        auraZone.matrix_map = NULL;
+    }
+    else
+    {
+        auraZone.leds_count = 0;
+    }
+
+    zones.push_back(auraZone);
+
+    for(unsigned int led_idx = 0; led_idx < auraZone.leds_count; led_idx++)
     {
         led KeyLED;
-        KeyLED.name = "Keyboard LED ";
+        KeyLED.name = auraZone.name + " ";
         KeyLED.name.append(std::to_string(led_idx + 1));
         leds.push_back(KeyLED);
     }
@@ -79,23 +215,88 @@ void RGBController_AuraCore::DeviceUpdateLEDs()
 
 void RGBController_AuraCore::UpdateZoneLEDs(int /*zone*/)
 {
-    for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
+    if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
     {
-        UpdateSingleLED(led_idx);
+        std::vector<AuraColor>  aura_colors;
+        std::vector<RGBColor>&  color_set = colors;
+
+        if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+        {
+            color_set = modes[active_mode].colors;
+        }
+
+        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
+        {
+            AuraColor new_color;
+
+            new_color.red   = RGBGetRValue(color_set[led_idx]);
+            new_color.green = RGBGetGValue(color_set[led_idx]);
+            new_color.blue  = RGBGetBValue(color_set[led_idx]);
+
+            aura_colors.push_back(new_color);
+        }
+
+        aura->UpdateDirect(aura_colors);
+    }
+    else if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
+    {
+        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
+        {
+            UpdateSingleLED(led_idx);
+        }
+    }
+    else
+    {
+        UpdateSingleLED(0);
     }
 }
 
 void RGBController_AuraCore::UpdateSingleLED(int led)
 {
+    unsigned char speed = 0xFF;
+    unsigned char red   = 0;
+    unsigned char green = 0;
+    unsigned char blue  = 0;
+    unsigned char dir   = 0;
+    mode& curr_mode     = modes[active_mode];
+
+    if(curr_mode.color_mode == MODE_COLORS_PER_LED)
+    {
+        red     = RGBGetRValue(colors[led]);
+        green   = RGBGetGValue(colors[led]);
+        blue    = RGBGetBValue(colors[led]);
+    }
+    else if(curr_mode.color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        red     = RGBGetRValue(curr_mode.colors[led]);
+        green   = RGBGetGValue(curr_mode.colors[led]);
+        blue    = RGBGetBValue(curr_mode.colors[led]);
+    }
+
+    if(curr_mode.flags & MODE_FLAG_HAS_SPEED)
+    {
+        speed   = curr_mode.speed;
+    }
+
+    if(curr_mode.flags & MODE_FLAG_HAS_DIRECTION_LR)
+    {
+        if(curr_mode.direction == MODE_DIRECTION_RIGHT)
+        {
+            dir = 1;
+        }
+    }
+
     aura->SendUpdate
             (
-            led + 1,
-            modes[active_mode].value,
-            AURA_CORE_SPEED_NORMAL,
-            RGBGetRValue(colors[led]),
-            RGBGetGValue(colors[led]),
-            RGBGetBValue(colors[led])
+            led,
+            curr_mode.value,
+            speed,
+            dir,
+            red,
+            green,
+            blue
             );
+
     aura->SendSet();
     aura->SendApply();
 }
@@ -107,5 +308,12 @@ void RGBController_AuraCore::SetCustomMode()
 
 void RGBController_AuraCore::DeviceUpdateMode()
 {
-    DeviceUpdateLEDs();
+    if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
+    {
+        aura->InitDirectMode();
+    }
+    else
+    {
+        DeviceUpdateLEDs();
+    }
 }

Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.h

@@ -15,7 +15,10 @@ class RGBController_AuraCore : public RGBController
 {
 public:
     RGBController_AuraCore(AuraCoreController* aura_ptr);
+    ~RGBController_AuraCore();
 
+    void        SetupKeyboard();
+    void        SetupGA15DH();
     void        SetupZones();
 
     void        ResizeZone(int zone, int new_size);
@@ -29,5 +32,4 @@ public:
 
 private:
     AuraCoreController* aura;
-
 };

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -11,24 +11,35 @@
 #include "RGBController.h"
 #include "RGBController_AsusAuraGPU.h"
 #include "i2c_smbus.h"
+#include "pci_ids.h"
 #include <vector>
 #include <stdio.h>
 #include <stdlib.h>
 
 using namespace std::chrono_literals;
 
-/*-------------------------------------------------------------*\
-| This list contains the available I2C addresses for Aura GPUs  |
-\*-------------------------------------------------------------*/
-#define AURA_GPU_ADDRESS_COUNT 3
-
-static const unsigned char aura_gpu_addresses[] =
+typedef struct
 {
-    0x29,
-    0x2A,
-    0x60
-};
+    int             pci_vendor;
+    int             pci_device;
+    int             pci_subsystem_vendor;
+    int             pci_subsystem_device;
+    unsigned char   controller_address;
+    const char *    name;
+} gpu_pci_device;
 
+#define GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+static const gpu_pci_device device_list[] =
+{
+    { NVIDIA_VEN,       NVIDIA_GTX1060_DEV,     ASUS_SUB_VEN,       ASUS_GTX1060_STRIX,                 0x29,   "ASUS GTX 1060 Strix"               },
+    { NVIDIA_VEN,       NVIDIA_GTX1660TI_DEV,   ASUS_SUB_VEN,       ASUS_ROG_GTX1660TI_OC,              0x2A,   "ASUS ROG GTX 1660 Ti OC 6G"        },
+    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_A8G_GAMING,  0x29,   "ASUS ROG Strix GTX1080 A8G Gaming" },
+    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_GAMING,    0x29,   "ASUS ROG Strix GTX1080 Ti Gaming"  },
+    { AMD_GPU_VEN,      AMD_VEGA10_DEV,         ASUS_SUB_VEN,       ASUS_VEGA64_STRIX,                  0x29,   "ASUS Vega 64 Strix"                },
+    { AMD_GPU_VEN,      AMD_NAVI10_DEV,         ASUS_SUB_VEN,       ASUS_RX5700XT_STRIX_GAMING_OC,      0x2A,   "ASUS RX 5700XT Strix Gaming OC"    },
+    { AMD_GPU_VEN,      AMD_POLARIS_DEV,        ASUS_SUB_VEN,       ASUS_RX580_STRIX_GAMING_OC,         0x29,   "ASUS RX 580 Strix Gaming OC"       }
+};
 
 /******************************************************************************************\
 *                                                                                          *
@@ -54,7 +65,6 @@ bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char addres
 
 }   /* TestForAuraGPUController() */
 
-
 /******************************************************************************************\
 *                                                                                          *
 *   DetectAuraGPUControllers                                                               *
@@ -63,26 +73,30 @@ bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char addres
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses)
 {
     AuraGPUController* new_aura_gpu;
     RGBController_AuraGPU* new_controller;
 
     for (unsigned int bus = 0; bus < busses.size(); bus++)
     {
-        // Add Aura-enabled GPU controllers
-        for (unsigned int address_list_idx = 0; address_list_idx < AURA_GPU_ADDRESS_COUNT; address_list_idx++)
+        for(unsigned int dev_idx = 0; dev_idx < GPU_NUM_DEVICES; dev_idx++)
         {
-            if (TestForAsusAuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]))
+            if(busses[bus]->pci_vendor           == device_list[dev_idx].pci_vendor           &&
+               busses[bus]->pci_device           == device_list[dev_idx].pci_device           &&
+               busses[bus]->pci_subsystem_vendor == device_list[dev_idx].pci_subsystem_vendor &&
+               busses[bus]->pci_subsystem_device == device_list[dev_idx].pci_subsystem_device)
             {
-                new_aura_gpu = new AuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]);
-                new_controller = new RGBController_AuraGPU(new_aura_gpu);
-                rgb_controllers.push_back(new_controller);
+                if (TestForAsusAuraGPUController(busses[bus], device_list[dev_idx].controller_address))
+                {
+                    new_aura_gpu         = new AuraGPUController(busses[bus], device_list[dev_idx].controller_address);
+                    new_controller       = new RGBController_AuraGPU(new_aura_gpu);
+                    new_controller->name = device_list[dev_idx].name;
+                    ResourceManager::get()->RegisterRGBController(new_controller);
+                }
             }
-
-            std::this_thread::sleep_for(1ms);
         }
     }
-} /* DetectAuraGPUControllers() */
+} /* DetectAsusAuraGPUControllers() */
 
 REGISTER_I2C_DETECTOR("ASUS Aura GPU", DetectAsusAuraGPUControllers);

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp

@@ -100,6 +100,11 @@ RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * aura_gpu_ptr)
     active_mode = GetDeviceMode();
 }
 
+RGBController_AuraGPU::~RGBController_AuraGPU()
+{
+    delete aura_gpu;
+}
+
 void RGBController_AuraGPU::SetupZones()
 {
     /*---------------------------------------------------------*\

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.h

@@ -15,6 +15,7 @@ class RGBController_AuraGPU : public RGBController
 {
 public:
     RGBController_AuraGPU(AuraGPUController* aura_gpu_ptr);
+    ~RGBController_AuraGPU();
 
     void        SetupZones();
 

Controllers/AsusAuraSMBusController/AsusAuraSMBusControllerDetect.cpp

@@ -110,7 +110,7 @@ bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char addr
 
 /******************************************************************************************\
 *                                                                                          *
-*   DetectAuraSMBusControllers                                                                  *
+*   DetectAuraSMBusControllers                                                             *
 *                                                                                          *
 *       Detect Aura controllers on the enumerated I2C busses.  Searches for Aura-enabled   *
 *       RAM at 0x77 and tries to initialize their slot addresses, then searches for them   *
@@ -122,7 +122,7 @@ bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char addr
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses)
 {
     AuraSMBusController* new_aura;
     RGBController_AuraSMBus* new_controller;
@@ -171,7 +171,7 @@ void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, s
                 {
                     new_aura = new AuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]);
                     new_controller = new RGBController_AuraSMBus(new_aura);
-                    rgb_controllers.push_back(new_controller);
+                    ResourceManager::get()->RegisterRGBController(new_controller);
                 }
 
                 std::this_thread::sleep_for(1ms);
@@ -187,7 +187,7 @@ void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, s
                 {
                     new_aura = new AuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]);
                     new_controller = new RGBController_AuraSMBus(new_aura);
-                    rgb_controllers.push_back(new_controller);
+                    ResourceManager::get()->RegisterRGBController(new_controller);
                 }
 
                 std::this_thread::sleep_for(1ms);

Controllers/AsusAuraUSBController/AsusAuraKeyboardController.cpp

@@ -0,0 +1,110 @@
+/*-----------------------------------------*\
+|  AsusAuraKeyboardController.cpp           |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 3/19/2020   |
+\*-----------------------------------------*/
+
+#include "AsusAuraKeyboardController.h"
+
+#include <cstring>
+
+AuraKeyboardController::AuraKeyboardController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+AuraKeyboardController::~AuraKeyboardController()
+{
+    hid_close(dev);
+}
+
+std::string AuraKeyboardController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AuraKeyboardController::GetSerialString()
+{
+    wchar_t serial_string[128];
+    hid_get_serial_number_string(dev, serial_string, 128);
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+void AuraKeyboardController::SendDirect
+    (
+    unsigned char       frame_count,
+    unsigned char *     frame_data
+    )
+{
+    unsigned char usb_buf[65];
+    unsigned int  packet_count = frame_count / 15 + (((frame_count % 15) == 0) ? 0 : 1);
+    unsigned int  total_frame_idx = 0;
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0xC0;
+    usb_buf[0x02]   = 0x81;
+    usb_buf[0x03]   = packet_count * 15;
+    usb_buf[0x04]   = 0x00;
+
+    /*-----------------------------------------------------*\
+    | Copy in frame data and send packets until all data    |
+    | has been sent                                         |
+    \*-----------------------------------------------------*/
+    for(unsigned int packet_idx = 0; packet_idx < packet_count; packet_idx++)
+    {
+        unsigned int packet_data_size = 15 * 4;
+
+        if((frame_count - total_frame_idx) < 15)
+        {
+            packet_data_size = (frame_count - total_frame_idx) * 4;
+            memset(&usb_buf[0x05 + packet_data_size], 0xFF, (15*4) - packet_data_size);
+        }
+
+        memcpy(&usb_buf[0x05], &frame_data[packet_idx * 15 * 4], packet_data_size);
+
+        /*-----------------------------------------------------*\
+        | Send packet                                           |
+        \*-----------------------------------------------------*/
+        hid_write(dev, usb_buf, 65);
+
+        /*-----------------------------------------------------*\
+        | Decrement remaining frame count                       |
+        \*-----------------------------------------------------*/
+        usb_buf[0x03] -= 0x0F;
+        total_frame_idx += 0x0F;
+    }
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0xC0;
+    usb_buf[0x02]   = 0x81;
+    usb_buf[0x03]   = 0x90;
+
+    /*-----------------------------------------------------*\
+    | Read to apply                                         |
+    \*-----------------------------------------------------*/
+    hid_read(dev,usb_buf, 65);
+}

Controllers/AsusAuraUSBController/AsusAuraKeyboardController.h

@@ -0,0 +1,36 @@
+/*-----------------------------------------*\
+|  AsusAuraKeyboardController.h             |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 3/19/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+class AuraKeyboardController
+{
+public:
+    AuraKeyboardController(hid_device* dev_handle, const char* path);
+    virtual ~AuraKeyboardController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void SendDirect
+        (
+        unsigned char       frame_count,
+        unsigned char *     frame_data
+        );
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+};

Controllers/AsusAuraUSBController/AsusAuraMainboardController.cpp

@@ -62,8 +62,6 @@ void AuraMainboardController::SetChannelLEDs(unsigned char channel, RGBColor * c
 
         leds_sent += leds_to_send;
     }
-
-    SendCommit();
 }
 
 void AuraMainboardController::SetMode
@@ -104,11 +102,13 @@ void AuraMainboardController::SetMode
         channel,
         start_led,
         device_info[channel].num_leds,
-        led_data,
-        device_info[channel].device_type == AuraDeviceType::FIXED
+        led_data
     );
+}
 
-    SendCommit();
+unsigned short AuraMainboardController::GetMask(int start, int size)
+{
+    return(((1 << size) - 1) << start);
 }
 
 void AuraMainboardController::SendEffect
@@ -145,11 +145,11 @@ void AuraMainboardController::SendColor
     unsigned char   channel,
     unsigned char   start_led,
     unsigned char   led_count,
-    unsigned char*  led_data,
-    bool            fixed
+    unsigned char*  led_data
     )
 {
-    unsigned char usb_buf[65];
+    unsigned short  mask = GetMask(start_led, led_count);
+    unsigned char   usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -161,8 +161,8 @@ void AuraMainboardController::SendColor
     \*-----------------------------------------------------*/
     usb_buf[0x00]   = 0xEC;
     usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_EFFECT_COLOR;
-    usb_buf[0x02]   = channel;
-    usb_buf[0x03]   = fixed ? 0xFF : 0x00;
+    usb_buf[0x02]   = mask >> 8;
+    usb_buf[0x03]   = mask & 0xff;
     usb_buf[0x04]   = 0x00;
 
     /*-----------------------------------------------------*\
@@ -196,4 +196,4 @@ void AuraMainboardController::SendCommit()
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
-}
+}

Controllers/AsusAuraUSBController/AsusAuraMainboardController.h

@@ -47,6 +47,8 @@ public:
 private:
     unsigned int mode;
 
+    unsigned short GetMask(int start, int size);
+    
     void SendEffect
         (
         unsigned char   channel,
@@ -58,8 +60,7 @@ private:
         unsigned char   channel,
         unsigned char   start_led,
         unsigned char   led_count,
-        unsigned char*  led_data,
-        bool            fixed
+        unsigned char*  led_data
         );
 
     void SendCommit();

Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp

@@ -19,7 +19,7 @@ AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* pat
 
 AuraMouseController::~AuraMouseController()
 {
-
+    hid_close(dev);
 }
 
 std::string AuraMouseController::GetDeviceLocation()

Controllers/AsusAuraUSBController/AsusAuraUSBController.cpp

@@ -22,9 +22,8 @@ AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path)
 
 AuraUSBController::~AuraUSBController()
 {
-
+    hid_close(dev);
 }
-
 unsigned int AuraUSBController::GetChannelCount()
 {
     return(device_info.size());
@@ -95,11 +94,9 @@ void AuraUSBController::GetConfigTable()
         }
     }
     else
-    {
-        if(dev)
-        {
-            hid_close(dev);
-        }
+    {       
+        hid_close(dev);
+
         throw std::runtime_error("Could not read config table");
     }
 }

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -1,9 +1,11 @@
 #include "Detector.h"
 #include "AsusAuraAddressableController.h"
+#include "AsusAuraKeyboardController.h"
 #include "AsusAuraMainboardController.h"
 #include "AsusAuraMouseController.h"
 #include "RGBController.h"
 #include "RGBController_AsusAuraUSB.h"
+#include "RGBController_AsusAuraKeyboard.h"
 #include "RGBController_AsusAuraMouse.h"
 #include <stdexcept>
 #include <hidapi/hidapi.h>
@@ -18,7 +20,13 @@
 #define AURA_MOTHERBOARD_2_PID                  0x1939
 #define AURA_ROG_GLADIUS_II_CORE_PID            0x18DD
 #define AURA_ROG_GLADIUS_II_PID                 0x1845
+#define AURA_ROG_STRIX_FLARE_PID                0x1875
 #define AURA_ROG_GLADIUS_II_ORIGIN_PID          0x1877
+#define AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID  0x18CD
+#define AURA_ROG_STRIX_FLARE_PNK_LTD_PID        0x18CF
+#define AURA_ROG_CHAKRAM_WIRELESS_PID           0x18E5
+#define AURA_ROG_CHAKRAM_WIRED_1_PID            0x18E3
+#define AURA_ROG_CHAKRAM_WIRED_2_PID            0x1958
 
 void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& name)
 {
@@ -52,6 +60,18 @@ void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& nam
     }
 }
 
+void DetectAsusAuraUSBKeyboards(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        AuraKeyboardController* controller = new AuraKeyboardController(dev, info->path);
+        RGBController_AuraKeyboard* rgb_controller = new RGBController_AuraKeyboard(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -64,13 +84,19 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
     }
 }
 
-REGISTER_HID_DETECTOR   ("ASUS ROG AURA Terminal",     DetectAsusAuraUSBAddressable,  AURA_USB_VID, AURA_TERMINAL_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",      DetectAsusAuraUSBAddressable,  AURA_USB_VID, AURA_ADDRESSABLE_1_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",      DetectAsusAuraUSBAddressable,  AURA_USB_VID, AURA_ADDRESSABLE_2_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",      DetectAsusAuraUSBAddressable,  AURA_USB_VID, AURA_ADDRESSABLE_3_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",      DetectAsusAuraUSBAddressable,  AURA_USB_VID, AURA_ADDRESSABLE_4_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",      DetectAsusAuraUSBMotherboards, AURA_USB_VID, AURA_MOTHERBOARD_1_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",      DetectAsusAuraUSBMotherboards, AURA_USB_VID, AURA_MOTHERBOARD_2_PID);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core",   DetectAsusAuraUSBMice,         AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID,   0, 0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II",        DetectAsusAuraUSBMice,         AURA_USB_VID, AURA_ROG_GLADIUS_II_PID,        2, 0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin", DetectAsusAuraUSBMice,         AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID, 2, 0xFF01);
+REGISTER_HID_DETECTOR   ("ASUS ROG AURA Terminal",              DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_TERMINAL_PID);
+REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_1_PID);
+REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_2_PID);
+REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_3_PID);
+REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_4_PID);
+REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",               DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_1_PID);
+REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",               DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_2_PID);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID,             0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_PID,                  2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin",          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID,           2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD",  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID,   2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",         DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRELESS_PID,            0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,             0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_2_PID,             0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                 1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,         1,  0xFF00);

Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.cpp

@@ -0,0 +1,274 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraKeyboard.cpp       |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 3/19/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusAuraKeyboard.h"
+
+//0xFFFFFFFF indicates an unused entry in matrix
+#define NA  0xFFFFFFFF
+
+static unsigned int matrix_map[6][22] =
+    { {   0,  NA,  12,  17,  22,  27,  37,  42,  48,  53,  59,  64,  67,  68,  NA,  74,  78,  83,  NA,  NA,  NA,  NA },
+      {   1,   7,  13,  18,  23,  28,  33,  38,  43,  49,  54,  60,  65,  69,  NA,  75,  79,  84,  87,  92,  96, 101 },
+      {   2,  NA,   8,  14,  19,  24,  29,  34,  39,  44,  50,  55,  61,  66,  70,  76,  80,  85,  88,  93,  97, 102 },
+      {   3,  NA,   9,  15,  20,  25,  30,  35,  40,  45,  51,  56,  62,  71,  NA,  NA,  NA,  NA,  89,  94,  98,  NA },
+      {   4,  NA,  10,  16,  21,  26,  31,  36,  41,  46,  52,  57,  NA,  NA,  72,  NA,  81,  NA,  90,  95,  99, 103 },
+      {   5,   6,  11,  NA,  NA,  NA,  NA,  32,  NA,  47,  NA,  58,  63,  73,  NA,  77,  82,  86,  91,  NA, 100,  NA } };
+
+static const char* zone_names[] =
+{
+    "Keyboard",
+    "Logo",
+    "Underglow"
+};
+
+static zone_type zone_types[] =
+{
+    ZONE_TYPE_MATRIX,
+    ZONE_TYPE_SINGLE,
+    ZONE_TYPE_SINGLE
+};
+
+static const unsigned int zone_sizes[] =
+{
+    104,
+    1,
+    2,
+};
+
+typedef struct
+{
+    const char *        name;
+    const unsigned char idx;
+} led_type;
+
+static const led_type led_names[] =
+{
+    /* Key Label                Index  */
+    { "Key: Escape",            0x00    },
+    { "Key: `",                 0x01    },
+    { "Key: Tab",               0x02    },
+    { "Key: Caps Lock",         0x03    },
+    { "Key: Left Shift",        0x04    },
+    { "Key: Left Control",      0x05    },
+    { "Key: Left Windows",      0x0D    },
+    { "Key: 1",                 0x11    },
+    { "Key: Q",                 0x12    },
+    { "Key: A",                 0x13    },
+    { "Key: Z",                 0x14    },
+    { "Key: Left Alt",          0x15    },
+    { "Key: F1",                0x18    },
+    { "Key: 2",                 0x19    },
+    { "Key: W",                 0x1A    },
+    { "Key: S",                 0x1B    },
+    { "Key: X",                 0x1C    },
+    { "Key: F2",                0x20    },
+    { "Key: 3",                 0x21    },
+    { "Key: E",                 0x22    },
+    { "Key: D",                 0x23    },
+    { "Key: C",                 0x24    },
+    { "Key: F3",                0x28    },
+    { "Key: 4",                 0x29    },
+    { "Key: R",                 0x2A    },
+    { "Key: F",                 0x2B    },
+    { "Key: V",                 0x2C    },
+    { "Key: F4",                0x30    },
+    { "Key: 5",                 0x31    },
+    { "Key: T",                 0x32    },
+    { "Key: G",                 0x33    },
+    { "Key: B",                 0x34    },
+    { "Key: Space",             0x35    },
+    { "Key: 6",                 0x39    },
+    { "Key: Y",                 0x3A    },
+    { "Key: H",                 0x3B    },
+    { "Key: N",                 0x3C    },
+    { "Key: F5",                0x40    },
+    { "Key: 7",                 0x41    },
+    { "Key: U",                 0x42    },
+    { "Key: J",                 0x43    },
+    { "Key: M",                 0x44    },
+    { "Key: F6",                0x48    },
+    { "Key: 8",                 0x49    },
+    { "Key: I",                 0x4A    },
+    { "Key: K",                 0x4B    },
+    { "Key: ,",                 0x4C    },
+    { "Key: Right Alt",         0x4D    },
+    { "Key: F7",                0x50    },
+    { "Key: 9",                 0x51    },
+    { "Key: O",                 0x52    },
+    { "Key: L",                 0x53    },
+    { "Key: .",                 0x54    },
+    { "Key: F8",                0x58    },
+    { "Key: 0",                 0x59    },
+    { "Key: P",                 0x5A    },
+    { "Key: ;",                 0x5B    },
+    { "Key: /",                 0x5C    },
+    { "Key: Right Fn",          0x5D    },
+    { "Key: F9",                0x60    },
+    { "Key: -",                 0x61    },
+    { "Key: [",                 0x62    },
+    { "Key: '",                 0x63    },
+    { "Key: Menu",              0x65    },
+    { "Key: F10",               0x68    },
+    { "Key: =",                 0x69    },
+    { "Key: ]",                 0x6A    },
+    { "Key: F11",               0x70    },
+    { "Key: F12",               0x78    },
+    { "Key: Backspace",         0x79    },
+    { "Key: \\ (ANSI)",         0x7A    },
+    { "Key: Enter",             0x7B    },
+    { "Key: Right Shift",       0x7C    },
+    { "Key: Right Control",     0x7D    },
+    { "Key: Print Screen",      0x80    },
+    { "Key: Insert",            0x81    },
+    { "Key: Delete",            0x82    },
+    { "Key: Left Arrow",        0x85    },
+    { "Key: Scroll Lock",       0x88    },
+    { "Key: Home",              0x89    },
+    { "Key: End",               0x8A    },
+    { "Key: Up Arrow",          0x8C    },
+    { "Key: Down Arrow",        0x8D    },
+    { "Key: Pause/Break",       0x90    },
+    { "Key: Page Up",           0x91    },
+    { "Key: Page Down",         0x92    },
+    { "Key: Right Arrow",       0x95    },
+    { "Key: Num Lock",          0x99    },
+    { "Key: Number Pad 7",      0x9A    },
+    { "Key: Number Pad 4",      0x9B    },
+    { "Key: Number Pad 1",      0x9C    },
+    { "Key: Number Pad 0",      0x9D    },
+    { "Key: Number Pad /",      0xA1    },
+    { "Key: Number Pad 8",      0xA2    },
+    { "Key: Number Pad 5",      0xA3    },
+    { "Key: Number Pad 2",      0xA4    },
+    { "Key: Number Pad *",      0xA9    },
+    { "Key: Number Pad 9",      0xAA    },
+    { "Key: Number Pad 6",      0xAB    },
+    { "Key: Number Pad 3",      0xAC    },
+    { "Key: Number Pad .",      0xAD    },
+    { "Key: Number Pad -",      0xB1    },
+    { "Key: Number Pad +",      0xB2    },
+    { "Key: Number Pad Enter",  0xB4    },
+    { "Logo",                   0xB8    },
+    { "Left Underglow",         0xB9    },
+    { "Right Underglow",        0xBA    },
+};
+
+RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* aura_ptr)
+{
+    aura = aura_ptr;
+
+    name        = "ASUS Aura Keyboard";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "ASUS Aura Keyboard Device";
+    location    = aura->GetDeviceLocation();
+    serial      = aura->GetSerialString();
+
+    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_AuraKeyboard::~RGBController_AuraKeyboard()
+{
+    delete aura;
+}
+
+void RGBController_AuraKeyboard::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    unsigned int total_led_count = 0;
+    for(unsigned int zone_idx = 0; zone_idx < 3; zone_idx++)
+    {
+        zone new_zone;
+        new_zone.name                   = zone_names[zone_idx];
+        new_zone.type                   = zone_types[zone_idx];
+        new_zone.leds_min               = zone_sizes[zone_idx];
+        new_zone.leds_max               = zone_sizes[zone_idx];
+        new_zone.leds_count             = zone_sizes[zone_idx];
+
+        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
+        {
+            new_zone.matrix_map         = new matrix_map_type;
+            new_zone.matrix_map->height = 6;
+            new_zone.matrix_map->width  = 22;
+            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+        }
+        else
+        {
+            new_zone.matrix_map         = NULL;
+        }
+
+        zones.push_back(new_zone);
+
+        total_led_count += zone_sizes[zone_idx];
+    }
+
+    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
+    {
+        led new_led;
+        new_led.name  = led_names[led_idx].name;
+        new_led.value = led_names[led_idx].idx;
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AuraKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AuraKeyboard::DeviceUpdateLEDs()
+{
+unsigned char frame_buf[107 * 4];
+
+/*---------------------------------------------------------*\
+| TODO: Send packets with multiple LED frames               |
+\*---------------------------------------------------------*/
+for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+{
+    frame_buf[(led_idx * 4) + 0] = leds[led_idx].value;
+    frame_buf[(led_idx * 4) + 1] = RGBGetRValue(colors[led_idx]);
+    frame_buf[(led_idx * 4) + 2] = RGBGetGValue(colors[led_idx]);
+    frame_buf[(led_idx * 4) + 3] = RGBGetBValue(colors[led_idx]);
+}
+
+aura->SendDirect(107, frame_buf);
+}
+
+void RGBController_AuraKeyboard::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraKeyboard::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraKeyboard::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_AuraKeyboard::DeviceUpdateMode()
+{
+
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraKeyboard.h         |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 3/19/2021   |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraKeyboardController.h"
+
+class RGBController_AuraKeyboard : public RGBController
+{
+public:
+    RGBController_AuraKeyboard(AuraKeyboardController* aura_ptr);
+    ~RGBController_AuraKeyboard();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    AuraKeyboardController* aura;
+};

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp

@@ -53,7 +53,7 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
 
 RGBController_AuraMouse::~RGBController_AuraMouse()
 {
-
+    delete aura;
 }
 
 void RGBController_AuraMouse::SetupZones()

Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

@@ -105,7 +105,7 @@ RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* aura_ptr) :
 
 RGBController_AuraUSB::~RGBController_AuraUSB()
 {
-
+    delete aura;
 }
 
 void RGBController_AuraUSB::SetupZones()

Controllers/CoolerMasterController/CMARGBcontroller.cpp

@@ -18,12 +18,6 @@ static unsigned char argb_colour_index_data[2][2][2] =
       { 0x04, 0x07 }, }  //G1 R1
 };
 
-static unsigned char argb_mode_data[2][9] =
-{
-    { 0x05, 0x01, 0x02, 0x03, 0x04, 0x01, 0x01, 0x01, 0x01 },    //12v RGB Mode values
-    { 0x0A, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08, 0x09 }     //5v ARGB Mode values
-};
-
 CMARGBController::CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx)
 {
     const int szTemp = 256;
@@ -32,7 +26,6 @@ CMARGBController::CMARGBController(hid_device* dev_handle, char *_path, unsigned
     dev                     = dev_handle;
     location                = _path;
     zone_index              = _zone_idx;
-    current_speed           = CM_ARGB_SPEED_NORMAL;
 
     hid_get_manufacturer_string(dev, tmpName, szTemp);
     std::wstring wName = std::wstring(tmpName);
@@ -56,28 +49,37 @@ CMARGBController::~CMARGBController()
 
 void CMARGBController::GetStatus()
 {
-    unsigned char buffer[0x40]          = { 0x00 };
-    int buffer_size                     = (sizeof(buffer) / sizeof(buffer[0]));
-    int header                          = zone_index - 1;
+    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = { 0x00, 0x80, 0x0B, 0x01 };
+    int buffer_size                             = (sizeof(buffer) / sizeof(buffer[0]));
+    int rgb_offset                              = 0;
+    int zone;
 
-    /*buffer[CM_ARGB_REPORT_BYTE]         = 0x80;
-    buffer[CM_ARGB_COMMAND_BYTE]        = 0x01;
-    buffer[CM_ARGB_FUNCTION_BYTE]       = 0x01;
+    if (argb_header_data[zone_index].digital)
+    {
+        zone                                    = argb_header_data[zone_index].header;
+        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0B;
+    }
+    else
+    {
+        zone                                    = 0x00;
+        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0A;
+        rgb_offset                              = 1;
+    }
+
+    /*---------------------------------------------------------*\
+    | If this is the group then just return the first status    |
+    \*---------------------------------------------------------*/
+    buffer[CM_ARGB_ZONE_BYTE]                   = ( zone > 0x08 ) ? 0x01 : zone;
     hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
 
-    buffer[CM_ARGB_COMMAND_BYTE]        = 0x0b;
-    buffer[CM_ARGB_FUNCTION_BYTE]       = 0x03;
-    buffer[CM_ARGB_ZONE_BYTE]           = 0xFF;
-    hid_write(dev, buffer, buffer_size);
-
-    int i = 0;
-    do{
-        hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
-        i++;
-    }while( (i < 4) );
-
-    current_mode                        = argb_mode_data[1][buffer[4]];
-    current_speed                       = buffer[5];*/
+    current_mode                                = buffer[4 - rgb_offset];
+    bool_random                                 = ( buffer[5 - rgb_offset] == 0x00 );
+    current_speed                               = buffer[6 - rgb_offset];
+    current_brightness                          = buffer[7 - rgb_offset];
+    current_red                                 = buffer[8 - rgb_offset];
+    current_green                               = buffer[9 - rgb_offset];
+    current_blue                                = buffer[10 - rgb_offset];
 }
 
 std::string CMARGBController::GetDeviceName()
@@ -125,6 +127,11 @@ unsigned char CMARGBController::GetLedSpeed()
     return current_speed;
 }
 
+bool CMARGBController::GetRandomColours()
+{
+    return bool_random;
+}
+
 unsigned int CMARGBController::GetLargestColour(unsigned int red, unsigned int green, unsigned int blue)
 {
     unsigned int largest;
@@ -142,65 +149,79 @@ unsigned int CMARGBController::GetLargestColour(unsigned int red, unsigned int g
 
 unsigned char CMARGBController::GetColourIndex(unsigned char red, unsigned char green, unsigned char blue)
 {
-    //The Coolermaster ARGB controller uses a limited colour pallette referenced by an index
-    //Starting at 0x00 Random, 0x01 Red, 0x02 Green, 0x03 Blue, 0x04 Yellow, 0x05 Purple, 0x06 Cyan, 0x07 White
-    //The index can be calculated by normalising the input colour, rounding those values 
-    //and using them as the indicies of a 3d array containing the correct index
+    /*---------------------------------------------------------------------------------------------------------*\
+    | The Cooler Master ARGB controller V0008 uses a limited colour pallette referenced by an index             |
+    | Starting at 0x00 Random, 0x01 Red, 0x02 Green, 0x03 Blue, 0x04 Yellow, 0x05 Purple, 0x06 Cyan, 0x07 White |
+    | The index can be calculated by normalising the input colour, rounding those values                        |
+    | and using them as the indicies of a 3d array containing the correct index                                 |
+    \*---------------------------------------------------------------------------------------------------------*/
     unsigned int divisor    = GetLargestColour( red, green, blue);
     unsigned int r          = round( red / divisor );
     unsigned int g          = round( green / divisor );
     unsigned int b          = round( blue / divisor );
     unsigned char idx       = argb_colour_index_data[r][g][b];
+
     return idx;
 }
 
-void CMARGBController::SetMode(unsigned char mode, unsigned char speed)
+void CMARGBController::SetLedCount(int zone, int led_count)
 {
-    current_mode  = mode;
-    current_speed = speed;
+    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = { 0x00, 0x80, 0x0D, 0x02 };
+    int  buffer_size                            = (sizeof(buffer) / sizeof(buffer[0]));
 
-    SendUpdate();
+    buffer[CM_ARGB_ZONE_BYTE]                   = zone;
+    buffer[CM_ARGB_MODE_BYTE]                   = led_count;
+    buffer[CM_ARGB_COLOUR_INDEX_BYTE]           = (0x0F - led_count > 0) ? 0x0F - led_count : 0x01;
+
+    hid_write(dev, buffer, buffer_size);
 }
 
-void CMARGBController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
+void CMARGBController::SetMode(unsigned char mode, unsigned char speed, RGBColor colour, bool random_colours)
 {
-    current_red   = red;
-    current_green = green;
-    current_blue  = blue;
+    bool needs_update   = !( (current_mode == mode) && (current_speed == speed) && (current_brightness == 0xFF) && (ToRGBColor(current_red, current_green, current_blue) == colour));
 
-    SendUpdate();
+    if (needs_update)
+    {
+        current_mode        = mode;
+        current_speed       = speed;
+        current_brightness  = 0xFF;
+        current_red         = RGBGetRValue(colour);
+        current_green       = RGBGetGValue(colour);
+        current_blue        = RGBGetBValue(colour);
+        bool_random         = random_colours;
+
+        SendUpdate();
+    }
 }
 
 void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_count)
 {
-    const unsigned char buffer_size     = 0x41;
-    unsigned char buffer[buffer_size]   = { 0x00 };
-    unsigned char packet_count          = 0x00;
+    const unsigned char buffer_size     = CM_ARGB_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { 0x00, 0x10, 0x02 };
+    unsigned char packet_count          = 0;
     std::vector<unsigned char> colours;
 
-    //Set up the RGB triplets to send
+    /*---------------------------------------------*\
+    | Set up the RGB triplets to send               |
+    \*---------------------------------------------*/
     for(int i = 0; i < led_count; i++)
     {
         RGBColor      colour            = led_colours[i];
-        unsigned char r                 = RGBGetRValue(colour);
-        unsigned char g                 = RGBGetGValue(colour);
-        unsigned char b                 = RGBGetBValue(colour);
 
-        colours.push_back(r);
-        colours.push_back(g);
-        colours.push_back(b);
+        colours.push_back( RGBGetRValue(colour) );
+        colours.push_back( RGBGetGValue(colour) );
+        colours.push_back( RGBGetBValue(colour) );
     }
 
-    //buffer[CM_ARGB_REPORT_BYTE]         = packet_count;
-    buffer[CM_ARGB_COMMAND_BYTE]        = 0x10;
-    buffer[CM_ARGB_FUNCTION_BYTE]       = 0x02;
     buffer[CM_ARGB_ZONE_BYTE]           = argb_header_data[zone_index].header;
-    buffer[CM_ARGB_MODE_BYTE]           = 0x30; //30 might be the LED count??
-    unsigned char buffer_idx            = CM_ARGB_MODE_BYTE + 1;    //Start colour info from
+    buffer[CM_ARGB_MODE_BYTE]           = led_count;
+    unsigned char buffer_idx            = CM_ARGB_MODE_BYTE + 1;
 
-    for (std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = 0)
+    for(std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = 0)
     {
-        //Fill the write buffer till its full or the colour buffer is empty
+        /*-----------------------------------------------------------------*\
+        | Fill the write buffer till its full or the colour buffer is empty |
+        \*-----------------------------------------------------------------*/
         buffer[CM_ARGB_REPORT_BYTE] = packet_count;
         while (( buffer_idx < buffer_size) && ( it != colours.end() ))
         {
@@ -212,17 +233,20 @@ void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_cou
         hid_write(dev, buffer, buffer_size);
         hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
 
-        //reset the write buffer
-        memset(buffer, 0x00, sizeof(buffer) );
+        /*-----------------------------------------------------------------*\
+        | Reset the write buffer                                            |
+        \*-----------------------------------------------------------------*/
+        memset(buffer, 0x00, buffer_size );
         packet_count++;
     }
+
     buffer[CM_ARGB_REPORT_BYTE]         = 0x82;
-    buffer[CM_ARGB_COMMAND_BYTE]        = 0x62;
+    /*buffer[CM_ARGB_COMMAND_BYTE]        = 0x62;
     buffer[CM_ARGB_FUNCTION_BYTE]       = 0x00;
     buffer[CM_ARGB_ZONE_BYTE]           = 0x73;
     buffer[CM_ARGB_MODE_BYTE]           = 0x00;
     buffer[CM_ARGB_COLOUR_INDEX_BYTE]   = 0x33;
-    buffer[CM_ARGB_SPEED_BYTE]          = 0x1B;
+    buffer[CM_ARGB_SPEED_BYTE]          = 0x1B;*/
 
     hid_write(dev, buffer, buffer_size);
     hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
@@ -230,52 +254,53 @@ void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_cou
 
 void CMARGBController::SendUpdate()
 {
-    unsigned char buffer[0x40]          = { 0x00 };
-    int  buffer_size                    = (sizeof(buffer) / sizeof(buffer[0]));
-    bool boolARGB_header                = argb_header_data[zone_index].digital;
-    bool boolPassthru                   = ( current_mode == CM_ARGB_MODE_PASSTHRU );
-    bool boolDirect                     = ( current_mode == CM_ARGB_MODE_DIRECT );
-    unsigned char function              = boolPassthru ? 0x02 : ( boolARGB_header ? 0x03 : 0x01);
-    buffer[CM_ARGB_REPORT_BYTE]         = 0x80;
-    buffer[CM_ARGB_COMMAND_BYTE]        = boolDirect ? 0x10 : 0x01;
-    buffer[CM_ARGB_FUNCTION_BYTE]       = boolDirect ? 0x01 : function;
+    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = { 0x00 };
+    int  buffer_size                            = (sizeof(buffer) / sizeof(buffer[0]));
+    bool boolARGB_header                        = argb_header_data[zone_index].digital;
+    bool boolPassthru                           = ( current_mode == CM_ARGB_MODE_PASSTHRU ) || ( current_mode == CM_RGB_MODE_PASSTHRU );
+    bool boolDirect                             = ( current_mode == CM_ARGB_MODE_DIRECT );
+    unsigned char function                      = boolPassthru ? (boolARGB_header ? 0x02 : 0x04) : (boolARGB_header ? 0x01 : 0x03);
+    buffer[CM_ARGB_REPORT_BYTE]                 = 0x80;
+    buffer[CM_ARGB_COMMAND_BYTE]                = 0x01;
+    buffer[CM_ARGB_FUNCTION_BYTE]               = boolDirect ? 0x01 : function;
 
-    if ( boolDirect )
-    {
-        buffer[CM_ARGB_COMMAND_BYTE]        = 0x10;
-        buffer[CM_ARGB_FUNCTION_BYTE]       = 0x01;
-        buffer[CM_ARGB_ZONE_BYTE]           = argb_header_data[zone_index].header;
-        buffer[CM_ARGB_MODE_BYTE]           = 0x30; //30 might be the LED count??
-
-        //hid_write(dev, buffer, buffer_size);
-        //hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
-    }
-    else
-    {
-        buffer[CM_ARGB_COMMAND_BYTE]        = 0x01;
-        buffer[CM_ARGB_FUNCTION_BYTE]       = function;
-    }
     hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
 
-
-    if ( boolARGB_header )
+    /*-----------------------------------------------------------------*\
+    | Direct mode is now set up and no other mode packet is required    |
+    \*-----------------------------------------------------------------*/
+    if(boolDirect)
     {
-        buffer[CM_ARGB_COMMAND_BYTE]        = 0x0b; //ARGB sends 0x0b (1011) RGB sends 0x04 (0100)
-        buffer[CM_ARGB_FUNCTION_BYTE]       = (false) ? 0x01 : 0x02; //This controls custom mode TODO
-        buffer[CM_ARGB_ZONE_BYTE]           = argb_header_data[zone_index].header;
-        buffer[CM_ARGB_MODE_BYTE]           = argb_mode_data[1][current_mode];
-        buffer[CM_ARGB_COLOUR_INDEX_BYTE]   = GetColourIndex( current_red, current_green, current_blue );
-        buffer[CM_ARGB_SPEED_BYTE]          = current_speed;
+        return;
+    }
+
+    if(boolARGB_header)
+    {
+        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0b;                                     //ARGB sends 0x0b (1011) RGB sends 0x04 (0100)
+        buffer[CM_ARGB_FUNCTION_BYTE]           = (false) ? 0x01 : 0x02;                    //This controls direct mode TODO
+        buffer[CM_ARGB_ZONE_BYTE]               = argb_header_data[zone_index].header;
+        buffer[CM_ARGB_MODE_BYTE]               = current_mode;
+        buffer[CM_ARGB_COLOUR_INDEX_BYTE]       = bool_random ? 0x00 : 0x10;
+        buffer[CM_ARGB_SPEED_BYTE]              = current_speed;
+        buffer[CM_ARGB_BRIGHTNESS_BYTE]         = current_brightness;
+        buffer[CM_ARGB_RED_BYTE]                = current_red;
+        buffer[CM_ARGB_GREEN_BYTE]              = current_green;
+        buffer[CM_ARGB_BLUE_BYTE]               = current_blue;
 
         hid_write(dev, buffer, buffer_size);
         hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
     }
     else
     {
-        buffer[CM_ARGB_COMMAND_BYTE]                        = 0x04; //ARGB sends 0x0b (1011) RGB sends 0x04 (0100)
-        buffer[CM_ARGB_MODE_BYTE + CM_RGB_OFFSET]           = argb_mode_data[0][current_mode];
-        buffer[CM_ARGB_COLOUR_INDEX_BYTE + CM_RGB_OFFSET]   = GetColourIndex( current_red, current_green, current_blue );
+        buffer[CM_ARGB_COMMAND_BYTE]                        = boolPassthru ? 0x01 : 0x04;   //ARGB sends 0x0b (1011) RGB sends 0x04 (0100)
+        buffer[CM_ARGB_MODE_BYTE + CM_RGB_OFFSET]           = current_mode;
+        buffer[CM_ARGB_COLOUR_INDEX_BYTE + CM_RGB_OFFSET]   = bool_random ? 0x00 : 0x10;
         buffer[CM_ARGB_SPEED_BYTE + CM_RGB_OFFSET]          = current_speed;
+        buffer[CM_ARGB_BRIGHTNESS_BYTE + CM_RGB_OFFSET]     = current_brightness;
+        buffer[CM_ARGB_RED_BYTE + CM_RGB_OFFSET]            = current_red;
+        buffer[CM_ARGB_GREEN_BYTE + CM_RGB_OFFSET]          = current_green;
+        buffer[CM_ARGB_BLUE_BYTE + CM_RGB_OFFSET]           = current_blue;
 
         hid_write(dev, buffer, buffer_size);
         hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);

Controllers/CoolerMasterController/CMARGBcontroller.h

@@ -20,6 +20,7 @@
 #define CM_ARGB_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
 #define CM_ARGB_HEADER_DATA_SIZE (sizeof(argb_header_data) / sizeof(argb_headers) )
 #define CM_ARGB_INTERRUPT_TIMEOUT 250
+#define CM_ARGB_PACKET_SIZE 65
 #define CM_ARGB_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
 #define CM_RGB_OFFSET -2
 #define HID_MAX_STR 255
@@ -32,7 +33,11 @@ enum
     CM_ARGB_ZONE_BYTE           = 4,
     CM_ARGB_MODE_BYTE           = 5,
     CM_ARGB_COLOUR_INDEX_BYTE	= 6,
-    CM_ARGB_SPEED_BYTE          = 7
+    CM_ARGB_SPEED_BYTE          = 7,
+    CM_ARGB_BRIGHTNESS_BYTE     = 8,
+    CM_ARGB_RED_BYTE            = 9,
+    CM_ARGB_GREEN_BYTE          = 10,
+    CM_ARGB_BLUE_BYTE           = 11
 };
 
 struct argb_headers
@@ -45,7 +50,7 @@ struct argb_headers
 
 static argb_headers argb_header_data[6] =
 {
-    { "RGB Header",         0xFF, false,  1 },
+    { "RGB Header",         0xFE, false,  1 },
     { "Digital ARGB1",      0x01, true,  12 },
     { "Digital ARGB2",      0x02, true,  12 },
     { "Digital ARGB3",      0x04, true,  12 },
@@ -55,24 +60,26 @@ static argb_headers argb_header_data[6] =
 
 enum
 {
-    CM_RGB_MODE_OFF             = 0,    //Turn off
-    CM_RGB_MODE_COLOUR_CYCLE    = 1,    //Colour Cycle
-    CM_RGB_MODE_FLASH           = 2,    //Flash
-    CM_RGB_MODE_BREATHING       = 3,    //Breathing
-    CM_RGB_MODE_PASSTHRU        = 4     //Motherboard Pass Thru Mode
+    CM_RGB_MODE_MIRAGE          = 0x01, //Mirage
+    CM_RGB_MODE_FLASH           = 0x02, //Flash
+    CM_RGB_MODE_BREATHING       = 0x03, //Breathing
+    CM_RGB_MODE_STATIC          = 0x05, //Static
+    CM_RGB_MODE_OFF             = 0x06, //Turn off
+    CM_RGB_MODE_PASSTHRU        = 0xFF  //Motherboard Pass Thru Mode
 };
 
 enum
 {
-    CM_ARGB_MODE_OFF            = 0,    //Turn off
-    CM_ARGB_MODE_SPECTRUM       = 1,    //Spectrum Mode
-    CM_ARGB_MODE_RELOAD         = 2,    //Reload Mode
-    CM_ARGB_MODE_RECOIL         = 3,    //Recoil Mode
-    CM_ARGB_MODE_BREATHING      = 4,    //Breathing Mode
-    CM_ARGB_MODE_REFILL         = 5,    //Refill Mode
-    CM_ARGB_MODE_DEMO           = 6,    //Demo Mode
-    CM_ARGB_MODE_FILLFLOW       = 7,    //Fill Flow Mode
-    CM_ARGB_MODE_RAINBOW        = 8,    //Rainbow Mode
+    CM_ARGB_MODE_OFF            = 0x0B, //Turn off
+    CM_ARGB_MODE_SPECTRUM       = 0x01, //Spectrum Mode
+    CM_ARGB_MODE_RELOAD         = 0x02, //Reload Mode
+    CM_ARGB_MODE_RECOIL         = 0x03, //Recoil Mode
+    CM_ARGB_MODE_BREATHING      = 0x04, //Breathing Mode
+    CM_ARGB_MODE_REFILL         = 0x05, //Refill Mode
+    CM_ARGB_MODE_DEMO           = 0x06, //Demo Mode
+    CM_ARGB_MODE_FILLFLOW       = 0x08, //Fill Flow Mode
+    CM_ARGB_MODE_RAINBOW        = 0x09, //Rainbow Mode
+    CM_ARGB_MODE_STATIC         = 0x0A, //Static Mode
     CM_ARGB_MODE_DIRECT         = 0xFE, //Direct Led Control
     CM_ARGB_MODE_PASSTHRU       = 0xFF  //Motherboard Pass Thru Mode
 };
@@ -102,9 +109,11 @@ public:
     unsigned char GetLedGreen();
     unsigned char GetLedBlue();
     unsigned char GetLedSpeed();
-    void SetMode(unsigned char mode, unsigned char speed);
-    void SetColor(unsigned char red, unsigned char green, unsigned char blue);
+    bool GetRandomColours();
+    void SetLedCount(int zone, int led_count);
+    void SetMode(unsigned char mode, unsigned char speed, RGBColor colour, bool random_colours);
     void SetLedsDirect(RGBColor * led_colours, unsigned int led_count);
+
 private:
     std::string             device_name;
     std::string             serial;
@@ -118,10 +127,11 @@ private:
     unsigned char           current_red;
     unsigned char           current_green;
     unsigned char           current_blue;
+    unsigned char           current_brightness;
+    bool                    bool_random;
 
     unsigned int GetLargestColour(unsigned int red, unsigned int green, unsigned int blue);
     unsigned char GetColourIndex(unsigned char red, unsigned char green, unsigned char blue);
     void GetStatus();
     void SendUpdate();
-
 };

Controllers/CoolerMasterController/CMMP750Controller.cpp

@@ -11,20 +11,17 @@
 
 static unsigned char colour_mode_data[][6] =
 {
-    { 0x01, 0x04, 0xFF, 0x00, 0xFF, 0x00 },                  /* Static                       */
-    { 0x02, 0x04, 0xFF, 0x00, 0xFF, 0x80 },                  /* Blinking                     */
-    { 0x03, 0x04, 0xFF, 0x00, 0xFF, 0x80 },                  /* Breathing                    */
-    { 0x04, 0x04, 0x80, 0x00, 0x00, 0x00 },                  /* Colour Cycle                 */
-    { 0x05, 0x04, 0x80, 0x00, 0x00, 0x00 }                   /* Colour Breath                */
+    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },                 /* Off                          */
+    { 0x01, 0x04, 0xFF, 0x00, 0xFF, 0x00 },                 /* Static                       */
+    { 0x02, 0x04, 0xFF, 0x00, 0xFF, 0x80 },                 /* Blinking                     */
+    { 0x03, 0x04, 0xFF, 0x00, 0xFF, 0x80 },                 /* Breathing                    */
+    { 0x04, 0x04, 0x80, 0x00, 0x00, 0x00 },                 /* Colour Cycle                 */
+    { 0x05, 0x04, 0x80, 0x00, 0x00, 0x00 }                  /* Colour Breath                */
 };
 
-static unsigned char speed_mode_data[][9] =
+static unsigned char speed_mode_data[9] =
 {
-    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },/* Static                       */
-    { 0xFF, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00 },/* Blinking                     */
-    { 0xFF, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00 },/* Breathing                    */
-    { 0xFF, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00 },/* Colour Cycle                 */
-    { 0xFF, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00 } /* Colour Breath                */
+    0xFF, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00    /* Speed Definition             */
 };
 
 CMMP750Controller::CMMP750Controller(hid_device* dev_handle, char *_path)
@@ -57,21 +54,21 @@ CMMP750Controller::~CMMP750Controller()
 
 void CMMP750Controller::GetStatus()
 {
-    unsigned char buffer[0x40]  = { 0x00 };
+    unsigned char buffer[0x41]  = { 0x00 };
     int buffer_size             = (sizeof(buffer) / sizeof(buffer[0]));
-    buffer[0]                   = 0x07;
+    buffer[1]                   = 0x07;
 
     hid_write(dev, buffer, buffer_size);
     hid_read(dev, buffer, buffer_size);
 
     if((buffer[0] == 0x80) && (buffer[1] == 0x05))
     {
-        current_mode  = buffer[2] - 1;
+        current_mode  = buffer[2];
         current_red   = buffer[3];
         current_green = buffer[4];
         current_blue  = buffer[5];
 
-        for(int i = 0; speed_mode_data[current_mode][i] >= buffer[6]; i++)
+        for(int i = 0; (speed_mode_data[i] >= buffer[6] && i <= MP750_SPEED_FASTEST); i++)
         {
             current_speed = i;
         }
@@ -79,7 +76,7 @@ void CMMP750Controller::GetStatus()
     else
     {
         //Code should never reach here however just in case there is a failure set something
-        current_mode  = MP750_MODE_COLOR_CYCLE;      //Unicorn Spew
+        current_mode  = CM_MP750_MODE_COLOR_CYCLE;      //Unicorn Spew
         current_red   = 0xFF;
         current_green = 0xFF;
         current_blue  = 0xFF;
@@ -146,18 +143,18 @@ void CMMP750Controller::SetColor(unsigned char red, unsigned char green, unsigne
 
 void CMMP750Controller::SendUpdate()
 {
-    unsigned char buffer[0x40] = { 0x00 };
+    unsigned char buffer[0x41] = { 0x00 };
     int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
 
     for(std::size_t i = 0; i < CM_COLOUR_MODE_DATA_SIZE; i++)
     {
-        buffer[i] = colour_mode_data[current_mode][i];
+        buffer[i+1] = colour_mode_data[current_mode][i];
     }
 
-   if(current_mode > MP750_MODE_BREATHING)
+   if(current_mode > CM_MP750_MODE_BREATHING)
     { 
         //If the mode is random colours set SPEED at BYTE2
-        buffer[CM_RED_BYTE]     = speed_mode_data[current_mode][current_speed];
+        buffer[CM_RED_BYTE]     = speed_mode_data[current_speed];
     }
     else
     { 
@@ -165,7 +162,7 @@ void CMMP750Controller::SendUpdate()
         buffer[CM_RED_BYTE]     = current_red;
         buffer[CM_GREEN_BYTE]   = current_green;
         buffer[CM_BLUE_BYTE]    = current_blue;
-        buffer[CM_SPEED_BYTE]   = speed_mode_data[current_mode][current_speed];
+        buffer[CM_SPEED_BYTE]   = speed_mode_data[current_speed];
     }
 
     hid_write(dev, buffer, buffer_size);

Controllers/CoolerMasterController/CMMP750Controller.h

@@ -28,20 +28,22 @@
 
 enum
 {
-    CM_MODE_BYTE   = 0,
-    CM_RED_BYTE    = 2,
-    CM_GREEN_BYTE  = 3,
-    CM_BLUE_BYTE   = 4,
-    CM_SPEED_BYTE  = 5
+    CM_MODE_BYTE   = 1,
+    CM_LENGTH_BYTE = 2,
+    CM_RED_BYTE    = 3,
+    CM_GREEN_BYTE  = 4,
+    CM_BLUE_BYTE   = 5,
+    CM_SPEED_BYTE  = 6
 };
 
 enum
 {
-    MP750_MODE_STATIC       = 0x00, //Static Mode
-    MP750_MODE_BLINK        = 0x01, //Blinking Mode
-    MP750_MODE_BREATHING    = 0x02, //Breathing Mode
-    MP750_MODE_COLOR_CYCLE  = 0x03, //Color Cycle Mode
-    MP750_MODE_BREATH_CYCLE = 0x04  //Breathing Cycle Mode
+    CM_MP750_MODE_OFF           = 0x00, //Off
+    CM_MP750_MODE_STATIC        = 0x01, //Static Mode
+    CM_MP750_MODE_BLINK         = 0x02, //Blinking Mode
+    CM_MP750_MODE_BREATHING     = 0x03, //Breathing Mode
+    CM_MP750_MODE_COLOR_CYCLE   = 0x04, //Color Cycle Mode
+    CM_MP750_MODE_BREATH_CYCLE  = 0x05  //Breathing Cycle Mode
 };
 
 enum

Controllers/CoolerMasterController/CMR6000Controller.cpp

@@ -0,0 +1,196 @@
+/*-------------------------------------------------------------------*\
+|  CMR6000Controller.cpp                                              |
+|                                                                     |
+|  Driver for Coolermaster based AMD Radeon GPU (6000 series)         |
+|                                                                     |
+|  Eric S (edbgon)          2nd Feb 2021                              |
+\*-------------------------------------------------------------------*/
+
+#include "CMR6000Controller.h"
+#include <cstring>
+
+CMR6000Controller::CMR6000Controller(hid_device* dev_handle, char *_path)
+{
+    dev             = dev_handle;
+    location        = _path;
+
+    const int szTemp = 256;
+    wchar_t tmpName[szTemp];
+
+    hid_get_manufacturer_string(dev, tmpName, szTemp);
+    std::wstring wName = std::wstring(tmpName);
+    device_name        = std::string(wName.begin(), wName.end());
+
+    hid_get_product_string(dev, tmpName, szTemp);
+    wName  = std::wstring(tmpName);
+    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
+
+    hid_get_serial_number_string(dev, tmpName, szTemp);
+    wName  = std::wstring(tmpName);
+    serial = std::string(wName.begin(), wName.end());
+
+    GetStatus();        //When setting up device get current status
+}
+
+CMR6000Controller::~CMR6000Controller()
+{
+    if(dev)
+    {
+        hid_close(dev);
+    }
+}
+
+void CMR6000Controller::GetStatus()
+{
+    unsigned char buffer[CM_6K_PACKET_SIZE]     = { 0x00, 0x52, 0xA0, 0x01, 0x00, 0x00, 0x03 };
+    int buffer_size                             = (sizeof(buffer) / sizeof(buffer[0]));
+
+    // Request mode
+    hid_write(dev, buffer, buffer_size);
+    hid_read(dev, buffer, buffer_size);
+
+    unsigned char cmdbuffer[CM_6K_PACKET_SIZE]  = { 0x00, 0x52, 0x2C, 0x01, 0x00 };
+    int cmdbuffer_size                          = (sizeof(cmdbuffer) / sizeof(cmdbuffer[0]));
+
+    current_mode    = buffer[0x0A];
+    cmdbuffer[0x05] = current_mode;
+    hid_write(dev, cmdbuffer, cmdbuffer_size);
+    hid_read(dev, cmdbuffer, cmdbuffer_size);
+
+    current_speed       = cmdbuffer[0x05];
+    current_brightness  = cmdbuffer[0x09];
+    current_red         = cmdbuffer[0x0A];
+    current_green       = cmdbuffer[0x0B];
+    current_blue        = cmdbuffer[0x0C];
+}
+
+std::string CMR6000Controller::GetDeviceName()
+{
+    return device_name;
+}
+
+std::string CMR6000Controller::GetSerial()
+{
+    return serial;
+}
+
+std::string CMR6000Controller::GetLocation()
+{
+    return("HID: " + location);
+}
+
+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;
+}
+
+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)
+{
+    current_mode        = mode;
+    current_speed       = speed;
+    current_red         = red;
+    current_green       = green;
+    current_blue        = blue;
+    current_random      = random;
+    current_brightness  = (current_mode == CM_MR6000_MODE_COLOR_CYCLE) ? 0x7F : 0xFF;    //Color_Cycle brightness needs to be clamped to 0x7F to avoid wash out
+
+    SendUpdate();
+}
+
+void CMR6000Controller::SendUpdate()
+{    
+    if(current_mode == CM_MR6000_MODE_OFF)
+    {
+        unsigned char buffer[CM_6K_PACKET_SIZE] = { 0x00, 0x41, 0x43 };
+        int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
+        hid_write(dev, buffer, buffer_size);
+    }
+    else
+    {
+        SendEnableCommand();
+
+        unsigned char buffer[CM_6K_PACKET_SIZE] = { 0x00 };
+        int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
+        memset(buffer, 0xFF, buffer_size);
+
+        buffer[0x00] = 0x00;
+        buffer[0x01] = 0x51;
+        buffer[0x02] = 0x2C;
+        buffer[0x03] = 0x01;
+        buffer[0x04] = 0x00;
+        buffer[0x05] = current_mode;
+        buffer[0x06] = (current_mode == CM_MR6000_MODE_STATIC) ? 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[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[0x0E] = 0x00;
+        buffer[0x0F] = 0x00;
+        buffer[0x10] = 0x00;
+
+        hid_write(dev, buffer, buffer_size);
+
+        SendColourConfig();
+        SendApplyCommand();
+    }
+}
+
+void CMR6000Controller::SendEnableCommand()
+{
+    unsigned char buffer[CM_6K_PACKET_SIZE] = { 0x00, 0x41, 0x80 };
+    int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_6K_INTERRUPT_TIMEOUT);
+}
+
+void CMR6000Controller::SendApplyCommand()
+{
+    unsigned char buffer[CM_6K_PACKET_SIZE] = { 0x00, 0x51, 0x28, 0x00, 0x00, 0xE0 };
+    int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_6K_INTERRUPT_TIMEOUT);
+}
+
+void CMR6000Controller::SendColourConfig()
+{
+    unsigned char buffer[CM_6K_PACKET_SIZE] = { 0x00, 0x51, 0xA0, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x05, 0x06 };
+    int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
+
+    for(int i = 0x0B; i < 0x1A; i++)
+    {
+        buffer[i] = current_mode;
+    }
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_6K_INTERRUPT_TIMEOUT);
+}

Controllers/CoolerMasterController/CMR6000Controller.h

@@ -0,0 +1,82 @@
+/*-------------------------------------------------------------------*\
+|  CMR6000Controller.h                                                |
+|                                                                     |
+|  Driver for Coolermaster based AMD Radeon GPU (6000 series)         |
+|                                                                     |
+|  Eric S (edbgon)          2nd Feb 2021                              |
+\*-------------------------------------------------------------------*/
+
+#include <string>
+#include <array>
+#include <hidapi/hidapi.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
+
+enum
+{
+    CM_MR6000_MODE_STATIC        = 0x00, //Static Mode
+    CM_MR6000_MODE_BREATHE       = 0x01, //Breathe Mode
+    CM_MR6000_MODE_COLOR_CYCLE   = 0x02, //Color cycle
+    CM_MR6000_MODE_OFF           = 0xFF, //Off
+};
+
+enum
+{
+    MR6000_CYCLE_SPEED_SLOWEST              = 0x96, /* Slowest speed                */
+    MR6000_CYCLE_SPEED_SLOW                 = 0x8C, /* Slow speed                   */
+    MR6000_CYCLE_SPEED_NORMAL               = 0x80, /* Normal speed                 */
+    MR6000_CYCLE_SPEED_FAST                 = 0x6E, /* Fast speed                   */
+    MR6000_CYCLE_SPEED_FASTEST              = 0x68, /* Fastest speed                */
+
+    MR6000_BREATHE_SPEED_SLOWEST            = 0x3C, /* Slowest speed                */
+    MR6000_BREATHE_SPEED_SLOW               = 0x37, /* Slow speed                   */
+    MR6000_BREATHE_SPEED_NORMAL             = 0x31, /* Normal speed                 */
+    MR6000_BREATHE_SPEED_FAST               = 0x2C, /* Fast speed                   */
+    MR6000_BREATHE_SPEED_FASTEST            = 0x26, /* Fastest speed                */
+};
+
+class CMR6000Controller
+{
+public:
+    CMR6000Controller(hid_device* dev_handle, char *_path);
+    ~CMR6000Controller();
+
+    std::string   GetDeviceName();
+    std::string   GetSerial();
+    std::string   GetLocation();
+
+    unsigned char GetMode();
+    unsigned char GetLedRed();
+    unsigned char GetLedGreen();
+    unsigned char GetLedBlue();
+    unsigned char GetLedSpeed();
+    bool          GetRandomColours();
+    void          SetMode(unsigned char mode, unsigned char speed, unsigned char red, unsigned char green, unsigned char blue, unsigned char random);
+
+private:
+    std::string             device_name;
+    std::string             serial;
+    std::string             location;
+    hid_device*             dev;
+
+    unsigned char           current_mode;
+    unsigned char           current_speed;
+    unsigned char           current_random;
+
+    unsigned char           current_red;
+    unsigned char           current_green;
+    unsigned char           current_blue;
+    unsigned char           current_brightness;
+
+    void GetStatus();
+    void SendUpdate();
+    void SendEnableCommand();
+    void SendApplyCommand();
+    void SendColourConfig();
+};

Controllers/CoolerMasterController/CMSmallARGBController.cpp

@@ -0,0 +1,237 @@
+/*-------------------------------------------------------------------*\
+|  CMSmallARGBController.cpp                                          |
+|                                                                     |
+|  Driver for Coolermaster Small ARGB USB Controller                  |
+|                                                                     |
+|  Chris M (Dr_No)          31st Jan 2021                             |
+|                                                                     |
+|  Simple RGB device with 5 modes                                     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "CMSmallARGBController.h"
+#include <cstring>
+
+CMSmallARGBController::CMSmallARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx)
+{
+    const int szTemp = 256;
+    wchar_t tmpName[szTemp];
+
+    dev                     = dev_handle;
+    location                = _path;
+    zone_index              = _zone_idx;
+    current_speed           = CM_SMALL_ARGB_SPEED_NORMAL;
+
+    hid_get_manufacturer_string(dev, tmpName, szTemp);
+    std::wstring wName = std::wstring(tmpName);
+    device_name = std::string(wName.begin(), wName.end());
+
+    hid_get_product_string(dev, tmpName, szTemp);
+    wName = std::wstring(tmpName);
+    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
+
+    hid_get_serial_number_string(dev, tmpName, szTemp);
+    wName = std::wstring(tmpName);
+    serial = std::string(wName.begin(), wName.end());
+
+    GetStatus();
+}
+
+CMSmallARGBController::~CMSmallARGBController()
+{
+    if(dev)
+    {
+        hid_close(dev);
+    }
+}
+
+void CMSmallARGBController::GetStatus()
+{
+    unsigned char buffer[CM_SMALL_ARGB_PACKET_SIZE]     = { 0x00, 0x80, 0x01, 0x01 };
+    int buffer_size                                     = (sizeof(buffer) / sizeof(buffer[0]));
+    int header                                          = zone_index - 1;
+
+    buffer[CM_SMALL_ARGB_ZONE_BYTE]                     = header;
+    buffer[CM_SMALL_ARGB_MODE_BYTE]                     = 0x01;
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_SMALL_ARGB_INTERRUPT_TIMEOUT);
+
+    memset(buffer, 0x00, buffer_size );
+
+    buffer[CM_SMALL_ARGB_COMMAND_BYTE]                  = 0x0B;
+    buffer[CM_SMALL_ARGB_FUNCTION_BYTE]                 = 0x01;
+    buffer[CM_SMALL_ARGB_ZONE_BYTE]                     = 0x01;
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_SMALL_ARGB_INTERRUPT_TIMEOUT);
+
+    current_mode                                        = buffer[4];
+    current_speed                                       = buffer[5];
+    bool_random                                         = buffer[6] == 0x00;
+    current_brightness                                  = buffer[7];
+    current_red                                         = buffer[8];
+    current_green                                       = buffer[9];
+    current_blue                                        = buffer[10];
+}
+
+std::string CMSmallARGBController::GetDeviceName()
+{
+    return device_name;
+}
+
+std::string CMSmallARGBController::GetSerial()
+{
+    return serial;
+}
+
+std::string CMSmallARGBController::GetLocation()
+{
+    return("HID: " + location);
+}
+
+unsigned char CMSmallARGBController::GetZoneIndex()
+{
+    return zone_index;
+}
+
+unsigned char CMSmallARGBController::GetMode()
+{
+    return current_mode;
+}
+
+unsigned char CMSmallARGBController::GetLedRed()
+{
+    return current_red;
+}
+
+unsigned char CMSmallARGBController::GetLedGreen()
+{
+    return current_green;
+}
+
+unsigned char CMSmallARGBController::GetLedBlue()
+{
+    return current_blue;
+}
+
+unsigned char CMSmallARGBController::GetLedSpeed()
+{
+    return current_speed;
+}
+
+bool CMSmallARGBController::GetRandomColours()
+{
+    return bool_random;
+}
+
+void CMSmallARGBController::SetLedCount(int zone, int led_count)
+{
+    unsigned char buffer[CM_SMALL_ARGB_PACKET_SIZE]     = { 0x00, 0x80, 0x0D, 0x02 };
+    int  buffer_size                                    = (sizeof(buffer) / sizeof(buffer[0]));
+
+    buffer[CM_SMALL_ARGB_ZONE_BYTE]                     = zone;
+    buffer[CM_SMALL_ARGB_MODE_BYTE]                     = (0x0F - led_count > 0) ? 0x0F - led_count : 0x01;
+    buffer[CM_SMALL_ARGB_SPEED_BYTE]                    = led_count;
+
+    hid_write(dev, buffer, buffer_size);
+}
+
+void CMSmallARGBController::SetMode(unsigned char mode, unsigned char speed, RGBColor colour, bool random_colours)
+{
+    current_mode    = mode;
+    current_speed   = speed;
+    current_red     = RGBGetRValue(colour);
+    current_green   = RGBGetGValue(colour);
+    current_blue    = RGBGetBValue(colour);
+    bool_random     = random_colours;
+
+    SendUpdate();
+}
+
+void CMSmallARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_count)
+{
+    // Mode not yet Tested
+    /*
+    const unsigned char buffer_size     = 0x41;
+    unsigned char buffer[buffer_size]   = { 0x00 };
+    unsigned char packet_count          = 0x00;
+    std::vector<unsigned char> colours;
+
+    //Set up the RGB triplets to send
+    for(int i = 0; i < led_count; i++)
+    {
+        RGBColor      colour            = led_colours[i];
+        unsigned char r                 = RGBGetRValue(colour);
+        unsigned char g                 = RGBGetGValue(colour);
+        unsigned char b                 = RGBGetBValue(colour);
+
+        colours.push_back(r);
+        colours.push_back(g);
+        colours.push_back(b);
+    }
+
+    //buffer[CM_ARGB_REPORT_BYTE]       = packet_count;
+    buffer[CM_SMALL_ARGB_COMMAND_BYTE]  = 0x10;
+    buffer[CM_SMALL_ARGB_FUNCTION_BYTE] = 0x02;
+    buffer[CM_SMALL_ARGB_ZONE_BYTE]     = small_argb_header_data[zone_index].header;
+    buffer[CM_SMALL_ARGB_MODE_BYTE]     = 0x30; //30 might be the LED count??
+    unsigned char buffer_idx            = CM_SMALL_ARGB_MODE_BYTE + 1;    //Start colour info from
+
+    for (std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = 0)
+    {
+        //Fill the write buffer till its full or the colour buffer is empty
+        buffer[CM_SMALL_ARGB_REPORT_BYTE] = packet_count;
+        while (( buffer_idx < buffer_size) && ( it != colours.end() ))
+        {
+            buffer[buffer_idx] = *it;
+            buffer_idx++;
+            it++;
+        }
+
+        hid_write(dev, buffer, buffer_size);
+        hid_read_timeout(dev, buffer, buffer_size, CM_SMALL_ARGB_INTERRUPT_TIMEOUT);
+
+        //reset the write buffer
+        memset(buffer, 0x00, sizeof(buffer) );
+        packet_count++;
+    }
+    buffer[CM_SMALL_ARGB_REPORT_BYTE]         = 0x82;
+    buffer[CM_SMALL_ARGB_COMMAND_BYTE]        = 0x62;
+    buffer[CM_SMALL_ARGB_FUNCTION_BYTE]       = 0x00;
+    buffer[CM_SMALL_ARGB_ZONE_BYTE]           = 0x73;
+    buffer[CM_SMALL_ARGB_MODE_BYTE]           = 0x00;
+    buffer[CM_SMALL_ARGB_SPEED_BYTE]          = 0x33;
+    buffer[CM_SMALL_ARGB_COLOUR_INDEX_BYTE]   = 0x18;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_SMALL_ARGB_INTERRUPT_TIMEOUT);
+    */
+}
+
+void CMSmallARGBController::SendUpdate()
+{
+    unsigned char buffer[CM_SMALL_ARGB_PACKET_SIZE]     = { 0x00 };
+    int  buffer_size                                    = (sizeof(buffer) / sizeof(buffer[0]));
+    bool boolPassthru                                   = ( current_mode == CM_SMALL_ARGB_MODE_PASSTHRU );
+    bool boolDirect                                     = ( current_mode == CM_SMALL_ARGB_MODE_DIRECT );
+    unsigned char function                              = boolPassthru ? 0x02 : 0x01;
+    buffer[CM_SMALL_ARGB_REPORT_BYTE]                   = 0x80;
+    buffer[CM_SMALL_ARGB_COMMAND_BYTE]                  = boolDirect   ? 0x10 : 0x01;
+    buffer[CM_SMALL_ARGB_FUNCTION_BYTE]                 = boolDirect   ? 0x01 : function;
+    buffer[CM_SMALL_ARGB_MODE_BYTE]                     = boolPassthru ? 0x00 : 0x02;
+
+    hid_write(dev, buffer, buffer_size);
+
+    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_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
+    buffer[CM_SMALL_ARGB_BRIGHTNESS_BYTE]               = 0xFF;
+    buffer[CM_SMALL_ARGB_RED_BYTE]                      = current_red;
+    buffer[CM_SMALL_ARGB_GREEN_BYTE]                    = current_green;
+    buffer[CM_SMALL_ARGB_BLUE_BYTE]                     = current_blue;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_SMALL_ARGB_INTERRUPT_TIMEOUT);
+}

Controllers/CoolerMasterController/CMSmallARGBController.h

@@ -0,0 +1,113 @@
+/*-------------------------------------------------------------------*\
+|  CMSmallARGBController.h                                            |
+|                                                                     |
+|  Driver for Coolermaster Small ARGB USB Controller                  |
+|                                                                     |
+|  Chris M (Dr_No)          31st Jan 2021                             |
+|                                                                     |
+|  Simple RGB device with 5 modes                                     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include <string>
+#include <array>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"  //Needed to set the direct mode
+
+#pragma once
+
+#define CM_SMALL_ARGB_PACKET_SIZE 65
+#define CM_SMALL_ARGB_INTERRUPT_TIMEOUT 250
+
+enum
+{
+    CM_SMALL_ARGB_REPORT_BYTE           =  1,
+    CM_SMALL_ARGB_COMMAND_BYTE          =  2,
+    CM_SMALL_ARGB_FUNCTION_BYTE         =  3,
+    CM_SMALL_ARGB_ZONE_BYTE             =  4,
+    CM_SMALL_ARGB_MODE_BYTE             =  5,
+    CM_SMALL_ARGB_SPEED_BYTE            =  6,
+    CM_SMALL_ARGB_COLOUR_INDEX_BYTE     =  7,  //Not used on the small controller
+    CM_SMALL_ARGB_BRIGHTNESS_BYTE       =  8,  //0x00 thru 0xFF
+    CM_SMALL_ARGB_RED_BYTE              =  9,
+    CM_SMALL_ARGB_GREEN_BYTE            = 10,
+    CM_SMALL_ARGB_BLUE_BYTE             = 11,
+};
+
+struct _argb_headers
+{
+    const char*     name;
+    unsigned char   header;
+    bool            digital;
+    unsigned int    count;
+};
+
+static _argb_headers small_argb_header_data[1] =
+{
+    { "CM Small ARGB",  0x01, true,  12 }
+};
+
+enum
+{
+    CM_SMALL_ARGB_MODE_SPECTRUM       = 0x01,   //Spectrum Mode
+    CM_SMALL_ARGB_MODE_RELOAD         = 0x02,   //Reload Mode
+    CM_SMALL_ARGB_MODE_RECOIL         = 0x03,   //Recoil Mode
+    CM_SMALL_ARGB_MODE_BREATHING      = 0x04,   //Breathing Mode
+    CM_SMALL_ARGB_MODE_REFILL         = 0x05,   //Refill Mode
+    CM_SMALL_ARGB_MODE_DEMO           = 0x06,   //Demo Mode
+    CM_SMALL_ARGB_MODE_OFF            = 0x09,   //Turn off
+    CM_SMALL_ARGB_MODE_DIRECT         = 0xFE,   //Direct Led Control (possibly N?A for small controller)
+    CM_SMALL_ARGB_MODE_PASSTHRU       = 0xFF    //Motherboard Pass Thru Mode
+};
+
+enum
+{
+    CM_SMALL_ARGB_SPEED_SLOWEST       = 0x00,   // Slowest speed
+    CM_SMALL_ARGB_SPEED_SLOW          = 0x01,   // Slower speed
+    CM_SMALL_ARGB_SPEED_NORMAL        = 0x02,   // Normal speed
+    CM_SMALL_ARGB_SPEED_FAST          = 0x03,   // Fast speed
+    CM_SMALL_ARGB_SPEED_FASTEST       = 0x04,   // Fastest speed
+};
+
+class CMSmallARGBController
+{
+public:
+    CMSmallARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx);
+    ~CMSmallARGBController();
+
+    std::string         GetDeviceName();
+    std::string         GetSerial();
+    std::string         GetLocation();
+
+    unsigned char       GetZoneIndex();
+    unsigned char       GetMode();
+    unsigned char       GetLedRed();
+    unsigned char       GetLedGreen();
+    unsigned char       GetLedBlue();
+    unsigned char       GetLedSpeed();
+    bool                GetRandomColours();
+
+    void                SetLedCount(int zone, int led_count);
+    void                SetMode(unsigned char mode, unsigned char speed, RGBColor colour, bool random_colours);
+    void                SetLedsDirect(RGBColor * led_colours, unsigned int led_count);
+private:
+    std::string         device_name;
+    std::string         serial;
+    std::string         location;
+    hid_device*         dev;
+
+    unsigned char       zone_index;
+    unsigned char       current_mode;
+    unsigned char       current_speed;
+
+    unsigned char       current_red;
+    unsigned char       current_green;
+    unsigned char       current_blue;
+    unsigned char       current_brightness;
+    bool                bool_random;
+
+    unsigned int        GetLargestColour(unsigned int red, unsigned int green, unsigned int blue);
+    unsigned char       GetColourIndex(unsigned char red, unsigned char green, unsigned char blue);
+    void                GetStatus();
+    void                SendUpdate();
+};

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -1,9 +1,13 @@
 #include "Detector.h"
 #include "CMMP750Controller.h"
 #include "CMARGBcontroller.h"
+#include "CMSmallARGBController.h"
+#include "CMR6000Controller.h"
 #include "RGBController.h"
 #include "RGBController_CMMP750Controller.h"
 #include "RGBController_CMARGBController.h"
+#include "RGBController_CMSmallARGBController.h"
+#include "RGBController_CMR6000Controller.h"
 #include <hidapi/hidapi.h>
 
 #define COOLERMASTER_VID                0x2516
@@ -11,6 +15,8 @@
 #define COOLERMASTER_MP750_XL_PID       0x0109
 #define COOLERMASTER_MP750_MEDIUM_PID   0x0105
 #define COOLERMASTER_ARGB_PID           0x1011
+#define COOLERMASTER_SMALL_ARGB_PID     0x1000
+#define COOLERMASTER_RADEON_6000_PID    0x014D
 
 /******************************************************************************************\
 *                                                                                          *
@@ -47,6 +53,32 @@ void DetectCoolerMasterARGB(hid_device_info* info, const std::string&)
     }
 }
 
-REGISTER_HID_DETECTOR_IPU("Cooler Master MP750 XL",     DetectCoolerMasterMousemats, COOLERMASTER_VID, COOLERMASTER_MP750_XL_PID,     0, 0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master MP750 Medium", DetectCoolerMasterMousemats, COOLERMASTER_VID, COOLERMASTER_MP750_MEDIUM_PID, 0, 0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB",         DetectCoolerMasterARGB,      COOLERMASTER_VID, COOLERMASTER_ARGB_PID,         0, 0xFF00, 1);
+void DetectCoolerMasterSmallARGB(hid_device_info* info, const std::string&)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        CMSmallARGBController* controller = new CMSmallARGBController(dev, info->path, 0);
+        RGBController_CMSmallARGBController* rgb_controller = new RGBController_CMSmallARGBController(controller);
+        // Constructor sets the 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);
+        RGBController_CMR6000Controller* rgb_controller = new RGBController_CMR6000Controller(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 XL",         DetectCoolerMasterMousemats,    COOLERMASTER_VID, COOLERMASTER_MP750_XL_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 ARGB",             DetectCoolerMasterARGB,         COOLERMASTER_VID, COOLERMASTER_ARGB_PID,         	0,  0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master Smalll ARGB",      DetectCoolerMasterSmallARGB,    COOLERMASTER_VID, COOLERMASTER_SMALL_ARGB_PID,   	0,  0xFF00, 1);
+REGISTER_HID_DETECTOR_I  ("Cooler Master Radeon 6000 GPU",  DetectCoolerMasterGPU,          COOLERMASTER_VID, COOLERMASTER_RADEON_6000_PID,                 1);

Controllers/CoolerMasterController/RGBController_CMARGBController.cpp

@@ -18,11 +18,11 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
     vendor                  = "Cooler Master";
     type                    = DEVICE_TYPE_LEDSTRIP;
     description             = cmargb->GetDeviceName();
-    version                 = "1.0";
+    version                 = "2.0 for FW0023";
     serial                  = cmargb->GetSerial();
     location                = cmargb->GetLocation();
 
-    if ( argb_header_data[cmargb->GetZoneIndex()].digital)
+    if(argb_header_data[cmargb->GetZoneIndex()].digital)
     {
         mode Off;
         Off.name                = "Turn Off";
@@ -39,7 +39,7 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
         Reload.colors.resize(Reload.colors_max);
         Reload.speed_min        = CM_ARGB_SPEED_SLOWEST;
         Reload.speed_max        = CM_ARGB_SPEED_FASTEST;
-        Reload.color_mode       = MODE_COLORS_RANDOM;
+        Reload.color_mode       = MODE_COLORS_MODE_SPECIFIC;
         Reload.speed            = speed;
         modes.push_back(Reload);
 
@@ -49,10 +49,10 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
         Recoil.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
         Recoil.colors_min       = 1;
         Recoil.colors_max       = 1;
-        Recoil.colors.resize(Reload.colors_max);
+        Recoil.colors.resize(Recoil.colors_max);
         Recoil.speed_min        = CM_ARGB_SPEED_SLOWEST;
         Recoil.speed_max        = CM_ARGB_SPEED_FASTEST;
-        Recoil.color_mode       = MODE_COLORS_RANDOM;
+        Recoil.color_mode       = MODE_COLORS_MODE_SPECIFIC;
         Recoil.speed            = speed;
         modes.push_back(Recoil);
 
@@ -62,10 +62,10 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
         Breathing.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
         Breathing.colors_min    = 1;
         Breathing.colors_max    = 1;
-        Breathing.colors.resize(Reload.colors_max);
+        Breathing.colors.resize(Breathing.colors_max);
         Breathing.speed_min     = CM_ARGB_SPEED_SLOWEST;
         Breathing.speed_max     = CM_ARGB_SPEED_FASTEST;
-        Breathing.color_mode    = MODE_COLORS_RANDOM;
+        Breathing.color_mode    = MODE_COLORS_MODE_SPECIFIC;
         Breathing.speed         = speed;
         modes.push_back(Breathing);
 
@@ -75,10 +75,10 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
         Refill.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
         Refill.colors_min       = 1;
         Refill.colors_max       = 1;
-        Refill.colors.resize(Reload.colors_max);
+        Refill.colors.resize(Refill.colors_max);
         Refill.speed_min        = CM_ARGB_SPEED_SLOWEST;
         Refill.speed_max        = CM_ARGB_SPEED_FASTEST;
-        Refill.color_mode       = MODE_COLORS_RANDOM;
+        Refill.color_mode       = MODE_COLORS_MODE_SPECIFIC;
         Refill.speed            = speed;
         modes.push_back(Refill);
 
@@ -122,6 +122,19 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
         Rainbow.speed           = speed;
         modes.push_back(Rainbow);
 
+        mode Static;
+        Static.name             = "Static";
+        Static.value            = CM_ARGB_MODE_STATIC;
+        Static.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+        Static.colors_min       = 1;
+        Static.colors_max       = 1;
+        Static.colors.resize(Static.colors_max);
+        Static.speed_min        = CM_ARGB_SPEED_SLOWEST;
+        Static.speed_max        = CM_ARGB_SPEED_FASTEST;
+        Static.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+        Static.speed            = speed;
+        modes.push_back(Static);
+
         mode Direct;
         Direct.name             = "Direct";
         Direct.value            = CM_ARGB_MODE_DIRECT;
@@ -132,16 +145,22 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
         mode PassThru;
         PassThru.name           = "Pass Thru";
         PassThru.value          = CM_ARGB_MODE_PASSTHRU;
+        PassThru.flags          = 0;
         PassThru.color_mode     = MODE_COLORS_NONE;
         modes.push_back(PassThru);
     }
     else
     {
-        mode Off;
-        Off.name                = "Turn Off";
-        Off.value               = CM_RGB_MODE_OFF;
-        Off.color_mode          = MODE_COLORS_NONE;
-        modes.push_back(Off);
+        mode Static;
+        Static.name             = "Static";
+        Static.value            = CM_RGB_MODE_STATIC;
+        Static.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+        Static.colors_min       = 1;
+        Static.colors_max       = 1;
+        Static.colors.resize(Static.colors_max);
+        Static.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+        Static.speed            = 0;
+        modes.push_back(Static);
 
         mode Breathing;
         Breathing.name          = "Breathing";
@@ -152,61 +171,93 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
         Breathing.colors.resize(Breathing.colors_max);
         Breathing.speed_min     = CM_ARGB_SPEED_SLOWEST;
         Breathing.speed_max     = CM_ARGB_SPEED_FASTEST;
-        Breathing.color_mode    = MODE_COLORS_RANDOM;
-        Breathing.speed         = speed;
+        Breathing.color_mode    = MODE_COLORS_MODE_SPECIFIC;
+        Breathing.speed         = CM_ARGB_SPEED_NORMAL;
         modes.push_back(Breathing);
 
         mode Flash;
-        Breathing.name          = "Flash";
-        Breathing.value         = CM_RGB_MODE_FLASH;
-        Breathing.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Breathing.colors_min    = 1;
-        Breathing.colors_max    = 1;
-        Breathing.colors.resize(Breathing.colors_max);
-        Breathing.speed_min     = CM_ARGB_SPEED_SLOWEST;
-        Breathing.speed_max     = CM_ARGB_SPEED_FASTEST;
-        Breathing.color_mode    = MODE_COLORS_RANDOM;
-        Breathing.speed         = speed;
-        modes.push_back(Breathing);
+        Flash.name              = "Flash";
+        Flash.value             = CM_RGB_MODE_FLASH;
+        Flash.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+        Flash.colors_min        = 1;
+        Flash.colors_max        = 1;
+        Flash.colors.resize(Flash.colors_max);
+        Flash.speed_min         = CM_ARGB_SPEED_SLOWEST;
+        Flash.speed_max         = CM_ARGB_SPEED_FASTEST;
+        Flash.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+        Flash.speed             = CM_ARGB_SPEED_NORMAL;
+        modes.push_back(Flash);
 
-        mode ColourCycle;
-        ColourCycle.name          = "Colour Cycle";
-        ColourCycle.value         = CM_RGB_MODE_COLOUR_CYCLE;
-        ColourCycle.flags         = MODE_FLAG_HAS_SPEED;
-        ColourCycle.speed_min     = CM_ARGB_SPEED_SLOWEST;
-        ColourCycle.speed_max     = CM_ARGB_SPEED_FASTEST;
-        ColourCycle.color_mode    = MODE_COLORS_NONE;
-        ColourCycle.speed         = speed;
-        modes.push_back(ColourCycle);
+        mode Mirage;
+        Mirage.name             = "Mirage";
+        Mirage.value            = CM_RGB_MODE_MIRAGE;
+        Mirage.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+        Mirage.colors_min       = 1;
+        Mirage.colors_max       = 1;
+        Mirage.colors.resize(Mirage.colors_max);
+        Mirage.speed_min        = CM_ARGB_SPEED_SLOWEST;
+        Mirage.speed_max        = CM_ARGB_SPEED_FASTEST;
+        Mirage.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+        Mirage.speed            = CM_ARGB_SPEED_NORMAL;
+        modes.push_back(Mirage);
 
         mode PassThru;
         PassThru.name           = "Pass Thru";
         PassThru.value          = CM_RGB_MODE_PASSTHRU;
         PassThru.color_mode     = MODE_COLORS_NONE;
         modes.push_back(PassThru);
+
+        mode Off;
+        Off.name                = "Turn Off";
+        Off.value               = CM_RGB_MODE_OFF;
+        Off.color_mode          = MODE_COLORS_NONE;
+        modes.push_back(Off);
     }
 
-    Init_Controller();         //Only processed on first run
+    Init_Controller();
     SetupZones();
-    //active_mode = cmargb->GetMode();
+
+    int temp_mode   = cmargb->GetMode();
+    for(std::size_t mode_idx = 0; mode_idx < modes.size() ; mode_idx++)
+    {
+        if (temp_mode == modes[mode_idx].value)
+        {
+            active_mode = mode_idx;
+            break;
+        }
+    }
+    if (modes[active_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
+    {
+        modes[active_mode].colors[0] = ToRGBColor(cmargb->GetLedRed(), cmargb->GetLedGreen(), cmargb->GetLedBlue());
+    }
+    modes[active_mode].color_mode = (cmargb->GetRandomColours()) ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
+    if (modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
+    {
+        modes[active_mode].speed = cmargb->GetLedSpeed();
+    }
 }
 
 RGBController_CMARGBController::~RGBController_CMARGBController()
 {
-
+    delete cmargb;
 }
 
 void RGBController_CMARGBController::Init_Controller()
 {
     int zone_idx            = cmargb->GetZoneIndex();
     int zone_led_count      = argb_header_data[zone_idx].count;
-    bool boolSingleLED      = ( zone_led_count == 1 );          //If argb_header_data[zone_idx].count == 1 then the zone is ZONE_TYPE_SINGLE
+
+    /*-------------------------------------------------*\
+    | If argb_header_data[zone_idx].count == 1 then the |
+    | zone is ZONE_TYPE_SINGLE                          |
+    \*-------------------------------------------------*/
+    bool boolSingleLED      = ( zone_led_count == 1 );
 
     zone ARGB_zone;
     ARGB_zone.name          = std::to_string(zone_idx);
     ARGB_zone.type          = (boolSingleLED) ? ZONE_TYPE_SINGLE : ZONE_TYPE_LINEAR;
-    ARGB_zone.leds_min      = 0;
-    ARGB_zone.leds_max      = 64;
+    ARGB_zone.leds_min      = 4;
+    ARGB_zone.leds_max      = 48;
     ARGB_zone.leds_count    = zone_led_count;
     ARGB_zone.matrix_map    = NULL;
     zones.push_back(ARGB_zone);
@@ -225,7 +276,12 @@ void RGBController_CMARGBController::SetupZones()
     \*---------------------------------------------------------*/
     for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
-        bool boolSingleLED = (zones[zone_idx].type == ZONE_TYPE_SINGLE);    //Calculated for later use
+        bool boolSingleLED = (zones[zone_idx].type == ZONE_TYPE_SINGLE);
+
+        if (!boolSingleLED)
+        {
+            cmargb->SetLedCount( std::stoi(zones[zone_idx].name), zones[zone_idx].leds_count);
+        }
 
         for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
         {
@@ -257,59 +313,74 @@ void RGBController_CMARGBController::ResizeZone(int zone, int new_size)
     {
         return;
     }
+    uint8_t end_zone = last_zone(zone);
 
-    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
+    for(std::size_t zone_idx = first_zone(zone); zone_idx < end_zone; zone_idx++)
     {
-        zones[zone].leds_count = new_size;
-
-        SetupZones();
+        if(((unsigned int)new_size >= zones[zone_idx].leds_min) && ((unsigned int)new_size <= zones[zone_idx].leds_max))
+        {
+            zones[zone_idx].leds_count = new_size;
+        }
     }
+
+    SetupZones();
 }
 
 void RGBController_CMARGBController::DeviceUpdateLEDs()
 {
-    /*unsigned char red = RGBGetRValue(colors[0]);
-    unsigned char grn = RGBGetGValue(colors[0]);
-    unsigned char blu = RGBGetBValue(colors[0]);
-    cmargb->SetColor(red, grn, blu);*/
+    uint8_t end_zone = last_zone(cmargb->GetZoneIndex());
 
-    //this one
-    cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed );
-    cmargb->SetLedsDirect( zones[0].colors, zones[0].leds_count );
+    for(std::size_t zone_idx = first_zone(cmargb->GetZoneIndex()); zone_idx < end_zone; zone_idx++)
+    {
+        UpdateZoneLEDs(zone_idx);
+    }
 }
 
 void RGBController_CMARGBController::UpdateZoneLEDs(int zone)
 {
-    RGBColor      colour    = colors[zone];
-    unsigned char red       = RGBGetRValue(colour);
-    unsigned char grn       = RGBGetGValue(colour);
-    unsigned char blu       = RGBGetBValue(colour);
-    cmargb->SetColor(red, grn, blu);
+    //cmargb->SetLedsDirect( zones[zone].colors, zones[zone].leds_count );
 }
 
 void RGBController_CMARGBController::UpdateSingleLED(int led)
 {
-        //cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed );
-        //cmargb->SetLedsDirect( zones[0].colors, zones[0].leds_count );
+    UpdateZoneLEDs(GetLED_Zone(led));
 }
 
 void RGBController_CMARGBController::SetCustomMode()
 {
-    active_mode = CM_ARGB_MODE_DIRECT;
+    for(std::size_t mode_idx = 0; mode_idx < modes.size() ; mode_idx++)
+    {
+        if (modes[mode_idx].value == CM_ARGB_MODE_DIRECT)
+        {
+            active_mode = mode_idx;
+            break;
+        }
+    }
 }
 
 void RGBController_CMARGBController::DeviceUpdateMode()
 {
-    if( modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC )
+    bool random_colours     = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+    RGBColor colour         = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
+
+    cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed, colour, random_colours );
+}
+
+int RGBController_CMARGBController::GetLED_Zone(int led_idx)
+{
+    /*---------------------------------------------------------*\
+    | This may be more useful in the abstract RGBController.cpp |
+    \*---------------------------------------------------------*/
+    for(size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
-        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]);
-        cmargb->SetColor(red, grn, blu);
+        int zone_start  = zones[zone_idx].start_idx;
+        int zone_end    = zone_start + zones[zone_idx].leds_count - 1;
+
+        if( zone_start <= led_idx && zone_end >= led_idx)
+        {
+            return(zone_idx);
+        }
     }
-    else
-    {
-        cmargb->SetColor(0, 0, 0);        //If the mode is not colour specific then set colour to black for the random index
-    }
-    cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed );
+
+    return -1;
 }

Controllers/CoolerMasterController/RGBController_CMARGBController.h

@@ -12,6 +12,9 @@
 #include "CMARGBcontroller.h"
 #include <vector>
 
+#define first_zone(zn)          ((zones.size() > 1) ? 1 : 0)
+#define last_zone(zn)           ((zones.size() > 1) ? 4 : 1)
+
 class RGBController_CMARGBController : public RGBController
 {
 public:
@@ -27,9 +30,11 @@ public:
 
     void        SetCustomMode();
     void        DeviceUpdateMode();
+
 private:
     void        Init_Controller();
     int         GetDeviceMode();
+    int         GetLED_Zone(int led_idx);
 
     CMARGBController* cmargb;
 };

Controllers/CoolerMasterController/RGBController_CMMP750Controller.cpp

@@ -11,71 +11,91 @@
 
 RGBController_CMMP750Controller::RGBController_CMMP750Controller(CMMP750Controller* cmmp_ptr)
 {
-    cmmp750             = cmmp_ptr;
-    unsigned char speed = cmmp750->GetLedSpeed();
+    cmmp750                 = cmmp_ptr;
+    unsigned char speed     = cmmp750->GetLedSpeed();
 
-    name                = cmmp750->GetDeviceName();
-    vendor              = "Cooler Master";
-    type                = DEVICE_TYPE_MOUSEMAT;
-    description         = cmmp750->GetDeviceName();
-    version             = "1.0";
-    serial              = cmmp750->GetSerial();
-    location            = cmmp750->GetLocation();
+    name                    = cmmp750->GetDeviceName();
+    vendor                  = "Cooler Master";
+    type                    = DEVICE_TYPE_MOUSEMAT;
+    description             = cmmp750->GetDeviceName();
+    version                 = "1.0";
+    serial                  = cmmp750->GetSerial();
+    location                = cmmp750->GetLocation();
 
     mode Static;
-    Static.name       = "Static";
-    Static.value      = MP750_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode = MODE_COLORS_PER_LED;
+    Static.name             = "Static";
+    Static.value            = CM_MP750_MODE_STATIC;
+    Static.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode       = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     mode Blink;
-    Blink.name       = "Blink";
-    Blink.value      = MP750_MODE_BLINK;
-    Blink.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    Blink.speed_min  = MP750_SPEED_SLOWEST;
-    Blink.speed_max  = MP750_SPEED_FASTEST;
-    Blink.color_mode = MODE_COLORS_PER_LED;
-    Blink.speed      = speed;
+    Blink.name              = "Blink";
+    Blink.value             = CM_MP750_MODE_BLINK;
+    Blink.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Blink.speed_min         = MP750_SPEED_SLOWEST;
+    Blink.speed_max         = MP750_SPEED_FASTEST;
+    Blink.color_mode        = MODE_COLORS_PER_LED;
+    Blink.speed             = speed;
     modes.push_back(Blink);
 
     mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = MP750_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    Breathing.speed_min  = MP750_SPEED_SLOWEST;
-    Breathing.speed_max  = MP750_SPEED_FASTEST;
-    Breathing.color_mode = MODE_COLORS_PER_LED;
-    Breathing.speed      = speed;
+    Breathing.name          = "Breathing";
+    Breathing.value         = CM_MP750_MODE_BREATHING;
+    Breathing.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.speed_min     = MP750_SPEED_SLOWEST;
+    Breathing.speed_max     = MP750_SPEED_FASTEST;
+    Breathing.color_mode    = MODE_COLORS_PER_LED;
+    Breathing.speed         = speed;
     modes.push_back(Breathing);
 
     mode ColorCycle;
-    ColorCycle.name       = "Color Cycle";
-    ColorCycle.value      = MP750_MODE_COLOR_CYCLE;
-    ColorCycle.flags      = MODE_FLAG_HAS_SPEED;
-    ColorCycle.speed_min  = MP750_SPEED_SLOWEST;
-    ColorCycle.speed_max  = MP750_SPEED_FASTEST;
-    ColorCycle.color_mode = MODE_COLORS_NONE;
-    ColorCycle.speed      = speed;
+    ColorCycle.name         = "Color Cycle";
+    ColorCycle.value        = CM_MP750_MODE_COLOR_CYCLE;
+    ColorCycle.flags        = MODE_FLAG_HAS_SPEED;
+    ColorCycle.speed_min    = MP750_SPEED_SLOWEST;
+    ColorCycle.speed_max    = MP750_SPEED_FASTEST;
+    ColorCycle.color_mode   = MODE_COLORS_NONE;
+    ColorCycle.speed        = speed;
     modes.push_back(ColorCycle);
 
     mode BreathCycle;
-    BreathCycle.name       = "Breath Cycle";
-    BreathCycle.value      = MP750_MODE_BREATH_CYCLE;
-    BreathCycle.flags      = MODE_FLAG_HAS_SPEED;
-    BreathCycle.speed_min  = MP750_SPEED_SLOWEST;
-    BreathCycle.speed_max  = MP750_SPEED_FASTEST;
-    BreathCycle.color_mode = MODE_COLORS_NONE;
-    BreathCycle.speed      = speed;
+    BreathCycle.name        = "Breath Cycle";
+    BreathCycle.value       = CM_MP750_MODE_BREATH_CYCLE;
+    BreathCycle.flags       = MODE_FLAG_HAS_SPEED;
+    BreathCycle.speed_min   = MP750_SPEED_SLOWEST;
+    BreathCycle.speed_max   = MP750_SPEED_FASTEST;
+    BreathCycle.color_mode  = MODE_COLORS_NONE;
+    BreathCycle.speed       = speed;
     modes.push_back(BreathCycle);
 
+    mode Off;
+    Off.name                = "Turn Off";
+    Off.value               = CM_MP750_MODE_OFF;
+    Off.color_mode          = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
     SetupZones();
-    active_mode = cmmp750->GetMode();
+    active_mode = GetDeviceMode();
 }
 
 RGBController_CMMP750Controller::~RGBController_CMMP750Controller()
 {
+    delete cmmp750;
+}
 
+int RGBController_CMMP750Controller::GetDeviceMode()
+{
+    int temp_mode = cmmp750->GetMode();
+    for( int i = 0; i < modes.size(); i++)
+    {
+        if (temp_mode == modes[i].value)
+        {
+            return i;
+        }
+    }
+    //If not found return 0
+    return 0;
 }
 
 void RGBController_CMMP750Controller::SetupZones()

Controllers/CoolerMasterController/RGBController_CMR6000Controller.cpp

@@ -0,0 +1,149 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMR6000Controller.cpp                                |
+|                                                                     |
+|  Driver for Coolermaster based AMD Radeon GPU (6000 series)         |
+|                                                                     |
+|  Eric S (edbgon)          2nd Feb 2021                              |
+\*-------------------------------------------------------------------*/
+
+#include "RGBController_CMR6000Controller.h"
+
+RGBController_CMR6000Controller::RGBController_CMR6000Controller(CMR6000Controller* cmmp_ptr)
+{
+    cmr6000             = cmmp_ptr;
+    unsigned char speed = cmr6000->GetLedSpeed();
+
+    name                = "AMD RX 6xxx GPU";
+    vendor              = "Cooler Master";
+    type                = DEVICE_TYPE_GPU;
+    description         = cmr6000->GetDeviceName();
+    version             = "1.0";
+    serial              = cmr6000->GetSerial();
+    location            = cmr6000->GetLocation();
+
+    mode Off;
+    Off.name            = "Off";
+    Off.flags           = 0;
+    Off.value           = CM_MR6000_MODE_OFF;
+    Off.color_mode      = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Static;
+    Static.name         = "Static";
+    Static.value        = CM_MR6000_MODE_STATIC;
+    Static.flags        = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.color_mode   = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min   = 1;
+    Static.colors_max   = 1;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode ColorCycle;
+    ColorCycle.name       = "Color Cycle";
+    ColorCycle.value      = CM_MR6000_MODE_COLOR_CYCLE;
+    ColorCycle.flags      = MODE_FLAG_HAS_SPEED;
+    ColorCycle.speed_min  = MR6000_CYCLE_SPEED_SLOWEST;
+    ColorCycle.speed      = MR6000_CYCLE_SPEED_NORMAL;
+    ColorCycle.speed_max  = MR6000_CYCLE_SPEED_FASTEST;
+    ColorCycle.color_mode = MODE_COLORS_NONE;
+    ColorCycle.speed      = speed;
+    modes.push_back(ColorCycle);
+
+    mode Breathing;
+    Breathing.name       = "Breathing";
+    Breathing.value      = CM_MR6000_MODE_BREATHE;
+    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Breathing.speed_min  = MR6000_BREATHE_SPEED_SLOWEST;
+    Breathing.speed      = MR6000_BREATHE_SPEED_NORMAL;
+    Breathing.speed_max  = MR6000_BREATHE_SPEED_FASTEST;
+    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors_min = 1;
+    Breathing.colors_max = 1;
+    Breathing.colors.resize(1);
+    Breathing.speed      = speed;
+    modes.push_back(Breathing);    
+
+    SetupZones();
+    active_mode = cmr6000->GetMode();
+    if (modes[active_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
+    {
+        modes[active_mode].colors[0] = ToRGBColor(cmr6000->GetLedRed(), cmr6000->GetLedGreen(), cmr6000->GetLedBlue());
+    }
+    if (modes[active_mode].flags & MODE_FLAG_HAS_RANDOM_COLOR)
+    {
+        modes[active_mode].color_mode = (cmr6000->GetRandomColours()) ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
+    }
+    if (modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
+    {
+        modes[active_mode].speed = cmr6000->GetLedSpeed();
+    }
+}
+
+RGBController_CMR6000Controller::~RGBController_CMR6000Controller()
+{
+    delete cmr6000;
+}
+
+void RGBController_CMR6000Controller::SetupZones()
+{
+    zone GP_zone;
+    GP_zone.name          = "GPU";
+    GP_zone.type          = ZONE_TYPE_SINGLE;
+    GP_zone.leds_min      = 1;
+    GP_zone.leds_max      = 1;
+    GP_zone.leds_count    = 1;
+    GP_zone.matrix_map    = NULL;
+    zones.push_back(GP_zone);
+
+    led GP_led;
+    GP_led.name = "Logo";
+    leds.push_back(GP_led);
+
+    SetupColors();
+
+}
+
+void RGBController_CMR6000Controller::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_CMR6000Controller::DeviceUpdateLEDs()
+{
+    unsigned char red = 0;
+    unsigned char grn = 0;
+    unsigned char blu = 0;
+
+    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        red = RGBGetRValue(modes[active_mode].colors[0]);
+        grn = RGBGetGValue(modes[active_mode].colors[0]);
+        blu = RGBGetBValue(modes[active_mode].colors[0]);
+    }
+
+    unsigned char rnd = (modes[active_mode].color_mode == MODE_COLORS_RANDOM) ? 0xA0 : 0x20;
+
+    cmr6000->SetMode(modes[active_mode].value, modes[active_mode].speed, red, grn, blu, rnd);
+}
+
+void RGBController_CMR6000Controller::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CMR6000Controller::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CMR6000Controller::SetCustomMode()
+{
+    active_mode = 1;
+}
+
+void RGBController_CMR6000Controller::DeviceUpdateMode()
+{
+    DeviceUpdateLEDs();
+}

Controllers/CoolerMasterController/RGBController_CMR6000Controller.h

@@ -0,0 +1,32 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMR6000Controller.h                                  |
+|                                                                     |
+|  Driver for Coolermaster based AMD Radeon GPU (6000 series)         |
+|                                                                     |
+|  Eric S (edbgon)          2nd Feb 2021                              |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "CMR6000Controller.h"
+
+class RGBController_CMR6000Controller : public RGBController
+{
+public:
+    RGBController_CMR6000Controller(CMR6000Controller* cmmp_ptr);
+    ~RGBController_CMR6000Controller();
+
+    void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+private:
+    CMR6000Controller* cmr6000;
+
+    int         GetDeviceMode();
+};

Controllers/CoolerMasterController/RGBController_CMSmallARGBController.cpp

@@ -0,0 +1,251 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMSmallARGBController.cpp                            |
+|                                                                     |
+|  Driver for Coolermaster Small ARGB USB Controller                  |
+|                                                                     |
+|  Chris M (Dr_No)          31st Jan 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "RGBController_CMSmallARGBController.h"
+
+RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmallARGBController *cmargb_ptr)
+{
+    cmargb                  = cmargb_ptr;
+    unsigned char speed     = cmargb->GetLedSpeed();
+
+    name                    = small_argb_header_data[cmargb->GetZoneIndex()].name;
+    vendor                  = "Cooler Master";
+    type                    = DEVICE_TYPE_LEDSTRIP;
+    description             = cmargb->GetDeviceName();
+    version                 = "1.0";
+    serial                  = cmargb->GetSerial();
+    location                = cmargb->GetLocation();
+
+    mode Off;
+    Off.name                = "Turn Off";
+    Off.value               = CM_SMALL_ARGB_MODE_OFF;
+    Off.color_mode          = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Reload;
+    Reload.name             = "Reload";
+    Reload.value            = CM_SMALL_ARGB_MODE_RELOAD;
+    Reload.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Reload.colors_min       = 1;
+    Reload.colors_max       = 1;
+    Reload.colors.resize(Reload.colors_max);
+    Reload.speed_min        = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Reload.speed_max        = CM_SMALL_ARGB_SPEED_FASTEST;
+    Reload.color_mode       = MODE_COLORS_RANDOM;
+    Reload.speed            = speed;
+    modes.push_back(Reload);
+
+    mode Recoil;
+    Recoil.name             = "Recoil";
+    Recoil.value            = CM_SMALL_ARGB_MODE_RECOIL;
+    Recoil.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Recoil.colors_min       = 1;
+    Recoil.colors_max       = 1;
+    Recoil.colors.resize(Recoil.colors_max);
+    Recoil.speed_min        = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Recoil.speed_max        = CM_SMALL_ARGB_SPEED_FASTEST;
+    Recoil.color_mode       = MODE_COLORS_RANDOM;
+    Recoil.speed            = speed;
+    modes.push_back(Recoil);
+
+    mode Breathing;
+    Breathing.name          = "Breathing";
+    Breathing.value         = CM_SMALL_ARGB_MODE_BREATHING;
+    Breathing.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Breathing.colors_min    = 1;
+    Breathing.colors_max    = 1;
+    Breathing.colors.resize(Breathing.colors_max);
+    Breathing.speed_min     = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Breathing.speed_max     = CM_SMALL_ARGB_SPEED_FASTEST;
+    Breathing.color_mode    = MODE_COLORS_RANDOM;
+    Breathing.speed         = speed;
+    modes.push_back(Breathing);
+
+    mode Refill;
+    Refill.name             = "Refill";
+    Refill.value            = CM_SMALL_ARGB_MODE_REFILL;
+    Refill.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Refill.colors_min       = 1;
+    Refill.colors_max       = 1;
+    Refill.colors.resize(Refill.colors_max);
+    Refill.speed_min        = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Refill.speed_max        = CM_SMALL_ARGB_SPEED_FASTEST;
+    Refill.color_mode       = MODE_COLORS_RANDOM;
+    Refill.speed            = speed;
+    modes.push_back(Refill);
+
+    mode Demo;
+    Demo.name               = "Demo";
+    Demo.value              = CM_SMALL_ARGB_MODE_DEMO;
+    Demo.flags              = MODE_FLAG_HAS_SPEED;
+    Demo.speed_min          = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Demo.speed_max          = CM_SMALL_ARGB_SPEED_FASTEST;
+    Demo.color_mode         = MODE_COLORS_NONE;
+    Demo.speed              = speed;
+    modes.push_back(Demo);
+
+    mode Spectrum;
+    Spectrum.name           = "Spectrum";
+    Spectrum.value          = CM_SMALL_ARGB_MODE_SPECTRUM;
+    Spectrum.flags          = MODE_FLAG_HAS_SPEED;
+    Spectrum.speed_min      = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Spectrum.speed_max      = CM_SMALL_ARGB_SPEED_FASTEST;
+    Spectrum.color_mode     = MODE_COLORS_NONE;
+    Spectrum.speed          = speed;
+    modes.push_back(Spectrum);
+
+    mode Direct;
+    Direct.name             = "Direct";
+    Direct.value            = CM_SMALL_ARGB_MODE_DIRECT;
+    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode PassThru;
+    PassThru.name           = "Pass Thru";
+    PassThru.value          = CM_SMALL_ARGB_MODE_PASSTHRU;
+    PassThru.color_mode     = MODE_COLORS_NONE;
+    modes.push_back(PassThru);
+
+    Init_Controller();         //Only processed on first run
+    SetupZones();
+
+    int temp_mode   = cmargb->GetMode();
+    for(std::size_t mode_idx = 0; mode_idx < modes.size() ; mode_idx++)
+    {
+        if (temp_mode == modes[mode_idx].value)
+        {
+            active_mode = mode_idx;
+            break;
+        }
+    }
+    if (modes[active_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
+    {
+        modes[active_mode].colors[0] = ToRGBColor(cmargb->GetLedRed(), cmargb->GetLedGreen(), cmargb->GetLedBlue());
+    }
+    modes[active_mode].color_mode = (cmargb->GetRandomColours()) ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
+    if (modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
+    {
+        modes[active_mode].speed = cmargb->GetLedSpeed();
+    }
+}
+
+RGBController_CMSmallARGBController::~RGBController_CMSmallARGBController()
+{
+    delete cmargb;
+}
+
+void RGBController_CMSmallARGBController::Init_Controller()
+{
+    int zone_idx            = cmargb->GetZoneIndex();
+    int zone_led_count      = small_argb_header_data[zone_idx].count;
+    bool boolSingleLED      = ( zone_led_count == 1 );          //If argb_header_data[zone_idx].count == 1 then the zone is ZONE_TYPE_SINGLE
+
+    zone ARGB_zone;
+    ARGB_zone.name          = std::to_string(zone_idx);
+    ARGB_zone.type          = (boolSingleLED) ? ZONE_TYPE_SINGLE : ZONE_TYPE_LINEAR;
+    ARGB_zone.leds_min      = CM_SMALL_ARGB_MIN_LEDS;
+    ARGB_zone.leds_max      = CM_SMALL_ARGB_MAX_LEDS;
+    ARGB_zone.leds_count    = zone_led_count;
+    ARGB_zone.matrix_map    = NULL;
+    zones.push_back(ARGB_zone);
+}
+
+void RGBController_CMSmallARGBController::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
+    leds.clear();
+    colors.clear();
+
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        bool boolSingleLED = (zones[zone_idx].type == ZONE_TYPE_SINGLE);    //Calculated for later use
+
+        if (!boolSingleLED)
+        {
+            cmargb->SetLedCount(small_argb_header_data[zone_idx].header, zones[zone_idx].leds_count);
+        }
+
+        for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
+        {
+            led     new_led;
+            unsigned int i = std::stoi(zones[zone_idx].name);
+
+            if(boolSingleLED)
+            {
+                new_led.name  = i;
+                new_led.value = small_argb_header_data[i].header;
+            }
+            else
+            {
+                new_led.name = i;
+                new_led.name.append(" LED " + std::to_string(lp_idx));
+                new_led.value = small_argb_header_data[i].header;
+            }
+
+            leds.push_back(new_led);
+        }
+    }
+
+    SetupColors();
+}
+
+void RGBController_CMSmallARGBController::ResizeZone(int zone, int new_size)
+{
+    if((size_t) zone >= zones.size())
+    {
+        return;
+    }
+
+    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
+    {
+        zones[zone].leds_count = new_size;
+
+        SetupZones();
+    }
+}
+
+void RGBController_CMSmallARGBController::DeviceUpdateLEDs()
+{
+    for(size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        UpdateZoneLEDs(zone_idx);
+    }
+}
+
+void RGBController_CMSmallARGBController::UpdateZoneLEDs(int zone)
+{
+    bool random_colours     = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+
+    //cmargb->SetLedsDirect(zones[zone].colors, random_colours);
+}
+
+void RGBController_CMSmallARGBController::UpdateSingleLED(int led)
+{
+    //cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed );
+    //cmargb->SetLedsDirect( zones[0].colors, zones[0].leds_count );
+}
+
+void RGBController_CMSmallARGBController::SetCustomMode()
+{
+    active_mode = CM_SMALL_ARGB_MODE_DIRECT;  //The small ARGB may not support "Direct" mode
+}
+
+void RGBController_CMSmallARGBController::DeviceUpdateMode()
+{
+    bool random_colours     = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+    RGBColor colour         = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
+
+    cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed, colour, random_colours );
+}

Controllers/CoolerMasterController/RGBController_CMSmallARGBController.h

@@ -0,0 +1,38 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMSmallARGBController.h                              |
+|                                                                     |
+|  Driver for Coolermaster Small ARGB USB Controller                  |
+|                                                                     |
+|  Chris M (Dr_No)          31st Jan 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "CMSmallARGBController.h"
+#include <vector>
+
+#define CM_SMALL_ARGB_MIN_LEDS 4
+#define CM_SMALL_ARGB_MAX_LEDS 48
+
+class RGBController_CMSmallARGBController : public RGBController
+{
+public:
+    RGBController_CMSmallARGBController(CMSmallARGBController* cmargb_ptr);
+    ~RGBController_CMSmallARGBController();
+
+    void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+private:
+    void        Init_Controller();
+    int         GetDeviceMode();
+
+    CMSmallARGBController* cmargb;
+};

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumControllerDetect.cpp

@@ -47,7 +47,7 @@ bool TestForCorsairDominatorPlatinumController(i2c_smbus_interface *bus, unsigne
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *> &busses, std::vector<RGBController *> &rgb_controllers)
+void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *> &busses)
 {
     for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
@@ -59,7 +59,7 @@ void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *
                 {
                     CorsairDominatorPlatinumController* new_controller        = new CorsairDominatorPlatinumController(busses[bus], addr);
                     RGBController_CorsairDominatorPlatinum* new_rgbcontroller = new RGBController_CorsairDominatorPlatinum(new_controller);
-                    rgb_controllers.push_back(new_rgbcontroller);
+                    ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
                 }
                 std::this_thread::sleep_for(10ms);
             }

Controllers/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.cpp

@@ -33,6 +33,11 @@ RGBController_CorsairDominatorPlatinum::RGBController_CorsairDominatorPlatinum(C
     active_mode = 0;
 }
 
+RGBController_CorsairDominatorPlatinum::~RGBController_CorsairDominatorPlatinum()
+{
+    delete corsair;
+}
+
 void RGBController_CorsairDominatorPlatinum::SetupZones()
 {
     /*---------------------------------------------------------*\

Controllers/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.h

@@ -15,6 +15,7 @@ class RGBController_CorsairDominatorPlatinum : public RGBController
 {
 public:
     RGBController_CorsairDominatorPlatinum(CorsairDominatorPlatinumController* corsair_ptr);
+    ~RGBController_CorsairDominatorPlatinum();
 
     void SetupZones();
 

Controllers/CorsairHydroController/CorsairHydroController.cpp

@@ -29,6 +29,14 @@ CorsairHydroController::CorsairHydroController(libusb_device_handle* dev_handle)
     SendFirmwareRequest();
 }
 
+CorsairHydroController::~CorsairHydroController()
+{
+    if(dev)
+    {
+        libusb_close(dev);
+    }
+}
+
 std::string CorsairHydroController::GetFirmwareString()
 {
     return(firmware_version);

Controllers/CorsairHydroController/CorsairHydroControllerDetect.cpp

@@ -47,16 +47,15 @@ static const corsair_hydro_device device_list[] =
 
 void DetectCorsairHydroControllers(std::vector<RGBController*>& rgb_controllers)
 {
-    libusb_context * ctx;
-    libusb_init(&ctx);
+    libusb_init(NULL);
 
     #ifdef _WIN32
-    libusb_set_option(ctx, LIBUSB_OPTION_USE_USBDK);
+    libusb_set_option(NULL, LIBUSB_OPTION_USE_USBDK);
     #endif
 
     for(std::size_t device_idx = 0; device_idx < CORSAIR_NUM_DEVICES; device_idx++)
     {
-        libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+        libusb_device_handle * dev = libusb_open_device_with_vid_pid(NULL, device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
 
         //Look for Corsair RGB Peripheral
         if(dev)

Controllers/CorsairHydroController/RGBController_CorsairHydro.cpp

@@ -68,6 +68,11 @@ RGBController_CorsairHydro::RGBController_CorsairHydro(CorsairHydroController* c
     SetupZones();
 }
 
+RGBController_CorsairHydro::~RGBController_CorsairHydro()
+{
+    delete corsair;
+}
+
 void RGBController_CorsairHydro::SetupZones()
 {
     zone new_zone;

Controllers/CorsairHydroController/RGBController_CorsairHydro.h

@@ -15,6 +15,7 @@ class RGBController_CorsairHydro : public RGBController
 {
 public:
     RGBController_CorsairHydro(CorsairHydroController* corsair_ptr);
+    ~RGBController_CorsairHydro();
 
     void        SetupZones();
 

Controllers/CorsairHydroPlatinumController/CorsairHydroPlatinumController.cpp

@@ -0,0 +1,245 @@
+/*-------------------------------------------------------------------*\
+|  CorsairHydroPlatinumController.cpp                                 |
+|                                                                     |
+|  Driver for Corsair Hydro Platinum AIO Coolers                      |
+|                                                                     |
+|  Kasper         28th March 2021                                     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "CorsairHydroPlatinumController.h"
+#include <cstring>
+
+static const uint8_t CRC_TABLE[256] =
+{
+    0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
+    0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
+    0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
+    0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
+    0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
+    0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
+    0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
+    0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
+    0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
+    0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
+    0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
+    0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
+    0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
+    0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
+    0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
+    0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
+    0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
+    0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
+    0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
+    0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
+    0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
+    0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
+    0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
+    0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
+    0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
+    0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
+    0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
+    0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
+    0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
+    0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
+    0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
+    0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
+};
+
+static const uint8_t MAGIC_1[61] =
+{
+    0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f,
+    0x7f, 0x7f, 0x7f, 0xff, 0x00, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff,
+    0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff,
+    0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff
+};
+
+static const uint8_t MAGIC_2[61] =
+{
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+    0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff
+};
+
+static const uint8_t MAGIC_3[61] =
+{
+    0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
+    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+    0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+    0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+    0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff
+};
+
+CorsairHydroPlatinumController::CorsairHydroPlatinumController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+
+    SendMagic(MAGIC_1, CORSAIR_HYDRO_PLATINUM_MAGIC_1);
+    SendMagic(MAGIC_2, CORSAIR_HYDRO_PLATINUM_MAGIC_2);
+    SendMagic(MAGIC_3, CORSAIR_HYDRO_PLATINUM_MAGIC_3);
+}
+
+CorsairHydroPlatinumController::~CorsairHydroPlatinumController()
+{
+    hid_close(dev);
+}
+
+std::string CorsairHydroPlatinumController::GetLocation()
+{
+    return location;
+}
+
+std::string CorsairHydroPlatinumController::GetFirmwareString()
+{
+    return firmware_version;
+}
+
+void CorsairHydroPlatinumController::SetupColors(std::vector<RGBColor> colors)
+{
+    unsigned int end_led = colors.size() >= 20 ? 20 : colors.size();
+    SendColors(colors, 0, end_led, CORSAIR_HYDRO_PLATINUM_SET_LIGHTING_1);
+
+    if(colors.size() > 20)
+    {
+        end_led = colors.size() >= 40 ? 40 : colors.size();
+        SendColors(colors, 20, end_led, CORSAIR_HYDRO_PLATINUM_SET_LIGHTING_2);
+    }
+    if(colors.size() > 40)
+    {
+        end_led = colors.size() >= 48 ? 48 : colors.size();
+        SendColors(colors, 40, end_led, CORSAIR_HYDRO_PLATINUM_SET_LIGHTING_3);
+    }
+}
+
+void CorsairHydroPlatinumController::SendMagic(const uint8_t* magic, unsigned int command)
+{
+    unsigned char usb_buf[CORSAIR_HYDRO_PLATINUM_PACKET_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Set up config table request packet                    |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00] = 0x00;
+    usb_buf[0x01] = 0x3F;
+    usb_buf[0x02] = (GetSequenceNumber()) | command;
+
+    /*-----------------------------------------------------*\
+    | Copy the magic bytes into the buffer                  |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[3], magic, 61 * sizeof magic[0]);
+
+    /*-----------------------------------------------------*\
+    | The data sent to the PEC function should not contain  |
+    | the first (report id), second (prefix) and            |
+    | last (checksum) bytes                                 |
+    \*-----------------------------------------------------*/
+    std::vector<unsigned char> checksum_array;
+    checksum_array.insert(checksum_array.begin(), std::begin(usb_buf) + 2, std::end(usb_buf) - 1);
+    usb_buf[64] = ComputePEC(static_cast<void*>(checksum_array.data()), 62);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
+    hid_read(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
+
+    if(firmware_version.empty())
+    {
+        firmware_version =
+            std::to_string(usb_buf[2] >> 4) + "."
+            + std::to_string(usb_buf[2] & 0xf) + "."
+            + std::to_string(usb_buf[3]);
+    }
+
+    /*-----------------------------------------------------*\
+    | This delay prevents the AIO from soft-locking when    |
+    | using an EE.                                          |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(CORSAIR_HYDRO_PLATINUM_PACKET_DELAY));
+}
+
+void CorsairHydroPlatinumController::SendColors(std::vector<RGBColor> colors, unsigned int start, unsigned int end, unsigned int command)
+{
+    unsigned char usb_buf[CORSAIR_HYDRO_PLATINUM_PACKET_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
+
+    /*-----------------------------------------------------*\
+    | Set up config table request packet                    |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00] = 0x00;
+    usb_buf[0x01] = 0x3F;
+    usb_buf[0x02] = (GetSequenceNumber()) | command;
+
+    unsigned int i = 0;
+    for(std::size_t color_idx = start; color_idx < end; color_idx++)
+    {
+        usb_buf[(i * 3) + 3] = RGBGetBValue(colors[color_idx]);
+        usb_buf[(i * 3) + 4] = RGBGetGValue(colors[color_idx]);
+        usb_buf[(i * 3) + 5] = RGBGetRValue(colors[color_idx]);
+        i++;
+    }
+
+    /*-----------------------------------------------------*\
+    | The data sent to the PEC function should not contain  |
+    | the first (report id), second (prefix) and            |
+    | last (checksum) bytes                                 |
+    \*-----------------------------------------------------*/
+    std::vector<unsigned char> checksum_array;
+    checksum_array.insert(checksum_array.begin(), std::begin(usb_buf) + 2, std::end(usb_buf) - 1);
+    usb_buf[64] = ComputePEC(static_cast<void*>(checksum_array.data()), 62);
+
+    hid_write(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
+    hid_read(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
+
+    /*-----------------------------------------------------*\
+    | This delay prevents the AIO from soft-locking when    |
+    | using an EE.                                          |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(CORSAIR_HYDRO_PLATINUM_PACKET_DELAY));
+}
+
+unsigned int CorsairHydroPlatinumController::GetSequenceNumber()
+{
+    if(sequence_number < 31)
+    {
+        sequence_number++;
+    }
+    else
+    {
+        sequence_number = 1;
+    }
+
+    return(sequence_number << 3);
+}
+
+uint8_t CorsairHydroPlatinumController::ComputePEC(const void * data, size_t size)
+{
+	uint8_t val = 0;
+
+	uint8_t * pos = (uint8_t *) data;
+	uint8_t * end = pos + size;
+
+	while (pos < end)
+    {
+		val = CRC_TABLE[val ^ *pos];
+		pos++;
+	}
+
+	return val;
+}

Controllers/CorsairHydroPlatinumController/CorsairHydroPlatinumController.h

@@ -0,0 +1,52 @@
+/*-------------------------------------------------------------------*\
+|  CorsairHydroPlatinumController.h                                   |
+|                                                                     |
+|  Driver for Corsair Hydro Platinum AIO Coolers                      |
+|                                                                     |
+|  Kasper         28th March 2021                                     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include <vector>
+#include <string>
+#include <hidapi/hidapi.h>
+
+#define CORSAIR_HYDRO_PLATINUM_PACKET_SIZE 65
+#define CORSAIR_HYDRO_PLATINUM_PACKET_DELAY 3
+
+enum
+{
+    CORSAIR_HYDRO_PLATINUM_MAGIC_1 = 0b001,
+    CORSAIR_HYDRO_PLATINUM_MAGIC_2 = 0b010,
+    CORSAIR_HYDRO_PLATINUM_MAGIC_3 = 0b011,
+
+    CORSAIR_HYDRO_PLATINUM_SET_LIGHTING_1 = 0b100,
+    CORSAIR_HYDRO_PLATINUM_SET_LIGHTING_2 = 0b101,
+    CORSAIR_HYDRO_PLATINUM_SET_LIGHTING_3 = 0b110,
+};
+
+class CorsairHydroPlatinumController
+{
+public:
+    CorsairHydroPlatinumController(hid_device* dev_handle, const char* path);
+    ~CorsairHydroPlatinumController();
+
+    std::string GetLocation();
+    std::string GetFirmwareString();
+    void SetupColors(std::vector<RGBColor> colors);
+
+private:
+    hid_device* dev;
+    std::string location;
+    std::string firmware_version;
+
+    std::atomic<unsigned int> sequence_number;
+
+    void SendMagic(const uint8_t* magic, unsigned int command);
+    void SendColors(std::vector<RGBColor> colors, unsigned int start, unsigned int end, unsigned int command);
+    unsigned int GetSequenceNumber();
+    uint8_t ComputePEC(const void * data, size_t size);
+};

Controllers/CorsairHydroPlatinumController/CorsairHydroPlatinumControllerDetect.cpp

@@ -0,0 +1,49 @@
+/*-------------------------------------------------------------------*\
+|  CorsairHydroPlatinumControllerDetect.cpp                           |
+|                                                                     |
+|  Driver for Corsair Hydro Platinum AIO Coolers                      |
+|                                                                     |
+|  Kasper         28th March 2021                                     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "Detector.h"
+#include "CorsairHydroPlatinumController.h"
+#include "RGBController.h"
+#include "RGBController_CorsairHydroPlatinum.h"
+#include <hidapi/hidapi.h>
+
+/*-----------------------------------------------------*\
+| Corsair vendor ID                                     |
+\*-----------------------------------------------------*/
+#define CORSAIR_VID 0x1B1C
+
+/*-----------------------------------------------------*\
+| Product IDs                                           |
+\*-----------------------------------------------------*/
+#define CORSAIR_HYDRO_H100I_PLATINUM_PID    0x0c18
+#define CORSAIR_HYDRO_H100I_PLATINUM_SE_PID 0x0C19
+#define CORSAIR_HYDRO_H115I_PLATINUM_PID    0x0c17
+#define CORSAIR_HYDRO_H100I_PRO_XT_PID      0x0c20
+#define CORSAIR_HYDRO_H115I_PRO_XT_PID      0x0c21
+#define CORSAIR_HYDRO_H150I_PRO_XT_PID      0x0c22
+
+void DetectCorsairHydroPlatinumControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if( dev )
+    {
+        CorsairHydroPlatinumController* controller = new CorsairHydroPlatinumController(dev, info->path);
+        RGBController_CorsairHydroPlatinum* rgb_controller = new RGBController_CorsairHydroPlatinum(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR("Corsair Hydro H100i Platinum",       DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H100I_PLATINUM_PID    );
+REGISTER_HID_DETECTOR("Corsair Hydro H100i Platinum SE",    DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H100I_PLATINUM_SE_PID );
+REGISTER_HID_DETECTOR("Corsair Hydro H115i Platinum",       DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H115I_PLATINUM_PID    );
+REGISTER_HID_DETECTOR("Corsair Hydro H100i Pro XT",         DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H100I_PRO_XT_PID      );
+REGISTER_HID_DETECTOR("Corsair Hydro H115i Pro XT",         DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H115I_PRO_XT_PID      );
+REGISTER_HID_DETECTOR("Corsair Hydro H150i Pro XT",         DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H150I_PRO_XT_PID      );

Controllers/CorsairHydroPlatinumController/RGBController_CorsairHydroPlatinum.cpp

@@ -0,0 +1,127 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CorsairHydroPlatinum.cpp                             |
+|                                                                     |
+|  Driver for Corsair Hydro Platinum AIO Coolers                      |
+|                                                                     |
+|  Kasper         28th March 2021                                     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "RGBController_CorsairHydroPlatinum.h"
+
+#define NA 0xFFFFFFFF
+static unsigned int matrix_map[5][5] =
+{
+    { NA,  11,  12,  13,  NA },
+    { 10,  NA,  1,   NA,  14 },
+    { 9,   0,   NA,  2,   15 },
+    { 8,   NA,  3,   NA,   4 },
+    { NA,  7,   6,   5,   NA }
+};
+
+RGBController_CorsairHydroPlatinum::RGBController_CorsairHydroPlatinum(CorsairHydroPlatinumController* corsair_ptr)
+{
+    corsair = corsair_ptr;
+
+    name        = "Corsair Hydro Platinum Series Device";
+    vendor      = "Corsair";
+    description = "Corsair Hydro Platinum Series Device";
+    type        = DEVICE_TYPE_COOLER;
+    location    = corsair->GetLocation();
+    version     = corsair->GetFirmwareString();
+
+    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);
+
+    Init_Controller();
+    SetupZones();
+}
+
+void RGBController_CorsairHydroPlatinum::Init_Controller()
+{
+    zone cpu_block_zone;
+    cpu_block_zone.name               = "CPU Block";
+    cpu_block_zone.type               = ZONE_TYPE_MATRIX;
+    cpu_block_zone.leds_min           = 16;
+    cpu_block_zone.leds_max           = 16;
+    cpu_block_zone.leds_count         = 16;
+    cpu_block_zone.matrix_map         = new matrix_map_type;
+    cpu_block_zone.matrix_map->height = 5;
+    cpu_block_zone.matrix_map->width  = 5;
+    cpu_block_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+    zones.push_back(cpu_block_zone);
+
+    zone fans_zone;
+    fans_zone.name       = "Fans";
+    fans_zone.type       = ZONE_TYPE_LINEAR;
+    fans_zone.leds_min   = 0;
+    fans_zone.leds_max   = 32;
+    fans_zone.leds_count = 0;
+    fans_zone.matrix_map = NULL;
+    zones.push_back(fans_zone);
+}
+
+void RGBController_CorsairHydroPlatinum::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
+    leds.clear();
+    colors.clear();
+
+    for (unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        for (unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
+        {
+            led new_led;
+            new_led.name = zones[zone_idx].name + " " + std::to_string(led_idx);;
+            leds.push_back(new_led);
+        }
+    }
+
+    SetupColors();
+}
+
+void RGBController_CorsairHydroPlatinum::ResizeZone(int zone, int new_size)
+{
+    if((size_t) zone >= zones.size())
+    {
+        return;
+    }
+
+    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
+    {
+        zones[zone].leds_count = new_size;
+
+        SetupZones();
+    }
+}
+
+void RGBController_CorsairHydroPlatinum::DeviceUpdateLEDs()
+{
+    corsair->SetupColors(colors);
+}
+
+void RGBController_CorsairHydroPlatinum::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CorsairHydroPlatinum::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CorsairHydroPlatinum::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_CorsairHydroPlatinum::DeviceUpdateMode()
+{
+
+}

Controllers/CorsairHydroPlatinumController/RGBController_CorsairHydroPlatinum.h

@@ -0,0 +1,34 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CorsairHydroPlatinum.h                               |
+|                                                                     |
+|  Driver for Corsair Hydro Platinum AIO Coolers                      |
+|                                                                     |
+|  Kasper         28th March 2021                                     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "CorsairHydroPlatinumController.h"
+
+class RGBController_CorsairHydroPlatinum : public RGBController
+{
+public:
+    RGBController_CorsairHydroPlatinum(CorsairHydroPlatinumController* corsair_ptr);
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    CorsairHydroPlatinumController* corsair;
+
+    void        Init_Controller();
+};

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

@@ -35,6 +35,8 @@ CorsairLightingNodeController::~CorsairLightingNodeController()
     keepalive_thread_run = 0;
     keepalive_thread->join();
     delete keepalive_thread;
+
+    hid_close(dev);
 }
 
 void CorsairLightingNodeController::KeepaliveThread()

Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.cpp

@@ -167,6 +167,11 @@ RGBController_CorsairLightingNode::RGBController_CorsairLightingNode(CorsairLigh
     SetupZones();
 }
 
+RGBController_CorsairLightingNode::~RGBController_CorsairLightingNode()
+{
+    delete corsair;
+}
+
 void RGBController_CorsairLightingNode::SetupZones()
 {
     /*-------------------------------------------------*\

Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.h

@@ -15,6 +15,7 @@ class RGBController_CorsairLightingNode : public RGBController
 {
 public:
     RGBController_CorsairLightingNode(CorsairLightingNodeController* corsair_ptr);
+    ~RGBController_CorsairLightingNode();
 
     void        SetupZones();
 

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

@@ -20,7 +20,7 @@ static unsigned int keys[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x
                               79,   80,   81,   84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   96,   97,
                               98,   99,   100,  101,  102,  103,  104,  105,  108,  109,  110,  111,  112,  113,  115,
                               116,  117,  120,  121,  122,  123,  124,  126,  127,  128,  129,  132,  133,  134,  135,
-                              136,  137,  139,  140,  141};
+                              136,  137,  139,  140,  141, 0x10, 114};
 
 
 static unsigned int keys_k95_plat[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0C, 0x0D, 0x0E, 0x0F, 0x11, 0x12,
@@ -31,7 +31,7 @@ static unsigned int keys_k95_plat[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
                                        98,   99,   100,  101,  102,  103,  104,  105,  108,  109,  110,  111,  112,  113,  115,
                                        116,  117,  120,  121,  122,  123,  124,  126,  127,  128,  129,  132,  133,  134,  135,
                                        136,  137,  139,  140,  141,
-                                       0x10, 114, 0x0a, 0x16, 0x22, 0x2e, 0x3a, 0x46,
+                                       0x10, 114, 0x0a, 0x16, 0x22, 0x2e, 0x3a, 0x46,  125,
                                        144,  145,  146,  158,  160,  147,  148,  149,  150,  151,  152,  153,
                                        154,  155,  159,  162,  161,  156,  157};
 
@@ -55,15 +55,25 @@ CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle,
 
     ReadFirmwareInfo();
 
+    /*-----------------------------------------------------*\
+    | K95 Platinum requires additional steps                |
+    \*-----------------------------------------------------*/
+    if (logical_layout == CORSAIR_TYPE_K95_PLAT)
+    {
+        SpecialFunctionControl();
+    }
+
     LightingControl();
+
+    if (logical_layout == CORSAIR_TYPE_K95_PLAT)
+    {
+        SetupK95LightingControl();
+    }
 }
 
 CorsairPeripheralController::~CorsairPeripheralController()
 {
-    if(dev)
-    {
-        hid_close(dev);
-    }
+    hid_close(dev);
 }
 
 device_type CorsairPeripheralController::GetDeviceType()
@@ -112,7 +122,14 @@ void CorsairPeripheralController::SetLEDs(std::vector<RGBColor>colors)
     switch(type)
     {
         case DEVICE_TYPE_KEYBOARD:
-            SetLEDsKeyboardFull(colors);
+            if (logical_layout == CORSAIR_TYPE_K55)
+            {
+                SubmitKeyboardZonesColors(colors[0], colors[1], colors[2]);
+            }
+            else
+            {
+                SetLEDsKeyboardFull(colors);
+            }
             break;
 
         case DEVICE_TYPE_MOUSE:
@@ -150,6 +167,7 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
     unsigned char red_val[168];
     unsigned char grn_val[168];
     unsigned char blu_val[168];
+    unsigned char data_sz = 24;
 
     /*-----------------------------------------------------*\
     | Zero out buffers                                      |
@@ -169,12 +187,14 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
             red_val[keys_k95_plat[color_idx]] = RGBGetRValue(color);
             grn_val[keys_k95_plat[color_idx]] = RGBGetGValue(color);
             blu_val[keys_k95_plat[color_idx]] = RGBGetBValue(color);
+            data_sz = 48;
         }
         else if (logical_layout == CORSAIR_TYPE_K95)
         {
             red_val[keys_k95[color_idx]] = RGBGetRValue(color);
             grn_val[keys_k95[color_idx]] = RGBGetGValue(color);
             blu_val[keys_k95[color_idx]] = RGBGetBValue(color);
+            data_sz = 48; //untested
         }
         else
         {
@@ -189,7 +209,7 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
     \*-----------------------------------------------------*/
     StreamPacket(1, 60, &red_val[0]);
     StreamPacket(2, 60, &red_val[60]);
-    StreamPacket(3, 48, &red_val[120]);
+    StreamPacket(3, data_sz, &red_val[120]);
     SubmitKeyboardFullColors(1, 3, 1);
 
     /*-----------------------------------------------------*\
@@ -197,7 +217,7 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
     \*-----------------------------------------------------*/
     StreamPacket(1, 60, &grn_val[0]);
     StreamPacket(2, 60, &grn_val[60]);
-    StreamPacket(3, 48, &grn_val[120]);
+    StreamPacket(3, data_sz, &grn_val[120]);
     SubmitKeyboardFullColors(2, 3, 1);
 
     /*-----------------------------------------------------*\
@@ -205,10 +225,11 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
     \*-----------------------------------------------------*/
     StreamPacket(1, 60, &blu_val[0]);
     StreamPacket(2, 60, &blu_val[60]);
-    StreamPacket(3, 48, &blu_val[120]);
+    StreamPacket(3, data_sz, &blu_val[120]);
     SubmitKeyboardFullColors(3, 3, 2);
 }
 
+
 void CorsairPeripheralController::SetLEDsMouse(std::vector<RGBColor> colors)
 {
     SubmitMouseColors(colors.size(), &colors[0]);
@@ -320,7 +341,7 @@ void CorsairPeripheralController::LightingControl()
     {
         default:
         case DEVICE_TYPE_KEYBOARD:
-            usb_buf[0x05]   = 0x03;
+            usb_buf[0x05]   = 0x03; // On K95 Platinum, this controls keyboard brightness
             break;
 
         case DEVICE_TYPE_MOUSE:
@@ -342,6 +363,70 @@ void CorsairPeripheralController::LightingControl()
     hid_write(dev, (unsigned char *)usb_buf, 65);
 }
 
+/*-----------------------------------------------------*\
+| Probably a key mapping packet?                        |
+\*-----------------------------------------------------*/
+
+void CorsairPeripheralController::SetupK95LightingControl()
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up a packet                                       |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x02]           = CORSAIR_PROPERTY_LIGHTING_CONTROL;
+    usb_buf[0x03]           = 0x08;
+
+    usb_buf[0x05]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    int identifier = 0;
+    for (int i = 0; i < 4; i++)
+    {
+        /*-----------------------------------------------------*\
+        | Zero out buffer                                       |
+        \*-----------------------------------------------------*/
+        memset(usb_buf, 0x00, sizeof(usb_buf));
+
+        /*-----------------------------------------------------*\
+        | Set up a packet - a sequence of 120 ids               |
+        \*-----------------------------------------------------*/
+        usb_buf[0x00]           = 0x00;
+        usb_buf[0x01]           = CORSAIR_COMMAND_WRITE;
+        usb_buf[0x02]           = 0x40;
+        usb_buf[0x03]           = 0x1E;
+
+        for (int j = 0; j < 30; j++)
+        {
+            while (identifier == 0x31 || identifier == 0x41 || identifier == 0x42 || identifier == 0x48
+                || identifier == 0x49 || identifier == 0x51 || identifier == 0x55 || identifier == 0x6f
+                || identifier == 0x7e || identifier == 0x7f || identifier == 0x80 || identifier == 0x81)
+            {
+                identifier++;
+            }
+
+            usb_buf[5 + 2 * j]      = identifier++;
+            usb_buf[5 + 2 * j + 1]  = 0xC0;
+        }
+
+        /*-----------------------------------------------------*\
+        | Send packet                                           |
+        \*-----------------------------------------------------*/
+        hid_write(dev, (unsigned char *)usb_buf, 65);
+    }
+}
+
 void CorsairPeripheralController::SpecialFunctionControl()
 {
     char usb_buf[65];
@@ -365,7 +450,6 @@ void CorsairPeripheralController::SpecialFunctionControl()
     hid_write(dev, (unsigned char *)usb_buf, 65);
 }
 
-
 void CorsairPeripheralController::ReadFirmwareInfo()
 {
     int  actual;
@@ -421,11 +505,14 @@ void CorsairPeripheralController::ReadFirmwareInfo()
     {
         case 0xC0:
             {
-                unsigned short pid = (unsigned short)(usb_buf[0x0F] << 8) + (unsigned char)(usb_buf[0x0E]);
+                unsigned short pid = (unsigned short)(usb_buf[0x0E] << 8) + (unsigned char)(usb_buf[0x0F]);
 
+                /*-----------------------------------------------------*\
+                | Get the correct Keyboard Type                         |
+                \*-----------------------------------------------------*/
                 switch(pid)
                 {
-                    case 0x2D1B:
+                    case 0x1B2D:
                     logical_layout = CORSAIR_TYPE_K95_PLAT;
                     break;
 
@@ -433,9 +520,40 @@ void CorsairPeripheralController::ReadFirmwareInfo()
                     logical_layout = CORSAIR_TYPE_K95;
                     break;
 
+                    case 0x1B3D:
+                    logical_layout = CORSAIR_TYPE_K55;
+                    SpecialFunctionControl();
+                    break;
+
                     default:
                     logical_layout = CORSAIR_TYPE_NORMAL;
                 }
+
+                /*-----------------------------------------------------*\
+                | Get the correct Keyboard Layout.                      |
+                | Currently unused but can be implemented in the future.|
+                \*-----------------------------------------------------*/
+                switch((unsigned char)usb_buf[0x17 + offset])
+                {
+                    case CORSAIR_LAYOUT_ANSI:
+                        physical_layout = CORSAIR_LAYOUT_ANSI;
+                        break;
+                    case CORSAIR_LAYOUT_ISO:
+                        physical_layout = CORSAIR_LAYOUT_ISO;
+                        break;
+                    case CORSAIR_LAYOUT_ABNT:
+                        physical_layout = CORSAIR_LAYOUT_ABNT;
+                        break;
+                    case CORSAIR_LAYOUT_JIS:
+                        physical_layout = CORSAIR_LAYOUT_JIS;
+                        break;
+                    case CORSAIR_LAYOUT_DUBEOLSIK:
+                        physical_layout = CORSAIR_LAYOUT_DUBEOLSIK;
+                        break;
+                    default:
+                        physical_layout = CORSAIR_LAYOUT_ANSI;
+                }
+
             }
             type = DEVICE_TYPE_KEYBOARD;
             break;
@@ -476,21 +594,6 @@ void CorsairPeripheralController::ReadFirmwareInfo()
     {
         firmware_version = std::to_string(usb_buf[0x09 + offset]) + "." + std::to_string(usb_buf[0x08 + offset]);
     }
-
-    /*-----------------------------------------------------*\
-    | Get the correct Keyboard Layout                       |
-    \*-----------------------------------------------------*/
-    switch((unsigned char)usb_buf[0x17 + offset])
-    {
-        case CORSAIR_LAYOUT_ANSI:
-            physical_layout = CORSAIR_LAYOUT_ANSI;
-            break;
-        case CORSAIR_LAYOUT_ISO:
-            physical_layout = CORSAIR_LAYOUT_ISO;
-            break;
-        default:
-            physical_layout = CORSAIR_LAYOUT_ANSI;
-    }
 }
 
 void CorsairPeripheralController::StreamPacket
@@ -556,6 +659,44 @@ void CorsairPeripheralController::SubmitKeyboardFullColors
     hid_write(dev, (unsigned char *)usb_buf, 65);
 }
 
+void CorsairPeripheralController::SubmitKeyboardZonesColors
+    (
+    RGBColor left,
+    RGBColor mid,
+    RGBColor right
+    )
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Submit Keyboard 24-Bit Colors packet           |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x02]   = CORSAIR_PROPERTY_SUBMIT_KBZONES_COLOR_24;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = 0x00;
+    usb_buf[0x05]   = RGBGetRValue(left);
+    usb_buf[0x06]   = RGBGetGValue(left);
+    usb_buf[0x07]   = RGBGetBValue(left);
+    usb_buf[0x08]   = RGBGetRValue(mid);
+    usb_buf[0x09]   = RGBGetGValue(mid);
+    usb_buf[0x0A]   = RGBGetBValue(mid);
+    usb_buf[0x0B]   = RGBGetRValue(right);
+    usb_buf[0x0C]   = RGBGetGValue(right);
+    usb_buf[0x0D]   = RGBGetBValue(right);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+}
+
 void CorsairPeripheralController::SubmitKeyboardLimitedColors
     (
     unsigned char   byte_count

Controllers/CorsairPeripheralController/CorsairPeripheralController.h

@@ -30,6 +30,7 @@ enum
     CORSAIR_PROPERTY_LIGHTING_CONTROL           = 0x05,
     CORSAIR_PROPERTY_HARDWARE_PROFILE           = 0x13,
     CORSAIR_PROPERTY_SUBMIT_MOUSE_COLOR         = 0x22,
+    CORSAIR_PROPERTY_SUBMIT_KBZONES_COLOR_24    = 0x25,
     CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_9    = 0x27,
     CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_24   = 0x28,
 };
@@ -60,7 +61,8 @@ enum
 {
     CORSAIR_TYPE_NORMAL             = 0,
     CORSAIR_TYPE_K95_PLAT           = 1,
-    CORSAIR_TYPE_K95                = 2
+    CORSAIR_TYPE_K95                = 2,
+    CORSAIR_TYPE_K55                = 3
 };
 
 class CorsairPeripheralController
@@ -95,6 +97,7 @@ private:
     int                     logical_layout;    //Normal, K95 or K95 Platinum
 
     void    LightingControl();
+    void    SetupK95LightingControl();
     void    SpecialFunctionControl();
 
     void    ReadFirmwareInfo();
@@ -113,6 +116,14 @@ private:
                 unsigned char   finish_val
                 );
 
+    void    SubmitKeyboardZonesColors
+                (
+                RGBColor left,
+                RGBColor mid,
+                RGBColor right
+                );
+
+
     void    SubmitKeyboardLimitedColors
                 (
                 unsigned char   byte_count

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -39,6 +39,7 @@
 | Mouse product IDs                                     |
 |   List taken from ckb-next                            |
 \*-----------------------------------------------------*/
+#define CORSAIR_GLAIVE_RGB_PID          0x1B34
 #define CORSAIR_GLAIVE_RGB_PRO_PID      0x1B74
 #define CORSAIR_HARPOON_RGB_PID         0x1B3C
 #define CORSAIR_HARPOON_RGB_PRO_PID     0x1B75
@@ -90,7 +91,7 @@ void DetectCorsairPeripheralControllers(hid_device_info* info, const std::string
 /*-----------------------------------------------------------------------------------------------------*\
 | Keyboards                                                                                             |
 \*-----------------------------------------------------------------------------------------------------*/
-//REGISTER_HID_DETECTOR_IP("Corsair K55 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K55_RGB_PID,           1, 0xFFC2); // Not per-key, disabled for now
+REGISTER_HID_DETECTOR_IP("Corsair K55 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K55_RGB_PID,           1, 0xFFC2); // Not per-key, disabled for now
 REGISTER_HID_DETECTOR_IP("Corsair K65 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_PID,           1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K65 LUX RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_LUX_RGB_PID,       1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K65 RGB RAPIDFIRE",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_RAPIDFIRE_PID, 1, 0xFFC2);
@@ -108,6 +109,7 @@ REGISTER_HID_DETECTOR_IP("Corsair Strafe MK.2",              DetectCorsairPeriph
 /*-----------------------------------------------------------------------------------------------------*\
 | Mice                                                                                                  |
 \*-----------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("Corsair Glaive RGB",               DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_GLAIVE_RGB_PID,        1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Glaive RGB PRO",           DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_GLAIVE_RGB_PRO_PID,    1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PID,       1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB PRO",          DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PRO_PID,   1, 0xFFC2);

Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.cpp

@@ -21,7 +21,7 @@ static unsigned int matrix_map[6][23] =
       {   5,  14,  23,  NA,  NA,  NA,  NA,  41,  NA,  NA,  NA,  NA,  69,  79,  89,  71,  90,  99, 108, 101,  NA, 110,  NA } };
 
 static unsigned int matrix_map_k95_platinum[7][24] =
-    { {  NA,  NA,  NA,  NA, 107,   8,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  16,  NA,  NA,  NA,},
+    { {  NA,  NA,  NA, 119, 107,   8,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  16,  NA,  NA,  NA,},
       { 113,   0,  NA,  10,  18,  28,  36,  NA,  46,  55,  64,  74,  NA,  84,  93, 102,   6,  15,  24,  33,  26,  35,  44,  53 },
       { 114,   1,  11,  19,  29,  37,  47,  56,  65,  75,  85,  94,  NA, 103,   7,  25,  NA,  42,  51,  60,  62,  72,  82,  91 },
       { 115,   2,  NA,  12,  20,  30,  38,  NA,  48,  57,  66,  76,  86,  95, 104,  70,  80,  34,  43,  52,  9,   17,  27, 100 },
@@ -67,7 +67,7 @@ static const char* zone_names_k95_platinum[] =
 
 static const unsigned int zone_sizes_k95_platinum[] =
 {
-    119,
+    120,
     19
 };
 
@@ -95,6 +95,29 @@ static const zone_type zone_types_k95[] =
     ZONE_TYPE_MATRIX
 };
 
+/*---------------------------------------------------------*\
+| K55                                                       |
+\*---------------------------------------------------------*/
+static const char* zone_names_k55[] =
+{
+    "Left",
+    "Middle",
+    "Right",
+};
+
+static const unsigned int zone_sizes_k55[] =
+{
+    1,
+    1,
+    1
+};
+
+static const zone_type zone_types_k55[] =
+{
+    ZONE_TYPE_SINGLE,
+    ZONE_TYPE_SINGLE,
+    ZONE_TYPE_SINGLE
+};
 
 static const char* led_names[] =
 {
@@ -334,6 +357,7 @@ static const char* led_names_k95_plat[] =
     "Key: Macro G4",
     "Key: Macro G5",
     "Key: Macro G6",
+    "Key: Preset",
     "Light Bar 1",
     "Light Bar 2",
     "Light Bar 3",
@@ -513,6 +537,13 @@ static const char* corsair_mouse_leds[] =
     "Mouse LED 15",
 };
 
+static const char* led_names_k55[] =
+{
+    "LEFT",
+    "MIDDLE",
+    "RIGHT",
+};
+
 static const char* corsair_m65_elite_leds[] =
 {
     "",
@@ -607,6 +638,8 @@ RGBController_CorsairPeripheral::~RGBController_CorsairPeripheral()
             delete zones[zone_index].matrix_map;
         }
     }
+
+    delete corsair;
 }
 
 void RGBController_CorsairPeripheral::SetupZones()
@@ -625,6 +658,11 @@ void RGBController_CorsairPeripheral::SetupZones()
                 num_zones = 2;
                 break;
             }
+            if (logical_layout == CORSAIR_TYPE_K55)
+            {
+                num_zones = 3;
+                break;
+            }
             num_zones = 1;
             break;
 
@@ -688,6 +726,15 @@ void RGBController_CorsairPeripheral::SetupZones()
                         new_zone.matrix_map         = NULL;
                     }
                 }
+                else if (logical_layout == CORSAIR_TYPE_K55)
+                {
+                    new_zone.name                   = zone_names_k55[zone_idx];
+                    new_zone.type                   = zone_types_k55[zone_idx];
+                    new_zone.leds_min               = zone_sizes_k55[zone_idx];
+                    new_zone.leds_max               = zone_sizes_k55[zone_idx];
+                    new_zone.leds_count             = zone_sizes_k55[zone_idx];
+                    new_zone.matrix_map             = NULL;
+                }
                 else //default layout
                 {
                     new_zone.name                   = zone_names[zone_idx];
@@ -771,6 +818,10 @@ void RGBController_CorsairPeripheral::SetupZones()
                 {
                     new_led.name = led_names_k95[led_idx];
                 }
+                else if(logical_layout == CORSAIR_TYPE_K55)
+                {
+                    new_led.name = led_names_k55[led_idx];
+                }
                 else
                 {
                     new_led.name = led_names[led_idx];

Controllers/CorsairVengeanceController/CorsairVengeanceControllerDetect.cpp

@@ -52,7 +52,7 @@ bool TestForCorsairVengeanceController(i2c_smbus_interface* bus, unsigned char a
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses)
 {
     CorsairVengeanceController* new_corsair;
     RGBController_CorsairVengeance* new_controller;
@@ -66,7 +66,7 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
             {
                 new_corsair = new CorsairVengeanceController(busses[bus], 0x58);
                 new_controller = new RGBController_CorsairVengeance(new_corsair);
-                rgb_controllers.push_back(new_controller);
+                ResourceManager::get()->RegisterRGBController(new_controller);
             }
 
             // Check for Corsair controller at 0x59
@@ -74,7 +74,7 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
             {
                 new_corsair = new CorsairVengeanceController(busses[bus], 0x59);
                 new_controller = new RGBController_CorsairVengeance(new_corsair);
-                rgb_controllers.push_back(new_controller);
+                ResourceManager::get()->RegisterRGBController(new_controller);
             }
 
             // Check for Corsair controller at 0x5A
@@ -82,7 +82,7 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
             {
                 new_corsair = new CorsairVengeanceController(busses[bus], 0x5A);
                 new_controller = new RGBController_CorsairVengeance(new_corsair);
-                rgb_controllers.push_back(new_controller);
+                ResourceManager::get()->RegisterRGBController(new_controller);
             }
 
             // Check for Corsair controller at 0x5B
@@ -90,7 +90,7 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
             {
                 new_corsair = new CorsairVengeanceController(busses[bus], 0x5B);
                 new_controller = new RGBController_CorsairVengeance(new_corsair);
-                rgb_controllers.push_back(new_controller);
+                ResourceManager::get()->RegisterRGBController(new_controller);
             }
 
             // Check for Corsair controller at 0x5C
@@ -98,7 +98,7 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
             {
                 new_corsair = new CorsairVengeanceController(busses[bus], 0x5C);
                 new_controller = new RGBController_CorsairVengeance(new_corsair);
-                rgb_controllers.push_back(new_controller);
+                ResourceManager::get()->RegisterRGBController(new_controller);
             }
 
             // Check for Corsair controller at 0x5D
@@ -106,7 +106,7 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
             {
                 new_corsair = new CorsairVengeanceController(busses[bus], 0x5D);
                 new_controller = new RGBController_CorsairVengeance(new_corsair);
-                rgb_controllers.push_back(new_controller);
+                ResourceManager::get()->RegisterRGBController(new_controller);
             }
 
             // Check for Corsair controller at 0x5E
@@ -114,7 +114,7 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
             {
                 new_corsair = new CorsairVengeanceController(busses[bus], 0x5E);
                 new_controller = new RGBController_CorsairVengeance(new_corsair);
-                rgb_controllers.push_back(new_controller);
+                ResourceManager::get()->RegisterRGBController(new_controller);
             }
 
             // Check for Corsair controller at 0x5F
@@ -122,7 +122,7 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
             {
                 new_corsair = new CorsairVengeanceController(busses[bus], 0x5F);
                 new_controller = new RGBController_CorsairVengeance(new_corsair);
-                rgb_controllers.push_back(new_controller);
+                ResourceManager::get()->RegisterRGBController(new_controller);
             }
         }
     }

Controllers/CorsairVengeanceController/RGBController_CorsairVengeance.cpp

@@ -43,6 +43,11 @@ RGBController_CorsairVengeance::RGBController_CorsairVengeance(CorsairVengeanceC
     SetupZones();
 }
 
+RGBController_CorsairVengeance::~RGBController_CorsairVengeance()
+{
+    delete corsair;
+}
+
 void RGBController_CorsairVengeance::SetupZones()
 {
     /*---------------------------------------------------------*\

Controllers/CorsairVengeanceController/RGBController_CorsairVengeance.h

@@ -16,6 +16,7 @@ class RGBController_CorsairVengeance : public RGBController
 {
 public:
     RGBController_CorsairVengeance(CorsairVengeanceController* corsair_ptr);
+    ~RGBController_CorsairVengeance();
 
     void        SetupZones();
 

Controllers/CorsairVengeanceProController/CorsairVengeanceProController.cpp

@@ -20,6 +20,7 @@ CorsairVengeanceProController::CorsairVengeanceProController(i2c_smbus_interface
     strcpy(device_name, "Corsair Vengeance Pro RGB");
     led_count = CORSAIR_PRO_LED_COUNT;
 
+    direct_mode = false;
     effect_mode = CORSAIR_PRO_MODE_STATIC;
     
     for (unsigned int i = 0; i < led_count; i++)
@@ -79,20 +80,49 @@ void CorsairVengeanceProController::SetLEDColor(unsigned int led, unsigned char
 
 void CorsairVengeanceProController::ApplyColors()
 {
-    bus->i2c_smbus_write_byte_data(dev, 0x26, 0x02);
-    std::this_thread::sleep_for(1ms);
-    bus->i2c_smbus_write_byte_data(dev, 0x21, 0x00);
-    std::this_thread::sleep_for(1ms);
-
-    for (int i = 0; i < 10; i++)
+    if(direct_mode)
     {
-        bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_red[i]);
-        bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_green[i]);
-        bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_blue[i]);
-        bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0xFF);
-    }
+        unsigned char   full_packet[32];
+        unsigned char   crc_packet[31];
 
-    bus->i2c_smbus_write_byte_data(dev, 0x82, 0x02);
+        full_packet[0]  = 0x0A;
+        crc_packet[0]   = 0x0A;
+
+        for (int i = 0; i < 10; i++)
+        {
+            crc_packet[(i * 3) + 1]     = led_red[i];
+            full_packet[(i * 3) + 1]    = led_red[i];
+
+            crc_packet[(i * 3) + 2]     = led_green[i];
+            full_packet[(i * 3) + 2]    = led_green[i];
+
+            crc_packet[(i * 3) + 3]     = led_blue[i];
+            full_packet[(i * 3) + 3]    = led_blue[i];
+        }
+
+        uint8_t footer = CRCPP::CRC::Calculate(crc_packet, 31, CRCPP::CRC::CRC_8());
+
+        full_packet[31] = footer;
+
+        bus->i2c_smbus_write_block_data(dev, CORSAIR_PRO_DIRECT_COMMAND, 32, full_packet);
+    }
+    else
+    {
+        bus->i2c_smbus_write_byte_data(dev, 0x26, 0x02);
+        std::this_thread::sleep_for(1ms);
+        bus->i2c_smbus_write_byte_data(dev, 0x21, 0x00);
+        std::this_thread::sleep_for(1ms);
+
+        for (int i = 0; i < 10; i++)
+        {
+            bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_red[i]);
+            bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_green[i]);
+            bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_blue[i]);
+            bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0xFF);
+        }
+
+        bus->i2c_smbus_write_byte_data(dev, 0x82, 0x02);
+    }
 }
 
 void CorsairVengeanceProController::SetEffect(unsigned char mode,
@@ -107,8 +137,20 @@ void CorsairVengeanceProController::SetEffect(unsigned char mode,
                                      unsigned char blu2
                                     )
 {
+    if(mode == effect_mode)
+    {
+        return;
+    }
+
     effect_mode = mode;
 
+    direct_mode = (effect_mode == CORSAIR_PRO_MODE_DIRECT);
+
+    if(direct_mode)
+    {
+        return;
+    }
+
     bus->i2c_smbus_write_byte_data(dev, 0x26, 0x01);
     std::this_thread::sleep_for(1ms);
     bus->i2c_smbus_write_byte_data(dev, 0x21, 0x00);
@@ -125,10 +167,10 @@ void CorsairVengeanceProController::SetEffect(unsigned char mode,
         random_byte = CORSAIR_PRO_EFFECT_CUSTOM_COLORS;
     }
 
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, effect_mode);  //Mode
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, speed);        //Speed
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, random_byte);  //Custom color
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, direction);    //Direction
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, effect_mode);  // Mode
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, speed);        // Speed
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, random_byte);  // Custom color
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, direction);    // Direction
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, red1);         // Custom color 1 red
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, grn1);         // Custom color 1 green
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, blu1);         // Custom color 1 blue
@@ -161,3 +203,8 @@ bool CorsairVengeanceProController::WaitReady()
 
     return false;
 }
+
+void CorsairVengeanceProController::SetDirect(bool direct)
+{
+    direct_mode = direct;
+}

Controllers/CorsairVengeanceProController/CorsairVengeanceProController.h

@@ -9,6 +9,7 @@
 
 #include <string>
 #include "i2c_smbus.h"
+#include "CRC.h"
 
 #pragma once
 
@@ -19,20 +20,22 @@ typedef unsigned char	corsair_dev_id;
 enum
 {
     CORSAIR_PRO_REG_COMMAND             = 0x20,     /* Command write register               */
+    CORSAIR_PRO_DIRECT_COMMAND          = 0x31,     /* Where it writes direct mode colors   */
 };
 
 enum
 {
-    CORSAIR_PRO_MODE_COLOR_SHIFT        = 0x00,     /* Color Shift mode                     */
-    CORSAIR_PRO_MODE_COLOR_PULSE        = 0x01,     /* Color Pulse mode                     */
-    CORSAIR_PRO_MODE_RAINBOW_WAVE       = 0x03,     /* Rainbow Wave mode                    */
-    CORSAIR_PRO_MODE_COLOR_WAVE         = 0x04,     /* Color Wave mode                      */
-    CORSAIR_PRO_MODE_VISOR              = 0x05,     /* Visor mode                           */
-    CORSAIR_PRO_MODE_RAIN               = 0x06,     /* Rain mode                            */
-    CORSAIR_PRO_MODE_MARQUEE            = 0x07,     /* Marquee mode                         */
-    CORSAIR_PRO_MODE_RAINBOW            = 0x08,     /* Rainbow mode                         */
-    CORSAIR_PRO_MODE_SEQUENTIAL         = 0x09,     /* Sequential mode                      */
-    CORSAIR_PRO_MODE_STATIC             = 0x10,     /* Static mode                          */
+    CORSAIR_PRO_MODE_DIRECT             = 0xDD,     /* Arbitrary value to compare against later. Not the actual packet  */
+    CORSAIR_PRO_MODE_COLOR_SHIFT        = 0x00,     /* Color Shift mode                                                 */
+    CORSAIR_PRO_MODE_COLOR_PULSE        = 0x01,     /* Color Pulse mode                                                 */
+    CORSAIR_PRO_MODE_RAINBOW_WAVE       = 0x03,     /* Rainbow Wave mode                                                */
+    CORSAIR_PRO_MODE_COLOR_WAVE         = 0x04,     /* Color Wave mode                                                  */
+    CORSAIR_PRO_MODE_VISOR              = 0x05,     /* Visor mode                                                       */
+    CORSAIR_PRO_MODE_RAIN               = 0x06,     /* Rain mode                                                        */
+    CORSAIR_PRO_MODE_MARQUEE            = 0x07,     /* Marquee mode                                                     */
+    CORSAIR_PRO_MODE_RAINBOW            = 0x08,     /* Rainbow mode                                                     */
+    CORSAIR_PRO_MODE_SEQUENTIAL         = 0x09,     /* Sequential mode                                                  */
+    CORSAIR_PRO_MODE_STATIC             = 0x10,     /* Static mode                                                      */
 
     CORSAIR_PRO_NUMBER_MODES            = 10,       /* Number of Corsair Pro modes          */
 };
@@ -87,9 +90,12 @@ public:
     void            ApplyColors();
     bool            WaitReady();
 
+    void            SetDirect(bool direct);
+
 private:
     char                    device_name[32];
     unsigned int            led_count;
+    bool                    direct_mode;
     unsigned char           effect_mode;
     unsigned char           led_red[CORSAIR_PRO_LED_COUNT];
     unsigned char           led_green[CORSAIR_PRO_LED_COUNT];

Controllers/CorsairVengeanceProController/CorsairVengeanceProControllerDetect.cpp

@@ -60,7 +60,7 @@ bool TestForCorsairVengeanceProController(i2c_smbus_interface* bus, unsigned cha
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &busses)
 {
     CorsairVengeanceProController* new_corsair_pro;
     RGBController_CorsairVengeancePro* new_controller;
@@ -74,7 +74,7 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
             {
                 new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x58);
                 new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-                rgb_controllers.push_back(new_controller);
+                ResourceManager::get()->RegisterRGBController(new_controller);
             }
 
             // Check for Corsair controller at 0x59
@@ -82,7 +82,7 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
             {
                 new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x59);
                 new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-                rgb_controllers.push_back(new_controller);
+                ResourceManager::get()->RegisterRGBController(new_controller);
             }
 
             // Check for Corsair controller at 0x5A
@@ -90,7 +90,7 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
             {
                 new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5A);
                 new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-                rgb_controllers.push_back(new_controller);
+                ResourceManager::get()->RegisterRGBController(new_controller);
             }
 
             // Check for Corsair controller at 0x5B
@@ -98,7 +98,7 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
             {
                 new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5B);
                 new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-                rgb_controllers.push_back(new_controller);
+                ResourceManager::get()->RegisterRGBController(new_controller);
             }
 
             // Check for Corsair controller at 0x5C
@@ -106,7 +106,7 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
             {
                 new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5C);
                 new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-                rgb_controllers.push_back(new_controller);
+                ResourceManager::get()->RegisterRGBController(new_controller);
             }
 
             // Check for Corsair controller at 0x5D
@@ -114,7 +114,7 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
             {
                 new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5D);
                 new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-                rgb_controllers.push_back(new_controller);
+                ResourceManager::get()->RegisterRGBController(new_controller);
             }
 
             // Check for Corsair controller at 0x5E
@@ -122,7 +122,7 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
             {
                 new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5E);
                 new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-                rgb_controllers.push_back(new_controller);
+                ResourceManager::get()->RegisterRGBController(new_controller);
             }
 
             // Check for Corsair controller at 0x5F
@@ -130,7 +130,7 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
             {
                 new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5F);
                 new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-                rgb_controllers.push_back(new_controller);
+                ResourceManager::get()->RegisterRGBController(new_controller);
             }
         }
     }

Controllers/CorsairVengeanceProController/RGBController_CorsairVengeancePro.cpp

@@ -21,7 +21,7 @@ RGBController_CorsairVengeancePro::RGBController_CorsairVengeancePro(CorsairVeng
 
     mode Direct;
     Direct.name       = "Direct";
-    Direct.value      = CORSAIR_PRO_MODE_STATIC;
+    Direct.value      = CORSAIR_PRO_MODE_DIRECT;
     Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
     Direct.speed_min  = 0;
     Direct.speed_max  = 0;
@@ -29,6 +29,16 @@ RGBController_CorsairVengeancePro::RGBController_CorsairVengeancePro(CorsairVeng
     Direct.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
+    mode Static;
+    Static.name       = "Static";
+    Static.value      = CORSAIR_PRO_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.speed_min  = 0;
+    Static.speed_max  = 0;
+    Static.speed      = 0;
+    Static.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Static);
+
     mode ColorShift;
     ColorShift.name       = "Color Shift";
     ColorShift.value      = CORSAIR_PRO_MODE_COLOR_SHIFT;
@@ -150,6 +160,11 @@ RGBController_CorsairVengeancePro::RGBController_CorsairVengeancePro(CorsairVeng
     active_mode = 9;
 }
 
+RGBController_CorsairVengeancePro::~RGBController_CorsairVengeancePro()
+{
+    delete corsair;
+}
+
 void RGBController_CorsairVengeancePro::SetupZones()
 {
     /*---------------------------------------------------------*\
@@ -269,6 +284,15 @@ void RGBController_CorsairVengeancePro::DeviceUpdateMode()
         }        
     }
 
+    if (modes[active_mode].name == "Direct")
+    {
+        corsair->SetDirect(true);
+    }
+    else
+    {
+        corsair->SetDirect(false);
+    }
+
     corsair->SetEffect(modes[active_mode].value,
                        modes[active_mode].speed,
                        corsair_direction,
@@ -279,4 +303,6 @@ void RGBController_CorsairVengeancePro::DeviceUpdateMode()
                        mode_colors[3],
                        mode_colors[4],
                        mode_colors[5]);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(15));
 }

Controllers/CorsairVengeanceProController/RGBController_CorsairVengeancePro.h

@@ -16,6 +16,7 @@ class RGBController_CorsairVengeancePro : public RGBController
 {
 public:
     RGBController_CorsairVengeancePro(CorsairVengeanceProController* corsair_ptr);
+    ~RGBController_CorsairVengeancePro();
 
     void        SetupZones();
 

Controllers/CreativeController/CreativeControllerDetect.cpp

@@ -0,0 +1,30 @@
+#include "CreativeSoundBlasterXG6Controller.h"
+#include "RGBController_CreativeSoundBlasterXG6.h"
+#include "Detector.h"
+#include <hidapi/hidapi.h>
+
+/*-----------------------------------------------------*\
+| Creative vendor ID                                    |
+\*-----------------------------------------------------*/
+#define CREATIVE_VID                            0x041E
+/*-----------------------------------------------------*\
+| SoundCards                                            |
+\*-----------------------------------------------------*/
+#define CREATIVE_SOUNDBLASTERX_G6_PID           0x3256
+
+void DetectCreativeDevice(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        CreativeSoundBlasterXG6Controller*     controller     = new CreativeSoundBlasterXG6Controller(dev, info->path);
+        RGBController_CreativeSoundBlasterXG6* rgb_controller = new RGBController_CreativeSoundBlasterXG6(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Sound Cards                                                                                                                                       |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_I("Creative SoundBlasterX G6",               DetectCreativeDevice,         CREATIVE_VID,     CREATIVE_SOUNDBLASTERX_G6_PID, 4);

Controllers/CreativeController/CreativeSoundBlasterXG6Controller.cpp

@@ -0,0 +1,82 @@
+#include "CreativeSoundBlasterXG6Controller.h"
+
+CreativeSoundBlasterXG6Controller::CreativeSoundBlasterXG6Controller(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+CreativeSoundBlasterXG6Controller::~CreativeSoundBlasterXG6Controller()
+{
+    hid_close(dev);
+}
+
+std::string CreativeSoundBlasterXG6Controller::GetDeviceLocation()
+{
+    return("HID " + location);
+}
+
+void CreativeSoundBlasterXG6Controller::SetLedColor (unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    //5A 3A 02 06 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+    usb_buf[0x01]           = 0x5A;
+    usb_buf[0x02]           = 0x3A;
+    usb_buf[0x03]           = 0x02;
+    usb_buf[0x04]           = 0x06;
+    usb_buf[0x05]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 64);
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    //5A 3A 06 04 00 03 01 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+    usb_buf[0x01]           = 0x5A;
+    usb_buf[0x02]           = 0x3A;
+    usb_buf[0x03]           = 0x06;
+    usb_buf[0x04]           = 0x04;
+    usb_buf[0x06]           = 0x03;
+    usb_buf[0x07]           = 0x01;
+    usb_buf[0x09]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 64);
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    //5A 3A 09 0A 00 03 01 01 FF BB GG RR
+    usb_buf[0x01]           = 0x5A;
+    usb_buf[0x02]           = 0x3A;
+    usb_buf[0x03]           = 0x09;
+    usb_buf[0x04]           = 0x0A;
+    usb_buf[0x06]           = 0x03;
+    usb_buf[0x07]           = 0x01;
+    usb_buf[0x08]           = 0x01;
+    usb_buf[0x09]           = 0x0FF;
+
+    usb_buf[0x0A]           = blue;
+    usb_buf[0x0B]           = green;
+    usb_buf[0x0C]           = red;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 64);
+}

Controllers/CreativeController/CreativeSoundBlasterXG6Controller.h

@@ -0,0 +1,20 @@
+#include "RGBController.h"
+#include <cstring>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+class CreativeSoundBlasterXG6Controller
+{
+public:
+    CreativeSoundBlasterXG6Controller(hid_device* dev_handle, const char* path);
+    ~CreativeSoundBlasterXG6Controller();
+    void            SetLedColor (unsigned char red, unsigned char green, unsigned char blue);
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+private:
+    hid_device*             dev;
+    std::string             location;
+};

Controllers/CreativeController/RGBController_CreativeSoundBlasterXG6.cpp

@@ -0,0 +1,81 @@
+#include "RGBController_CreativeSoundBlasterXG6.h"
+
+RGBController_CreativeSoundBlasterXG6::RGBController_CreativeSoundBlasterXG6(CreativeSoundBlasterXG6Controller* creative_device)
+{
+    creative    = creative_device;
+
+    name        = "Creative SoundBlasterX G6 Device";
+    vendor      = "Creative";
+    type        = DEVICE_TYPE_HEADSET;
+    description = "Creative SoundBlasterX G6 Device";
+    location    = creative_device->GetDeviceLocation();
+    serial      = "";
+
+    mode Static;
+    Static.name                     = "Direct";
+    Static.value                    = 0;
+    Static.flags                    = MODE_COLORS_PER_LED;
+    Static.color_mode               = MODE_COLORS_PER_LED;
+    modes.push_back(Static);
+
+    SetupZones();
+}
+
+RGBController_CreativeSoundBlasterXG6::~RGBController_CreativeSoundBlasterXG6()
+{
+    delete creative;
+}
+
+void RGBController_CreativeSoundBlasterXG6::SetupZones()
+{
+    zone logo_zone;
+    logo_zone.name                  = "Logo";
+    logo_zone.type                  = ZONE_TYPE_SINGLE;
+    logo_zone.leds_min              = 1;
+    logo_zone.leds_max              = 1;
+    logo_zone.leds_count            = 1;
+    logo_zone.matrix_map            = NULL;
+    zones.push_back(logo_zone);
+
+    led logo_led;
+    logo_led.name = "Logo";
+    leds.push_back(logo_led);
+
+    SetupColors();
+}
+
+void RGBController_CreativeSoundBlasterXG6::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_CreativeSoundBlasterXG6::DeviceUpdateLEDs()
+{
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+
+    creative->SetLedColor(red, grn, blu);
+}
+
+void RGBController_CreativeSoundBlasterXG6::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CreativeSoundBlasterXG6::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CreativeSoundBlasterXG6::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_CreativeSoundBlasterXG6::DeviceUpdateMode()
+{
+    DeviceUpdateLEDs();
+}

Controllers/CreativeController/RGBController_CreativeSoundBlasterXG6.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "RGBController.h"
+#include "CreativeSoundBlasterXG6Controller.h"
+
+class RGBController_CreativeSoundBlasterXG6: public RGBController
+{
+public:
+    RGBController_CreativeSoundBlasterXG6(CreativeSoundBlasterXG6Controller* creative_device);
+    ~RGBController_CreativeSoundBlasterXG6();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    CreativeSoundBlasterXG6Controller*   creative;
+};

Controllers/CrucialController/CrucialControllerDetect.cpp

@@ -8,6 +8,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+using namespace std::chrono_literals;
+
 /*----------------------------------------------------------------------*\
 | This list contains the available SMBus addresses for Crucial RAM       |
 \*----------------------------------------------------------------------*/
@@ -15,6 +17,16 @@
 
 static const unsigned char crucial_addresses[] =
 {
+/*-----------------------------------------------------*\
+| These addresses have been disabled due to conflict    |
+| with ASUS Aura DRAM.  Since the detection scheme is   |
+| the same, Aura RAM will be detected as Crucial.       |
+| We need to improve the Crucial detection scheme.      |
+\*-----------------------------------------------------*/
+//  0x39,
+//  0x3A,
+//  0x3B,
+//  0x3C,
     0x20,
     0x21,
     0x22,
@@ -57,6 +69,15 @@ bool TestForCrucialController(i2c_smbus_interface* bus, unsigned char address)
 
 }   /* TestForCrucialController() */
 
+void CrucialRegisterWrite(i2c_smbus_interface* bus, unsigned char dev, unsigned short reg, unsigned char val)
+{
+    //Write Crucial register
+    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
+
+    //Write Crucial value
+    bus->i2c_smbus_write_byte_data(dev, 0x01, val);
+}
+
 /******************************************************************************************\
 *                                                                                          *
 *   DetectCrucialControllers                                                               *
@@ -68,15 +89,51 @@ bool TestForCrucialController(i2c_smbus_interface* bus, unsigned char address)
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses)
 {
     CrucialController* new_crucial;
     RGBController_Crucial* new_controller;
 
     for (unsigned int bus = 0; bus < busses.size(); bus++)
     {
+        int address_list_idx = -1;
+
         IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
+            // Remap Crucial RAM modules on 0x27
+            for (unsigned int slot = 0; slot < 4; slot++)
+            {
+                int res = busses[bus]->i2c_smbus_write_quick(0x27, I2C_SMBUS_WRITE);
+
+                if (res < 0)
+                {
+                    break;
+                }
+
+                do
+                {
+                    address_list_idx++;
+
+                    if(address_list_idx < CRUCIAL_ADDRESS_COUNT)
+                    {
+                        res = busses[bus]->i2c_smbus_write_quick(crucial_addresses[address_list_idx], I2C_SMBUS_WRITE);
+                    }
+                    else
+                    {
+                        break;
+                    }
+                } while (res >= 0);
+
+                if(address_list_idx < CRUCIAL_ADDRESS_COUNT)
+                {
+                    CrucialRegisterWrite(busses[bus], 0x27, 0x82EE, slot);
+                    CrucialRegisterWrite(busses[bus], 0x27, 0x82EF, (crucial_addresses[address_list_idx] << 1));
+                    CrucialRegisterWrite(busses[bus], 0x27, 0x82F0, 0xF0);
+                }
+
+                std::this_thread::sleep_for(1ms);
+            }
+
             // Add Crucial controllers
             for (unsigned int address_list_idx = 0; address_list_idx < CRUCIAL_ADDRESS_COUNT; address_list_idx++)
             {
@@ -84,7 +141,7 @@ void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses, std::ve
                 {
                     new_crucial = new CrucialController(busses[bus], crucial_addresses[address_list_idx]);
                     new_controller = new RGBController_Crucial(new_crucial);
-                    rgb_controllers.push_back(new_controller);
+                    ResourceManager::get()->RegisterRGBController(new_controller);
                 }
             }
         }

Controllers/CrucialController/RGBController_Crucial.cpp

@@ -116,6 +116,11 @@ RGBController_Crucial::RGBController_Crucial(CrucialController * crucial_ptr)
     SetupZones();
 }
 
+RGBController_Crucial::~RGBController_Crucial()
+{
+    delete crucial;
+}
+
 void RGBController_Crucial::SetupZones()
 {
     /*---------------------------------------------------------*\

Controllers/CrucialController/RGBController_Crucial.h

@@ -16,6 +16,7 @@ class RGBController_Crucial : public RGBController
 {
 public:
     RGBController_Crucial(CrucialController* crucial_ptr);
+    ~RGBController_Crucial();
 
     void        SetupZones();
 

Controllers/DasKeyboardController/DasKeyboardController.cpp

@@ -0,0 +1,351 @@
+/*-----------------------------------------*\
+|  DasKeyboardController.cpp                |
+|                                           |
+|  Driver for Das Keyboard RGB keyboard     |
+|  lighting controller                      |
+|                                           |
+|  Frank Niessen (denk_mal) 12/16/2020      |
+\*-----------------------------------------*/
+
+#include <cstring>
+#include "DasKeyboardController.h"
+
+using namespace std::chrono_literals;
+
+DasKeyboardController::DasKeyboardController(hid_device *dev_handle, const char *path)
+{
+    dev                    = dev_handle;
+    location               = path;
+    version                = "";
+    useTraditionalSendData = false;
+
+    SendInitialize();
+}
+
+DasKeyboardController::~DasKeyboardController()
+{
+    hid_close(dev);
+}
+
+std::string DasKeyboardController::GetDeviceLocation()
+{
+    return "HID: " + location;
+}
+
+std::string DasKeyboardController::GetSerialString()
+{
+    wchar_t serial_string[128] = {};
+    int     err                = hid_get_serial_number_string(dev, serial_string, 128);
+
+    std::string return_string;
+    if(!err)
+    {
+        std::wstring return_wstring = serial_string;
+        return_string = std::string(return_wstring.begin(), return_wstring.end());
+    }
+
+    if(return_string.empty())
+    {
+        return_string = version;
+    }
+
+    return return_string;
+}
+
+std::string DasKeyboardController::GetVersionString()
+{
+    if(version.length() < 17)
+    {
+        return version;
+    }
+
+    std::string fw_version  = "V";
+    fw_version             += version.substr(6, 2);
+    fw_version             += ".";
+    fw_version             += version.substr(15, 2);
+    fw_version             += ".0";
+
+    return fw_version;
+}
+
+std::string DasKeyboardController::GetLayoutString()
+{
+    /*-----------------------------------------------------*\
+    | Experimental for now; should be '16' for US and '28'  |
+    | for EU layout                                         |
+    \*-----------------------------------------------------*/
+    if(version.length() < 17)
+    {
+        return "NONE";
+    }
+    std::string layout_id = version.substr(3, 2);
+
+    if(layout_id == "16")
+    {
+        return "US";
+    }
+
+    return "EU";
+}
+
+void DasKeyboardController::SendColors(unsigned char key_id, unsigned char mode,
+                                       unsigned char red, unsigned char green, unsigned char blue)
+{
+    if(key_id < 130)
+    {
+        unsigned char usb_buf[] = {0xEA,
+                                   0x08,
+                                   0x78,
+                                   0x08,
+                                   static_cast<unsigned char>(key_id),
+                                   mode,
+                                   red,
+                                   green,
+                                   blue};
+
+        SendData(usb_buf, sizeof(usb_buf));
+    }
+    else
+    {
+        /*-----------------------------------------------------*\
+        | Special handling for the Q-Button; only color, no mode|
+        \*-----------------------------------------------------*/
+        unsigned char usb_buf[] = {0xEA,
+                                   0x06,
+                                   0x78,
+                                   0x06,
+                                   red,
+                                   green,
+                                   blue};
+
+        SendData(usb_buf, sizeof(usb_buf));
+    }
+}
+
+
+void DasKeyboardController::SendInitialize()
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    int cnt_receive = 0;
+
+    while(!cnt_receive)
+    {
+        /*-----------------------------------------------------*\
+        | Set up Initialize connection                          |
+        \*-----------------------------------------------------*/
+        unsigned char usb_init[] = {0xEA, 0x02, 0xB0};
+        SendData(usb_init, sizeof(usb_init));
+
+        /*-----------------------------------------------------*\
+        | Get Version String                                    |
+        \*-----------------------------------------------------*/
+        cnt_receive = ReceiveData(usb_buf, sizeof(usb_buf));
+
+        /*-----------------------------------------------------*\
+        | check if the faster modern transfer method is working |
+        \*-----------------------------------------------------*/
+        if(!cnt_receive)
+        {
+            if(useTraditionalSendData)
+            {
+                break;
+            }
+            useTraditionalSendData = true;
+        }
+    }
+
+    std::string fw_version(reinterpret_cast<char *>(&usb_buf[2]));
+    version = fw_version;
+}
+
+void DasKeyboardController::SendApply()
+{
+    /*-----------------------------------------------------*\
+    | Set up Terminate Color packet                         |
+    \*-----------------------------------------------------*/
+    unsigned char usb_buf_send[]    = {0xEA, 0x03, 0x78, 0x0a};
+    unsigned char usb_buf_receive[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    SendData(usb_buf_send, sizeof(usb_buf_send));
+    ReceiveData(usb_buf_receive, sizeof(usb_buf_receive));
+}
+
+void DasKeyboardController::SendData(const unsigned char *data, const unsigned int length)
+{
+    if(useTraditionalSendData)
+    {
+        SendDataTraditional(data, length);
+    }
+    else
+    {
+        SendDataModern(data, length);
+    }
+}
+
+void DasKeyboardController::SendDataModern(const unsigned char *data, const unsigned int length)
+{
+    /*-----------------------------------------------------*\
+    | modern SendData (send whole bytes in one transfer)    |
+    \*-----------------------------------------------------*/
+    unsigned char usb_buf[65];
+
+    unsigned int err_cnt = 3;
+    int          res     = -1;
+    while(res == -1)
+    {
+        /*-----------------------------------------------------*\
+        | Fill data into send buffer                            |
+        \*-----------------------------------------------------*/
+        unsigned int chk_sum = 0;
+        usb_buf[0] = 1;
+
+        for(unsigned int idx = 0; idx < length; idx++)
+        {
+            usb_buf[idx + 1] = data[idx];
+            chk_sum ^= data[idx];
+        }
+        usb_buf[length + 1] = chk_sum;
+
+        res = hid_send_feature_report(dev, usb_buf, length + 2);
+        if(res == -1)
+        {
+            if(!err_cnt--)
+            {
+                return;
+            }
+        }
+        /*-----------------------------------------------------*\
+        | Hack to work around a firmware bug in v21.27.0        |
+        \*-----------------------------------------------------*/
+        std::this_thread::sleep_for(0.3ms);
+    }
+}
+
+void DasKeyboardController::SendDataTraditional(const unsigned char *data, const unsigned int length)
+{
+    /*-----------------------------------------------------*\
+    | traditional SendData (split into chunks of 8 byte)    |
+    \*-----------------------------------------------------*/
+    unsigned char usb_buf[9];
+
+    /*-----------------------------------------------------*\
+    | Fill data into send buffer                            |
+    \*-----------------------------------------------------*/
+    unsigned int err_cnt = 3;
+    unsigned int chk_sum = 0;
+    usb_buf[8] = 0;
+
+    for(unsigned int idx = 0; idx < length + 1; idx += 7)
+    {
+        usb_buf[0] = 1;
+        for(unsigned int fld_idx = 1; fld_idx < 8; fld_idx++)
+        {
+            unsigned int tmp_idx = idx + fld_idx - 1;
+            if(tmp_idx < length)
+            {
+                usb_buf[fld_idx] = data[tmp_idx];
+                chk_sum ^= data[tmp_idx];
+            }
+            else if(tmp_idx == length)
+            {
+                usb_buf[fld_idx] = chk_sum;
+            }
+            else
+            {
+                usb_buf[fld_idx] = 0;
+            }
+        }
+        int res = hid_send_feature_report(dev, usb_buf, 8);
+        if(res == -1)
+        {
+            idx = 0;
+            if(!err_cnt--)
+            {
+                return;
+            }
+        }
+
+        /*-----------------------------------------------------*\
+        | Hack to work around a firmware bug in v21.27.0        |
+        \*-----------------------------------------------------*/
+        std::this_thread::sleep_for(0.3ms);
+    }
+}
+
+int DasKeyboardController::ReceiveData(unsigned char *data, const unsigned int max_length)
+{
+    unsigned char              usb_buf[9];
+    std::vector<unsigned char> receive_buf;
+
+    /*-----------------------------------------------------*\
+    | Fill data from receive buffer                         |
+    \*-----------------------------------------------------*/
+    unsigned int chk_sum = 0;
+
+    do
+    {
+        memset(usb_buf, 0x00, sizeof(usb_buf));
+        usb_buf[0x00] = 0x01;
+
+        int res = hid_get_feature_report(dev, usb_buf, 8);
+        if(res == -1)
+        {
+            break;
+        }
+
+        if(usb_buf[0])
+        {
+            for(unsigned int ii = 0; ii < 8; ii++)
+            {
+                receive_buf.push_back(usb_buf[ii]);
+                chk_sum ^= usb_buf[ii];
+            }
+        }
+    } while(usb_buf[0]);
+
+    /*-----------------------------------------------------*\
+    | clean up data buffer                                  |
+    \*-----------------------------------------------------*/
+    for(unsigned int ii = 0; ii < max_length; ii++)
+    {
+        data[ii] = 0;
+    }
+
+    /*-----------------------------------------------------*\
+    | If checksum is not correct, return with empty buffer  |
+    \*-----------------------------------------------------*/
+    if(chk_sum)
+    {
+        return -1;
+    }
+
+    size_t response_size = 0;
+    if(receive_buf.size() > 1)
+    {
+        response_size = receive_buf.at(1);
+        if(response_size + 2 > receive_buf.size())
+        {
+            return -1;
+        }
+        if(response_size > max_length)
+        {
+            response_size = static_cast<int>(max_length);
+        }
+
+        /*-----------------------------------------------------*\
+        | Remove first two bytes (signature?) and content length|
+        \*-----------------------------------------------------*/
+        for(size_t ii = 0; ii < response_size - 1; ii++)
+        {
+            data[ii] = receive_buf.at(ii + 2);
+        }
+    }
+
+    return response_size;
+}

Controllers/DasKeyboardController/DasKeyboardController.h

@@ -0,0 +1,52 @@
+/*-----------------------------------------*\
+|  DasKeyboardController.h                  |
+|                                           |
+|  Definitions and types for Das Keyboard   |
+|  RGB keyboard lighting controller         |
+|                                           |
+|  Frank Niessen (denk_mal) 12/16/2020      |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+class DasKeyboardController
+{
+public:
+    DasKeyboardController(hid_device *dev_handle, const char *path);
+
+    ~DasKeyboardController();
+
+    std::string GetDeviceLocation();
+
+    std::string GetSerialString();
+
+    std::string GetVersionString();
+
+    std::string GetLayoutString();
+
+    void SendColors(unsigned char key_id, unsigned char mode,
+                    unsigned char red, unsigned char green, unsigned char blue);
+
+    void SendApply();
+
+private:
+    hid_device  *dev;
+    std::string location;
+    std::string version;
+    bool        useTraditionalSendData;
+
+    void SendInitialize();
+
+    void SendData(const unsigned char *data, unsigned int length);
+
+    void SendDataTraditional(const unsigned char *data, unsigned int length);
+
+    void SendDataModern(const unsigned char *data, unsigned int length);
+
+    int ReceiveData(unsigned char *data, unsigned int max_length);
+};

Controllers/DasKeyboardController/DasKeyboardControllerDetect.cpp

@@ -0,0 +1,70 @@
+#include "Detector.h"
+#include "DasKeyboardController.h"
+#include "RGBController.h"
+#include "RGBController_DasKeyboard.h"
+#include <hidapi/hidapi.h>
+
+/*-----------------------------------------------------*\
+| Das Keyboard vendor ID                                |
+\*-----------------------------------------------------*/
+#define DAS_KEYBOARD_VID                0x24F0
+
+/*-----------------------------------------------------*\
+| Keyboard product IDs                                  |
+\*-----------------------------------------------------*/
+#define DAS_KEYBOARD_Q4_PID             0x2037
+#define DAS_KEYBOARD_Q5_PID             0x2020
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectDasKeyboardControllers                                                           *
+*                                                                                          *
+*       Tests the USB address to see if a Das Keyboard RGB controller exists there.        *
+*       We need the second interface to communicate with the keyboard                      *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectDasKeyboardControllers(hid_device_info *info_in, const std::string &name)
+{
+    hid_device_info *info = info_in;
+
+    while(info)
+    {
+        if(info->vendor_id        == DAS_KEYBOARD_VID     &&
+          (info->product_id       == DAS_KEYBOARD_Q4_PID  ||
+           info->product_id       == DAS_KEYBOARD_Q5_PID) &&
+           info->interface_number == 1)
+        {
+            break;
+        }
+        info = info->next;
+    }
+
+    if(!info)
+    {
+        return;
+    }
+
+    hid_device *dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        DasKeyboardController *controller = new DasKeyboardController(dev, info->path);
+
+        if(controller->GetLayoutString() == "NONE")
+        {
+            delete controller;
+        }
+        else
+        {
+            RGBController_DasKeyboard *rgb_controller = new RGBController_DasKeyboard(controller);
+            rgb_controller->SetupZones();
+            rgb_controller->name = name;
+
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+    }
+}   /* DetectDasKeyboardControllers() */
+
+REGISTER_HID_DETECTOR_I("Das Keyboard Q4 RGB", DetectDasKeyboardControllers, DAS_KEYBOARD_VID, DAS_KEYBOARD_Q4_PID, 0);
+REGISTER_HID_DETECTOR_I("Das Keyboard Q5 RGB", DetectDasKeyboardControllers, DAS_KEYBOARD_VID, DAS_KEYBOARD_Q5_PID, 0);

Controllers/DasKeyboardController/RGBController_DasKeyboard.cpp

@@ -0,0 +1,346 @@
+/*-----------------------------------------*\
+|  RGBController_DasKeyboard.cpp            |
+|                                           |
+|  Generic RGB Interface for Das Keyboard   |
+|  RGB keyboard devices                     |
+|                                           |
+|  Frank Niessen (denk_mal) 12/16/2020      |
+\*-----------------------------------------*/
+
+#include "RGBController_DasKeyboard.h"
+
+using namespace std::chrono_literals;
+
+//0xFFFFFFFF indicates an unused entry in matrix
+#define NA  0xFFFFFFFF
+
+// US Layout TODO: mus be checked/corrected
+static unsigned int matrix_map_us[7][21] =
+    {
+        {NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA,  NA, 126,  NA,  NA,  NA},
+        { 5, NA, 17, 23, 29, 35, 41, 47, 53, 59, 65, 71, 77, 83, 89, 95, 101, 127, 128, 129, 130},
+        { 4, 10, 16, 22, 28, 34, 40, 46, 52, 58, 64, 70, 76, 82, 88, 94, 100, 106, 112, 118, 124},
+        { 3,  9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75,  7, 87, 93,  99, 105, 111, 117, 123},
+        { 2,  8, 14, 20, 26, 32, 38, 44, 50, 56, 62, 68, NA, 80, NA, NA,  NA, 104, 110, 116,  NA},
+        { 1, NA, 13, 19, 25, 31, 37, 43, 49, 55, 61, 67, 79, NA, NA, 91,  NA, 103, 109, 115, 122},
+        { 0,  6, 12, NA, NA, NA, 36, NA, NA, NA, 60, 66, 72, 78, 84, 90,  96, 102,  NA, 114,  NA}
+    };
+
+// EU Layout
+static unsigned int matrix_map_eu[7][21] =
+    {
+        {NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA,  NA, 126,  NA,  NA,  NA},
+        { 5, NA, 17, 23, 29, 35, 41, 47, 53, 59, 65, 71, 77, 83, 89, 95, 101, 127, 128, 129, 130},
+        { 4, 10, 16, 22, 28, 34, 40, 46, 52, 58, 64, 70, 76, 82, 88, 94, 100, 106, 112, 118, 124},
+        { 3,  9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, NA, 87, 93,  99, 105, 111, 117, 123},
+        { 2,  8, 14, 20, 26, 32, 38, 44, 50, 56, 62, 68, 81, 80, NA, NA,  NA, 104, 110, 116,  NA},
+        { 1,  7, 13, 19, 25, 31, 37, 43, 49, 55, 61, 67, 79, NA, NA, 91,  NA, 103, 109, 115, 122},
+        { 0,  6, 12, NA, NA, NA, 36, NA, NA, NA, 60, 66, 72, 78, 84, 90,  96, 102,  NA, 114,  NA}
+    };
+
+static const char *zone_names[] =
+    {
+        "Keyboard"
+    };
+
+static zone_type zone_types[] =
+    {
+        ZONE_TYPE_MATRIX,
+    };
+
+static const unsigned int zone_sizes[] =
+    {
+        131
+    };
+
+// UK Layout
+static const char *led_names[] =
+    {
+        "Key: Left Control",
+        "Key: Left Shift",
+        "Key: Caps Lock",
+        "Key: Tab",
+        "Key: `",
+        "Key: Escape",
+        "Key: Left Windows",
+        "Key: \\ (ANSI)",
+        "Key: A",
+        "Key: Q",
+        "Key: 1",
+        "Undefined",
+        "Key: Left Alt",
+        "Key: Z",
+        "Key: S",
+        "Key: W",
+        "Key: 2",
+        "Key: F1",
+        "Undefined",
+        "Key: X",
+        "Key: D",
+        "Key: E",
+        "Key: 3",
+        "Key: F2",
+        "Undefined",
+        "Key: C",
+        "Key: F",
+        "Key: R",
+        "Key: 4",
+        "Key: F3",
+        "Undefined",
+        "Key: V",
+        "Key: G",
+        "Key: T",
+        "Key: 5",
+        "Key: F4",
+        "Key: Space",
+        "Key: B",
+        "Key: H",
+        "Key: Y",
+        "Key: 6",
+        "Key: F5",
+        "Undefined",
+        "Key: N",
+        "Key: J",
+        "Key: U",
+        "Key: 7",
+        "Key: F6",
+        "Undefined",
+        "Key: M",
+        "Key: K",
+        "Key: I",
+        "Key: 8",
+        "Key: F7",
+        "Undefined",
+        "Key: ,",
+        "Key: L",
+        "Key: O",
+        "Key: 9",
+        "Key: F8",
+        "Key: Right Alt",
+        "Key: .",
+        "Key: ;",
+        "Key: P",
+        "Key: 0",
+        "Key: F9",
+        "Key: Right Windows",
+        "Key: /",
+        "Key: '",
+        "Key: [",
+        "Key: -",
+        "Key: F10",
+        "Key: Menu",
+        "Undefined",
+        "Undefined",
+        "Key: ]",
+        "Key: =",
+        "Key: F11",
+        "Key: Right Control",
+        "Key: Right Shift",
+        "Key: Enter",
+        "Key: #",
+        "Key: Backspace",
+        "Key: F12",
+        "Key: Left Arrow",
+        "Undefined",
+        "Undefined",
+        "Key: Delete",
+        "Key: Insert",
+        "Key: Print Screen",
+        "Key: Down Arrow",
+        "Key: Up Arrow",
+        "Undefined",
+        "Key: End",
+        "Key: Home",
+        "Key: Scroll Lock",
+        "Key: Right Arrow",
+        "Undefined",
+        "Undefined",
+        "Key: Page Down",
+        "Key: Page Up",
+        "Key: Pause/Break",
+        "Key: Number Pad 0",
+        "Key: Number Pad 1",
+        "Key: Number Pad 4",
+        "Key: Number Pad 7",
+        "Key: Num Lock",
+        "Undefined",
+        "Undefined",
+        "Key: Number Pad 2",
+        "Key: Number Pad 5",
+        "Key: Number Pad 8",
+        "Key: Number Pad /",
+        "Undefined",
+        "Key: Number Pad .",
+        "Key: Number Pad 3",
+        "Key: Number Pad 6",
+        "Key: Number Pad 9",
+        "Key: Number Pad *",
+        "Undefined",
+        "Undefined",
+        "Undefined",
+        "Key: Number Pad Enter",
+        "Key: Number Pad +",
+        "Key: Number Pad -",
+        "Undefined",
+        "Key: Sleep",
+        "Key: Brightness",
+        "Key: Media Play/Pause",
+        "Key: Media Next",
+        "Key: Q-Button"
+    };
+
+RGBController_DasKeyboard::RGBController_DasKeyboard(DasKeyboardController *das_ptr)
+{
+    das = das_ptr;
+
+    for(unsigned int ii = 0; ii < zone_sizes[0]; ii++)
+    {
+        double_buffer.push_back(-1);
+    }
+
+    updateDevice = true;
+
+    name        = "Das Keyboard Device";
+    vendor      = "Metadot";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "Das Keyboard Device";
+    location    = das->GetDeviceLocation();
+    serial      = das->GetSerialString();
+    version     = das->GetVersionString();
+
+    modes.resize(4);
+    modes[0].name       = "Direct";
+    modes[0].value      = DAS_KEYBOARD_MODE_DIRECT;
+    modes[0].flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    modes[0].color_mode = MODE_COLORS_PER_LED;
+
+    modes[1].name       = "Flashing";
+    modes[1].value      = DAS_KEYBOARD_MODE_FLASHING;
+    modes[1].flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    modes[1].color_mode = MODE_COLORS_PER_LED;
+
+    modes[2].name       = "Breathing";
+    modes[2].value      = DAS_KEYBOARD_MODE_BREATHING;
+    modes[2].flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    modes[2].color_mode = MODE_COLORS_PER_LED;
+
+    modes[3].name       = "Spectrum Cycle";
+    modes[3].value      = DAS_KEYBOARD_MODE_SPECTRUM_CYCLE;
+    modes[3].flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    modes[3].color_mode = MODE_COLORS_PER_LED;
+}
+
+RGBController_DasKeyboard::~RGBController_DasKeyboard()
+{
+    /*---------------------------------------------------------*\
+    | Delete the matrix map                                     |
+    \*---------------------------------------------------------*/
+    unsigned int zone_size = zones.size();
+
+    for(unsigned int zone_index = 0; zone_index < zone_size; zone_index++)
+    {
+        delete zones[zone_index].matrix_map;
+    }
+
+    delete das;
+}
+
+void RGBController_DasKeyboard::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    unsigned int total_led_count = 0;
+
+    for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
+    {
+        zone new_zone;
+        new_zone.name               = zone_names[zone_idx];
+        new_zone.type               = zone_types[zone_idx];
+        new_zone.leds_min           = zone_sizes[zone_idx];
+        new_zone.leds_max           = zone_sizes[zone_idx];
+        new_zone.leds_count         = zone_sizes[zone_idx];
+        new_zone.matrix_map         = new matrix_map_type;
+        new_zone.matrix_map->height = 7;
+        new_zone.matrix_map->width  = 21;
+
+        if(das->GetLayoutString() == "US")
+        {
+            new_zone.matrix_map->map = (unsigned int *) &matrix_map_us;
+        }
+        else
+        {
+            new_zone.matrix_map->map = (unsigned int *) &matrix_map_eu;
+        }
+
+        zones.push_back(new_zone);
+
+        total_led_count += zone_sizes[zone_idx];
+    }
+
+    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
+    {
+        led new_led;
+        new_led.name = led_names[led_idx];
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_DasKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_DasKeyboard::DeviceUpdateLEDs()
+{
+    UpdateZoneLEDs(0);
+}
+
+void RGBController_DasKeyboard::UpdateZoneLEDs(int /*zone*/)
+{
+    updateDevice = false;
+
+    for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        UpdateSingleLED(static_cast<int>(led_idx));
+    }
+
+    updateDevice = true;
+
+    das->SendApply();
+}
+
+void RGBController_DasKeyboard::UpdateSingleLED(int led)
+{
+    mode selected_mode = modes[active_mode];
+
+    if(double_buffer[led] == colors[led])
+    {
+        return;
+    }
+
+    das->SendColors(led, selected_mode.value,
+                    RGBGetRValue(colors[led]),
+                    RGBGetGValue(colors[led]),
+                    RGBGetBValue(colors[led]));
+
+    double_buffer[led] = colors[led];
+
+    if(updateDevice)
+    {
+        das->SendApply();
+    }
+}
+
+void RGBController_DasKeyboard::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_DasKeyboard::DeviceUpdateMode()
+{
+}

Controllers/DasKeyboardController/RGBController_DasKeyboard.h

@@ -0,0 +1,50 @@
+/*-----------------------------------------*\
+|  RGBController_DasKeyboard.h              |
+|                                           |
+|  Generic RGB Interface for Das Keyboard   |
+|  RGB keyboard devices                     |
+|                                           |
+|  Frank Niessen (denk_mal) 12/16/2020      |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "DasKeyboardController.h"
+
+enum
+{
+    DAS_KEYBOARD_MODE_DIRECT         = 0x01,
+    DAS_KEYBOARD_MODE_FLASHING       = 0x1F,
+    DAS_KEYBOARD_MODE_BREATHING      = 0x08,
+    DAS_KEYBOARD_MODE_SPECTRUM_CYCLE = 0x14
+};
+
+
+class RGBController_DasKeyboard : public RGBController
+{
+public:
+    RGBController_DasKeyboard(DasKeyboardController *das_ptr);
+
+    ~RGBController_DasKeyboard();
+
+    void SetupZones();
+
+    void ResizeZone(int zone, int new_size);
+
+    void DeviceUpdateLEDs();
+
+    void UpdateZoneLEDs(int zone);
+
+    void UpdateSingleLED(int led);
+
+    void SetCustomMode();
+
+    void DeviceUpdateMode();
+
+private:
+    DasKeyboardController *das;
+
+    std::vector<RGBColor> double_buffer;
+    bool                  updateDevice;
+};

Controllers/DebugController/DebugControllerDetect.cpp

@@ -25,6 +25,11 @@ static unsigned int debug_keyboard_matrix_map[6][23] =
       {   4,  20,  34,  48,  58,  69,  NA,  79,  NA,  88,  99,  12,  27,  42 ,  81,  NA ,  NA, 102,  NA,  64,  74,  83, 104 },
       {   5,  21,  35,  NA,  NA,  NA,  NA,  59,  NA,  NA,  NA,  NA,  89,  100,  13,  91 ,  15,  29,  43,  94,  NA, 105,  NA } };
 
+static unsigned int dummy_keyboard_underglow_map[3][10] =
+    { {   0 , 1 ,  2 ,  3 ,  4 ,  5 ,  6 ,  7 ,  8 ,  9  },
+      {   10, 11,  12,  13,  14,  15,  16,  17,  18,  19 },
+      {   20, 21,  22,  23,  24,  25,  26,  27,  28,  29 } };
+
 static const char *led_names[] =
 {
     "Key: Escape",
@@ -154,10 +159,39 @@ static const char *led_names[] =
     "Key: Media Previous",
     "Key: Media Play/Pause",
     "Key: Media Next",
-    "Key: Media Mute"
+    "Key: Media Mute",
+    "Underglow LED 1",
+    "Underglow LED 2",
+    "Underglow LED 3",
+    "Underglow LED 4",
+    "Underglow LED 5",
+    "Underglow LED 6",
+    "Underglow LED 7",
+    "Underglow LED 8",
+    "Underglow LED 9",
+    "Underglow LED 10",
+    "Underglow LED 11",
+    "Underglow LED 12",
+    "Underglow LED 13",
+    "Underglow LED 14",
+    "Underglow LED 15",
+    "Underglow LED 16",
+    "Underglow LED 17",
+    "Underglow LED 18",
+    "Underglow LED 19",
+    "Underglow LED 20",
+    "Underglow LED 21",
+    "Underglow LED 22",
+    "Underglow LED 23",
+    "Underglow LED 24",
+    "Underglow LED 25",
+    "Underglow LED 26",
+    "Underglow LED 27",
+    "Underglow LED 28",
+    "Underglow LED 29",
+    "Underglow LED 30"
 };
 
-
 /******************************************************************************************\
 *                                                                                          *
 *   DetectDebugControllers                                                                 *
@@ -169,7 +203,7 @@ static const char *led_names[] =
 void DetectDebugControllers(std::vector<RGBController*> &rgb_controllers)
 {
     json            debug_settings;
-    
+
     /*-------------------------------------------------*\
     | Get Debug Device settings from settings manager   |
     \*-------------------------------------------------*/
@@ -432,16 +466,16 @@ void DetectDebugControllers(std::vector<RGBController*> &rgb_controllers)
                 dummy_keyboard->serial                           = "Debug Keyboard Serial";
 
                 /*---------------------------------------------------------*\
-                | Create a direct mode for the dummy GPU                    |
+                | Create a direct mode for the dummy keyboard               |
                 \*---------------------------------------------------------*/
-                mode dummy_gpu_direct_mode;
+                mode dummy_keyboard_direct_mode;
 
-                dummy_gpu_direct_mode.name                  = "Direct";
-                dummy_gpu_direct_mode.value                 = 0;
-                dummy_gpu_direct_mode.flags                 = MODE_FLAG_HAS_PER_LED_COLOR;
-                dummy_gpu_direct_mode.color_mode            = MODE_COLORS_PER_LED;
+                dummy_keyboard_direct_mode.name                  = "Direct";
+                dummy_keyboard_direct_mode.value                 = 0;
+                dummy_keyboard_direct_mode.flags                 = MODE_FLAG_HAS_PER_LED_COLOR;
+                dummy_keyboard_direct_mode.color_mode            = MODE_COLORS_PER_LED;
 
-                dummy_keyboard->modes.push_back(dummy_gpu_direct_mode);
+                dummy_keyboard->modes.push_back(dummy_keyboard_direct_mode);
 
                 /*---------------------------------------------------------*\
                 | Create a matrix zone for the debug Keyboard               |
@@ -460,6 +494,23 @@ void DetectDebugControllers(std::vector<RGBController*> &rgb_controllers)
 
                 dummy_keyboard->zones.push_back(dummy_keyboard_matrix_zone);
 
+                /*-----------------------------------------------------------------*\
+                | Add another matrix zone so that is can resemble a huntsman elite  |
+                \*-----------------------------------------------------------------*/
+                zone dummy_keyboard_underglow_matrix_zone;
+
+                dummy_keyboard_underglow_matrix_zone.name               = "Underglow";
+                dummy_keyboard_underglow_matrix_zone.type               = ZONE_TYPE_MATRIX;
+                dummy_keyboard_underglow_matrix_zone.leds_min           = 30;
+                dummy_keyboard_underglow_matrix_zone.leds_max           = 30;
+                dummy_keyboard_underglow_matrix_zone.leds_count         = 30;
+                dummy_keyboard_underglow_matrix_zone.matrix_map         = new matrix_map_type;
+                dummy_keyboard_underglow_matrix_zone.matrix_map->height = 3;
+                dummy_keyboard_underglow_matrix_zone.matrix_map->width  = 10;
+                dummy_keyboard_underglow_matrix_zone.matrix_map->map    = (unsigned int*)&dummy_keyboard_underglow_map;
+
+                dummy_keyboard->zones.push_back(dummy_keyboard_underglow_matrix_zone);
+
                 /*---------------------------------------------------------*\
                 | Create a linear zone for the dummy GPU                    |
                 \*---------------------------------------------------------*/
@@ -474,7 +525,7 @@ void DetectDebugControllers(std::vector<RGBController*> &rgb_controllers)
 
                 dummy_keyboard->zones.push_back(dummy_keyboard_linear_zone);
 
-                for(std::size_t led_idx = 0; led_idx < 124; led_idx++)
+                for(std::size_t led_idx = 0; led_idx < 154; led_idx++)
                 {
                     led dummy_keyboard_led;
                     dummy_keyboard_led.name = led_names[led_idx];
@@ -513,7 +564,7 @@ void DetectDebugControllers(std::vector<RGBController*> &rgb_controllers)
                 dummy_argb_direct_mode.color_mode           = MODE_COLORS_PER_LED;
 
                 dummy_argb->modes.push_back(dummy_argb_direct_mode);
-                
+
                 /*---------------------------------------------------------*\
                 | Create a linear zone for the dummy ARGB                   |
                 \*---------------------------------------------------------*/
@@ -539,6 +590,219 @@ void DetectDebugControllers(std::vector<RGBController*> &rgb_controllers)
         }
     }
 
+    if (debug_settings.contains("CustomDevices"))
+    {
+        for (int CustomDevice = 0; CustomDevice < (int)debug_settings["CustomDevices"].size(); CustomDevice++)
+        {
+            json CustomDev = debug_settings["CustomDevices"][CustomDevice];
+            /*---------------------------*\
+            | Create a custom controller  |
+            \*---------------------------*/
+            RGBController_Debug* dummy_custom = new RGBController_Debug();
+
+            /*----------------------------------------------------------------------*\
+            | if ANY of the attributes are missing then go ahead and skip the entry  |
+            \*----------------------------------------------------------------------*/
+            if (
+                    !CustomDev.contains("DeviceName")        ||
+                    !CustomDev.contains("DeviceType")        ||
+                    !CustomDev.contains("DeviceDescription") ||
+                    !CustomDev.contains("DeviceLocation")    ||
+                    !CustomDev.contains("DeviceVersion")     ||
+                    !CustomDev.contains("DeviceSerial")      ||
+                    !CustomDev.contains("DeviceZones")
+                    )
+            {
+                continue;
+            }
+
+
+            /*-------------*\
+            | Set the name  |
+            \*-------------*/
+            dummy_custom->name = CustomDev["DeviceName"];
+
+            /*---------------------*\
+            | Find the device type  |
+            \*---------------------*/
+            if      (CustomDev["DeviceType"] == "motherboard")   dummy_custom->type = DEVICE_TYPE_MOTHERBOARD;
+            else if (CustomDev["DeviceType"] == "dram")          dummy_custom->type = DEVICE_TYPE_DRAM;
+            else if (CustomDev["DeviceType"] == "gpu")           dummy_custom->type = DEVICE_TYPE_GPU;
+            else if (CustomDev["DeviceType"] == "cooler")        dummy_custom->type = DEVICE_TYPE_COOLER;
+            else if (CustomDev["DeviceType"] == "led_strip")     dummy_custom->type = DEVICE_TYPE_LEDSTRIP;
+            else if (CustomDev["DeviceType"] == "keyboard")      dummy_custom->type = DEVICE_TYPE_KEYBOARD;
+            else if (CustomDev["DeviceType"] == "mouse")         dummy_custom->type = DEVICE_TYPE_MOUSE;
+            else if (CustomDev["DeviceType"] == "mousemat")      dummy_custom->type = DEVICE_TYPE_MOUSEMAT;
+            else if (CustomDev["DeviceType"] == "headset")       dummy_custom->type = DEVICE_TYPE_HEADSET;
+            else if (CustomDev["DeviceType"] == "headset_stand") dummy_custom->type = DEVICE_TYPE_HEADSET_STAND;
+            else if (CustomDev["DeviceType"] == "gamepad")       dummy_custom->type = DEVICE_TYPE_GAMEPAD;
+            else if (CustomDev["DeviceType"] == "light")         dummy_custom->type = DEVICE_TYPE_LIGHT;
+            else if (CustomDev["DeviceType"] == "speaker")       dummy_custom->type = DEVICE_TYPE_SPEAKER;
+            else if (CustomDev["DeviceType"] == "unknown")       dummy_custom->type = DEVICE_TYPE_UNKNOWN;
+
+            /*-----------------------------------------------*\
+            | Set description, location, version, and serial  |
+            \*-----------------------------------------------*/
+            dummy_custom->description = CustomDev["DeviceDescription"];
+            dummy_custom->location    = CustomDev["DeviceLocation"];
+            dummy_custom->version     = CustomDev["DeviceVersion"];
+            dummy_custom->serial      = CustomDev["DeviceSerial"];
+
+            /*----------------*\
+            | Create the mode  |
+            \*----------------*/
+            mode dummy_custom_direct;
+            dummy_custom_direct.name                 = "Direct";
+            dummy_custom_direct.value                = 0;
+            dummy_custom_direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+            dummy_custom_direct.color_mode           = MODE_COLORS_PER_LED;
+            dummy_custom->modes.push_back(dummy_custom_direct);
+
+            /*--------------*\
+            | Fill in zones  |
+            \*--------------*/
+            for (int ZoneID = 0; ZoneID < (int)CustomDev["DeviceZones"].size(); ZoneID++)
+            {
+                json ZoneJson = CustomDev["DeviceZones"][ZoneID];
+                if
+                (
+                    !ZoneJson.contains("name")       ||
+                    !ZoneJson.contains("type")       ||
+                    !ZoneJson.contains("leds_min")   ||
+                    !ZoneJson.contains("leds_max")   ||
+                    !ZoneJson.contains("leds_count")
+                )
+                {
+                    continue;
+                }
+                zone custom_zone;
+
+                custom_zone.name = ZoneJson["name"];
+
+                if      (ZoneJson["type"] == "linear") custom_zone.type = ZONE_TYPE_LINEAR;
+                else if (ZoneJson["type"] == "matrix") custom_zone.type = ZONE_TYPE_MATRIX;
+                else if (ZoneJson["type"] == "single") custom_zone.type = ZONE_TYPE_SINGLE;
+                else
+                {
+                    continue;
+                }
+
+                custom_zone.leds_min   = ZoneJson["leds_min"];
+                custom_zone.leds_max   = ZoneJson["leds_max"];
+                custom_zone.leds_count = ZoneJson["leds_count"];
+
+                /*-----------------------*\
+                | Fill in the matrix map  |
+                \*-----------------------*/
+                bool BadVal = false;
+                if (custom_zone.type == ZONE_TYPE_MATRIX)
+                {
+                    if
+                    (
+                        !ZoneJson.contains("matrix_height") ||
+                        !ZoneJson.contains("matrix_width")  ||
+                        !ZoneJson.contains("matrix_map")
+                    )
+                    {
+                        /*--------------------------------------------------------------*\
+                        | If there is no map then the zone can't be valid. Don't add it  |
+                        \*--------------------------------------------------------------*/
+                        continue;
+                    }
+
+                    custom_zone.matrix_map = new matrix_map_type;
+
+                    custom_zone.matrix_map->width  = ZoneJson["matrix_width"];
+                    custom_zone.matrix_map->height = ZoneJson["matrix_height"];
+
+                    int H = custom_zone.matrix_map->height;
+                    int W = custom_zone.matrix_map->width;
+
+                    BadVal = (ZoneJson["matrix_map"].size() != custom_zone.matrix_map->height);
+
+                    unsigned int* MatrixARR = new unsigned int[H * W];
+                    for (int MatrixMapRow = 0; MatrixMapRow < H; MatrixMapRow++)
+                    {
+                        /*-----------------------------------------------------------------------------------------------------*\
+                        | If something went wrong then make no attempt to recover and just move on in a way that doesn't crash  |
+                        | Even 1 bad row can corrupt the map so skip the zone entirely                                          |
+                        \*-----------------------------------------------------------------------------------------------------*/
+                        if ((custom_zone.matrix_map->width != ZoneJson["matrix_map"][MatrixMapRow].size()) || BadVal)
+                        {
+                            BadVal = true;
+                            break;
+                        }
+
+                        for (int MatrixMapCol = 0; MatrixMapCol < W; MatrixMapCol++)
+                        {
+                            int Val = ZoneJson["matrix_map"][MatrixMapRow][MatrixMapCol];
+
+                            if ((signed)Val == -1)
+                            {
+                                MatrixARR[MatrixMapRow * W + MatrixMapCol] = NA;
+                            }
+                            else
+                            {
+                                MatrixARR[MatrixMapRow * W + MatrixMapCol] = (unsigned)Val;
+                            }
+                        }
+                    }
+
+                    custom_zone.matrix_map->map = MatrixARR;
+                }
+
+                /*------------------------------------*\
+                | Don't add the zone if it is invalid  |
+                \*------------------------------------*/
+                if (BadVal)
+                {
+                    continue;
+                }
+
+                bool UseCustomLabels = false;
+                if (ZoneJson.contains("custom_labels"))
+                {
+                    /*-------------------------------------------------------*\
+                    | If the count is correct and the zone is non-resizeable  |
+                    \*-------------------------------------------------------*/
+                    if ((ZoneJson["custom_labels"].size() == custom_zone.leds_count) && (custom_zone.leds_min == custom_zone.leds_max))
+                    {
+                        UseCustomLabels = true;
+                    }
+                }
+
+                /*------------------*\
+                | Set the LED names  |
+                \*------------------*/
+                for (int LED_ID = 0; LED_ID < (int)custom_zone.leds_count; LED_ID++)
+                {
+                    led custom_led;
+                    if (UseCustomLabels)
+                    {
+                        /*----------------------------------------*\
+                        | Set the label to the user defined label  |
+                        \*----------------------------------------*/
+                        custom_led.name = ZoneJson["custom_labels"][LED_ID];
+                    }
+                    else
+                    {
+                        /*------------------------------------------------*\
+                        | Set default labels because something went wrong  |
+                        \*------------------------------------------------*/
+                        custom_led.name = ("Custom LED. Zone " + std::to_string(ZoneID) + ", LED " + std::to_string(LED_ID));
+                    }
+                    dummy_custom->leds.push_back(custom_led);
+                }
+
+                dummy_custom->zones.push_back(custom_zone);
+            }
+
+            dummy_custom->SetupColors();
+
+            rgb_controllers.push_back(dummy_custom);
+        }
+    }
+
 }   /* DetectDebugControllers() */
 
 REGISTER_DETECTOR("Debug Controllers", DetectDebugControllers);

Controllers/DuckyKeyboardController/DuckyKeyboardController.cpp

@@ -20,7 +20,7 @@ DuckyKeyboardController::DuckyKeyboardController(hid_device* dev_handle, const c
 
 DuckyKeyboardController::~DuckyKeyboardController()
 {
-    
+    hid_close(dev);
 }
 
 std::string DuckyKeyboardController::GetDeviceLocation()
@@ -81,6 +81,7 @@ void DuckyKeyboardController::SendInitialize()
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, (unsigned char *)usb_buf, 65);
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
 }
 
 void DuckyKeyboardController::SendInitializeColorPacket()
@@ -109,6 +110,7 @@ void DuckyKeyboardController::SendInitializeColorPacket()
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, (unsigned char *)usb_buf, 65);
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
 }
 
 unsigned int DuckyKeyboardController::SendColorDataPacket
@@ -176,6 +178,7 @@ unsigned int DuckyKeyboardController::SendColorDataPacket
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, (unsigned char *)usb_buf, 65);
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
 
     return(bytes_sent);
 }
@@ -201,4 +204,5 @@ void DuckyKeyboardController::SendTerminateColorPacket()
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, (unsigned char *)usb_buf, 65);
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
 }

Controllers/DuckyKeyboardController/RGBController_DuckyKeyboard.cpp

@@ -204,6 +204,8 @@ RGBController_DuckyKeyboard::~RGBController_DuckyKeyboard()
             delete zones[zone_index].matrix_map;
         }
     }
+
+    delete ducky;
 }
 
 void RGBController_DuckyKeyboard::SetupZones()

Controllers/E131Controller/E131ControllerDetect.cpp

@@ -52,6 +52,8 @@ void DetectE131Controllers(std::vector<RGBController*> &rgb_controllers)
             dev.matrix_height  = 0;
             dev.start_channel  = 1;
             dev.start_universe = 1;
+            dev.keepalive_time = 0;
+            dev.universe_size  = 512;
 
             if(e131_settings["devices"][device_idx].contains("name"))
             {
@@ -78,6 +80,11 @@ void DetectE131Controllers(std::vector<RGBController*> &rgb_controllers)
                 dev.start_channel = e131_settings["devices"][device_idx]["start_channel"];
             }
 
+            if(e131_settings["devices"][device_idx].contains("keepalive_time"))
+            {
+                dev.keepalive_time = e131_settings["devices"][device_idx]["keepalive_time"];
+            }
+
             if(e131_settings["devices"][device_idx].contains("matrix_order"))
             {
                 std::string matrix_order_val = e131_settings["devices"][device_idx]["matrix_order"];
@@ -164,6 +171,11 @@ void DetectE131Controllers(std::vector<RGBController*> &rgb_controllers)
                 dev.matrix_height = e131_settings["devices"][device_idx]["matrix_height"];
             }
             
+            if(e131_settings["devices"][device_idx].contains("universe_size"))
+            {
+                dev.universe_size = e131_settings["devices"][device_idx]["universe_size"];
+            }
+            
             if(e131_settings["devices"][device_idx].contains("type"))
             {
                 std::string type_val = e131_settings["devices"][device_idx]["type"];

Controllers/E131Controller/RGBController_E131.cpp

@@ -56,7 +56,8 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
 
     for(unsigned int device_idx = 0; device_idx < devices.size(); device_idx++)
     {
-        unsigned int total_universes = ceil( ( ( devices[device_idx].num_leds * 3 ) + devices[device_idx].start_channel ) / 512.0f );
+        float universe_size = devices[device_idx].universe_size;
+        unsigned int total_universes = ceil( ( ( devices[device_idx].num_leds * 3 ) + devices[device_idx].start_channel ) / universe_size );
 
         for(unsigned int univ_idx = 0; univ_idx < total_universes; univ_idx++)
         {
@@ -141,7 +142,8 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
         /*-----------------------------------------*\
         | Add Universes                             |
         \*-----------------------------------------*/
-        unsigned int total_universes = ceil( ( ( devices[device_idx].num_leds * 3 ) + devices[device_idx].start_channel ) / 512.0f );
+        float universe_size = devices[device_idx].universe_size;
+        unsigned int total_universes = ceil( ( ( devices[device_idx].num_leds * 3 ) + devices[device_idx].start_channel ) / universe_size );
 
         for (unsigned int univ_idx = 0; univ_idx < total_universes; univ_idx++)
         {
@@ -161,7 +163,7 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
                 e131_packet_t   packet;
                 e131_addr_t     dest_addr;
 
-                e131_pkt_init(&packet, universe, 512);
+                e131_pkt_init(&packet, universe, universe_size);
 
                 if(multicast)
                 {
@@ -363,7 +365,8 @@ void RGBController_E131::DeviceUpdateLEDs()
     
     for(std::size_t device_idx = 0; device_idx < devices.size(); device_idx++)
     {
-        unsigned int total_universes = ceil( ( ( devices[device_idx].num_leds * 3 ) + devices[device_idx].start_channel ) / 512.0f );
+        float universe_size = devices[device_idx].universe_size;
+        unsigned int total_universes = ceil( ( ( devices[device_idx].num_leds * 3 ) + devices[device_idx].start_channel ) / universe_size );
         unsigned int channel_idx = devices[device_idx].start_channel;
         unsigned int led_idx = 0;
         unsigned int rgb_idx = 0;
@@ -377,7 +380,7 @@ void RGBController_E131::DeviceUpdateLEDs()
             {
                 if(!done && (universes[packet_idx] == universe))
                 {
-                    while(!done && (channel_idx <= 512))
+                    while(!done && (channel_idx <= universe_size))
                     {
                         switch(rgb_idx)
                         {

Controllers/E131Controller/RGBController_E131.h

@@ -51,6 +51,7 @@ struct E131Device
     zone_type type;
     unsigned int matrix_width;
     unsigned int matrix_height;
+    unsigned int universe_size;
     e131_matrix_order matrix_order;
 };
 

Controllers/EKController/RGBController_EKController.cpp

@@ -113,7 +113,7 @@ RGBController_EKController::RGBController_EKController(EKController* _dev)
 
 RGBController_EKController::~RGBController_EKController()
 {
-
+    delete EK_dev;
 }
 
 void RGBController_EKController::SetupZones()

Controllers/EVGAGPUController/EVGAGPUControllerDetect.cpp

@@ -30,11 +30,19 @@ typedef struct
 
 static const gpu_pci_device device_list[] =
 {
-    { NVIDIA_VEN,   NVIDIA_GTX1070_DEV,     EVGA_SUB_VEN,   EVGA_GTX1070_FTW_SUB_DEV,       EVGA_RGB_V1,    "EVGA GeForce GTX 1070 FTW"             },
-    { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,     EVGA_SUB_VEN,   EVGA_GTX1080_FTW_SUB_DEV,       EVGA_RGB_V1,    "EVGA GeForce GTX 1080 FTW"             },
-    { NVIDIA_VEN,   NVIDIA_RTX2070_OC_DEV,  EVGA_SUB_VEN,   EVGA_RTX2070_XC_OC_SUB_DEV,     EVGA_RGB_V2,    "EVGA GeForce RTX 2070 XC OC"           },
-    { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,    EVGA_SUB_VEN,   EVGA_RTX2070S_XC_ULTRA_SUB_DEV, EVGA_RGB_V2,    "EVGA GeForce RTX 2070 SUPER XC ULTRA"  },
-    { NVIDIA_VEN,   NVIDIA_RTX2080_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_GAMING_SUB_DEV, EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC GAMING"       },
+    { NVIDIA_VEN,   NVIDIA_GTX1070_DEV,       EVGA_SUB_VEN,   EVGA_GTX1070_FTW_SUB_DEV,               EVGA_RGB_V1,    "EVGA GeForce GTX 1070 FTW"               },
+    { NVIDIA_VEN,   NVIDIA_GTX1070TI_DEV,     EVGA_SUB_VEN,   EVGA_GTX1070TI_FTW2_SUB_DEV,            EVGA_RGB_V1,    "EVGA GeForce GTX 1070 Ti FTW2"           },
+    { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,       EVGA_SUB_VEN,   EVGA_GTX1080_FTW_SUB_DEV,               EVGA_RGB_V1,    "EVGA GeForce GTX 1080 FTW"               },
+    { NVIDIA_VEN,   NVIDIA_RTX2070_OC_DEV,    EVGA_SUB_VEN,   EVGA_RTX2070_XC_GAMING_SUB_DEV,         EVGA_RGB_V2,    "EVGA GeForce RTX 2070 XC Gaming"         },
+    { NVIDIA_VEN,   NVIDIA_RTX2070_OC_DEV,    EVGA_SUB_VEN,   EVGA_RTX2070_XC_OC_SUB_DEV,             EVGA_RGB_V2,    "EVGA GeForce RTX 2070 XC OC"             },
+    { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,      EVGA_SUB_VEN,   EVGA_RTX2070S_XC_ULTRA_SUB_DEV,         EVGA_RGB_V2,    "EVGA GeForce RTX 2070 SUPER XC Ultra"    },
+    { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,      EVGA_SUB_VEN,   EVGA_RTX2070S_XC_ULTRA_PLUS_SUB_DEV,    EVGA_RGB_V2,    "EVGA GeForce RTX 2070 SUPER XC Ultra+"   },
+    { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_BLACK_SUB_DEV,          EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Black"          },
+    { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_GAMING_SUB_DEV,         EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Gaming"         },
+    { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_ULTRA_GAMING_SUB_DEV,   EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Ultra Gaming"   },
+    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080TI_XC_ULTRA_GAMING_SUB_DEV, EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti XC Ultra"        },
+    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080TI_FTW3_ULTRA_SUB_DEV     , EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti FTW3 Ultra"      },
+
 };
 
 /******************************************************************************************\
@@ -48,7 +56,7 @@ static const gpu_pci_device device_list[] =
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectEVGAGPUControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
+void DetectEVGAGPUControllers(std::vector<i2c_smbus_interface*>& busses)
 {
     for (unsigned int bus = 0; bus < busses.size(); bus++)
     {
@@ -74,7 +82,7 @@ void DetectEVGAGPUControllers(std::vector<i2c_smbus_interface*>& busses, std::ve
                             new_controller          = new EVGAGPUv1Controller(busses[bus], 0x49);
                             new_rgbcontroller       = new RGBController_EVGAGPUv1(new_controller);
                             new_rgbcontroller->name = device_list[dev_idx].name;
-                            rgb_controllers.push_back(new_rgbcontroller);
+                            ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
                         }
                         break;
 
@@ -86,7 +94,7 @@ void DetectEVGAGPUControllers(std::vector<i2c_smbus_interface*>& busses, std::ve
                             new_controller          = new EVGAGPUv2Controller(busses[bus], 0x49);
                             new_rgbcontroller       = new RGBController_EVGAGPUv2(new_controller);
                             new_rgbcontroller->name = device_list[dev_idx].name;
-                            rgb_controllers.push_back(new_rgbcontroller);
+                            ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
                         }
                         break;
                 }