QMK Improvements - make LEDs per update configurable

* Fix Windows include error that breaks std::min/max if a Windows header is included (tracked down to
net_port.h)

Commit amended by Adam Honse <[email protected]>

.gitlab-ci.yml

@@ -32,7 +32,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 32 AppImage":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:stretch-32
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
   stage: build
   script:
   - export $(dpkg-architecture)
@@ -51,7 +51,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 64 AppImage":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:stretch-64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
   stage: build
   script:
   - export $(dpkg-architecture)
@@ -70,7 +70,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 32 deb":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:stretch-32
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
   stage: build
   script:
   - dpkg-architecture -l
@@ -91,7 +91,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 64 deb":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:stretch-64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
   stage: build
   script:
   - dpkg-architecture -l
@@ -143,7 +143,7 @@ before_script:
   stage: build
   script:
   - apt update
-  - apt install -y build-essential qtcreator qtbase5-dev libusb-1.0-0-dev libhidapi-dev pkgconf wget git file debhelper
+  - apt install -y build-essential qtcreator qtbase5-dev libusb-1.0-0-dev libhidapi-dev libmbedtls-dev pkgconf wget git file debhelper
   - dpkg-architecture -l
   - dpkg-buildpackage --target-arch i386 -us -B
   - rm -v ../openrgb-dbgsym*.deb
@@ -166,7 +166,7 @@ before_script:
   stage: build
   script:
   - apt update
-  - apt install -y build-essential qtcreator qtbase5-dev libusb-1.0-0-dev libhidapi-dev pkgconf wget git file debhelper
+  - apt install -y build-essential qtcreator qtbase5-dev libusb-1.0-0-dev libhidapi-dev libmbedtls-dev pkgconf wget git file debhelper
   - dpkg-architecture -l
   - dpkg-buildpackage -us -B
   - rm -v ../openrgb-dbgsym*.deb
@@ -214,39 +214,39 @@ before_script:
   needs:
   - "Linux 32 deb"
 
-#-----------------------------------------------------------------------#
-# Ubuntu 32 18.04LTS test                                               #
-#-----------------------------------------------------------------------#
-"Ubuntu 32 18.04LTS":
-  image: i386/ubuntu:bionic
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
-  - openrgb --version
-  - openrgb -l
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 32 deb"
-  needs:
-  - "Linux 32 deb"
+# #-----------------------------------------------------------------------#
+# # Ubuntu 32 18.04LTS test                                               #
+# #-----------------------------------------------------------------------#
+# "Ubuntu 32 18.04LTS":
+#   image: i386/ubuntu:bionic
+#   stage: test
+#   script:
+#   - apt update
+#   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
+#   - openrgb --version
+#   - openrgb -l
+#   - apt remove -y openrgb
+#   dependencies:
+#   - "Linux 32 deb"
+#   needs:
+#   - "Linux 32 deb"
 
-#-----------------------------------------------------------------------#
-# Mint 32 19.3 test                                                     #
-#-----------------------------------------------------------------------#
-"Mint 32 20.1":
-  image: linuxmintd/mint19.3-i386
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
-  - openrgb --version
-  - openrgb -l
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 32 deb"
-  needs:
-  - "Linux 32 deb"
+# #-----------------------------------------------------------------------#
+# # Mint 32 19.3 test                                                     #
+# #-----------------------------------------------------------------------#
+# "Mint 32 20.1":
+#   image: linuxmintd/mint19.3-i386
+#   stage: test
+#   script:
+#   - apt update
+#   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
+#   - openrgb --version
+#   - openrgb -l
+#   - apt remove -y openrgb
+#   dependencies:
+#   - "Linux 32 deb"
+#   needs:
+#   - "Linux 32 deb"
 
 #-----------------------------------------------------------------------#
 # Debian 64 Buster test                                                 #
@@ -298,22 +298,22 @@ before_script:
   needs:
   - "Linux 64 rpm"
 
-#-----------------------------------------------------------------------#
-# Ubuntu 64 18.04LTS test                                               #
-#-----------------------------------------------------------------------#
-"Ubuntu 64 18.04LTS":
-  image: ubuntu:bionic
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
-  - openrgb --version
-  - openrgb -l
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 64 deb"
-  needs:
-  - "Linux 64 deb"
+# #-----------------------------------------------------------------------#
+# # Ubuntu 64 18.04LTS test                                               #
+# #-----------------------------------------------------------------------#
+# "Ubuntu 64 18.04LTS":
+#   image: ubuntu:bionic
+#   stage: test
+#   script:
+#   - apt update
+#   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
+#   - openrgb --version
+#   - openrgb -l
+#   - apt remove -y openrgb
+#   dependencies:
+#   - "Linux 64 deb"
+#   needs:
+#   - "Linux 64 deb"
 
 #-----------------------------------------------------------------------#
 # Ubuntu 64 20.04LTS test                                               #

60-openrgb.rules

@@ -65,6 +65,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18cf", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e5", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e3", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1958", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a0", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  ASUS TUF Laptops (faustus)                                   #
@@ -338,6 +339,12 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0cf2", ATTR{idProduct}=="7750", TAG+="uacces
 #  Speakers:                                                    #
 #       Logitech G560                                           #
 #                                                               #
+#  Headsets:                                                    #
+#       Logitech G933                                           #
+#                                                               #
+#  Joysticks:                                                   #
+#       Logitech Rhino X56 Hotas (Throttle and Stick)           #
+#                                                               #
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c336", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c342", TAG+="uaccess"
@@ -375,6 +382,11 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c53a", TAG+="uacces
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0a78", TAG+="uaccess"
 
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0a5b", TAG+="uaccess"
+
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0738", ATTR{idProduct}=="2221", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0738", ATTR{idProduct}=="A221", TAG+="uaccess"
+
 #---------------------------------------------------------------#
 #  Metadot Das Keyboard 4Q + 5Q                                 #
 #---------------------------------------------------------------#
@@ -456,6 +468,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2005", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2006", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2007", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2009", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="200D", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  NZXT Kraken                                                  #
@@ -614,6 +627,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1e7d", ATTR{idProduct}=="2e27", TAG+="uacces
 #  Mice:                                                        #
 #       Redragon M711 Cobra                                     #
 #       Redragon M715 Dagger                                    #
+#       Redragon M716 Inquisitor                                #
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0c45", ATTR{idProduct}=="5204", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0c45", ATTR{idProduct}=="5104", TAG+="uaccess"
@@ -622,6 +636,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}=="fc3a", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="fc4d", TAG+="uaccess"
 
 #---------------------------------------------------------------#
@@ -665,7 +680,8 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="054c", ATTR{idProduct}=="0ba0", TAG+="uacces
 #       SteelSeries Rival 300 Blackops Edition                  #
 #       SteelSeries Rival 310                                   #
 #       SteelSeries Rival 310 CS:GO Howl Edition                #
-#       SteelSeries Rival 310 PubG Edition                      #
+#       SteelSeries Rival 310 PubG Edition			#
+#	SteelSeries Rival 650 Wireless		                #
 #       SteelSeries Rival Sensei Ten                            #
 #       SteelSeries Rival Sensei Ten CS:GO Neon Rider           #
 #       SteelSeries Rival Sensei 310                            #
@@ -700,6 +716,8 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1736", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1832", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1834", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1722", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1726", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="172B", TAG+="uaccess"
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1229", TAG+="uaccess"
 

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -52,7 +52,12 @@ char* AMDWraithPrismController::GetDeviceName()
 std::string AMDWraithPrismController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.cpp

@@ -10,6 +10,7 @@
 #include "ASRockPolychromeSMBusController.h"
 #include <cstring>
 #include "dependencies/dmiinfo.h"
+#include "LogManager.h"
 
 using namespace std::chrono_literals;
 
@@ -20,36 +21,39 @@ PolychromeController::PolychromeController(i2c_smbus_interface* bus, polychrome_
 
     DMIInfo dmi;
 
-    unsigned short fw_version    = ReadFirmwareVersion();
-    unsigned char  major_version = fw_version >> 8;
+    device_name =   "ASRock " + dmi.getMainboard();
+    fw_version =    ReadFirmwareVersion();
+    unsigned char   major_version = fw_version >> 8;
 
     /*-----------------------------------------------------*\
     | Determine whether the device uses ASR LED or          |
     | Polychrome protocol by checking firmware version.     |
-    | Versions 1.xx and 2.xx use ASR LED, 3.xx uses         |
-    | Polychrome                                            |
+    | Versions: 1.xx are ASR RGB LED                        |
+    |           2.xx are Polychrome v1                      |
+    |           3.xx are Polychrome v2                      |
     \*-----------------------------------------------------*/
     switch(major_version)
     {
         case ASROCK_TYPE_ASRLED:
-            device_name = "ASRock " + dmi.getMainboard();
+            LOG_DEBUG("Device type is ASR RGB LED");
             asrock_type = ASROCK_TYPE_ASRLED;
             memset(zone_led_count, 0, sizeof(zone_led_count));
             break;
 
         case ASROCK_TYPE_POLYCHROME_V1:
-            device_name = "ASRock " + dmi.getMainboard();
+            LOG_DEBUG("Device type is Polychrome v1");
             asrock_type = ASROCK_TYPE_POLYCHROME_V1;
             ReadLEDConfiguration();
             break;
 
         case ASROCK_TYPE_POLYCHROME_V2:
-            device_name = "ASRock " + dmi.getMainboard();
+            LOG_DEBUG("Device type is Polychrome v2");
             asrock_type = ASROCK_TYPE_POLYCHROME_V2;
             ReadLEDConfiguration();
             break;
 
         default:
+            LOG_DEBUG("Got Unknown version!");
             asrock_type = ASROCK_TYPE_UNKNOWN;
             break;
     }
@@ -82,7 +86,6 @@ std::string PolychromeController::GetDeviceName()
 
 std::string PolychromeController::GetFirmwareVersion()
 {
-    unsigned short fw_version    = ReadFirmwareVersion();
     unsigned char  major_version = fw_version >> 8;
     unsigned char  minor_version = fw_version & 0xFF;
 
@@ -93,17 +96,20 @@ unsigned short PolychromeController::ReadFirmwareVersion()
 {
     // The firmware register holds two bytes, so the first read should return 2
     // If not, report invalid firmware revision FFFF
-    if (bus->i2c_smbus_read_byte_data(dev, ASROCK_REG_FIRMWARE_VER) == 0x02)
+    LOG_DEBUG("Reading back device firmware version");
+    // Version response array needs to be 32 bytes to prevent non ASRock board from stack smashing
+    unsigned char asrock_version[I2C_SMBUS_BLOCK_MAX] = { 0x00, 0x00 };
+    if (bus->i2c_smbus_read_block_data(dev, ASROCK_REG_FIRMWARE_VER, asrock_version) == 0x02)
     {
-        std::this_thread::sleep_for(1ms);
-        unsigned char major = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
-        unsigned char minor = bus->i2c_smbus_read_byte(dev);
+        unsigned char major = asrock_version[0];
+        unsigned char minor = asrock_version[1];
 
+        LOG_DEBUG("Device firmware version: v%02d.%02d", major, minor);
         return((major << 8) | minor);
     }
     else
     {
+        LOG_WARNING("Firmware readback failed; Returning 0xFFFF");
         return(0xFFFF);
     }
 }
@@ -114,23 +120,26 @@ void PolychromeController::ReadLEDConfiguration()
     | The LED configuration register holds 6 bytes, so the first read should return 6   |
     | If not, set all zone sizes to zero                                                |
     \*---------------------------------------------------------------------------------*/
-    if (bus->i2c_smbus_read_byte_data(dev, POLYCHROME_REG_LED_CONFIG) == 0x06)
+    LOG_DEBUG("Reading back LED config");
+    unsigned char asrock_zone_count[I2C_SMBUS_BLOCK_MAX] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
+    if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_REG_LED_CONFIG, asrock_zone_count) == 0x06)
     {
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_1]           = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_2]           = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_3]           = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_4]           = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_5]           = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_ADDRESSABLE] = bus->i2c_smbus_read_byte(dev);
+        zone_led_count[POLYCHROME_ZONE_1]           = asrock_zone_count[0];
+        zone_led_count[POLYCHROME_ZONE_2]           = asrock_zone_count[1];
+        zone_led_count[POLYCHROME_ZONE_3]           = asrock_zone_count[2];
+        zone_led_count[POLYCHROME_ZONE_4]           = asrock_zone_count[3];
+        zone_led_count[POLYCHROME_ZONE_5]           = asrock_zone_count[4];
+        zone_led_count[POLYCHROME_ZONE_ADDRESSABLE] = asrock_zone_count[5];
+        LOG_DEBUG("Zone 1 LED count: %02d", zone_led_count[POLYCHROME_ZONE_1]);
+        LOG_DEBUG("Zone 2 LED count: %02d", zone_led_count[POLYCHROME_ZONE_2]);
+        LOG_DEBUG("Zone 3 LED count: %02d", zone_led_count[POLYCHROME_ZONE_3]);
+        LOG_DEBUG("Zone 4 LED count: %02d", zone_led_count[POLYCHROME_ZONE_4]);
+        LOG_DEBUG("Zone 5 LED count: %02d", zone_led_count[POLYCHROME_ZONE_5]);
+        LOG_DEBUG("Addressable Zone LED count: %02d", zone_led_count[POLYCHROME_ZONE_ADDRESSABLE]);
     }
     else
     {
+        LOG_WARNING("LED config read failed");
         memset(zone_led_count, 0, sizeof(zone_led_count));
     }
 }

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.h

@@ -209,6 +209,7 @@ public:
     
 private:
     unsigned int            asrock_type;
+    unsigned short          fw_version;
     std::string             device_name;
     unsigned char           active_zone;
     unsigned char           active_mode;

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusControllerDetect.cpp

@@ -1,5 +1,6 @@
 #include "Detector.h"
 #include "ASRockPolychromeSMBusController.h"
+#include "LogManager.h"
 #include "RGBController.h"
 #include "RGBController_ASRockPolychromeSMBus.h"
 #include "i2c_smbus.h"
@@ -56,15 +57,18 @@ void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
             // Check for Polychrome controller at 0x6A
             if (TestForPolychromeSMBusController(busses[bus], 0x6A))
             {
+                LOG_DEBUG("Detected a device at address 0x6A, Testing for a known controller");
                 new_polychrome = new PolychromeController(busses[bus], 0x6A);
 
                 if(new_polychrome->GetASRockType() != ASROCK_TYPE_UNKNOWN)
                 {
+                    LOG_DEBUG("Found a known Polychrome device");
                     new_controller = new RGBController_Polychrome(new_polychrome);
                     ResourceManager::get()->RegisterRGBController(new_controller);
                 }
                 else
                 {
+                    LOG_DEBUG("Not a Polychrome device or unknown type");
                     delete new_polychrome;
                 }
             }

Controllers/ASRockPolychromeSMBusController/RGBController_ASRockPolychromeSMBus.cpp

@@ -46,7 +46,7 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
     {
         case ASROCK_TYPE_ASRLED:
             {
-                description = "ASRock ASR LED Device";
+                description = "ASRock ASR RGB LED Device";
 
                 mode Off;
                 Off.name                    = "Off";

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -54,8 +54,13 @@ std::string PolychromeUSBController::GetDeviceName()
 std::string PolychromeUSBController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
 
+    if(ret != 0)
+    {
+        return("");
+    }
+    
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());
 

Controllers/AnnePro2Controller/AnnePro2Controller.cpp

@@ -0,0 +1,122 @@
+/*-----------------------------------------*\
+|  AnnePro2Controller.cpp                   |
+|                                           |
+|  Driver for Obins Lab AnnePro2 keyboard   |
+|                                           |
+|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
+\*-----------------------------------------*/
+
+#include "AnnePro2Controller.h"
+
+using namespace std::chrono_literals;
+
+AnnePro2Controller::AnnePro2Controller(hid_device* dev_handle, const char* path) 
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+AnnePro2Controller::~AnnePro2Controller() 
+{
+    hid_close(dev);
+}
+
+std::string AnnePro2Controller::GetDeviceLocation() 
+{
+    return("HID: " + location);
+}
+
+std::string AnnePro2Controller::GetSerialString() 
+{
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+void AnnePro2Controller::SendDirect(unsigned char frame_count, unsigned char * frame_data) 
+{
+    /*-------------------------------------------------------------*\
+    | Reverse engineered by https://github.com/manualmanul/Annemone |
+    \*-------------------------------------------------------------*/
+
+    const unsigned char hid_cmd_service_data_length                             = 4;
+    const unsigned char hid_cmd_service_data[hid_cmd_service_data_length]       = {0, 123, 16, 65};
+
+    const unsigned char hid_cmd_static_message_length                           = 3;
+    const unsigned char hid_cmd_static_message[hid_cmd_static_message_length]   = {0, 0, 125};
+
+    const unsigned char hid_cmd_command_info_length                             = 3;
+    const unsigned char hid_cmd_command_info[hid_cmd_command_info_length]       = {32, 3, 255};
+
+    const unsigned char real_command_info_length                                = hid_cmd_command_info_length + 1;
+    const unsigned char max_hid_length                                          = 64;
+
+    const unsigned char max_command_length                                      = max_hid_length - hid_cmd_service_data_length - 2 - hid_cmd_static_message_length;
+    const unsigned char max_message_length                                      = max_command_length - real_command_info_length;
+    const unsigned char messages_to_send_amount                                 = frame_count / max_message_length + 1;
+    const unsigned char val_1                                                   = frame_count % max_message_length;
+    const unsigned char val_2                                                   = (0 == val_1) ? max_message_length : val_1;
+
+    unsigned char hid_command[max_hid_length];
+
+    unsigned char led_data = 0;
+
+    for(unsigned char p = 0; p < messages_to_send_amount; p++)
+    {
+        const unsigned char e = (messages_to_send_amount << 4) + p;
+        const unsigned char a = ((messages_to_send_amount - 1) == p) ? val_2 + real_command_info_length : max_message_length + real_command_info_length;
+        
+        /*---------------------------------------------------------*\
+        | Service data                                              |
+        \*---------------------------------------------------------*/
+        hid_command[0] = hid_cmd_service_data[0];
+        hid_command[1] = hid_cmd_service_data[1];
+        hid_command[2] = hid_cmd_service_data[2];
+        hid_command[3] = hid_cmd_service_data[3];
+
+        hid_command[4] = e;
+        hid_command[5] = a;
+
+        /*---------------------------------------------------------*\
+        | Static message                                            |
+        \*---------------------------------------------------------*/
+        hid_command[6] = hid_cmd_static_message[0];
+        hid_command[7] = hid_cmd_static_message[1];
+        hid_command[8] = hid_cmd_static_message[2];
+
+        /*---------------------------------------------------------*\
+        | Command info                                              |
+        \*---------------------------------------------------------*/
+        hid_command[9] = hid_cmd_command_info[0];
+        hid_command[10] = hid_cmd_command_info[1];
+        hid_command[11] = hid_cmd_command_info[2];
+
+        hid_command[12] = 2;
+
+        /*---------------------------------------------------------*\
+        | LED data                                                  |
+        \*---------------------------------------------------------*/
+        for(uint8_t i = 0; i < max_message_length; i++)
+        {
+            hid_command[13 + i] = frame_data[led_data];
+            led_data++;
+        }
+
+        hid_write(dev, hid_command, max_hid_length);
+
+        /*---------------------------------------------------------*\
+        | Needed due to Anne Pro 2 ignoring commands when they're   |
+        | sent faster than 50ms apart from each other.              |
+        \*---------------------------------------------------------*/
+        std::this_thread::sleep_for(50ms);
+    }
+}

Controllers/AnnePro2Controller/AnnePro2Controller.h

@@ -0,0 +1,36 @@
+/*-----------------------------------------*\
+|  AnnePro2Controller.h                     |
+|                                           |
+|  Driver for Obins Lab AnnePro2 keyboard   |
+|                                           |
+|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+
+#include <string>
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+class AnnePro2Controller
+{
+public:
+    AnnePro2Controller(hid_device* dev_handle, const char* path);
+    ~AnnePro2Controller();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void SendDirect
+        (
+        unsigned char       frame_count,
+        unsigned char *     frame_data
+        );
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+};

Controllers/AnnePro2Controller/AnnePro2ControllerDetect.cpp

@@ -0,0 +1,36 @@
+#include "Detector.h"
+#include "AnnePro2Controller.h"
+#include "RGBController.h"
+#include "RGBController_AnnePro2.h"
+#include <hidapi/hidapi.h>
+
+#define ANNE_PRO_2_VID 0x04D9
+#define ANNE_PRO_2_PID_1 0x8008
+#define ANNE_PRO_2_PID_2 0x8009
+#define ANNE_PRO_2_PID_3 0xA292
+#define ANNE_PRO_2_PID_4 0xA293
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAnnePro2Controllers                                                              *
+*                                                                                          *
+*       Tests the USB address to see if an Obins Lab AnnePro2 keyboard exists there.       *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
+    {
+        AnnePro2Controller*     controller     = new AnnePro2Controller(dev, info->path);
+        RGBController_AnnePro2* rgb_controller = new RGBController_AnnePro2(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_1, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_2, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_3, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_4, 1);

Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp

@@ -0,0 +1,235 @@
+/*-----------------------------------------*\
+|  RGBController_AnnePro2.cpp               |
+|                                           |
+|  Generic RGB Interface for Obins Lab      |
+|  AnnePro2 keyboard                        |
+|                                           |
+|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
+\*-----------------------------------------*/
+
+#include "RGBController_AnnePro2.h"
+
+#define NA              0xFFFFFFFF
+#define LED_REAL_COUNT  (5*14)
+#define LED_COUNT       (LED_REAL_COUNT - 9)
+
+static unsigned int matrix_map[5][14] =
+    { { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13 },
+      { 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27 },
+      { 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, NA },
+      { 41, NA, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, NA }, 
+      { 53, NA, 54, 55, NA, NA, 56, NA, NA, 57, 58, 59, 60, NA } };
+
+static const char* zone_names[] =
+{
+    "Keyboard",
+};
+
+static zone_type zone_types[] =
+{
+    ZONE_TYPE_MATRIX
+};
+
+static const unsigned int zone_sizes[] =
+{
+    LED_COUNT,
+};
+
+typedef struct
+{
+    const char *        name;
+    const unsigned char idx;
+} led_type;
+
+static const led_type led_names[] =
+{
+    /* Key Label                Index  */
+    { "Key: Escape",            0       },
+    { "Key: 1",                 1       },
+    { "Key: 2",                 2       },
+    { "Key: 3",                 3       },
+    { "Key: 4",                 4       },
+    { "Key: 5",                 5       },
+    { "Key: 6",                 6       },
+    { "Key: 7",                 7       },
+    { "Key: 8",                 8       },
+    { "Key: 9",                 9       },
+    { "Key: 0",                 10      },
+    { "Key: -",                 11      },
+    { "Key: =",                 12      },
+    { "Key: Backspace",         13      },
+    { "Key: Tab",               14      },
+    { "Key: Q",                 15      },
+    { "Key: W",                 16      },
+    { "Key: E",                 17      },
+    { "Key: R",                 18      },
+    { "Key: T",                 19      },
+    { "Key: Y",                 20      },
+    { "Key: U",                 21      },
+    { "Key: I",                 22      },
+    { "Key: O",                 23      },
+    { "Key: P",                 24      },
+    { "Key: [",                 25      },
+    { "Key: ]",                 26      },
+    { "Key: \\ (ANSI)",         27      },
+    { "Key: Caps Lock",         28      },
+    { "Key: A",                 29      },
+    { "Key: S",                 30      },
+    { "Key: D",                 31      },
+    { "Key: F",                 32      },
+    { "Key: G",                 33      },
+    { "Key: H",                 34      },
+    { "Key: J",                 35      },
+    { "Key: K",                 36      },
+    { "Key: L",                 37      },
+    { "Key: ;",                 38      },
+    { "Key: '",                 39      },
+    { "Key: Enter",             40      },
+    { "Key: Left Shift",        41      },
+    { "Key: Z",                 42      },
+    { "Key: X",                 43      },
+    { "Key: C",                 44      },
+    { "Key: V",                 45      },
+    { "Key: B",                 46      },
+    { "Key: N",                 47      },
+    { "Key: M",                 48      },
+    { "Key: ,",                 49      },
+    { "Key: .",                 50      },
+    { "Key: /",                 51      },
+    { "Key: Right Shift",       52      },
+    { "Key: Left Control",      53      },
+    { "Key: Left Windows",      54      },
+    { "Key: Left Alt",          55      },
+    { "Key: Space",             56      },
+    { "Key: Right Alt",         57      },
+    { "Key: Right Fn",          58      },
+    { "Key: Menu",              59      },
+    { "Key: Right Control",     60      },
+};
+
+RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* annepro2_ptr) 
+{
+    annepro2    = annepro2_ptr;
+
+    name        = "Anne Pro 2";
+    vendor      = "Obinslab";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "Obinslab Anne Pro 2 Device";
+    location    = annepro2->GetDeviceLocation();
+    serial      = annepro2->GetSerialString();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+}
+
+RGBController_AnnePro2::~RGBController_AnnePro2() 
+{
+    delete annepro2;
+}
+
+void RGBController_AnnePro2::SetupZones() 
+{
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    unsigned int total_led_count = 0;
+    for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
+    {
+        zone new_zone;
+        new_zone.name                   = zone_names[zone_idx];
+        new_zone.type                   = zone_types[zone_idx];
+        new_zone.leds_min               = zone_sizes[zone_idx];
+        new_zone.leds_max               = zone_sizes[zone_idx];
+        new_zone.leds_count             = zone_sizes[zone_idx];
+
+        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
+        {
+            new_zone.matrix_map         = new matrix_map_type;
+            new_zone.matrix_map->height = 5;
+            new_zone.matrix_map->width  = 14;
+            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+        }
+        else
+        {
+            new_zone.matrix_map         = NULL;
+        }
+
+        zones.push_back(new_zone);
+
+        total_led_count += zone_sizes[zone_idx];
+    }
+
+    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
+    {
+        led new_led;
+        new_led.name  = led_names[led_idx].name;
+        new_led.value = led_names[led_idx].idx;
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AnnePro2::ResizeZone(int /*zone*/, int /*new_size*/) 
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AnnePro2::DeviceUpdateLEDs() 
+{
+    const unsigned char frame_buf_length = LED_REAL_COUNT * 3;
+    unsigned char frame_buf[frame_buf_length];
+
+    /*---------------------------------------------------------*\
+    | TODO: Send packets with multiple LED frames               |
+    \*---------------------------------------------------------*/
+    std::size_t led_real_idx = 0;
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        frame_buf[(led_real_idx * 3) + 0] = RGBGetRValue(colors[led_idx]);
+        frame_buf[(led_real_idx * 3) + 1] = RGBGetGValue(colors[led_idx]);
+        frame_buf[(led_real_idx * 3) + 2] = RGBGetBValue(colors[led_idx]);
+
+        if(led_idx == 40 || led_idx == 41 || led_idx == 52 || led_idx == 53 || led_idx == 60)
+        {
+            led_real_idx++;
+        }
+        else if(led_idx == 55 || led_idx == 56)
+        {
+            led_real_idx++;
+            led_real_idx++;
+        }
+
+        led_real_idx++;
+    }
+
+    annepro2->SendDirect(frame_buf_length, frame_buf);
+}
+
+void RGBController_AnnePro2::UpdateZoneLEDs(int /*zone*/) 
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AnnePro2::UpdateSingleLED(int /*led*/) 
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AnnePro2::SetCustomMode() 
+{
+    active_mode = 0;
+}
+
+void RGBController_AnnePro2::DeviceUpdateMode() 
+{
+    
+}

Controllers/AnnePro2Controller/RGBController_AnnePro2.h

@@ -0,0 +1,32 @@
+/*-----------------------------------------*\
+|  RGBController_AnnePro2.h                 |
+|                                           |
+|  Generic RGB Interface for Obins Lab      |
+|  AnnePro2 keyboard                        |
+|                                           |
+|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AnnePro2Controller.h"
+
+class RGBController_AnnePro2 : public RGBController
+{
+public:
+    RGBController_AnnePro2(AnnePro2Controller* annepro2_ptr);
+    ~RGBController_AnnePro2();
+
+    void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    AnnePro2Controller*   annepro2;
+};

Controllers/AsusAuraCoreController/AsusAuraCoreController.cpp

@@ -40,7 +40,12 @@ std::string AuraCoreController::GetDeviceLocation()
 std::string AuraCoreController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -33,17 +33,24 @@ typedef struct
 static const gpu_pci_device device_list[] =
 {
     { NVIDIA_VEN,       NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,       ASUS_GTX1060_STRIX,                     0x29,   "ASUS GTX 1060 Strix"                       },
-    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX,                     0x29,   "ASUS GTX 1070 Strix OC"                    },
+    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_GAMING,              0x29,   "ASUS GTX 1070 Strix Gaming"                },
+    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_OC,                  0x29,   "ASUS GTX 1070 Strix OC"                    },
     { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_GTX1080_STRIX,                     0x29,   "ASUS GTX 1080 Strix OC"                    },
     { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_A8G_GAMING,      0x29,   "ASUS ROG Strix GTX1080 A8G Gaming"         },
+    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_O8G_GAMING,      0x29,   "ASUS ROG Strix GTX1080 O8G Gaming"         },
     { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_GAMING,        0x29,   "ASUS ROG Strix GTX1080 Ti Gaming"          },
     { NVIDIA_VEN,       NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_GTX1660TI_OC,                  0x2A,   "ASUS ROG GTX 1660 Ti OC 6G"                },
     { NVIDIA_VEN,       NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_EVO_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2060 EVO Gaming 6G"     },
+    { NVIDIA_VEN,       NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING, 0x2A,   "ASUS ROG STRIX RTX 2060S A8G EVO Gaming 6G"},
+    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_A8G_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2070 A8G Gaming 8G"     },
+    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_O8G_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2070 O8G Gaming 8G"     },
     { NVIDIA_VEN,       NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,     0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
+    { NVIDIA_VEN,       NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,     0x2A,   "ASUS ROG STRIX RTX 2070S O8G Gaming 8G"    },
     { NVIDIA_VEN,       NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080_O8G_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2080 O8G Gaming"        },
     { NVIDIA_VEN,       NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,   0x2A,   "ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    },
     { AMD_GPU_VEN,      AMD_VEGA10_DEV,             ASUS_SUB_VEN,       ASUS_VEGA64_STRIX,                      0x29,   "ASUS Vega 64 Strix"                        },
     { AMD_GPU_VEN,      AMD_NAVI10_DEV,             ASUS_SUB_VEN,       ASUS_RX5700XT_STRIX_GAMING_OC,          0x2A,   "ASUS RX 5700XT Strix Gaming OC"            },
+    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX570_STRIX_O4G_GAMING_OC,         0x29,   "ASUS RX 570 Strix O4G Gaming OC"           },
     { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX580_STRIX_GAMING_OC,             0x29,   "ASUS RX 580 Strix Gaming OC"               }
 };  
 

Controllers/AsusAuraSMBusController/AsusAuraSMBusController.cpp

@@ -207,7 +207,7 @@ void AuraSMBusController::SetAllColorsDirect(RGBColor* colors)
 
     AuraRegisterWriteBlock(direct_reg, color_buf, led_count * 3);
 
-    delete color_buf;
+    delete[] color_buf;
 }
 
 void AuraSMBusController::SetAllColorsEffect(RGBColor* colors)

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.cpp

@@ -0,0 +1,133 @@
+/*-----------------------------------------*\
+|  AsusAuraHeadsetStandController.cpp       |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Mola19 06/04/2021                        |
+\*-----------------------------------------*/
+
+#include "AsusAuraHeadsetStandController.h"
+
+#include <cstring>
+
+AuraHeadsetStandController::AuraHeadsetStandController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+AuraHeadsetStandController::~AuraHeadsetStandController()
+{
+	hid_close(dev);
+}
+
+std::string AuraHeadsetStandController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AuraHeadsetStandController::GetSerialString()
+{
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+void AuraHeadsetStandController::UpdateLeds
+    (
+    std::vector<RGBColor>    colors
+    )
+{
+    unsigned char usb_buf_0[365];
+
+    memset(usb_buf_0, 0x00, sizeof(usb_buf_0));
+
+    usb_buf_0[0x00]   = 0x00;
+    usb_buf_0[0x01]   = 0xC0;
+    usb_buf_0[0x02]   = 0x81;
+    usb_buf_0[0x03]   = 0x00;
+    usb_buf_0[0x04]   = 0x00;
+
+    for(unsigned int i = 0; i < 60; i += 4)
+    {
+        usb_buf_0[5 + i]   = 0x00;
+        usb_buf_0[6 + i]   = RGBGetRValue(colors[i / 4]);
+        usb_buf_0[7 + i]   = RGBGetGValue(colors[i / 4]);
+        usb_buf_0[8 + i]   = RGBGetBValue(colors[i / 4]);
+    }
+
+    hid_write(dev, usb_buf_0, 65);
+
+    unsigned char usb_buf_1[65];
+
+    memset(usb_buf_1, 0x00, sizeof(usb_buf_1));
+
+    usb_buf_1[0x00]   = 0x00;
+    usb_buf_1[0x01]   = 0xC0;
+    usb_buf_1[0x02]   = 0x81;
+    usb_buf_1[0x03]   = 0x01;
+    usb_buf_1[0x04]   = 0x00;
+
+    for(unsigned int i = 0; i < 12; i += 4)
+    {
+        usb_buf_1[5 + i]   = 0x00;
+        usb_buf_1[6 + i]   = RGBGetRValue(colors[(i / 4) + 15]);
+        usb_buf_1[7 + i]   = RGBGetGValue(colors[(i / 4) + 15]);
+        usb_buf_1[8 + i]   = RGBGetBValue(colors[(i / 4) + 15]);
+    }
+
+    hid_write(dev, usb_buf_1, 65);
+}
+
+void AuraHeadsetStandController::UpdateDevice
+    (
+    unsigned char   mode,
+    unsigned char   red,
+    unsigned char   grn,
+    unsigned char   blu,
+    unsigned char   speed,
+    bool            save
+    )
+{
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x51;
+    usb_buf[0x02]   = 0x28;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = 0x00;
+    usb_buf[0x05]   = mode;
+    usb_buf[0x06]   = speed;
+    usb_buf[0x07]   = 0x04;
+    usb_buf[0x08]   = 0x00;
+    usb_buf[0x09]   = 0x00;
+    usb_buf[0x0a]   = red;
+    usb_buf[0x0b]   = grn;
+    usb_buf[0x0c]   = blu;
+    hid_write(dev, usb_buf, 65);
+
+    if(save)
+    {
+        unsigned char usb_save_buf[65];
+
+        memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
+        
+        usb_save_buf[0x00]   = 0x00;
+        usb_save_buf[0x01]   = 0x50;
+        usb_save_buf[0x02]   = 0x55;
+        
+        hid_write(dev, usb_save_buf, 65);
+    }
+}

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.h

@@ -0,0 +1,59 @@
+/*-----------------------------------------*\
+|  AsusAuraHeadsetStandController.h         |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Mola19 06/04/2021                        |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    AURA_HEADSET_STAND_ZONE_UNDERGLOW   = 0,
+    AURA_HEADSET_STAND_ZONE_LOGO        = 1
+};
+
+enum
+{
+    AURA_HEADSET_STAND_MODE_DIRECT      = 0,
+    AURA_HEADSET_STAND_MODE_STATIC      = 1,
+    AURA_HEADSET_STAND_MODE_BREATHING   = 2,
+    AURA_HEADSET_STAND_MODE_STROBING    = 3,
+    AURA_HEADSET_STAND_MODE_COLOR_CYCLE = 4,
+    AURA_HEADSET_STAND_MODE_RAINBOW     = 5
+};
+
+class AuraHeadsetStandController
+{
+public:
+    AuraHeadsetStandController(hid_device* dev_handle, const char* path);
+    virtual ~AuraHeadsetStandController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void UpdateLeds
+        (
+        std::vector<RGBColor>    colors
+        );
+
+    void UpdateDevice
+        (
+        unsigned char   mode,
+        unsigned char   red,
+        unsigned char   grn,
+        unsigned char   blu,
+        unsigned char   speed,
+        bool            save
+        );
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+};

Controllers/AsusAuraUSBController/AsusAuraKeyboardController.cpp

@@ -30,7 +30,12 @@ std::string AuraKeyboardController::GetDeviceLocation()
 std::string AuraKeyboardController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp

@@ -30,7 +30,12 @@ std::string AuraMouseController::GetDeviceLocation()
 std::string AuraMouseController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp

@@ -0,0 +1,218 @@
+/*-----------------------------------------*\
+|  AsusAuraTUFKeyboardController.cpp        |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Mola19 03/03/2021                        |
+\*-----------------------------------------*/
+
+#include "AsusAuraTUFKeyboardController.h"
+
+#include <cstring>
+#include <string>
+#include <vector>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+
+AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+AuraTUFKeyboardController::~AuraTUFKeyboardController()
+{
+    hid_close(dev);
+}
+
+std::string AuraTUFKeyboardController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AuraTUFKeyboardController::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 AuraTUFKeyboardController::UpdateSingleLed
+    (
+    int             led,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    /*-----------------------------------------------------*\
+    | Set up message packet for single LED                  |
+    \*-----------------------------------------------------*/
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0] = 0x00;
+    usb_buf[1] = 0xc0;
+    usb_buf[2] = 0x81;
+    usb_buf[3] = 0x01;
+    usb_buf[4] = 0x00;
+
+    /*-----------------------------------------------------*\
+    | Convert LED index                                     |
+    \*-----------------------------------------------------*/
+    usb_buf[5] = floor(led/6)*8 + led%6;
+    usb_buf[6] = red;
+    usb_buf[7] = green;
+    usb_buf[8] = blue;
+
+    hid_write(dev, usb_buf, 65);
+}
+
+void AuraTUFKeyboardController::UpdateLeds
+    (
+    std::vector<RGBColor>    colors
+    )
+{
+    /*-----------------------------------------------------*\
+    | Loop over every column (optimisation needed)          |
+    \*-----------------------------------------------------*/
+    for(unsigned int i = 0; i < 192; i += 16)
+    {
+        unsigned char usb_buf[69];
+
+        memset(usb_buf, 0x00, sizeof(usb_buf));
+
+        usb_buf[0] = 0x00;
+        usb_buf[1] = 0xc0;
+        usb_buf[2] = 0x81;
+        usb_buf[3] = (138 - i / 16 * 12);
+        usb_buf[4] = 0x00;
+
+        for(unsigned int n = 0; n < 6; n++)
+        {
+            usb_buf[n * 4 + 5] = i + n;
+            usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n]);
+            usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n]);
+            usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n]);
+        }
+
+        for(unsigned int n = 6; n < 8; n++)
+        {
+            usb_buf[n * 4 + 5] = i + n;
+            usb_buf[n * 4 + 6] = 0;
+            usb_buf[n * 4 + 7] = 0;
+            usb_buf[n * 4 + 8] = 0;
+        }
+
+        if(i != 176)
+        {
+            for(unsigned int n = 8; n < 14; n++)
+            {
+                usb_buf[n * 4 + 5] = i + n;
+                usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n-2]);
+                usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n-2]);
+                usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n-2]);
+            }
+
+            for(unsigned int n = 14; n < 16; n++)
+            {
+                usb_buf[n * 4 + 5] = i + n;
+                usb_buf[n * 4 + 6] = 0;
+                usb_buf[n * 4 + 7] = 0;
+                usb_buf[n * 4 + 8] = 0;
+            }
+        }
+
+        hid_write(dev, usb_buf, 69);
+    }
+}
+
+void AuraTUFKeyboardController::UpdateDevice
+    (
+    unsigned char           mode,
+    std::vector<RGBColor>   colors,
+    unsigned char           dir,
+    unsigned char           color_mode,
+    unsigned char           speed
+    )
+{
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x51;
+    usb_buf[0x02]   = 0x2C;
+    usb_buf[0x03]   = mode;
+    usb_buf[0x04]   = 0x00;
+    usb_buf[0x05]   = speed;
+    usb_buf[0x06]   = 0x64;
+    usb_buf[0x07]   = color_mode;
+    usb_buf[0x08]   = dir;
+    usb_buf[0x09]   = 0x02;
+
+	if(mode == 4 || mode == 5)
+	{
+	    /*-----------------------------------------------------*\
+        | If mode is Rainbow or Ripple                          |
+	    \*-----------------------------------------------------*/
+	    usb_buf[0x0A]   = colors.size();
+
+	    /*-----------------------------------------------------*\
+	    | Loop over every color given                           |
+	    \*-----------------------------------------------------*/
+        for(unsigned int i = 0; i / 4 < colors.size(); i += 4)
+        {
+            if(colors[i / 4])
+            {
+                usb_buf[11 + i] = 100/(double)colors.size()*(i/4+1);
+                usb_buf[12 + i] = RGBGetRValue(colors[i/4]);
+                usb_buf[13 + i] = RGBGetGValue(colors[i/4]);
+                usb_buf[14 + i] = RGBGetBValue(colors[i/4]);
+            }
+        }
+	}
+    else
+    {
+	    /*-----------------------------------------------------*\
+	    | Loop over Color1, Color2 and Background if there      |
+	    \*-----------------------------------------------------*/
+	    for(unsigned int i = 0; i / 3 != colors.size(); i += 3)
+        {
+            if(colors[i / 3])
+            {
+                usb_buf[10 + i] = RGBGetRValue(colors[i/3]);
+                usb_buf[11 + i] = RGBGetGValue(colors[i/3]);
+                usb_buf[12 + i] = RGBGetBValue(colors[i/3]);
+            }
+        }
+			
+	}
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Set up and send packet save Packet                    |
+    \*-----------------------------------------------------*/
+    unsigned char usb_save_buf[65];
+
+    memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
+
+    usb_save_buf[0x00]   = 0x00;
+    usb_save_buf[0x01]   = 0x50;
+    usb_save_buf[0x02]   = 0x55;
+    
+    hid_write(dev, usb_save_buf, 65);
+}
+

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h

@@ -0,0 +1,76 @@
+/*-----------------------------------------*\
+|  AsusAuraTUFKeyboardController.h          |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Mola19 03/03/2021                        |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    AURA_KEYBOARD_ZONE_LOGO         = 0,
+    AURA_KEYBOARD_ZONE_SCROLL       = 1,
+    AURA_KEYBOARD_ZONE_UNDERGLOW    = 2,
+    AURA_KEYBOARD_ZONE_ALL          = 3,
+};
+
+enum
+{
+    AURA_KEYBOARD_MODE_STATIC       =  0,
+    AURA_KEYBOARD_MODE_BREATHING    =  1,
+    AURA_KEYBOARD_MODE_COLOR_CYCLE  =  2,
+    AURA_KEYBOARD_MODE_REACTIVE     =  3,
+    AURA_KEYBOARD_MODE_WAVE         =  4,
+    AURA_KEYBOARD_MODE_RIPPLE       =  5,
+    AURA_KEYBOARD_MODE_STARRY_NIGHT =  6,
+    AURA_KEYBOARD_MODE_QUICKSAND    =  7,
+    AURA_KEYBOARD_MODE_CURRENT      =  8,
+    AURA_KEYBOARD_MODE_RAIN_DROP    =  9,
+    AURA_KEYBOARD_MODE_DIRECT       = 15,
+};
+
+class AuraTUFKeyboardController
+{
+public:
+    AuraTUFKeyboardController(hid_device* dev_handle, const char* path);
+    ~AuraTUFKeyboardController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void UpdateSingleLed
+        (
+        int             led,
+        unsigned char   red,
+        unsigned char   green,
+        unsigned char   blue
+        );
+
+	void UpdateLeds
+        (
+        std::vector<RGBColor>    colors
+        );
+
+    void UpdateDevice
+        (
+        unsigned char           mode,
+        std::vector<RGBColor>   colors,
+        unsigned char           dir,
+        unsigned char           color_mode,
+        unsigned char           speed
+        );
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+};
+

Controllers/AsusAuraUSBController/AsusAuraUSBController.cpp

@@ -42,7 +42,12 @@ std::string AuraUSBController::GetDeviceName()
 std::string AuraUSBController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -1,11 +1,15 @@
 #include "Detector.h"
 #include "AsusAuraAddressableController.h"
+#include "AsusAuraHeadsetStandController.h"
 #include "AsusAuraKeyboardController.h"
+#include "AsusAuraTUFKeyboardController.h"
 #include "AsusAuraMainboardController.h"
 #include "AsusAuraMouseController.h"
 #include "RGBController.h"
 #include "RGBController_AsusAuraUSB.h"
+#include "RGBController_AsusAuraHeadsetStand.h"
 #include "RGBController_AsusAuraKeyboard.h"
+#include "RGBController_AsusAuraTUFKeyboard.h"
 #include "RGBController_AsusAuraMouse.h"
 #include <stdexcept>
 #include <hidapi/hidapi.h>
@@ -25,10 +29,13 @@
 #define AURA_ROG_STRIX_FLARE_PID                0x1875
 #define AURA_ROG_GLADIUS_II_ORIGIN_PID          0x1877
 #define AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID  0x18CD
+#define AURA_ROG_GLADIUS_II_WIRELESS_PID        0x18A0
 #define AURA_ROG_STRIX_FLARE_PNK_LTD_PID        0x18CF
 #define AURA_ROG_CHAKRAM_WIRELESS_PID           0x18E5
 #define AURA_ROG_CHAKRAM_WIRED_1_PID            0x18E3
 #define AURA_ROG_CHAKRAM_WIRED_2_PID            0x1958
+#define AURA_ROG_THRONE_QI_PID                  0x18C5
+#define AURA_TUF_K7_GAMING_PID				    0x18AA
 
 void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
 {
@@ -101,6 +108,30 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
     }
 }
 
+void DetectAsusAuraUSBHeadsetStand(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        AuraHeadsetStandController* controller = new AuraHeadsetStandController(dev, info->path);
+        RGBController_AuraHeadsetStand* rgb_controller = new RGBController_AuraHeadsetStand(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        AuraTUFKeyboardController* controller = new AuraTUFKeyboardController(dev, info->path);
+        RGBController_AuraTUFKeyboard* rgb_controller = new RGBController_AuraTUFKeyboard(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 REGISTER_HID_DETECTOR   ("ASUS ROG AURA Terminal",              DetectAsusAuraUSBTerminal,      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);
@@ -113,8 +144,11 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core",            DetectAsusAuraUS
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_PID,                  2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin",          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID,           2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD",  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID,   2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_PID,         2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",         DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRELESS_PID,            0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,             0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_2_PID,             0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                 1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,         1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,         1,  0xFF00);
+REGISTER_HID_DETECTOR_I ("ASUS ROG Throne QI",         			DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_PID, 					0);
+REGISTER_HID_DETECTOR_I ("ASUS TUF Gaming K7",         			DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID, 					1);

Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.cpp

@@ -0,0 +1,182 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraHeadsetStand.cpp   |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 06/04/2021                        |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusAuraHeadsetStand.h"
+
+RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandController* aura_ptr)
+{
+    aura        = aura_ptr;
+
+    name        = "ASUS Aura Headset Stand";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_HEADSET_STAND;
+    description = "ASUS Aura Headset Stand Device";
+    location    = aura->GetDeviceLocation();
+    serial      = aura->GetSerialString();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = AURA_HEADSET_STAND_MODE_DIRECT;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Static;
+    Static.name       = "Static";
+    Static.value      = AURA_HEADSET_STAND_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min = 1;
+    Static.colors_max = 1;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name       = "Breathing";
+    Breathing.value      = AURA_HEADSET_STAND_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed_min  = 0;
+    Breathing.speed_max  = 255;
+    Breathing.speed      = 127;
+    Breathing.colors_min = 1;
+    Breathing.colors_max = 1;
+    Breathing.colors.resize(1);
+    modes.push_back(Breathing);
+
+    mode Strobing;
+    Strobing.name       = "Strobing";
+    Strobing.value      = AURA_HEADSET_STAND_MODE_STROBING;
+    Strobing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Strobing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Strobing.colors_min = 1;
+    Strobing.colors_max = 1;
+    Strobing.colors.resize(1);
+    modes.push_back(Strobing);
+
+    mode SpectrumCycle;
+    SpectrumCycle.name       = "Spectrum Cycle";
+    SpectrumCycle.value      = AURA_HEADSET_STAND_MODE_COLOR_CYCLE;
+    SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED;
+    SpectrumCycle.speed_min  = 0;
+    SpectrumCycle.speed_max  = 255;
+    SpectrumCycle.speed      = 127;
+    SpectrumCycle.color_mode = MODE_COLORS_NONE;
+    modes.push_back(SpectrumCycle);
+
+    mode Rainbow;
+    Rainbow.name       = "Rainbow";
+    Rainbow.value      = AURA_HEADSET_STAND_MODE_RAINBOW;
+    Rainbow.flags      = MODE_FLAG_HAS_SPEED;
+    Rainbow.speed_min  = 0;
+    Rainbow.speed_max  = 255;
+    Rainbow.speed      = 127;
+    modes.push_back(Rainbow);
+    SetupZones();
+}
+
+RGBController_AuraHeadsetStand::~RGBController_AuraHeadsetStand()
+{
+	delete aura;
+}
+
+void RGBController_AuraHeadsetStand::SetupZones()
+{
+    zone underglow_zone;
+
+    underglow_zone.name         = "Underglow";
+    underglow_zone.type         = ZONE_TYPE_LINEAR;
+    underglow_zone.leds_min     = 17;
+    underglow_zone.leds_max     = 17;
+    underglow_zone.leds_count   = 17;
+    underglow_zone.matrix_map   = NULL;
+
+    zones.push_back(underglow_zone);
+
+    for(unsigned int i = 0; i < 17; i++)
+    {
+        led underglow_led;
+
+        underglow_led.name      = "Underglow LED " + std::to_string(i);
+
+        leds.push_back(underglow_led);
+    }
+
+    zone logo_zone;
+
+    logo_zone.name              = "Logo";
+    logo_zone.type              = ZONE_TYPE_SINGLE;
+    logo_zone.leds_min          = 1;
+    logo_zone.leds_max          = 1;
+    logo_zone.leds_count        = 1;
+    logo_zone.matrix_map        = NULL;
+
+    zones.push_back(logo_zone);
+
+    led logo_led;
+
+    logo_led.name               = "Logo LED";
+
+    leds.push_back(logo_led);
+
+    SetupColors();
+}
+
+void RGBController_AuraHeadsetStand::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AuraHeadsetStand::DeviceUpdateLEDs()
+{
+    aura->UpdateLeds(std::vector<RGBColor>(colors));
+}
+
+void RGBController_AuraHeadsetStand::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraHeadsetStand::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraHeadsetStand::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+
+void RGBController_AuraHeadsetStand::DeviceUpdateMode()
+{
+    unsigned char red = 0;
+    unsigned char grn = 0;
+    unsigned char blu = 0;
+    switch(modes[active_mode].value)
+    {
+        case 0:
+            aura->UpdateLeds(std::vector<RGBColor>(colors));
+            break;
+        case 1:
+        case 2:
+        case 3:
+            red = RGBGetRValue(modes[active_mode].colors[0]);
+            grn = RGBGetGValue(modes[active_mode].colors[0]);
+            blu = RGBGetBValue(modes[active_mode].colors[0]);
+            aura->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, false);
+            break;
+        case 4:
+        case 5:
+            aura->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, false);
+            break;
+    }
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraHeadsetStand.h     |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 06/04/2021                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraHeadsetStandController.h"
+
+class RGBController_AuraHeadsetStand : public RGBController
+{
+public:
+    RGBController_AuraHeadsetStand(AuraHeadsetStandController* aura_ptr);
+    ~RGBController_AuraHeadsetStand();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    AuraHeadsetStandController*  aura;
+};

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -0,0 +1,470 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraTUFKeyboard.cpp    |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 03/03/2020                        |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusAuraTUFKeyboard.h"
+#include <vector>
+
+#define NA  0xFFFFFFFF
+
+static unsigned int matrix_map[6][23] =
+    { {   0,  NA,  18,  24,  30,  36,  NA,  48,  54,  60,  66,  72,  78,  84,  90,  NA,  96, 102, 108,  NA,  NA,  NA,  NA },
+      {   1,  13,  19,  25,  31,  37,  43,  49,  55,  61,  67,  73,  79,  91,  NA,  NA,  97, 103, 109, 115, 121, 127, 133 },
+      {   2,  NA,  14,  20,  26,  32,  38,  44,  50,  56,  62,  68,  74,  80,  NA,  NA,  98, 104, 110, 116, 122, 128, 134 },
+      {   3,  NA,  15,  21,  27,  33,  39,  45,  51,  57,  63,  69,  75,  81,  93,  NA,  NA,  NA,  NA, 117, 123, 129,  NA },
+      {   4,  10,  16,  22,  28,  34,  40,  46,  52,  58,  64,  70,  NA,  94,  NA,  NA,  NA, 106,  NA, 118, 124, 130, 136 },
+      {   5,  11,  17,  NA,  NA,  NA,  41,  NA,  NA,  NA,  59,  71,  77,  NA,  95,  NA, 101, 107, 113, 119,  NA, 131,  NA } };
+
+static const char* zone_names[] =
+{
+    "Keyboard"
+};
+
+static zone_type zone_types[] =
+{
+    ZONE_TYPE_MATRIX,
+};
+
+static const unsigned int zone_sizes[] =
+{
+    138
+};
+
+static const char *led_names[] =
+{
+    "Key: Escape",
+    "Key: ^",
+    "Key: Tab",
+    "Key: Caps Lock",
+    "Key: Left Shift",
+    "Key: Left Control",
+
+    "Unused",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Key: <",
+    "Key: Left Windows",
+
+    "Unused",
+    "Key: 1",
+    "Key: Q",
+    "Key: A",
+    "Key: Y",
+    "Key: Left Alt",
+
+    "Key: F1",
+    "Key: 2",
+    "Key: W",
+    "Key: S",
+    "Key: X",
+    "Unused",
+
+    "Key: F2",
+    "Key: 3",
+    "Key: E",
+    "Key: D",
+    "Key: C",
+    "Unused",
+
+    "Key: F3",
+    "Key: 4",
+    "Key: R",
+    "Key: F",
+    "Key: V",
+    "Unused",
+
+    "Key: F4",
+    "Key: 5",
+    "Key: T",
+    "Key: G",
+    "Key: B",
+    "Key: Space",
+
+    "Unused",
+    "Key: 6",
+    "Key: Z",
+    "Key: H",
+    "Key: N",
+    "Unused",
+
+    "Key: F5",
+    "Key: 7",
+    "Key: U",
+    "Key: J",
+    "Key: M",
+    "Unused",
+
+    "Key: F6",
+    "Key: 8",
+    "Key: I",
+    "Key: K",
+    "Key: ,",
+    "Key: Right Alt",
+
+    "Key: F7",
+    "Key: 9",
+    "Key: O",
+    "Key: L",
+    "Key: .",
+    "Unused",
+
+    "Key: F8",
+    "Key: 0",
+    "Key: P",
+    "Key: Ö",
+    "Key: -",
+    "Key: Right Fn",
+
+    "Key: F9",
+    "Key: ß",
+    "Key: Ü",
+    "Key: Ä",
+    "Unused",
+    "Key: Menu",
+
+    "Key: F10",
+    "Key: ´",
+    "Key: +",
+    "Key: #",
+    "Unused",
+    "Unused",
+
+    "Key: F11",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Unused",
+
+    "Key: F12",
+    "Key: Backspace",
+    "Unused",
+    "Key: Enter",
+    "Key: Right Shift",
+    "Key: Right Control",
+
+    "Key: Print Screen",
+    "Key: Insert",
+    "Key: Delete",
+    "Unused",
+    "Unused",
+    "Key: Left Arrow",
+
+    "Key: Scroll Lock",
+    "Key: Home",
+    "Key: End",
+    "Unused",
+    "Key: Up Arrow",
+    "Key: Down Arrow",
+
+    "Key: Pause/Break",
+    "Key: Page Up",
+    "Key: Page Down",
+    "Unused",
+    "Unused",
+    "Key: Right Arrow",
+
+    "Unused",
+    "Key: Num Lock",
+    "Key: Number Pad 7",
+    "Key: Number Pad 4",
+    "Key: Number Pad 1",
+    "Key: Number Pad 0",
+
+    "Unused",
+    "Key: Number Pad /",
+    "Key: Number Pad 8",
+    "Key: Number Pad 5",
+    "Key: Number Pad 2",
+    "Unused",
+
+    "Unused",
+    "Key: Number Pad *",
+    "Key: Number Pad 9",
+    "Key: Number Pad 6",
+    "Key: Number Pad 3",
+    "Key: Number Pad ,",
+
+    "Unused",
+    "Key: Number Pad -",
+    "Key: Number Pad +",
+    "Unused",
+    "Key: Number Pad Enter",
+    "Unused",
+};
+
+RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* aura_ptr)
+{
+    aura = aura_ptr;
+
+    name        = "ASUS Aura Keyboard";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "ASUS Aura Keyboard Device";
+    location    = aura->GetDeviceLocation();
+    serial      = aura->GetSerialString();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = AURA_KEYBOARD_MODE_DIRECT;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Static;
+    Static.name       = "Static";
+    Static.value      = AURA_KEYBOARD_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min = 1;
+    Static.colors_max = 1;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name       = "Breathing";
+    Breathing.value      = AURA_KEYBOARD_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed_min  = 0;
+    Breathing.speed_max  = 15;
+    Breathing.speed      = 8;
+    Breathing.colors_min = 1;
+    Breathing.colors_max = 2;
+    Breathing.colors.resize(1);
+    modes.push_back(Breathing);
+
+    mode Color_Cycle;
+    Color_Cycle.name       = "Color Cycle";
+    Color_Cycle.value      = AURA_KEYBOARD_MODE_COLOR_CYCLE;
+    Color_Cycle.flags      = MODE_FLAG_HAS_SPEED;
+    Color_Cycle.color_mode = MODE_COLORS_NONE;
+    Color_Cycle.speed_min  = 0;
+    Color_Cycle.speed_max  = 15;
+    Color_Cycle.speed      = 8;
+    modes.push_back(Color_Cycle);
+
+    mode Wave;
+    Wave.name       = "Wave";
+    Wave.value      = AURA_KEYBOARD_MODE_WAVE;
+    Wave.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_HV;
+    Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Wave.speed_min  = 0;
+    Wave.speed_max  = 15;
+    Wave.speed      = 8;
+    Wave.direction  = MODE_DIRECTION_LEFT;
+    Wave.colors_min = 1;
+    Wave.colors_max = 7;
+    Wave.colors.resize(7);
+    modes.push_back(Wave);
+
+    mode Ripple;
+    Ripple.name       = "Ripple";
+    Ripple.value      = AURA_KEYBOARD_MODE_RIPPLE;
+    Ripple.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
+    Ripple.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Ripple.speed_min  = 0;
+    Ripple.speed_max  = 15;
+    Ripple.speed      = 8;
+    Ripple.colors_min = 1;
+    Ripple.colors_max = 8;
+    Ripple.colors.resize(7);
+    modes.push_back(Ripple);
+
+    mode Reactive;
+    Reactive.name       = "Reactive";
+    Reactive.value      = AURA_KEYBOARD_MODE_REACTIVE;
+    Reactive.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
+    Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Reactive.speed_min  = 0;
+    Reactive.speed_max  = 15;
+    Reactive.speed      = 8;
+    Reactive.colors_min = 1;
+    Reactive.colors_max = 2;
+    Reactive.colors.resize(1);
+    modes.push_back(Reactive);
+
+    mode Starry_Night;
+    Starry_Night.name       = "Starry Night";
+    Starry_Night.value      = AURA_KEYBOARD_MODE_STARRY_NIGHT;
+    Starry_Night.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
+    Starry_Night.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Starry_Night.speed_min  = 0;
+    Starry_Night.speed_max  = 15;
+    Starry_Night.speed      = 8;
+    Starry_Night.colors_min = 1;
+    Starry_Night.colors_max = 3;
+    Starry_Night.colors.resize(1);
+    modes.push_back(Starry_Night);
+
+    mode Quicksand;
+    Quicksand.name       = "Quicksand";
+    Quicksand.value      = AURA_KEYBOARD_MODE_QUICKSAND;
+    Quicksand.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD;
+    Quicksand.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Quicksand.direction  = MODE_DIRECTION_DOWN;
+    Quicksand.speed_min  = 0;
+    Quicksand.speed_max  = 15;
+    Quicksand.speed      = 8;
+    Quicksand.colors_min = 6;
+    Quicksand.colors_max = 6;
+    Quicksand.colors.resize(6);
+    modes.push_back(Quicksand);
+
+    mode Current;
+    Current.name       = "Current";
+    Current.value      = AURA_KEYBOARD_MODE_CURRENT;
+    Current.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
+    Current.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Current.speed_min  = 0;
+    Current.speed_max  = 15;
+    Current.speed      = 8;
+    Current.colors_min = 1;
+    Current.colors_max = 3;
+    Current.colors.resize(1);
+    modes.push_back(Current);
+
+    mode Rain_Drop;
+    Rain_Drop.name       = "Rain Drop";
+    Rain_Drop.value      = AURA_KEYBOARD_MODE_RAIN_DROP;
+    Rain_Drop.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
+    Rain_Drop.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Rain_Drop.speed_min  = 0;
+    Rain_Drop.speed_max  = 15;
+    Rain_Drop.speed      = 8;
+    Rain_Drop.colors_min = 1;
+    Rain_Drop.colors_max = 3;
+    Rain_Drop.colors.resize(1);
+    modes.push_back(Rain_Drop);
+
+    SetupZones();
+}
+
+RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
+{
+    delete aura;
+}
+
+void RGBController_AuraTUFKeyboard::SetupZones()
+{
+    unsigned int total_led_count = 0;
+
+    for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
+    {
+        zone new_zone;
+        new_zone.name               = zone_names[zone_idx];
+        new_zone.type               = zone_types[zone_idx];
+        new_zone.leds_min           = zone_sizes[zone_idx];
+        new_zone.leds_max           = zone_sizes[zone_idx];
+        new_zone.leds_count         = zone_sizes[zone_idx];
+        new_zone.matrix_map         = new matrix_map_type;
+        new_zone.matrix_map->height = 6;
+        new_zone.matrix_map->width  = 23;
+        new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+        zones.push_back(new_zone);
+
+        total_led_count += zone_sizes[zone_idx];
+    }
+
+    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
+    {
+        led new_led;
+        new_led.name = led_names[led_idx];
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
+void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
+{
+    DeviceUpdateMode();
+}
+
+void RGBController_AuraTUFKeyboard::UpdateZoneLEDs(int /*zone*/)
+{
+    aura->UpdateLeds(colors);
+}
+
+void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
+{
+    unsigned char red   = RGBGetRValue(colors[led]);
+    unsigned char green = RGBGetGValue(colors[led]);
+    unsigned char blue  = RGBGetBValue(colors[led]);
+    aura->UpdateSingleLed(led, red, green, blue);
+}
+
+void RGBController_AuraTUFKeyboard::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
+{   
+    unsigned char color_mode;
+    std::vector<RGBColor> mode_colors;
+
+    if(modes[active_mode].value == AURA_KEYBOARD_MODE_DIRECT)
+    {
+        aura->UpdateLeds(colors);
+    }
+    else
+    {
+        bool mode_with_double = (modes[active_mode].value == 1 || modes[active_mode].value == 3 || modes[active_mode].value == 6 || modes[active_mode].value == 8 || modes[active_mode].value == 9);
+
+        if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && mode_with_double && modes[active_mode].colors.size() > 1)
+        {
+            if(modes[active_mode].colors[1] == 000)
+            {
+                color_mode = 0;
+            }
+            else
+            {
+                color_mode = 16;
+            }
+        }
+        else
+        {
+            color_mode = modes[active_mode].color_mode == MODE_COLORS_RANDOM ? 1 : 0;
+        }
+
+        int direction = 0;
+
+        switch (modes[active_mode].direction)
+        {
+            case MODE_DIRECTION_LEFT:
+                direction = 0;
+                break;
+            case MODE_DIRECTION_RIGHT:
+                direction = 4;
+                break;
+            case MODE_DIRECTION_UP:
+                direction = 6;
+                break;
+            case MODE_DIRECTION_DOWN:
+                direction = 2;
+                break;
+            case MODE_DIRECTION_HORIZONTAL:
+                direction = 8;
+                break;
+            case MODE_DIRECTION_VERTICAL:
+                direction = 1;
+                break;
+        }
+
+        mode_colors = modes[active_mode].color_mode == MODE_COLORS_PER_LED ? std::vector<RGBColor>(colors) : std::vector<RGBColor>(modes[active_mode].colors);
+
+        aura->UpdateDevice(modes[active_mode].value, mode_colors, direction, color_mode, (15 - modes[active_mode].speed));
+    }
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraTUFKeyboard.h      |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 03/03/2021                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraTUFKeyboardController.h"
+
+class RGBController_AuraTUFKeyboard : public RGBController
+{
+public:
+    RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* aura_ptr);
+    ~RGBController_AuraTUFKeyboard();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    AuraTUFKeyboardController*  aura;
+};

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreController.cpp

@@ -0,0 +1,276 @@
+/*---------------------------------------------------------*\
+|  CorsairCommanderCoreController.cpp                       |
+|                                                           |
+|  Processing Code for Corsair Commander Core               |
+|                                                           |
+|  Jeff P.                                                  |
+\*---------------------------------------------------------*/
+
+#include "CorsairCommanderCoreController.h"
+
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+
+using namespace std::chrono_literals;
+
+CorsairCommanderCoreController::CorsairCommanderCoreController(hid_device* dev_handle, const char* path)
+{
+    dev                     = dev_handle;
+    location                = path;
+    keepalive_thread_run    = 1;
+    controller_ready        = 0;
+
+    /*-----------------------------------------------------*\
+    | Initialize controller                                 |
+    \*-----------------------------------------------------*/
+    InitController();
+
+    /*-----------------------------------------------------*\
+    | Start keepalive thread                                |
+    \*-----------------------------------------------------*/
+    keepalive_thread = new std::thread(&CorsairCommanderCoreController::KeepaliveThread, this);
+}
+
+CorsairCommanderCoreController::~CorsairCommanderCoreController()
+{
+    /*-----------------------------------------------------*\
+    | Close keepalive thread                                |
+    \*-----------------------------------------------------*/
+    keepalive_thread_run = 0;
+    keepalive_thread->join();
+    delete keepalive_thread;
+
+    /*-----------------------------------------------------*\
+    | Close HID device                                      |
+    \*-----------------------------------------------------*/
+    hid_close(dev);
+}
+
+void CorsairCommanderCoreController::InitController()
+{
+    /*-----------------------------------------------------*\
+    | Packet sequence to put controller into direct mode    |
+    \*-----------------------------------------------------*/
+    unsigned char buffarray[][5] =
+    {
+        {0x08, 0x01, 0x03, 0x00, 0x02},
+        {0x08, 0x0D, 0x00, 0x22, 0x00},
+    };
+
+    SendMultiPkt(buffarray, sizeof(buffarray) / sizeof(buffarray[0]), sizeof(buffarray)[0] / sizeof(buffarray[0][0]));
+    SetFanMode();
+}
+
+std::string CorsairCommanderCoreController::GetLocationString()
+{
+    return("HID: " + location);
+}
+
+void CorsairCommanderCoreController::KeepaliveThread()
+{
+    while(keepalive_thread_run.load())
+    {
+        if (controller_ready)
+        {
+            if((std::chrono::steady_clock::now() - last_commit_time) > std::chrono::seconds(10))
+            {
+                SendCommit();
+            }
+        }
+        std::this_thread::sleep_for(1s);
+    }
+}
+
+void CorsairCommanderCoreController::SendCommit()
+{
+    if(!lastcolors.empty())
+    {
+        /*-----------------------------------------------------*\
+        | If colors remain to be sent, send them                |
+        \*-----------------------------------------------------*/
+        SetDirectColor(lastcolors, lastzones);
+    }
+    else
+    {
+        unsigned char   usb_buf[1025];
+
+        /*-----------------------------------------------------*\
+        | Zero out buffer                                       |
+        \*-----------------------------------------------------*/
+        memset(usb_buf, 0x00, sizeof(usb_buf));
+
+        /*-----------------------------------------------------*\
+        | Update last commit time                               |
+        \*-----------------------------------------------------*/
+        last_commit_time    = std::chrono::steady_clock::now();
+
+        /*-----------------------------------------------------*\
+        | Set up Commit packet                                  |
+        \*-----------------------------------------------------*/
+        memset(usb_buf, 0, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+
+        usb_buf[0]          = 0x00;
+        usb_buf[1]          = 0x08;
+        usb_buf[2]          = 0x06;
+        usb_buf[4]          = 0xBD;
+        usb_buf[5]          = 0x02;
+        usb_buf[8]          = 0x12;
+
+        hid_write(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    }
+}
+
+
+void CorsairCommanderCoreController::SendMultiPkt(unsigned char buffarray[][5], int r, int c)
+{
+    /*---------------------------------------------------------*\
+    | Private function to send multiple packets                 |
+    \*---------------------------------------------------------*/
+    unsigned char* hidtemp = new unsigned char[CORSAIR_COMMANDER_CORE_PACKET_SIZE];
+
+    for(unsigned int i = 0; i < r; i++)
+    {
+        memset(hidtemp, 0, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    
+        for(unsigned int j = 0; j < c; j++)
+        {
+            hidtemp[j+1] = buffarray[i][j];
+        }
+
+        hid_write(dev, hidtemp, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+        hid_read(dev, hidtemp, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    }
+}
+
+void CorsairCommanderCoreController::SetDirectColor
+    (
+        std::vector<RGBColor> colors,
+        std::vector<zone> zones
+    )
+{
+    if(controller_ready == 1 && ((std::chrono::steady_clock::now() - last_commit_time) > std::chrono::milliseconds(33)))
+    {
+        lastcolors              = colors;
+        lastzones               = zones;
+        int packet_offset       = CORSAIR_COMMANDER_CORE_PREAMBLE_OFFSET;
+        int led_idx             = 0;
+        int channel_idx         = 0;
+        unsigned char* usb_buf  = new unsigned char[CORSAIR_COMMANDER_CORE_PACKET_SIZE];
+
+        memset(usb_buf, 0, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+
+        /*-----------------------------------------------------*\
+        | Prepare color information packet                      |
+        \*-----------------------------------------------------*/
+        usb_buf[0]              = 0x00;
+        usb_buf[1]              = 0x08;
+        usb_buf[2]              = 0x06;
+        usb_buf[4]              = 0xBD;
+        usb_buf[5]              = 0x02;
+        usb_buf[8]              = 0x12;
+
+        for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+        {
+            /*-------------------------------------------------*\
+            | Add led colors                                    |
+            \*-------------------------------------------------*/
+            for(unsigned int i = led_idx; i < led_idx + zones[zone_idx].leds_count; i++)
+            {
+                usb_buf[packet_offset]   = RGBGetRValue(colors[i]);
+                usb_buf[packet_offset+1] = RGBGetGValue(colors[i]);
+                usb_buf[packet_offset+2] = RGBGetBValue(colors[i]);
+
+                packet_offset = packet_offset + 3;
+            }
+
+            led_idx = led_idx + zones[zone_idx].leds_count;
+
+            /*-------------------------------------------------*\
+            | Move offset for pump zone with less than 29 LEDs  |
+            \*-------------------------------------------------*/
+            if(zone_idx == 0)
+            {
+                packet_offset = packet_offset + 3 * (29 - zones[zone_idx].leds_count);
+            }
+
+            /*-------------------------------------------------*\
+            | Move offset for fans with less than 34 LEDs       |
+            \*-------------------------------------------------*/
+            if(zone_idx != 0)
+            {
+                packet_offset = packet_offset + 3 * (34 - zones[zone_idx].leds_count);
+            }
+
+            channel_idx++;
+        }
+
+        /*-----------------------------------------------------*\
+        | Sending a direct mode color packet resets the timeout |
+        \*-----------------------------------------------------*/
+        last_commit_time = std::chrono::steady_clock::now();
+
+        hid_write(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    }
+}
+
+void CorsairCommanderCoreController::SetFanMode()
+{
+    /*--------------------------------------------------------------------------------------------------*\
+    | Force controller to 6 QL fan mode to expose maximum number of LEDs per rgb port (34 LEDs per port) |
+    \*--------------------------------------------------------------------------------------------------*/
+
+    unsigned char usb_buf[1025];
+
+    unsigned char buffarray4[][5] =
+    {
+        {0x08, 0x05, 0x01, 0x01, 0x00},
+        {0x08, 0x0D, 0x01, 0x1E, 0x00},
+        {0x08, 0x09, 0x01, 0x00, 0x00}
+    };
+
+    SendMultiPkt(buffarray4, sizeof(buffarray4) / sizeof(buffarray4[0]), sizeof(buffarray4)[0] / sizeof(buffarray4[0][0]));
+
+    memset(usb_buf, 0, sizeof(usb_buf));
+
+    usb_buf[0]          = 0x00;
+    usb_buf[1]          = 0x08;
+    usb_buf[2]          = 0x06;
+    usb_buf[3]          = 0x01;
+    usb_buf[4]          = 0x11;
+    usb_buf[8]          = 0x0D;
+    usb_buf[10]         = 0x07;
+    usb_buf[11]         = 0x01;
+    usb_buf[12]         = 0x08;
+
+    for(unsigned int i = 13; i < 25; i = i + 2)
+    {
+        usb_buf[i]      = 0x01;
+        usb_buf[i + 1]  = 0x06;
+    }
+
+    hid_write(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    hid_read(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+
+    unsigned char buffarray2[][5] =
+    {
+        {0x08, 0x05, 0x01, 0x01, 0x00},
+        {0x08, 0x15, 0x01, 0x00, 0x00}
+    };
+
+    SendMultiPkt(buffarray2, sizeof(buffarray2) / sizeof(buffarray2[0]), sizeof(buffarray2)[0] / sizeof(buffarray2[0][0]));
+
+    memset(usb_buf, 0, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+
+    usb_buf[0]          = 0x00;
+    usb_buf[1]          = 0x08;
+    usb_buf[2]          = 0x06;
+    usb_buf[4]          = 0xBD;
+    usb_buf[5]          = 0x02;
+    usb_buf[8]          = 0x12;
+
+    hid_write(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    hid_read(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    
+    controller_ready    = 1;
+}

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreController.h

@@ -0,0 +1,65 @@
+/*---------------------------------------------------------*\
+|  CorsairCommanderCoreController.h                         |
+|                                                           |
+|  Definitions for Corsair Commander Core                   |
+|  Based on code by:                                        |
+|  Adam Honse ([email protected]), 8/17/2020        |
+|                                                           |
+|  Jeff P.                                                  |
+\*---------------------------------------------------------*/
+
+#include "RGBController.h"
+#include <vector>
+#include <chrono>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+#define CORSAIR_COMMANDER_CORE_PACKET_SIZE      1025
+#define CORSAIR_COMMANDER_CORE_PREAMBLE_OFFSET  10
+#define CORSAIR_ELITE_CAPELLIX_PUMP_LED_OFFSET  87
+#define CORSAIR_QL_FAN_ZONE_OFFSET              102
+#define CORSAIR_COMMANDER_CORE_NUM_CHANNELS     6
+
+enum
+{
+    CORSAIR_COMMANDER_CORE_MODE_DIRECT          = 0x00,
+};
+
+class CorsairCommanderCoreController
+{
+public:
+    CorsairCommanderCoreController(hid_device* dev_handle, const char* path);
+    ~CorsairCommanderCoreController();
+
+    std::string GetLocationString();
+
+    void        SetDirectColor
+                (
+                    std::vector<RGBColor>,
+                    std::vector<zone>
+                );
+
+    void        KeepaliveThread();
+    void        SetFanMode();
+
+private:
+    hid_device*             dev;
+    std::thread*            keepalive_thread;
+    std::atomic<bool>       keepalive_thread_run;
+    std::atomic<bool>       controller_ready;
+    std::string             location;
+    std::vector<RGBColor>   lastcolors;
+    std::vector<zone>       lastzones;
+    std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
+
+    void        SendMultiPkt
+                (
+                    unsigned char buffarray[][5],
+                    int r,
+                    int c
+                );
+
+    void        SendCommit();
+    void        InitController();
+};

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreControllerDetect.cpp

@@ -0,0 +1,41 @@
+#include "Detector.h"
+#include "CorsairCommanderCoreController.h"
+#include "RGBController.h"
+#include "RGBController_CorsairCommanderCore.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+/*-----------------------------------------------------*\
+| Corsair vendor ID                                     |
+\*-----------------------------------------------------*/
+#define CORSAIR_VID                         0x1B1C
+
+/*-----------------------------------------------------*\
+| Commander Core product IDs                            |
+\*-----------------------------------------------------*/
+#define CORSAIR_H150I_COMMANDER_CORE_PID    0x0C1C
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectCorsairCapellixControllers                                                       *
+*                                                                                          *
+*       Tests the USB address to see if a Corsair RGB Cooler controller exists there.      *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectCorsairCapellixHIDControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        CorsairCommanderCoreController*     controller     = new CorsairCommanderCoreController(dev, info->path);
+        RGBController_CorsairCommanderCore* rgb_controller = new RGBController_CorsairCommanderCore(controller);
+
+        rgb_controller->name = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR_PU("Corsair Commander Core",  DetectCorsairCapellixHIDControllers, CORSAIR_VID, CORSAIR_H150I_COMMANDER_CORE_PID, 0xFF42, 0x01);

Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.cpp

@@ -0,0 +1,125 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairCapellix.cpp        |
+|                                           |
+|  Generic RGB Interface for Corsair        |
+|  Commander Core                           |
+|                                           |
+|  Jeff P.                                  |
+\*-----------------------------------------*/
+
+#include "RGBController_CorsairCommanderCore.h"
+
+RGBController_CorsairCommanderCore::RGBController_CorsairCommanderCore(CorsairCommanderCoreController* corsair_ptr)
+{
+    corsair     = corsair_ptr;
+
+    vendor      = "Corsair";
+    description = "Corsair Commander Core";
+    type        = DEVICE_TYPE_COOLER;
+    location    = corsair->GetLocationString();
+
+    SetupZones();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+}
+
+RGBController_CorsairCommanderCore::~RGBController_CorsairCommanderCore()
+{
+    delete corsair;
+}
+
+void RGBController_CorsairCommanderCore::SetupZones()
+{
+    std::atomic<bool> first_run;
+    first_run = 0;
+
+    if(zones.size() == 0)
+    {
+        first_run = 1;
+    }
+
+    zones.resize(7);
+    zones[0].name                   = "Pump";
+    zones[0].type                   = ZONE_TYPE_LINEAR;
+    zones[0].leds_min               = 0;
+    zones[0].leds_max               = 29;
+
+    for(unsigned int i = 1; i < (CORSAIR_COMMANDER_CORE_NUM_CHANNELS + 1); i++)
+    {
+        zones[i].name               = "RGB Port " + std::to_string(i);
+        zones[i].type               = ZONE_TYPE_LINEAR;
+        zones[i].leds_min           = 0;
+        zones[i].leds_max           = 34;
+
+        if(first_run)
+        {
+            zones[i].leds_count = 0;
+        }
+    }
+
+    leds.clear();
+    colors.clear();
+
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        for (unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
+        {
+            led new_led;
+            new_led.name            = zones[zone_idx].name + " LED " + std::to_string(led_idx+1);
+
+            leds.push_back(new_led);
+        }
+    }
+
+    SetupColors();
+}
+
+void RGBController_CorsairCommanderCore::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_CorsairCommanderCore::DeviceUpdateLEDs()
+{
+    DeviceUpdateMode();
+}
+
+void RGBController_CorsairCommanderCore::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CorsairCommanderCore::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CorsairCommanderCore::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_CorsairCommanderCore::DeviceUpdateMode()
+{
+    switch(modes[active_mode].value)
+    {
+        case CORSAIR_COMMANDER_CORE_MODE_DIRECT:
+            corsair->SetDirectColor(colors, zones);
+            break;
+    }
+}

Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairCapellix.h          |
+|                                           |
+|  Generic RGB Interface for Corsair        |
+|  Commander Core                           |
+|                                           |
+|  Jeff P.                                  |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "CorsairCommanderCoreController.h"
+
+class RGBController_CorsairCommanderCore : public RGBController
+{
+public:
+    RGBController_CorsairCommanderCore(CorsairCommanderCoreController* corsair_ptr);
+    ~RGBController_CorsairCommanderCore();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    CorsairCommanderCoreController*     corsair;
+    std::vector<int>                    fanleds{0};
+};

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

@@ -64,7 +64,12 @@ std::string CorsairLightingNodeController::GetLocationString()
 std::string CorsairLightingNodeController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

@@ -112,7 +112,12 @@ std::string CorsairPeripheralController::GetName()
 std::string CorsairPeripheralController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/CorsairWirelessController/CorsairWirelessController.cpp

@@ -51,7 +51,12 @@ std::string CorsairWirelessController::GetName()
 std::string CorsairWirelessController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/DasKeyboardController/DasKeyboardController.cpp

@@ -38,7 +38,7 @@ std::string DasKeyboardController::GetSerialString()
     int     err                = hid_get_serial_number_string(dev, serial_string, 128);
 
     std::string return_string;
-    if(!err)
+    if(err == 0)
     {
         std::wstring return_wstring = serial_string;
         return_string = std::string(return_wstring.begin(), return_wstring.end());

Controllers/DuckyKeyboardController/DuckyKeyboardController.cpp

@@ -31,7 +31,12 @@ std::string DuckyKeyboardController::GetDeviceLocation()
 std::string DuckyKeyboardController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/EVisionKeyboardController/EVisionKeyboardController.cpp

@@ -33,7 +33,12 @@ std::string EVisionKeyboardController::GetDeviceLocation()
 std::string EVisionKeyboardController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp

@@ -9,12 +9,15 @@
 | Keyboard product IDs                                  |
 \*-----------------------------------------------------*/
 #define EVISION_KEYBOARD_VID            0x0C45
+#define WOMIER_K87_VID                  0x320F
 #define EVISION_KEYBOARD_USAGE_PAGE     0xFF1C
 #define REDRAGON_K550_PID               0x5204
 #define REDRAGON_K552_PID               0x5104
 #define REDRAGON_K556_PID               0x5004
 #define TECWARE_PHANTOM_ELITE_PID       0x652F
 #define WARRIOR_KANE_TC235              0x8520
+#define WOMIER_K87_PID                  0x502A
+#define WOMIER_K66_PID                  0x7698
 
 /******************************************************************************************\
 *                                                                                          *
@@ -44,3 +47,5 @@ REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5104",  DetectEVisionKeyboards,
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5004",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   REDRAGON_K556_PID,         1, EVISION_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:652F",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   TECWARE_PHANTOM_ELITE_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:8520",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   WARRIOR_KANE_TC235,        1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:502A",  DetectEVisionKeyboards, WOMIER_K87_VID,         WOMIER_K87_PID,            1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:7698",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   WOMIER_K66_PID,            1, EVISION_KEYBOARD_USAGE_PAGE);

Controllers/GigabyteAorusCPUCoolerController/ATC800Controller.cpp

@@ -30,7 +30,12 @@ std::string ATC800Controller::GetDeviceLocation()
 std::string ATC800Controller::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/GigabyteRGBFusion2USBController/GigabyteRGBFusion2USBController.h

@@ -35,7 +35,7 @@ const uint8_t LED8          = 0x27;
 
 /*-------------------------------------------------------------*\
 | LED "headers" 0x20..0x27, As seen on Gigabyte X570 Elite board|
-| Internal legacy shorthand naming and possibly depracated      |
+| Internal legacy shorthand naming and possibly deprecated      |
 \*-------------------------------------------------------------*/
 const uint8_t HDR_BACK_IO   = LED1;
 const uint8_t HDR_CPU       = LED2;

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUController.cpp

@@ -36,6 +36,15 @@ void RGBFusionGPUController::SetColor(unsigned char red, unsigned char green, un
     bus->i2c_smbus_write_byte(dev, red);
     bus->i2c_smbus_write_byte(dev, green);
     bus->i2c_smbus_write_byte(dev, blue);
+
+    // Pad commands with 4 zero-bytes for NVIDIA_RTX3060_DEV
+    if (dev == 0x62)
+    {
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+    }
 }
 
 void RGBFusionGPUController::SetMode(unsigned char mode, unsigned char speed)
@@ -44,4 +53,13 @@ void RGBFusionGPUController::SetMode(unsigned char mode, unsigned char speed)
     bus->i2c_smbus_write_byte(dev, mode);
     bus->i2c_smbus_write_byte(dev, speed);
     bus->i2c_smbus_write_byte(dev, 0x63);
+
+    // Pad commands with 4 zero-bytes for NVIDIA_RTX3060_DEV
+    if (dev == 0x62)
+    {
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+    }
 }

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUControllerDetect.cpp

@@ -34,14 +34,16 @@ static const gpu_pci_device device_list[] =
     { NVIDIA_VEN,   NVIDIA_GTX1650_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1650_GAMING_OC_SUB_DEV,             0x55,   "Gigabyte GTX1650 Gaming OC"                    },
     { NVIDIA_VEN,   NVIDIA_GTX1660S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_GTX1660S_GAMING_OC_SUB_DEV,            0x47,   "Gigabyte GTX1660 SUPER Gaming OC"              },
     { NVIDIA_VEN,   NVIDIA_RTX2060_TU106_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060_GAMING_OC_SUB_DEV,             0x47,   "Gigabyte RTX2060 Gaming OC"                    },
-    { NVIDIA_VEN,   NVIDIA_RTX2060S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060S_GAMING_SUB_DEV,               0x47,   "Gigabyte RTX2060 SUPER Gaming"                 },
+    { NVIDIA_VEN,   NVIDIA_RTX2060_TU106_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060_GAMING_OC_PRO_SUB_DEV,         0x47,   "Gigabyte RTX2060 Gaming OC PRO"                },
+    { NVIDIA_VEN,   NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060S_GAMING_SUB_DEV,               0x47,   "Gigabyte RTX2060 SUPER Gaming"                 },
     { NVIDIA_VEN,   NVIDIA_RTX2070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070_GAMING_OC_SUB_DEV,             0x47,   "Gigabyte RTX2070 Gaming OC 8G"                 },
     { NVIDIA_VEN,   NVIDIA_RTX2070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070_WINDFORCE_SUB_DEV,             0x47,   "Gigabyte RTX2070 Windforce 8G"                 },
     { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070S_GAMING_OC_SUB_DEV,            0x47,   "Gigabyte RTX2070S Gaming OC"                   },
     { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070S_GAMING_OC_3X_SUB_DEV,         0x55,   "Gigabyte RTX2070S Gaming OC 3X"                },
     { NVIDIA_VEN,   NVIDIA_RTX2080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2080_GAMING_OC_SUB_DEV,             0x47,   "Gigabyte RTX2080 Gaming OC 8G"                 },
     { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX2080_A_GAMING_OC_SUB_DEV,           0x47,   "Gigabyte RTX2080 Gaming OC 8G"                 },
-    { NVIDIA_VEN,   NVIDIA_RTX3060TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_EAGLE_OC_SUB_DEV,            0x63,   "Gigabyte RTX3060 EAGLE OC 8G"                  },
+    { NVIDIA_VEN,   NVIDIA_RTX3060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_GAMING_OC_12GB_SUB_DEV,        0x62,   "Gigabyte RTX3060 Gaming OC 12G"                },
+    { NVIDIA_VEN,   NVIDIA_RTX3060TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_EAGLE_OC_SUB_DEV,            0x63,   "Gigabyte RTX3060 Ti EAGLE OC 8G"               },
     { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_VISION_OC_SUB_DEV,             0x63,   "Gigabyte RTX3070 Vision 8G"                    },
 };
 
@@ -67,6 +69,15 @@ bool TestForGigabyteRGBFusionGPUController(i2c_smbus_interface* bus, unsigned ch
         bus->i2c_smbus_write_byte(address, 0x00);
         bus->i2c_smbus_write_byte(address, 0x00);
         bus->i2c_smbus_write_byte(address, 0x00);
+        
+        // NVIDIA_RTX3060_DEV requires additional bytes to initialise
+        if (address == 0x62)
+        {
+            bus->i2c_smbus_write_byte(address, 0x00);
+            bus->i2c_smbus_write_byte(address, 0x00);
+            bus->i2c_smbus_write_byte(address, 0x00);
+            bus->i2c_smbus_write_byte(address, 0x00);
+        }
 
         pass = true;
 

Controllers/HoltekController/HoltekA070Controller.cpp

@@ -29,7 +29,12 @@ std::string HoltekA070Controller::GetDeviceLocation()
 std::string HoltekA070Controller::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/HoltekController/HoltekA1FAController.cpp

@@ -30,7 +30,12 @@ std::string HoltekA1FAController::GetDeviceLocation()
 std::string HoltekA1FAController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/HyperXKeyboardController/HyperXAlloyElite2Controller.cpp

@@ -35,7 +35,12 @@ std::string HyperXAlloyElite2Controller::GetDeviceLocation()
 std::string HyperXAlloyElite2Controller::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/HyperXKeyboardController/HyperXAlloyOriginsController.cpp

@@ -12,7 +12,7 @@
 #include <cstring>
 
 // Skip these indices in the color output
-static unsigned int skip_idx[] = { 6, 23, 29, 41, 47, 59, 70, 71, 75, 76, 87, 88, 93, 99, 100, 102, 108, 113, 114, 120, 123, 124 };
+static unsigned int skip_idx[] = { 23, 29, 41, 47, 59, 70, 71, 76, 87, 88, 93, 99, 100, 102, 108, 113, 114, 120, 123, 124 };
 
 HyperXAlloyOriginsController::HyperXAlloyOriginsController(hid_device* dev_handle, const char* path)
 {
@@ -33,7 +33,12 @@ std::string HyperXAlloyOriginsController::GetDeviceLocation()
 std::string HyperXAlloyOriginsController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/HyperXKeyboardController/HyperXAlloyOriginsCoreController.cpp

@@ -0,0 +1,118 @@
+/*------------------------------------------*\
+|  HyperXAlloyOriginsCoreController.cpp      |
+|                                            |
+|  Driver for HyperX Alloy Origins Core      |
+|  RGB Keyboard lighting controller          |
+|                                            |
+|  Volodymyr Nazarchuk (Vavooon) 4/28/2021   |
+|  mike white (kamaaina)          6/9/2021   |
+\*------------------------------------------*/
+
+#include "HyperXAlloyOriginsCoreController.h"
+
+#include <cstring>
+
+// Skip these indices in the color output
+static unsigned int skip_idx[] = {6, 7, 14, 15, 22, 23, 30, 31, 38, 39, 44, 46, 47, 54, 55, 58, 60, 61, 62, 63, 70, 71, 78, 79, 86, 87, 94, 95, 101, 102, 103, 109, 110, 111, 118, 119};
+
+HyperXAlloyOriginsCoreController::HyperXAlloyOriginsCoreController(hid_device* dev_handle, hid_device_info* dev_info)
+{
+    dev              = dev_handle;
+    location         = dev_info->path;
+
+    /*-----------------------------------------------------*\
+    | Get the firmware version from the device info         |
+    \*-----------------------------------------------------*/
+    char fw_version_buf[8];
+    memset(fw_version_buf, '\0', sizeof(fw_version_buf));
+
+    unsigned short version = dev_info->release_number;
+    sprintf(fw_version_buf, "%.2X.%.2X", (version & 0xFF00) >> 8, version & 0x00FF);
+
+    firmware_version = fw_version_buf;
+}
+
+HyperXAlloyOriginsCoreController::~HyperXAlloyOriginsCoreController()
+{
+    hid_close(dev);
+}
+
+std::string HyperXAlloyOriginsCoreController::GetDeviceLocation()
+{
+    return("HID " + location);
+}
+
+std::string HyperXAlloyOriginsCoreController::GetSerialString()
+{
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+std::string HyperXAlloyOriginsCoreController::GetFirmwareVersion()
+{
+    return(firmware_version);
+}
+
+void HyperXAlloyOriginsCoreController::SetLEDsDirect(std::vector<RGBColor> colors)
+{
+    for(unsigned int skip_cnt = 0; skip_cnt < (sizeof(skip_idx) / sizeof(skip_idx[0])); skip_cnt++)
+    {
+        colors.insert(colors.begin() + skip_idx[skip_cnt], 0x00000000);
+    }
+
+    unsigned char buf[380];
+    memset(buf, 0x00, sizeof(buf));
+
+    int offset = 0;
+    int rowPos = 0;
+
+    for(unsigned int color_idx = 0; color_idx < colors.size(); color_idx++)
+    {
+        if (color_idx > 0 && color_idx % 16 == 0)
+        {
+            offset += 48;
+            rowPos = 0;
+        }
+
+        buf[rowPos + offset]      = RGBGetGValue(colors[color_idx]);
+        buf[rowPos + offset + 16] = RGBGetRValue(colors[color_idx]);
+        buf[rowPos + offset + 32] = RGBGetBValue(colors[color_idx]);
+
+        rowPos++;
+    }
+
+    unsigned int sentBytes   = 0;
+    unsigned int bytesToSend = sizeof(buf);
+    unsigned int payloadSize = 60;
+    unsigned int seq         = 0;
+
+    while(sentBytes < bytesToSend)
+    {
+        if (bytesToSend - sentBytes < payloadSize)
+        {
+            payloadSize = bytesToSend - sentBytes;
+        }
+
+        unsigned char packet[65];
+        memset(packet, 0x00, sizeof(packet));
+
+        packet[1] = 0xA2;
+        packet[2] = seq++;
+        packet[4] = payloadSize;
+
+        memcpy(&packet[5], &buf[sentBytes], payloadSize);
+        hid_write(dev, packet, 65);
+
+        sentBytes += payloadSize;
+    }
+}

Controllers/HyperXKeyboardController/HyperXAlloyOriginsCoreController.h

@@ -0,0 +1,34 @@
+/*------------------------------------------*\
+|  HyperXAlloyOriginsCoreController.h        |
+|                                            |
+|  Definitions and types for HyperX Alloy    |
+|  Origins Core RGB Keyboard lighting        |
+|  controller                                |
+|                                            |
+|  Volodymyr Nazarchuk (Vavooon) 4/28/2021   |
+\*------------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+class HyperXAlloyOriginsCoreController
+{
+public:
+    HyperXAlloyOriginsCoreController(hid_device* dev_handle, hid_device_info* dev_info);
+    ~HyperXAlloyOriginsCoreController();
+
+    std::string     GetDeviceLocation();
+    std::string     GetSerialString();
+    std::string     GetFirmwareVersion();
+
+    void SetLEDsDirect(std::vector<RGBColor> colors);
+
+private:
+    hid_device*     dev;
+    std::string     location;
+    std::string     firmware_version;
+};

Controllers/HyperXKeyboardController/HyperXKeyboardController.cpp

@@ -46,7 +46,12 @@ std::string HyperXKeyboardController::GetDeviceLocation()
 std::string HyperXKeyboardController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/HyperXKeyboardController/HyperXKeyboardControllerDetect.cpp

@@ -1,10 +1,12 @@
 #include "Detector.h"
 #include "HyperXAlloyElite2Controller.h"
 #include "HyperXAlloyOriginsController.h"
+#include "HyperXAlloyOriginsCoreController.h"
 #include "HyperXKeyboardController.h"
 #include "RGBController.h"
 #include "RGBController_HyperXAlloyElite2.h"
 #include "RGBController_HyperXAlloyOrigins.h"
+#include "RGBController_HyperXAlloyOriginsCore.h"
 #include "RGBController_HyperXKeyboard.h"
 #include <hidapi/hidapi.h>
 
@@ -41,6 +43,19 @@ void DetectHyperXAlloyOrigins(hid_device_info* info, const std::string& name)
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
+
+void DetectHyperXAlloyOriginsCore(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
+    {
+        HyperXAlloyOriginsCoreController* controller = new HyperXAlloyOriginsCoreController(dev, info);
+        RGBController_HyperXAlloyOriginsCore* rgb_controller = new RGBController_HyperXAlloyOriginsCore(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 void DetectHyperXAlloyElite2(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -53,15 +68,14 @@ void DetectHyperXAlloyElite2(hid_device_info* info, const std::string& name)
     }
 }
 
-REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite RGB",      DetectHyperXKeyboards,    HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_PID,            2, 0xFF01);
-REGISTER_HID_DETECTOR_IP("HyperX Alloy FPS RGB",        DetectHyperXKeyboards,    HYPERX_KEYBOARD_VID, HYPERX_ALLOY_FPS_RGB_PID,          2, 0xFF01);
+REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite RGB",      DetectHyperXKeyboards,        HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_PID,          2, 0xFF01);
+REGISTER_HID_DETECTOR_IP("HyperX Alloy FPS RGB",        DetectHyperXKeyboards,        HYPERX_KEYBOARD_VID, HYPERX_ALLOY_FPS_RGB_PID,        2, 0xFF01);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Origins Core",    DetectHyperXAlloyOriginsCore, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_CORE_PID,   2);
 
 #ifdef _WIN32
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins Core",    DetectHyperXAlloyOrigins, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_CORE_PID,     3);
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",         DetectHyperXAlloyOrigins, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,          3);
-REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite 2",        DetectHyperXAlloyElite2,  HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID,          3, 0xFF90);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",         DetectHyperXAlloyOrigins,     HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,        3);
+REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite 2",        DetectHyperXAlloyElite2,      HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID,        3, 0xFF90);
 #else
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins Core",    DetectHyperXAlloyOrigins, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_CORE_PID,     0);
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",         DetectHyperXAlloyOrigins, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,          0);
-REGISTER_HID_DETECTOR_I("HyperX Alloy Elite 2",         DetectHyperXAlloyElite2,  HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID,          0);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",         DetectHyperXAlloyOrigins,     HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,        0);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Elite 2",         DetectHyperXAlloyElite2,      HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID,        0);
 #endif

Controllers/HyperXKeyboardController/RGBController_HyperXAlloyOrigins.cpp

@@ -15,12 +15,12 @@ using namespace std::chrono_literals;
 #define NA  0xFFFFFFFF
 
 static unsigned int matrix_map[6][23] =
-    { {   0,  NA,  11,  17,  22,  27,  NA,  33,  38,  43,  49,  NA,  54,  60,  64,  68,  74,  78,  83,  NA,  NA,  NA,  NA },
-      {   1,   6,  12,  18,  23,  28,  34,  39,  44,  50,  55,  NA,  61,  65,  69,  NA,  75,  79,  84,  87,  92,  96, 101 },
-      {   2,  NA,   7,  13,  19,  24,  NA,  29,  35,  40,  45,  51,  56,  62,  66,  70,  76,  80,  85,  88,  93,  97, 102 },
-      {   3,  NA,   8,  14,  20,  25,  NA,  30,  36,  41,  46,  52,  57,  63,  71,  NA,  NA,  NA,  NA,  89,  94,  98,  NA },
-      {   4,  NA,   9,  15,  21,  26,  NA,  31,  NA,  37,  42,  47,  53,  58,  72,  NA,  NA,  81,  NA,  90,  95,  99, 103 },
-      {   5,  10,  16,  NA,  NA,  NA,  NA,  32,  NA,  NA,  NA,  NA,  48,  59,  67,  73,  77,  82,  86,  91,  NA, 100,  NA } };
+    { {   0,  NA,  12,  18,  23,  28,  NA,  34,  39,  44,  50,  NA,  55,  61,  65,  70,  76,  80,  85,  NA,  NA,  NA,  NA },
+      {   1,   7,  13,  19,  24,  29,  35,  40,  45,  51,  56,  NA,  62,  66,  71,  NA,  77,  81,  86,  89,  94,  98, 103 },
+      {   2,  NA,   8,  14,  20,  25,  NA,  30,  36,  41,  46,  52,  57,  63,  67,  72,  78,  82,  87,  90,  95,  99, 104 },
+      {   3,  NA,   9,  15,  21,  26,  NA,  31,  37,  42,  47,  53,  58,  64,  68,  73,  NA,  NA,  NA,  91,  96, 100,  NA },
+      {   4,  6,   10,  16,  22,  27,  NA,  32,  NA,  38,  43,  48,  54,  59,  74,  NA,  NA,  83,  NA,  92,  97, 101, 105 },
+      {   5,  11,  17,  NA,  NA,  NA,  NA,  33,  NA,  NA,  NA,  NA,  49,  60,  69,  75,  79,  84,  88,  93,  NA, 102,  NA } };
 
 static const char* zone_names[] =
 {
@@ -34,7 +34,7 @@ static zone_type zone_types[] =
 
 static const unsigned int zone_sizes[] =
 {
-    104,
+    106,
 };
 
 static const char *led_names[] =
@@ -45,7 +45,7 @@ static const char *led_names[] =
     "Key: Caps Lock",
     "Key: Left Shift",
     "Key: Left Control",
-    // Skip index 6
+    "Key: \\ (ISO)",
     "Key: 1",
     "Key: Q",
     "Key: A",
@@ -114,7 +114,7 @@ static const char *led_names[] =
     "Key: F11",
     "Key: =",
     "Key: ]",
-    // Skip index 75
+    "Key: #",
     // Skip index 76
     "Key: Menu",
     "Key: F12",
@@ -164,7 +164,7 @@ static const char *led_names[] =
     "Key: Number Pad +",
     // Skip index 123
     // Skip index 124
-    "Key: Number Pad Enter", 
+    "Key: Number Pad Enter",
 };
 
 RGBController_HyperXAlloyOrigins::RGBController_HyperXAlloyOrigins(HyperXAlloyOriginsController* hyperx_ptr)

Controllers/HyperXKeyboardController/RGBController_HyperXAlloyOriginsCore.cpp

@@ -0,0 +1,283 @@
+/*------------------------------------------*\
+|  RGBController_HyperXAlloyOriginsCore.cpp  |
+|                                            |
+|  Generic RGB Interface for HyperX Alloy    |
+|  Origins Core RGB Keyboard                 |
+|                                            |
+|  Volodymyr Nazarchuk (Vavooon) 4/28/2021   |
+\*------------------------------------------*/
+
+#include "RGBController_HyperXAlloyOriginsCore.h"
+
+using namespace std::chrono_literals;
+
+//0xFFFFFFFF indicates an unused entry in matrix
+#define NA  0xFFFFFFFF
+
+static unsigned int matrix_map[6][19] =
+{
+		{   0,  NA,   1,   2,   3,   4,   5,   6,   7,  44,  NA,  45,  46,  47,  48,  NA,  49,  50,  51 },
+		{   8,   9,  10,  11,  12,  13,  14,  15,  16,  52,  53,  54,  55,  56,  NA,  NA,  57,  58,  59 },
+		{  17,  NA,  18,  19,  20,  21,  22,  23,  24,  60,  61,  62,  63,  64,  65,  NA,  66,  67,  68 },
+		{  25,  NA,  26,  27,  28,  29,  30,  31,  32,  69,  70,  71,  72,  73,  NA,  NA,  NA,  NA,  NA },
+		{  33,  NA,  34,  35,  36,  37,  38,  NA,  39,  74,  75,  76,  77,  78,  NA,  NA,  NA,  79,  NA },
+		{  40,  41,  42,  NA,  NA,  NA,  43,  NA,  NA,  NA,  NA,  80,  81,  82,  83,  NA,  84,  85,  86 }
+};
+
+static const char* zone_names[] =
+{
+    "Keyboard",
+};
+
+static zone_type zone_types[] =
+{
+    ZONE_TYPE_MATRIX,
+};
+
+static const unsigned int zone_sizes[] =
+{
+    87,
+};
+
+static const char *led_names[] =
+{
+    "Key: Escape",
+    "Key: F1",
+    "Key: F2",
+    "Key: F3",
+    "Key: F4",
+    "Key: F5",
+    "Key: F6",
+    "Key: F7",
+
+    "Key: `",
+    "Key: 1",
+    "Key: 2",
+    "Key: 3",
+    "Key: 4",
+    "Key: 5",
+    "Key: 6",
+    "Key: 7",
+    "Key: 8",
+
+    "Key: Tab",
+    "Key: Q",
+    "Key: W",
+    "Key: E",
+    "Key: R",
+    "Key: T",
+    "Key: Y",
+    "Key: U",
+
+    "Key: Caps Lock",
+    "Key: A",
+    "Key: S",
+    "Key: D",
+    "Key: F",
+    "Key: G",
+    "Key: H",
+    "Key: J",
+
+    "Key: Left Shift",
+    "Key: Z",
+    "Key: X",
+    "Key: C",
+    "Key: V",
+    "Key: B",
+    "Key: N",
+
+    "Key: Left Control",
+    "Key: Left Windows",
+    "Key: Left Alt",
+    "Key: Space",
+
+	// End of first section
+
+    "Key: F8",
+    "Key: F9",
+    "Key: F10",
+    "Key: F11",
+    "Key: F12",
+    "Key: Print Screen",
+    "Key: Scroll Lock",
+    "Key: Pause/Break",
+
+    "Key: 9",
+    "Key: 0",
+    "Key: -",
+    "Key: =",
+    "Key: Backspace",
+    "Key: Insert",
+    "Key: Page Up",
+    "Key: Home",
+
+
+    "Key: I",
+    "Key: O",
+    "Key: P",
+    "Key: [",
+    "Key: ]",
+    "Key: \\ (ANSI)",
+    "Key: Delete",
+    "Key: Page Down",
+    "Key: End",
+
+
+    "Key: K",
+    "Key: L",
+    "Key: ;",
+    "Key: '",
+    "Key: Enter",
+
+
+    "Key: M",
+    "Key: ,",
+    "Key: .",
+    "Key: /",
+    "Key: Right Shift",
+    "Key: Up Arrow",
+    "Key: Right Alt",
+    "Key: Right Fn",
+    "Key: Menu",
+    "Key: Right Control",
+    "Key: Left Arrow",
+    "Key: Down Arrow",
+    "Key: Right Arrow"
+};
+
+RGBController_HyperXAlloyOriginsCore::RGBController_HyperXAlloyOriginsCore(HyperXAlloyOriginsCoreController* hyperx_ptr)
+{
+    hyperx = hyperx_ptr;
+
+    name        = "HyperX Alloy Origins Core Keyboard Device";
+    vendor      = "HyperX";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "HyperX Alloy Origins Core Keyboard Device";
+    location    = hyperx->GetDeviceLocation();
+    serial      = hyperx->GetSerialString();
+    version     = hyperx->GetFirmwareVersion();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0xFFFF;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+
+    /*-----------------------------------------------------*\
+    | The HyperX Origins Core requires a packet within few  |
+    | seconds of sending the lighting change in order to    |
+    | not revert back into current profile.  Start a thread |
+    | to continuously send color values each 10ms           |
+    \*-----------------------------------------------------*/
+    keepalive_thread_run = 1;
+    keepalive_thread = new std::thread(&RGBController_HyperXAlloyOriginsCore::KeepaliveThread, this);
+}
+
+RGBController_HyperXAlloyOriginsCore::~RGBController_HyperXAlloyOriginsCore()
+{
+    keepalive_thread_run = 0;
+    keepalive_thread->join();
+    delete keepalive_thread;
+
+    /*---------------------------------------------------------*\
+    | Delete the matrix map                                     |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    {
+        if(zones[zone_index].matrix_map != NULL)
+        {
+            delete zones[zone_index].matrix_map;
+        }
+    }
+
+    delete hyperx;
+}
+
+void RGBController_HyperXAlloyOriginsCore::SetupZones()
+{
+    unsigned int total_led_count = 0;
+    for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
+    {
+        zone new_zone;
+        new_zone.name                   = zone_names[zone_idx];
+        new_zone.type                   = zone_types[zone_idx];
+        new_zone.leds_min               = zone_sizes[zone_idx];
+        new_zone.leds_max               = zone_sizes[zone_idx];
+        new_zone.leds_count             = zone_sizes[zone_idx];
+
+        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
+        {
+            new_zone.matrix_map         = new matrix_map_type;
+            new_zone.matrix_map->height = 6;
+            new_zone.matrix_map->width  = 19;
+            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+        }
+        else
+        {
+            new_zone.matrix_map         = NULL;
+        }
+
+        zones.push_back(new_zone);
+
+        total_led_count += zone_sizes[zone_idx];
+    }
+
+    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
+    {
+        led new_led;
+        new_led.name = led_names[led_idx];
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_HyperXAlloyOriginsCore::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_HyperXAlloyOriginsCore::DeviceUpdateLEDs()
+{
+    hyperx->SetLEDsDirect(colors);
+}
+
+void RGBController_HyperXAlloyOriginsCore::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_HyperXAlloyOriginsCore::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_HyperXAlloyOriginsCore::SetCustomMode()
+{
+
+}
+
+void RGBController_HyperXAlloyOriginsCore::DeviceUpdateMode()
+{
+
+}
+
+void RGBController_HyperXAlloyOriginsCore::KeepaliveThread()
+{
+    while(keepalive_thread_run.load())
+    {
+        if(active_mode == 0)
+        {
+            if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50))
+            {
+                DeviceUpdateLEDs();
+            }
+        }
+        std::this_thread::sleep_for(10ms);
+    }
+}

Controllers/HyperXKeyboardController/RGBController_HyperXAlloyOriginsCore.h

@@ -0,0 +1,40 @@
+/*------------------------------------------*\
+|  RGBController_HyperXAlloyOriginsCore.h    |
+|                                            |
+|  Generic RGB Interface for HyperX Alloy    |
+|  Origins Core RGB Keyboard                 |
+|                                            |
+|  Volodymyr Nazarchuk (Vavooon) 4/28/2021   |
+\*------------------------------------------*/
+
+#pragma once
+#include <chrono>
+
+#include "RGBController.h"
+#include "HyperXAlloyOriginsCoreController.h"
+
+class RGBController_HyperXAlloyOriginsCore : public RGBController
+{
+public:
+    RGBController_HyperXAlloyOriginsCore(HyperXAlloyOriginsCoreController* hyperx_ptr);
+    ~RGBController_HyperXAlloyOriginsCore();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+    
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+    
+    void        KeepaliveThread();
+    
+private:
+    HyperXAlloyOriginsCoreController*                   hyperx;
+    std::thread*                                        keepalive_thread;
+    std::atomic<bool>                                   keepalive_thread_run;
+    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
+};

Controllers/HyperXMouseController/HyperXPulsefireDartController.cpp

@@ -30,7 +30,12 @@ std::string HyperXPulsefireDartController::GetDeviceLocation()
 std::string HyperXPulsefireDartController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/HyperXMouseController/HyperXPulsefireFPSProController.cpp

@@ -30,7 +30,12 @@ std::string HyperXPulsefireFPSProController::GetDeviceLocation()
 std::string HyperXPulsefireFPSProController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/HyperXMouseController/HyperXPulsefireSurgeController.cpp

@@ -30,7 +30,12 @@ std::string HyperXPulsefireSurgeController::GetDeviceLocation()
 std::string HyperXPulsefireSurgeController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/HyperXMousematController/HyperXMousematController.cpp

@@ -30,7 +30,12 @@ std::string HyperXMousematController::GetDeviceLocation()
 std::string HyperXMousematController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/LogitechController/LogitechControllerDetect.cpp

@@ -4,15 +4,18 @@
 #include "LogitechG203LController.h"
 #include "LogitechG213Controller.h"
 #include "LogitechG560Controller.h"
+#include "LogitechG933Controller.h"
 #include "LogitechG810Controller.h"
 #include "LogitechG910Controller.h"
 #include "LogitechG815Controller.h"
 #include "LogitechGLightsyncController.h"
 #include "LogitechLightspeedController.h"
+#include "LogitechX56Controller.h"
 #include "RGBController.h"
 #include "RGBController_LogitechG203L.h"
 #include "RGBController_LogitechG213.h"
 #include "RGBController_LogitechG560.h"
+#include "RGBController_LogitechG933.h"
 #include "RGBController_LogitechG810.h"
 #include "RGBController_LogitechG910.h"
 #include "RGBController_LogitechG815.h"
@@ -20,6 +23,7 @@
 #include "RGBController_LogitechGLightsync1zone.h"
 #include "RGBController_LogitechLightspeed.h"
 #include "RGBController_LogitechGPowerPlay.h"
+#include "RGBController_LogitechX56.h"
 #include <vector>
 #include <hidapi/hidapi.h>
 
@@ -72,6 +76,11 @@
 \*-----------------------------------------------------*/
 #define LOGITECH_G560_PID                       0x0A78
 
+/*-----------------------------------------------------*\
+| Headset product IDs                                   |
+\*-----------------------------------------------------*/
+#define LOGITECH_G933_PID                       0x0A5B
+
 /*-----------------------------------------------------*\
 | Unifying Device IDs (Including Lightspeed receivers)  |
 |   NB: Not used but preserved for debugging            |
@@ -90,6 +99,13 @@
 #define LOGITECH_G903_LIGHTSPEED_VIRTUAL_PID            0x4067
 #define LOGITECH_G_PRO_WIRELESS_VIRTUAL_PID             0x4079
 
+/*-----------------------------------------------------*\
+| Joystick product IDs                                  |
+\*-----------------------------------------------------*/
+#define LOGITECH_X56_VID                                0x0738
+#define LOGITECH_X56_JOYSTICK_PID                       0x2221
+#define LOGITECH_X56_THROTTLE_PID                       0xA221
+
 /*-----------------------------------------------------*\
 | Logitech Keyboards                                    |
 \*-----------------------------------------------------*/
@@ -441,9 +457,14 @@ void DetectLogitechMouseG403(hid_device_info* info, const std::string& name)
     addLogitechLightsyncMouse2zone(info, name, 0xFF, 0x0E, 0x3A);
 }
 
+void DetectLogitechMouseG502PS(hid_device_info* info, const std::string& name)
+{
+    addLogitechLightsyncMouse2zone(info, name, 0xFF, 0x02, 0x3A);
+}
+
 void DetectLogitechMouseGPRO(hid_device_info* info, const std::string& name)
 {
-    addLogitechLightsyncMouse2zone(info, name, 0x01, 0x07, 0x3C);
+    addLogitechLightsyncMouse1zone(info, name, 0xFF, 0x0E, 0x3C);
 }
 
 /*-----------------------------------------------------*\
@@ -465,6 +486,38 @@ void DetectLogitechG560(hid_device_info* info, const std::string& name)
     }
 }
 
+void DetectLogitechG933(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        /*---------------------------------------------*\
+        | Add G933 Headset                              |
+        \*---------------------------------------------*/
+        LogitechG933Controller*     controller     = new LogitechG933Controller(dev, info->path);
+        RGBController_LogitechG933* rgb_controller = new RGBController_LogitechG933(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectLogitechX56(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        /*---------------------------------------------*\
+        | Add X56 Devices                               |
+        \*---------------------------------------------*/
+        LogitechX56Controller*     controller     = new LogitechX56Controller(dev, info->path);
+        RGBController_LogitechX56* rgb_controller = new RGBController_LogitechX56(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 /*-------------------------------------------------------------------------------------------------------------------------------------------------*\
 | Keyboards                                                                                                                                         |
 \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
@@ -486,12 +539,23 @@ REGISTER_HID_DETECTOR_IP ("Logitech G203 Prodigy",                          Dete
 REGISTER_HID_DETECTOR_IPU("Logitech G203 Lightsync",                        DetectLogitechMouseG203L,   LOGITECH_VID, LOGITECH_G203_LIGHTSYNC_PID,          1, 0xFF00, 2);
 REGISTER_HID_DETECTOR_IP ("Logitech G303 Daedalus Apex",                    DetectLogitechMouseG303,    LOGITECH_VID, LOGITECH_G303_PID,                    1, 0xFF00);
 REGISTER_HID_DETECTOR_IP ("Logitech G403 Hero",                             DetectLogitechMouseG403,    LOGITECH_VID, LOGITECH_G403_HERO_PID,               1, 0xFF00);
+REGISTER_HID_DETECTOR_IP ("Logitech G502 Proteus Spectrum Gaming Mouse",    DetectLogitechMouseG502PS,  LOGITECH_VID, LOGITECH_G502_PROTEUS_SPECTRUM_PID,   1, 0xFF00);
+REGISTER_HID_DETECTOR_IP ("Logitech G502 Hero Gaming Mouse",                DetectLogitechMouseG502PS,  LOGITECH_VID, LOGITECH_G502_HERO_PID,               1, 0xFF00);
 REGISTER_HID_DETECTOR_IP ("Logitech G Pro Gaming Mouse",                    DetectLogitechMouseGPRO,    LOGITECH_VID, LOGITECH_G_PRO_PID,                   1, 0xFF00);
 REGISTER_HID_DETECTOR_IP ("Logitech G Pro (HERO) Gaming Mouse",             DetectLogitechMouseGPRO,    LOGITECH_VID, LOGITECH_G_PRO_HERO_PID,              1, 0xFF00);
 /*-------------------------------------------------------------------------------------------------------------------------------------------------*\
 | Speakers                                                                                                                                         |
 \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IPU("Logitech G560 Lightsync Speaker",                DetectLogitechG560,         LOGITECH_VID, LOGITECH_G560_PID,                    2, 0xFF43, 514);
+/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Headsets                                                                                                                                         |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IPU("Logitech G933 Lightsync Headset",                DetectLogitechG933,         LOGITECH_VID, LOGITECH_G933_PID,                    3, 0xFF43, 514);
+/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Joysticks                                                                                                                                         |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("Logitech X56 Rhino Hotas Joystick",               DetectLogitechX56,          LOGITECH_X56_VID, LOGITECH_X56_JOYSTICK_PID,        2, 0xFF00);
+REGISTER_HID_DETECTOR_IP("Logitech X56 Rhino Hotas Throttle",               DetectLogitechX56,          LOGITECH_X56_VID, LOGITECH_X56_THROTTLE_PID,        2, 0xFF00);
 
 /*---------------------------------------------------------------------------------------------------------*\
 | Windows and MacOS Lightspeed Detection                                                                    |
@@ -596,8 +660,6 @@ REGISTER_HID_DETECTOR_IP("Logitech G Powerplay Mousepad",
 | Lightspeed Wireless Devices (Windows Wired)                                                                                                       |
 \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IP("Logitech G403 Wireless Gaming Mouse (wired)",         DetectLogitechWired,                LOGITECH_VID, LOGITECH_G403_LIGHTSPEED_PID,         1, 0xFF00);
-REGISTER_HID_DETECTOR_IP("Logitech G502 Wireless Gaming Mouse (wired)",         DetectLogitechWired,                LOGITECH_VID, LOGITECH_G502_PROTEUS_SPECTRUM_PID,   1, 0xFF00);
-REGISTER_HID_DETECTOR_IP("Logitech G502 Hero Wireless Gaming Mouse (wired)",    DetectLogitechWired,                LOGITECH_VID, LOGITECH_G502_HERO_PID,               1, 0xFF00);
 REGISTER_HID_DETECTOR_IP("Logitech G502 Wireless Gaming Mouse (wired)",         DetectLogitechWired,                LOGITECH_VID, LOGITECH_G502_LIGHTSPEED_PID,         1, 0xFF00);
 REGISTER_HID_DETECTOR_IP("Logitech G703 Wireless Gaming Mouse (wired)",         DetectLogitechWired,                LOGITECH_VID, LOGITECH_G703_LIGHTSPEED_PID,         1, 0xFF00);
 REGISTER_HID_DETECTOR_IP("Logitech G900 Wireless Gaming Mouse (wired)",         DetectLogitechWired,                LOGITECH_VID, LOGITECH_G900_LIGHTSPEED_PID,         1, 0xFF00);
@@ -657,9 +719,7 @@ REGISTER_HID_DETECTOR_IPU("Logitech G Pro Wireless Gaming Mouse",
 | Lightspeed Wireless Devices (Linux Wired)                                                                                                          |
 \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IPU("Logitech G403 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G403_LIGHTSPEED_PID,         1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G502 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G502_PROTEUS_SPECTRUM_PID,   1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G502 Hero Wireless Gaming Mouse (wired)",   DetectLogitechWired,        LOGITECH_VID, LOGITECH_G502_LIGHTSPEED_PID,         1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G502 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G502_HERO_PID,               1, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G502 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G502_LIGHTSPEED_PID,         1, 0xFF00, 2);
 REGISTER_HID_DETECTOR_IPU("Logitech G703 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G703_LIGHTSPEED_PID,         1, 0xFF00, 2);
 REGISTER_HID_DETECTOR_IPU("Logitech G900 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G900_LIGHTSPEED_PID,         1, 0xFF00, 2);
 REGISTER_HID_DETECTOR_IPU("Logitech G903 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G903_LIGHTSPEED_PID,         1, 0xFF00, 2);

Controllers/LogitechController/LogitechG203LController.cpp

@@ -21,7 +21,12 @@ std::string LogitechG203LController::GetDeviceLocation()
 std::string LogitechG203LController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/LogitechController/LogitechG213Controller.cpp

@@ -28,7 +28,12 @@ std::string LogitechG213Controller::GetDeviceLocation()
 std::string LogitechG213Controller::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());
@@ -70,3 +75,78 @@ void LogitechG213Controller::SetDirect
     \*-----------------------------------------------------*/
     hid_write(dev, (unsigned char *)usb_buf, 20);
 }
+
+void LogitechG213Controller::SetMode
+    (
+    unsigned char       mode,
+    unsigned short      speed,
+    unsigned char       direction,
+    unsigned char       red,
+    unsigned char       green,
+    unsigned char       blue
+    )
+{
+    SendMode(LOGITECH_G213_ZONE_MODE_KEYBOARD, mode, speed, direction, red, green, blue);
+}
+
+void LogitechG213Controller::SendMode
+    (
+    unsigned char       zone,
+    unsigned char       mode,
+    unsigned short      speed,
+    unsigned char       direction,
+    unsigned char       red,
+    unsigned char       green,
+    unsigned char       blue
+    )
+{
+    char usb_buf[20];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Lighting Control packet                        |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x11;
+    usb_buf[0x01]           = 0xFF;
+    usb_buf[0x02]           = 0x0C;
+    usb_buf[0x03]           = 0x3C;
+    usb_buf[0x04]           = zone;
+
+    usb_buf[0x05]           = mode;
+
+    usb_buf[0x06]           = red;
+    usb_buf[0x07]           = green;
+    usb_buf[0x08]           = blue;
+
+    speed = 100 * speed;
+
+    if(mode == LOGITECH_G213_MODE_BREATHING)
+    {
+        usb_buf[0x09]       = speed >> 8;
+        usb_buf[0x0A]       = speed & 0xFF;
+        usb_buf[0x0C]       = 0x64;
+    }
+    else if(mode == LOGITECH_G213_MODE_CYCLE)
+    {
+        usb_buf[0x0B]       = speed >> 8;
+        usb_buf[0x0C]       = speed & 0xFF;
+        usb_buf[0x0D]       = 0x64;
+    }
+    else if(mode == LOGITECH_G213_MODE_WAVE)
+    {
+        usb_buf[0x0B]       = speed >> 8;
+        usb_buf[0x0C]       = speed & 0xFF;
+        usb_buf[0x0D]       = direction & 0xFF;
+        usb_buf[0x0F]       = speed >> 8;
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 20);
+    hid_read(dev, (unsigned char *)usb_buf, 20);
+}

Controllers/LogitechController/LogitechG213Controller.h

@@ -13,6 +13,39 @@
 
 #pragma once
 
+enum
+{
+    LOGITECH_G213_ZONE_MODE_KEYBOARD     = 0x00
+};
+
+enum
+{
+    LOGITECH_G213_MODE_OFF               = 0x00,
+    LOGITECH_G213_MODE_STATIC            = 0x01,
+    LOGITECH_G213_MODE_BREATHING         = 0x02,
+    LOGITECH_G213_MODE_CYCLE             = 0x03,
+    LOGITECH_G213_MODE_WAVE              = 0x04,
+};
+
+enum
+{
+    LOGITECH_G213_WAVE_MODE_LEFT         = 0x06,
+    LOGITECH_G213_WAVE_MODE_RIGHT        = 0x01,
+    LOGITECH_G213_WAVE_MODE_CENTER_EDGE  = 0x03,
+    LOGITECH_G213_WAVE_MODE_EDGE_CENTER  = 0x08,
+};
+
+/*---------------------------------------------------------------------------------------------*\
+| Speed is 1000 for fast and 20000 for slow.                                                    |
+| Values are multiplied by 100 later to give lots of GUI steps.                                 |
+\*---------------------------------------------------------------------------------------------*/
+enum
+{
+    LOGITECH_G213_SPEED_SLOWEST          = 0xC8,     /* Slowest speed                       */
+    LOGITECH_G213_SPEED_NORMAL           = 0x32,     /* Normal speed                        */
+    LOGITECH_G213_SPEED_FASTEST          = 0x0A,     /* Fastest speed                       */
+};
+
 class LogitechG213Controller
 {
 public:
@@ -30,8 +63,28 @@ public:
                     unsigned char       b
                     );
 
+    void        SetMode
+                    (
+                    unsigned char       mode,
+                    unsigned short      speed,
+                    unsigned char       direction,
+                    unsigned char       red,
+                    unsigned char       green,
+                    unsigned char       blue
+                    );
+
 private:
     hid_device* dev;
     std::string location;
 
+    void        SendMode
+                    (
+                    unsigned char       zone,
+                    unsigned char       mode,
+                    unsigned short      speed,
+                    unsigned char       direction,
+                    unsigned char       red,
+                    unsigned char       green,
+                    unsigned char       blue
+                    );
 };

Controllers/LogitechController/LogitechG810Controller.cpp

@@ -25,7 +25,12 @@ LogitechG810Controller::~LogitechG810Controller()
 std::string LogitechG810Controller::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev_pkt_0x11, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev_pkt_0x11, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/LogitechController/LogitechG815Controller.cpp

@@ -24,7 +24,12 @@ LogitechG815Controller::~LogitechG815Controller()
 std::string LogitechG815Controller::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev_pkt_0x11, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev_pkt_0x11, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/LogitechController/LogitechG910Controller.cpp

@@ -25,7 +25,12 @@ LogitechG910Controller::~LogitechG910Controller()
 std::string LogitechG910Controller::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev_pkt_0x11, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev_pkt_0x11, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/LogitechController/LogitechG933Controller.cpp

@@ -0,0 +1,146 @@
+/*-----------------------------------------*\
+|  LogitechG933Controller.cpp               |
+|                                           |
+|  Driver for Logitech G933 RGB Headset     |
+|                                           |
+|  Edbgon        06/21/2021                 |
+|  Based on                                 |
+|  TheRogueZeta   8/31/2020                 |
+\*-----------------------------------------*/
+
+#include "LogitechG933Controller.h"
+#include <cstring>
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace std::chrono_literals;
+
+LogitechG933Controller::LogitechG933Controller(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+LogitechG933Controller::~LogitechG933Controller()
+{
+    hid_close(dev);
+}
+
+std::string LogitechG933Controller::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+void LogitechG933Controller::SetDirectMode(uint8_t zone)
+{
+    unsigned char usb_buf[LOGI_G933_LED_PACKET_SIZE];
+
+    usb_buf[0x00]           = 0x11;
+    usb_buf[0x01]           = 0xFF;
+    usb_buf[0x02]           = 0x04;
+    usb_buf[0x03]           = 0xCA;
+    usb_buf[0x04]           = zone;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    fail_retry_write(dev, usb_buf, LOGI_G933_LED_PACKET_SIZE);
+}
+
+void LogitechG933Controller::SetOffMode(uint8_t zone)
+{
+    unsigned char usb_buf[LOGI_G933_LED_PACKET_SIZE];
+
+    usb_buf[0x00]           = 0x11;
+    usb_buf[0x01]           = 0xFF;
+    usb_buf[0x02]           = 0x04;
+    usb_buf[0x03]           = 0x3F;
+    usb_buf[0x04]           = zone;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    fail_retry_write(dev, usb_buf, LOGI_G933_LED_PACKET_SIZE);
+}
+
+void LogitechG933Controller::SendHeadsetMode
+    (
+    unsigned char       zone,
+    unsigned char       mode,
+    unsigned char       red,
+    unsigned char       green,
+    unsigned char       blue
+    )
+{
+    unsigned char usb_buf[LOGI_G933_LED_PACKET_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Lighting Control                               |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x11;
+    usb_buf[0x01]           = 0xFF;
+    usb_buf[0x02]           = 0x04;
+
+    /*-----------------------------------------------------*\
+    | This packet sets speaker into direct mode.  This mode |
+    | is used by Lightsync Ambilight and Music Visualizer   |
+    | realtime effect.                                      |
+    \*-----------------------------------------------------*/
+    usb_buf[0x03]           = 0x3A;
+
+    /*-----------------------------------------------------*\
+    | Set up mode and speed                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x04]           = zone;
+    usb_buf[0x05]           = mode;
+
+    /*-----------------------------------------------------*\
+    | And set up the colors                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x06]           = red;
+    usb_buf[0x07]           = green;
+    usb_buf[0x08]           = blue;
+
+    if(mode == LOGITECH_G933_MODE_DIRECT) //G933 only has Direct Mode.
+    {
+        usb_buf[0x09]       = 0x02;
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    fail_retry_write(dev, usb_buf, LOGI_G933_LED_PACKET_SIZE);
+}
+
+void LogitechG933Controller::fail_retry_write(hid_device *device, const unsigned char *data, size_t length)
+{
+    unsigned char usb_buf_out[LOGI_G933_LED_PACKET_SIZE];
+    unsigned int  write_max_retry = LOGI_G933_LED_COMMAND_SEND_RETRIES;
+    do
+    {
+        std::this_thread::sleep_for(1ms);
+        int ret = hid_write(device, data, length);
+
+        /*-------------------------------------------------------------------------------------*\
+        | HID write fails if a change led color and set volume command are sent at              |
+        | the same time because RGB controller and volume control shares the same interface.    |
+        \*-------------------------------------------------------------------------------------*/
+        if(ret == 20)
+        {
+            std::this_thread::sleep_for(1ms);
+            hid_read_timeout(dev, usb_buf_out, LOGI_G933_LED_PACKET_SIZE, 20);
+            break;
+        }
+        else
+        {
+            write_max_retry--;
+            std::this_thread::sleep_for(10ms);
+        }
+
+    }while (write_max_retry > 0);
+}

Controllers/LogitechController/LogitechG933Controller.h

@@ -0,0 +1,56 @@
+/*-----------------------------------------*\
+|  LogitechG933Controller.h                 |
+|                                           |
+|  Definitions and types for                |
+|  Logitech G933 RGB Headset                |
+|                                           |
+|  Edbgon        06/21/2021                 |
+|  Based on                                 |
+|  TheRogueZeta   8/31/2020                 |
+\*-----------------------------------------*/
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+#define LOGI_G933_LED_PACKET_SIZE               20
+#define LOGI_G933_LED_COMMAND_SEND_RETRIES      3
+
+enum
+{
+    LOGITECH_G933_MODE_OFF                      = 0x00,
+    LOGITECH_G933_MODE_DIRECT                   = 0x01,
+    LOGITECH_G933_MODE_CYCLE                    = 0x02,
+    LOGITECH_G933_MODE_BREATHING                = 0x03,
+};
+
+class LogitechG933Controller
+{
+public:
+    LogitechG933Controller(hid_device* dev_handle, const char* path);
+    ~LogitechG933Controller();
+
+    std::string GetDeviceLocation();
+
+    void SetDirectMode(uint8_t zone);
+    void SetOffMode(uint8_t zone);
+
+    void        SendHeadsetMode
+                   (
+                    unsigned char       zone,
+                    unsigned char       mode,
+                    unsigned char       red,
+                    unsigned char       green,
+                    unsigned char       blue
+                   );
+
+private:
+    hid_device*             dev;
+    std::string             location;
+
+    void fail_retry_write(hid_device *device, const unsigned char *data, size_t length);
+};
+
+

Controllers/LogitechController/LogitechGLightsyncController.cpp

@@ -46,7 +46,12 @@ std::string LogitechGLightsyncController::GetDeviceLocation()
 std::string LogitechGLightsyncController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/LogitechController/LogitechLightspeedController.cpp

@@ -30,7 +30,12 @@ std::string LogitechLightspeedController::GetDeviceLocation()
 std::string LogitechLightspeedController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/LogitechController/LogitechX56Controller.cpp

@@ -0,0 +1,83 @@
+/*-----------------------------------------*\
+|  LogitechX56Controller.cpp                |
+|                                           |
+|  Generic RGB Interface Logitech X56       |
+|  Class                                    |
+|                                           |
+|  Edbgon 11/06/2021                        |
+\*-----------------------------------------*/
+
+#include "LogitechX56Controller.h"
+#include <cstring>
+
+LogitechX56Controller::LogitechX56Controller(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+LogitechX56Controller::~LogitechX56Controller()
+{
+    hid_close(dev);
+}
+
+std::string LogitechX56Controller::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+char* LogitechX56Controller::GetDeviceName()
+{
+    return device_name;
+}
+
+std::string LogitechX56Controller::GetSerialString()
+{
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+    
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+void LogitechX56Controller::SetColor(RGBColor color)
+{
+    unsigned char buf[64];
+    unsigned char cbuf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+    memset(cbuf, 0x00, sizeof(cbuf));
+
+    /*-----------------------------------------------------*\
+    | Set up init packet                                    |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x09;
+    buf[0x02]   = 0x02;
+    buf[0x03]   = 0x64;
+
+    /*-----------------------------------------------------*\
+    | Set up color packet                                   |
+    \*-----------------------------------------------------*/
+    cbuf[0x00]  = 0x09;
+    cbuf[0x02]  = 0x03;
+    cbuf[0x03]  = RGBGetRValue(color);
+    cbuf[0x04]  = RGBGetGValue(color);
+    cbuf[0x05]  = RGBGetBValue(color);
+    
+    /*-----------------------------------------------------*\
+    | Send packets                                          |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, buf,  64);
+    hid_send_feature_report(dev, cbuf, 64);
+
+}

Controllers/LogitechController/LogitechX56Controller.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  LogitechX56Controller.h                  |
+|                                           |
+|  Generic RGB Interface Logitech X56       |
+|  Class                                    |
+|                                           |
+|  Edbgon 11/06/2021                        |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+class LogitechX56Controller
+{
+public:
+    LogitechX56Controller(hid_device* dev_handle, const char* path);
+
+    ~LogitechX56Controller();
+
+    std::string GetDeviceLocation();
+    char*       GetDeviceName();
+    std::string GetSerialString();
+
+    void SetColor(RGBColor colors);
+
+private:
+    char                    device_name[32];
+    hid_device*             dev;
+    std::string             location;
+};

Controllers/LogitechController/RGBController_LogitechG213.cpp

@@ -46,6 +46,47 @@ RGBController_LogitechG213::RGBController_LogitechG213(LogitechG213Controller* l
     Direct.color_mode               = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
+    mode Off;
+    Off.name                        = "Off";
+    Off.value                       = LOGITECH_G213_MODE_OFF;
+    Off.flags                       = 0;
+    Off.color_mode                  = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Cycle;
+    Cycle.name                      = "Cycle";
+    Cycle.value                     = LOGITECH_G213_MODE_CYCLE;
+    Cycle.flags                     = MODE_FLAG_HAS_SPEED;
+    Cycle.color_mode                = MODE_COLORS_NONE;
+    Cycle.speed_min                 = LOGITECH_G213_SPEED_SLOWEST;
+    Cycle.speed_max                 = LOGITECH_G213_SPEED_FASTEST;
+    Cycle.speed                     = LOGITECH_G213_SPEED_NORMAL;
+    modes.push_back(Cycle);
+
+    mode Wave;
+    Wave.name                      = "Wave";
+    Wave.value                     = LOGITECH_G213_MODE_WAVE;
+    Wave.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
+    Wave.color_mode                = MODE_COLORS_NONE;
+    Wave.speed_min                 = LOGITECH_G213_SPEED_SLOWEST;
+    Wave.speed_max                 = LOGITECH_G213_SPEED_FASTEST;
+    Wave.speed                     = LOGITECH_G213_SPEED_NORMAL;
+    Wave.direction                 = MODE_DIRECTION_LEFT;
+    modes.push_back(Wave);
+
+    mode Breathing;
+    Breathing.name                  = "Breathing";
+    Breathing.value                 = LOGITECH_G213_MODE_BREATHING;
+    Breathing.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Breathing.colors_min            = 1;
+    Breathing.colors_max            = 1;
+    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors.resize(1);
+    Breathing.speed_min             = LOGITECH_G213_SPEED_SLOWEST;
+    Breathing.speed_max             = LOGITECH_G213_SPEED_FASTEST;
+    Breathing.speed                 = LOGITECH_G213_SPEED_NORMAL;
+    modes.push_back(Breathing);
+
     SetupZones();
 }
 
@@ -117,4 +158,43 @@ void RGBController_LogitechG213::DeviceUpdateMode()
     | Direct mode does not send a mode packet                   |
     | Call UpdateLEDs to send direct packet                     |
     \*---------------------------------------------------------*/
+    if(active_mode == 0xFFFF)
+    {
+        UpdateLEDs();
+        return;
+    }
+
+    unsigned char red = 0;
+    unsigned char grn = 0;
+    unsigned char blu = 0;
+    unsigned char direction = 0;
+
+    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        red = RGBGetRValue(modes[active_mode].colors[0]);
+        grn = RGBGetGValue(modes[active_mode].colors[0]);
+        blu = RGBGetBValue(modes[active_mode].colors[0]);
+    }
+
+    switch (modes[active_mode].direction)
+    {
+        case MODE_DIRECTION_LEFT:
+            // Right to left
+            direction = LOGITECH_G213_WAVE_MODE_LEFT;
+            break;
+        case MODE_DIRECTION_RIGHT:
+            // Left to right
+            direction = LOGITECH_G213_WAVE_MODE_RIGHT;
+            break;
+        case MODE_DIRECTION_UP:
+            // Edge to center
+            direction = LOGITECH_G213_WAVE_MODE_EDGE_CENTER;
+            break;
+        case MODE_DIRECTION_DOWN:
+            // Center to edge
+            direction = LOGITECH_G213_WAVE_MODE_CENTER_EDGE;
+            break;
+    }
+
+    logitechG213->SetMode(modes[active_mode].value, modes[active_mode].speed, direction, red, grn, blu);
 }

Controllers/LogitechController/RGBController_LogitechG815.cpp

@@ -21,7 +21,7 @@ static unsigned int matrix_map[7][27] =
       { NA,  NA,  37,  NA,  54,  55,  56,  57,  NA,  58,  59,  60,  61,  NA,  62,  63,  64,  65,  NA,  66,  67,  68,  NA,  106, 107, 108, 109 },
       { 112, NA,  49,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  NA,  41,  42,  38,  NA,  NA,  69,  70,  71,  NA,  79,  80,  81,  82  },
       { 113, NA,  39,  NA,  16,  22,  4,   17,  NA,  19,  24,  20,  8,   14,  15,  43,  44,  45,  NA,  72,  73,  74,  NA,  91,  92,  93,  83  },
-      { 114, NA,  53,  NA,  0,   18,  3,   5,   NA,  6,   7,   9,   10,  11,  47,  48,  36,  NA,  NA,  NA,  NA,  NA,  NA,  88,  89,  90,  NA  },
+      { 114, NA,  53,  NA,  0,   18,  3,   5,   NA,  6,   7,   9,   10,  11,  47,  48,  46,  36,  NA,  NA,  NA,  NA,  NA,  88,  89,  90,  NA  },
       { 115, NA,  99,  NA,  25,  23,  2,   21,  NA,  1,   NA,  13,  12,  50,  51,  52,  103, NA,  NA,  NA,  78,  NA,  NA,  85,  86,  87,  84  },
       { 116, NA,  98,  101, 100, NA,  NA,  NA,  NA,  40,  NA,  NA,  NA,  NA,  104, 105, 97,  102, NA,  76,  77,  75,  NA,  94,  NA,  95,  NA  }  };
 

Controllers/LogitechController/RGBController_LogitechG933.cpp

@@ -0,0 +1,125 @@
+/*-----------------------------------------*\
+|  RGBController_LogitechG933.cpp           |
+|                                           |
+|  Generic RGB Interface for                |
+|  Logitech G933 RGB Headset                |
+|                                           |
+|  Edbgon        06/21/2021                 |
+|  Based on                                 |
+|  TheRogueZeta   8/31/2020                 |
+\*-----------------------------------------*/
+
+#include "RGBController_LogitechG933.h"
+
+RGBController_LogitechG933::RGBController_LogitechG933(LogitechG933Controller* logitech_ptr)
+{
+    logitech    = logitech_ptr;
+
+    name        = "Logitech G933 Lightsync Headset";
+    vendor      = "Logitech";
+    type        = DEVICE_TYPE_HEADSET;
+    description = "Logitech G933 Lightsync Headset";
+    location    = logitech->GetDeviceLocation();
+
+    mode Off;
+    Off.name                = "Off";
+    Off.value               = LOGITECH_G933_MODE_OFF;
+    Off.flags               = 0;
+    Off.color_mode          = MODE_COLORS_PER_LED;
+    modes.push_back(Off);
+
+    mode Direct;
+    Direct.name             = "Direct";
+    Direct.value            = LOGITECH_G933_MODE_DIRECT;
+    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+    SetupZones();
+}
+
+void RGBController_LogitechG933::SetupZones()
+{
+    zone G933_logo;
+    G933_logo.name           = "Logo";
+    G933_logo.type           = ZONE_TYPE_SINGLE;
+    G933_logo.leds_min       = 1;
+    G933_logo.leds_max       = 1;
+    G933_logo.leds_count     = 1;
+    G933_logo.matrix_map     = NULL;
+    zones.push_back(G933_logo);
+
+    led G933_logo_led;
+    G933_logo_led.name = "Logo";
+    G933_logo_led.value = 0x00;
+    leds.push_back(G933_logo_led);
+
+    zone G933_strip;
+    G933_strip.name           = "LED Strip";
+    G933_strip.type           = ZONE_TYPE_SINGLE;
+    G933_strip.leds_min       = 1;
+    G933_strip.leds_max       = 1;
+    G933_strip.leds_count     = 1;
+    G933_strip.matrix_map     = NULL;
+    zones.push_back(G933_strip);
+
+    led G933_strip_led;
+    G933_strip_led.name = "Led Strip";
+    G933_strip_led.value = 0x01;
+    leds.push_back(G933_strip_led);
+
+    SetupColors();
+}
+
+void RGBController_LogitechG933::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_LogitechG933::DeviceUpdateLEDs()
+{
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        unsigned char red = RGBGetRValue(colors[led_idx]);
+        unsigned char grn = RGBGetGValue(colors[led_idx]);
+        unsigned char blu = RGBGetBValue(colors[led_idx]);
+        logitech->SendHeadsetMode((unsigned char)leds[led_idx].value, modes[active_mode].value, red, grn, blu);
+    }
+}
+
+void RGBController_LogitechG933::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_LogitechG933::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_LogitechG933::SetCustomMode()
+{
+    active_mode = 1;
+}
+
+void RGBController_LogitechG933::DeviceUpdateMode()
+{
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        if(modes[active_mode].value == LOGITECH_G933_MODE_OFF)
+        {
+            logitech->SetOffMode(leds[led_idx].value);
+        }
+        else
+        {
+            /*---------------------------------------------------------*\
+            | Required to "reset" RGB controller and start receiving    |
+            | color in direct mode                                      |
+            \*---------------------------------------------------------*/
+            logitech->SetDirectMode(leds[led_idx].value);
+        }
+
+    }
+    DeviceUpdateLEDs();
+}

Controllers/LogitechController/RGBController_LogitechG933.h

@@ -0,0 +1,34 @@
+/*-----------------------------------------*\
+|  RGBController_LogitechG933.h             |
+|                                           |
+|  Generic RGB Interface for                |
+|  G933 RGB Headset                         |
+|                                           |
+|  Edbgon        06/21/2021                 |
+|  Based on                                 |
+|  TheRogueZeta   8/31/2020                 |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "LogitechG933Controller.h"
+
+class RGBController_LogitechG933 : public RGBController
+{
+public:
+    RGBController_LogitechG933(LogitechG933Controller* logitech_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:
+    LogitechG933Controller*   logitech;
+};

Controllers/LogitechController/RGBController_LogitechX56.cpp

@@ -0,0 +1,94 @@
+/*-----------------------------------------*\
+|  RGBController_LogitechX56.cpp            |
+|                                           |
+|  Generic RGB Interface Logitech X56       |
+|  Class                                    |
+|                                           |
+|  Edbgon 11/06/2021                        |
+\*-----------------------------------------*/
+
+#include "RGBController_LogitechX56.h"
+
+RGBController_LogitechX56::RGBController_LogitechX56(LogitechX56Controller* controller_ptr)
+{
+    controller  = controller_ptr;
+    
+    name        = controller->GetDeviceName();
+    vendor      = "Logitech";
+    type        = DEVICE_TYPE_GAMEPAD; 
+    description = "Logitech X56 Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+}
+
+RGBController_LogitechX56::~RGBController_LogitechX56()
+{
+    delete controller;
+}
+
+void RGBController_LogitechX56::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Each device has only one zone and LED                     |
+    \*---------------------------------------------------------*/
+    zone x56_zone;
+    x56_zone.name           = "X56";
+    x56_zone.type           = ZONE_TYPE_SINGLE;
+    x56_zone.leds_min       = 1;
+    x56_zone.leds_max       = 1;
+    x56_zone.leds_count     = 1;
+    x56_zone.matrix_map     = NULL;
+    zones.push_back(x56_zone);
+
+    led x56_led;
+    x56_led.name            = "X56";
+    leds.push_back(x56_led);
+
+    SetupColors();
+}
+
+void RGBController_LogitechX56::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_LogitechX56::DeviceUpdateLEDs()
+{
+    controller->SetColor(colors[0]);
+}
+
+void RGBController_LogitechX56::UpdateZoneLEDs(int /*zone*/)
+{
+    /*---------------------------------------------------------*\
+    | Packet expects both LEDs                                  |
+    \*---------------------------------------------------------*/
+    DeviceUpdateLEDs();
+}
+
+void RGBController_LogitechX56::UpdateSingleLED(int /*led*/)
+{
+    /*---------------------------------------------------------*\
+    | Packet expects both LEDs                                  |
+    \*---------------------------------------------------------*/
+    DeviceUpdateLEDs();
+}
+
+void RGBController_LogitechX56::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_LogitechX56::DeviceUpdateMode()
+{
+    DeviceUpdateLEDs();
+}

Controllers/LogitechController/RGBController_LogitechX56.h

@@ -0,0 +1,34 @@
+/*-----------------------------------------*\
+|  RGBController_LogitechX56.h              |
+|                                           |
+|  Generic RGB Interface Logitech X56       |
+|  Class                                    |
+|                                           |
+|  Edbgon 11/06/2021                        |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "LogitechX56Controller.h"
+
+class RGBController_LogitechX56 : public RGBController
+{
+public:
+    RGBController_LogitechX56(LogitechX56Controller* controller_ptr);
+    ~RGBController_LogitechX56();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    LogitechX56Controller*      controller;
+};

Controllers/MSI3ZoneController/MSI3ZoneController.cpp

@@ -35,7 +35,12 @@ std::string MSI3ZoneController::GetDeviceLocation()
 std::string MSI3ZoneController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/MSIGPUController/MSIGPUControllerDetect.cpp

@@ -36,8 +36,8 @@ static const msi_gpu_pci_device device_list[] =
     { NVIDIA_VEN,   NVIDIA_RTX2060_TU104_DEV,   MSI_SUB_VEN,    MSI_RTX2060_GAMING_Z_6G_SUB_DEV,        "MSI GeForce RTX 2060 Gaming Z 6G"              },
     { NVIDIA_VEN,   NVIDIA_RTX2060_TU106_DEV,   MSI_SUB_VEN,    MSI_RTX2060_GAMING_Z_6G_SUB_DEV,        "MSI GeForce RTX 2060 Gaming Z 6G"              },
     { NVIDIA_VEN,   NVIDIA_RTX2060_TU106_DEV,   MSI_SUB_VEN,    MSI_RTX2060_GAMING_Z_6G_SUB_DEV_2,      "MSI GeForce RTX 2060 Gaming Z 6G"              },
-    { NVIDIA_VEN,   NVIDIA_RTX2060S_DEV,        MSI_SUB_VEN,    MSI_RTX2060S_GAMING_X_SUB_DEV,          "MSI GeForce RTX 2060 Super Gaming X"           },
-    { NVIDIA_VEN,   NVIDIA_RTX2060S_DEV,        MSI_SUB_VEN,    MSI_RTX2060S_ARMOR_OC_SUB_DEV,          "MSI GeForce RTX 2060 Super ARMOR OC"           },
+    { NVIDIA_VEN,   NVIDIA_RTX2060S_OC_DEV,     MSI_SUB_VEN,    MSI_RTX2060S_GAMING_X_SUB_DEV,          "MSI GeForce RTX 2060 Super Gaming X"           },
+    { NVIDIA_VEN,   NVIDIA_RTX2060S_OC_DEV,     MSI_SUB_VEN,    MSI_RTX2060S_ARMOR_OC_SUB_DEV,          "MSI GeForce RTX 2060 Super ARMOR OC"           },
     { NVIDIA_VEN,   NVIDIA_RTX2070_OC_DEV,      MSI_SUB_VEN,    MSI_RTX2070_GAMING_Z_SUB_DEV,           "MSI GeForce RTX 2070 Gaming Z"                 },
     { NVIDIA_VEN,   NVIDIA_RTX2070_DEV,         MSI_SUB_VEN,    MSI_RTX2070_GAMING_SUB_DEV,             "MSI GeForce RTX 2070 Gaming"                   },
     { NVIDIA_VEN,   NVIDIA_RTX2070_DEV,         MSI_SUB_VEN,    MSI_RTX2070_ARMOR_SUB_DEV,              "MSI GeForce RTX 2070 ARMOR"                    },

Controllers/NZXTHue2Controller/NZXTHue2Controller.cpp

@@ -71,7 +71,12 @@ std::string NZXTHue2Controller::GetFirmwareVersion()
 std::string NZXTHue2Controller::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/NZXTHue2Controller/NZXTHue2ControllerDetect.cpp

@@ -11,6 +11,7 @@
 #define NZXT_SMART_DEVICE_V2_PID    0x2006
 #define NZXT_KRAKEN_X3_PID          0x2007
 #define NZXT_RGB_FAN_CONTROLLER_PID 0x2009
+#define NZXT_SMART_DEVICE_V2_1_PID  0x200D
 
 static void spawn_hue(hid_device_info* info, const std::string& name, int rgb_channels, int fan_channels)
 {
@@ -60,3 +61,4 @@ REGISTER_HID_DETECTOR("NZXT Hue 2 Motherboard",    DetectNZXTHue2Motherboard, NZ
 REGISTER_HID_DETECTOR("NZXT Smart Device V2",      DetectNZXTSmartDeviceV2,   NZXT_VID, NZXT_SMART_DEVICE_V2_PID);
 REGISTER_HID_DETECTOR("NZXT Kraken X3",            DetectNZXTKrakenX3,        NZXT_VID, NZXT_KRAKEN_X3_PID);
 REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController,   NZXT_VID, NZXT_RGB_FAN_CONTROLLER_PID);
+REGISTER_HID_DETECTOR("NZXT Smart Device V2",      DetectNZXTSmartDeviceV2,   NZXT_VID, NZXT_SMART_DEVICE_V2_1_PID);

Controllers/NZXTKrakenController/NZXTKrakenController.cpp

@@ -56,7 +56,12 @@ std::string NZXTKrakenController::GetLocation()
 std::string NZXTKrakenController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/PatriotViperController/PatriotViperControllerDetect.cpp

@@ -37,32 +37,44 @@ void DetectPatriotViperControllers(std::vector<i2c_smbus_interface*> &busses)
                 // Test for Patriot Viper RGB SPD at slot_addr
                 // This test was copied from Viper RGB software
                 // Tests SPD addresses in order: 0x00, 0x40, 0x41, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68
-                busses[bus]->i2c_smbus_write_byte_data(0x36, 0x00, 0xFF);
+                bool pass = false;
 
-                std::this_thread::sleep_for(1ms);
+                int res = busses[bus]->i2c_smbus_read_byte(slot_addr);
 
-                if(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x00) == 0x23)
+                if (res >= 0)
                 {
-                    busses[bus]->i2c_smbus_write_byte_data(0x37, 0x00, 0xFF);
+                    pass = true;
+                }
+
+                if(pass)
+                {
+                    busses[bus]->i2c_smbus_write_byte_data(0x36, 0x00, 0xFF);
 
                     std::this_thread::sleep_for(1ms);
 
-                    if((busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x40) == 0x85)
-                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x41) == 0x02)
-                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x61) == 0x4D)
-                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x62) == 0x49)
-                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x63) == 0x43)
-                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x64) == 0x53)
-                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x65) == 0x59)
-                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x66) == 0x53)
-                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x67) == 0x5f)
-                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x68) == 0x44))
+                    if(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x00) == 0x23)
                     {
-                        slots_valid |= (1 << (slot_addr - 0x50));
-                    }
-                }
+                        busses[bus]->i2c_smbus_write_byte_data(0x37, 0x00, 0xFF);
 
-                std::this_thread::sleep_for(1ms);
+                        std::this_thread::sleep_for(1ms);
+
+                        if((busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x40) == 0x85)
+                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x41) == 0x02)
+                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x61) == 0x4D)
+                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x62) == 0x49)
+                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x63) == 0x43)
+                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x64) == 0x53)
+                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x65) == 0x59)
+                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x66) == 0x53)
+                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x67) == 0x5f)
+                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x68) == 0x44))
+                        {
+                            slots_valid |= (1 << (slot_addr - 0x50));
+                        }
+                    }
+
+                    std::this_thread::sleep_for(1ms);
+                }
             }
 
             if(slots_valid != 0)

Controllers/PhilipsHueController/PhilipsHueController.cpp

@@ -0,0 +1,81 @@
+/*---------------------------------------------------------*\
+|  Driver for Philips Hue                                   |
+|                                                           |
+|  Adam Honse ([email protected]), 9/15/2020        |
+\*---------------------------------------------------------*/
+
+#include "PhilipsHueController.h"
+
+PhilipsHueController::PhilipsHueController(hueplusplus::Light& light_ptr, std::string bridge_ip):light(light_ptr)
+{
+    dark        = false;
+    location    = "IP: " + bridge_ip;
+}
+
+PhilipsHueController::~PhilipsHueController()
+{
+
+}
+
+std::string PhilipsHueController::GetLocation()
+{
+    return(location);
+}
+
+std::string PhilipsHueController::GetName()
+{
+    return(light.getModelId());
+}
+
+std::string PhilipsHueController::GetVersion()
+{
+    return(light.getSwVersion());
+}
+
+std::string PhilipsHueController::GetManufacturer()
+{
+    return(light.getManufacturername());
+}
+
+std::string PhilipsHueController::GetUniqueID()
+{
+    return(light.getUId());
+}
+
+void PhilipsHueController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    hueplusplus::RGB rgb;
+    rgb.r = red;
+    rgb.g = green;
+    rgb.b = blue;
+
+    if((red == 0) && (green == 0) && (blue == 0))
+    {
+        if(!dark)
+        {
+            try
+            {
+                light.setColorRGB(rgb, 0);
+            }
+            catch(std::exception& e)
+            {
+
+            }
+        }
+
+        dark = true;    
+    }
+    else
+    {
+        dark = false;
+
+        try
+        {
+            light.setColorRGB(rgb, 0);
+        }
+        catch(std::exception& e)
+        {
+            
+        }
+    }
+}

Controllers/PhilipsHueController/PhilipsHueController.h

@@ -0,0 +1,33 @@
+/*---------------------------------------------------------*\
+|  Definitions for Philips Hue                              |
+|                                                           |
+|  Adam Honse ([email protected]), 9/15/2020        |
+\*---------------------------------------------------------*/
+
+#include "RGBController.h"
+#include "HueDeviceTypes.h"
+
+#include <string>
+#include <vector>
+
+#pragma once
+
+class PhilipsHueController
+{
+public:
+    PhilipsHueController(hueplusplus::Light& light_ptr, std::string bridge_ip);
+    ~PhilipsHueController();
+
+    std::string GetLocation();
+    std::string GetName();
+    std::string GetVersion();
+    std::string GetManufacturer();
+    std::string GetUniqueID();
+
+    void SetColor(unsigned char red, unsigned char green, unsigned char blue);
+
+private:
+    hueplusplus::Light& light;
+    std::string         location;
+    bool                dark;
+};

Controllers/PhilipsHueController/PhilipsHueControllerDetect.cpp

@@ -0,0 +1,232 @@
+#include "Bridge.h"
+#include "HueDeviceTypes.h"
+
+#ifdef _WIN32
+#include "WinHttpHandler.h"
+#else
+#include "LinHttpHandler.h"
+#endif
+
+#include "Detector.h"
+#include "LogManager.h"
+#include "PhilipsHueController.h"
+#include "PhilipsHueEntertainmentController.h"
+#include "RGBController_PhilipsHue.h"
+#include "RGBController_PhilipsHueEntertainment.h"
+#include "SettingsManager.h"
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectPhilipsHueControllers                                                            *
+*                                                                                          *
+*       Detect Philips Hue lighting devices with RGB control                               *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectPhilipsHueControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    json                    hue_settings;
+
+    /*-------------------------------------------------*\
+    | Create an HTTP handler                            |
+    \*-------------------------------------------------*/
+#ifdef _WIN32
+    using SystemHttpHandler = hueplusplus::WinHttpHandler;
+#else
+    using SystemHttpHandler = hueplusplus::LinHttpHandler;
+#endif
+
+    /*-------------------------------------------------*\
+    | Get Philips Hue settings from settings manager    |
+    \*-------------------------------------------------*/
+    hue_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("PhilipsHueDevices");
+
+    /*-------------------------------------------------*\
+    | Create a finder and find bridges                  |
+    \*-------------------------------------------------*/
+    static hueplusplus::BridgeFinder finder(std::make_shared<SystemHttpHandler>());
+    std::vector<hueplusplus::BridgeFinder::BridgeIdentification> bridges;// = finder.findBridges();
+
+    /*-------------------------------------------------*\
+    | If no bridges were detected, manually add bridge  |
+    | IP and MAC (need to get these from file)          |
+    \*-------------------------------------------------*/
+    if(bridges.empty())
+    {
+        if(hue_settings.contains("bridges"))
+        {
+            hueplusplus::BridgeFinder::BridgeIdentification ident;
+
+            if(hue_settings["bridges"][0].contains("ip"))
+            {
+                ident.ip = hue_settings["bridges"][0]["ip"];
+            }
+
+            if(hue_settings["bridges"][0].contains("mac"))
+            {
+                ident.mac = hue_settings["bridges"][0]["mac"];
+            }
+
+            bridges.push_back(ident);
+        }
+    }
+
+    /*-------------------------------------------------*\
+    | If no bridges were found, return, otherwise       |
+    | connect to the first bridge                       |
+    \*-------------------------------------------------*/
+    if(bridges.empty())
+    {
+        return;
+    }
+    else
+    {
+        /*-------------------------------------------------*\
+        | Check if a saved username exists                  |
+        \*-------------------------------------------------*/
+        if(hue_settings.contains("bridges"))
+        {
+            /*-------------------------------------------------*\
+            | Add the username if it exists                     |
+            \*-------------------------------------------------*/
+            if(hue_settings["bridges"][0].contains("username"))
+            {
+                finder.addUsername(bridges[0].mac, hue_settings["bridges"][0]["username"]);
+            }
+            
+            /*-------------------------------------------------*\
+            | Add the client key if it exists                   |
+            \*-------------------------------------------------*/
+            if(hue_settings["bridges"][0].contains("clientkey"))
+            {
+                finder.addClientKey(bridges[0].mac, hue_settings["bridges"][0]["clientkey"]);
+            }
+        }
+
+        /*-------------------------------------------------*\
+        | If username was added, this should connect right  |
+        | away.  If not, the user will have to push the     |
+        | connect button on the bridge.                     |
+        \*-------------------------------------------------*/
+        try
+        {
+            static hueplusplus::Bridge bridge = finder.getBridge(bridges[0]);
+
+            bridge.refresh();
+
+            /*-------------------------------------------------*\
+            | Check to see if we need to save the settings      |
+            | Settings need to be saved if either username or   |
+            | client key either do not exist or have changed    |
+            \*-------------------------------------------------*/
+            bool save_settings = false;
+            bool use_entertainment = false;
+
+            if(hue_settings.contains("bridges"))
+            {
+                if(hue_settings["bridges"][0].contains("username"))
+                {
+                    if(hue_settings["bridges"][0]["username"] != bridge.getUsername())
+                    {
+                        save_settings = true;
+                    }
+                }
+                else
+                {
+                    save_settings = true;
+                }
+
+                if(hue_settings["bridges"][0].contains("clientkey"))
+                {
+                    if(hue_settings["bridges"][0]["clientkey"] != bridge.getClientKey())
+                    {
+                        use_entertainment = true;
+                        save_settings = true;
+                    }
+                }
+                else
+                {
+                    save_settings = true;
+                }
+            }
+
+            /*-------------------------------------------------*\
+            | Save the settings if needed                       |
+            \*-------------------------------------------------*/
+            if(save_settings)
+            {
+                hue_settings["bridges"][0]["username"] = bridge.getUsername();
+                hue_settings["bridges"][0]["clientkey"] = bridge.getClientKey();
+                hue_settings["bridges"][0]["entertainment"] = use_entertainment;
+
+                ResourceManager::get()->GetSettingsManager()->SetSettings("PhilipsHueDevices", hue_settings);
+
+                ResourceManager::get()->GetSettingsManager()->SaveSettings();
+            }
+
+            /*-------------------------------------------------*\
+            | Get all groups from the bridge                    |
+            \*-------------------------------------------------*/
+            if(hue_settings["bridges"][0].contains("entertainment"))
+            {
+                use_entertainment = hue_settings["bridges"][0]["entertainment"];
+            }
+
+            /*-------------------------------------------------*\
+            | Get all groups from the bridge                    |
+            \*-------------------------------------------------*/
+            if(use_entertainment)
+            {
+                std::vector<hueplusplus::Group> groups = bridge.groups().getAll();
+
+                if(groups.size() > 0)
+                {
+                    /*-------------------------------------------------*\
+                    | Loop through all available groups and check to    |
+                    | see if any are Entertainment groups               |
+                    \*-------------------------------------------------*/
+                    for(unsigned int group_idx = 0; group_idx < groups.size(); group_idx++)
+                    {
+                        if(groups[group_idx].getType() == "Entertainment")
+                        {
+                            PhilipsHueEntertainmentController*       new_controller    = new PhilipsHueEntertainmentController(bridge, groups[group_idx]);
+                            RGBController_PhilipsHueEntertainment*   new_rgbcontroller = new RGBController_PhilipsHueEntertainment(new_controller);
+                            rgb_controllers.push_back(new_rgbcontroller);
+                        }
+                    }
+                }
+            }
+
+            /*-------------------------------------------------*\
+            | Get all lights from the bridge                    |
+            \*-------------------------------------------------*/
+            else
+            {
+                std::vector<hueplusplus::Light> lights = bridge.lights().getAll();
+
+                if(lights.size() > 0)
+                {
+                    /*-------------------------------------------------*\
+                    | Loop through all available lights and add those   |
+                    | that have color (RGB) control capability          |
+                    \*-------------------------------------------------*/
+                    for(unsigned int light_idx = 0; light_idx < lights.size(); light_idx++)
+                    {
+                        if(lights[light_idx].hasColorControl())
+                        {
+                            PhilipsHueController*       new_controller    = new PhilipsHueController(lights[light_idx], bridge.getBridgeIP());
+                            RGBController_PhilipsHue*   new_rgbcontroller = new RGBController_PhilipsHue(new_controller);
+                            rgb_controllers.push_back(new_rgbcontroller);
+                        }
+                    }
+                }
+            }
+        }
+        catch(std::exception &e)
+        {
+            LOG_NOTICE("Exception occurred in Philips Hue detection");
+        }
+    }
+}   /* DetectPhilipsHueControllers() */
+
+REGISTER_DETECTOR("Philips Hue", DetectPhilipsHueControllers);

Controllers/PhilipsHueController/PhilipsHueEntertainmentController.cpp

@@ -0,0 +1,82 @@
+/*---------------------------------------------------------*\
+|  Driver for Philips Hue Entertainment Mode                |
+|                                                           |
+|  Adam Honse ([email protected]), 11/6/2020        |
+\*---------------------------------------------------------*/
+
+#include "PhilipsHueEntertainmentController.h"
+
+PhilipsHueEntertainmentController::PhilipsHueEntertainmentController(hueplusplus::Bridge& bridge_ptr, hueplusplus::Group& group_ptr):bridge(bridge_ptr),group(group_ptr)
+{
+    /*-------------------------------------------------*\
+    | Fill in location string with bridge IP            |
+    \*-------------------------------------------------*/
+    location                            = "IP: " + bridge.getBridgeIP();
+    num_leds                            = group.getLightIds().size();
+
+    /*-------------------------------------------------*\
+    | Create Entertainment Mode from bridge and group   |
+    \*-------------------------------------------------*/
+    entertainment = new hueplusplus::EntertainmentMode(bridge, group);
+
+    /*-------------------------------------------------*\
+    | Connect Hue Entertainment Mode                    |
+    \*-------------------------------------------------*/
+    entertainment->connect();
+}
+
+PhilipsHueEntertainmentController::~PhilipsHueEntertainmentController()
+{
+    /*-------------------------------------------------*\
+    | Disconnect Hue Entertainment Mode                 |
+    \*-------------------------------------------------*/
+    entertainment->disconnect();
+}
+
+std::string PhilipsHueEntertainmentController::GetLocation()
+{
+    return(location);
+}
+
+std::string PhilipsHueEntertainmentController::GetName()
+{
+    return(group.getName());
+}
+
+std::string PhilipsHueEntertainmentController::GetVersion()
+{
+    return("");
+}
+
+std::string PhilipsHueEntertainmentController::GetManufacturer()
+{
+    return("");
+}
+
+std::string PhilipsHueEntertainmentController::GetUniqueID()
+{
+    return("");
+}
+
+unsigned int PhilipsHueEntertainmentController::GetNumLEDs()
+{
+    return(num_leds);
+}
+
+void PhilipsHueEntertainmentController::SetColor(RGBColor* colors)
+{
+    /*-------------------------------------------------*\
+    | Fill in Entertainment Mode light data             |
+    \*-------------------------------------------------*/
+    for(unsigned int light_idx = 0; light_idx < num_leds; light_idx++)
+    {
+        RGBColor color                  = colors[light_idx];
+        unsigned char red               = RGBGetRValue(color);
+        unsigned char green             = RGBGetGValue(color);
+        unsigned char blue              = RGBGetBValue(color);
+
+        entertainment->setColorRGB(light_idx, red, green, blue);
+    }
+
+    entertainment->update();
+}

Controllers/PhilipsHueController/PhilipsHueEntertainmentController.h

@@ -0,0 +1,42 @@
+/*---------------------------------------------------------*\
+|  Definitions for Philips Hue Entertainment Mode           |
+|                                                           |
+|  Adam Honse ([email protected]), 11/6/2020        |
+\*---------------------------------------------------------*/
+
+#include "RGBController.h"
+#include "Bridge.h"
+#include "EntertainmentMode.h"
+#include "Group.h"
+
+#include <string>
+#include <vector>
+
+#pragma once
+
+#define HUE_ENTERTAINMENT_HEADER_SIZE   16
+#define HUE_ENTERTAINMENT_LIGHT_SIZE    9
+
+class PhilipsHueEntertainmentController
+{
+public:
+    PhilipsHueEntertainmentController(hueplusplus::Bridge& bridge_ptr, hueplusplus::Group& group_ptr);
+    ~PhilipsHueEntertainmentController();
+
+    std::string GetLocation();
+    std::string GetName();
+    std::string GetVersion();
+    std::string GetManufacturer();
+    std::string GetUniqueID();
+    unsigned int GetNumLEDs();
+
+    void SetColor(RGBColor* colors);
+
+private:
+    hueplusplus::Bridge&            bridge;
+    hueplusplus::Group&             group;
+    hueplusplus::EntertainmentMode* entertainment;
+
+    std::string                     location;
+    unsigned int                    num_leds;
+};

Controllers/PhilipsHueController/RGBController_PhilipsHue.cpp

@@ -0,0 +1,85 @@
+/*-----------------------------------------*\
+|  RGBController_PhilipsHue.cpp             |
+|                                           |
+|  Generic RGB Interface for Philips Hue    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 9/15/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController_PhilipsHue.h"
+
+RGBController_PhilipsHue::RGBController_PhilipsHue(PhilipsHueController* light_ptr)
+{
+    light = light_ptr;
+
+    name        = light->GetManufacturer() + " " + light->GetName();
+    type        = DEVICE_TYPE_LIGHT;
+    version     = light->GetVersion();
+    description = "Philips Hue Device";
+    serial      = light->GetUniqueID();
+    location    = light->GetLocation();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+}
+
+void RGBController_PhilipsHue::SetupZones()
+{
+    zone led_zone;
+    led_zone.name       = "RGB Light";
+    led_zone.type       = ZONE_TYPE_SINGLE;
+    led_zone.leds_min   = 1;
+    led_zone.leds_max   = 1;
+    led_zone.leds_count = 1;
+    led_zone.matrix_map = NULL;
+    zones.push_back(led_zone);
+
+    led new_led;
+    new_led.name = "RGB Light";
+
+    leds.push_back(new_led);
+
+    SetupColors();
+}
+
+void RGBController_PhilipsHue::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_PhilipsHue::DeviceUpdateLEDs()
+{
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+
+    light->SetColor(red, grn, blu);
+}
+
+void RGBController_PhilipsHue::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_PhilipsHue::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_PhilipsHue::SetCustomMode()
+{
+
+}
+
+void RGBController_PhilipsHue::DeviceUpdateMode()
+{
+
+}

Controllers/PhilipsHueController/RGBController_PhilipsHue.h

@@ -0,0 +1,31 @@
+/*-----------------------------------------*\
+|  RGBController_PhilipsHue.h               |
+|                                           |
+|  Generic RGB Interface for Philips Hue    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 9/15/2020   |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "PhilipsHueController.h"
+
+class RGBController_PhilipsHue : public RGBController
+{
+public:
+    RGBController_PhilipsHue(PhilipsHueController* light_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:
+    PhilipsHueController* light;
+};

Controllers/PhilipsHueController/RGBController_PhilipsHueEntertainment.cpp

@@ -0,0 +1,113 @@
+/*-----------------------------------------*\
+|  RGBController_PhilipsHueEntertainment.cpp|
+|                                           |
+|  Generic RGB Interface for Philips Hue    |
+|  Entertainment Mode                       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 11/7/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController_PhilipsHueEntertainment.h"
+
+using namespace std::chrono_literals;
+
+RGBController_PhilipsHueEntertainment::RGBController_PhilipsHueEntertainment(PhilipsHueEntertainmentController* light_ptr)
+{
+    light = light_ptr;
+
+    name        = light->GetManufacturer() + " " + light->GetName();
+    type        = DEVICE_TYPE_LIGHT;
+    version     = light->GetVersion();
+    description = "Philips Hue Entertainment Mode Device";
+    serial      = light->GetUniqueID();
+    location    = light->GetLocation();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+
+    /*-----------------------------------------------------*\
+    | The Philips Hue Entertainment Mode requires a packet  |
+    | within 10 seconds of sending the lighting change in   |
+    | order to not exit entertainment mode.  Start a thread |
+    | to continuously send a packet every 5s                |
+    \*-----------------------------------------------------*/
+    KeepaliveThreadRunning = true;
+    KeepaliveThread = new std::thread(&RGBController_PhilipsHueEntertainment::KeepaliveThreadFunction, this);
+}
+
+void RGBController_PhilipsHueEntertainment::SetupZones()
+{
+    zone led_zone;
+    led_zone.name       = "RGB Light";
+    led_zone.type       = ZONE_TYPE_SINGLE;
+    led_zone.leds_min   = light->GetNumLEDs();
+    led_zone.leds_max   = light->GetNumLEDs();
+    led_zone.leds_count = light->GetNumLEDs();
+    led_zone.matrix_map = NULL;
+    zones.push_back(led_zone);
+
+    for(unsigned int led_idx = 0; led_idx < light->GetNumLEDs(); led_idx++)
+    {
+        led new_led;
+        new_led.name = "RGB Light";
+
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_PhilipsHueEntertainment::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_PhilipsHueEntertainment::DeviceUpdateLEDs()
+{
+    last_update_time = std::chrono::steady_clock::now();
+
+    light->SetColor(&colors[0]);
+}
+
+void RGBController_PhilipsHueEntertainment::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_PhilipsHueEntertainment::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_PhilipsHueEntertainment::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_PhilipsHueEntertainment::DeviceUpdateMode()
+{
+
+}
+
+void RGBController_PhilipsHueEntertainment::KeepaliveThreadFunction()
+{
+    while(KeepaliveThreadRunning)
+    {
+        if(active_mode == 0)
+        {
+            if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::seconds(5))
+            {
+                UpdateLEDs();
+            }
+        }
+        std::this_thread::sleep_for(1s);
+    }
+}

Controllers/PhilipsHueController/RGBController_PhilipsHueEntertainment.h

@@ -0,0 +1,42 @@
+/*-----------------------------------------*\
+|  RGBController_PhilipsHueEntertainment.h  |
+|                                           |
+|  Generic RGB Interface for Philips Hue    |
+|  Entertainment Mode                       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 11/7/2020   |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "PhilipsHueEntertainmentController.h"
+
+#include <atomic>
+#include <thread>
+
+class RGBController_PhilipsHueEntertainment : public RGBController
+{
+public:
+    RGBController_PhilipsHueEntertainment(PhilipsHueEntertainmentController* light_ptr);
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+    void        KeepaliveThreadFunction();
+
+private:
+    PhilipsHueEntertainmentController* light;
+
+    std::atomic<bool>   KeepaliveThreadRunning;
+    std::thread*        KeepaliveThread;
+
+    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
+};

Controllers/QMKOpenRGBController/QMKOpenRGBController.cpp

@@ -59,6 +59,30 @@ static std::map<uint8_t, std::string> QMKKeycodeToKeynameMap
 
 QMKOpenRGBController::QMKOpenRGBController(hid_device *dev_handle, const char *path)
 {
+    /*-------------------------------------------------*\
+    | Get QMKOpenRGB settings                           |
+    \*-------------------------------------------------*/
+    json qmk_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("QMKOpenRGBDevices");
+    if(qmk_settings.contains("leds_per_update"))
+    {
+        if(qmk_settings["leds_per_update"] > 20)
+        {
+            qmk_settings["leds_per_update"] = 20;
+        }
+        else if(qmk_settings["leds_per_update"] < 1)
+        {
+            qmk_settings["leds_per_update"] = 1;
+        }
+        SettingsManager* settings_manager   = ResourceManager::get()->GetSettingsManager();
+        settings_manager->SetSettings("QMKOpenRGBDevices", qmk_settings);
+        settings_manager->SaveSettings();
+        leds_per_update = qmk_settings["leds_per_update"];
+    }
+    else
+    {
+        leds_per_update = 20;
+    }
+
     dev         = dev_handle;
     location    = path;
 
@@ -150,7 +174,7 @@ unsigned int QMKOpenRGBController::GetProtocolVersion()
     do
     {
         hid_write(dev, usb_buf, QMK_OPENRGB_PACKET_SIZE);
-        bytes_read = hid_read_timeout(dev, usb_buf, QMK_OPENRGB_PACKET_SIZE, QMK_HID_READ_TIMEOUT);
+        bytes_read = hid_read_timeout(dev, usb_buf, QMK_OPENRGB_PACKET_SIZE, QMK_OPENRGB_HID_READ_TIMEOUT);
     } while(bytes_read <= 0);
 
     return usb_buf[1];
@@ -204,7 +228,7 @@ void QMKOpenRGBController::GetDeviceInfo()
     do
     {
         hid_write(dev, usb_buf, QMK_OPENRGB_PACKET_SIZE);
-        bytes_read = hid_read_timeout(dev, usb_buf, QMK_OPENRGB_PACKET_SIZE, QMK_HID_READ_TIMEOUT);
+        bytes_read = hid_read_timeout(dev, usb_buf, QMK_OPENRGB_PACKET_SIZE, QMK_OPENRGB_HID_READ_TIMEOUT);
     } while(bytes_read <= 0);
 
     total_number_of_leds = usb_buf[QMK_OPENRGB_TOTAL_NUMBER_OF_LEDS_BYTE];
@@ -244,7 +268,7 @@ void QMKOpenRGBController::GetModeInfo()
     do
     {
         hid_write(dev, usb_buf, 65);
-        bytes_read = hid_read_timeout(dev, usb_buf, 65, QMK_HID_READ_TIMEOUT);
+        bytes_read = hid_read_timeout(dev, usb_buf, 65, QMK_OPENRGB_HID_READ_TIMEOUT);
     } while(bytes_read <= 0);
 
     mode = usb_buf[QMK_OPENRGB_MODE_BYTE];
@@ -286,7 +310,7 @@ void QMKOpenRGBController::GetLEDInfo(unsigned int led)
     do
     {
         hid_write(dev, usb_buf, QMK_OPENRGB_PACKET_SIZE);
-        bytes_read = hid_read_timeout(dev, usb_buf, QMK_OPENRGB_PACKET_SIZE, QMK_HID_READ_TIMEOUT);
+        bytes_read = hid_read_timeout(dev, usb_buf, QMK_OPENRGB_PACKET_SIZE, QMK_OPENRGB_HID_READ_TIMEOUT);
     } while(bytes_read <= 0);
 
     if(usb_buf[62] != QMK_OPENRGB_FAILURE)
@@ -329,7 +353,7 @@ bool QMKOpenRGBController::GetIsModeEnabled(unsigned int mode)
     do
     {
         hid_write(dev, usb_buf, QMK_OPENRGB_PACKET_SIZE);
-        bytes_read = hid_read_timeout(dev, usb_buf, QMK_OPENRGB_PACKET_SIZE, QMK_HID_READ_TIMEOUT);
+        bytes_read = hid_read_timeout(dev, usb_buf, QMK_OPENRGB_PACKET_SIZE, QMK_OPENRGB_HID_READ_TIMEOUT);
     } while(bytes_read <= 0);
 
     return usb_buf[1] == QMK_OPENRGB_SUCCESS ? true : false;
@@ -359,7 +383,7 @@ void QMKOpenRGBController::SetMode(hsv_t hsv_color, unsigned char mode, unsigned
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
-    hid_read_timeout(dev, usb_buf, 65, QMK_HID_READ_TIMEOUT);
+    hid_read_timeout(dev, usb_buf, 65, QMK_OPENRGB_HID_READ_TIMEOUT);
 }
 
 void QMKOpenRGBController::DirectModeSetSingleLED(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
@@ -386,13 +410,12 @@ void QMKOpenRGBController::DirectModeSetSingleLED(unsigned int led, unsigned cha
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
-    hid_read_timeout(dev, usb_buf, 65, QMK_HID_READ_TIMEOUT);
+    hid_read_timeout(dev, usb_buf, 65, QMK_OPENRGB_HID_READ_TIMEOUT);
 }
 
 void QMKOpenRGBController::DirectModeSetLEDs(std::vector<RGBColor> colors, unsigned int leds_count)
 {
     unsigned int leds_sent = 0;
-    unsigned int leds_per_update = 20;
 
     while (leds_sent < leds_count)
     {

Controllers/QMKOpenRGBController/QMKOpenRGBController.h

@@ -9,14 +9,15 @@
 
 #pragma once
 
+#include "ResourceManager.h"
 #include "RGBController.h"
 #include "hsv.h"
 #include <hidapi/hidapi.h>
 #include <cstring>
 #include <map>
 
-#define QMK_OPENRGB_PACKET_SIZE 65
-#define QMK_HID_READ_TIMEOUT    50
+#define QMK_OPENRGB_PACKET_SIZE         65
+#define QMK_OPENRGB_HID_READ_TIMEOUT    50
 
 enum CommandsId
 {
@@ -160,6 +161,8 @@ protected:
     hid_device *dev;
 
 private:
+    unsigned int    leds_per_update;
+
     std::string     location;
 
     std::string     device_name;

Controllers/QMKOpenRGBController/RGBController_QMKOpenRGB.cpp

@@ -554,7 +554,7 @@ void RGBController_QMKOpenRGB::PlaceLEDsInMaps
         VectorMatrix&               matrix_map_xl,
         VectorMatrix&               underglow_map_xl
      )
-{   
+{
     matrix_map_xl                   = MakeEmptyMatrixMap(unique_rows.size(), std::round(255/divisor) + 10);
     underglow_map_xl                = MakeEmptyMatrixMap(unique_rows.size(), std::round(255/divisor) + 10);
 

Controllers/RazerController/RazerController.cpp

@@ -147,6 +147,7 @@ RazerController::RazerController(hid_device* dev_handle, hid_device* dev_argb_ha
         case RAZER_BLADE_2020_ADVANCED_PID:
         case RAZER_BLADE_2020_BASE_PID:
         case RAZER_BLADE_2021_BASE_PID:
+        case RAZER_BLADE_14_2021_PID:
         case RAZER_BLADE_PRO_2016_PID:
         case RAZER_BLADE_PRO_2017_PID:
         case RAZER_BLADE_PRO_2017_FULLHD_PID:
@@ -416,6 +417,7 @@ bool RazerController::SupportsWave()
         case RAZER_BLADE_2020_ADVANCED_PID:
         case RAZER_BLADE_2020_BASE_PID:
         case RAZER_BLADE_2021_BASE_PID:
+        case RAZER_BLADE_14_2021_PID:
         case RAZER_BLADE_PRO_2016_PID:
         case RAZER_BLADE_PRO_2017_PID:
         case RAZER_BLADE_PRO_2017_FULLHD_PID:

Controllers/RazerController/RazerControllerDetect.cpp

@@ -214,12 +214,14 @@ REGISTER_HID_DETECTOR_IPU("Razer Huntsman",                                  Det
 REGISTER_HID_DETECTOR_IPU("Razer Huntsman Elite",                            DetectRazerControllers,        RAZER_VID,  RAZER_HUNTSMAN_ELITE_PID,                       0x00,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Huntsman Tournament Edition",               DetectRazerControllers,        RAZER_VID,  RAZER_HUNTSMAN_TE_PID,                          0x00,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Ornata Chroma",                             DetectRazerControllers,        RAZER_VID,  RAZER_ORNATA_CHROMA_PID,                        0x00,   0x01,   0x02);
+REGISTER_HID_DETECTOR_IPU("Razer Ornata Chroma V2",                          DetectRazerControllers,        RAZER_VID,  RAZER_ORNATA_CHROMA_V2_PID,                     0x00,   0x01,   0x02);
 
 /*-----------------------------------------------------------------------------------------------------*\
 | Laptops                                                                                               |
 \*-----------------------------------------------------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IPU("Razer Blade (2016)",                              DetectRazerControllers,        RAZER_VID,  RAZER_BLADE_2016_PID,                           0x00,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Blade (Late 2016)",                         DetectRazerControllers,        RAZER_VID,  RAZER_BLADE_LATE_2016_PID,                      0x00,   0x01,   0x02);
+REGISTER_HID_DETECTOR_IPU("Razer Blade 14 (2021)",                           DetectRazerControllers,        RAZER_VID,  RAZER_BLADE_14_2021_PID,                        0x00,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Blade 15 (2018 Advanced)",                  DetectRazerControllers,        RAZER_VID,  RAZER_BLADE_2018_ADVANCED_PID,                  0x00,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Blade 15 (2018 Base)",                      DetectRazerControllers,        RAZER_VID,  RAZER_BLADE_2018_BASE_PID,                      0x00,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Blade 15 (2018 Mercury)",                   DetectRazerControllers,        RAZER_VID,  RAZER_BLADE_2018_MERCURY_PID,                   0x00,   0x01,   0x02);

Controllers/RazerController/RazerDevices.h

@@ -36,6 +36,8 @@
 #define RAZER_BLADE_2020_BASE_PID                       0x0255
 #define RAZER_BLADE_2021_BASE_PID                       0x026F
 
+#define RAZER_BLADE_14_2021_PID                         0x0270
+
 #define RAZER_BLADE_PRO_2016_PID                        0x0210
 #define RAZER_BLADE_PRO_2017_PID                        0x0225
 #define RAZER_BLADE_PRO_2017_FULLHD_PID                 0x022F
@@ -406,6 +408,93 @@ static const razer_key blackwidow_chroma_te_keymap[] =
     {   0,      5,      17,             "Key: Right Arrow"                  },
 };
 
+#define BLADE_14_2021_KEYMAP_SIZE (sizeof(blade_14_2021_keymap) / sizeof(blade_14_2021_keymap[0]))
+
+static const razer_key blade_14_2021_keymap[] =
+{
+    /*---------------------------------------------------------------------*\
+    |   Zone,   Row,    Column,         Key                                 |
+    \*---------------------------------------------------------------------*/
+    {   0,      0,      1,              "Key: Escape"                       },
+    {   0,      0,      2,              "Key: F1"                           },
+    {   0,      0,      3,              "Key: F2"                           },
+    {   0,      0,      4,              "Key: F3"                           },
+    {   0,      0,      5,              "Key: F4"                           },
+    {   0,      0,      6,              "Key: F5"                           },
+    {   0,      0,      7,              "Key: F6"                           },
+    {   0,      0,      8,              "Key: F7"                           },
+    {   0,      0,      9,              "Key: F8"                           },
+    {   0,      0,      10,             "Key: F9"                           },
+    {   0,      0,      11,             "Key: F10"                          },
+    {   0,      0,      12,             "Key: F11"                          },
+    {   0,      0,      13,             "Key: F12"                          },
+    {   0,      0,      14,             "Key: Delete"                       },
+    {   0,      0,      15,             "Key: Power"                        },
+    {   0,      1,      1,              "Key: `"                            },
+    {   0,      1,      2,              "Key: 1"                            },
+    {   0,      1,      3,              "Key: 2"                            },
+    {   0,      1,      4,              "Key: 3"                            },
+    {   0,      1,      5,              "Key: 4"                            },
+    {   0,      1,      6,              "Key: 5"                            },
+    {   0,      1,      7,              "Key: 6"                            },
+    {   0,      1,      8,              "Key: 7"                            },
+    {   0,      1,      9,              "Key: 8"                            },
+    {   0,      1,      10,             "Key: 9"                            },
+    {   0,      1,      11,             "Key: 0"                            },
+    {   0,      1,      12,             "Key: -"                            },
+    {   0,      1,      13,             "Key: ="                            },
+    {   0,      1,      15,             "Key: Backspace"                    },
+    {   0,      2,      1,              "Key: Tab"                          },
+    {   0,      2,      2,              "Key: Q"                            },
+    {   0,      2,      3,              "Key: W"                            },
+    {   0,      2,      4,              "Key: E"                            },
+    {   0,      2,      5,              "Key: R"                            },
+    {   0,      2,      6,              "Key: T"                            },
+    {   0,      2,      7,              "Key: Y"                            },
+    {   0,      2,      8,              "Key: U"                            },
+    {   0,      2,      9,              "Key: I"                            },
+    {   0,      2,      10,             "Key: O"                            },
+    {   0,      2,      11,             "Key: P"                            },
+    {   0,      2,      12,             "Key: ["                            },
+    {   0,      2,      13,             "Key: ]"                            },
+    {   0,      2,      15,             "Key: \\ (ANSI)"                    },
+    {   0,      3,      1,              "Key: Caps Lock"                    },
+    {   0,      3,      2,              "Key: A"                            },
+    {   0,      3,      3,              "Key: S"                            },
+    {   0,      3,      4,              "Key: D"                            },
+    {   0,      3,      5,              "Key: F"                            },
+    {   0,      3,      6,              "Key: G"                            },
+    {   0,      3,      7,              "Key: H"                            },
+    {   0,      3,      8,              "Key: J"                            },
+    {   0,      3,      9,              "Key: K"                            },
+    {   0,      3,      10,             "Key: L"                            },
+    {   0,      3,      11,             "Key: ;"                            },
+    {   0,      3,      12,             "Key: '"                            },
+    {   0,      3,      15,             "Key: Enter"                        },
+    {   0,      4,      1,              "Key: Left Shift"                   },
+    {   0,      4,      3,              "Key: Z"                            },
+    {   0,      4,      4,              "Key: X"                            },
+    {   0,      4,      5,              "Key: C"                            },
+    {   0,      4,      6,              "Key: V"                            },
+    {   0,      4,      7,              "Key: B"                            },
+    {   0,      4,      8,              "Key: N"                            },
+    {   0,      4,      9,              "Key: M"                            },
+    {   0,      4,      10,             "Key: ,"                            },
+    {   0,      4,      11,             "Key: ."                            },
+    {   0,      4,      12,             "Key: /"                            },
+    {   0,      4,      15,             "Key: Right Shift"                  },
+    {   0,      5,      1,              "Key: Left Control"                 },
+    {   0,      5,      2,              "Key: Left Fn"                      },
+    {   0,      5,      3,              "Key: Left Windows"                 },
+    {   0,      5,      5,              "Key: Left Alt"                     },
+    {   0,      5,      9,              "Key: Right Alt"                    },
+    {   0,      5,      11,             "Key: Right Control"                },
+    {   0,      5,      12,             "Key: Left Arrow"                   },
+    {   0,      5,      13,             "Key: Up Arrow"                     },
+    {   0,      5,      14,             "Key: Right Arrow"                  },
+    {   0,      5,      15,             "Key: Down Arrow"                   },
+};
+
 #define BLADE_PRO_2017_KEYMAP_SIZE (sizeof(blade_pro_2017_keymap) / sizeof(blade_pro_2017_keymap[0]))
 
 static const razer_key blade_pro_2017_keymap[] =
@@ -2515,6 +2604,41 @@ static const razer_device blade_15_2021_base_device =
     0
 };
 
+/*-------------------------------------------------------------*\
+|  Razer Blade 14 (2021)                                        |
+|                                                               |
+|   Zone "Keyboard"                                             |
+|       Matrix                                                  |
+|       6 Rows, 16 Columns                                      |
+\*-------------------------------------------------------------*/
+static const razer_zone blade_14_2021_zone =
+{
+    "Keyboard",
+    ZONE_TYPE_MATRIX,
+    6,
+    16
+};
+
+static const razer_device blade_14_2021_device =
+{
+    "Razer Blade 14 (2021)",
+    RAZER_BLADE_14_2021_PID,
+    DEVICE_TYPE_KEYBOARD,
+    true,
+    6,
+    16,
+    {
+        &blade_14_2021_zone,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL
+    },
+    blade_14_2021_keymap,
+    BLADE_14_2021_KEYMAP_SIZE
+};
+
 /*-------------------------------------------------------------*\
 |  Razer Blade Pro (2016)                                       |
 |                                                               |
@@ -5548,6 +5672,7 @@ static const razer_device* device_list[] =
     &blade_15_2020_advanced_device,
     &blade_15_2020_base_device,
     &blade_15_2021_base_device,
+    &blade_14_2021_device,
     &blade_pro_2016_device,
     &blade_pro_2017_device,
     &blade_pro_2017_fullhd_device,

Controllers/RedragonController/RedragonControllerDetect.cpp

@@ -12,6 +12,7 @@
 #define REDRAGON_MOUSE_USAGE_PAGE       0xFFA0
 #define REDRAGON_M711_PID               0xFC30
 #define REDRAGON_M715_PID               0xFC39
+#define REDRAGON_M716_PID               0xFC3A
 #define REDRAGON_M908_PID               0xFC4D
 
 /******************************************************************************************\
@@ -37,6 +38,7 @@ void DetectRedragonMice(hid_device_info* info, const std::string& name)
 /*---------------------------------------------------------------------------------------------------------------------------------------------*\
 | Mice                                                                                                                                          |
 \*---------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Redragon M711 Cobra",     DetectRedragonMice,      REDRAGON_MOUSE_VID,    REDRAGON_M711_PID,         2, REDRAGON_MOUSE_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Redragon M715 Dagger",    DetectRedragonMice,      REDRAGON_MOUSE_VID,    REDRAGON_M715_PID,         2, REDRAGON_MOUSE_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Redragon M908 Impact",    DetectRedragonMice,      REDRAGON_MOUSE_VID,    REDRAGON_M908_PID,         2, REDRAGON_MOUSE_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Redragon M711 Cobra",      DetectRedragonMice,      REDRAGON_MOUSE_VID,    REDRAGON_M711_PID,         2, REDRAGON_MOUSE_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Redragon M715 Dagger",     DetectRedragonMice,      REDRAGON_MOUSE_VID,    REDRAGON_M715_PID,         2, REDRAGON_MOUSE_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Redragon M716 Inquisitor", DetectRedragonMice,      REDRAGON_MOUSE_VID,    REDRAGON_M716_PID,         2, REDRAGON_MOUSE_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Redragon M908 Impact",     DetectRedragonMice,      REDRAGON_MOUSE_VID,    REDRAGON_M908_PID,         2, REDRAGON_MOUSE_USAGE_PAGE);