OpenRGB version 0.5

Commits squashed and amended to read information only from settings manager by Adam Honse <[email protected]>

.gitignore

@@ -4,5 +4,8 @@ ui_*
 moc_*
 qrc_*
 OpenRGB
+openrgb
 Makefile
 OpenRGB-x86_64.AppImage
+.qmake.stash
+.vscode

.gitlab-ci.yml

@@ -20,38 +20,90 @@ stages:
 before_script:
  - echo "started by ${GITLAB_USER_NAME}"
 
+#reusable templates
+.ccache_init: &ccache_init
+  before_script:
+    - apt update
+    - apt install -y build-essential qtcreator qt5-default libusb-1.0-0-dev libhidapi-dev pkgconf wget git
+
 #-----------------------------------------------------------------------#
 # Linux (AppImage) 32-bit Build Target                                  #
 #-----------------------------------------------------------------------#
 build_linux_32:
+  <<: *ccache_init
   image: i386/ubuntu:bionic
   stage: build
   script:
-  - apt update
-  - apt install -y build-essential qtcreator qt5-default libusb-1.0-0-dev libhidapi-dev pkgconf wget git
-  - ./scripts/build-appimage-32.sh
+  - export $(dpkg-architecture)
+  - ./scripts/build-appimage.sh
   
   artifacts:
     paths:
     - OpenRGB-i386.AppImage
-    expire_in: 1337 years
+    - 60-openrgb.rules
+    - README.md
+    expire_in: 30 days
 
 #-----------------------------------------------------------------------#
 # Linux (AppImage) 64-bit Build Target                                  #
 #-----------------------------------------------------------------------#
 build_linux_64:
+  <<: *ccache_init
   image: ubuntu:bionic
   stage: build
   script:
-  - apt update
-  - apt install -y build-essential qtcreator qt5-default libusb-1.0-0-dev libhidapi-dev pkgconf wget git
+  - export $(dpkg-architecture)
   - ./scripts/build-appimage.sh
   
   artifacts:
     paths:
     - OpenRGB-x86_64.AppImage
-    expire_in: 1337 years
-  
+    - 60-openrgb.rules
+    - README.md
+    expire_in: 30 days
+
+#-----------------------------------------------------------------------#
+# Linux (.deb) 32-bit Build Target                                      #
+#-----------------------------------------------------------------------#
+build_linux_deb32:
+  <<: *ccache_init
+  image: i386/ubuntu:bionic
+  stage: build
+  script:
+  - apt install -y debhelper
+  - dpkg-architecture -l
+  - dpkg-buildpackage --target-arch i386 -us -B
+  - rm -v ../openrgb-dbgsym*.ddeb
+  - mv -v ../openrgb*.deb ./
+
+  artifacts:
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.deb
+    expire_in: 30 days
+
+#-----------------------------------------------------------------------#
+# Linux (.deb) 64-bit Build Target                                      #
+#-----------------------------------------------------------------------#
+build_linux_deb64:
+  <<: *ccache_init
+  image: ubuntu:bionic
+  stage: build
+  script:
+  - apt install -y debhelper
+  - dpkg-architecture -l
+  - dpkg-buildpackage -us -B
+  - rm -v ../openrgb-dbgsym*.ddeb
+  - mv -v ../openrgb*.deb ./
+
+  artifacts:
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.deb
+    expire_in: 30 days
+
 #-----------------------------------------------------------------------#
 # Windows (32-bit) Build Target                                         #
 #-----------------------------------------------------------------------#
@@ -122,7 +174,7 @@ build_windows_32:
   artifacts:
     paths:
     - _build/*.7z
-    expire_in: 1337 years
+    expire_in: 30 days
 
 #-----------------------------------------------------------------------#
 # Windows (64-bit) Build Target                                         #
@@ -194,4 +246,4 @@ build_windows_64:
   artifacts:
     paths:
     - _build/*.7z
-    expire_in: 1337 years
+    expire_in: 30 days

.gitlab/issue_templates/Bug Report.md

@@ -0,0 +1,14 @@
+<!-- 
+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.
+-->
+
+
+### 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.
+-->

.gitlab/issue_templates/Feature Request.md

@@ -0,0 +1,9 @@
+<!-- 
+Have something you would like to see added to OpenRGB? Let us know here 
+To help us keep track of the requests please start the title with [Feature Request]
+-->
+
+### 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.
+-->

.gitlab/issue_templates/New Device.md

@@ -0,0 +1,48 @@
+<!-- 
+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
+-->
+
+### Name of device:
+<!--
+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 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)
+
+### 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
+For USB devices we will need the USB VID and PID
+-->
+
+
+### Please attach screenshots of the device's official control application here:
+<!--
+Screenshots of the official control software should show lists of supported modes, color selection, and zone/LED selection capabilities of the device's official software.
+-->
+
+
+### 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
+-->

60-openrgb.rules

@@ -68,6 +68,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c12", TAG+="uacces
 #       Corsair LS100                                           #
 #       Corsair 1000D Obsidian                                  #
 #       Corsair Spec Omega RGB                                  #
+#       Corsair LT100                                           #
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c1a", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c0b", TAG+="uaccess"
@@ -75,6 +76,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c10", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c1e", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1d00", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1d04", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0a32", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  Corsair Peripheral Devices                                   #
@@ -134,12 +136,28 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0a34", TAG+="uacces
 #                                                               #
 #  Keyboards:                                                   #
 #       HyperX Alloy Elite                                      #
+#                                                               #
+#  Mice:                                                        #
+#       HyperX Pulsefire Surge                                  #
+#                                                               #
+#  Mousemats:                                                   #
+#       HyperX Fury Ultra                                       #
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16be", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16d3", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="1705", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  Logitech Peripheral Devices                                  #
 #                                                               #
+#   Keyboards:                                                  #
+#       Logitech G213                                           #
+#       Logitech G512                                           #
+#       Logitech G512 RGB                                       #
+#       Logitech G610                                           #
+#       Logitech G810 #1                                        #
+#       Logitech G810 #2                                        #
+#                                                               #
 #  Mice:                                                        #
 #       Logitech G203 Prodigy                                   #
 #       Logitech G203 Lightsync                                 #
@@ -148,27 +166,28 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16be", TAG+="uacces
 #       Logitech G502 Proteus Spectrum                          #
 #       Logitech G Lightspeed Wireless Gaming Mouse             #
 #       Logitech G Pro Wireless Gaming Mouse (Wired)            #
+#                                                               #
+#  Mousemats:                                                   #
 #       Logitech G Powerplay Mousepad with Lightspeed           #
 #                                                               #
-#   Keyboards:                                                  #
-#       Logitech G512                                           #
-#       Logitech G512 RGB                                       #
-#       Logitech G810 #1                                        #
-#       Logitech G810 #2                                        #
 #---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c336", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c342", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33c", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c333", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c331", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c337", TAG+="uaccess"
+
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c084", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c092", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c083", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08f", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c332", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08b", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c539", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c088", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c53a", TAG+="uaccess"
 
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c342", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33c", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c337", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c331", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c53a", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  MSI Mysticlight                                              #
@@ -220,6 +239,11 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="905D", TAG+="uacces
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1770", ATTR{idProduct}=="FF00", TAG+="uaccess"
 
+#---------------------------------------------------------------#
+#  NZXT Hue+                                                    #
+#---------------------------------------------------------------#
+KERNEL=="ttyACM[0-9]*", ATTR{idVendor}=="04D8", ATTR{idProduct}=="00DF", TAG+="uaccess"
+
 #---------------------------------------------------------------#
 #  NZXT Hue 2 Devices                                           #
 #                                                               #
@@ -254,6 +278,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0c45", ATTR{idProduct}=="652f", TAG+="uacces
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="fc30", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="fc39", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="fc4d", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  Gigabyte/Aorus RGB Fusion 2 USB                              #
@@ -261,6 +286,16 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="fc39", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="048d", ATTR{idProduct}=="8297", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="048d", ATTR{idProduct}=="5702", TAG+="uaccess"
 
+#---------------------------------------------------------------#
+#  Sinowealth USB                                               #
+#  Glorious Model O / O-                                        #
+#  Glorious Model D / D-                                        #
+#  Everest GT-100 RGB                                           #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="258a", ATTR{idProduct}=="0036", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="258a", ATTR{idProduct}=="0033", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="258a", ATTR{idProduct}=="0029", TAG+="uaccess"
+
 #---------------------------------------------------------------#
 #  SteelSeries Peripheral Devices                               #
 #                                                               #

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -12,9 +12,10 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle)
+AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const char* path)
 {
-    dev = dev_handle;
+    dev         = dev_handle;
+    location    = path;
 
     strcpy(device_name, "AMD Wraith Prism");
 
@@ -38,11 +39,27 @@ AMDWraithPrismController::~AMDWraithPrismController()
 
 }
 
+std::string AMDWraithPrismController::GetLocationString()
+{
+    return("HID: " + location);
+}
+
 char* AMDWraithPrismController::GetDeviceName()
 {
     return device_name;
 }
 
+std::string AMDWraithPrismController::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);
+}
+
 std::string AMDWraithPrismController::GetEffectChannelString(unsigned char channel)
 {
     std::string ret_string = "";

Controllers/AMDWraithPrismController/AMDWraithPrismController.h

@@ -109,13 +109,15 @@ enum
 class AMDWraithPrismController
 {
 public:
-    AMDWraithPrismController(hid_device* dev_handle);
+    AMDWraithPrismController(hid_device* dev_handle, const char* path);
     ~AMDWraithPrismController();
 
     char* GetDeviceName();
 
     std::string GetEffectChannelString(unsigned char channel);
     std::string GetFirmwareVersionString();
+    std::string GetLocationString();
+    std::string GetSerialString();
 
     void SetRingEffectChannel(unsigned char channel);
 
@@ -131,6 +133,7 @@ public:
 private:
     char                    device_name[32];
     hid_device*             dev;
+    std::string             location;
 
     unsigned char           current_fan_mode;
     unsigned char           current_fan_speed;

Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp

@@ -2,8 +2,8 @@
 #include "AMDWraithPrismController.h"
 #include "RGBController.h"
 #include "RGBController_AMDWraithPrism.h"
-#include <vector>
 #include <hidapi/hidapi.h>
+
 #define AMD_WRAITH_PRISM_VID 0x2516
 #define AMD_WRAITH_PRISM_PID 0x0051
 
@@ -15,40 +15,16 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectAMDWraithPrismControllers(std::vector<RGBController*>& rgb_controllers)
+void DetectAMDWraithPrismControllers(hid_device_info* info, const std::string&)
 {
-    hid_device_info* info;
-    hid_device* dev = NULL;
-
-    hid_init();
-
-    info = hid_enumerate(AMD_WRAITH_PRISM_VID, AMD_WRAITH_PRISM_PID);
-
-    //Look for AMD Wraith Prism
-    while(info)
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
     {
-        if((info->vendor_id == AMD_WRAITH_PRISM_VID)
-         &&(info->product_id == AMD_WRAITH_PRISM_PID)
-#if USE_HID_USAGE
-         &&(info->interface_number == 1)
-         &&(info->usage_page == 0xFF00))
-#else
-         &&(info->interface_number == 1))
-#endif
-        {
-            dev = hid_open_path(info->path);
-        
-            if( dev )
-            {
-                AMDWraithPrismController* controller = new AMDWraithPrismController(dev);
-
-                RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
-
-                rgb_controllers.push_back(rgb_controller);
-            }
-        }
-        info = info->next;
+        AMDWraithPrismController* controller = new AMDWraithPrismController(dev, info->path);
+        RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
 
-REGISTER_DETECTOR("AMD Wraith Prism", DetectAMDWraithPrismControllers);
+REGISTER_HID_DETECTOR_IP("AMD Wraith Prism", DetectAMDWraithPrismControllers, AMD_WRAITH_PRISM_VID, AMD_WRAITH_PRISM_PID, 1, 0xFF00);

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

@@ -14,9 +14,16 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
     wraith = wraith_ptr;
 
     name        = "AMD Wraith Prism";
+    vendor      = "Cooler Master";
     type        = DEVICE_TYPE_COOLER;
     description = "AMD Wraith Prism Device";
     version     = wraith->GetFirmwareVersionString();
+    location    = wraith->GetLocationString();
+    /*-----------------------------------------------------*\
+    | Don't use HID serial string, it is inconsistent on my |
+    | Wraith Prism                                          |
+    \*-----------------------------------------------------*/
+    serial      = "";//wraith->GetSerialString();
 
     mode Direct;
     Direct.name       = "Direct";

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  PolychromeController.cpp                 |
+|  ASRockPolychromeSMBusController.cpp      |
 |                                           |
 |  Driver for for ASRock ASR LED and        |
 |  Polychrome RGB lighting controller       |
@@ -7,8 +7,9 @@
 |  Adam Honse (CalcProgrammer1) 12/14/2019  |
 \*-----------------------------------------*/
 
-#include "PolychromeController.h"
+#include "ASRockPolychromeSMBusController.h"
 #include <cstring>
+#include "dependencies/dmiinfo.h"
 
 using namespace std::chrono_literals;
 
@@ -17,6 +18,8 @@ PolychromeController::PolychromeController(i2c_smbus_interface* bus, polychrome_
     this->bus = bus;
     this->dev = dev;
 
+    DMIInfo dmi;
+
     unsigned short fw_version    = ReadFirmwareVersion();
     unsigned char  major_version = fw_version >> 8;
 
@@ -29,19 +32,19 @@ PolychromeController::PolychromeController(i2c_smbus_interface* bus, polychrome_
     switch(major_version)
     {
         case ASROCK_TYPE_ASRLED:
-            device_name = "ASRock ASR LED";
+            device_name = "ASRock " + dmi.getMainboard();
             asrock_type = ASROCK_TYPE_ASRLED;
             memset(zone_led_count, 0, sizeof(zone_led_count));
             break;
 
         case ASROCK_TYPE_POLYCHROME_V1:
-            device_name = "ASRock Polychrome V1";
+            device_name = "ASRock " + dmi.getMainboard();
             asrock_type = ASROCK_TYPE_POLYCHROME_V1;
             ReadLEDConfiguration();
             break;
 
         case ASROCK_TYPE_POLYCHROME_V2:
-            device_name = "ASRock Polychrome V2";
+            device_name = "ASRock " + dmi.getMainboard();
             asrock_type = ASROCK_TYPE_POLYCHROME_V2;
             ReadLEDConfiguration();
             break;
@@ -69,7 +72,7 @@ std::string PolychromeController::GetDeviceLocation()
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");
     return_string.append(addr);
-    return(return_string);
+    return("I2C: " + return_string);
 }
 
 std::string PolychromeController::GetDeviceName()

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  PolychromeController.h                   |
+|  ASRockPolychromeSMBusController.h        |
 |                                           |
 |  Definitions and types for ASRock         |
 |  ASR LED and Polychrome RGB lighting      |

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusControllerDetect.cpp

@@ -1,22 +1,23 @@
 #include "Detector.h"
-#include "PolychromeController.h"
+#include "ASRockPolychromeSMBusController.h"
 #include "RGBController.h"
-#include "RGBController_Polychrome.h"
+#include "RGBController_ASRockPolychromeSMBus.h"
 #include "i2c_smbus.h"
+#include "pci_ids.h"
 #include <vector>
 #include <stdio.h>
 #include <stdlib.h>
 
 /******************************************************************************************\
 *                                                                                          *
-*   TestForPolychromeController                                                            *
+*   TestForPolychromeSMBusController                                                       *
 *                                                                                          *
 *       Tests the given address to see if an ASRock Polychrome RGB controller exists there.*
 *       First does a quick write to test for a response                                    *
 *                                                                                          *
 \******************************************************************************************/
 
-bool TestForPolychromeController(i2c_smbus_interface* bus, unsigned char address)
+bool TestForPolychromeSMBusController(i2c_smbus_interface* bus, unsigned char address)
 {
     bool pass = false;
 
@@ -35,38 +36,41 @@ bool TestForPolychromeController(i2c_smbus_interface* bus, unsigned char address
 *                                                                                          *
 *   DetectPolychromeControllers                                                            *
 *                                                                                          *
-*       Detect ASRock Polychrome RGB controllers on the enumerated I2C busses at address   *
-*       0x6A.                                                                              *
+*       Detect ASRock Polychrome RGB SMBus controllers on the enumerated I2C busses at     *
+*       address 0x6A.                                                                      *
 *                                                                                          *
 *           bus - pointer to i2c_smbus_interface where Polychrome device is connected      *
 *           dev - I2C address of Polychrome device                                         *
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectPolychromeControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
+void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
 {
     PolychromeController* new_polychrome;
     RGBController_Polychrome* new_controller;
 
     for (unsigned int bus = 0; bus < busses.size(); bus++)
     {
-        // Check for Polychrome controller at 0x6A
-        if (TestForPolychromeController(busses[bus], 0x6A))
+        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            new_polychrome = new PolychromeController(busses[bus], 0x6A);
+            // Check for Polychrome controller at 0x6A
+            if (TestForPolychromeSMBusController(busses[bus], 0x6A))
+            {
+                new_polychrome = new PolychromeController(busses[bus], 0x6A);
 
-            if(new_polychrome->GetASRockType() != ASROCK_TYPE_UNKNOWN)
-            {
-                new_controller = new RGBController_Polychrome(new_polychrome);
-                rgb_controllers.push_back(new_controller);
-            }
-            else
-            {
-                delete new_polychrome;
+                if(new_polychrome->GetASRockType() != ASROCK_TYPE_UNKNOWN)
+                {
+                    new_controller = new RGBController_Polychrome(new_polychrome);
+                    rgb_controllers.push_back(new_controller);
+                }
+                else
+                {
+                    delete new_polychrome;
+                }
             }
         }
     }
 
-}   /* DetectPolychromeControllers() */
+}   /* DetectSMBusPolychromeControllers() */
 
-REGISTER_I2C_DETECTOR("ASRock Polychrome", DetectPolychromeControllers);
+REGISTER_I2C_DETECTOR("ASRock Polychrome SMBus", DetectPolychromeSMBusControllers);

Controllers/ASRockPolychromeSMBusController/RGBController_ASRockPolychromeSMBus.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_Polychrome.cpp             |
+|  RGBController_ASRockPolychromeSMBus.cpp  |
 |                                           |
 |  Generic RGB Interface for OpenRGB        |
 |  ASRock ASR LED and Polychrome RGB Driver |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 12/15/2019  |
 \*-----------------------------------------*/
 
-#include "RGBController_Polychrome.h"
+#include "RGBController_ASRockPolychromeSMBus.h"
 
 #define ASROCK_MAX_ZONES    4
 #define ASROCK_MAX_LEDS     22
@@ -37,15 +37,17 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
     polychrome = polychrome_ptr;
 
     name        = polychrome->GetDeviceName();
+    vendor      = "ASRock";
     version     = polychrome->GetFirmwareVersion();
     type        = DEVICE_TYPE_MOTHERBOARD;
-    description = "ASRock ASR LED/Polychrome Device";
     location    = polychrome->GetDeviceLocation();
 
     switch(polychrome->GetASRockType())
     {
         case ASROCK_TYPE_ASRLED:
             {
+                description = "ASRock ASR LED Device";
+
                 mode Off;
                 Off.name       = "Off";
                 Off.value      = ASRLED_MODE_OFF;
@@ -121,6 +123,8 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
 
         case ASROCK_TYPE_POLYCHROME_V1:
             {
+                description = "ASRock Polychrome v1 Device";
+
                 mode Off;
                 Off.name                    = "Off";
                 Off.value                   = POLYCHROME_V1_MODE_OFF;
@@ -269,6 +273,8 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
 
         case ASROCK_TYPE_POLYCHROME_V2:
             {
+                description = "ASRock Polychrome v2 Device";
+
                 mode Off;
                 Off.name       = "Off";
                 Off.value      = POLYCHROME_V2_MODE_OFF;

Controllers/ASRockPolychromeSMBusController/RGBController_ASRockPolychromeSMBus.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_Polychrome.h               |
+|  RGBController_ASRockPolychromeSMBus.h    |
 |                                           |
 |  Generic RGB Interface for OpenRGB        |
 |  ASRock ASR LED and Polychrome RGB Driver |
@@ -10,7 +10,7 @@
 #pragma once
 
 #include "RGBController.h"
-#include "PolychromeController.h"
+#include "ASRockPolychromeSMBusController.h"
 
 class RGBController_Polychrome : public RGBController
 {

Controllers/AorusCPUCoolerController/AorusCPUCoolerControllerDetect.cpp

@@ -1,87 +0,0 @@
-#include "Detector.h"
-#include "RGBController.h"
-#include "ATC800Controller.h"
-#include "RGBController_AorusATC800.h"
-#include <vector>
-#include <hidapi/hidapi.h>
-
-/*-----------------------------------------------------*\
-| Vendor ID                                             |
-\*-----------------------------------------------------*/
-#define HOLTEK_VID                            0x1044
-
-/*-----------------------------------------------------*\
-| Controller product ids                                |
-\*-----------------------------------------------------*/
-#define ATC_800_CONTROLLER_PID                0x7A42
-
-typedef struct
-{
-    unsigned short  usb_vid;
-    unsigned short  usb_pid;
-    char            usb_interface;
-    device_type     type;
-    const char *    name;
-} device;
-
-#define NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const device device_list[] =
-{
-    { HOLTEK_VID,             ATC_800_CONTROLLER_PID,                  0,  DEVICE_TYPE_KEYBOARD,   "Aorus ATC800 CPU Cooler"                             },
-};
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAorusCPUCoolerControllers                                                        *
-*                                                                                          *
-*       Tests the USB address to see if a Aorus RGB CPU Cooler exists there.               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAorusCPUCoolerControllers(std::vector<RGBController*>& rgb_controllers)
-{
-    hid_init();
-
-    for(unsigned int device_idx = 0; device_idx < NUM_DEVICES; device_idx++)
-    {
-        hid_device_info* info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
-
-        while(info)
-        {
-            if((info->vendor_id == device_list[device_idx].usb_vid)
-            &&(info->product_id == device_list[device_idx].usb_pid)
-#ifdef USE_HID_USAGE                    
-            &&(info->interface_number == device_list[device_idx].usb_interface)
-            &&(info->usage_page == 0xFF01)
-            &&(info->usage == 1))
-#else
-            &&(info->interface_number == device_list[device_idx].usb_interface))
-#endif
-            {
-                hid_device* dev = hid_open_path(info->path);
-
-                if(dev)
-                {
-                    switch(device_list[device_idx].usb_pid)
-                    {
-                    case ATC_800_CONTROLLER_PID:
-                        {
-                            ATC800Controller* controller = new ATC800Controller(dev);
-
-                            RGBController_AorusATC800* rgb_controller = new RGBController_AorusATC800(controller);
-
-                            rgb_controller->name = device_list[device_idx].name;
-                            rgb_controllers.push_back(rgb_controller);
-                        }
-                        break;
-                    }
-                }
-            }
-        info = info->next;
-        }
-        hid_free_enumeration(info);
-    }
-}
-
-REGISTER_DETECTOR("Aorus CPU Coolers", DetectAorusCPUCoolerControllers);

Controllers/AsusAuraCoreController/AsusAuraCoreController.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraCoreController.cpp                   | 
+|  AsusAuraCoreController.cpp               | 
 |                                           |
 |  Driver for ASUS ROG Aura Core RGB        |
 |  lighting controller                      |
@@ -7,12 +7,13 @@
 |  Adam Honse (CalcProgrammer1) 4/13/2020   |
 \*-----------------------------------------*/
 
-#include "AuraCoreController.h"
+#include "AsusAuraCoreController.h"
 #include <cstring>
 
-AuraCoreController::AuraCoreController(hid_device* dev_handle)
+AuraCoreController::AuraCoreController(hid_device* dev_handle, const char* path)
 {
-    dev = dev_handle;
+    dev         = dev_handle;
+    location    = path;
 }
 
 AuraCoreController::~AuraCoreController()
@@ -20,6 +21,22 @@ AuraCoreController::~AuraCoreController()
 
 }
 
+std::string AuraCoreController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AuraCoreController::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 AuraCoreController::SendBrightness
     (
     unsigned char   brightness

Controllers/AsusAuraCoreController/AsusAuraCoreController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraCoreController.h                     |
+|  AsusAuraCoreController.h                 |
 |                                           |
 |  Definitions and types for ASUS ROG Aura  |
 |  Core RGB lighting controller             |
@@ -48,9 +48,12 @@ enum
 class AuraCoreController
 {
 public:
-    AuraCoreController(hid_device* dev_handle);
+    AuraCoreController(hid_device* dev_handle, const char* path);
     ~AuraCoreController();
 
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
     void    SendBrightness
                 (
                 unsigned char   brightness
@@ -72,5 +75,6 @@ public:
 
 private:
     hid_device*             dev;
+    std::string             location;
 
 };

Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp

@@ -0,0 +1,31 @@
+#include "Detector.h"
+#include "AsusAuraCoreController.h"
+#include "RGBController.h"
+#include "RGBController_AsusAuraCore.h"
+#include <hidapi/hidapi.h>
+
+#define AURA_CORE_VID 0x0B05
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAuraCoreControllers                                                              *
+*                                                                                          *
+*       Tests the USB address to see if an Asus ROG Aura Core controller exists there      *
+*                                                                                          *
+\******************************************************************************************/
+
+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);
+        RGBController_AuraCore* rgb_controller = new RGBController_AuraCore(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1854);
+REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1866);
+REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1869);

Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.cpp

@@ -1,20 +1,23 @@
 /*-----------------------------------------*\
-|  RGBController_AuraCore.cpp               |
+|  RGBController_AsusAuraCore.cpp           |
 |                                           |
 |  Generic RGB Interface for ROG Aura Core  |
 |                                           |
 |  Adam Honse (CalcProgrammer1) 4/17/2020   |
 \*-----------------------------------------*/
 
-#include "RGBController_AuraCore.h"
+#include "RGBController_AsusAuraCore.h"
 
 RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* aura_ptr)
 {
     aura = aura_ptr;
 
     name        = "ASUS Aura Core";
+    vendor      = "ASUS";
     type        = DEVICE_TYPE_KEYBOARD;
     description = "ASUS Aura Core Device";
+    location    = aura->GetDeviceLocation();
+    serial      = aura->GetSerialString();
 
     mode Static;
     Static.name       = "Static";

Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AuraCore.h                 |
+|  RGBController_AsusAuraCore.h             |
 |                                           |
 |  Generic RGB Interface for ROG Aura Core  |
 |                                           |
@@ -9,7 +9,7 @@
 #pragma once
 
 #include "RGBController.h"
-#include "AuraCoreController.h"
+#include "AsusAuraCoreController.h"
 
 class RGBController_AuraCore : public RGBController
 {

Controllers/AsusAuraGPUController/AsusAuraGPUController.cpp

@@ -1,12 +1,12 @@
 /*-----------------------------------------*\
-|  AuraGPUController.cpp                    |
+|  AsusAuraGPUController.cpp                |
 |                                           |
 |  Driver for ASUS Aura RGB on GPUs         |
 |                                           |
 |  Jan Rettig (Klapstuhl) 14.02.2020        |
 \*-----------------------------------------*/
 
-#include "AuraGPUController.h"
+#include "AsusAuraGPUController.h"
 #include <cstring>
 
 AuraGPUController::AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id dev)

Controllers/AsusAuraGPUController/AsusAuraGPUController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraGPUController.h                      |
+|  AsusAuraGPUController.h                  |
 |                                           |
 |  Definitions for ASUS Aura RGB on GPUs    |
 |                                           |

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraGPUControllerDetect.cpp              |
+|  AsusAuraGPUControllerDetect.cpp          |
 |                                           |
 |  Driver for ASUS Aura RGB on GPUs         |
 |                                           |
@@ -7,9 +7,9 @@
 \*-----------------------------------------*/
 
 #include "Detector.h"
-#include "AuraGPUController.h"
+#include "AsusAuraGPUController.h"
 #include "RGBController.h"
-#include "RGBController_AuraGPU.h"
+#include "RGBController_AsusAuraGPU.h"
 #include "i2c_smbus.h"
 #include <vector>
 #include <stdio.h>
@@ -38,7 +38,7 @@ static const unsigned char aura_gpu_addresses[] =
 *                                                                                          *
 \******************************************************************************************/
 
-bool TestForAuraGPUController(i2c_smbus_interface* bus, unsigned char address)
+bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char address)
 {
     bool pass = false;
 
@@ -63,7 +63,7 @@ bool TestForAuraGPUController(i2c_smbus_interface* bus, unsigned char address)
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
 {
     AuraGPUController* new_aura_gpu;
     RGBController_AuraGPU* new_controller;
@@ -73,7 +73,7 @@ void DetectAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::ve
         // Add Aura-enabled GPU controllers
         for (unsigned int address_list_idx = 0; address_list_idx < AURA_GPU_ADDRESS_COUNT; address_list_idx++)
         {
-            if (TestForAuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]))
+            if (TestForAsusAuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]))
             {
                 new_aura_gpu = new AuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]);
                 new_controller = new RGBController_AuraGPU(new_aura_gpu);
@@ -85,4 +85,4 @@ void DetectAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::ve
     }
 } /* DetectAuraGPUControllers() */
 
-REGISTER_I2C_DETECTOR("ASUS Aura GPU", DetectAuraGPUControllers);
+REGISTER_I2C_DETECTOR("ASUS Aura GPU", DetectAsusAuraGPUControllers);

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp

@@ -1,12 +1,12 @@
 /*-----------------------------------------*\
-|  RGBController_AuraGPU.h                  |
+|  RGBController_AsusAuraGPU.h              |
 |                                           |
 |  Generic RGB Interface for Asus Aura GPU  |
 |                                           |
 |  Jan Rettig (Klapstuhl) 14.02.2020        |
 \*-----------------------------------------*/
 
-#include "RGBController_AuraGPU.h"
+#include "RGBController_AsusAuraGPU.h"
 
 int RGBController_AuraGPU::GetDeviceMode()
 {
@@ -47,6 +47,7 @@ RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * aura_gpu_ptr)
 
 
     name        = aura_gpu->GetDeviceName();
+    vendor      = "ASUS";
     type        = DEVICE_TYPE_GPU;
     description = "ASUS Aura GPU Device";
     version     = "0.00.1";

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AuraGPU.h                  |
+|  RGBController_AsusAuraGPU.h              |
 |                                           |
 |  Generic RGB Interface for Asus Aura GPU  |
 |                                           |
@@ -9,7 +9,7 @@
 #pragma once
 
 #include "RGBController.h"
-#include "AuraGPUController.h"
+#include "AsusAuraGPUController.h"
 
 class RGBController_AuraGPU : public RGBController
 {

Controllers/AsusAuraSMBusController/AsusAuraSMBusController.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraSMBusController.cpp                  |
+|  AsusAuraSMBusController.cpp              |
 |                                           |
 |  Driver for ASUS Aura RGB lighting        |
 |  controller                               |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 8/19/2018   |
 \*-----------------------------------------*/
 
-#include "AuraSMBusController.h"
+#include "AsusAuraSMBusController.h"
 #include <cstring>
 
 static const char* aura_channels[] =                /* Aura channel strings                 */
@@ -116,7 +116,7 @@ std::string AuraSMBusController::GetDeviceLocation()
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");
     return_string.append(addr);
-    return(return_string);
+    return("I2C: " + return_string);
 }
 
 unsigned char AuraSMBusController::GetChannel(unsigned int led)

Controllers/AsusAuraSMBusController/AsusAuraSMBusController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraSMBusController.h                    |
+|  AsusAuraSMBusController.h                |
 |                                           |
 |  Definitions and types for ASUS Aura RGB  |
 |  lighting controller                      |

Controllers/AsusAuraSMBusController/AsusAuraSMBusControllerDetect.cpp

@@ -1,8 +1,9 @@
 #include "Detector.h"
-#include "AuraSMBusController.h"
+#include "AsusAuraSMBusController.h"
 #include "RGBController.h"
-#include "RGBController_AuraSMBus.h"
+#include "RGBController_AsusAuraSMBus.h"
 #include "i2c_smbus.h"
+#include "pci_ids.h"
 #include <vector>
 #include <stdio.h>
 #include <stdlib.h>
@@ -63,7 +64,7 @@ static const unsigned char aura_mobo_addresses[] =
 *                                                                                          *
 \******************************************************************************************/
 
-void AuraRegisterWrite(i2c_smbus_interface* bus, aura_dev_id dev, aura_register reg, unsigned char val)
+void AsusAuraRegisterWrite(i2c_smbus_interface* bus, aura_dev_id dev, aura_register reg, unsigned char val)
 {
     //Write Aura register
     bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
@@ -82,7 +83,7 @@ void AuraRegisterWrite(i2c_smbus_interface* bus, aura_dev_id dev, aura_register
 *                                                                                          *
 \******************************************************************************************/
 
-bool TestForAuraSMBusController(i2c_smbus_interface* bus, unsigned char address)
+bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char address)
 {
     bool pass = false;
 
@@ -121,7 +122,7 @@ bool TestForAuraSMBusController(i2c_smbus_interface* bus, unsigned char address)
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
 {
     AuraSMBusController* new_aura;
     RGBController_AuraSMBus* new_controller;
@@ -130,64 +131,70 @@ void DetectAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::
     {
         int address_list_idx = -1;
 
-        // Remap Aura-enabled RAM modules on 0x77
-        for (unsigned int slot = 0; slot < 8; slot++)
+        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            int res = busses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
-
-            if (res < 0)
+            // Remap Aura-enabled RAM modules on 0x77
+            for (unsigned int slot = 0; slot < 8; slot++)
             {
-                break;
-            }
+                int res = busses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
 
-            do
-            {
-                address_list_idx++;
-
-                if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
-                {
-                    res = busses[bus]->i2c_smbus_write_quick(aura_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
-                }
-                else
+                if (res < 0)
                 {
                     break;
                 }
-            } while (res >= 0);
 
-            if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
-            {
-                AuraRegisterWrite(busses[bus], 0x77, AURA_REG_SLOT_INDEX, slot);
-                AuraRegisterWrite(busses[bus], 0x77, AURA_REG_I2C_ADDRESS, (aura_ram_addresses[address_list_idx] << 1));
-            }
-        }
+                do
+                {
+                    address_list_idx++;
 
-        // Add Aura-enabled controllers at their remapped addresses
-        for (unsigned int address_list_idx = 0; address_list_idx < AURA_RAM_ADDRESS_COUNT; address_list_idx++)
-        {
-            if (TestForAuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]))
-            {
-                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);
+                    if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
+                    {
+                        res = busses[bus]->i2c_smbus_write_quick(aura_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
+                    }
+                    else
+                    {
+                        break;
+                    }
+                } while (res >= 0);
+
+                if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
+                {
+                    AsusAuraRegisterWrite(busses[bus], 0x77, AURA_REG_SLOT_INDEX, slot);
+                    AsusAuraRegisterWrite(busses[bus], 0x77, AURA_REG_I2C_ADDRESS, (aura_ram_addresses[address_list_idx] << 1));
+                }
             }
 
-            std::this_thread::sleep_for(1ms);
+            // Add Aura-enabled controllers at their remapped addresses
+            for (unsigned int address_list_idx = 0; address_list_idx < AURA_RAM_ADDRESS_COUNT; address_list_idx++)
+            {
+                if (TestForAsusAuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]))
+                {
+                    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);
+                }
+
+                std::this_thread::sleep_for(1ms);
+            }
         }
 
         // Add Aura-enabled motherboard controllers
-        for (unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
+        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            if (TestForAuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
+            for (unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
             {
-                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);
-            }
+                if (TestForAsusAuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
+                {
+                    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);
+                }
 
-            std::this_thread::sleep_for(1ms);
+                std::this_thread::sleep_for(1ms);
+            }
         }
     }
 
 }   /* DetectAuraSMBusControllers() */
 
-REGISTER_I2C_DETECTOR("ASUS Aura SMBus", DetectAuraSMBusControllers);
+REGISTER_I2C_DETECTOR("ASUS Aura SMBus", DetectAsusAuraSMBusControllers);

Controllers/AsusAuraSMBusController/RGBController_AsusAuraSMBus.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AuraSMBus.cpp              |
+|  RGBController_AsusAuraSMBus.cpp          |
 |                                           |
 |  Generic RGB Interface for OpenAuraSDK    |
 |  Asus Aura SMBus driver                   |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 6/13/2019   |
 \*-----------------------------------------*/
 
-#include "RGBController_AuraSMBus.h"
+#include "RGBController_AsusAuraSMBus.h"
 
 int RGBController_AuraSMBus::GetDeviceMode()
 {
@@ -129,6 +129,7 @@ RGBController_AuraSMBus::RGBController_AuraSMBus(AuraSMBusController * aura_ptr)
         type = DEVICE_TYPE_MOTHERBOARD;
         name = "ASUS Aura Motherboard";
     }
+    vendor      = "ASUS";
     description = "ASUS Aura SMBus Device";
 
     mode Direct;

Controllers/AsusAuraSMBusController/RGBController_AsusAuraSMBus.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AuraSMBus.h                |
+|  RGBController_AsusAuraSMBus.h            |
 |                                           |
 |  Generic RGB Interface for OpenAuraSDK    |
 |  Asus Aura SMBus driver                   |
@@ -10,7 +10,7 @@
 #pragma once
 
 #include "RGBController.h"
-#include "AuraSMBusController.h"
+#include "AsusAuraSMBusController.h"
 
 class RGBController_AuraSMBus : public RGBController
 {

Controllers/AsusAuraUSBController/AsusAuraAddressableController.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraAddressableController.cpp            |
+|  AsusAuraAddressableController.cpp        |
 |                                           |
 |  Driver for ASUS Aura RGB Addressable     |
 |  lighting controller                      |
@@ -7,10 +7,10 @@
 |  Adam Honse (CalcProgrammer1) 1/18/2020   |
 \*-----------------------------------------*/
 
-#include "AuraAddressableController.h"
+#include "AsusAuraAddressableController.h"
 #include <cstring>
 
-AuraAddressableController::AuraAddressableController(hid_device* dev_handle) : AuraUSBController(dev_handle)
+AuraAddressableController::AuraAddressableController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
 {
     /*-----------------------------------------------------*\
     | Add addressable devices                               |

Controllers/AsusAuraUSBController/AsusAuraAddressableController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraAddressableController.h              |
+|  AsusAuraAddressableController.h          |
 |                                           |
 |  Definitions and types for ASUS Aura      |
 |  Addressable RGB lighting controller      |
@@ -8,7 +8,7 @@
 \*-----------------------------------------*/
 
 #include "RGBController.h"
-#include "AuraUSBController.h"
+#include "AsusAuraUSBController.h"
 
 #include <string>
 #include <hidapi/hidapi.h>
@@ -23,7 +23,7 @@ enum
 class AuraAddressableController : public AuraUSBController
 {
 public:
-    AuraAddressableController(hid_device* dev_handle);
+    AuraAddressableController(hid_device* dev_handle, const char* path);
     ~AuraAddressableController();
 
     void SetChannelLEDs

Controllers/AsusAuraUSBController/AsusAuraMainboardController.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraMainboardController.cpp              |
+|  AsusAuraMainboardController.cpp          |
 |                                           |
 |  Driver for ASUS Aura RGB USB mainboard   |
 |  lighting controller                      |
@@ -7,10 +7,10 @@
 |  Martin Hartl (inlart) 4/25/2020          |
 \*-----------------------------------------*/
 
-#include "AuraMainboardController.h"
+#include "AsusAuraMainboardController.h"
 #include <cstring>
 
-AuraMainboardController::AuraMainboardController(hid_device* dev_handle) : AuraUSBController(dev_handle), mode(AURA_MODE_DIRECT)
+AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path), mode(AURA_MODE_DIRECT)
 {
     /*-----------------------------------------------------*\
     | Add mainboard device                                  |

Controllers/AsusAuraUSBController/AsusAuraMainboardController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraMainboardController.h                |
+|  AsusAuraMainboardController.h            |
 |                                           |
 |  Definitions and types for ASUS Aura      |
 |  USB Mainboard RGB lighting controller    |
@@ -8,7 +8,7 @@
 \*-----------------------------------------*/
 
 #include "RGBController.h"
-#include "AuraUSBController.h"
+#include "AsusAuraUSBController.h"
 
 #include <string>
 #include <hidapi/hidapi.h>
@@ -25,7 +25,7 @@ enum
 class AuraMainboardController : public AuraUSBController
 {
 public:
-    AuraMainboardController(hid_device* dev_handle);
+    AuraMainboardController(hid_device* dev_handle, const char* path);
     ~AuraMainboardController();
 
     void SetChannelLEDs

Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp

@@ -0,0 +1,75 @@
+/*-----------------------------------------*\
+|  AsusAuraMouseController.cpp              |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 10/23/2020  |
+\*-----------------------------------------*/
+
+#include "AsusAuraMouseController.h"
+
+#include <cstring>
+
+AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+AuraMouseController::~AuraMouseController()
+{
+
+}
+
+std::string AuraMouseController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AuraMouseController::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 AuraMouseController::SendUpdate
+    (
+    unsigned char   zone,
+    unsigned char   mode,
+    unsigned char   red,
+    unsigned char   grn,
+    unsigned char   blu
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x51;
+    usb_buf[0x02]   = 0x28;
+    usb_buf[0x03]   = zone;
+    usb_buf[0x04]   = 0x00;
+    usb_buf[0x05]   = mode;
+    usb_buf[0x06]   = 0x04;
+    usb_buf[0x07]   = red;
+    usb_buf[0x08]   = grn;
+    usb_buf[0x09]   = blu;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+}

Controllers/AsusAuraUSBController/AsusAuraMouseController.h

@@ -0,0 +1,55 @@
+/*-----------------------------------------*\
+|  AsusAuraMouseController.h                |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 10/23/2020  |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    AURA_MOUSE_ZONE_LOGO        = 0,
+    AURA_MOUSE_ZONE_SCROLL      = 1,
+    AURA_MOUSE_ZONE_UNDERGLOW   = 2,
+    AURA_MOUSE_ZONE_ALL         = 3,
+};
+
+enum
+{
+    AURA_MOUSE_MODE_STATIC      = 0,
+    AURA_MOUSE_MODE_BREATHING   = 1,
+    AURA_MOUSE_MODE_COLOR_CYCLE = 2,
+    AURA_MOUSE_MODE_REACTIVE    = 3,
+};
+
+class AuraMouseController
+{
+public:
+    AuraMouseController(hid_device* dev_handle, const char* path);
+    virtual ~AuraMouseController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void SendUpdate
+        (
+        unsigned char   zone,
+        unsigned char   mode,
+        unsigned char   red,
+        unsigned char   grn,
+        unsigned char   blu
+        );
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+};

Controllers/AsusAuraUSBController/AsusAuraUSBController.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraUSBController.cpp                    |
+|  AsusAuraUSBController.cpp                |
 |                                           |
 |  Driver for ASUS Aura RGB USB             |
 |  lighting controller                      |
@@ -7,13 +7,14 @@
 |  Martin Hartl (inlart) 4/25/2020          |
 \*-----------------------------------------*/
 
-#include "AuraUSBController.h"
+#include "AsusAuraUSBController.h"
 #include <cstring>
 #include <stdexcept>
 
-AuraUSBController::AuraUSBController(hid_device* dev_handle)
+AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path)
 {
-    dev = dev_handle;
+    dev         = dev_handle;
+    location    = path;
 
     GetFirmwareVersion();
     GetConfigTable();
@@ -29,11 +30,27 @@ unsigned int AuraUSBController::GetChannelCount()
     return(device_info.size());
 }
 
+std::string AuraUSBController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
 std::string AuraUSBController::GetDeviceName()
 {
     return(device_name);
 }
 
+std::string AuraUSBController::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);
+}
+
 const std::vector<AuraDeviceInfo>& AuraUSBController::GetAuraDevices() const
 {
     return(device_info);

Controllers/AsusAuraUSBController/AsusAuraUSBController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraUSBController.h                      |
+|  AsusAuraUSBController.h                  |
 |                                           |
 |  Definitions and types for ASUS Aura      |
 |  USB RGB lighting controller              |
@@ -59,12 +59,14 @@ struct AuraDeviceInfo
 class AuraUSBController
 {
 public:
-    AuraUSBController(hid_device* dev_handle);
+    AuraUSBController(hid_device* dev_handle, const char* path);
     virtual ~AuraUSBController();
 
     unsigned int GetChannelCount();
 
+    std::string GetDeviceLocation();
     std::string GetDeviceName();
+    std::string GetSerialString();
 
     const std::vector<AuraDeviceInfo>& GetAuraDevices() const;
 
@@ -88,6 +90,7 @@ protected:
     hid_device*                 dev;
     unsigned char               config_table[60];
     std::vector<AuraDeviceInfo> device_info;
+    std::string                 location;
 
     void SendDirect
         (

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -0,0 +1,76 @@
+#include "Detector.h"
+#include "AsusAuraAddressableController.h"
+#include "AsusAuraMainboardController.h"
+#include "AsusAuraMouseController.h"
+#include "RGBController.h"
+#include "RGBController_AsusAuraUSB.h"
+#include "RGBController_AsusAuraMouse.h"
+#include <stdexcept>
+#include <hidapi/hidapi.h>
+
+#define AURA_USB_VID                            0x0B05
+#define AURA_TERMINAL_PID                       0x1889
+#define AURA_ADDRESSABLE_1_PID                  0x1867
+#define AURA_ADDRESSABLE_2_PID                  0x1872
+#define AURA_ADDRESSABLE_3_PID                  0x18A3
+#define AURA_ADDRESSABLE_4_PID                  0x18A5
+#define AURA_MOTHERBOARD_1_PID                  0x18F3
+#define AURA_MOTHERBOARD_2_PID                  0x1939
+#define AURA_ROG_GLADIUS_II_CORE_PID            0x18DD
+#define AURA_ROG_GLADIUS_II_PID                 0x1845
+#define AURA_ROG_GLADIUS_II_ORIGIN_PID          0x1877
+
+void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AuraAddressableController* controller = new AuraAddressableController(dev, info->path);
+        RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        try
+        {
+            AuraMainboardController* controller = new AuraMainboardController(dev, info->path);
+            RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
+            rgb_controller->name = name;
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+        catch(std::runtime_error&)
+        {
+            // reading the config table failed
+        }
+    }
+}
+
+void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        AuraMouseController* controller = new AuraMouseController(dev, info->path);
+        RGBController_AuraMouse* rgb_controller = new RGBController_AuraMouse(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+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);

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp

@@ -0,0 +1,204 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraMouse.cpp          |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 10/25/2020  |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusAuraMouse.h"
+
+RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
+{
+    aura = aura_ptr;
+
+    name        = "ASUS Aura Mouse";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_MOUSE;
+    description = "ASUS Aura Mouse Device";
+    location    = aura->GetDeviceLocation();
+    serial      = aura->GetSerialString();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = AURA_MOUSE_MODE_STATIC;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Breathing;
+    Breathing.name       = "Breathing";
+    Breathing.value      = AURA_MOUSE_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Breathing);
+
+    mode SpectrumCycle;
+    SpectrumCycle.name       = "Spectrum Cycle";
+    SpectrumCycle.value      = AURA_MOUSE_MODE_COLOR_CYCLE;
+    SpectrumCycle.flags      = 0;
+    SpectrumCycle.color_mode = MODE_COLORS_NONE;
+    modes.push_back(SpectrumCycle);
+
+    mode Reactive;
+    Reactive.name       = "Reactive";
+    Reactive.value      = AURA_MOUSE_MODE_REACTIVE;
+    Reactive.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Reactive.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Reactive);
+
+    SetupZones();
+}
+
+RGBController_AuraMouse::~RGBController_AuraMouse()
+{
+
+}
+
+void RGBController_AuraMouse::SetupZones()
+{
+    zone logo_zone;
+
+    logo_zone.name          = "Logo";
+    logo_zone.type          = ZONE_TYPE_SINGLE;
+    logo_zone.leds_min      = 1;
+    logo_zone.leds_max      = 1;
+    logo_zone.leds_count    = 1;
+    logo_zone.matrix_map    = NULL;
+
+    zones.push_back(logo_zone);
+
+    led logo_led;
+
+    logo_led.name           = "Logo";
+
+    leds.push_back(logo_led);
+
+    zone scroll_zone;
+
+    scroll_zone.name        = "Scroll Wheel";
+    scroll_zone.type        = ZONE_TYPE_SINGLE;
+    scroll_zone.leds_min    = 1;
+    scroll_zone.leds_max    = 1;
+    scroll_zone.leds_count  = 1;
+    scroll_zone.matrix_map  = NULL;
+
+    zones.push_back(scroll_zone);
+
+    led scroll_led;
+
+    scroll_led.name         = "Scroll Wheel";
+
+    leds.push_back(scroll_led);
+
+    zone underglow_zone;
+
+    underglow_zone.name       = "Underglow";
+    underglow_zone.type       = ZONE_TYPE_SINGLE;
+    underglow_zone.leds_min   = 1;
+    underglow_zone.leds_max   = 1;
+    underglow_zone.leds_count = 1;
+    underglow_zone.matrix_map = NULL;
+
+    zones.push_back(underglow_zone);
+
+    led underglow_led;
+
+    underglow_led.name        = "Underglow";
+
+    leds.push_back(underglow_led);
+
+    SetupColors();
+}
+
+void RGBController_AuraMouse::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
+void RGBController_AuraMouse::DeviceUpdateLEDs()
+{
+    DeviceUpdateMode();
+}
+
+void RGBController_AuraMouse::UpdateZoneLEDs(int zone)
+{
+    UpdateSingleLED(zone);
+}
+
+void RGBController_AuraMouse::UpdateSingleLED(int led)
+{
+    unsigned char red = 0;
+    unsigned char grn = 0;
+    unsigned char blu = 0;
+
+    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
+    {
+        if(led == 0)
+        {
+            red = RGBGetRValue(colors[led]);
+            grn = RGBGetGValue(colors[led]);
+            blu = RGBGetBValue(colors[led]);
+
+            aura->SendUpdate(AURA_MOUSE_ZONE_LOGO, modes[active_mode].value, red, grn, blu);
+        }
+        else if(led == 1)
+        {
+            red = RGBGetRValue(colors[led]);
+            grn = RGBGetGValue(colors[led]);
+            blu = RGBGetBValue(colors[led]);
+
+            aura->SendUpdate(AURA_MOUSE_ZONE_SCROLL, modes[active_mode].value, red, grn, blu);
+        }
+        else
+        {
+            red = RGBGetRValue(colors[led]);
+            grn = RGBGetGValue(colors[led]);
+            blu = RGBGetBValue(colors[led]);
+
+            aura->SendUpdate(AURA_MOUSE_ZONE_UNDERGLOW, modes[active_mode].value, red, grn, blu);
+        }
+    }
+    else
+    {
+        aura->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu);
+    }
+}
+
+void RGBController_AuraMouse::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_AuraMouse::DeviceUpdateMode()
+{
+    unsigned char red = 0;
+    unsigned char grn = 0;
+    unsigned char blu = 0;
+
+    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
+    {
+        red = RGBGetRValue(colors[0]);
+        grn = RGBGetGValue(colors[0]);
+        blu = RGBGetBValue(colors[0]);
+
+        aura->SendUpdate(AURA_MOUSE_ZONE_LOGO, modes[active_mode].value, red, grn, blu);
+
+        red = RGBGetRValue(colors[1]);
+        grn = RGBGetGValue(colors[1]);
+        blu = RGBGetBValue(colors[1]);
+
+        aura->SendUpdate(AURA_MOUSE_ZONE_SCROLL, modes[active_mode].value, red, grn, blu);
+
+        red = RGBGetRValue(colors[2]);
+        grn = RGBGetGValue(colors[2]);
+        blu = RGBGetBValue(colors[2]);
+
+        aura->SendUpdate(AURA_MOUSE_ZONE_UNDERGLOW, modes[active_mode].value, red, grn, blu);
+    }
+    else
+    {
+        aura->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu);
+    }
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraMouse.h            |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 10/25/2020  |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraMouseController.h"
+
+class RGBController_AuraMouse : public RGBController
+{
+public:
+    RGBController_AuraMouse(AuraMouseController* aura_ptr);
+    ~RGBController_AuraMouse();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    AuraMouseController*  aura;
+};

Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AuraUSB.cpp                |
+|  RGBController_AsusAuraUSB.cpp            |
 |                                           |
 |  Generic RGB Interface for Asus Aura      |
 |  USB controller driver                    |
@@ -7,16 +7,20 @@
 |  Adam Honse (CalcProgrammer1) 1/18/2020   |
 \*-----------------------------------------*/
 
-#include "RGBController_AuraUSB.h"
+#include "RGBController_AsusAuraUSB.h"
 
-RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* aura_ptr)
+RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* aura_ptr) :
+    initializedMode(false)
 {
     aura = aura_ptr;
 
     name        = "ASUS Aura USB";
+    vendor      = "ASUS";
     version     = aura->GetDeviceName();
     type        = DEVICE_TYPE_MOTHERBOARD;
     description = "ASUS Aura USB Device";
+    location    = aura->GetDeviceLocation();
+    serial      = aura->GetSerialString();
 
     mode Direct;
     Direct.name       = "Direct";
@@ -190,6 +194,10 @@ void RGBController_AuraUSB::ResizeZone(int zone, int new_size)
 
 void RGBController_AuraUSB::DeviceUpdateLEDs()
 {
+    if(!initializedMode)
+    {
+        DeviceUpdateMode();
+    }
     for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
         aura->SetChannelLEDs(zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
@@ -198,11 +206,19 @@ void RGBController_AuraUSB::DeviceUpdateLEDs()
 
 void RGBController_AuraUSB::UpdateZoneLEDs(int zone)
 {
+    if(!initializedMode)
+    {
+        DeviceUpdateMode();
+    }
     aura->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count);
 }
 
 void RGBController_AuraUSB::UpdateSingleLED(int led)
 {
+    if(!initializedMode)
+    {
+        DeviceUpdateMode();
+    }
     unsigned int channel = leds[led].value;
 
     aura->SetChannelLEDs(channel, zones[channel].colors, zones[channel].leds_count);
@@ -215,6 +231,7 @@ void RGBController_AuraUSB::SetCustomMode()
 
 void RGBController_AuraUSB::DeviceUpdateMode()
 {
+    initializedMode = true;
     unsigned char red = 0;
     unsigned char grn = 0;
     unsigned char blu = 0;

Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AuraUSB.h                  |
+|  RGBController_AsusAuraUSB.h              |
 |                                           |
 |  Generic RGB Interface for Asus Aura      |
 |  USB controller driver                    |
@@ -9,7 +9,7 @@
 
 #pragma once
 #include "RGBController.h"
-#include "AuraUSBController.h"
+#include "AsusAuraUSBController.h"
 
 #define AURA_ADDRESSABLE_MAX_LEDS       120
 
@@ -31,7 +31,8 @@ public:
     void        DeviceUpdateMode();
 
 private:
-    AuraUSBController*  aura;
+    AuraUSBController*          aura;
     std::vector<unsigned int>   leds_channel;
     std::vector<unsigned int>   zones_channel;
+    bool                        initializedMode;
 };

Controllers/AsusTUFLaptopController/AsusTUFLaptopWMIDetect.cpp

@@ -0,0 +1,48 @@
+#ifdef _WIN32
+
+#include "RGBController_AsusTUFLaptopWMI.h"
+
+#include "acpiwmi.h"
+#include "Detector.h"
+#include "wmi.h"
+#include <string>
+
+static void DetectAsusTUFLaptopWMIControllers(std::vector<RGBController*>&)
+{
+    // Try to retrieve ProductID / Device name from WMI; Possibly can be rewritten to use wmi.cpp
+    // IF you encounter false detection ( e.g. if your laptop keyboard backlight uses USB interface
+    // instead of ACPI WMI) please add a WHITELIST by checking the
+    // `name` variable for model substrings like "FX505DU"
+    // For now, checking for "TUF Gaming" should suffice
+
+    Wmi wmi;
+    wmi.init();
+
+    std::vector<QueryObj> systemProduct;
+    if (wmi.query("SELECT * FROM Win32_ComputerSystemProduct", systemProduct))
+    {
+        return;
+    }
+
+    // There should only be one, a cycle is a precaution
+    if(systemProduct.size() != 1)
+    {
+        return;
+    }
+    std::string& name = systemProduct[0]["Name"];
+    if(name.find("TUF Gaming") == name.npos)
+    {
+        return;
+    }
+
+    if(AsWMI_Open())
+    {
+        RGBController* new_controller = new RGBController_AsusTUFLaptopWMI();
+        ResourceManager::get()->RegisterRGBController(new_controller);
+        // Success! No more if's
+    }
+}   /* DetectFaustusControllers() */
+
+REGISTER_DETECTOR("TUF Laptop WMI", DetectAsusTUFLaptopWMIControllers);
+
+#endif

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopWMI.cpp

@@ -0,0 +1,143 @@
+#ifdef _WIN32
+
+#include "RGBController_AsusTUFLaptopWMI.h"
+
+#include "acpiwmi.h"
+#include "ResourceManager.h"
+#include "Detector.h"
+#include "wmi.h"
+#include <string>
+
+using namespace std::chrono_literals;
+
+RGBController_AsusTUFLaptopWMI::RGBController_AsusTUFLaptopWMI()
+{
+    name        = "ASUS TUF Keyboard";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "WMI Device";
+    location    = "\\\\.\\ATKACPI";
+
+    modes.resize(5);
+    modes[0].name       = "Direct";
+    modes[0].value      = 4;
+    modes[0].flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    modes[0].color_mode = MODE_COLORS_PER_LED;
+
+    modes[1].name       = "Static";
+    modes[1].value      = 0;
+    modes[1].flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    modes[1].color_mode = MODE_COLORS_PER_LED;
+
+    modes[2].name       = "Breathing";
+    modes[2].value      = 1;
+    modes[2].flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    modes[2].speed_min  = 0;
+    modes[2].speed_max  = 2;
+    modes[2].color_mode = MODE_COLORS_PER_LED;
+    modes[2].speed      = 1;
+
+    modes[3].name       = "Color Cycle";
+    modes[3].value      = 2;
+    modes[3].flags      = MODE_FLAG_HAS_SPEED;
+    modes[3].speed_min  = 0;
+    modes[3].speed_max  = 2;
+    modes[3].color_mode = MODE_COLORS_NONE;
+    modes[3].speed      = 1;
+
+    modes[4].name       = "Strobe";
+    modes[4].value      = 0x0A;
+    modes[4].flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    modes[4].color_mode = MODE_COLORS_PER_LED;
+
+    SetupZones();
+}
+
+RGBController_AsusTUFLaptopWMI::~RGBController_AsusTUFLaptopWMI()
+{
+    AsWMI_Close();
+}
+
+void RGBController_AsusTUFLaptopWMI::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Set up zone                                               |
+    \*---------------------------------------------------------*/
+    zones.resize(1);
+    zones[0].type           = ZONE_TYPE_SINGLE;
+    zones[0].name           = "Keyboard Backlight zone";
+    zones[0].leds_min       = 1;
+    zones[0].leds_max       = 1;
+    zones[0].leds_count     = 1;
+    zones[0].matrix_map     = NULL;
+
+    /*---------------------------------------------------------*\
+    | Set up LED                                                |
+    \*---------------------------------------------------------*/
+    leds.resize(1);
+    leds[0].name = "Keyboard Backlight LED";
+
+    SetupColors();
+}
+
+void RGBController_AsusTUFLaptopWMI::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AsusTUFLaptopWMI::DeviceUpdateLEDs()
+{
+    uint8_t red   = RGBGetRValue(colors[0]);
+    uint8_t green = RGBGetGValue(colors[0]);
+    uint8_t blue  = RGBGetBValue(colors[0]);
+    uint8_t speed_byte = 0;
+    uint8_t mode = modes[active_mode].value;
+    uint8_t inv = 0;
+    if(mode == 4)
+    {
+        mode = 1;
+        inv = 4; // Any invalid mode, i.e. anything other than 0, 1, 2 and 10
+    }
+    if(mode == 1 || mode == 2)
+    {
+        switch(modes[active_mode].speed)
+        {
+        case 0: speed_byte = 0xE1; break;
+        case 1: speed_byte = 0xEB; break;
+        case 2: speed_byte = 0xF5; break;
+        }
+    }
+    int high = ((mode | ((red | (green << 8)) << 8)) << 8) | 0xB3;
+    int low = blue | (speed_byte << 8);
+    AsWMI_NB_DeviceControl_2arg(0x100056, high, low);
+    if(inv)
+    {
+        //std::this_thread::sleep_for(10ms);
+        high = ((inv | ((red | (green << 8)) << 8)) << 8) | 0xB3;
+        AsWMI_NB_DeviceControl_2arg(0x100056, high, low);
+    }
+}
+
+void RGBController_AsusTUFLaptopWMI::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AsusTUFLaptopWMI::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AsusTUFLaptopWMI::SetCustomMode()
+{
+    SetMode(0);
+}
+
+void RGBController_AsusTUFLaptopWMI::DeviceUpdateMode()
+{
+    DeviceUpdateLEDs();
+}
+
+#endif

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopWMI.h

@@ -0,0 +1,29 @@
+#ifndef RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
+#define RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
+
+#ifdef _WIN32
+
+#include "RGBController.h"
+
+class RGBController_AsusTUFLaptopWMI : public RGBController
+{
+public:
+    RGBController_AsusTUFLaptopWMI();
+    virtual ~RGBController_AsusTUFLaptopWMI();
+
+    void SetupZones() override;
+
+    void ResizeZone(int zone, int new_size) override;
+
+    void DeviceUpdateLEDs() override;
+    void UpdateZoneLEDs(int zone) override;
+    void UpdateSingleLED(int led) override;
+
+    void DeviceUpdateMode() override;
+
+    void SetCustomMode() override;
+};
+
+#endif
+
+#endif // RGBCONTROLLER_ASUSTUFLAPTOPWMI_H

Controllers/AuraCoreController/AuraCoreControllerDetect.cpp

@@ -1,48 +0,0 @@
-#include "Detector.h"
-#include "AuraCoreController.h"
-#include "RGBController.h"
-#include "RGBController_AuraCore.h"
-#include <vector>
-#include <hidapi/hidapi.h>
-
-#define AURA_CORE_VID 0x0B05
-
-#define NUM_PIDS 3
-static const unsigned short pid_table[] =
-    {
-    0x1854,
-    0x1869,
-    0x1866
-    };
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAuraCoreControllers                                                              *
-*                                                                                          *
-*       Tests the USB address to see if an Asus ROG Aura Core controller exists there      *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAuraCoreControllers(std::vector<RGBController*>& rgb_controllers)
-{
-    hid_device* dev;
-
-    //Look for Asus ROG Aura Core RGB controller
-    hid_init();
-
-    for(int pid_idx = 0; pid_idx < NUM_PIDS; pid_idx++)
-    {
-        dev = hid_open(AURA_CORE_VID, pid_table[pid_idx], 0);
-
-        if( dev )
-        {
-            AuraCoreController* controller = new AuraCoreController(dev);
-
-            RGBController_AuraCore* rgb_controller = new RGBController_AuraCore(controller);
-
-            rgb_controllers.push_back(rgb_controller);
-        }
-    }
-}
-
-REGISTER_DETECTOR("ASUS Aura Core", DetectAuraCoreControllers);

Controllers/AuraUSBController/AuraUSBControllerDetect.cpp

@@ -1,80 +0,0 @@
-#include "Detector.h"
-#include "AuraAddressableController.h"
-#include "AuraMainboardController.h"
-#include "RGBController.h"
-#include "RGBController_AuraUSB.h"
-#include <vector>
-#include <stdexcept>
-#include <hidapi/hidapi.h>
-
-#define AURA_USB_VID 0x0B05
-
-#define NUM_ADDRESSABLE_PIDS 4
-static const unsigned short addressable_pid_table[] =
-    {
-    0x1867,
-    0x1872,
-    0x1889,
-    0x18A3
-    };
-
-#define NUM_MAINBOARD_PIDS 2
-static const unsigned short mainboard_pid_table[] =
-    {
-    0x18f3,
-    0x1939
-    };
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAuraUSBControllers                                                               *
-*                                                                                          *
-*       Tests the USB address to see if an Asus Aura USB RGB header controller             *
-*       exists there.                                                                      *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAuraUSBControllers(std::vector<RGBController*>& rgb_controllers)
-{
-    hid_device* dev;
-
-    //Look for Asus Aura addressable RGB header controller
-    hid_init();
-
-    for(int pid_idx = 0; pid_idx < NUM_ADDRESSABLE_PIDS; pid_idx++)
-    {
-        dev = hid_open(AURA_USB_VID, addressable_pid_table[pid_idx], 0);
-
-        if( dev )
-        {
-            AuraAddressableController* controller = new AuraAddressableController(dev);
-
-            RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
-
-            rgb_controllers.push_back(rgb_controller);
-        }
-    }
-
-    for(int pid_idx = 0; pid_idx < NUM_MAINBOARD_PIDS; pid_idx++)
-    {
-        dev = hid_open(AURA_USB_VID, mainboard_pid_table[pid_idx], 0);
-
-        if( dev )
-        {
-            try
-            {
-                AuraMainboardController* controller = new AuraMainboardController(dev);
-
-                RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
-
-                rgb_controllers.push_back(rgb_controller);
-            }
-            catch(std::runtime_error&)
-            {
-                // reading the config table failed
-            }
-        }
-    }
-}   /* DetectAuraUSBControllers() */
-
-REGISTER_DETECTOR("ASUS Aura USB", DetectAuraUSBControllers);

Controllers/CoolerMasterController/CMARGBcontroller.cpp

@@ -0,0 +1,283 @@
+/*-------------------------------------------------------------------*\
+|  CMARGBController.cpp                                               |
+|                                                                     |
+|  Driver for Coolermaster ARGB USB Controller                        |
+|                                                                     |
+|  Chris M (Dr_No)          10th Oct 2020                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "CMARGBcontroller.h"
+#include <cstring>
+
+static unsigned char argb_colour_index_data[2][2][2] =
+{     //B0    B1
+    { { 0x00, 0x03 },    //G0 R0
+      { 0x02, 0x06 }, }, //G1 R0
+    { { 0x01, 0x05 }, 	 //G0 R1
+      { 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;
+    wchar_t tmpName[szTemp];
+
+    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);
+    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();
+}
+
+CMARGBController::~CMARGBController()
+{
+    hid_close(dev);
+}
+
+void CMARGBController::GetStatus()
+{
+    unsigned char buffer[0x40]          = { 0x00 };
+    int buffer_size                     = (sizeof(buffer) / sizeof(buffer[0]));
+    int header                          = zone_index - 1;
+
+    /*buffer[CM_ARGB_REPORT_BYTE]         = 0x80;
+    buffer[CM_ARGB_COMMAND_BYTE]        = 0x01;
+    buffer[CM_ARGB_FUNCTION_BYTE]       = 0x01;
+    hid_write(dev, buffer, buffer_size);
+
+    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];*/
+}
+
+std::string CMARGBController::GetDeviceName()
+{
+    return device_name;
+}
+
+std::string CMARGBController::GetSerial()
+{
+    return serial;
+}
+
+std::string CMARGBController::GetLocation()
+{
+    return("HID: " + location);
+}
+
+unsigned char CMARGBController::GetZoneIndex()
+{
+    return zone_index;
+}
+
+unsigned char CMARGBController::GetMode()
+{
+    return current_mode;
+}
+
+unsigned char CMARGBController::GetLedRed()
+{
+    return current_red;
+}
+
+unsigned char CMARGBController::GetLedGreen()
+{
+    return current_green;
+}
+
+unsigned char CMARGBController::GetLedBlue()
+{
+    return current_blue;
+}
+
+unsigned char CMARGBController::GetLedSpeed()
+{
+    return current_speed;
+}
+
+unsigned int CMARGBController::GetLargestColour(unsigned int red, unsigned int green, unsigned int blue)
+{
+    unsigned int largest;
+    if ( red > green )
+    {
+        ( red > blue ) ? largest = red : largest = blue;
+    }
+    else
+    {
+        ( green > blue ) ? largest = green : largest = blue;
+    }
+
+    return (largest == 0) ? 1 : largest;
+}
+
+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
+    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)
+{
+    current_mode  = mode;
+    current_speed = speed;
+
+    SendUpdate();
+}
+
+void CMARGBController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    current_red   = red;
+    current_green = green;
+    current_blue  = blue;
+
+    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;
+    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_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
+
+    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_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_ARGB_INTERRUPT_TIMEOUT);
+
+        //reset the write buffer
+        memset(buffer, 0x00, sizeof(buffer) );
+        packet_count++;
+    }
+    buffer[CM_ARGB_REPORT_BYTE]         = 0x82;
+    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;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
+}
+
+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;
+
+    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);
+
+
+    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 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;
+
+        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_SPEED_BYTE + CM_RGB_OFFSET]          = current_speed;
+
+        hid_write(dev, buffer, buffer_size);
+        hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
+    }
+}

Controllers/CoolerMasterController/CMARGBcontroller.h

@@ -0,0 +1,127 @@
+/*-------------------------------------------------------------------*\
+|  CMARGBController.h                                                 |
+|                                                                     |
+|  Driver for Coolermaster ARGB USB Controller                        |
+|                                                                     |
+|  Chris M (Dr_No)          10th Oct 2020                             |
+|                                                                     |
+|  Simple RGB device with 5 modes                                     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include <string>
+#include <array>
+#include <cmath>            //Needed by round()
+#include <hidapi/hidapi.h>
+#include "RGBController.h"  //Needed to set the direct mode
+
+#pragma once
+
+#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_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
+#define CM_RGB_OFFSET -2
+#define HID_MAX_STR 255
+
+enum
+{
+    CM_ARGB_REPORT_BYTE         = 1,
+    CM_ARGB_COMMAND_BYTE        = 2,
+    CM_ARGB_FUNCTION_BYTE       = 3,
+    CM_ARGB_ZONE_BYTE           = 4,
+    CM_ARGB_MODE_BYTE           = 5,
+    CM_ARGB_COLOUR_INDEX_BYTE	= 6,
+    CM_ARGB_SPEED_BYTE          = 7
+};
+
+struct argb_headers
+{
+    const char*     name;
+    unsigned char   header;
+    bool            digital;
+    unsigned int    count;
+};
+
+static argb_headers argb_header_data[6] =
+{
+    { "RGB Header",         0xFF, false,  1 },
+    { "Digital ARGB1",      0x01, true,  12 },
+    { "Digital ARGB2",      0x02, true,  12 },
+    { "Digital ARGB3",      0x04, true,  12 },
+    { "Digital ARGB4",      0x08, true,  12 },
+    { "All Digital ARGB",   0xFF, true,  12 }
+};
+
+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
+};
+
+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_DIRECT         = 0xFE, //Direct Led Control
+    CM_ARGB_MODE_PASSTHRU       = 0xFF  //Motherboard Pass Thru Mode
+};
+
+enum
+{
+    CM_ARGB_SPEED_SLOWEST       = 0x00, // Slowest speed
+    CM_ARGB_SPEED_SLOW          = 0x01, // Slower speed
+    CM_ARGB_SPEED_NORMAL        = 0x02, // Normal speed
+    CM_ARGB_SPEED_FAST          = 0x03, // Fast speed
+    CM_ARGB_SPEED_FASTEST       = 0x04, // Fastest speed
+};
+
+class CMARGBController
+{
+public:
+    CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx);
+    ~CMARGBController();
+
+    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();
+    void SetMode(unsigned char mode, unsigned char speed);
+    void SetColor(unsigned char red, unsigned char green, unsigned char blue);
+    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 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

@@ -27,20 +27,25 @@ static unsigned char speed_mode_data[][9] =
     { 0xFF, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00 } /* Colour Breath                */
 };
 
-CMMP750Controller::CMMP750Controller(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path)
+CMMP750Controller::CMMP750Controller(hid_device* dev_handle, char *_path)
 {
-    std::size_t tmp_size    = wcslen(_vendor);
-    dev                     = dev_handle;
-    location                = _path;
+    dev             = dev_handle;
+    location        = _path;
 
-    for(std::size_t i = 0; (i < tmp_size) && (i < CM_DEVICE_NAME_SIZE); i++)
-    {
-        device_name[i] = (char)_vendor[i];
-    }
-    for(std::size_t j = 0; (j < wcslen(_vendor)) && (tmp_size + j < CM_DEVICE_NAME_SIZE); j++)
-    {
-        device_name[tmp_size + j] = (char)_device_name[j];
-    }
+    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
 }
@@ -82,19 +87,19 @@ void CMMP750Controller::GetStatus()
     }
 }
 
-char* CMMP750Controller::GetDeviceName()
+std::string CMMP750Controller::GetDeviceName()
 {
     return device_name;
 }
 
-char* CMMP750Controller::GetSerial()
+std::string CMMP750Controller::GetSerial()
 {
     return serial;
 }
 
 std::string CMMP750Controller::GetLocation()
 {
-    return location;
+    return("HID: " + location);
 }
 
 unsigned char CMMP750Controller::GetMode()

Controllers/CoolerMasterController/CMMP750Controller.h

@@ -60,11 +60,11 @@ enum
 class CMMP750Controller
 {
 public:
-    CMMP750Controller(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path);
+    CMMP750Controller(hid_device* dev_handle, char *_path);
     ~CMMP750Controller();
 
-    char* GetDeviceName();
-    char* GetSerial();
+    std::string GetDeviceName();
+    std::string GetSerial();
     std::string GetLocation();
 
     unsigned char GetMode();
@@ -76,8 +76,8 @@ public:
     void SetColor(unsigned char red, unsigned char green, unsigned char blue);
 
 private:
-    char                    device_name[32];
-    char                    serial[32];
+    std::string             device_name;
+    std::string             serial;
     std::string             location;
     hid_device*             dev;
 

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -1,27 +1,16 @@
 #include "Detector.h"
 #include "CMMP750Controller.h"
+#include "CMARGBcontroller.h"
 #include "RGBController.h"
 #include "RGBController_CMMP750Controller.h"
+#include "RGBController_CMARGBController.h"
 #include <hidapi/hidapi.h>
 
 #define COOLERMASTER_VID                0x2516
 
 #define COOLERMASTER_MP750_XL_PID       0x0109
 #define COOLERMASTER_MP750_MEDIUM_PID   0x0105
-
-#define COOLERMASTER_NUM_DEVICES (sizeof(cm_pids) / sizeof(cm_pids[ 0 ]))
-
-enum
-{
-    CM_PID = 0,
-    CM_INTERFACE = 1
-};
-
-static const unsigned int cm_pids[][4] =
-{  // PID,      Interface
-    { COOLERMASTER_MP750_XL_PID,        0x00 },     //Coolermaster MP750 (Extra Large)
-    { COOLERMASTER_MP750_MEDIUM_PID,    0x00 }      //Coolermaster MP750 (Medium)
-};
+#define COOLERMASTER_ARGB_PID           0x1011
 
 /******************************************************************************************\
 *                                                                                          *
@@ -31,39 +20,33 @@ static const unsigned int cm_pids[][4] =
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectCoolerMasterControllers(std::vector<RGBController*>& rgb_controllers)
+void DetectCoolerMasterMousemats(hid_device_info* info, const std::string&)
 {
-    hid_device_info* info;
-
-    //Look for the passed in cm_pids
-    hid_init();
-    info = hid_enumerate(COOLERMASTER_VID, 0x0);
-
-    while(info)
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
     {
-        hid_device* dev = NULL;
-        if(info->vendor_id == COOLERMASTER_VID)
-        {
-            for(unsigned int cm_pid_idx = 0; cm_pid_idx < COOLERMASTER_NUM_DEVICES; cm_pid_idx++)
-            {
-                if((info->product_id        == cm_pids[cm_pid_idx][CM_PID])
-                 &&(info->interface_number  == cm_pids[cm_pid_idx][CM_INTERFACE]))
-                {
-                    dev = hid_open_path(info->path);
-                    break;
-                }
-            }
-        }
-
-        if(dev)
-        {
-            CMMP750Controller* controller                   = new CMMP750Controller(dev, info->manufacturer_string, info->product_string, info->path);
-            RGBController_CMMP750Controller* rgb_controller = new RGBController_CMMP750Controller(controller);
-            rgb_controllers.push_back(rgb_controller);
-        }
-        info = info->next;
+        CMMP750Controller* controller                   = new CMMP750Controller(dev, info->path);
+        RGBController_CMMP750Controller* rgb_controller = new RGBController_CMMP750Controller(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-    hid_free_enumeration(info);
-}   /* DetectCoolerMasterControllers() */
+}
 
-REGISTER_DETECTOR("Cooler Master", DetectCoolerMasterControllers);
+void DetectCoolerMasterARGB(hid_device_info* info, const std::string&)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        for(std::size_t i = 0; i < CM_ARGB_HEADER_DATA_SIZE; i++)
+        {
+            CMARGBController* controller = new CMARGBController(dev, info->path, i);
+            RGBController_CMARGBController* rgb_controller = new RGBController_CMARGBController(controller);
+            // Constructor sets the name
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+    }
+}
+
+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);

Controllers/CoolerMasterController/RGBController_CMARGBController.cpp

@@ -0,0 +1,315 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMARGBController.cpp                                 |
+|                                                                     |
+|  Driver for Coolermaster ARGB Controller                            |
+|                                                                     |
+|  Chris M (Dr_No)          14th Oct 2020                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "RGBController_CMARGBController.h"
+
+RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController *cmargb_ptr)
+{
+    cmargb                  = cmargb_ptr;
+    unsigned char speed     = cmargb->GetLedSpeed();
+
+    name                    = 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();
+
+    if ( argb_header_data[cmargb->GetZoneIndex()].digital)
+    {
+        mode Off;
+        Off.name                = "Turn Off";
+        Off.value               = CM_ARGB_MODE_OFF;
+        Off.color_mode          = MODE_COLORS_NONE;
+        modes.push_back(Off);
+
+        mode Reload;
+        Reload.name             = "Reload";
+        Reload.value            = CM_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_ARGB_SPEED_SLOWEST;
+        Reload.speed_max        = CM_ARGB_SPEED_FASTEST;
+        Reload.color_mode       = MODE_COLORS_RANDOM;
+        Reload.speed            = speed;
+        modes.push_back(Reload);
+
+        mode Recoil;
+        Recoil.name             = "Recoil";
+        Recoil.value            = CM_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(Reload.colors_max);
+        Recoil.speed_min        = CM_ARGB_SPEED_SLOWEST;
+        Recoil.speed_max        = CM_ARGB_SPEED_FASTEST;
+        Recoil.color_mode       = MODE_COLORS_RANDOM;
+        Recoil.speed            = speed;
+        modes.push_back(Recoil);
+
+        mode Breathing;
+        Breathing.name          = "Breathing";
+        Breathing.value         = CM_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(Reload.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);
+
+        mode Refill;
+        Refill.name             = "Refill";
+        Refill.value            = CM_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(Reload.colors_max);
+        Refill.speed_min        = CM_ARGB_SPEED_SLOWEST;
+        Refill.speed_max        = CM_ARGB_SPEED_FASTEST;
+        Refill.color_mode       = MODE_COLORS_RANDOM;
+        Refill.speed            = speed;
+        modes.push_back(Refill);
+
+        mode Demo;
+        Demo.name               = "Demo";
+        Demo.value              = CM_ARGB_MODE_DEMO;
+        Demo.flags              = MODE_FLAG_HAS_SPEED;
+        Demo.speed_min          = CM_ARGB_SPEED_SLOWEST;
+        Demo.speed_max          = CM_ARGB_SPEED_FASTEST;
+        Demo.color_mode         = MODE_COLORS_NONE;
+        Demo.speed              = speed;
+        modes.push_back(Demo);
+
+        mode Spectrum;
+        Spectrum.name           = "Spectrum";
+        Spectrum.value          = CM_ARGB_MODE_SPECTRUM;
+        Spectrum.flags          = MODE_FLAG_HAS_SPEED;
+        Spectrum.speed_min      = CM_ARGB_SPEED_SLOWEST;
+        Spectrum.speed_max      = CM_ARGB_SPEED_FASTEST;
+        Spectrum.color_mode     = MODE_COLORS_NONE;
+        Spectrum.speed          = speed;
+        modes.push_back(Spectrum);
+
+        mode FillFlow;
+        FillFlow.name           = "Fill Flow";
+        FillFlow.value          = CM_ARGB_MODE_FILLFLOW;
+        FillFlow.flags          = MODE_FLAG_HAS_SPEED;
+        FillFlow.speed_min      = CM_ARGB_SPEED_SLOWEST;
+        FillFlow.speed_max      = CM_ARGB_SPEED_FASTEST;
+        FillFlow.color_mode     = MODE_COLORS_NONE;
+        FillFlow.speed          = speed;
+        modes.push_back(FillFlow);
+
+        mode Rainbow;
+        Rainbow.name            = "Rainbow";
+        Rainbow.value           = CM_ARGB_MODE_RAINBOW;
+        Rainbow.flags           = MODE_FLAG_HAS_SPEED;
+        Rainbow.speed_min       = CM_ARGB_SPEED_SLOWEST;
+        Rainbow.speed_max       = CM_ARGB_SPEED_FASTEST;
+        Rainbow.color_mode      = MODE_COLORS_NONE;
+        Rainbow.speed           = speed;
+        modes.push_back(Rainbow);
+
+        mode Direct;
+        Direct.name             = "Direct";
+        Direct.value            = CM_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_ARGB_MODE_PASSTHRU;
+        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 Breathing;
+        Breathing.name          = "Breathing";
+        Breathing.value         = CM_RGB_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_ARGB_SPEED_SLOWEST;
+        Breathing.speed_max     = CM_ARGB_SPEED_FASTEST;
+        Breathing.color_mode    = MODE_COLORS_RANDOM;
+        Breathing.speed         = speed;
+        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);
+
+        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 PassThru;
+        PassThru.name           = "Pass Thru";
+        PassThru.value          = CM_RGB_MODE_PASSTHRU;
+        PassThru.color_mode     = MODE_COLORS_NONE;
+        modes.push_back(PassThru);
+    }
+
+    Init_Controller();         //Only processed on first run
+    SetupZones();
+    //active_mode = cmargb->GetMode();
+}
+
+RGBController_CMARGBController::~RGBController_CMARGBController()
+{
+
+}
+
+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
+
+    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_count    = zone_led_count;
+    ARGB_zone.matrix_map    = NULL;
+    zones.push_back(ARGB_zone);
+}
+
+void RGBController_CMARGBController::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
+
+        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 = argb_header_data[i].header;
+            }
+            else
+            {
+                new_led.name = i;
+                new_led.name.append(" LED " + std::to_string(lp_idx));
+                new_led.value = argb_header_data[i].header;
+            }
+
+            leds.push_back(new_led);
+        }
+    }
+
+    SetupColors();
+}
+
+void RGBController_CMARGBController::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_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);*/
+
+    //this one
+    cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed );
+    cmargb->SetLedsDirect( zones[0].colors, zones[0].leds_count );
+}
+
+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);
+}
+
+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 );
+}
+
+void RGBController_CMARGBController::SetCustomMode()
+{
+    active_mode = CM_ARGB_MODE_DIRECT;
+}
+
+void RGBController_CMARGBController::DeviceUpdateMode()
+{
+    if( modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC )
+    {
+        unsigned char red = RGBGetRValue(modes[active_mode].colors[0]);
+        unsigned char grn = RGBGetGValue(modes[active_mode].colors[0]);
+        unsigned char blu = RGBGetBValue(modes[active_mode].colors[0]);
+        cmargb->SetColor(red, grn, blu);
+    }
+    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 );
+}

Controllers/CoolerMasterController/RGBController_CMARGBController.h

@@ -0,0 +1,35 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMARGBController.h                                   |
+|                                                                     |
+|  Driver for Coolermaster ARGB Controller                            |
+|                                                                     |
+|  Chris M (Dr_No)          14th Oct 2020                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "CMARGBcontroller.h"
+#include <vector>
+
+class RGBController_CMARGBController : public RGBController
+{
+public:
+    RGBController_CMARGBController(CMARGBController* cmargb_ptr);
+    ~RGBController_CMARGBController();
+
+    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();
+
+    CMARGBController* cmargb;
+};

Controllers/CoolerMasterController/RGBController_CMMP750Controller.cpp

@@ -15,10 +15,11 @@ RGBController_CMMP750Controller::RGBController_CMMP750Controller(CMMP750Controll
     unsigned char speed = cmmp750->GetLedSpeed();
 
     name                = cmmp750->GetDeviceName();
+    vendor              = "Cooler Master";
     type                = DEVICE_TYPE_MOUSEMAT;
     description         = cmmp750->GetDeviceName();
     version             = "1.0";
-    serial              = "";
+    serial              = cmmp750->GetSerial();
     location            = cmmp750->GetLocation();
 
     mode Static;
@@ -143,25 +144,5 @@ void RGBController_CMMP750Controller::SetCustomMode()
 
 void RGBController_CMMP750Controller::DeviceUpdateMode()
 {
-    switch(modes[active_mode].value)
-    {
-        case MP750_MODE_STATIC:
-            cmmp750->SetMode(MP750_MODE_STATIC, modes[active_mode].speed);
-            break;
-        case MP750_MODE_BLINK:
-            cmmp750->SetMode(MP750_MODE_BLINK, modes[active_mode].speed);
-            break;
-        case MP750_MODE_BREATHING:
-            cmmp750->SetMode(MP750_MODE_BREATHING, modes[active_mode].speed);
-            break;
-        case MP750_MODE_COLOR_CYCLE:
-            cmmp750->SetMode(MP750_MODE_COLOR_CYCLE, modes[active_mode].speed);
-            break;
-        case MP750_MODE_BREATH_CYCLE:
-            cmmp750->SetMode(MP750_MODE_BREATH_CYCLE, modes[active_mode].speed);
-            break;
-        default:
-            cmmp750->SetMode(MP750_MODE_BREATHING, modes[active_mode].speed);
-            break;
-    }
+    cmmp750->SetMode(modes[active_mode].value, modes[active_mode].speed);
 }

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumController.cpp

@@ -0,0 +1,126 @@
+/*------------------------------------------*\
+|  CorsairDominatorPlatinumController.cpp    |  
+|                                            |
+|  Drover for Corsair Domintator Platinum    |
+|  RGB RAM lighting controller               |
+|                                            |
+|  Erik Gilling (konkers)       9/25/2020    |
+\*------------------------------------------*/
+
+#include "CorsairDominatorPlatinumController.h"
+
+#include <cstring>
+
+using namespace std::chrono_literals;
+
+CorsairDominatorPlatinumController::CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+
+    led_data[0] = 0xc;
+}
+
+CorsairDominatorPlatinumController::~CorsairDominatorPlatinumController()
+{
+
+}
+
+std::string CorsairDominatorPlatinumController::GetDeviceName()
+{
+    return "Corsair Dominator Platinum RGB";
+}
+
+std::string CorsairDominatorPlatinumController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+void CorsairDominatorPlatinumController::SetAllColors
+    (
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    for(unsigned int led = 0; led < CORSAIR_PLAT_LED_COUNT; led++)
+    {
+        SetLEDColor(led, red, green, blue);
+    }
+}
+
+void CorsairDominatorPlatinumController::SetLEDColor
+    (
+    unsigned int    led,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    if(led >= CORSAIR_PLAT_LED_COUNT)
+    {
+        return;
+    }
+
+    unsigned int offset     = (led * 3) + 1;
+    led_data[offset]        = red;
+    led_data[offset + 1]    = green;
+    led_data[offset + 2]    = blue;
+}
+
+unsigned char CorsairDominatorPlatinumController::crc8
+    (
+    unsigned char   init,
+    unsigned char   poly,
+    unsigned char*  data,
+    unsigned char   len
+    )
+{
+    unsigned char crc = init;
+
+    for(unsigned int i = 0; i < len; i++)
+    {
+        unsigned char val = data[i];
+        for(unsigned char mask = 0x80; mask != 0; mask >>= 1)
+        {
+            unsigned char bit;
+            if ((val & mask) != 0)
+            {
+                bit = (crc & 0x80) ^ 0x80;
+            }
+            else
+            {
+                bit = crc & 0x80;
+            }
+
+            if (bit == 0)
+            {
+                crc <<= 1;
+            }
+            else
+            {
+                crc = (crc << 1) ^ poly;
+            }
+        }
+    }
+
+    return crc;
+}
+
+void CorsairDominatorPlatinumController::ApplyColors()
+{
+    unsigned char data[sizeof(led_data)];
+    memcpy(data, led_data, sizeof(led_data));
+    unsigned char crc = crc8(0x0, 0x7, data, sizeof(data) - 1);
+    data[sizeof(data) - 1] = crc;
+
+    bus->i2c_smbus_write_block_data(dev, 0x31, 0x20, data);
+    std::this_thread::sleep_for(800us);
+    bus->i2c_smbus_write_block_data(dev, 0x32, sizeof(data) - 0x20, data + 0x20);
+    std::this_thread::sleep_for(200us);
+}

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumController.h

@@ -0,0 +1,42 @@
+/*-----------------------------------------*\
+|  CorsairDominatorPlatinumController.h     |
+|                                           |
+|  Definitions and types for Corsair        |
+|  Domintator Platinum RGB RAM lighting     |
+|   controller                              |
+|                                           |
+|  Erik Gilling (konkers)       9/25/2020   |
+\*-----------------------------------------*/
+
+#include <string>
+#include "i2c_smbus.h"
+
+#pragma once
+
+typedef unsigned char corsair_dev_id;
+
+class CorsairDominatorPlatinumController
+{
+public:
+    CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev);
+    ~CorsairDominatorPlatinumController();
+
+    std::string GetDeviceName();
+    std::string GetDeviceLocation();
+
+    size_t GetLEDCount() { return CORSAIR_PLAT_LED_COUNT; }
+    void SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
+    void SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
+    void ApplyColors();
+    bool WaitReady();
+
+private:
+    static constexpr size_t CORSAIR_PLAT_LED_COUNT = 12;
+
+    unsigned char led_data[CORSAIR_PLAT_LED_COUNT * 3 + 2];
+
+    i2c_smbus_interface*    bus;
+    corsair_dev_id          dev;
+
+    static unsigned char crc8(unsigned char init, unsigned char poly, unsigned char *data, unsigned char len);
+};

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumControllerDetect.cpp

@@ -0,0 +1,70 @@
+#include "Detector.h"
+#include "CorsairDominatorPlatinumController.h"
+#include "RGBController.h"
+#include "RGBController_CorsairDominatorPlatinum.h"
+#include "i2c_smbus.h"
+#include "pci_ids.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace std::chrono_literals;
+
+bool TestForCorsairDominatorPlatinumController(i2c_smbus_interface *bus, unsigned char address)
+{
+
+    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
+    if(res < 0)
+    {
+        return false;
+    }
+
+    res = bus->i2c_smbus_read_byte_data(address, 0x43);
+
+    if(res != 0x1b)
+    {
+        return false;
+    }
+
+    res = bus->i2c_smbus_read_byte_data(address, 0x44);
+
+    if(res != 0x04)
+    {
+        return false;
+    }
+
+    return true;
+}
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectCorsairDominatorPlatinumControllers                                              *
+*                                                                                          *
+*       Detect Corsair Dominator Platinum controllers on the enumerated I2C busses.        *
+*                                                                                          *
+*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
+*           dev - I2C address of Aura device                                               *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *> &busses, std::vector<RGBController *> &rgb_controllers)
+{
+    for(unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        {
+            for(unsigned char addr = 0x58; addr <= 0x5f; addr++)
+            {
+                if(TestForCorsairDominatorPlatinumController(busses[bus], addr))
+                {
+                    CorsairDominatorPlatinumController* new_controller        = new CorsairDominatorPlatinumController(busses[bus], addr);
+                    RGBController_CorsairDominatorPlatinum* new_rgbcontroller = new RGBController_CorsairDominatorPlatinum(new_controller);
+                    rgb_controllers.push_back(new_rgbcontroller);
+                }
+                std::this_thread::sleep_for(10ms);
+            }
+        }
+    }
+}
+
+REGISTER_I2C_DETECTOR("Corsair Dominator Platinum", DetectCorsairDominatorPlatinumControllers);

Controllers/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.cpp

@@ -0,0 +1,109 @@
+/*-------------------------------------------------*\
+|  RGBController_CorsairDominatorPlatinum.cpp       |
+|                                                   |
+|  Corsair Vengeance Pro RGB driver                 |
+|                                                   |
+|  Erik Gilling (konkers)       9/25/2020           |
+\*-------------------------------------------------*/
+
+#include "RGBController_CorsairDominatorPlatinum.h"
+
+RGBController_CorsairDominatorPlatinum::RGBController_CorsairDominatorPlatinum(CorsairDominatorPlatinumController* corsair_ptr)
+{
+    corsair = corsair_ptr;
+
+    name        = corsair->GetDeviceName();
+    vendor      = "Corsair";
+    type        = DEVICE_TYPE_DRAM;
+    description = "Corsair Dominator Platinum RGB Device";
+    location    = corsair->GetDeviceLocation();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.speed_min  = 0;
+    Direct.speed_max  = 0;
+    Direct.speed      = 0;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+
+    active_mode = 0;
+}
+
+void RGBController_CorsairDominatorPlatinum::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Set up zone                                               |
+    \*---------------------------------------------------------*/
+    zone new_zone;
+    new_zone.name       = "Corsair Platinum Zone";
+    new_zone.type       = ZONE_TYPE_LINEAR;
+    new_zone.leds_min   = corsair->GetLEDCount();
+    new_zone.leds_max   = corsair->GetLEDCount();
+    new_zone.leds_count = corsair->GetLEDCount();
+    new_zone.matrix_map = NULL;
+    zones.push_back(new_zone);
+
+    /*---------------------------------------------------------*\
+    | Set up LEDs                                               |
+    \*---------------------------------------------------------*/
+    for(std::size_t led_idx = 0; led_idx < zones[0].leds_count; led_idx++)
+    {
+        led *new_led  = new led();
+        new_led->name = "Corsair Platinum LED ";
+        new_led->name.append(std::to_string(led_idx));
+        leds.push_back(*new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_CorsairDominatorPlatinum::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_CorsairDominatorPlatinum::DeviceUpdateLEDs()
+{
+    for(std::size_t led = 0; led < colors.size(); led++)
+    {
+        RGBColor color    = colors[led];
+        unsigned char red = RGBGetRValue(color);
+        unsigned char grn = RGBGetGValue(color);
+        unsigned char blu = RGBGetBValue(color);
+        corsair->SetLEDColor(led, red, grn, blu);
+    }
+
+    corsair->ApplyColors();
+}
+
+void RGBController_CorsairDominatorPlatinum::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CorsairDominatorPlatinum::UpdateSingleLED(int led)
+{
+    RGBColor color    = colors[led];
+    unsigned char red = RGBGetRValue(color);
+    unsigned char grn = RGBGetGValue(color);
+    unsigned char blu = RGBGetBValue(color);
+
+    corsair->SetLEDColor(led, red, grn, blu);
+    corsair->ApplyColors();
+}
+
+void RGBController_CorsairDominatorPlatinum::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_CorsairDominatorPlatinum::DeviceUpdateMode()
+{
+
+}

Controllers/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.h

@@ -0,0 +1,32 @@
+/*--------------------------------------------*\
+|  RGBController_CorsairDominatorPlatinum.h    |
+|                                              |
+|  Corsair Dominator Platinum RGB driver       |
+|                                              |
+|  Erik Gilling (konkers)       9/25/2020      |
+\*--------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "CorsairDominatorPlatinumController.h"
+
+class RGBController_CorsairDominatorPlatinum : public RGBController
+{
+public:
+    RGBController_CorsairDominatorPlatinum(CorsairDominatorPlatinumController* 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:
+    CorsairDominatorPlatinumController* corsair;
+};

Controllers/CorsairHydroController/CorsairHydroController.cpp

@@ -7,10 +7,22 @@
 #include "CorsairHydroController.h"
 
 #include <cstring>
+#include <iomanip>
+#include <sstream>
 
 CorsairHydroController::CorsairHydroController(libusb_device_handle* dev_handle)
 {
-    dev = dev_handle;
+    dev         = dev_handle;
+
+    /*-----------------------------------------------------*\
+    | Fill in location string with USB ID                   |
+    \*-----------------------------------------------------*/
+    libusb_device_descriptor descriptor;
+    libusb_get_device_descriptor(libusb_get_device(dev_handle), &descriptor);
+
+    std::stringstream location_stream;
+    location_stream << std::hex << std::setfill('0') << std::setw(4) << descriptor.idVendor << ":" << std::hex << std::setfill('0') << std::setw(4) << descriptor.idProduct;
+    location = location_stream.str();
 
     SendInit();
 
@@ -22,6 +34,11 @@ std::string CorsairHydroController::GetFirmwareString()
     return(firmware_version);
 }
 
+std::string CorsairHydroController::GetLocation()
+{
+    return("USB: " + location);
+}
+
 void CorsairHydroController::SetBlink
     (
         std::vector<RGBColor> & colors,
@@ -248,4 +265,4 @@ void CorsairHydroController::SendSpeed
     \*-----------------------------------------------------*/
     libusb_bulk_transfer(dev, 0x01, usb_buf, 2, &actual, 1000);
     libusb_bulk_transfer(dev, 0x81, usb_buf, 3, &actual, 1000);
-}
+}

Controllers/CorsairHydroController/CorsairHydroController.h

@@ -39,6 +39,8 @@ public:
 
     std::string     GetFirmwareString();
 
+    std::string     GetLocation();
+
     void            SetBlink
                         (
                             std::vector<RGBColor> & colors,
@@ -65,6 +67,7 @@ public:
 private:
     libusb_device_handle*   dev;
     std::string             firmware_version;
+    std::string             location;
 
     void            SendApplyBlink();
     void            SendApplyPulse();

Controllers/CorsairHydroController/CorsairHydroControllerDetect.cpp

@@ -50,6 +50,10 @@ void DetectCorsairHydroControllers(std::vector<RGBController*>& rgb_controllers)
     libusb_context * ctx;
     libusb_init(&ctx);
 
+    #ifdef _WIN32
+    libusb_set_option(ctx, 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);

Controllers/CorsairHydroController/RGBController_CorsairHydro.cpp

@@ -13,9 +13,11 @@ RGBController_CorsairHydro::RGBController_CorsairHydro(CorsairHydroController* c
 {
     corsair = corsair_ptr;
 
+    vendor      = "Corsair";
     description = "Corsair Hydro Series Device";
     version     = corsair->GetFirmwareString();
     type        = DEVICE_TYPE_COOLER;
+    location    = corsair->GetLocation();
 
     mode Direct;
     Direct.name       = "Direct";

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

@@ -11,35 +11,12 @@
 #include <string>
 #include <cstring>
 
-//Include thread libraries for Windows or Linux
-#ifdef WIN32
-#include <process.h>
-#else
-#include "pthread.h"
-#include "unistd.h"
-#endif
-
-//Thread functions have different types in Windows and Linux
-#ifdef WIN32
-#define THREAD static void
-#define THREADRETURN
-#else
-#define THREAD static void*
-#define THREADRETURN return(NULL);
-#endif
-
 using namespace std::chrono_literals;
 
-THREAD keepalive_thread(void *param)
+CorsairLightingNodeController::CorsairLightingNodeController(hid_device* dev_handle, const char* path)
 {
-    CorsairLightingNodeController* corsair = static_cast<CorsairLightingNodeController*>(param);
-    corsair->KeepaliveThread();
-    THREADRETURN
-}
-
-CorsairLightingNodeController::CorsairLightingNodeController(hid_device* dev_handle)
-{
-    dev = dev_handle;
+    dev         = dev_handle;
+    location    = path;
 
     SendFirmwareRequest();
 
@@ -49,21 +26,20 @@ CorsairLightingNodeController::CorsairLightingNodeController(hid_device* dev_han
     | to not revert back into rainbow mode.  Start a thread |
     | to continuously send a keepalive packet every 5s      |
     \*-----------------------------------------------------*/
-#ifdef WIN32
-    _beginthread(keepalive_thread, 0, this);
-#else
-    pthread_t thread;
-    pthread_create(&thread, NULL, &keepalive_thread, this);
-#endif
+    keepalive_thread_run = 1;
+    keepalive_thread = new std::thread(&CorsairLightingNodeController::KeepaliveThread, this);
 }
 
 CorsairLightingNodeController::~CorsairLightingNodeController()
 {
+    keepalive_thread_run = 0;
+    keepalive_thread->join();
+    delete keepalive_thread;
 }
 
 void CorsairLightingNodeController::KeepaliveThread()
 {
-    while(1)
+    while(keepalive_thread_run.load())
     {
         if((std::chrono::steady_clock::now() - last_commit_time) > std::chrono::seconds(5))
         {
@@ -78,6 +54,22 @@ std::string CorsairLightingNodeController::GetFirmwareString()
     return(firmware_version);
 }
 
+std::string CorsairLightingNodeController::GetLocationString()
+{
+    return("HID: " + location);
+}
+
+std::string CorsairLightingNodeController::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 CorsairLightingNodeController::SetChannelEffect(unsigned char channel,
                                                 unsigned char num_leds,
                                                 unsigned char mode,

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.h

@@ -79,10 +79,12 @@ enum
 class CorsairLightingNodeController
 {
 public:
-    CorsairLightingNodeController(hid_device* dev_handle);
+    CorsairLightingNodeController(hid_device* dev_handle, const char* path);
     ~CorsairLightingNodeController();
 
     std::string     GetFirmwareString();
+    std::string     GetLocationString();
+    std::string     GetSerialString();
 
     unsigned int    GetStripsOnChannel(unsigned int channel);
 
@@ -110,6 +112,9 @@ public:
 private:
     hid_device*             dev;
     std::string             firmware_version;
+    std::string             location;
+    std::thread*            keepalive_thread;
+    std::atomic<bool>       keepalive_thread_run;
     std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
 
     void            SendFirmwareRequest();

Controllers/CorsairLightingNodeController/CorsairLightingNodeControllerDetect.cpp

@@ -12,26 +12,7 @@
 #define CORSAIR_LS100_PID               0x0C1E
 #define CORSAIR_1000D_OBSIDIAN_PID      0x1D00
 #define CORSAIR_SPEC_OMEGA_RGB_PID      0x1D04
-
-typedef struct
-{
-    unsigned short  usb_vid;
-    unsigned short  usb_pid;
-    unsigned char   channel_count;
-    const char *    name;
-} corsair_node_device;
-
-#define CORSAIR_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const corsair_node_device device_list[] =
-{
-    { CORSAIR_VID,          CORSAIR_LIGHTING_NODE_CORE_PID,     1,      "Corsair Lighting Node Core"    },
-    { CORSAIR_VID,          CORSAIR_LIGHTING_NODE_PRO_PID,      2,      "Corsair Lighting Node Pro"     },
-    { CORSAIR_VID,          CORSAIR_COMMANDER_PRO_PID,          2,      "Corsair Commander Pro"         },
-    { CORSAIR_VID,          CORSAIR_LS100_PID,                  1,      "Corsair LS100 Lighting Kit"    },
-    { CORSAIR_VID,          CORSAIR_1000D_OBSIDIAN_PID,         2,      "Corsair 1000D Obsidian"        },
-    { CORSAIR_VID,          CORSAIR_SPEC_OMEGA_RGB_PID,         2,      "Corsair SPEC OMEGA RGB"        }
-};
+#define CORSAIR_LT100_PID               0x0C23
 
 /******************************************************************************************\
 *                                                                                          *
@@ -41,42 +22,22 @@ static const corsair_node_device device_list[] =
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectCorsairLightingNodeControllers(std::vector<RGBController*> &rgb_controllers)
+void DetectCorsairLightingNodeControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device_info* info;
-    hid_device* dev;
-
-    hid_init();
-
-    for(std::size_t device_idx = 0; device_idx < CORSAIR_NUM_DEVICES; device_idx++)
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
     {
-        dev = NULL;
-
-        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
-
-        //Look for Corsair Lighting Node Devices
-        while(info)
-        {
-            if((info->vendor_id == device_list[device_idx].usb_vid)
-            &&(info->product_id == device_list[device_idx].usb_pid))
-            {
-                dev = hid_open_path(info->path);
-
-                if( dev )
-                {
-                    CorsairLightingNodeController* controller = new CorsairLightingNodeController(dev);
-
-                    RGBController_CorsairLightingNode* rgb_controller = new RGBController_CorsairLightingNode(controller);
-
-                    rgb_controller->name = device_list[device_idx].name;
-
-                    rgb_controllers.push_back(rgb_controller);
-                }
-            }
-
-            info = info->next;
-        }
+        CorsairLightingNodeController* controller = new CorsairLightingNodeController(dev, info->path);
+        RGBController_CorsairLightingNode* rgb_controller = new RGBController_CorsairLightingNode(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }   /* DetectCorsairLightingNodeControllers() */
 
-REGISTER_DETECTOR("Corsair Lighting Node", DetectCorsairLightingNodeControllers);
+REGISTER_HID_DETECTOR("Corsair Lighting Node Core", DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LIGHTING_NODE_CORE_PID); // 1 channel
+REGISTER_HID_DETECTOR("Corsair Lighting Node Pro",  DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LIGHTING_NODE_PRO_PID);  // 2 channels
+REGISTER_HID_DETECTOR("Corsair Commander Pro",      DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_COMMANDER_PRO_PID);      // 2 channels
+REGISTER_HID_DETECTOR("Corsair LS100 Lighting Kit", DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LS100_PID);              // 1 channel
+REGISTER_HID_DETECTOR("Corsair 1000D Obsidian",     DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_1000D_OBSIDIAN_PID);     // 2 channels
+REGISTER_HID_DETECTOR("Corsair SPEC OMEGA RGB",     DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_SPEC_OMEGA_RGB_PID);     // 2 channels
+REGISTER_HID_DETECTOR("Corsair LT100",              DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LT100_PID);              // 2 channels

Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.cpp

@@ -15,9 +15,12 @@ RGBController_CorsairLightingNode::RGBController_CorsairLightingNode(CorsairLigh
     corsair = corsair_ptr;
 
     name        = "Corsair Lighting Node Device";
+    vendor      = "Corsair";
     description = "Corsair Lighting Node Device";
     type        = DEVICE_TYPE_LEDSTRIP;
     version     = corsair->GetFirmwareString();
+    location    = corsair->GetLocationString();
+    serial      = corsair->GetSerialString();
 
     mode Direct;
     Direct.name       = "Direct";
@@ -201,7 +204,7 @@ void RGBController_CorsairLightingNode::SetupZones()
         | can support is 200.                               |
         \*-------------------------------------------------*/
         zones[channel_idx].leds_min   = 0;
-        zones[channel_idx].leds_max   = 200;
+        zones[channel_idx].leds_max   = 204;
 
         if(first_run)
         {

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

@@ -48,9 +48,10 @@ static unsigned int keys_k95[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
 
 static unsigned int st100[] = { 0x00, 0x01, 0x02, 0x03, 0x05, 0x06, 0x07, 0x08, 0x04 };
 
-CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle)
+CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle, const char* path)
 {
-    dev = dev_handle;
+    dev         = dev_handle;
+    location    = path;
 
     ReadFirmwareInfo();
 
@@ -59,7 +60,10 @@ CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle)
 
 CorsairPeripheralController::~CorsairPeripheralController()
 {
-
+    if(dev)
+    {
+        hid_close(dev);
+    }
 }
 
 device_type CorsairPeripheralController::GetDeviceType()
@@ -67,6 +71,11 @@ device_type CorsairPeripheralController::GetDeviceType()
     return type;
 }
 
+std::string CorsairPeripheralController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
 int CorsairPeripheralController::GetPhysicalLayout()
 {
     return physical_layout;
@@ -82,6 +91,22 @@ std::string CorsairPeripheralController::GetFirmwareString()
     return firmware_version;
 }
 
+std::string CorsairPeripheralController::GetName()
+{
+    return name;
+}
+
+std::string CorsairPeripheralController::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 CorsairPeripheralController::SetLEDs(std::vector<RGBColor>colors)
 {
     switch(type)
@@ -261,6 +286,11 @@ void CorsairPeripheralController::SetLEDsKeyboardLimited(std::vector<RGBColor> c
     SubmitKeyboardLimitedColors(216);
 }
 
+void CorsairPeripheralController::SetName(std::string device_name)
+{
+    name = device_name;
+}
+
 /*-------------------------------------------------------------------------------------------------*\
 | Private packet sending functions.                                                                 |
 \*-------------------------------------------------------------------------------------------------*/

Controllers/CorsairPeripheralController/CorsairPeripheralController.h

@@ -66,24 +66,30 @@ enum
 class CorsairPeripheralController
 {
 public:
-    CorsairPeripheralController(hid_device* dev_handle);
+    CorsairPeripheralController(hid_device* dev_handle, const char* path);
     ~CorsairPeripheralController();
 
     int             GetLogicalLayout();
     int             GetPhysicalLayout();
     device_type     GetDeviceType();
+    std::string     GetDeviceLocation();
     std::string     GetFirmwareString();
+    std::string     GetName();
+    std::string     GetSerialString();
 
     void            SetLEDs(std::vector<RGBColor> colors);
     void            SetLEDsKeyboardFull(std::vector<RGBColor> colors);
     void            SetLEDsKeyboardLimited(std::vector<RGBColor> colors);
     void            SetLEDsMouse(std::vector<RGBColor> colors);
     void            SetLEDsMousemat(std::vector<RGBColor> colors);
+    void            SetName(std::string device_name);
 
 private:
     hid_device*             dev;
 
     std::string             firmware_version;
+    std::string             location;
+    std::string             name;
     device_type             type;
     int                     physical_layout;   //ANSI, ISO, etc.
     int                     logical_layout;    //Normal, K95 or K95 Platinum

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -2,7 +2,6 @@
 #include "CorsairPeripheralController.h"
 #include "RGBController.h"
 #include "RGBController_CorsairPeripheral.h"
-#include <vector>
 #include <hidapi/hidapi.h>
 
 /*-----------------------------------------------------*\
@@ -60,56 +59,6 @@
 \*-----------------------------------------------------*/
 #define CORSAIR_ST100_PID               0x0A34
 
-typedef struct
-{
-    unsigned short  usb_vid;
-    unsigned short  usb_pid;
-    unsigned char   usb_interface;
-    const char *    name;
-} corsair_node_device;
-
-#define CORSAIR_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const corsair_node_device device_list[] =
-{
-    /*-----------------------------------------------------------------------------------------------------*\
-    | Keyboards                                                                                             |
-    \*-----------------------------------------------------------------------------------------------------*/
-//  { CORSAIR_VID,          CORSAIR_K55_RGB_PID,                1,      "Corsair K55 RGB"                   }, //Not per-key, disabled for now
-    { CORSAIR_VID,          CORSAIR_K65_RGB_PID,                1,      "Corsair K65 RGB"                   },
-    { CORSAIR_VID,          CORSAIR_K65_LUX_RGB_PID,            1,      "Corsair K65 LUX RGB"               },
-    { CORSAIR_VID,          CORSAIR_K65_RGB_RAPIDFIRE_PID,      1,      "Corsair K65 RGB RAPIDFIRE"         },
-    { CORSAIR_VID,          CORSAIR_K68_RGB,                    1,      "Corsair K68 RGB"                   },
-    { CORSAIR_VID,          CORSAIR_K70_RGB_PID,                1,      "Corsair K70 RGB"                   },
-    { CORSAIR_VID,          CORSAIR_K70_LUX_RGB_PID,            1,      "Corsair K70 LUX RGB"               },
-    { CORSAIR_VID,          CORSAIR_K70_RGB_RAPIDFIRE_PID,      1,      "Corsair K70 RGB RAPIDFIRE"         },
-    { CORSAIR_VID,          CORSAIR_K70_RGB_MK2_PID,            1,      "Corsair K70 RGB MK.2"              },
-    { CORSAIR_VID,          CORSAIR_K70_RGB_MK2_SE_PID,         1,      "Corsair K70 RGB MK.2 SE"           },
-    { CORSAIR_VID,          CORSAIR_K70_RGB_MK2_LP_PID,         1,      "Corsair K70 RGB MK.2 Low Profile"  },
-    { CORSAIR_VID,          CORSAIR_K95_RGB_PID,                1,      "Corsair K95 RGB"                   },
-    { CORSAIR_VID,          CORSAIR_K95_PLATINUM_PID,           1,      "Corsair K95 RGB PLATINUM"          },
-    { CORSAIR_VID,          CORSAIR_STRAFE_PID,                 1,      "Corsair Strafe"                    },
-    { CORSAIR_VID,          CORSAIR_STRAFE_MK2_PID,             1,      "Corsair Strafe MK.2"               },
-    /*-----------------------------------------------------------------------------------------------------*\
-    | Mice                                                                                                  |
-    \*-----------------------------------------------------------------------------------------------------*/
-    { CORSAIR_VID,          CORSAIR_GLAIVE_RGB_PRO_PID,         1,      "Corsair Glaive RGB PRO"            },
-    { CORSAIR_VID,          CORSAIR_HARPOON_RGB_PID,            1,      "Corsair Harpoon RGB"               },
-    { CORSAIR_VID,          CORSAIR_HARPOON_RGB_PRO_PID,        1,      "Corsair Harpoon RGB PRO"           },
-    { CORSAIR_VID,          CORSAIR_M65_PRO_PID,                1,      "Corsair M65 PRO"                   },
-    { CORSAIR_VID,          CORSAIR_M65_RGB_ELITE_PID,          1,      "Corsair M65 RGB Elite"             },
-    { CORSAIR_VID,          CORSAIR_SCIMITAR_PRO_RGB_PID,       1,      "Corsair Scimitar PRO RGB"          },
-    { CORSAIR_VID,          CORSAIR_SABRE_RGB_PID,              1,      "Corsair Sabre RGB"                 },
-    /*-----------------------------------------------------------------------------------------------------*\
-    | Mousemats                                                                                             |
-    \*-----------------------------------------------------------------------------------------------------*/
-    { CORSAIR_VID,          CORSAIR_MM800_RGB_POLARIS_PID,      0,      "Corsair MM800 RGB Polaris"         },
-    /*-----------------------------------------------------------------------------------------------------*\
-    | Headset Stands                                                                                        |
-    \*-----------------------------------------------------------------------------------------------------*/
-    { CORSAIR_VID,          CORSAIR_ST100_PID,                  0,      "Corsair ST100 RGB"                 }
-};
-
 /******************************************************************************************\
 *                                                                                          *
 *   DetectCorsairPeripheralControllers                                                     *
@@ -118,50 +67,68 @@ static const corsair_node_device device_list[] =
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectCorsairPeripheralControllers(std::vector<RGBController*>& rgb_controllers)
+void DetectCorsairPeripheralControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device_info* info;
-    hid_device* dev;
-
-    hid_init();
-
-    for(std::size_t device_idx = 0; device_idx < CORSAIR_NUM_DEVICES; device_idx++)
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
     {
-        dev = NULL;
+        CorsairPeripheralController* controller = new CorsairPeripheralController(dev, info->path);
+        controller->SetName(name);
 
-        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
-
-        //Look for Corsair RGB Peripheral
-        while(info)
+        if(controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
         {
-            if((info->vendor_id == device_list[device_idx].usb_vid)
-#ifdef USE_HID_USAGE
-            &&(info->product_id == device_list[device_idx].usb_pid)
-            &&(info->usage_page == 0xFFC2))
-#else
-            &&(info->product_id == device_list[device_idx].usb_pid)
-            &&(info->interface_number == device_list[device_idx].usb_interface))
-#endif
-            {
-                dev = hid_open_path(info->path);
-
-                if( dev )
-                {
-                    CorsairPeripheralController* controller = new CorsairPeripheralController(dev);
-
-                    if(controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
-                    {
-                        RGBController_CorsairPeripheral* rgb_controller = new RGBController_CorsairPeripheral(controller);
-
-                        rgb_controller->name = device_list[device_idx].name;
-
-                        rgb_controllers.push_back(rgb_controller);
-                    }
-                }
-            }
-            info = info->next;
+            RGBController_CorsairPeripheral* rgb_controller = new RGBController_CorsairPeripheral(controller);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+        else
+        {
+            delete controller;
         }
     }
 }   /* DetectCorsairPeripheralControllers() */
 
-REGISTER_DETECTOR("Corsair Peripheral", DetectCorsairPeripheralControllers);
+/*-----------------------------------------------------------------------------------------------------*\
+| 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 K65 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_PID,           1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K65 LUX RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_LUX_RGB_PID,       1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K65 RGB RAPIDFIRE",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_RAPIDFIRE_PID, 1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K68 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K68_RGB,               1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K70 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_PID,           1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K70 LUX RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_LUX_RGB_PID,       1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K70 RGB RAPIDFIRE",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_RAPIDFIRE_PID, 1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_PID,       1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2 SE",          DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_SE_PID,    1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2 Low Profile", DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_LP_PID,    1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K95 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K95_RGB_PID,           1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K95 RGB PLATINUM",         DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K95_PLATINUM_PID,      1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Strafe",                   DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_PID,            1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Strafe MK.2",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_MK2_PID,        1, 0xFFC2);
+/*-----------------------------------------------------------------------------------------------------*\
+| Mice                                                                                                  |
+\*-----------------------------------------------------------------------------------------------------*/
+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);
+REGISTER_HID_DETECTOR_IP("Corsair M65 PRO",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_PRO_PID,           1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair M65 RGB Elite" ,           DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_RGB_ELITE_PID,     1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Scimitar PRO RGB",         DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SCIMITAR_PRO_RGB_PID,  1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Sabre RGB",                DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SABRE_RGB_PID,         1, 0xFFC2);
+
+/*-----------------------------------------------------------------------------------------------------*\
+| Mousemats                                                                                             |
+\*-----------------------------------------------------------------------------------------------------*/
+#ifdef USE_HID_USAGE
+REGISTER_HID_DETECTOR_P("Corsair MM800 RGB Polaris",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_MM800_RGB_POLARIS_PID, 0xFFC2);
+#else
+REGISTER_HID_DETECTOR_I("Corsair MM800 RGB Polaris",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_MM800_RGB_POLARIS_PID, 0);
+#endif
+/*-----------------------------------------------------------------------------------------------------*\
+| Headset Stands                                                                                        |
+\*-----------------------------------------------------------------------------------------------------*/
+#ifdef USE_HID_USAGE
+REGISTER_HID_DETECTOR_P("Corsair ST100 RGB",                DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_ST100_PID,             0xFFC2);
+#else
+REGISTER_HID_DETECTOR_I("Corsair ST100 RGB",                DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_ST100_PID,             0);
+#endif

Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.cpp

@@ -513,6 +513,25 @@ static const char* corsair_mouse_leds[] =
     "Mouse LED 15",
 };
 
+static const char* corsair_m65_elite_leds[] =
+{
+    "",
+    "",
+    "Logo",
+    "DPI",
+    "Scroll Wheel",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+};
+
 static const char* corsair_sabre_rgb_leds[] =
 {
     "",
@@ -555,10 +574,13 @@ RGBController_CorsairPeripheral::RGBController_CorsairPeripheral(CorsairPeripher
 {
     corsair = corsair_ptr;
 
-    name        = "Corsair RGB Peripheral Device";
+    name        = corsair->GetName();
+    vendor      = "Corsair";
     description = "Corsair RGB Peripheral Device";
     type        = corsair->GetDeviceType();
     version     = corsair->GetFirmwareString();
+    location    = corsair->GetDeviceLocation();
+    serial      = corsair->GetSerialString();
 
     physical_layout = corsair->GetPhysicalLayout();
     logical_layout  = corsair->GetLogicalLayout();
@@ -575,7 +597,16 @@ RGBController_CorsairPeripheral::RGBController_CorsairPeripheral(CorsairPeripher
 
 RGBController_CorsairPeripheral::~RGBController_CorsairPeripheral()
 {
-
+    /*---------------------------------------------------------*\
+    | Delete the matrix map                                     |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    {
+        if(zones[zone_index].matrix_map != NULL)
+        {
+            delete zones[zone_index].matrix_map;
+        }
+    }
 }
 
 void RGBController_CorsairPeripheral::SetupZones()
@@ -747,7 +778,22 @@ void RGBController_CorsairPeripheral::SetupZones()
                 break;
 
             case DEVICE_TYPE_MOUSE:
-                new_led.name = corsair_mouse_leds[led_idx];
+                if(name == "Corsair M65 RGB Elite")
+                {
+                    new_led.name = corsair_m65_elite_leds[led_idx];
+                }
+                else if(name == "Corsair Harpoon RGB PRO")
+                {
+                    new_led.name = corsair_harpoon_pro_leds[led_idx];
+                }
+                else if(name == "Corsair Sabre RGB")
+                {
+                    new_led.name = corsair_sabre_rgb_leds[led_idx];
+                }
+                else
+                {
+                    new_led.name = corsair_mouse_leds[led_idx];
+                }
                 break;
             
             case DEVICE_TYPE_MOUSEMAT:

Controllers/CorsairVengeanceController/CorsairVengeanceController.cpp

@@ -36,7 +36,7 @@ std::string CorsairVengeanceController::GetDeviceLocation()
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");
     return_string.append(addr);
-    return(return_string);
+    return("I2C: " + return_string);
 }
 
 unsigned int CorsairVengeanceController::GetLEDCount()

Controllers/CorsairVengeanceController/CorsairVengeanceControllerDetect.cpp

@@ -3,6 +3,7 @@
 #include "RGBController.h"
 #include "RGBController_CorsairVengeance.h"
 #include "i2c_smbus.h"
+#include "pci_ids.h"
 #include <vector>
 #include <stdio.h>
 #include <stdlib.h>
@@ -58,68 +59,71 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
 
     for (unsigned int bus = 0; bus < busses.size(); bus++)
     {
-        // Check for Corsair controller at 0x58
-        if (TestForCorsairVengeanceController(busses[bus], 0x58))
+        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            new_corsair = new CorsairVengeanceController(busses[bus], 0x58);
-            new_controller = new RGBController_CorsairVengeance(new_corsair);
-            rgb_controllers.push_back(new_controller);
-        }
+            // Check for Corsair controller at 0x58
+            if (TestForCorsairVengeanceController(busses[bus], 0x58))
+            {
+                new_corsair = new CorsairVengeanceController(busses[bus], 0x58);
+                new_controller = new RGBController_CorsairVengeance(new_corsair);
+                rgb_controllers.push_back(new_controller);
+            }
 
-        // Check for Corsair controller at 0x59
-        if (TestForCorsairVengeanceController(busses[bus], 0x59))
-        {
-            new_corsair = new CorsairVengeanceController(busses[bus], 0x59);
-            new_controller = new RGBController_CorsairVengeance(new_corsair);
-            rgb_controllers.push_back(new_controller);
-        }
+            // Check for Corsair controller at 0x59
+            if (TestForCorsairVengeanceController(busses[bus], 0x59))
+            {
+                new_corsair = new CorsairVengeanceController(busses[bus], 0x59);
+                new_controller = new RGBController_CorsairVengeance(new_corsair);
+                rgb_controllers.push_back(new_controller);
+            }
 
-        // Check for Corsair controller at 0x5A
-        if (TestForCorsairVengeanceController(busses[bus], 0x5A))
-        {
-            new_corsair = new CorsairVengeanceController(busses[bus], 0x5A);
-            new_controller = new RGBController_CorsairVengeance(new_corsair);
-            rgb_controllers.push_back(new_controller);
-        }
+            // Check for Corsair controller at 0x5A
+            if (TestForCorsairVengeanceController(busses[bus], 0x5A))
+            {
+                new_corsair = new CorsairVengeanceController(busses[bus], 0x5A);
+                new_controller = new RGBController_CorsairVengeance(new_corsair);
+                rgb_controllers.push_back(new_controller);
+            }
 
-        // Check for Corsair controller at 0x5B
-        if (TestForCorsairVengeanceController(busses[bus], 0x5B))
-        {
-            new_corsair = new CorsairVengeanceController(busses[bus], 0x5B);
-            new_controller = new RGBController_CorsairVengeance(new_corsair);
-            rgb_controllers.push_back(new_controller);
-        }
+            // Check for Corsair controller at 0x5B
+            if (TestForCorsairVengeanceController(busses[bus], 0x5B))
+            {
+                new_corsair = new CorsairVengeanceController(busses[bus], 0x5B);
+                new_controller = new RGBController_CorsairVengeance(new_corsair);
+                rgb_controllers.push_back(new_controller);
+            }
 
-        // Check for Corsair controller at 0x5C
-        if (TestForCorsairVengeanceController(busses[bus], 0x5C))
-        {
-            new_corsair = new CorsairVengeanceController(busses[bus], 0x5C);
-            new_controller = new RGBController_CorsairVengeance(new_corsair);
-            rgb_controllers.push_back(new_controller);
-        }
+            // Check for Corsair controller at 0x5C
+            if (TestForCorsairVengeanceController(busses[bus], 0x5C))
+            {
+                new_corsair = new CorsairVengeanceController(busses[bus], 0x5C);
+                new_controller = new RGBController_CorsairVengeance(new_corsair);
+                rgb_controllers.push_back(new_controller);
+            }
 
-        // Check for Corsair controller at 0x5D
-        if (TestForCorsairVengeanceController(busses[bus], 0x5D))
-        {
-            new_corsair = new CorsairVengeanceController(busses[bus], 0x5D);
-            new_controller = new RGBController_CorsairVengeance(new_corsair);
-            rgb_controllers.push_back(new_controller);
-        }
+            // Check for Corsair controller at 0x5D
+            if (TestForCorsairVengeanceController(busses[bus], 0x5D))
+            {
+                new_corsair = new CorsairVengeanceController(busses[bus], 0x5D);
+                new_controller = new RGBController_CorsairVengeance(new_corsair);
+                rgb_controllers.push_back(new_controller);
+            }
 
-        // Check for Corsair controller at 0x5E
-        if (TestForCorsairVengeanceController(busses[bus], 0x5E))
-        {
-            new_corsair = new CorsairVengeanceController(busses[bus], 0x5E);
-            new_controller = new RGBController_CorsairVengeance(new_corsair);
-            rgb_controllers.push_back(new_controller);
-        }
+            // Check for Corsair controller at 0x5E
+            if (TestForCorsairVengeanceController(busses[bus], 0x5E))
+            {
+                new_corsair = new CorsairVengeanceController(busses[bus], 0x5E);
+                new_controller = new RGBController_CorsairVengeance(new_corsair);
+                rgb_controllers.push_back(new_controller);
+            }
 
-        // Check for Corsair controller at 0x5F
-        if (TestForCorsairVengeanceController(busses[bus], 0x5F))
-        {
-            new_corsair = new CorsairVengeanceController(busses[bus], 0x5F);
-            new_controller = new RGBController_CorsairVengeance(new_corsair);
-            rgb_controllers.push_back(new_controller);
+            // Check for Corsair controller at 0x5F
+            if (TestForCorsairVengeanceController(busses[bus], 0x5F))
+            {
+                new_corsair = new CorsairVengeanceController(busses[bus], 0x5F);
+                new_controller = new RGBController_CorsairVengeance(new_corsair);
+                rgb_controllers.push_back(new_controller);
+            }
         }
     }
 

Controllers/CorsairVengeanceController/RGBController_CorsairVengeance.cpp

@@ -14,6 +14,7 @@ RGBController_CorsairVengeance::RGBController_CorsairVengeance(CorsairVengeanceC
     corsair = corsair_ptr;
 
     name        = corsair->GetDeviceName();
+    vendor      = "Corsair";
     type        = DEVICE_TYPE_DRAM;
     description = "Corsair Vengeance RGB Device";
     location    = corsair->GetDeviceLocation();

Controllers/CorsairVengeanceProController/CorsairVengeanceProController.cpp

@@ -47,7 +47,7 @@ std::string CorsairVengeanceProController::GetDeviceLocation()
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");
     return_string.append(addr);
-    return(return_string);
+    return("I2C: " + return_string);
 }
 
 unsigned int CorsairVengeanceProController::GetLEDCount()

Controllers/CorsairVengeanceProController/CorsairVengeanceProControllerDetect.cpp

@@ -3,6 +3,7 @@
 #include "RGBController.h"
 #include "RGBController_CorsairVengeancePro.h"
 #include "i2c_smbus.h"
+#include "pci_ids.h"
 #include <vector>
 #include <stdio.h>
 #include <stdlib.h>
@@ -66,68 +67,71 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
 
     for (unsigned int bus = 0; bus < busses.size(); bus++)
     {
-        // Check for Corsair controller at 0x58
-        if (TestForCorsairVengeanceProController(busses[bus], 0x58))
+        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x58);
-            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-            rgb_controllers.push_back(new_controller);
-        }
+            // Check for Corsair controller at 0x58
+            if (TestForCorsairVengeanceProController(busses[bus], 0x58))
+            {
+                new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x58);
+                new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+                rgb_controllers.push_back(new_controller);
+            }
 
-        // Check for Corsair controller at 0x59
-        if (TestForCorsairVengeanceProController(busses[bus], 0x59))
-        {
-            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x59);
-            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-            rgb_controllers.push_back(new_controller);
-        }
+            // Check for Corsair controller at 0x59
+            if (TestForCorsairVengeanceProController(busses[bus], 0x59))
+            {
+                new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x59);
+                new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+                rgb_controllers.push_back(new_controller);
+            }
 
-        // Check for Corsair controller at 0x5A
-        if (TestForCorsairVengeanceProController(busses[bus], 0x5A))
-        {
-            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5A);
-            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-            rgb_controllers.push_back(new_controller);
-        }
+            // Check for Corsair controller at 0x5A
+            if (TestForCorsairVengeanceProController(busses[bus], 0x5A))
+            {
+                new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5A);
+                new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+                rgb_controllers.push_back(new_controller);
+            }
 
-        // Check for Corsair controller at 0x5B
-        if (TestForCorsairVengeanceProController(busses[bus], 0x5B))
-        {
-            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5B);
-            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-            rgb_controllers.push_back(new_controller);
-        }
+            // Check for Corsair controller at 0x5B
+            if (TestForCorsairVengeanceProController(busses[bus], 0x5B))
+            {
+                new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5B);
+                new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+                rgb_controllers.push_back(new_controller);
+            }
 
-        // Check for Corsair controller at 0x5C
-        if (TestForCorsairVengeanceProController(busses[bus], 0x5C))
-        {
-            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5C);
-            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-            rgb_controllers.push_back(new_controller);
-        }
+            // Check for Corsair controller at 0x5C
+            if (TestForCorsairVengeanceProController(busses[bus], 0x5C))
+            {
+                new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5C);
+                new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+                rgb_controllers.push_back(new_controller);
+            }
 
-        // Check for Corsair controller at 0x5D
-        if (TestForCorsairVengeanceProController(busses[bus], 0x5D))
-        {
-            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5D);
-            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-            rgb_controllers.push_back(new_controller);
-        }
+            // Check for Corsair controller at 0x5D
+            if (TestForCorsairVengeanceProController(busses[bus], 0x5D))
+            {
+                new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5D);
+                new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+                rgb_controllers.push_back(new_controller);
+            }
 
-        // Check for Corsair controller at 0x5E
-        if (TestForCorsairVengeanceProController(busses[bus], 0x5E))
-        {
-            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5E);
-            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-            rgb_controllers.push_back(new_controller);
-        }
+            // Check for Corsair controller at 0x5E
+            if (TestForCorsairVengeanceProController(busses[bus], 0x5E))
+            {
+                new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5E);
+                new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+                rgb_controllers.push_back(new_controller);
+            }
 
-        // Check for Corsair controller at 0x5F
-        if (TestForCorsairVengeanceProController(busses[bus], 0x5F))
-        {
-            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5F);
-            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-            rgb_controllers.push_back(new_controller);
+            // Check for Corsair controller at 0x5F
+            if (TestForCorsairVengeanceProController(busses[bus], 0x5F))
+            {
+                new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5F);
+                new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+                rgb_controllers.push_back(new_controller);
+            }
         }
     }
 

Controllers/CorsairVengeanceProController/RGBController_CorsairVengeancePro.cpp

@@ -14,6 +14,7 @@ RGBController_CorsairVengeancePro::RGBController_CorsairVengeancePro(CorsairVeng
     corsair = corsair_ptr;
 
     name        = corsair->GetDeviceName();
+    vendor      = "Corsair";
     type        = DEVICE_TYPE_DRAM;
     description = "Corsair Vengeance Pro RGB Device";
     location    = corsair->GetDeviceLocation();

Controllers/CrucialController/CrucialController.cpp

@@ -15,6 +15,9 @@ CrucialController::CrucialController(i2c_smbus_interface* bus, crucial_dev_id de
 {
     this->bus = bus;
     this->dev = dev;
+
+    // We don't know what mode the sticks are in until we set one.
+    this->last_mode = CRUCIAL_MODE_UNKNOWN;
 }
 
 CrucialController::~CrucialController()
@@ -34,7 +37,7 @@ std::string CrucialController::GetDeviceLocation()
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");
     return_string.append(addr);
-    return(return_string);
+    return("I2C: " + return_string);
 }
 
 unsigned int CrucialController::GetLEDCount()
@@ -44,7 +47,11 @@ unsigned int CrucialController::GetLEDCount()
 
 void CrucialController::SetMode(unsigned char mode)
 {
+    // Don't set a mode if we've already set the same one before.
+    // This is mostly useful for direct mode and updating colors often.
+    if (mode == last_mode) return;
     SendEffectMode(mode, 0x10);
+    last_mode = mode;
 }
 
 void CrucialController::SetAllColorsDirect(RGBColor* colors)
@@ -80,6 +87,8 @@ void CrucialController::SendEffectMode(unsigned char mode, unsigned char speed)
 
 void CrucialController::SendDirectColors(RGBColor* color_buf)
 {
+    SetMode(CRUCIAL_MODE_STATIC);
+
     //Red Channels
     CrucialRegisterWrite(0x8300, RGBGetRValue(color_buf[0]));
     CrucialRegisterWrite(0x8301, RGBGetRValue(color_buf[1]));

Controllers/CrucialController/CrucialController.h

@@ -18,6 +18,7 @@ typedef unsigned short	crucial_register;
 
 enum
 {
+    CRUCIAL_MODE_UNKNOWN            = 0x00,     /* We don't know what the mode is   */
     CRUCIAL_MODE_SHIFT              = 0x1F,     /* Shift effect mode                */
     CRUCIAL_MODE_GRADIENT_SHIFT     = 0x2F,     /* Gradient shift mode              */
     CRUCIAL_MODE_FILL               = 0x3F,     /* Fill effect mode                 */
@@ -53,6 +54,7 @@ private:
     unsigned char           config_table[64];
     unsigned int            led_count;
     unsigned char           channel_cfg;
+    unsigned char           last_mode;
     i2c_smbus_interface *   bus;
     crucial_dev_id          dev;
 

Controllers/CrucialController/CrucialControllerDetect.cpp

@@ -3,6 +3,7 @@
 #include "RGBController.h"
 #include "RGBController_Crucial.h"
 #include "i2c_smbus.h"
+#include "pci_ids.h"
 #include <vector>
 #include <stdio.h>
 #include <stdlib.h>
@@ -74,14 +75,17 @@ void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses, std::ve
 
     for (unsigned int bus = 0; bus < busses.size(); bus++)
     {
-        // Add Crucial controllers
-        for (unsigned int address_list_idx = 0; address_list_idx < CRUCIAL_ADDRESS_COUNT; address_list_idx++)
+        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            if (TestForCrucialController(busses[bus], crucial_addresses[address_list_idx]))
+            // Add Crucial controllers
+            for (unsigned int address_list_idx = 0; address_list_idx < CRUCIAL_ADDRESS_COUNT; address_list_idx++)
             {
-                new_crucial = new CrucialController(busses[bus], crucial_addresses[address_list_idx]);
-                new_controller = new RGBController_Crucial(new_crucial);
-                rgb_controllers.push_back(new_controller);
+                if (TestForCrucialController(busses[bus], crucial_addresses[address_list_idx]))
+                {
+                    new_crucial = new CrucialController(busses[bus], crucial_addresses[address_list_idx]);
+                    new_controller = new RGBController_Crucial(new_crucial);
+                    rgb_controllers.push_back(new_controller);
+                }
             }
         }
     }

Controllers/CrucialController/RGBController_Crucial.cpp

@@ -14,6 +14,7 @@ RGBController_Crucial::RGBController_Crucial(CrucialController * crucial_ptr)
     crucial = crucial_ptr;
 
     name        = "Crucial DRAM";
+    vendor      = "Crucial";
     type        = DEVICE_TYPE_DRAM;
     description = "Crucial DRAM Device";
     location    = crucial->GetDeviceLocation();

Controllers/DebugController/DebugControllerDetect.cpp

@@ -0,0 +1,544 @@
+#include "Detector.h"
+#include "RGBController.h"
+#include "RGBController_Debug.h"
+#include "RGBController_Dummy.h"
+#include "SettingsManager.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <fcntl.h>
+#include <string.h>
+#include <fstream>
+#include <iostream>
+#include <string>
+
+
+//0xFFFFFFFF indicates an unused entry in matrix
+#define NA  0xFFFFFFFF
+
+static unsigned int debug_keyboard_matrix_map[6][23] =
+    { {   0,  NA,  16,  30,  44,  54,  NA,  65,  75,  84,  95,  NA,   8,  23 ,  38,   6 ,  22,  36,  49,  NA,  NA,  NA,  NA },
+      {   1,  17,  31,  45,  55,  66,  76,  85,  96,   9,  24,  NA,  39,   7 ,  37,  NA ,  60,  70,  80,  52,  63,  73,  82 },
+      {   2,  NA,  18,  32,  46,  56,  NA,  67,  77,  86,  97,  10,  25,  40 ,  90,  101,  50,  61,  71,  51,  62,  72,  93 },
+      {   3,  NA,  19,  33,  47,  57,  NA,  68,  78,  87,  98,  11,  26,  41 ,  28,  14 ,  NA,  NA,  NA,  92, 103,  53,  NA },
+      {   4,  20,  34,  48,  58,  69,  NA,  79,  NA,  88,  99,  12,  27,  42 ,  81,  NA ,  NA, 102,  NA,  64,  74,  83, 104 },
+      {   5,  21,  35,  NA,  NA,  NA,  NA,  59,  NA,  NA,  NA,  NA,  89,  100,  13,  91 ,  15,  29,  43,  94,  NA, 105,  NA } };
+
+static const char *led_names[] =
+{
+    "Key: Escape",
+    "Key: `",
+    "Key: Tab",
+    "Key: Caps Lock",
+    "Key: Left Shift",
+    "Key: Left Control",
+    "Key: F12",
+    "Key: =",
+    "Key: F9",
+    "Key: 9",
+    "Key: O",
+    "Key: L",
+    "Key: ,",
+    "Key: Menu",
+    "Key: Enter (ISO)",
+    "Key: Left Arrow",
+    "Key: F1",
+    "Key: 1",
+    "Key: Q",
+    "Key: A",
+    "Key: \\ (ISO)",
+    "Key: Left Windows",
+    "Key: Print Screen",
+    "Key: F10",
+    "Key: 0",
+    "Key: P",
+    "Key: ;",
+    "Key: .",
+    "Key: Enter",
+    "Key: Down Arrow",
+    "Key: F2",
+    "Key: 2",
+    "Key: W",
+    "Key: S",
+    "Key: Z",
+    "Key: Left Alt",
+    "Key: Scroll Lock",
+    "Key: Backspace",
+    "Key: F11",
+    "Key: -",
+    "Key: [",
+    "Key: '",
+    "Key: /",
+    "Key: Right Arrow",
+    "Key: F3",
+    "Key: 3",
+    "Key: E",
+    "Key: D",
+    "Key: X",
+    "Key: Pause/Break",
+    "Key: Delete",
+    "Key: Number Pad 7",
+    "Key: Num Lock",
+    "Key: Number Pad 6",
+    "Key: F4",
+    "Key: 4",
+    "Key: R",
+    "Key: F",
+    "Key: C",
+    "Key: Space",
+    "Key: Insert",
+    "Key: End",
+    "Key: Number Pad 8",
+    "Key: Number Pad /",
+    "Key: Number Pad 1",
+    "Key: F5",
+    "Key: 5",
+    "Key: T",
+    "Key: G",
+    "Key: V",
+    "Key: Home",
+    "Key: Page Down",
+    "Key: Number Pad 9",
+    "Key: Number Pad *",
+    "Key: Number Pad 2",
+    "Key: F6",
+    "Key: 6",
+    "Key: Y",
+    "Key: H",
+    "Key: B",
+    "Key: Page Up",
+    "Key: Right Shift",
+    "Key: Number Pad -",
+    "Key: Number Pad 3",
+    "Key: F7",
+    "Key: 7",
+    "Key: U",
+    "Key: J",
+    "Key: N",
+    "Key: Right Alt",
+    "Key: ]",
+    "Key: Right Control",
+    "Key: Number Pad 4",
+    "Key: Number Pad +",
+    "Key: Number Pad 0",
+    "Key: F8",
+    "Key: 8",
+    "Key: I",
+    "Key: K",
+    "Key: M",
+    "Key: Right Windows",
+    "Key: \\ (ANSI)",
+    "Key: Up Arrow",
+    "Key: Number Pad 5",
+    "Key: Number Pad Enter",
+    "Key: Number Pad .",
+    "RGB Strip 1",
+    "RGB Strip 2",
+    "RGB Strip 3",
+    "RGB Strip 4",
+    "RGB Strip 5",
+    "RGB Strip 6",
+    "RGB Strip 7",
+    "RGB Strip 8",
+    "RGB Strip 9",
+    "RGB Strip 10",
+    "RGB Strip 11",
+    "RGB Strip 12",
+    "RGB Strip 13",
+    "RGB Strip 14",
+    "RGB Strip 15",
+    "RGB Strip 16",
+    "RGB Strip 17",
+    "RGB Strip 18",
+    "Key: Media Previous",
+    "Key: Media Play/Pause",
+    "Key: Media Next",
+    "Key: Media Mute"
+};
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectDebugControllers                                                                 *
+*                                                                                          *
+*       Add dummy controllers based on the DebugDevices key in the settings json           *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectDebugControllers(std::vector<RGBController*> &rgb_controllers)
+{
+    json            debug_settings;
+    
+    /*-------------------------------------------------*\
+    | Get Debug Device settings from settings manager   |
+    \*-------------------------------------------------*/
+    debug_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("DebugDevices");
+
+    /*-------------------------------------------------*\
+    | If the Debug settings contains devices, process   |
+    \*-------------------------------------------------*/
+    if(debug_settings.contains("devices"))
+    {
+        for(unsigned int device_idx = 0; device_idx < debug_settings["devices"].size(); device_idx++)
+        {
+            std::string type = "";
+
+            if(debug_settings["devices"][device_idx].contains("type"))
+            {
+                type = debug_settings["devices"][device_idx]["type"];
+            }
+
+            if(type == "motherboard")
+            {
+                /*---------------------------------------------------------*\
+                | Create a dummy motherboard                                |
+                \*---------------------------------------------------------*/
+                RGBController_Dummy* dummy_motherboard = new RGBController_Dummy();
+
+                dummy_motherboard->name                     = "Debug Motherboard";
+                dummy_motherboard->type                     = DEVICE_TYPE_MOTHERBOARD;
+                dummy_motherboard->description              = "Debug Motherboard Device";
+                dummy_motherboard->location                 = "Debug Motherboard Location";
+                dummy_motherboard->version                  = "Debug Motherboard Version";
+                dummy_motherboard->serial                   = "Debug Motherboard Serial";
+
+                /*---------------------------------------------------------*\
+                | Create a direct mode for the dummy motherboard            |
+                \*---------------------------------------------------------*/
+                mode dummy_motherboard_direct_mode;
+
+                dummy_motherboard_direct_mode.name          = "Direct";
+                dummy_motherboard_direct_mode.value         = 0;
+                dummy_motherboard_direct_mode.flags         = MODE_FLAG_HAS_PER_LED_COLOR;
+                dummy_motherboard_direct_mode.color_mode    = MODE_COLORS_PER_LED;
+
+                dummy_motherboard->modes.push_back(dummy_motherboard_direct_mode);
+
+                /*---------------------------------------------------------*\
+                | Create a single zone/LED for the dummy motherboard        |
+                \*---------------------------------------------------------*/
+                zone dummy_motherboard_single_zone;
+
+                dummy_motherboard_single_zone.name          = "Single Zone";
+                dummy_motherboard_single_zone.type          = ZONE_TYPE_SINGLE;
+                dummy_motherboard_single_zone.leds_min      = 1;
+                dummy_motherboard_single_zone.leds_max      = 1;
+                dummy_motherboard_single_zone.leds_count    = 1;
+                dummy_motherboard_single_zone.matrix_map    = NULL;
+
+                dummy_motherboard->zones.push_back(dummy_motherboard_single_zone);
+
+                led dummy_motherboard_single_led;
+
+                dummy_motherboard_single_led.name           = "Single LED";
+
+                dummy_motherboard->leds.push_back(dummy_motherboard_single_led);
+
+                /*---------------------------------------------------------*\
+                | Create a linear zone for the dummy motherboard            |
+                \*---------------------------------------------------------*/
+                zone dummy_motherboard_linear_zone;
+
+                dummy_motherboard_linear_zone.name          = "Linear Zone";
+                dummy_motherboard_linear_zone.type          = ZONE_TYPE_LINEAR;
+                dummy_motherboard_linear_zone.leds_min      = 10;
+                dummy_motherboard_linear_zone.leds_max      = 10;
+                dummy_motherboard_linear_zone.leds_count    = 10;
+                dummy_motherboard_linear_zone.matrix_map    = NULL;
+
+                dummy_motherboard->zones.push_back(dummy_motherboard_linear_zone);
+
+                for(std::size_t led_idx = 0; led_idx < 10; led_idx++)
+                {
+                    led dummy_motherboard_linear_led;
+
+                    dummy_motherboard_linear_led.name       = "Linear LED " + std::to_string(led_idx);
+
+                    dummy_motherboard->leds.push_back(dummy_motherboard_linear_led);
+                }
+
+                dummy_motherboard->SetupColors();
+
+                /*---------------------------------------------------------*\
+                | Push the dummy motherboard onto the controller list       |
+                \*---------------------------------------------------------*/
+                rgb_controllers.push_back(dummy_motherboard);
+            }
+            else if(type == "dram")
+            {
+                /*---------------------------------------------------------*\
+                | Create a dummy DRAM                                       |
+                \*---------------------------------------------------------*/
+                RGBController_Dummy* dummy_dram = new RGBController_Dummy();
+
+                dummy_dram->name                            = "Debug DRAM";
+                dummy_dram->type                            = DEVICE_TYPE_DRAM;
+                dummy_dram->description                     = "Debug DRAM Device";
+                dummy_dram->location                        = "Debug DRAM Location";
+                dummy_dram->version                         = "Debug DRAM Version";
+                dummy_dram->serial                          = "Debug DRAM Serial";
+
+                /*---------------------------------------------------------*\
+                | Create a direct mode for the dummy DRAM                   |
+                \*---------------------------------------------------------*/
+                mode dummy_dram_direct_mode;
+
+                dummy_dram_direct_mode.name                 = "Direct";
+                dummy_dram_direct_mode.value                = 0;
+                dummy_dram_direct_mode.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+                dummy_dram_direct_mode.color_mode           = MODE_COLORS_PER_LED;
+
+                dummy_dram->modes.push_back(dummy_dram_direct_mode);
+
+                /*---------------------------------------------------------*\
+                | Create a single zone/LED for the dummy DRAM               |
+                \*---------------------------------------------------------*/
+                zone dummy_dram_single_zone;
+
+                dummy_dram_single_zone.name                 = "Single Zone";
+                dummy_dram_single_zone.type                 = ZONE_TYPE_SINGLE;
+                dummy_dram_single_zone.leds_min             = 1;
+                dummy_dram_single_zone.leds_max             = 1;
+                dummy_dram_single_zone.leds_count           = 1;
+                dummy_dram_single_zone.matrix_map           = NULL;
+
+                dummy_dram->zones.push_back(dummy_dram_single_zone);
+
+                led dummy_dram_single_led;
+
+                dummy_dram_single_led.name                  = "Single LED";
+
+                dummy_dram->leds.push_back(dummy_dram_single_led);
+
+                /*---------------------------------------------------------*\
+                | Create a linear zone for the dummy DRAM                   |
+                \*---------------------------------------------------------*/
+                zone dummy_dram_linear_zone;
+
+                dummy_dram_linear_zone.name                 = "Linear Zone";
+                dummy_dram_linear_zone.type                 = ZONE_TYPE_LINEAR;
+                dummy_dram_linear_zone.leds_min             = 5;
+                dummy_dram_linear_zone.leds_max             = 5;
+                dummy_dram_linear_zone.leds_count           = 5;
+                dummy_dram_linear_zone.matrix_map           = NULL;
+
+                dummy_dram->zones.push_back(dummy_dram_linear_zone);
+
+                for(std::size_t led_idx = 0; led_idx < 5; led_idx++)
+                {
+                    led dummy_dram_linear_led;
+
+                    dummy_dram_linear_led.name              = "Linear LED " + std::to_string(led_idx);
+
+                    dummy_dram->leds.push_back(dummy_dram_linear_led);
+                }
+
+                dummy_dram->SetupColors();
+
+                /*---------------------------------------------------------*\
+                | Push the dummy DRAM onto the controller list              |
+                \*---------------------------------------------------------*/
+                rgb_controllers.push_back(dummy_dram);
+            }
+            else if(type == "gpu")
+            {
+                /*---------------------------------------------------------*\
+                | Create a dummy GPU                                        |
+                \*---------------------------------------------------------*/
+                RGBController_Dummy* dummy_gpu = new RGBController_Dummy();
+
+                dummy_gpu->name                             = "Debug GPU";
+                dummy_gpu->type                             = DEVICE_TYPE_GPU;
+                dummy_gpu->description                      = "Debug GPU Device";
+                dummy_gpu->location                         = "Debug GPU Location";
+                dummy_gpu->version                          = "Debug GPU Version";
+                dummy_gpu->serial                           = "Debug GPU Serial";
+
+                /*---------------------------------------------------------*\
+                | Create a direct mode for the dummy GPU                    |
+                \*---------------------------------------------------------*/
+                mode dummy_gpu_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_gpu->modes.push_back(dummy_gpu_direct_mode);
+
+                /*---------------------------------------------------------*\
+                | Create a single zone/LED for the dummy GPU                |
+                \*---------------------------------------------------------*/
+                zone dummy_gpu_single_zone;
+
+                dummy_gpu_single_zone.name                  = "Single Zone";
+                dummy_gpu_single_zone.type                  = ZONE_TYPE_SINGLE;
+                dummy_gpu_single_zone.leds_min              = 1;
+                dummy_gpu_single_zone.leds_max              = 1;
+                dummy_gpu_single_zone.leds_count            = 1;
+                dummy_gpu_single_zone.matrix_map            = NULL;
+
+                dummy_gpu->zones.push_back(dummy_gpu_single_zone);
+
+                led dummy_gpu_single_led;
+
+                dummy_gpu_single_led.name                   = "Single LED";
+
+                dummy_gpu->leds.push_back(dummy_gpu_single_led);
+
+                /*---------------------------------------------------------*\
+                | Create a linear zone for the dummy GPU                    |
+                \*---------------------------------------------------------*/
+                zone dummy_gpu_linear_zone;
+
+                dummy_gpu_linear_zone.name                  = "Linear Zone";
+                dummy_gpu_linear_zone.type                  = ZONE_TYPE_LINEAR;
+                dummy_gpu_linear_zone.leds_min              = 15;
+                dummy_gpu_linear_zone.leds_max              = 15;
+                dummy_gpu_linear_zone.leds_count            = 15;
+                dummy_gpu_linear_zone.matrix_map            = NULL;
+
+                dummy_gpu->zones.push_back(dummy_gpu_linear_zone);
+
+                for(std::size_t led_idx = 0; led_idx < 15; led_idx++)
+                {
+                    led dummy_gpu_linear_led;
+
+                    dummy_gpu_linear_led.name               = "Linear LED " + std::to_string(led_idx);
+
+                    dummy_gpu->leds.push_back(dummy_gpu_linear_led);
+                }
+
+                dummy_gpu->SetupColors();
+
+                /*---------------------------------------------------------*\
+                | Push the dummy GPU onto the controller list               |
+                \*---------------------------------------------------------*/
+                rgb_controllers.push_back(dummy_gpu);
+            }
+            else if(type == "keyboard")
+            {
+                /*---------------------------------------------------------*\
+                | Create a dummy Keyboard                                   |
+                \*---------------------------------------------------------*/
+                RGBController_Dummy* dummy_keyboard = new RGBController_Dummy();
+
+                dummy_keyboard->name                             = "Debug Keyboard";
+                dummy_keyboard->type                             = DEVICE_TYPE_KEYBOARD;
+                dummy_keyboard->description                      = "Debug Keyboard Device";
+                dummy_keyboard->location                         = "Debug Keyboard Location";
+                dummy_keyboard->version                          = "Debug Keyboard Version";
+                dummy_keyboard->serial                           = "Debug Keyboard Serial";
+
+                /*---------------------------------------------------------*\
+                | Create a direct mode for the dummy GPU                    |
+                \*---------------------------------------------------------*/
+                mode dummy_gpu_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->modes.push_back(dummy_gpu_direct_mode);
+
+                /*---------------------------------------------------------*\
+                | Create a matrix zone for the debug Keyboard               |
+                \*---------------------------------------------------------*/
+                zone dummy_keyboard_matrix_zone;
+
+                dummy_keyboard_matrix_zone.name                  = "Keyboard Matrix Zone";
+                dummy_keyboard_matrix_zone.type                  = ZONE_TYPE_MATRIX;
+                dummy_keyboard_matrix_zone.leds_min              = 106;
+                dummy_keyboard_matrix_zone.leds_max              = 106;
+                dummy_keyboard_matrix_zone.leds_count            = 106;
+                dummy_keyboard_matrix_zone.matrix_map            = new matrix_map_type;
+                dummy_keyboard_matrix_zone.matrix_map->height    = 6;
+                dummy_keyboard_matrix_zone.matrix_map->width     = 23;
+                dummy_keyboard_matrix_zone.matrix_map->map       = (unsigned int*)&debug_keyboard_matrix_map;
+
+                dummy_keyboard->zones.push_back(dummy_keyboard_matrix_zone);
+
+                /*---------------------------------------------------------*\
+                | Create a linear zone for the dummy GPU                    |
+                \*---------------------------------------------------------*/
+                zone dummy_keyboard_linear_zone;
+
+                dummy_keyboard_linear_zone.name                  = "Linear Zone";
+                dummy_keyboard_linear_zone.type                  = ZONE_TYPE_LINEAR;
+                dummy_keyboard_linear_zone.leds_min              = 18;
+                dummy_keyboard_linear_zone.leds_max              = 18;
+                dummy_keyboard_linear_zone.leds_count            = 18;
+                dummy_keyboard_linear_zone.matrix_map            = NULL;
+
+                dummy_keyboard->zones.push_back(dummy_keyboard_linear_zone);
+
+                for(std::size_t led_idx = 0; led_idx < 124; led_idx++)
+                {
+                    led dummy_keyboard_led;
+                    dummy_keyboard_led.name = led_names[led_idx];
+                    dummy_keyboard->leds.push_back(dummy_keyboard_led);
+                }
+
+                dummy_keyboard->SetupColors();
+
+                /*---------------------------------------------------------*\
+                | Push the dummy Keyboard onto the controller list          |
+                \*---------------------------------------------------------*/
+                rgb_controllers.push_back(dummy_keyboard);
+            }
+            else if(type == "argb")
+            {
+                /*---------------------------------------------------------*\
+                | Create a dummy ARGB                                       |
+                \*---------------------------------------------------------*/
+                RGBController_Debug* dummy_argb = new RGBController_Debug();
+
+                dummy_argb->name                            = "Debug ARGB";
+                dummy_argb->type                            = DEVICE_TYPE_LEDSTRIP;
+                dummy_argb->description                     = "Debug ARGB Device";
+                dummy_argb->location                        = "Debug ARGB Location";
+                dummy_argb->version                         = "Debug ARGB Version";
+                dummy_argb->serial                          = "Debug ARGB Serial";
+
+                /*---------------------------------------------------------*\
+                | Create a direct mode for the dummy ARGB                   |
+                \*---------------------------------------------------------*/
+                mode dummy_argb_direct_mode;
+
+                dummy_argb_direct_mode.name                 = "Direct";
+                dummy_argb_direct_mode.value                = 0;
+                dummy_argb_direct_mode.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+                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                   |
+                \*---------------------------------------------------------*/
+                zone dummy_argb_linear_zone;
+
+                dummy_argb_linear_zone.name                 = "Resizable zone";
+                dummy_argb_linear_zone.type                 = ZONE_TYPE_LINEAR;
+                dummy_argb_linear_zone.leds_min             = 1;
+                dummy_argb_linear_zone.leds_max             = 100;
+                dummy_argb_linear_zone.leds_count           = 0;
+                dummy_argb_linear_zone.matrix_map           = NULL;
+
+                dummy_argb->zones.push_back(dummy_argb_linear_zone);
+
+                dummy_argb->SetupColors();
+                dummy_argb->ResizeZone(0, 60);
+
+                /*---------------------------------------------------------*\
+                | Push the dummy ARGB onto the controller list              |
+                \*---------------------------------------------------------*/
+                rgb_controllers.push_back(dummy_argb);
+            }
+        }
+    }
+
+}   /* DetectDebugControllers() */
+
+REGISTER_DETECTOR("Debug Controllers", DetectDebugControllers);

Controllers/DebugController/RGBController_Debug.cpp

@@ -0,0 +1,49 @@
+#include "RGBController_Debug.h"
+
+#include <algorithm>
+#include <cstring>
+
+RGBController_Debug::RGBController_Debug()
+{
+
+}
+
+void RGBController_Debug::ResizeZone(int index, int new_size)
+{
+    //Make sure that it isn't out of bounds (negative numbers)
+    if(new_size < int(zones[index].leds_min))
+    {
+         new_size = zones[index].leds_min;
+    }
+
+    // Same thing as the above line except for over 100
+    if(new_size > int(zones[index].leds_max))
+    {
+        new_size = zones[index].leds_max;
+    }
+
+    // Store the previous amount of LEDs
+    int old_size = zones[index].leds_count;
+
+    // Set the LED count in the zone to the new ammount
+    zones[index].leds_count = new_size;
+
+    // Set the new ammount of LEDs for to the new size
+    size_t old_leds_size = leds.size();
+
+    // Add the new ammount of LEDs to the old ammount
+    size_t new_leds_size = leds.size() - old_size + new_size;
+    
+    leds.resize(std::max(old_leds_size, new_leds_size));
+
+    memmove(&leds[zones[index].start_idx] + old_leds_size, &leds[zones[index].start_idx] + new_leds_size, (old_leds_size - zones[index].start_idx - old_size) * sizeof(led));
+
+    leds.resize(new_leds_size);
+
+    for(int i = 0; i < new_size; ++i)
+    {
+        leds[zones[index].start_idx + i].name = "Linear LED " + std::to_string(i);
+    }
+    
+    SetupColors();
+}

Controllers/DebugController/RGBController_Debug.h

@@ -0,0 +1,15 @@
+#ifndef RGBCONTROLLER_DEBUG_H
+#define RGBCONTROLLER_DEBUG_H
+
+#include "RGBController_Dummy.h"
+
+// A variation of Dummy controller that allows the zones to be resized
+
+class RGBController_Debug : public RGBController_Dummy
+{
+public:
+    RGBController_Debug();
+    void ResizeZone(int zone, int newSize) override;
+};
+
+#endif // RGBCONTROLLER_DEBUG_H

Controllers/DuckyKeyboardController/DuckyKeyboardController.cpp

@@ -10,9 +10,10 @@
 #include <cstring>
 #include "DuckyKeyboardController.h"
 
-DuckyKeyboardController::DuckyKeyboardController(hid_device* dev_handle)
+DuckyKeyboardController::DuckyKeyboardController(hid_device* dev_handle, const char* path)
 {
-    dev = dev_handle;
+    dev         = dev_handle;
+    location    = path;
 
     SendInitialize();
 }
@@ -22,6 +23,22 @@ DuckyKeyboardController::~DuckyKeyboardController()
     
 }
 
+std::string DuckyKeyboardController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string DuckyKeyboardController::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 DuckyKeyboardController::SendColors
     (
     unsigned char*  color_data,
@@ -184,4 +201,4 @@ void DuckyKeyboardController::SendTerminateColorPacket()
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, (unsigned char *)usb_buf, 65);
-}
+}

Controllers/DuckyKeyboardController/DuckyKeyboardController.h

@@ -17,9 +17,12 @@
 class DuckyKeyboardController
 {
 public:
-    DuckyKeyboardController(hid_device* dev_handle);
+    DuckyKeyboardController(hid_device* dev_handle, const char* path);
     ~DuckyKeyboardController();
 
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
     void SendColors
             (
             unsigned char*  color_data,
@@ -28,6 +31,7 @@ public:
 
 private:
     hid_device*             dev;
+    std::string             location;
 
     void SendInitialize();
     void SendInitializeColorPacket();
@@ -38,4 +42,4 @@ private:
         unsigned int    color_size
         );
     void SendTerminateColorPacket();
-};
+};

Controllers/DuckyKeyboardController/DuckyKeyboardControllerDetect.cpp

@@ -2,7 +2,6 @@
 #include "DuckyKeyboardController.h"
 #include "RGBController.h"
 #include "RGBController_DuckyKeyboard.h"
-#include <vector>
 #include <hidapi/hidapi.h>
 
 /*-----------------------------------------------------*\
@@ -16,25 +15,6 @@
 #define DUCKY_SHINE_7_ONE_2_RGB_PID     0x0348
 #define DUCKY_ONE_2_RGB_TKL_PID         0x0356
 
-typedef struct
-{
-    unsigned short  usb_vid;
-    unsigned short  usb_pid;
-    unsigned char   usb_interface;
-    const char *    name;
-} ducky_device;
-
-#define DUCKY_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const ducky_device device_list[] =
-{
-    /*-----------------------------------------------------------------------------------------------------*\
-    | Keyboards                                                                                             |
-    \*-----------------------------------------------------------------------------------------------------*/
-    { DUCKY_VID,            DUCKY_SHINE_7_ONE_2_RGB_PID,        1,      "Ducky Shine 7/Ducky One 2 RGB"     },
-    { DUCKY_VID,            DUCKY_ONE_2_RGB_TKL_PID,            1,      "Ducky One 2 RGB TKL"               },
-};
-
 /******************************************************************************************\
 *                                                                                          *
 *   DetectDuckyKeyboardControllers                                                         *
@@ -43,42 +23,17 @@ static const ducky_device device_list[] =
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectDuckyKeyboardControllers(std::vector<RGBController*>& rgb_controllers)
+void DetectDuckyKeyboardControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device_info* info;
-    hid_device* dev;
-
-    hid_init();
-
-    for(std::size_t device_idx = 0; device_idx < DUCKY_NUM_DEVICES; device_idx++)
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
     {
-        dev = NULL;
-
-        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
-
-        //Look for Ducky RGB Peripheral
-        while(info)
-        {
-            if((info->vendor_id == device_list[device_idx].usb_vid)
-            &&(info->product_id == device_list[device_idx].usb_pid)
-            &&(info->interface_number == device_list[device_idx].usb_interface))
-            {
-                dev = hid_open_path(info->path);
-
-                if( dev )
-                {
-                    DuckyKeyboardController* controller = new DuckyKeyboardController(dev);
-
-                    RGBController_DuckyKeyboard* rgb_controller = new RGBController_DuckyKeyboard(controller);
-
-                    rgb_controller->name = device_list[device_idx].name;
-                    
-                    rgb_controllers.push_back(rgb_controller);
-                }
-            }
-            info = info->next;
-        }
+        DuckyKeyboardController* controller = new DuckyKeyboardController(dev, info->path);
+        RGBController_DuckyKeyboard* rgb_controller = new RGBController_DuckyKeyboard(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }   /* DetectDuckyKeyboardControllers() */
 
-REGISTER_DETECTOR("Ducky Keyboard", DetectDuckyKeyboardControllers);
+REGISTER_HID_DETECTOR_I("Ducky Shine 7/Ducky One 2 RGB", DetectDuckyKeyboardControllers, DUCKY_VID, DUCKY_SHINE_7_ONE_2_RGB_PID, 1);
+REGISTER_HID_DETECTOR_I("Ducky One 2 RGB TKL",           DetectDuckyKeyboardControllers, DUCKY_VID, DUCKY_ONE_2_RGB_TKL_PID,     1);

Controllers/DuckyKeyboardController/RGBController_DuckyKeyboard.cpp

@@ -176,8 +176,11 @@ RGBController_DuckyKeyboard::RGBController_DuckyKeyboard(DuckyKeyboardController
     ducky = ducky_ptr;
 
     name        = "Ducky Keyboard Device";
+    vendor      = "Ducky";
     type        = DEVICE_TYPE_KEYBOARD;
     description = "Ducky Keyboard Device";
+    location    = ducky->GetDeviceLocation();
+    serial      = ducky->GetSerialString();
 
     mode Direct;
     Direct.name       = "Direct";
@@ -191,7 +194,16 @@ RGBController_DuckyKeyboard::RGBController_DuckyKeyboard(DuckyKeyboardController
 
 RGBController_DuckyKeyboard::~RGBController_DuckyKeyboard()
 {
-
+    /*---------------------------------------------------------*\
+    | Delete the matrix map                                     |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    {
+        if(zones[zone_index].matrix_map != NULL)
+        {
+            delete zones[zone_index].matrix_map;
+        }
+    }
 }
 
 void RGBController_DuckyKeyboard::SetupZones()