Center the device view horizontally

Setting RGB values works. Modes still unknown.

.gitlab-ci.yml

@@ -4,6 +4,10 @@
 # https://www.kittell.net/code/powershell-unix-sed-equivalent-change-text-file/
 # https://powershell.org/forums/topic/how-to-use-ansi-vt100-formatting-in-powershell-ooh-pretty-colors/
 
+#-----------------------------------------------------------------------#
+# OpenRGB GitLab CI Configuration                                       #
+#-----------------------------------------------------------------------#
+
 .shared_windows_runners:
   tags:
   - shared-windows
@@ -16,6 +20,9 @@ stages:
 before_script:
  - echo "started by ${GITLAB_USER_NAME}"
 
+#-----------------------------------------------------------------------#
+# Linux (AppImage) Build Target                                         #
+#-----------------------------------------------------------------------#
 build_linux:
   image: ubuntu:bionic
   stage: build
@@ -29,7 +36,82 @@ build_linux:
     - OpenRGB-x86_64.AppImage
     expire_in: 1337 years
 
-build_windows:
+#-----------------------------------------------------------------------#
+# Windows (32-bit) Build Target                                         #
+#-----------------------------------------------------------------------#
+build_windows_32:
+  extends:
+  - .shared_windows_runners
+  stage: build
+  script:
+  - $esc = "$([char]27)"
+  - $count = 0
+  - function _unix_tmsec_ { [int64](([datetime]::UtcNow)-(get-date "1/1/1970")).TotalSeconds }
+  - function _fold_start_ { param( [string]$TEXT_TAG ) $t=_unix_tmsec_; $global:count += 1; Write-Host -NoNewLine "`r`n`r`nsection_start:${t}:sect_${count}`r${esc}[0K${esc}[33m${TEXT_TAG}${esc}[39m`r`n"; }
+  - function _fold_final_ {                            $t=_unix_tmsec_;                     Write-Host -NoNewLine   "`r`n`r`nsection_end:${t}:sect_${count}`r${esc}[0K`r`n"           ; }
+
+
+  - _fold_start_ 'configuring the msvc environment variables'
+  - Push-Location "C:/Program Files (x86)/Microsoft Visual Studio/2019/BuildTools/VC/Auxiliary/Build"
+  - '& cmd.exe /C "vcvarsall.bat x86 & set" | Foreach-Object { if ($_ -match "(.*?)=(.*)") { Set-Item -force -path "Env:\$($matches[1])" -value "$($matches[2])" } }'
+  - Pop-Location
+  - _fold_final_
+  
+  - _fold_start_ 'downloading precompiled versions of qtbase, qttools (for windeployqt) and jom (for a more parallel nmake)'
+  - mkdir _qt
+  - mkdir _qt_download
+  - Push-Location _qt_download
+  - curl.exe -LJ -o qt-base.7z  'https://download.qt.io/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z' 
+  - curl.exe -LJ -o qt-tools.7z 'https://download.qt.io/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z'
+  - curl.exe -LJ -o qt-jom.zip  'https://download.qt.io/official_releases/jom/jom.zip'
+  - _fold_final_
+  
+  - _fold_start_ 'extracting the downloaded qt binaries'
+  - 7z x qt-base.7z  '-o../_qt' -y
+  - 7z x qt-tools.7z '-o../_qt' -y
+  - 7z x qt-jom.zip  '-o../_qt' -y
+  - _fold_final_
+  
+  - _fold_start_ 'turn the qt install from enterprise to foss; remove the licensing checks'
+  - ${qconfig-pri-folder} = '..\_qt\5.15.0\msvc2019\mkspecs\qconfig.pri'
+  - (Get-Content ${qconfig-pri-folder}).replace('QT_EDITION = Enterprise', 'QT_EDITION = OpenSource') | Set-Content ${qconfig-pri-folder}
+  - (Get-Content ${qconfig-pri-folder}).replace('QT_LICHECK = licheck.exe', '')                       | Set-Content ${qconfig-pri-folder}
+  - Pop-Location
+  - _fold_final_
+  
+  - _fold_start_ 'run qmake and generate the msvc nmake makefile'
+  - mkdir _build; cd _build
+  - ..\_qt\5.15.0\msvc2019\bin\qmake ..\OpenRGB.pro
+  - _fold_final_
+  
+  - _fold_start_ 'start the actual build with jom instead of nmake; for speed'
+  - ..\_qt\jom
+  - _fold_final_
+  
+  - _fold_start_ 'run windeployqt to automatically copy the needed dll files'
+  - ..\_qt\5.15.0\msvc2019\bin\windeployqt --no-angle --no-translations --no-opengl-sw --no-system-d3d-compiler --no-compiler-runtime --no-webkit2 .\release\
+  - _fold_final_
+  
+  - _fold_start_ 'compressing the release folder so that we can upload it as artifact'
+  - mv release 'OpenRGB Windows 32-bit'
+  - ${datetime} = Get-Date ([datetime]::UtcNow) -Format "yyyy-MM-ddTHH-mm-ss"
+  - ${revision} = ((git rev-parse --short HEAD) | Out-String).Trim()
+  - ${rversion} = (((Get-Content '..\OpenRGB.pro' | Select-String -Pattern "VERSION     =") | Out-String).Trim().Split("="))[1].Trim()
+  - 7z a -mx9 -r -y "OpenRGB_${rversion}_32_${revision}_nightly_${datetime}.7z" 'OpenRGB Windows 32-bit'
+  - _fold_final_
+#  cache:
+#    key: same-key
+#    paths:
+#    - C:\vcpkg\installed\
+  artifacts:
+    paths:
+    - _build/*.7z
+    expire_in: 1337 years
+
+#-----------------------------------------------------------------------#
+# Windows (64-bit) Build Target                                         #
+#-----------------------------------------------------------------------#
+build_windows_64:
   extends:
   - .shared_windows_runners
   stage: build
@@ -51,8 +133,8 @@ build_windows:
   - mkdir _qt
   - mkdir _qt_download
   - Push-Location _qt_download
-  - curl.exe -LJ -o qt-base.7z  'https://download.qt.io/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2017_64/5.15.0-0-202002260536qtbase-Windows-Windows_10-MSVC2017-Windows-Windows_10-X86_64.7z' 
-  - curl.exe -LJ -o qt-tools.7z 'https://download.qt.io/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2017_64/5.15.0-0-202002260536qttools-Windows-Windows_10-MSVC2017-Windows-Windows_10-X86_64.7z'
+  - curl.exe -LJ -o qt-base.7z  'https://download.qt.io/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z' 
+  - curl.exe -LJ -o qt-tools.7z 'https://download.qt.io/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z'
   - curl.exe -LJ -o qt-jom.zip  'https://download.qt.io/official_releases/jom/jom.zip'
   - _fold_final_
   
@@ -63,7 +145,7 @@ build_windows:
   - _fold_final_
   
   - _fold_start_ 'turn the qt install from enterprise to foss; remove the licensing checks'
-  - ${qconfig-pri-folder} = '..\_qt\5.15.0\msvc2017_64\mkspecs\qconfig.pri'
+  - ${qconfig-pri-folder} = '..\_qt\5.15.0\msvc2019_64\mkspecs\qconfig.pri'
   - (Get-Content ${qconfig-pri-folder}).replace('QT_EDITION = Enterprise', 'QT_EDITION = OpenSource') | Set-Content ${qconfig-pri-folder}
   - (Get-Content ${qconfig-pri-folder}).replace('QT_LICHECK = licheck.exe', '')                       | Set-Content ${qconfig-pri-folder}
   - Pop-Location
@@ -71,7 +153,7 @@ build_windows:
   
   - _fold_start_ 'run qmake and generate the msvc nmake makefile'
   - mkdir _build; cd _build
-  - ..\_qt\5.15.0\msvc2017_64\bin\qmake ..\OpenRGB.pro
+  - ..\_qt\5.15.0\msvc2019_64\bin\qmake ..\OpenRGB.pro
   - _fold_final_
   
   - _fold_start_ 'start the actual build with jom instead of nmake; for speed'
@@ -79,7 +161,7 @@ build_windows:
   - _fold_final_
   
   - _fold_start_ 'run windeployqt to automatically copy the needed dll files'
-  - ..\_qt\5.15.0\msvc2017_64\bin\windeployqt --no-angle --no-translations --no-opengl-sw --no-system-d3d-compiler --no-compiler-runtime --no-webkit2 .\release\
+  - ..\_qt\5.15.0\msvc2019_64\bin\windeployqt --no-angle --no-translations --no-opengl-sw --no-system-d3d-compiler --no-compiler-runtime --no-webkit2 .\release\
   - _fold_final_
   
   - _fold_start_ 'compressing the release folder so that we can upload it as artifact'

60-openrgb.rules

@@ -133,6 +133,51 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c084", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c083", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08f", TAG+="uaccess"
 
+#---------------------------------------------------------------#
+#  MSI Mysticlight                                              #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="3EA4", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="4559", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B10", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B93", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B94", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B96", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C34", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C35", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C36", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C37", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C42", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C56", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C59", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C60", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C67", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C70", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C71", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C73", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C75", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C76", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C77", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C79", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C80", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C81", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C82", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C83", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C84", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C85", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C86", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C87", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C88", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C89", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C90", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C91", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C92", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C94", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C95", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C96", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C98", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C99", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="905D", TAG+="uaccess"
+
 #---------------------------------------------------------------#
 #  MSI/SteelSeries 3-Zone Laptop Keyboard                       #
 #---------------------------------------------------------------#
@@ -177,6 +222,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="fc39", TAG+="uacces
 #  Gigabyte/Aorus RGB Fusion 2 USB                              #
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="048d", ATTR{idProduct}=="8297", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="048d", ATTR{idProduct}=="5702", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  SteelSeries Peripheral Devices                               #

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -49,6 +49,7 @@ std::string AMDWraithPrismController::GetEffectChannelString(unsigned char chann
 
     unsigned char usb_buf[] =
     {
+        0x00,
         0x40, 0x21, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00,
@@ -67,9 +68,9 @@ std::string AMDWraithPrismController::GetEffectChannelString(unsigned char chann
         0x00, 0x00, 0x00, 0x00,
     };
 
-    usb_buf[0x02] = channel;
+    usb_buf[0x03] = channel;
 
-    hid_write(dev, usb_buf, 64);
+    hid_write(dev, usb_buf, 65);
     hid_read(dev, usb_buf, 64);
 
     ret_string.append((char *)&usb_buf[0x08]);
@@ -83,6 +84,7 @@ std::string AMDWraithPrismController::GetFirmwareVersionString()
 
     unsigned char usb_buf[] =
     {
+        0x00,
         0x12, 0x20, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00,
@@ -103,7 +105,7 @@ std::string AMDWraithPrismController::GetFirmwareVersionString()
 
     unsigned char   fw_buf[16] = {0x00};
 
-    hid_write(dev, usb_buf, 64);
+    hid_write(dev, usb_buf, 65);
     hid_read(dev, usb_buf, 64);
 
     for(int char_idx = 0; char_idx < 16; char_idx+=2)
@@ -206,6 +208,7 @@ void AMDWraithPrismController::SendEnableCommand()
 {
     unsigned char usb_buf[] =
     {
+        0x00,
         0x41, 0x80, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00,
@@ -224,7 +227,7 @@ void AMDWraithPrismController::SendEnableCommand()
         0x00, 0x00, 0x00, 0x00,
     };
 
-    hid_write(dev, usb_buf, 64);
+    hid_write(dev, usb_buf, 65);
     hid_read(dev, usb_buf, 64);
 }
 
@@ -232,6 +235,7 @@ void AMDWraithPrismController::SendApplyCommand()
 {
     unsigned char usb_buf[] =
     {
+        0x00,
         0x51, 0x28, 0x00, 0x00,
         0xE0, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00,
@@ -250,7 +254,7 @@ void AMDWraithPrismController::SendApplyCommand()
         0x00, 0x00, 0x00, 0x00,
     };
 
-    hid_write(dev, usb_buf, 64);
+    hid_write(dev, usb_buf, 65);
     hid_read(dev, usb_buf, 64);
 }
 
@@ -269,6 +273,7 @@ void AMDWraithPrismController::SendEffectChannelUpdate
 {
     unsigned char usb_buf[] =
     {
+        0x00,
         0x51, 0x2C, 0x01, 0x00,
         0x05, 0xFF, 0x00, 0x01,
         0xFF, 0xFF, 0x00, 0xFF,
@@ -287,18 +292,18 @@ void AMDWraithPrismController::SendEffectChannelUpdate
         0xFF, 0xFF, 0xFF, 0xFF
     };
 
-    usb_buf[0x04]   = effect_channel;
-    usb_buf[0x05]   = speed;
-    usb_buf[0x06]   = (direction ? 0x01 : 0x00) | (random_color ? 0x80 : 0x00);
-    usb_buf[0x07]   = mode;
+    usb_buf[0x05]   = effect_channel;
+    usb_buf[0x06]   = speed;
+    usb_buf[0x07]   = (direction ? 0x01 : 0x00) | (random_color ? 0x80 : 0x00);
+    usb_buf[0x08]   = mode;
 
-    usb_buf[0x09]   = brightness;
+    usb_buf[0x0A]   = brightness;
 
-    usb_buf[0x0A]   = red;
-    usb_buf[0x0B]   = green;
-    usb_buf[0x0C]   = blue;
+    usb_buf[0x0B]   = red;
+    usb_buf[0x0C]   = green;
+    usb_buf[0x0D]   = blue;
 
-    hid_write(dev, usb_buf, 64);
+    hid_write(dev, usb_buf, 65);
     hid_read(dev, usb_buf, 64);
 }
 
@@ -306,6 +311,7 @@ void AMDWraithPrismController::SendChannelRemap(unsigned char ring_channel, unsi
 {
     unsigned char usb_buf[] =
     {
+        0x00,
         0x51, 0xA0, 0x01, 0x00,
         0x00, 0x03, 0x00, 0x00,
         0x05, 0x06, 0x07, 0x07,
@@ -324,14 +330,14 @@ void AMDWraithPrismController::SendChannelRemap(unsigned char ring_channel, unsi
         0x00, 0x00, 0x00, 0x00,
     };
 
-    usb_buf[0x08] = logo_channel;
-    usb_buf[0x09] = fan_channel;
+    usb_buf[0x09] = logo_channel;
+    usb_buf[0x0A] = fan_channel;
 
-    for(int led = 0x0A; led <= 0x18; led++)
+    for(int led = 0x0B; led <= 0x19; led++)
     {
         usb_buf[led] = ring_channel;
     }
 
-    hid_write(dev, usb_buf, 64);
+    hid_write(dev, usb_buf, 65);
     hid_read(dev, usb_buf, 64);
 }

Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp

@@ -28,23 +28,24 @@ void DetectAMDWraithPrismControllers(std::vector<RGBController*>& rgb_controller
     {
         if((info->vendor_id == AMD_WRAITH_PRISM_VID)
          &&(info->product_id == AMD_WRAITH_PRISM_PID)
+#if USE_HID_USAGE
+         &&(info->interface_number == 1)
+         &&(info->usage_page == 0xFF00))
+#else
          &&(info->interface_number == 1))
+#endif
         {
             dev = hid_open_path(info->path);
-            break;
+        
+            if( dev )
+            {
+                AMDWraithPrismController* controller = new AMDWraithPrismController(dev);
+
+                RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
+
+                rgb_controllers.push_back(rgb_controller);
+            }
         }
-        else
-        {
-            info = info->next;
-        }
-    }
-
-    if( dev )
-    {
-        AMDWraithPrismController* controller = new AMDWraithPrismController(dev);
-
-        RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
-
-        rgb_controllers.push_back(rgb_controller);
+        info = info->next;
     }
 }

Controllers/AuraSMBusController/AuraSMBusControllerDetect.cpp

@@ -11,7 +11,7 @@ using namespace std::chrono_literals;
 /*----------------------------------------------------------------------*\
 | This list contains the available SMBus addresses for mapping Aura RAM  |
 \*----------------------------------------------------------------------*/
-#define AURA_RAM_ADDRESS_COUNT  22
+#define AURA_RAM_ADDRESS_COUNT  23
 
 static const unsigned char aura_ram_addresses[] =
 {
@@ -34,6 +34,7 @@ static const unsigned char aura_ram_addresses[] =
     0x66,
     0x67,
     0x39,
+    0x3A,
     0x3B,
     0x3C,
     0x3D

Controllers/CoolerMasterController/CMMP750Controller.cpp

@@ -11,9 +11,9 @@
 
 CMMP750Controller::CMMP750Controller(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path)
 {
-    int tmp_size = wcslen(_vendor);
-
-    dev = dev_handle;
+    int tmp_size    = wcslen(_vendor);
+    dev             = dev_handle;
+    location        = _path;
 
     for (int i=0; ( i<tmp_size && i<CM_DEVICE_NAME_SIZE); i++)
     {
@@ -22,10 +22,7 @@ CMMP750Controller::CMMP750Controller(hid_device* dev_handle, wchar_t *_vendor, w
     for (int j=0; ( j<wcslen(_vendor) && tmp_size+j<CM_DEVICE_NAME_SIZE); j++)
         device_name[tmp_size+j] = (char)_device_name[j];
 
-    location = _path;
-
-    current_mode = MP750_MODE_STATIC;
-    current_speed = MP750_SPEED_NORMAL;
+    GetStatus();        //When setting up device get current status
 }
 
 CMMP750Controller::~CMMP750Controller()
@@ -33,6 +30,36 @@ CMMP750Controller::~CMMP750Controller()
     hid_close(dev);
 }
 
+void CMMP750Controller::GetStatus()
+{
+    unsigned char buffer[0x40]  = { 0x00 };
+    int buffer_size             = (sizeof(buffer) / sizeof(buffer[0]));
+    buffer[0]                   = 0x07;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read(dev, buffer, buffer_size);
+
+    if( buffer[0] == 0x80 && buffer[1] == 0x05 )
+    {
+        current_mode  = buffer[2] - 1;
+        current_red   = buffer[3];
+        current_green = buffer[4];
+        current_blue  = buffer[5];
+
+        for( int i = 0; speed_mode_data[current_mode][i] >= buffer[6]; i++)
+            current_speed = i;
+    }
+    else
+    {
+        //Code should never reach here however just in case there is a failure set something
+        current_mode = MP750_MODE_COLOR_CYCLE;      //Unicorn Spew
+        current_red   = 0xFF;
+        current_green = 0xFF;
+        current_blue  = 0xFF;
+        current_speed = MP750_SPEED_NORMAL;
+    }
+}
+
 char* CMMP750Controller::GetDeviceName()
 {
     return device_name;
@@ -48,6 +75,31 @@ std::string CMMP750Controller::GetLocation()
     return location;
 }
 
+unsigned char CMMP750Controller::GetMode()
+{
+    return current_mode;
+}
+
+unsigned char CMMP750Controller::GetLedRed()
+{
+    return current_red;
+}
+
+unsigned char CMMP750Controller::GetLedGreen()
+{
+    return current_green;
+}
+
+unsigned char CMMP750Controller::GetLedBlue()
+{
+    return current_blue;
+}
+
+unsigned char CMMP750Controller::GetLedSpeed()
+{
+    return current_speed;
+}
+
 void CMMP750Controller::SetMode(unsigned char mode, unsigned char speed)
 {
     current_mode  = mode;

Controllers/CoolerMasterController/CMMP750Controller.h

@@ -20,7 +20,7 @@
 
 #pragma once
 
-#define CM_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data) / sizeof(colour_mode_data[0]))
+#define CM_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
 #define CM_INTERRUPT_TIMEOUT 250
 #define CM_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
 #define CM_SERIAL_SIZE (sizeof(serial) / sizeof(serial[ 0 ]))
@@ -85,6 +85,11 @@ public:
     char* GetSerial();
     std::string GetLocation();
 
+    unsigned char GetMode();
+    unsigned char GetLedRed();
+    unsigned char GetLedGreen();
+    unsigned char GetLedBlue();
+    unsigned char GetLedSpeed();
     void SetMode(unsigned char mode, unsigned char speed);
     void SetColor(unsigned char red, unsigned char green, unsigned char blue);
 
@@ -101,5 +106,6 @@ private:
     unsigned char           current_green;
     unsigned char           current_blue;
 
+    void GetStatus();
     void SendUpdate();
 };

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -36,7 +36,7 @@ void DetectCoolerMasterControllers(std::vector<RGBController*>& rgb_controllers)
 
     //Look for the passed in cm_pids
     hid_init();
-    info = hid_enumerate(0x0, 0x0);
+    info = hid_enumerate(COOLERMASTER_VID, 0x0);
 
     while(info)
     {
@@ -56,7 +56,7 @@ void DetectCoolerMasterControllers(std::vector<RGBController*>& rgb_controllers)
 
         if(dev)
         {
-            CMMP750Controller* controller = new CMMP750Controller(dev, info->manufacturer_string, info->product_string, info->path);
+            CMMP750Controller* controller                   = new CMMP750Controller(dev, info->manufacturer_string, info->product_string, info->path);
             RGBController_CMMP750Controller* rgb_controller = new RGBController_CMMP750Controller(controller);
             rgb_controllers.push_back(rgb_controller);
         }

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

@@ -65,7 +65,7 @@ void CorsairLightingNodeController::KeepaliveThread()
 {
     while(1)
     {
-        if((clock() - last_commit_time) > 5000)
+        if((std::chrono::steady_clock::now() - last_commit_time) > std::chrono::seconds(5))
         {
             SendCommit();
         }
@@ -198,7 +198,7 @@ void CorsairLightingNodeController::SetChannelLEDs(unsigned char channel, RGBCol
 void CorsairLightingNodeController::SendFirmwareRequest()
 {
     int             actual;
-    unsigned char   usb_buf[64];
+    unsigned char   usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -208,13 +208,14 @@ void CorsairLightingNodeController::SendFirmwareRequest()
     /*-----------------------------------------------------*\
     | Set up Firmware Version Request packet                |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_LIGHTING_NODE_PACKET_ID_FIRMWARE;
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_FIRMWARE;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 64);
-    actual = hid_read(dev, usb_buf, 16);
+    hid_write(dev, usb_buf, 65);
+    actual = hid_read(dev, usb_buf, 17);
 
     if(actual > 0)
     {
@@ -231,7 +232,7 @@ void CorsairLightingNodeController::SendDirect
     unsigned char*  color_data
     )
 {
-    unsigned char   usb_buf[64];
+    unsigned char   usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -241,27 +242,28 @@ void CorsairLightingNodeController::SendDirect
     /*-----------------------------------------------------*\
     | Set up Direct packet                                  |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_LIGHTING_NODE_PACKET_ID_DIRECT;
-    usb_buf[0x01]   = channel;
-    usb_buf[0x02]   = start;
-    usb_buf[0x03]   = count;
-    usb_buf[0x04]   = color_channel;
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_DIRECT;
+    usb_buf[0x02]   = channel;
+    usb_buf[0x03]   = start;
+    usb_buf[0x04]   = count;
+    usb_buf[0x05]   = color_channel;
 
     /*-----------------------------------------------------*\
     | Copy in color data bytes                              |
     \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x05], color_data, count);
+    memcpy(&usb_buf[0x06], color_data, count);
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 64);
-    hid_read(dev, usb_buf, 16);
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 17);
 }
 
 void CorsairLightingNodeController::SendCommit()
 {
-    unsigned char   usb_buf[64];
+    unsigned char   usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -271,19 +273,20 @@ void CorsairLightingNodeController::SendCommit()
     /*-----------------------------------------------------*\
     | Update last commit time                               |
     \*-----------------------------------------------------*/
-    last_commit_time = clock();
+    last_commit_time = std::chrono::steady_clock::now();
 
     /*-----------------------------------------------------*\
     | Set up Commit packet                                  |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_LIGHTING_NODE_PACKET_ID_COMMIT;
-    usb_buf[0x01]   = 0xFF;
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_COMMIT;
+    usb_buf[0x02]   = 0xFF;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 64);
-    hid_read(dev, usb_buf, 16);
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 17);
 }
 
 void CorsairLightingNodeController::SendBegin
@@ -291,7 +294,7 @@ void CorsairLightingNodeController::SendBegin
     unsigned char   channel
     )
 {
-    unsigned char   usb_buf[64];
+    unsigned char   usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -301,14 +304,15 @@ void CorsairLightingNodeController::SendBegin
     /*-----------------------------------------------------*\
     | Set up Begin packet                                   |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_LIGHTING_NODE_PACKET_ID_BEGIN;
-    usb_buf[0x01]   = channel;
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_BEGIN;
+    usb_buf[0x02]   = channel;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 64);
-    hid_read(dev, usb_buf, 16);
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 17);
 }
 
 void CorsairLightingNodeController::SendEffectConfig
@@ -334,7 +338,7 @@ void CorsairLightingNodeController::SendEffectConfig
     unsigned short  temperature_2
     )
 {
-    unsigned char   usb_buf[64];
+    unsigned char   usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -344,48 +348,49 @@ void CorsairLightingNodeController::SendEffectConfig
     /*-----------------------------------------------------*\
     | Set up Effect Config packet                           |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_LIGHTING_NODE_PACKET_ID_EFFECT_CONFIG;
-    usb_buf[0x01]   = channel;
-    usb_buf[0x02]   = count;
-    usb_buf[0x03]   = led_type;
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_EFFECT_CONFIG;
+    usb_buf[0x02]   = channel;
+    usb_buf[0x03]   = count;
+    usb_buf[0x04]   = led_type;
 
     /*-----------------------------------------------------*\
     | Set up mode parameters                                |
     \*-----------------------------------------------------*/
-    usb_buf[0x04]   = mode;
-    usb_buf[0x05]   = speed;
-    usb_buf[0x06]   = direction;
-    usb_buf[0x07]   = change_style;
-    usb_buf[0x08]   = 0;
+    usb_buf[0x05]   = mode;
+    usb_buf[0x06]   = speed;
+    usb_buf[0x07]   = direction;
+    usb_buf[0x08]   = change_style;
+    usb_buf[0x09]   = 0;
 
     /*-----------------------------------------------------*\
     | Set up mode colors                                    |
     \*-----------------------------------------------------*/
-    usb_buf[0x09]   = color_0_red;
-    usb_buf[0x0A]   = color_0_green;
-    usb_buf[0x0B]   = color_0_blue;
-    usb_buf[0x0C]   = color_1_red;
-    usb_buf[0x0D]   = color_1_green;
-    usb_buf[0x0E]   = color_1_blue;
-    usb_buf[0x0F]   = color_2_red;
-    usb_buf[0x10]   = color_2_green;
-    usb_buf[0x11]   = color_2_blue;
+    usb_buf[0x0A]   = color_0_red;
+    usb_buf[0x0B]   = color_0_green;
+    usb_buf[0x0C]   = color_0_blue;
+    usb_buf[0x0D]   = color_1_red;
+    usb_buf[0x0E]   = color_1_green;
+    usb_buf[0x0F]   = color_1_blue;
+    usb_buf[0x10]   = color_2_red;
+    usb_buf[0x11]   = color_2_green;
+    usb_buf[0x12]   = color_2_blue;
 
     /*-----------------------------------------------------*\
     | Set up temperatures                                   |
     \*-----------------------------------------------------*/
-    usb_buf[0x12]   = (temperature_0 >> 8);
-    usb_buf[0x13]   = (temperature_0 & 0xFF);
-    usb_buf[0x14]   = (temperature_1 >> 8);
-    usb_buf[0x15]   = (temperature_1 & 0xFF);
-    usb_buf[0x16]   = (temperature_2 >> 8);
-    usb_buf[0x17]   = (temperature_2 & 0xFF);
+    usb_buf[0x13]   = (temperature_0 >> 8);
+    usb_buf[0x14]   = (temperature_0 & 0xFF);
+    usb_buf[0x15]   = (temperature_1 >> 8);
+    usb_buf[0x16]   = (temperature_1 & 0xFF);
+    usb_buf[0x17]   = (temperature_2 >> 8);
+    usb_buf[0x18]   = (temperature_2 & 0xFF);
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 64);
-    hid_read(dev, usb_buf, 16);
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 17);
 }
 
 void CorsairLightingNodeController::SendTemperature()
@@ -398,7 +403,7 @@ void CorsairLightingNodeController::SendReset
     unsigned char   channel
     )
 {
-    unsigned char   usb_buf[64];
+    unsigned char   usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -408,14 +413,15 @@ void CorsairLightingNodeController::SendReset
     /*-----------------------------------------------------*\
     | Set up Reset packet                                   |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_LIGHTING_NODE_PACKET_ID_RESET;
-    usb_buf[0x01]   = channel;
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_RESET;
+    usb_buf[0x02]   = channel;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 64);
-    hid_read(dev, usb_buf, 16);
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 17);
 }
 
 void CorsairLightingNodeController::SendPortState
@@ -424,7 +430,7 @@ void CorsairLightingNodeController::SendPortState
     unsigned char   state
     )
 {
-    unsigned char   usb_buf[64];
+    unsigned char   usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -434,15 +440,16 @@ void CorsairLightingNodeController::SendPortState
     /*-----------------------------------------------------*\
     | Set up Port State packet                              |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_LIGHTING_NODE_PACKET_ID_PORT_STATE;
-    usb_buf[0x01]   = channel;
-    usb_buf[0x02]   = state;
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_PORT_STATE;
+    usb_buf[0x02]   = channel;
+    usb_buf[0x03]   = state;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 64);
-    hid_read(dev, usb_buf, 16);
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 17);
 }
 
 void CorsairLightingNodeController::SendBrightness()

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.h

@@ -5,6 +5,7 @@
 \*---------------------------------------------------------*/
 
 #include "RGBController.h"
+#include <chrono>
 #include <vector>
 #include <hidapi/hidapi.h>
 
@@ -109,7 +110,7 @@ public:
 private:
     hid_device*             dev;
     std::string             firmware_version;
-    clock_t                 last_commit_time;
+    std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
 
     void            SendFirmwareRequest();
 

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

@@ -24,27 +24,12 @@ static unsigned int keys[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x
 
 static unsigned int st100[] = { 0x00, 0x01, 0x02, 0x03, 0x05, 0x06, 0x07, 0x08, 0x04 };
 
-static void send_usb_msg(hid_device* dev, char * data_pkt)
-{
-    char usb_pkt[65];
-    usb_pkt[0] = 0x00;
-    for(int i = 1; i < 65; i++)
-    {
-        usb_pkt[i] = data_pkt[i-1];
-    }
-    int bytes = hid_send_feature_report(dev, (unsigned char *)usb_pkt, 65);
-    bytes++;
-
-    std::this_thread::sleep_for(1ms);
-}
-
 CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle)
 {
     dev = dev_handle;
 
     ReadFirmwareInfo();
 
-    SpecialFunctionControl();
     LightingControl();
 }
 
@@ -233,7 +218,7 @@ void CorsairPeripheralController::SetLEDsKeyboardLimited(std::vector<RGBColor> c
 
 void CorsairPeripheralController::LightingControl()
 {
-    char usb_buf[64];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -243,9 +228,10 @@ void CorsairPeripheralController::LightingControl()
     /*-----------------------------------------------------*\
     | Set up Lighting Control packet                        |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]           = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x01]           = CORSAIR_PROPERTY_LIGHTING_CONTROL;
-    usb_buf[0x02]           = CORSAIR_LIGHTING_CONTROL_SOFTWARE;
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x02]           = CORSAIR_PROPERTY_LIGHTING_CONTROL;
+    usb_buf[0x03]           = CORSAIR_LIGHTING_CONTROL_SOFTWARE;
 
     /*-----------------------------------------------------*\
     | Lighting control byte needs to be 3 for keyboards and |
@@ -255,31 +241,31 @@ void CorsairPeripheralController::LightingControl()
     {
         default:
         case DEVICE_TYPE_KEYBOARD:
-            usb_buf[0x04]   = 0x03;
+            usb_buf[0x05]   = 0x03;
             break;
 
         case DEVICE_TYPE_MOUSE:
-            usb_buf[0x04]   = 0x01;
+            usb_buf[0x05]   = 0x01;
             break;
 
         case DEVICE_TYPE_MOUSEMAT:
-            usb_buf[0x04]   = 0x04;
+            usb_buf[0x05]   = 0x04;
             break;
 
         case DEVICE_TYPE_HEADSET_STAND:
-            usb_buf[0x04]   = 0x03;
+            usb_buf[0x05]   = 0x03;
             break;
     }
     
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 }
 
 void CorsairPeripheralController::SpecialFunctionControl()
 {
-    char usb_buf[64];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -289,20 +275,22 @@ void CorsairPeripheralController::SpecialFunctionControl()
     /*-----------------------------------------------------*\
     | Set up Lighting Control packet                        |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]           = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x01]           = CORSAIR_PROPERTY_SPECIAL_FUNCTION;
-    usb_buf[0x02]           = CORSAIR_LIGHTING_CONTROL_SOFTWARE;
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x02]           = CORSAIR_PROPERTY_SPECIAL_FUNCTION;
+    usb_buf[0x03]           = CORSAIR_LIGHTING_CONTROL_SOFTWARE;
     
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 }
 
 void CorsairPeripheralController::ReadFirmwareInfo()
 {
     int  actual;
-    char usb_buf[64];
+    char usb_buf[65];
+    char offset = 0;
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -312,16 +300,17 @@ void CorsairPeripheralController::ReadFirmwareInfo()
     /*-----------------------------------------------------*\
     | Set up Read Firmware Info packet                      |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_COMMAND_READ;
-    usb_buf[0x01]   = CORSAIR_PROPERTY_FIRMWARE_INFO;
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_COMMAND_READ;
+    usb_buf[0x02]   = CORSAIR_PROPERTY_FIRMWARE_INFO;
 
     /*-----------------------------------------------------*\
     | Send packet and try reading it using an HID read      |
     | If that fails, repeat the send and read the reply as  |
     | a feature report.                                     |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char*)usb_buf, 64);
-    actual = hid_read_timeout(dev, (unsigned char*)usb_buf, 64, 1000);
+    hid_write(dev, (unsigned char*)usb_buf, 65);
+    actual = hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000);
 
     if(actual == 0)
     {
@@ -333,11 +322,13 @@ void CorsairPeripheralController::ReadFirmwareInfo()
         /*-------------------------------------------------*\
         | Set up Read Firmware Info packet                  |
         \*-------------------------------------------------*/
-        usb_buf[0x00]   = CORSAIR_COMMAND_READ;
-        usb_buf[0x01]   = CORSAIR_PROPERTY_FIRMWARE_INFO;
+        usb_buf[0x00]   = 0x00;
+        usb_buf[0x01]   = CORSAIR_COMMAND_READ;
+        usb_buf[0x02]   = CORSAIR_PROPERTY_FIRMWARE_INFO;
 
-        hid_write(dev, (unsigned char*)usb_buf, 64);
-        actual = hid_get_feature_report(dev, (unsigned char*)usb_buf, 64);
+        hid_send_feature_report(dev, (unsigned char*)usb_buf, 65);
+        actual = hid_get_feature_report(dev, (unsigned char*)usb_buf, 65);
+        offset = 1;
     }
 
     /*-----------------------------------------------------*\
@@ -346,7 +337,7 @@ void CorsairPeripheralController::ReadFirmwareInfo()
     |   0xC1    Device is a mouse                           |
     |   0xC2    Device is a mousepad or headset stand       |
     \*-----------------------------------------------------*/
-    switch((unsigned char)usb_buf[0x14])
+    switch((unsigned char)usb_buf[0x14 + offset])
     {
         case 0xC0:
             type = DEVICE_TYPE_KEYBOARD;
@@ -354,6 +345,7 @@ void CorsairPeripheralController::ReadFirmwareInfo()
 
         case 0xC1:
             type = DEVICE_TYPE_MOUSE;
+            SpecialFunctionControl();
             break;
 
         case 0xC2:
@@ -364,10 +356,12 @@ void CorsairPeripheralController::ReadFirmwareInfo()
                 {
                     case 0x0A34:
                         type = DEVICE_TYPE_HEADSET_STAND;
+                        SpecialFunctionControl();
                         break;
                     
                     default:
                         type = DEVICE_TYPE_MOUSEMAT;
+                        SpecialFunctionControl();
                         break;
                 }
             }
@@ -383,7 +377,7 @@ void CorsairPeripheralController::ReadFirmwareInfo()
     \*-----------------------------------------------------*/
     if(type != DEVICE_TYPE_UNKNOWN)
     {
-        firmware_version = std::to_string(usb_buf[0x09]) + "." + std::to_string(usb_buf[0x08]);
+        firmware_version = std::to_string(usb_buf[0x09 + offset]) + "." + std::to_string(usb_buf[0x08 + offset]);
     }
 }
 
@@ -394,7 +388,7 @@ void CorsairPeripheralController::StreamPacket
     unsigned char*  data_ptr
     )
 {
-    char usb_buf[64];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -404,19 +398,20 @@ void CorsairPeripheralController::StreamPacket
     /*-----------------------------------------------------*\
     | Set up Stream packet                                  |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_COMMAND_STREAM;
-    usb_buf[0x01]   = packet_id;
-    usb_buf[0x02]   = data_sz;
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_COMMAND_STREAM;
+    usb_buf[0x02]   = packet_id;
+    usb_buf[0x03]   = data_sz;
 
     /*-----------------------------------------------------*\
     | Copy in data bytes                                    |
     \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x04], data_ptr, data_sz);
+    memcpy(&usb_buf[0x05], data_ptr, data_sz);
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 64);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 }
 
 void CorsairPeripheralController::SubmitKeyboardFullColors
@@ -426,7 +421,7 @@ void CorsairPeripheralController::SubmitKeyboardFullColors
     unsigned char   finish_val
     )
 {
-    char usb_buf[64];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -436,16 +431,17 @@ void CorsairPeripheralController::SubmitKeyboardFullColors
     /*-----------------------------------------------------*\
     | Set up Submit Keyboard 24-Bit Colors packet           |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x01]   = CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_24;
-    usb_buf[0x02]   = color_channel;
-    usb_buf[0x03]   = packet_count;
-    usb_buf[0x04]   = finish_val;
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x02]   = CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_24;
+    usb_buf[0x03]   = color_channel;
+    usb_buf[0x04]   = packet_count;
+    usb_buf[0x05]   = finish_val;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 64);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 }
 
 void CorsairPeripheralController::SubmitKeyboardLimitedColors
@@ -453,7 +449,7 @@ void CorsairPeripheralController::SubmitKeyboardLimitedColors
     unsigned char   byte_count
     )
 {
-    char usb_buf[64];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -463,14 +459,15 @@ void CorsairPeripheralController::SubmitKeyboardLimitedColors
     /*-----------------------------------------------------*\
     | Set up Submit Keyboard 9-Bit Colors packet            |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x01]   = CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_9;
-    usb_buf[0x04]   = byte_count;
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x02]   = CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_9;
+    usb_buf[0x05]   = byte_count;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 64);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 }
 
 void CorsairPeripheralController::SubmitMouseColors
@@ -479,7 +476,7 @@ void CorsairPeripheralController::SubmitMouseColors
     RGBColor *      color_data
     )
 {
-    char usb_buf[64];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -489,26 +486,27 @@ void CorsairPeripheralController::SubmitMouseColors
     /*-----------------------------------------------------*\
     | Set up Submit Mouse Colors packet                     |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x01]   = CORSAIR_PROPERTY_SUBMIT_MOUSE_COLOR;
-    usb_buf[0x02]   = num_zones;
-    usb_buf[0x03]   = 0x00;
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x02]   = CORSAIR_PROPERTY_SUBMIT_MOUSE_COLOR;
+    usb_buf[0x03]   = num_zones;
+    usb_buf[0x04]   = 0x00;
 
     /*-----------------------------------------------------*\
     | Copy in colors in <ZONE> <RED> <GREEN> <BLUE> order   |
     \*-----------------------------------------------------*/
     for(unsigned int zone_idx = 0; zone_idx < num_zones; zone_idx++)
     {
-        usb_buf[(zone_idx * 4) + 4] = zone_idx;
-        usb_buf[(zone_idx * 4) + 5] = RGBGetRValue(color_data[zone_idx]);
-        usb_buf[(zone_idx * 4) + 6] = RGBGetGValue(color_data[zone_idx]);
-        usb_buf[(zone_idx * 4) + 7] = RGBGetBValue(color_data[zone_idx]);
+        usb_buf[(zone_idx * 4) + 5] = zone_idx;
+        usb_buf[(zone_idx * 4) + 6] = RGBGetRValue(color_data[zone_idx]);
+        usb_buf[(zone_idx * 4) + 7] = RGBGetGValue(color_data[zone_idx]);
+        usb_buf[(zone_idx * 4) + 8] = RGBGetBValue(color_data[zone_idx]);
     }
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 64);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 }
 
 void CorsairPeripheralController::SubmitMousematColors
@@ -517,7 +515,7 @@ void CorsairPeripheralController::SubmitMousematColors
     RGBColor *      color_data
     )
 {
-    char usb_buf[64];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -527,24 +525,25 @@ void CorsairPeripheralController::SubmitMousematColors
     /*-----------------------------------------------------*\
     | Set up Submit Mouse Colors packet                     |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x01]   = CORSAIR_PROPERTY_SUBMIT_MOUSE_COLOR;
-    usb_buf[0x02]   = num_zones;
-    usb_buf[0x03]   = 0x00;
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x02]   = CORSAIR_PROPERTY_SUBMIT_MOUSE_COLOR;
+    usb_buf[0x03]   = num_zones;
+    usb_buf[0x04]   = 0x00;
 
     /*-----------------------------------------------------*\
     | Copy in colors in <RED> <GREEN> <BLUE> order          |
     \*-----------------------------------------------------*/
     for(unsigned int zone_idx = 0; zone_idx < num_zones; zone_idx++)
     {
-        usb_buf[(zone_idx * 3) + 4] = RGBGetRValue(color_data[zone_idx]);
-        usb_buf[(zone_idx * 3) + 5] = RGBGetGValue(color_data[zone_idx]);
-        usb_buf[(zone_idx * 3) + 6] = RGBGetBValue(color_data[zone_idx]);
+        usb_buf[(zone_idx * 3) + 5] = RGBGetRValue(color_data[zone_idx]);
+        usb_buf[(zone_idx * 3) + 6] = RGBGetGValue(color_data[zone_idx]);
+        usb_buf[(zone_idx * 3) + 7] = RGBGetBValue(color_data[zone_idx]);
     }
 
     /*-----------------------------------------------------*\
     | Send packet using feature reports, as headset stand   |
     | seems to not update completely using HID writes       |
     \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 }

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -39,6 +39,9 @@
 | Mouse product IDs                                     |
 |   List taken from ckb-next                            |
 \*-----------------------------------------------------*/
+#define CORSAIR_GLAIVE_RGB_PRO_PID      0x1B74
+#define CORSAIR_HARPOON_RGB_PID         0x1B3C
+#define CORSAIR_HARPOON_RGB_PRO_PID     0x1B75
 #define CORSAIR_M65_PRO_PID             0x1B2E
 #define CORSAIR_M65_RGB_ELITE_PID       0x1B5A
 
@@ -87,6 +90,9 @@ static const corsair_node_device device_list[] =
     /*-----------------------------------------------------------------------------------------------------*\
     | Mice                                                                                                  |
     \*-----------------------------------------------------------------------------------------------------*/
+    { CORSAIR_VID,          CORSAIR_GLAIVE_RGB_PRO_PID,         1,      "Corsair Glaive RGB PRO"            },
+    { CORSAIR_VID,          CORSAIR_HARPOON_RGB_PID,            1,      "Corsair Harpoon RGB"               },
+    { CORSAIR_VID,          CORSAIR_HARPOON_RGB_PRO_PID,        1,      "Corsair Harpoon RGB PRO"           },
     { CORSAIR_VID,          CORSAIR_M65_PRO_PID,                1,      "Corsair M65 PRO"                   },
     { CORSAIR_VID,          CORSAIR_M65_RGB_ELITE_PID,          1,      "Corsair M65 RGB Elite"             },
     /*-----------------------------------------------------------------------------------------------------*\
@@ -124,30 +130,31 @@ void DetectCorsairPeripheralControllers(std::vector<RGBController*>& rgb_control
         while(info)
         {
             if((info->vendor_id == device_list[device_idx].usb_vid)
+#ifdef USE_HID_USAGE
+            &&(info->product_id == device_list[device_idx].usb_pid)
+            &&(info->usage_page == 0xFFC2))
+#else
             &&(info->product_id == device_list[device_idx].usb_pid)
             &&(info->interface_number == device_list[device_idx].usb_interface))
+#endif
             {
                 dev = hid_open_path(info->path);
-                break;
-            }
-            else
-            {
-                info = info->next;
-            }
-        }
 
-        if( dev )
-        {
-            CorsairPeripheralController* controller = new CorsairPeripheralController(dev);
+                if( dev )
+                {
+                    CorsairPeripheralController* controller = new CorsairPeripheralController(dev);
 
-            if(controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
-            {
-                RGBController_CorsairPeripheral* rgb_controller = new RGBController_CorsairPeripheral(controller);
+                    if(controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
+                    {
+                        RGBController_CorsairPeripheral* rgb_controller = new RGBController_CorsairPeripheral(controller);
 
-                rgb_controller->name = device_list[device_idx].name;
-                
-                rgb_controllers.push_back(rgb_controller);
+                        rgb_controller->name = device_list[device_idx].name;
+
+                        rgb_controllers.push_back(rgb_controller);
+                    }
+                }
             }
+            info = info->next;
         }
     }
 }

Controllers/DuckyKeyboardController/DuckyKeyboardController.cpp

@@ -0,0 +1,187 @@
+/*-----------------------------------------*\
+|  DuckyKeyboardController.cpp              |
+|                                           |
+|  Driver for Ducky RGB keyboardlighting    |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 7/4/2020    |
+\*-----------------------------------------*/
+
+#include <cstring>
+#include "DuckyKeyboardController.h"
+
+DuckyKeyboardController::DuckyKeyboardController(hid_device* dev_handle)
+{
+    dev = dev_handle;
+
+    SendInitialize();
+}
+
+DuckyKeyboardController::~DuckyKeyboardController()
+{
+    
+}
+
+void DuckyKeyboardController::SendColors
+    (
+    unsigned char*  color_data,
+    unsigned int    color_data_size
+    )
+{
+    unsigned int    bytes_sent;
+    unsigned char*  color_data_ptr = color_data;
+
+    SendInitializeColorPacket();
+
+    for(int i = 0; i < 8; i++)
+    {
+        bytes_sent = SendColorDataPacket(i, color_data_ptr, color_data_size);
+
+        color_data_ptr += bytes_sent;
+        color_data_size -= bytes_sent;
+    }
+
+    SendTerminateColorPacket();
+}
+
+void DuckyKeyboardController::SendInitialize()
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Initialize Direct Mode packet                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x41;
+    usb_buf[0x02]   = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+}
+
+void DuckyKeyboardController::SendInitializeColorPacket()
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Initialize Color packet                        |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x56;
+    usb_buf[0x02]   = 0x81;
+    usb_buf[0x05]   = 0x01;
+    usb_buf[0x09]   = 0x08;
+    usb_buf[0x0D]   = 0xAA;
+    usb_buf[0x0E]   = 0xAA;
+    usb_buf[0x0F]   = 0xAA;
+    usb_buf[0x10]   = 0xAA;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+}
+
+unsigned int DuckyKeyboardController::SendColorDataPacket
+    (
+    unsigned char   packet_id,
+    unsigned char*  color_data,
+    unsigned int    color_size
+    )
+{
+    unsigned int bytes_sent;
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Color Data packet                              |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x56;
+    usb_buf[0x02]   = 0x83;
+    usb_buf[0x03]   = packet_id;
+
+    if(packet_id == 0x00)
+    {
+        usb_buf[0x05]   = 0x01;
+        usb_buf[0x09]   = 0x80;
+        usb_buf[0x0A]   = 0x01;
+        usb_buf[0x0C]   = 0xC1;
+        usb_buf[0x11]   = 0xFF;
+        usb_buf[0x12]   = 0xFF;
+        usb_buf[0x13]   = 0xFF;
+        usb_buf[0x14]   = 0xFF;
+    }
+
+    /*-----------------------------------------------------*\
+    | Copy in color data                                    |
+    \*-----------------------------------------------------*/
+    if(packet_id == 0x00)
+    {
+        bytes_sent = 65 - 0x19;
+
+        if(color_size < bytes_sent)
+        {
+            bytes_sent = color_size;
+        }
+
+        memcpy(&usb_buf[0x19], color_data, bytes_sent);
+    }
+    else
+    {
+        bytes_sent = 65 - 0x05;
+
+        if(color_size < bytes_sent)
+        {
+            bytes_sent = color_size;
+        }
+
+        memcpy(&usb_buf[0x05], color_data, bytes_sent);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    return(bytes_sent);
+}
+
+void DuckyKeyboardController::SendTerminateColorPacket()
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Terminate Color packet                         |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x51;
+    usb_buf[0x02]   = 0x28;
+    usb_buf[0x05]   = 0xFF;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+}

Controllers/DuckyKeyboardController/DuckyKeyboardController.h

@@ -0,0 +1,41 @@
+/*-----------------------------------------*\
+|  DuckyKeyboardController.h                |
+|                                           |
+|  Definitions and types for Ducky RGB      |
+|  keyboard lighting controller             |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 7/4/2020    |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+class DuckyKeyboardController
+{
+public:
+    DuckyKeyboardController(hid_device* dev_handle);
+    ~DuckyKeyboardController();
+
+    void SendColors
+            (
+            unsigned char*  color_data,
+            unsigned int    color_data_size
+            );
+
+private:
+    hid_device*             dev;
+
+    void SendInitialize();
+    void SendInitializeColorPacket();
+    unsigned int SendColorDataPacket
+        (
+        unsigned char   packet_id,
+        unsigned char*  color_data,
+        unsigned int    color_size
+        );
+    void SendTerminateColorPacket();
+};

Controllers/DuckyKeyboardController/DuckyKeyboardControllerDetect.cpp

@@ -0,0 +1,81 @@
+#include "DuckyKeyboardController.h"
+#include "RGBController.h"
+#include "RGBController_DuckyKeyboard.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+/*-----------------------------------------------------*\
+| Ducky vendor ID                                       |
+\*-----------------------------------------------------*/
+#define DUCKY_VID                       0x04D9
+
+/*-----------------------------------------------------*\
+| Keyboard product IDs                                  |
+\*-----------------------------------------------------*/
+#define DUCKY_SHINE_7_ONE_2_RGB_PID     0x0348
+#define DUCKY_ONE_2_RGB_TKL_PID         0x0356
+
+typedef struct
+{
+    unsigned short  usb_vid;
+    unsigned short  usb_pid;
+    unsigned char   usb_interface;
+    const char *    name;
+} ducky_device;
+
+#define DUCKY_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+static const ducky_device device_list[] =
+{
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Keyboards                                                                                             |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { DUCKY_VID,            DUCKY_SHINE_7_ONE_2_RGB_PID,        1,      "Ducky Shine 7/Ducky One 2 RGB"     },
+    { DUCKY_VID,            DUCKY_ONE_2_RGB_TKL_PID,            1,      "Ducky One 2 RGB TKL"               },
+};
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectDuckyKeyboardControllers                                                         *
+*                                                                                          *
+*       Tests the USB address to see if a Ducky RGB Keyboard controller exists there.      *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectDuckyKeyboardControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device_info* info;
+    hid_device* dev;
+
+    hid_init();
+
+    for(std::size_t device_idx = 0; device_idx < DUCKY_NUM_DEVICES; device_idx++)
+    {
+        dev = NULL;
+
+        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+
+        //Look for Ducky RGB Peripheral
+        while(info)
+        {
+            if((info->vendor_id == device_list[device_idx].usb_vid)
+            &&(info->product_id == device_list[device_idx].usb_pid)
+            &&(info->interface_number == device_list[device_idx].usb_interface))
+            {
+                dev = hid_open_path(info->path);
+
+                if( dev )
+                {
+                    DuckyKeyboardController* controller = new DuckyKeyboardController(dev);
+
+                    RGBController_DuckyKeyboard* rgb_controller = new RGBController_DuckyKeyboard(controller);
+
+                    rgb_controller->name = device_list[device_idx].name;
+                    
+                    rgb_controllers.push_back(rgb_controller);
+                }
+            }
+            info = info->next;
+        }
+    }
+}

Controllers/EKController/EKController.cpp

@@ -0,0 +1,92 @@
+/*-------------------------------------------------------------------*\
+|  EKController.cpp                                                   |
+|                                                                     |
+|  Driver for EK Loop Connect                                         |
+|                                                                     |
+|  Chris M (Dr_No)          16th Jul 2020                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "EKController.h"
+
+EKController::EKController(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path)
+{
+    int tmp_size = wcslen(_vendor);
+
+    dev = dev_handle;
+
+    for(int i=0; (i < tmp_size) && (i < EK_DEVICE_NAME_SIZE); i++)
+    {
+        device_name[i] = (char)_vendor[i];
+    }
+
+    for(int j=0; (j < wcslen(_vendor)) && ((tmp_size + j) < EK_DEVICE_NAME_SIZE); j++)
+    {
+        device_name[tmp_size+j] = (char)_device_name[j];
+    }
+
+    location = _path;
+
+    current_mode = EK_MODE_STATIC;
+    current_speed = EK_SPEED_NORMAL;
+}
+
+EKController::~EKController()
+{
+    hid_close(dev);
+}
+
+char* EKController::GetDeviceName()
+{
+    return device_name;
+}
+
+char* EKController::GetSerial()
+{
+    return serial;
+}
+
+std::string EKController::GetLocation()
+{
+    return location;
+}
+
+void EKController::SetMode(unsigned char mode, unsigned char speed)
+{
+    current_mode  = mode;
+    current_speed = speed;
+
+    SendUpdate();
+}
+
+void EKController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    current_red   = red;
+    current_green = green;
+    current_blue  = blue;
+
+    SendUpdate();
+}
+
+void EKController::SendUpdate()
+{
+    unsigned char buffer[EK_PACKET_LENGTH] = { 0x00 };
+    int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
+
+    for(int i = 0; i < EK_COLOUR_MODE_DATA_SIZE; i++)
+    {
+        buffer[i] = colour_mode_data[current_mode][i];
+    }
+
+    //Set the relevant colour info
+    buffer[EK_RED_BYTE] = current_red;
+    buffer[EK_GREEN_BYTE] = current_green;
+    buffer[EK_BLUE_BYTE] = current_blue;
+    buffer[EK_SPEED_BYTE] = speed_mode_data[current_mode][current_speed];
+
+    buffer[10] = 0x10;
+    buffer[47] = 0xFF;
+    buffer[48] = 0x00;
+
+    hid_write(dev, buffer, buffer_size);
+}

Controllers/EKController/EKController.h

@@ -0,0 +1,119 @@
+/*-------------------------------------------------------------------*\
+|  EKController.h                                                     |
+|                                                                     |
+|  Driver for EK Loop Connect                                         |
+|                                                                     |
+|  Chris M (Dr_No)          16th Jul 2020                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#ifndef EKCONTROLLER_H
+#define EKCONTROLLER_H
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#define EK_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
+#define EK_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
+#define EK_PACKET_LENGTH    0x3F
+
+enum
+{
+    EK_MODE_BYTE   = 12,
+    EK_SPEED_BYTE  = 14,
+    EK_RED_BYTE    = 16,
+    EK_GREEN_BYTE  = 17,
+    EK_BLUE_BYTE   = 18
+};
+
+enum
+{
+    EK_MODE_STATIC              = 0x00,                         //Static Mode
+    EK_MODE_BREATHING           = 0x01,                         //Breathing Mode
+    EK_MODE_FADING              = 0x02,                         //Fading Mode
+    EK_MODE_MARQUEE             = 0x03,                         //Marquee Mode
+    EK_MODE_COVERING_MARQUEE    = 0x04,                         //Covering Marquee Mode
+    EK_MODE_PULSE               = 0x05,                         //Pulse Mode
+    EK_MODE_SPECTRUM_WAVE       = 0x06,                         //Spectrum Wave Mode
+    EK_MODE_ALTERNATING         = 0x07,                         //Alternating Mode
+    EK_MODE_CANDLE              = 0x08                          //Candle Mode
+};
+
+static unsigned char colour_mode_data[][16] =
+{
+    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
+      0x00, 0x10, 0x20, 0x01, 0x01, 0x00, 0xFF, 0x64},          // Static
+    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
+      0x00, 0x10, 0x20, 0x01, 0x02, 0x00, 0xFF, 0x64},          // Breathing
+    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
+      0x00, 0x10, 0x20, 0x01, 0x03, 0xFF, 0xFF, 0x64},          // Fading
+    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
+      0x00, 0x10, 0x20, 0x01, 0x04, 0x00, 0xFF, 0x64},          // Marquee
+    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
+      0x00, 0x10, 0x20, 0x01, 0x05, 0x00, 0xFF, 0x64},          // Covering Marquee
+    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
+      0x00, 0x10, 0x20, 0x01, 0x06, 0x00, 0xFF, 0x64},          // Pulse
+    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
+      0x00, 0x10, 0x20, 0x01, 0x07, 0x00, 0xFF, 0x64},          // Wave
+    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
+      0x00, 0x10, 0x20, 0x01, 0x08, 0x00, 0xFF, 0x64},          // Alternating
+    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
+      0x00, 0x10, 0x20, 0x01, 0x09, 0x00, 0xFF, 0x64},          // Candle
+};
+
+static unsigned char speed_mode_data[][9] =
+{
+    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   // Static
+    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 },   // Breathing
+    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 },   // Fading
+    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 },   // Marquee
+    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 },   // Covering Marquee
+    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 },   // Pulse
+    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 },   // Wave
+    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 },   // Alternating
+    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 }    // Candle
+};
+
+enum
+{
+    EK_SPEED_SLOWEST              = 0x00, // Slowest speed
+    EK_SPEED_SLOWER               = 0x01, // Slower speed
+    EK_SPEED_SLOW                 = 0x02, // Slow speed
+    EK_SPEED_SLOWISH              = 0x03, // Slowish speed
+    EK_SPEED_NORMAL               = 0x04, // Normal speed
+    EK_SPEED_FASTISH              = 0x05, // Fastish speed
+    EK_SPEED_FAST                 = 0x06, // Fast speed
+    EK_SPEED_FASTER               = 0x07, // Faster speed
+    EK_SPEED_FASTEST              = 0x08, // Fastest speed
+};
+
+class EKController
+{
+public:
+    EKController(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path);
+    ~EKController();
+
+    char* GetDeviceName();
+    char* GetSerial();
+    std::string GetLocation();
+
+    void SetMode(unsigned char mode, unsigned char speed);
+    void SetColor(unsigned char red, unsigned char green, unsigned char blue);
+
+private:
+    char                    device_name[32];
+    char                    serial[32];
+    std::string             location;
+    hid_device*             dev;
+
+    unsigned char           current_mode;
+    unsigned char           current_speed;
+
+    unsigned char           current_red;
+    unsigned char           current_green;
+    unsigned char           current_blue;
+
+    void SendUpdate();
+};
+
+#endif // EKCONTROLLER_H

Controllers/EKController/EKControllerDetect.cpp

@@ -0,0 +1,64 @@
+#include "EKController.h"
+#include "RGBController.h"
+#include "RGBController_EKController.h"
+#include <hidapi/hidapi.h>
+
+#define EK_VID                0x0483
+
+#define EK_LOOP_CONNECT       0x5750
+
+#define EK_NUM_DEVICES (sizeof(ek_pids) / sizeof(ek_pids[ 0 ]))
+
+enum
+{
+    EK_PID = 0,
+    EK_INTERFACE = 1
+};
+
+static const unsigned int ek_pids[][2] =
+{  // PID,      Interface
+    { EK_LOOP_CONNECT,        0x00 }     //EK Loop Connect
+};
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectEKControllers                                                                    *
+*                                                                                          *
+*       Tests the USB address to see if any EK Controllers exists there.                   *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectEKControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device_info* info;
+
+    //Look for the passed in cm_pids
+    hid_init();
+    info = hid_enumerate(0x0, 0x0);
+
+    while(info)
+    {
+        hid_device* dev = NULL;
+        if(info->vendor_id == EK_VID)
+        {
+            for(int ek_pid_idx = 0; ek_pid_idx < EK_NUM_DEVICES; ek_pid_idx++)
+            {
+                if((info->product_id        == ek_pids[ek_pid_idx][EK_PID])
+                 &&(info->interface_number  == ek_pids[ek_pid_idx][EK_INTERFACE]))
+                {
+                    dev = hid_open_path(info->path);
+                    break;
+                }
+            }
+        }
+
+        if(dev)
+        {
+            EKController* controller = new EKController(dev, info->manufacturer_string, info->product_string, info->path);
+            RGBController_EKController* rgb_controller = new RGBController_EKController(controller);
+            rgb_controllers.push_back(rgb_controller);
+        }
+        info = info->next;
+    }
+    hid_free_enumeration(info);
+}

Controllers/GalaxGPUController/GalaxGPUController.cpp

@@ -0,0 +1,106 @@
+/*-----------------------------------------*\
+|  GalaxGPUController.cpp                   |
+|                                           |
+|  Driver for Galax / KFA2 RGB on GPUs      |
+|                                           |
+|  Niels Westphal (crashniels)  12.07.2020  |
+\*-----------------------------------------*/
+
+#include "GalaxGPUController.h"
+#include <cstring>
+
+GalaxGPUController::GalaxGPUController(i2c_smbus_interface* bus, galax_gpu_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+
+    strcpy(device_name, "Galax RTX GPU");                                               // Would be nice to get the actual GPU name. Using this as a placeholder.
+}
+
+GalaxGPUController::~GalaxGPUController()
+{
+
+}
+
+std::string GalaxGPUController::GetDeviceName()
+{
+    return(device_name);
+}
+
+std::string GalaxGPUController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return(return_string);
+}
+
+unsigned char GalaxGPUController::GetLEDRed()
+{
+    return(GalaxGPURegisterRead(GALAX_RED_REGISTER));
+}
+
+unsigned char GalaxGPUController::GetLEDGreen()
+{
+    return(GalaxGPURegisterRead(GALAX_GREEN_REGISTER));
+}
+
+unsigned char GalaxGPUController::GetLEDBlue()
+{
+    return(GalaxGPURegisterRead(GALAX_BLUE_REGISTER));
+}
+
+void GalaxGPUController::SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue)                  // Direct Mode is just Static Mode without applying color changes
+{
+    GalaxGPURegisterWrite(GALAX_RED_REGISTER, red);
+    GalaxGPURegisterWrite(GALAX_GREEN_REGISTER, green);
+    GalaxGPURegisterWrite(GALAX_BLUE_REGISTER, blue);
+}
+
+void GalaxGPUController::SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
+{
+    GalaxGPURegisterWrite(GALAX_RED_REGISTER, red);
+    GalaxGPURegisterWrite(GALAX_GREEN_REGISTER, green);
+    GalaxGPURegisterWrite(GALAX_BLUE_REGISTER, blue);
+}
+
+void GalaxGPUController::SetMode(unsigned char mode)
+{
+    switch(mode)
+    {
+    case 1:
+        GalaxGPURegisterWrite(GALAX_MODE_REGISTER_1, GALAX_MODE_STATIC_VALUE_1);
+        GalaxGPURegisterWrite(GALAX_MODE_REGISTER_2, GALAX_MODE_STATIC_VALUE_2);
+        break;
+
+    case 2:
+        GalaxGPURegisterWrite(GALAX_MODE_REGISTER_1, GALAX_MODE_BREATHING_VALUE_1);
+        GalaxGPURegisterWrite(GALAX_MODE_REGISTER_2, GALAX_MODE_BREATHING_VALUE_2);
+        break;
+
+    case 3:
+        GalaxGPURegisterWrite(GALAX_MODE_REGISTER_1, GALAX_MODE_RAINBOW_VALUE_1);
+        GalaxGPURegisterWrite(GALAX_MODE_REGISTER_2, GALAX_MODE_RAINBOW_VALUE_2);
+        break;
+
+    case 4:
+        GalaxGPURegisterWrite(GALAX_MODE_REGISTER_1, GALAX_MODE_CYCLE_BREATHING_VALUE_1);
+        GalaxGPURegisterWrite(GALAX_MODE_REGISTER_2, GALAX_MODE_CYCLE_BREATHING_VALUE_2);
+        break;
+
+    default:
+        break;
+    }
+}
+
+unsigned char GalaxGPUController::GalaxGPURegisterRead(unsigned char reg)
+{
+    return(bus->i2c_smbus_read_byte_data(dev, reg));
+}
+
+void GalaxGPUController::GalaxGPURegisterWrite(unsigned char reg, unsigned char val)
+{
+    bus->i2c_smbus_write_byte_data(dev, reg, val);
+}

Controllers/GalaxGPUController/GalaxGPUController.h

@@ -0,0 +1,67 @@
+/*-----------------------------------------*\
+|  GalaxGPUController.h                     |
+|                                           |
+|  Driver for Galax / KFA2 RGB on GPUs      |
+|                                           |
+|  Niels Westphal (crashniels)  12.07.2020  |
+\*-----------------------------------------*/
+
+#include <string>
+#include "i2c_smbus.h"
+
+#pragma once
+
+typedef unsigned char galax_gpu_dev_id;
+
+enum
+{
+    /* RGB Registers */
+    GALAX_RED_REGISTER                      = 0x02, /* Red Register */
+    GALAX_GREEN_REGISTER                    = 0x03, /* Green Register */
+    GALAX_BLUE_REGISTER                     = 0x04, /* Blue Register */
+    /* MODE Registers */
+    GALAX_MODE_REGISTER_1                   = 0x05, /* Mode Register 1 */
+    GALAX_MODE_REGISTER_2                   = 0x06, /* Mode Register 2 */
+};
+
+enum
+{
+    /* Static Mode Values */
+    GALAX_MODE_STATIC_VALUE_1               = 0x00,
+    GALAX_MODE_STATIC_VALUE_2               = 0x01,
+    /* Breathing Mode Values */
+    GALAX_MODE_BREATHING_VALUE_1            = 0x04,
+    GALAX_MODE_BREATHING_VALUE_2            = 0x00,
+    /* Rainbow Mode Values */
+    GALAX_MODE_RAINBOW_VALUE_1              = 0x84,
+    GALAX_MODE_RAINBOW_VALUE_2              = 0x02,
+    /* Cycle Breathing Mode Values */
+    GALAX_MODE_CYCLE_BREATHING_VALUE_1      = 0x84,
+    GALAX_MODE_CYCLE_BREATHING_VALUE_2      = 0x40,
+};
+
+class GalaxGPUController
+{
+public:
+    GalaxGPUController(i2c_smbus_interface* bus, galax_gpu_dev_id);
+    ~GalaxGPUController();
+
+    std::string   GetDeviceName();
+    std::string   GetDeviceLocation();
+    unsigned char GetLEDRed();
+    unsigned char GetLEDGreen();
+    unsigned char GetLEDBlue();
+    void          SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue);
+    void          SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue);
+    void          SetMode(unsigned char mode);
+
+    unsigned char GalaxGPURegisterRead(unsigned char reg);
+    void          GalaxGPURegisterWrite(unsigned char reg, unsigned char val);
+
+    bool          direct = false;                                                // Temporary solution to check if we are in "Direct" mode
+
+private:
+    char                    device_name[16];
+    i2c_smbus_interface *   bus;
+    galax_gpu_dev_id        dev;
+};

Controllers/GalaxGPUController/GalaxGPUControllerDetect.cpp

@@ -0,0 +1,68 @@
+/*-----------------------------------------*\
+|  GalaxGPUControllerDetect.cpp             |
+|                                           |
+|  Driver for Galax / KFA2 RGB on GPUs      |
+|                                           |
+|  Niels Westphal (crashniels)  12.07.2020  |
+\*-----------------------------------------*/
+
+#include "GalaxGPUController.h"
+#include "RGBController.h"
+#include "RGBController_GalaxGPU.h"
+#include "i2c_smbus.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace std::chrono_literals;
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   TestForGalaxGPUController                                                              *
+*                                                                                          *
+*       Tests the given address to see if a Galax GPU controller exists there.             *
+*                                                                                          *
+\******************************************************************************************/
+
+bool TestForGalaxGPUController(i2c_smbus_interface* bus, unsigned char address)
+{
+    bool pass = false;
+
+    unsigned char res  = bus->i2c_smbus_read_byte_data(address, 0x00);
+    unsigned char res2 = bus->i2c_smbus_read_byte_data(address, 0x01);
+    if(res == 0x27 && res2 == 0x10)
+    {
+        pass = true;
+    }
+
+    return(pass);
+
+}   /* TestForGalaxGPUController() */
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectGalaxGPUControllers                                                              *
+*                                                                                          *
+*       Detect Galax GPU controllers on the enumerated I2C busses.                         *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectGalaxGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+{
+    GalaxGPUController* new_GalaxGPU;
+    RGBController_GalaxGPU* new_controller;
+
+    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        // Check for GALAX controller at 0x23
+        if (TestForGalaxGPUController(busses[bus], 0x23))
+        {
+            new_GalaxGPU = new GalaxGPUController(busses[bus], 0x23);
+            new_controller = new RGBController_GalaxGPU(new_GalaxGPU);
+            rgb_controllers.push_back(new_controller);
+        }
+    }
+
+} /* DetectGalaxGPUControllers() */

Controllers/GloriousModelOController/GloriousModelOControllerDetect.cpp

@@ -29,9 +29,14 @@ void DetectGloriousModelOControllers(std::vector<RGBController*>& rgb_controller
     //Look for Glorious Model O
     while(info)
     {
-        if((info->vendor_id == Glorious_Model_O_VID)
-        &&(info->product_id == Glorious_Model_O_PID)
+        if((info->vendor_id       == Glorious_Model_O_VID)
+        &&(info->product_id       == Glorious_Model_O_PID)
+#ifdef USE_HID_USAGE
+        &&(info->interface_number == 1)
+        &&(info->usage_page       == 0xFF00))
+#else
         &&(info->interface_number == 1))
+#endif
         {
             dev = hid_open_path(info->path);
             break;

Controllers/HyperXKeyboardController/HyperXAlloyOriginsController.cpp

@@ -0,0 +1,131 @@
+/*-----------------------------------------*\
+|  HyperXAlloyOriginsController.cpp         |
+|                                           |
+|  Driver for HyperX Alloy Origins RGB      |
+|  Keyboard lighting controller             |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 7/11/2020   |
+\*-----------------------------------------*/
+
+#include "HyperXAlloyOriginsController.h"
+
+#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 };
+
+HyperXAlloyOriginsController::HyperXAlloyOriginsController(hid_device* dev_handle)
+{
+    dev = dev_handle;
+}
+
+HyperXAlloyOriginsController::~HyperXAlloyOriginsController()
+{
+
+}
+
+void HyperXAlloyOriginsController::SetLEDsDirect(std::vector<RGBColor> colors)
+{
+    /*-----------------------------------------------------*\
+    | Insert color data for unused positions                |
+    \*-----------------------------------------------------*/
+    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);
+    }
+
+    /*-----------------------------------------------------*\
+    | Set up variables to track progress of color transmit  |
+    | Do this after inserting blanks                        |
+    \*-----------------------------------------------------*/
+    int colors_to_send = colors.size();
+    int colors_sent    = 0;
+
+    SendDirectInitialization();
+
+    for(int pkt_idx = 0; pkt_idx < 9; pkt_idx++)
+    {
+        if(colors_to_send > 16)
+        {
+            SendDirectColorPacket(&colors[colors_sent], 16);
+            colors_sent    += 16;
+            colors_to_send -= 16;
+        }
+        else if(colors_to_send > 0)
+        {
+            SendDirectColorPacket(&colors[colors_sent], colors_to_send);
+            colors_sent    += colors_to_send;
+            colors_to_send -= colors_to_send;
+        }
+        else
+        {
+            RGBColor temp = 0x00000000;
+            SendDirectColorPacket(&temp, 1);
+        }
+    }
+}
+
+void HyperXAlloyOriginsController::SendDirectInitialization()
+{
+    unsigned char buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Direct Initialization packet                   |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x00;
+    buf[0x01]   = 0x04;
+    buf[0x02]   = 0xF2;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, buf, 65);
+}
+
+void HyperXAlloyOriginsController::SendDirectColorPacket
+    (
+    RGBColor*       color_data,
+    unsigned int    color_count
+    )
+{
+    unsigned char buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Direct Initialization packet                   |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x00;
+
+    /*-----------------------------------------------------*\
+    | The maximum number of colors per packet is 16         |
+    \*-----------------------------------------------------*/
+    if(color_count > 16)
+    {
+        color_count = 16;
+    }
+
+    /*-----------------------------------------------------*\
+    | Copy in color data                                    |
+    \*-----------------------------------------------------*/
+    for(int color_idx = 0; color_idx < color_count; color_idx++)
+    {
+        buf[(color_idx * 4) + 1] = 0x81;
+        buf[(color_idx * 4) + 2] = RGBGetRValue(color_data[color_idx]);
+        buf[(color_idx * 4) + 3] = RGBGetGValue(color_data[color_idx]);
+        buf[(color_idx * 4) + 4] = RGBGetBValue(color_data[color_idx]);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, buf, 65);
+}

Controllers/HyperXKeyboardController/HyperXAlloyOriginsController.h

@@ -0,0 +1,34 @@
+/*-----------------------------------------*\
+|  HyperXAlloyOriginsController.h           |
+|                                           |
+|  Definitions and types for HyperX Alloy   |
+|  Origins RGB Keyboard lighting controller |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 7/11/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+class HyperXAlloyOriginsController
+{
+public:
+    HyperXAlloyOriginsController(hid_device* dev_handle);
+    ~HyperXAlloyOriginsController();
+
+    void SetLEDsDirect(std::vector<RGBColor> colors);
+
+private:
+    hid_device*             dev;
+
+    void    SendDirectInitialization();
+    void    SendDirectColorPacket
+                (
+                RGBColor*       color_data,
+                unsigned int    color_count
+                );
+};

Controllers/HyperXKeyboardController/HyperXKeyboardController.cpp

@@ -431,6 +431,7 @@ void HyperXKeyboardController::SendDirect
     buf[0x00]   = 0x07;
     buf[0x01]   = HYPERX_PACKET_ID_DIRECT;
     buf[0x02]   = color_channel;
+    buf[0x03]   = 0xA0;
 
     /*-----------------------------------------------------*\
     | Fill in color data                                    |
@@ -464,6 +465,7 @@ void HyperXKeyboardController::SendDirectExtended
     buf[0x00]   = 0x07;
     buf[0x01]   = HYPERX_PACKET_ID_DIRECT;
     buf[0x02]   = HYPERX_COLOR_CHANNEL_EXTENDED;
+    buf[0x03]   = 0xA0;
 
     /*-----------------------------------------------------*\
     | Fill in color data                                    |

Controllers/HyperXKeyboardController/HyperXKeyboardControllerDetect.cpp

@@ -1,5 +1,7 @@
+#include "HyperXAlloyOriginsController.h"
 #include "HyperXKeyboardController.h"
 #include "RGBController.h"
+#include "RGBController_HyperXAlloyOrigins.h"
 #include "RGBController_HyperXKeyboard.h"
 #include <vector>
 #include <hidapi/hidapi.h>
@@ -9,6 +11,8 @@
 \*-----------------------------------------------------*/
 #define HYPERX_KEYBOARD_VID         0x0951
 #define HYPERX_ALLOY_ELITE_PID      0x16BE
+#define HYPERX_ALLOY_FPS_RGB_PID    0x16DC
+#define HYPERX_ALLOY_ORIGINS_PID    0x16E5
 
 typedef struct
 {
@@ -26,6 +30,8 @@ static const hyperx_device device_list[] =
     | Keyboards                                                                                             |
     \*-----------------------------------------------------------------------------------------------------*/
     { HYPERX_KEYBOARD_VID,  HYPERX_ALLOY_ELITE_PID,     2,      "HyperX Alloy Elite RGB"                    },
+    { HYPERX_KEYBOARD_VID,  HYPERX_ALLOY_FPS_RGB_PID,   2,      "HyperX Alloy FPS RGB"                      },
+    { HYPERX_KEYBOARD_VID,  HYPERX_ALLOY_ORIGINS_PID,   3,      "HyperX Alloy Origins"                      },
 };
 
 /******************************************************************************************\
@@ -52,28 +58,50 @@ void DetectHyperXKeyboardControllers(std::vector<RGBController*>& rgb_controller
         //Look for HyperX RGB Peripheral
         while(info)
         {
-            if((info->vendor_id == device_list[device_idx].usb_vid)
+            if((device_list[device_idx].usb_pid != HYPERX_ALLOY_ORIGINS_PID)
+            &&(info->vendor_id == device_list[device_idx].usb_vid)
+            &&(info->product_id == device_list[device_idx].usb_pid)
+#ifdef USE_HID_USAGE
+            &&(info->interface_number == device_list[device_idx].usb_interface)
+            &&(info->usage_page == 0xFF01))
+#else
+            &&(info->interface_number == device_list[device_idx].usb_interface))
+#endif
+            {
+                dev = hid_open_path(info->path);
+
+                if( dev )
+                {
+                    HyperXKeyboardController* controller = new HyperXKeyboardController(dev);
+
+                    RGBController_HyperXKeyboard* rgb_controller = new RGBController_HyperXKeyboard(controller);
+
+                    rgb_controller->name = device_list[device_idx].name;
+
+                    rgb_controllers.push_back(rgb_controller);
+                }
+            }
+
+            if((device_list[device_idx].usb_pid == HYPERX_ALLOY_ORIGINS_PID)
+            &&(info->vendor_id == device_list[device_idx].usb_vid)
             &&(info->product_id == device_list[device_idx].usb_pid)
             &&(info->interface_number == device_list[device_idx].usb_interface))
             {
                 dev = hid_open_path(info->path);
-                break;
+
+                if( dev )
+                {
+                    HyperXAlloyOriginsController* controller = new HyperXAlloyOriginsController(dev);
+
+                    RGBController_HyperXAlloyOrigins* rgb_controller = new RGBController_HyperXAlloyOrigins(controller);
+
+                    rgb_controller->name = device_list[device_idx].name;
+                    
+                    rgb_controllers.push_back(rgb_controller);
+                }
             }
-            else
-            {
-                info = info->next;
-            }
-        }
 
-        if( dev )
-        {
-            HyperXKeyboardController* controller = new HyperXKeyboardController(dev);
-
-            RGBController_HyperXKeyboard* rgb_controller = new RGBController_HyperXKeyboard(controller);
-
-            rgb_controller->name = device_list[device_idx].name;
-            
-            rgb_controllers.push_back(rgb_controller);
+            info = info->next;
         }
     }
 }

Controllers/HyperXMouseController/HyperXMouseControllerDetect.cpp

@@ -0,0 +1,76 @@
+#include "HyperXPulsefireSurgeController.h"
+#include "RGBController.h"
+#include "RGBController_HyperXPulsefireSurge.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+/*-----------------------------------------------------*\
+| HyperX keyboard vendor IDs                            |
+\*-----------------------------------------------------*/
+#define HYPERX_VID                  0x0951
+#define HYPERX_PULSEFIRE_SURGE_PID  0x16D3
+
+typedef struct
+{
+    unsigned short  usb_vid;
+    unsigned short  usb_pid;
+    unsigned char   usb_interface;
+    const char *    name;
+} hyperx_device;
+
+#define HYPERX_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+static const hyperx_device device_list[] =
+{
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Mice                                                                                                  |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { HYPERX_VID,           HYPERX_PULSEFIRE_SURGE_PID, 1,      "HyperX Pulsefire Surge"                    },
+};
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectHyperXMouseControllers                                                           *
+*                                                                                          *
+*       Tests the USB address to see if a HyperX Mouse controller exists there.            *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectHyperXMouseControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device_info* info;
+    hid_device* dev = NULL;
+
+    hid_init();
+
+    for(std::size_t device_idx = 0; device_idx < HYPERX_NUM_DEVICES; device_idx++)
+    {
+        dev = NULL;
+
+        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+
+        //Look for HyperX RGB Peripheral
+        while(info)
+        {
+            if((info->vendor_id        == device_list[device_idx].usb_vid)
+             &&(info->product_id       == device_list[device_idx].usb_pid)
+             &&(info->interface_number == device_list[device_idx].usb_interface))
+            {
+                dev = hid_open_path(info->path);
+
+                if( dev )
+                {
+                    HyperXPulsefireSurgeController* controller = new HyperXPulsefireSurgeController(dev);
+
+                    RGBController_HyperXPulsefireSurge* rgb_controller = new RGBController_HyperXPulsefireSurge(controller);
+
+                    rgb_controller->name = device_list[device_idx].name;
+                    
+                    rgb_controllers.push_back(rgb_controller);
+                }
+            }
+
+            info = info->next;
+        }
+    }
+}

Controllers/HyperXMouseController/HyperXPulsefireSurgeController.cpp

@@ -0,0 +1,22 @@
+/*-----------------------------------------*\
+|  HyperXPulsefireSurgeController.cpp       |
+|                                           |
+|  Driver for HyperX Pulsefire Surge        |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 7/25/2020   |
+\*-----------------------------------------*/
+
+#include "HyperXPulsefireSurgeController.h"
+
+#include <cstring>
+
+HyperXPulsefireSurgeController::HyperXPulsefireSurgeController(hid_device* dev_handle)
+{
+    dev = dev_handle;
+}
+
+HyperXPulsefireSurgeController::~HyperXPulsefireSurgeController()
+{
+
+}

Controllers/HyperXMouseController/HyperXPulsefireSurgeController.h

@@ -0,0 +1,25 @@
+/*-----------------------------------------*\
+|  HyperXPulsefireSurgeController.h         |
+|                                           |
+|  Definitions and types for HyperX         |
+|  Pulsefire Surge lighting controller      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 7/25/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+class HyperXPulsefireSurgeController
+{
+public:
+    HyperXPulsefireSurgeController(hid_device* dev_handle);
+    ~HyperXPulsefireSurgeController();
+
+private:
+    hid_device*             dev;
+};

Controllers/LogitechController/LogitechControllerDetect.cpp

@@ -65,78 +65,132 @@ static const logitech_device device_list[] =
 
 void DetectLogitechControllers(std::vector<RGBController*>& rgb_controllers)
 {
-    hid_device_info* info;
-    hid_device* dev;
-
     hid_init();
 
     for(int device_idx = 0; device_idx < LOGITECH_NUM_DEVICES; device_idx++)
     {
-        dev = NULL;
-
-        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
-
-        //Look for Logitech RGB Peripheral
-        while(info)
+        switch(device_list[device_idx].type)
         {
-            if((info->vendor_id == device_list[device_idx].usb_vid)
-            &&(info->product_id == device_list[device_idx].usb_pid)
-            &&(info->interface_number == device_list[device_idx].usb_interface))
+        /*-------------------------------------------------------------------------------------------------*\
+        | Logitech keyboards use two different usages, one for 20-byte packets and one for 64-byte packets  |
+        | Usage 0x0602 for 20 byte, usage 0x0604 for 64 byte, both are on usage page 0xFF43                 |
+        \*-------------------------------------------------------------------------------------------------*/
+        case DEVICE_TYPE_KEYBOARD:
             {
-                dev = hid_open_path(info->path);
-                break;
-            }
-            else
-            {
-                info = info->next;
-            }
-        }
+                hid_device_info* info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
 
-        if( dev )
-        {
-            switch(device_list[device_idx].type)
-            {
-                case DEVICE_TYPE_KEYBOARD:
+                while(info)
+                {
+                    if((info->vendor_id == device_list[device_idx].usb_vid)
+                    &&(info->product_id == device_list[device_idx].usb_pid)
+#ifdef USE_HID_USAGE
+                    &&(info->interface_number == device_list[device_idx].usb_interface)
+                    &&(info->usage_page == 0xFF43)
+                    &&(info->usage == 0x0602))
+#else
+                    &&(info->interface_number == device_list[device_idx].usb_interface))
+#endif
                     {
-                        LogitechG810Controller* controller = new LogitechG810Controller(dev);
+                        hid_device* dev_usage_0x0602 = hid_open_path(info->path);
 
-                        RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);
-
-                        rgb_controller->name = device_list[device_idx].name;
-                        rgb_controllers.push_back(rgb_controller);
-                    }
-                    break;
-
-                case DEVICE_TYPE_MOUSE:
-                    {
-                    switch(device_list[device_idx].usb_pid)
-                    {
-                        case LOGITECH_G203_PID:
+                        if(dev_usage_0x0602)
                         {
-                            LogitechG203Controller* controller = new LogitechG203Controller(dev);
+#ifdef USE_HID_USAGE
+                            hid_device_info* tmp_info_0x0604 = info;
 
-                            RGBController_LogitechG203* rgb_controller = new RGBController_LogitechG203(controller);
-
-                            rgb_controller->name = device_list[device_idx].name;
-                            rgb_controllers.push_back(rgb_controller);
-                        }
-                        break;
-                        case LOGITECH_G403_PID:
-                        case LOGITECH_G403H_PID:
-                        {
-                            LogitechG403Controller* controller = new LogitechG403Controller(dev);
-
-                            RGBController_LogitechG403* rgb_controller = new RGBController_LogitechG403(controller);
+                            while(tmp_info_0x0604)
+                            {
+                                if((tmp_info_0x0604->vendor_id == device_list[device_idx].usb_vid)
+                                &&(tmp_info_0x0604->product_id == device_list[device_idx].usb_pid)
+                                &&(tmp_info_0x0604->interface_number == device_list[device_idx].usb_interface)
+                                &&(tmp_info_0x0604->usage_page == 0xFF43)
+                                &&(tmp_info_0x0604->usage == 0x0604))
+                                {
+                                    hid_device* dev_usage_0x0604 = hid_open_path(tmp_info_0x0604->path);
+
+                                    if(dev_usage_0x0604)
+                                    {
+                                        LogitechG810Controller* controller = new LogitechG810Controller(dev_usage_0x0602, dev_usage_0x0604);
+
+                                        RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);
+
+                                        rgb_controller->name = device_list[device_idx].name;
+                                        rgb_controllers.push_back(rgb_controller);
+                                    }
+                                }
+                                tmp_info_0x0604 = tmp_info_0x0604->next;
+                            }
+#else
+                            LogitechG810Controller* controller = new LogitechG810Controller(dev_usage_0x0602, dev_usage_0x0602);
+
+                            RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);
 
                             rgb_controller->name = device_list[device_idx].name;
                             rgb_controllers.push_back(rgb_controller);
+#endif
                         }
                     }
-
-                    }
-                    break;
+                    info = info->next;
+                }
+                hid_free_enumeration(info);
             }
+            break;
+
+        /*-------------------------------------------------------------------------------------------------*\
+        | Logitech mice use a single usage on page 0xFF00                                                   |
+        \*-------------------------------------------------------------------------------------------------*/
+        case DEVICE_TYPE_MOUSE:
+            {
+                hid_device_info* info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+
+                while(info)
+                {
+                    if((info->vendor_id == device_list[device_idx].usb_vid)
+                    &&(info->product_id == device_list[device_idx].usb_pid)
+#ifdef USE_HID_USAGE                    
+                    &&(info->interface_number == device_list[device_idx].usb_interface)
+                    &&(info->usage_page == 0xFF00)
+                    &&(info->usage == 2))
+#else
+                    &&(info->interface_number == device_list[device_idx].usb_interface))
+#endif
+                    {
+                        hid_device* dev = hid_open_path(info->path);
+
+                        if(dev)
+                        {
+                            switch(device_list[device_idx].usb_pid)
+                            {
+                            case LOGITECH_G203_PID:
+                                {
+                                    LogitechG203Controller* controller = new LogitechG203Controller(dev);
+
+                                    RGBController_LogitechG203* rgb_controller = new RGBController_LogitechG203(controller);
+
+                                    rgb_controller->name = device_list[device_idx].name;
+                                    rgb_controllers.push_back(rgb_controller);
+                                }
+                                break;
+
+                            case LOGITECH_G403_PID:
+                            case LOGITECH_G403H_PID:
+                                {
+                                    LogitechG403Controller* controller = new LogitechG403Controller(dev);
+
+                                    RGBController_LogitechG403* rgb_controller = new RGBController_LogitechG403(controller);
+
+                                    rgb_controller->name = device_list[device_idx].name;
+                                    rgb_controllers.push_back(rgb_controller);
+                                }
+                            }
+                        }
+                    }
+                    info = info->next;
+                }
+                hid_free_enumeration(info);
+            }
+            break;
         }
-        hid_free_enumeration(info);
+
     }
 }

Controllers/LogitechController/LogitechG810Controller.cpp

@@ -10,9 +10,10 @@
 #include "LogitechG810Controller.h"
 #include <cstring>
 
-LogitechG810Controller::LogitechG810Controller(hid_device* dev_handle)
+LogitechG810Controller::LogitechG810Controller(hid_device* dev_handle_0x11, hid_device* dev_handle_0x12)
 {
-    dev = dev_handle;
+    dev_pkt_0x11 = dev_handle_0x11;
+    dev_pkt_0x12 = dev_handle_0x12;
 }
 
 LogitechG810Controller::~LogitechG810Controller()
@@ -74,8 +75,8 @@ void LogitechG810Controller::SendCommit()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 20);
-    hid_read(dev, (unsigned char *)usb_buf, 20);
+    hid_write(dev_pkt_0x11, (unsigned char *)usb_buf, 20);
+    hid_read(dev_pkt_0x11, (unsigned char *)usb_buf, 20);
 }
 
 void LogitechG810Controller::SendDirectFrame
@@ -110,8 +111,8 @@ void LogitechG810Controller::SendDirectFrame
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 64);
-    hid_read(dev, (unsigned char *)usb_buf, 20);
+    hid_write(dev_pkt_0x12, (unsigned char *)usb_buf, 64);
+    hid_read(dev_pkt_0x11, (unsigned char *)usb_buf, 20);
 }
 
 void LogitechG810Controller::SendMode
@@ -163,6 +164,6 @@ void LogitechG810Controller::SendMode
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 20);
-    hid_read(dev, (unsigned char *)usb_buf, 20);
+    hid_write(dev_pkt_0x11, (unsigned char *)usb_buf, 20);
+    hid_read(dev_pkt_0x11, (unsigned char *)usb_buf, 20);
 }

Controllers/LogitechController/LogitechG810Controller.h

@@ -49,7 +49,7 @@ enum
 class LogitechG810Controller
 {
 public:
-    LogitechG810Controller(hid_device* dev_handle);
+    LogitechG810Controller(hid_device* dev_handle_0x11, hid_device* dev_handle_0x12);
     ~LogitechG810Controller();
 
     void        Commit();
@@ -71,7 +71,8 @@ public:
                     );
 
 private:
-    hid_device* dev;
+    hid_device* dev_pkt_0x11;
+    hid_device* dev_pkt_0x12;
 
     void        SendDirectFrame
                     (

Controllers/MSIGPUController/MSIGPUController.cpp

@@ -0,0 +1,67 @@
+/*-----------------------------------------*\
+|  MSIGPUController.cpp                    |
+|                                          |
+|  Driver for MSI GPUs                     |
+|                                          |
+\*-----------------------------------------*/
+
+#include "MSIGPUController.h"
+#include <cstring>
+
+MSIGPUController::MSIGPUController(i2c_smbus_interface* bus)
+{
+    this->bus = bus;
+    this->dev = 0x68;
+}
+
+MSIGPUController::~MSIGPUController()
+{
+
+}
+
+std::string MSIGPUController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return(return_string);
+}
+
+void MSIGPUController::SetRGB1(unsigned char red, unsigned char green, unsigned char blue)
+{
+    MSIGPURegisterWrite(MSI_GPU_REG_R1, red);
+    MSIGPURegisterWrite(MSI_GPU_REG_G1, green);
+    MSIGPURegisterWrite(MSI_GPU_REG_B1, blue);
+}
+
+void MSIGPUController::SetRGB2(unsigned char red, unsigned char green, unsigned char blue)
+{
+    MSIGPURegisterWrite(MSI_GPU_REG_R2, red);
+    MSIGPURegisterWrite(MSI_GPU_REG_G2, green);
+    MSIGPURegisterWrite(MSI_GPU_REG_B2, blue);
+}
+
+void MSIGPUController::SetRGB3(unsigned char red, unsigned char green, unsigned char blue)
+{
+    MSIGPURegisterWrite(MSI_GPU_REG_R3, red);
+    MSIGPURegisterWrite(MSI_GPU_REG_G3, green);
+    MSIGPURegisterWrite(MSI_GPU_REG_B3, blue);
+}
+
+void MSIGPUController::SetMode(unsigned char mode)
+{
+    MSIGPURegisterWrite(MSI_GPU_REG_MODE, mode);
+    MSIGPURegisterWrite(MSI_GPU_REG_APPLY, 0x01);
+}
+
+unsigned char MSIGPUController::MSIGPURegisterRead(unsigned char reg)
+{
+    return(bus->i2c_smbus_read_byte_data(dev, reg));
+}
+
+void MSIGPUController::MSIGPURegisterWrite(unsigned char reg, unsigned char val)
+{
+    bus->i2c_smbus_write_byte_data(dev, reg, val);
+}

Controllers/MSIGPUController/MSIGPUController.h

@@ -0,0 +1,77 @@
+/*-----------------------------------------*\
+|  MSIGPUController.h                       |
+|                                           |
+|  Definitions for MSI GPUs                 |
+|                                           |
+\*-----------------------------------------*/
+
+#include <string>
+#include "i2c_smbus.h"
+
+#pragma once
+
+typedef unsigned char msi_gpu_dev_id;
+
+enum
+{
+    MSI_GPU_REG_BRIGHTNESS                 = 0x36,    /* MSI GPU Brightness Register     */
+    MSI_GPU_REG_SPEED                      = 0x38,    /* MSI GPU Speed Register          */
+    MSI_GPU_REG_UNKNOWN                    = 0x26,    /* MSI GPU Unknown Register        */
+    MSI_GPU_REG_R1                         = 0x30,    /* MSI GPU R1 Register             */
+    MSI_GPU_REG_G1                         = 0x31,    /* MSI GPU G1 Register             */
+    MSI_GPU_REG_B1                         = 0x32,    /* MSI GPU B1 Register             */
+    MSI_GPU_REG_R2                         = 0x27,    /* MSI GPU R2 Register             */
+    MSI_GPU_REG_G2                         = 0x28,    /* MSI GPU G2 Register             */
+    MSI_GPU_REG_B2                         = 0x29,    /* MSI GPU B2 Register             */
+    MSI_GPU_REG_R3                         = 0x2a,    /* MSI GPU R3 Register             */
+    MSI_GPU_REG_G3                         = 0x2b,    /* MSI GPU G3 Register             */
+    MSI_GPU_REG_B3                         = 0x2c,    /* MSI GPU B3 Register             */
+    MSI_GPU_REG_MODE                       = 0x22,    /* MSI GPU Mode Selection Register */
+    MSI_GPU_REG_APPLY                      = 0x3f,    /* MSI GPU Apply Changes Register  */
+};
+
+enum
+{
+    MSI_GPU_MODE_OFF                       = 0x01,        /* OFF mode                                            */
+    MSI_GPU_MODE_RAINBOW                   = 0x08,        /* Rainbow effect mode                                 */
+    MSI_GPU_MODE_STATIC                    = 0x13,        /* Static color mode                                   */
+    MSI_GPU_MODE_RAINDROP                  = 0x1a,        /* Raindrop effect mode                                */
+    MSI_GPU_MODE_MAGIC                     = 0x07,        /* Magic effect mode                                   */
+    MSI_GPU_MODE_PATROLLING                = 0x05,        /* Patrolling effect mode                              */
+    MSI_GPU_MODE_STREAMING                 = 0x06,        /* Streaming effect mode                               */
+    MSI_GPU_MODE_LIGHTNING                 = 0x15,        /* Lightning effect mode                               */
+    MSI_GPU_MODE_WAVE                      = 0x1f,        /* Wave effect mode                                    */
+    MSI_GPU_MODE_METEOR                    = 0x16,        /* Meteor effect mode                                  */
+    MSI_GPU_MODE_STACK                     = 0x0d,       /* Stack effect mode                                   */
+    MSI_GPU_MODE_RHYTHM                    = 0x0b,       /* Rhythm effect mode                                  */
+    MSI_GPU_MODE_FLOWING                   = 0x09,       /* Flowing effect mode                                 */
+    MSI_GPU_MODE_WHIRLING                  = 0x0f,       /* Whirling effect mode                                */
+    MSI_GPU_MODE_TWISTING                  = 0x11,       /* Twisting effect mode                                */
+    MSI_GPU_MODE_LAMINATING                = 0x1d,       /* Laminating effect mode                              */
+    MSI_GPU_MODE_FADEIN                    = 0x14,       /* Fadein effect mode                                  */
+    MSI_GPU_MODE_BREATHING                 = 0x04,       /* Breathing effect mode                               */
+    MSI_GPU_MODE_FLASHING                  = 0x02,       /* Flashing effect mode                                */
+    MSI_GPU_MODE_DOUBLEFLASHING            = 0x03,       /* Doubleflashing effect mode                          */
+};
+
+class MSIGPUController
+{
+public:
+    MSIGPUController(i2c_smbus_interface* bus);
+    ~MSIGPUController();
+
+    std::string   GetDeviceLocation();
+
+    void          SetRGB1(unsigned char red, unsigned char green, unsigned char blue);
+    void          SetRGB2(unsigned char red, unsigned char green, unsigned char blue);
+    void          SetRGB3(unsigned char red, unsigned char green, unsigned char blue);
+
+    void          SetMode(unsigned char mode);
+
+    unsigned char MSIGPURegisterRead(unsigned char reg);
+    void          MSIGPURegisterWrite(unsigned char reg, unsigned char val);
+
+private:
+    i2c_smbus_interface *   bus;
+    msi_gpu_dev_id          dev;
+};

Controllers/MSIGPUController/MSIGPUControllerDetect.cpp

@@ -0,0 +1,113 @@
+/*-----------------------------------------*\
+|  MSIGPUControllerDetect.cpp               |
+|                                           |
+|  Driver for MSI GPUs                      |
+|                                           |
+\*-----------------------------------------*/
+
+#include "MSIGPUController.h"
+#include "RGBController.h"
+#include "RGBController_MSIGPU.h"
+#include "i2c_smbus.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+/*-----------------------------------------------------*\
+| NVidia vendor ID                                      |
+\*-----------------------------------------------------*/
+#define NVIDIA_VEN                              0x10DE
+
+/*-----------------------------------------------------*\
+| NVidia device IDs                                     |
+\*-----------------------------------------------------*/
+#define NVIDIA_RTX2060_DEV                      0x1F08
+#define NVIDIA_RTX2060S_DEV                     0x1F06
+#define NVIDIA_RTX2070_DEV                      0x1F02
+#define NVIDIA_RTX2070S_DEV                     0x1E84
+#define NVIDIA_RTX2080_DEV                      0x1E87
+#define NVIDIA_RTX2080S_DEV                     0x1E81
+#define NVIDIA_RTX2080TI_DEV                    0x1E07
+
+/*-----------------------------------------------------*\
+| MSI sub-vendor ID                                     |
+\*-----------------------------------------------------*/
+#define MSI_SUB_VEN                             0x1462
+
+/*-----------------------------------------------------*\
+| MSI sub-device IDs                                    |
+\*-----------------------------------------------------*/
+#define MSI_RTX2060S_GAMING_X_SUB_DEV           0xC752
+#define MSI_RTX2070S_GAMING_X_SUB_DEV           0x373e
+#define MSI_RTX2070S_GAMING_X_TRIO_SUB_DEV      0xC726
+#define MSI_RTX2080_GAMING_X_TRIO_SUB_DEV       0x3726
+#define MSI_RTX2080S_GAMING_X_TRIO_SUB_DEV      0xC724
+#define MSI_RTX2080TI_GAMING_X_TRIO_SUB_DEV     0x3715
+#define MSI_RTX2060_GAMING_Z_6G_SUB_DEV         0x3754
+#define MSI_RTX2070_ARMOR_SUB_DEV               0x3734
+#define MSI_RTX2060S_ARMOR_OC_SUB_DEV           0xC754
+#define MSI_RTX2080_SEA_HAWK_EK_X_SUB_DEV       0x3728
+#define MSI_RTX2080TI_SEA_HAWK_EK_X_SUB_DEV     0x3717
+
+typedef struct
+{
+    int             pci_vendor;
+    int             pci_device;
+    int             pci_subsystem_vendor;
+    int             pci_subsystem_device;
+    const char *    name;
+} msi_gpu_pci_device;
+
+#define MSI_GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+static const msi_gpu_pci_device device_list[] =
+{
+    { NVIDIA_VEN,   NVIDIA_RTX2060S_DEV,    MSI_SUB_VEN,    MSI_RTX2060S_GAMING_X_SUB_DEV,          "MSI GeForce RTX 2060 Super Gaming X"           },
+    { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,    MSI_SUB_VEN,    MSI_RTX2070S_GAMING_X_SUB_DEV,          "MSI GeForce RTX 2070 Super Gaming X"           },
+    { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,    MSI_SUB_VEN,    MSI_RTX2070S_GAMING_X_TRIO_SUB_DEV,     "MSI GeForce RTX 2070 Super Gaming X Trio"      },
+    { NVIDIA_VEN,   NVIDIA_RTX2080_DEV,     MSI_SUB_VEN,    MSI_RTX2080_GAMING_X_TRIO_SUB_DEV,      "MSI GeForce RTX 2080 Gaming X Trio"            },
+    { NVIDIA_VEN,   NVIDIA_RTX2080S_DEV,    MSI_SUB_VEN,    MSI_RTX2080S_GAMING_X_TRIO_SUB_DEV,     "MSI GeForce RTX 2080 Super Gaming X Trio"      },
+    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,   MSI_SUB_VEN,    MSI_RTX2080TI_GAMING_X_TRIO_SUB_DEV,    "MSI GeForce RTX 2080Ti Gaming X Trio"          },
+    { NVIDIA_VEN,   NVIDIA_RTX2060_DEV,     MSI_SUB_VEN,    MSI_RTX2060_GAMING_Z_6G_SUB_DEV,        "MSI GeForce RTX 2060 Gaming Z 6G"              },
+    { NVIDIA_VEN,   NVIDIA_RTX2060S_DEV,    MSI_SUB_VEN,    MSI_RTX2060S_ARMOR_OC_SUB_DEV,          "MSI GeForce RTX 2060 Super ARMOR OC"           },
+    { NVIDIA_VEN,   NVIDIA_RTX2070_DEV,     MSI_SUB_VEN,    MSI_RTX2070_ARMOR_SUB_DEV,              "MSI GeForce RTX 2070 ARMOR"                    },
+    { NVIDIA_VEN,   NVIDIA_RTX2080_DEV,     MSI_SUB_VEN,    MSI_RTX2080_SEA_HAWK_EK_X_SUB_DEV,      "MSI GeForce RTX 2080 Sea Hawk EK X"            },
+    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,   MSI_SUB_VEN,    MSI_RTX2080TI_SEA_HAWK_EK_X_SUB_DEV,    "MSI GeForce RTX 2080Ti Sea Hawk EK X"          },
+};
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectMSIGPUControllers                                                               *
+*                                                                                          *
+*       Detect MSI GPU controllers on the enumerated I2C busses.                          *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectMSIGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+{
+    MSIGPUController* new_msi_gpu;
+    RGBController_MSIGPU* new_controller;
+
+    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        for(unsigned int dev_idx = 0; dev_idx < MSI_GPU_NUM_DEVICES; dev_idx++)
+        {
+            if (busses[bus]->port_id != 1)
+            {
+                break;
+            }
+
+            if(busses[bus]->pci_vendor           == device_list[dev_idx].pci_vendor           &&
+               busses[bus]->pci_device           == device_list[dev_idx].pci_device           &&
+               busses[bus]->pci_subsystem_vendor == device_list[dev_idx].pci_subsystem_vendor &&
+               busses[bus]->pci_subsystem_device == device_list[dev_idx].pci_subsystem_device)
+            {
+                new_msi_gpu = new MSIGPUController(busses[bus]);
+                new_controller = new RGBController_MSIGPU(new_msi_gpu);
+                new_controller->name = device_list[dev_idx].name;
+                rgb_controllers.push_back(new_controller);
+            }
+        }
+    }
+} /* DetectMSIGPUControllers() */

Controllers/MSIMysticLightController/MSIMysticLightController.cpp

@@ -35,25 +35,34 @@ MSIMysticLightController::~MSIMysticLightController()
     }
 }
 
-unsigned int MSIMysticLightController::GetZoneMinLedCount(ZONE /*zone*/)
+unsigned int MSIMysticLightController::GetZoneMinLedCount
+    (
+    MSI_ZONE            /*zone*/
+    )
 {
-    return 1u;
+    return 1;
 }
 
-unsigned int MSIMysticLightController::GetZoneMaxLedCount(ZONE zone)
+unsigned int MSIMysticLightController::GetZoneMaxLedCount
+    (
+    MSI_ZONE            zone
+    )
 {
-    switch (zone)
+    switch(zone)
     {
-    case J_RAINBOW_1:
-    case J_RAINBOW_2:
-    case J_CORSAIR:
-        return 4u; // TODO: It can be different by zone and by mobo
+    case MSI_ZONE_J_RAINBOW_1:
+    case MSI_ZONE_J_RAINBOW_2:
+    case MSI_ZONE_J_CORSAIR:
+        return 4; // TODO: It can be different by zone and by mobo
     default:
-        return 1u;
+        return 1;
     }
 }
 
-unsigned int MSIMysticLightController::GetZoneLedCount(ZONE zone)
+unsigned int MSIMysticLightController::GetZoneLedCount
+    (
+    MSI_ZONE            zone
+    )
 {
     RainbowZoneData *requestedZone = GetRainbowZoneData(zone);
 
@@ -65,7 +74,11 @@ unsigned int MSIMysticLightController::GetZoneLedCount(ZONE zone)
     return requestedZone->cycle_or_led_num;
 }
 
-void MSIMysticLightController::SetZoneLedCount(ZONE zone, unsigned int led_count)
+void MSIMysticLightController::SetZoneLedCount
+    (
+    MSI_ZONE            zone,
+    unsigned int        led_count
+    )
 {
     RainbowZoneData *requestedZone = GetRainbowZoneData(zone);
 
@@ -78,7 +91,14 @@ void MSIMysticLightController::SetZoneLedCount(ZONE zone, unsigned int led_count
     requestedZone->cycle_or_led_num = led_count;
 }
 
-void MSIMysticLightController::SetMode(ZONE zone, EFFECT mode, SPEED speed, BRIGHTNESS brightness, bool rainbow_color)
+void MSIMysticLightController::SetMode
+    (
+    MSI_ZONE            zone,
+    MSI_MODE            mode,
+    MSI_SPEED           speed,
+    MSI_BRIGHTNESS      brightness,
+    bool                rainbow_color
+    )
 {
     ZoneData* zoneData = GetZoneData(zone);
     if(!zoneData)
@@ -113,12 +133,18 @@ std::string MSIMysticLightController::GetSerial()
 
 bool MSIMysticLightController::ReadSettings()
 {
-    return hid_get_feature_report(dev, reinterpret_cast<unsigned char *>(&data), sizeof data) == sizeof data;
+    /*-----------------------------------------------------*\
+    | Read packet from hardware, return true if successful  |
+    \*-----------------------------------------------------*/
+    return(hid_get_feature_report(dev, (unsigned char *)&data, sizeof(data)) == sizeof data);
 }
 
 bool MSIMysticLightController::Update()
 {
-    return hid_send_feature_report(dev, reinterpret_cast<unsigned char *>(&data), sizeof data) == sizeof data;
+    /*-----------------------------------------------------*\
+    | Send packet to hardware, return true if successful    |
+    \*-----------------------------------------------------*/
+    return(hid_send_feature_report(dev, (unsigned char *)&data, sizeof(data)) == sizeof data);
 }
 
 void MSIMysticLightController::SaveOnUpdate(bool save)
@@ -126,26 +152,40 @@ void MSIMysticLightController::SaveOnUpdate(bool save)
     data.save_data = save;
 }
 
-void MSIMysticLightController::SetZoneColor(ZONE zone, unsigned char r1, unsigned char g1, unsigned char b1, unsigned char r2, unsigned char g2, unsigned char b2)
+void MSIMysticLightController::SetZoneColor
+    (
+    MSI_ZONE            zone,
+    unsigned char       red1,
+    unsigned char       grn1,
+    unsigned char       blu1,
+    unsigned char       red2,
+    unsigned char       grn2,
+    unsigned char       blu2
+    )
 {
     ZoneData* zoneData = GetZoneData(zone);
+
     if(!zoneData)
     {
         return;
     }
 
-    zoneData->color.R = r1;
-    zoneData->color.G = g1;
-    zoneData->color.B = b1;
+    zoneData->color.R = red1;
+    zoneData->color.G = grn1;
+    zoneData->color.B = blu1;
 
-    zoneData->color2.R = r2;
-    zoneData->color2.G = g2;
-    zoneData->color2.B = b2;
+    zoneData->color2.R = red2;
+    zoneData->color2.G = grn2;
+    zoneData->color2.B = blu2;
 }
 
-std::pair<Color, Color> MSIMysticLightController::GetZoneColor(ZONE zone)
+std::pair<Color, Color> MSIMysticLightController::GetZoneColor
+    (
+    MSI_ZONE            zone
+    )
 {
     ZoneData *zoneData = GetZoneData(zone);
+
     if (!zoneData)
     {
         return std::make_pair(Color{}, Color{});
@@ -158,61 +198,67 @@ std::pair<Color, Color> MSIMysticLightController::GetZoneColor(ZONE zone)
                           Color{zoneData->color2.R, zoneData->color2.G, zoneData->color2.B});
 }
 
-ZoneData *MSIMysticLightController::GetZoneData(ZONE zone)
+ZoneData *MSIMysticLightController::GetZoneData
+    (
+    MSI_ZONE            zone
+    )
 {
-    switch (zone)
+    switch(zone)
     {
-    case J_RGB_1:
+    case MSI_ZONE_J_RGB_1:
         return &data.j_rgb_1;
-    case J_RGB_2:
+    case MSI_ZONE_J_RGB_2:
         return &data.j_rgb_2;
-    case J_RAINBOW_1:
+    case MSI_ZONE_J_RAINBOW_1:
         return &data.j_rainbow_1;
-    case J_RAINBOW_2:
+    case MSI_ZONE_J_RAINBOW_2:
         return &data.j_rainbow_2;
-    case J_PIPE_1:
+    case MSI_ZONE_J_PIPE_1:
         return &data.j_pipe_1;
-    case J_PIPE_2:
+    case MSI_ZONE_J_PIPE_2:
         return &data.j_pipe_2;
-    case ON_BOARD_LED:
+    case MSI_ZONE_ON_BOARD_LED:
         return &data.on_board_led;
-    case ON_BOARD_LED_1:
+    case MSI_ZONE_ON_BOARD_LED_1:
         return &data.on_board_led_1;
-    case ON_BOARD_LED_2:
+    case MSI_ZONE_ON_BOARD_LED_2:
         return &data.on_board_led_2;
-    case ON_BOARD_LED_3:
+    case MSI_ZONE_ON_BOARD_LED_3:
         return &data.on_board_led_3;
-    case ON_BOARD_LED_4:
+    case MSI_ZONE_ON_BOARD_LED_4:
         return &data.on_board_led_4;
-    case ON_BOARD_LED_5:
+    case MSI_ZONE_ON_BOARD_LED_5:
         return &data.on_board_led_5;
-    case ON_BOARD_LED_6:
+    case MSI_ZONE_ON_BOARD_LED_6:
         return &data.on_board_led_6;
-    case ON_BOARD_LED_7:
+    case MSI_ZONE_ON_BOARD_LED_7:
         return &data.on_board_led_7;
-    case ON_BOARD_LED_8:
+    case MSI_ZONE_ON_BOARD_LED_8:
         return &data.on_board_led_8;
-    case ON_BOARD_LED_9:
+    case MSI_ZONE_ON_BOARD_LED_9:
         return &data.on_board_led_9;
-    case J_CORSAIR_OUTERLL120:
+    case MSI_ZONE_J_CORSAIR_OUTERLL120:
         return &data.j_corsair_outerll120;
     default:
-    case J_CORSAIR:
+    case MSI_ZONE_J_CORSAIR:
         break;
     }
 
     return nullptr;
 }
 
-RainbowZoneData *MSIMysticLightController::GetRainbowZoneData(ZONE zone)
+RainbowZoneData *MSIMysticLightController::GetRainbowZoneData
+    (
+    MSI_ZONE            zone
+    )
 {
-    switch (zone)
+    switch(zone)
     {
-    case J_RAINBOW_1:
+    case MSI_ZONE_J_RAINBOW_1:
         return &data.j_rainbow_1;
-    case J_RAINBOW_2:
+    case MSI_ZONE_J_RAINBOW_2:
         return &data.j_rainbow_2;
-    case J_CORSAIR:
+    case MSI_ZONE_J_CORSAIR:
     default:
         return nullptr;
     }
@@ -220,39 +266,98 @@ RainbowZoneData *MSIMysticLightController::GetRainbowZoneData(ZONE zone)
 
 bool MSIMysticLightController::ReadFwVersion()
 {
-    // First read the APROM
-    // Checksum also available at report ID 180, with highCheksum stored at index 8, and low at 9
-    int num = 1;
-    unsigned char request[64] = {1, 176};
+    unsigned char request[64];
     unsigned char response[64];
+    int ret_val = 64;
 
-    std::fill_n(request + 2, sizeof request - 2, 204);
-    num &= hid_write(dev, request, 64);
-    num &= hid_read(dev, response, 64);
+    /*-----------------------------------------------------*\
+    | First read the APROM                                  |
+    | Checksum also available at report ID 180, with MSB    |
+    | stored at index 0x08 and LSB at 0x09                  |
+    \*-----------------------------------------------------*/
 
+    /*-----------------------------------------------------*\
+    | Zero out buffers                                      |
+    \*-----------------------------------------------------*/
+    memset(request, 0x00, sizeof(request));
+    memset(response, 0x00, sizeof(response));
+
+    /*-----------------------------------------------------*\
+    | Set up APROM Firmware Version Request packet          |
+    \*-----------------------------------------------------*/
+    request[0x00]   = 0x01;
+    request[0x01]   = 0xB0;
+
+    /*-----------------------------------------------------*\
+    | Fill request from 0x02 to 0x61 with 0xCC              |
+    \*-----------------------------------------------------*/
+    memset(&request[0x02], 0xCC, sizeof(request) - 2);
+
+    /*-----------------------------------------------------*\
+    | Send request and receive response packets             |
+    \*-----------------------------------------------------*/
+    ret_val &= hid_write(dev, request, 64);
+    ret_val &= hid_read(dev, response, 64);
+
+    /*-----------------------------------------------------*\
+    | Extract high and low values from response             |
+    \*-----------------------------------------------------*/
     unsigned char highValue = response[2] >> 4;
-    unsigned char lowValue  = response[2] & 15;
+    unsigned char lowValue  = response[2] & 0x0F;
 
+    /*-----------------------------------------------------*\
+    | Build firmware string <high>.<low>                    |
+    \*-----------------------------------------------------*/
     version_APROM = std::to_string(static_cast<int>(highValue)).append(".").append(std::to_string(static_cast<int>(lowValue)));
 
-    // Now read the LDROM
-    // Checksum also available at report ID 184, with highCheksum stored at index 8, and low at 9
-    request[1] = 182u;
-    num &= hid_write(dev, request, 64);
-    num &= hid_read(dev, response, 64);
+    /*-----------------------------------------------------*\
+    | First read the LDROM                                  |
+    | Checksum also available at report ID 184, with MSB    |
+    | stored at index 0x08 and LSB at 0x09                  |
+    \*-----------------------------------------------------*/
 
-    highValue = response[2] >> 4u;
-    lowValue = response[2] & 15u;
+    /*-----------------------------------------------------*\
+    | Set up LDROM Firmware Version Request packet          |
+    \*-----------------------------------------------------*/
+    request[0x00]   = 0x01;
+    request[0x01]   = 0xB6;
 
+    /*-----------------------------------------------------*\
+    | Send request and receive response packets             |
+    \*-----------------------------------------------------*/
+    ret_val &= hid_write(dev, request, 64);
+    ret_val &= hid_read(dev, response, 64);
+
+    /*-----------------------------------------------------*\
+    | Extract high and low values from response             |
+    \*-----------------------------------------------------*/
+    highValue = response[2] >> 4;
+    lowValue  = response[2] & 0x0F;
+
+    /*-----------------------------------------------------*\
+    | Build firmware string <high>.<low>                    |
+    \*-----------------------------------------------------*/
     version_LDROM = std::to_string(static_cast<int>(highValue)).append(".").append(std::to_string(static_cast<int>(lowValue)));
 
-    return num == 1;
+    /*-----------------------------------------------------*\
+    | If return value is zero it means an HID transfer      |
+    | failed                                                |
+    \*-----------------------------------------------------*/
+    return(ret_val > 0);
 }
 
 void MSIMysticLightController::ReadSerial()
 {
     wchar_t serial[256];
+
+    /*-----------------------------------------------------*\
+    | Get the serial number string from HID                 |
+    \*-----------------------------------------------------*/
     hid_get_serial_number_string(dev, serial, 256);
+
+    /*-----------------------------------------------------*\
+    | Convert wchar_t into std::wstring into std::string    |
+    \*-----------------------------------------------------*/
     std::wstring wserial = std::wstring(serial);
     chip_id = std::string(wserial.begin(), wserial.end());
 }
@@ -260,27 +365,53 @@ void MSIMysticLightController::ReadSerial()
 void MSIMysticLightController::ReadName()
 {
     wchar_t tname[256];
+
+    /*-----------------------------------------------------*\
+    | Get the manufacturer string from HID                  |
+    \*-----------------------------------------------------*/
     hid_get_manufacturer_string(dev, tname, 256);
+
+    /*-----------------------------------------------------*\
+    | Convert wchar_t into std::wstring into std::string    |
+    \*-----------------------------------------------------*/
     std::wstring wname = std::wstring(tname);
     name = std::string(wname.begin(), wname.end());
 
+    /*-----------------------------------------------------*\
+    | Get the product string from HID                       |
+    \*-----------------------------------------------------*/
     hid_get_product_string(dev, tname, 256);
+
+    /*-----------------------------------------------------*\
+    | Append the product string to the manufacturer string  |
+    \*-----------------------------------------------------*/
     wname = std::wstring(tname);
     name.append(" ").append(std::string(wname.begin(), wname.end()));
 }
 
-void MSIMysticLightController::SetDeviceSettings(bool is_fan, FAN_TYPE fan_type,
-                                                 unsigned char corsair_device_quantity,
-                                                 bool is_LL120Outer_individual) 
+void MSIMysticLightController::SetDeviceSettings
+    (
+    bool            is_fan,
+    MSI_FAN_TYPE    fan_type,
+    unsigned char   corsair_device_quantity,
+    bool            is_LL120Outer_individual
+    )
 {
-    // If is_fan false, it is a stripe
-    CorsairZoneData &settingsZone = data.j_corsair;
-    settingsZone.fan_flags = (settingsZone.fan_flags & 128u) | fan_type << 1u | is_fan;
-    settingsZone.corsair_quantity = corsair_device_quantity << 2u;
-    settingsZone.is_individual = BitSet(settingsZone.is_individual, is_LL120Outer_individual, 0u);
+    /*-----------------------------------------------------*\
+    | If is_fan is false, it is an LED strip                |
+    \*-----------------------------------------------------*/
+    CorsairZoneData &settingsZone   = data.j_corsair;
+    settingsZone.fan_flags          = (settingsZone.fan_flags & 0x80) | fan_type << 1 | is_fan;
+    settingsZone.corsair_quantity   = corsair_device_quantity << 2;
+    settingsZone.is_individual      = BitSet(settingsZone.is_individual, is_LL120Outer_individual, 0);
 }
 
-bool MSIMysticLightController::SetVolume(unsigned char main, unsigned char left, unsigned char right)
+bool MSIMysticLightController::SetVolume
+    (
+    unsigned char       main,
+    unsigned char       left,
+    unsigned char       right
+    )
 {
     unsigned char packet[64];
     std::fill_n(packet, sizeof packet, 204u);
@@ -309,41 +440,78 @@ bool MSIMysticLightController::SetVolume(unsigned char main, unsigned char left,
     return hid_write(dev, packet, sizeof packet);
 }
 
-void MSIMysticLightController::SetBoardSyncSettings(bool onboard_sync, bool combine_JRGB, bool combine_JPIPE1,
-                                                    bool combine_JPIPE2, bool combine_JRAINBOW1, bool combine_JRAINBOW2,
-                                                    bool combine_crossair)
+void MSIMysticLightController::SetBoardSyncSettings
+    (
+    bool                onboard_sync,
+    bool                combine_JRGB,
+    bool                combine_JPIPE1,
+    bool                combine_JPIPE2,
+    bool                combine_JRAINBOW1,
+    bool                combine_JRAINBOW2,
+    bool                combine_crossair
+    )
 {
     ZoneData &syncZone = data.on_board_led;
-    syncZone.colorFlags = BitSet(syncZone.colorFlags, onboard_sync, 0u);
-    syncZone.colorFlags = BitSet(syncZone.colorFlags, combine_JRAINBOW1, 1u);
-    syncZone.colorFlags = BitSet(syncZone.colorFlags, combine_JRAINBOW2, 2u);
-    syncZone.colorFlags = BitSet(syncZone.colorFlags, combine_crossair, 3u);
-    syncZone.colorFlags = BitSet(syncZone.colorFlags, combine_JPIPE1, 4u);
-    syncZone.colorFlags = BitSet(syncZone.colorFlags, combine_JPIPE2, 5u);
 
-    syncZone.speedAndBrightnessFlags = BitSet(syncZone.speedAndBrightnessFlags, combine_JRGB, 7u);
+    /*-----------------------------------------------------*\
+    | Set sync flags for on-board LED zone                  |
+    \*-----------------------------------------------------*/
+    syncZone.colorFlags = BitSet(syncZone.colorFlags, onboard_sync,      0);
+    syncZone.colorFlags = BitSet(syncZone.colorFlags, combine_JRAINBOW1, 1);
+    syncZone.colorFlags = BitSet(syncZone.colorFlags, combine_JRAINBOW2, 2);
+    syncZone.colorFlags = BitSet(syncZone.colorFlags, combine_crossair,  3);
+    syncZone.colorFlags = BitSet(syncZone.colorFlags, combine_JPIPE1,    4);
+    syncZone.colorFlags = BitSet(syncZone.colorFlags, combine_JPIPE2,    5);
+
+    syncZone.speedAndBrightnessFlags = BitSet(syncZone.speedAndBrightnessFlags, combine_JRGB, 7);
 }
 
-void MSIMysticLightController::GetMode(ZONE zone, EFFECT &mode, SPEED &speed, BRIGHTNESS &brightness, bool &rainbow_color) 
+void MSIMysticLightController::GetMode
+    (
+    MSI_ZONE            zone,
+    MSI_MODE            &mode,
+    MSI_SPEED           &speed,
+    MSI_BRIGHTNESS      &brightness,
+    bool        &rainbow_color
+    ) 
 {
+    /*-----------------------------------------------------*\
+    | Get data for given zone                               |
+    \*-----------------------------------------------------*/
     ZoneData *zoneData = GetZoneData(zone);
+
+    /*-----------------------------------------------------*\
+    | Return if zone is invalid                             |
+    \*-----------------------------------------------------*/
     if (!zoneData)
     {
         return;
     }
 
-    mode = static_cast<EFFECT>(zoneData->effect);
-    speed = static_cast<SPEED>(zoneData->speedAndBrightnessFlags & 3u);
-    brightness = static_cast<BRIGHTNESS>((zoneData->speedAndBrightnessFlags >> 2u) & 31u);
-    rainbow_color = (zoneData->colorFlags & 128u) >> 7u;
+    /*-----------------------------------------------------*\
+    | Update pointers with data                             |
+    \*-----------------------------------------------------*/
+    mode            = (MSI_MODE)(zoneData->effect);
+    speed           = (MSI_SPEED)(zoneData->speedAndBrightnessFlags & 0x03);
+    brightness      = (MSI_BRIGHTNESS)((zoneData->speedAndBrightnessFlags >> 2) & 0x1F);
+    rainbow_color   = (zoneData->colorFlags & 0x80) >> 7;
 }
 
-unsigned char MSIMysticLightController::BitSet(unsigned char value, bool bit, unsigned int position)
+unsigned char MSIMysticLightController::BitSet
+    (
+    unsigned char       value,
+    bool                bit,
+    unsigned int        position
+    )
 {
     return static_cast<unsigned char>(std::bitset<8>(value).set(position, bit).to_ulong());
 }
 
-void MSIMysticLightController::SetCycleCount(ZONE zone, unsigned char cycle_num)
+void MSIMysticLightController::SetCycleCount
+    (
+    MSI_ZONE            zone,
+    unsigned char       cycle_num
+    )
 {
     RainbowZoneData *requestedZone = GetRainbowZoneData(zone);
 
@@ -355,7 +523,10 @@ void MSIMysticLightController::SetCycleCount(ZONE zone, unsigned char cycle_num)
     requestedZone->cycle_or_led_num = cycle_num;
 }
 
-unsigned char MSIMysticLightController::GetCycleCount(ZONE zone)
+unsigned char MSIMysticLightController::GetCycleCount
+    (
+    MSI_ZONE            zone
+    )
 {
     RainbowZoneData *requestedZone = GetRainbowZoneData(zone);
 
@@ -367,28 +538,43 @@ unsigned char MSIMysticLightController::GetCycleCount(ZONE zone)
     return requestedZone->cycle_or_led_num;
 }
 
-void MSIMysticLightController::GetBoardSyncSettings(bool &onboard_sync, bool &combine_JRGB, bool &combine_JPIPE1,
-                                                    bool &combine_JPIPE2, bool &combine_JRAINBOW1,
-                                                    bool &combine_JRAINBOW2, bool &combine_crossair)
+void MSIMysticLightController::GetBoardSyncSettings
+    (
+    bool                &onboard_sync,
+    bool                &combine_JRGB,
+    bool                &combine_JPIPE1,
+    bool                &combine_JPIPE2,
+    bool                &combine_JRAINBOW1,
+    bool                &combine_JRAINBOW2,
+    bool                &combine_crossair
+    )
 {
     ZoneData &syncZone = data.on_board_led;
-    onboard_sync = syncZone.colorFlags & 1u;
-    combine_JRAINBOW1 = syncZone.colorFlags >> 1u & 1u;
-    combine_JRAINBOW2 = syncZone.colorFlags >> 1u & 1u;
-    combine_crossair = syncZone.colorFlags >> 3u & 1u;
-    combine_JPIPE1 = syncZone.colorFlags >> 4u & 1u;
-    combine_JPIPE2 = syncZone.colorFlags >> 5u & 1u;
 
-    combine_JRGB = (syncZone.speedAndBrightnessFlags & 128u) >> 7u;
+    /*-----------------------------------------------------*\
+    | Get sync flags for on-board LED zone                  |
+    \*-----------------------------------------------------*/
+    onboard_sync        = (syncZone.colorFlags >> 0) & 0x01;
+    combine_JRAINBOW1   = (syncZone.colorFlags >> 1) & 0x01;
+    combine_JRAINBOW2   = (syncZone.colorFlags >> 2) & 0x01;
+    combine_crossair    = (syncZone.colorFlags >> 3) & 0x01;
+    combine_JPIPE1      = (syncZone.colorFlags >> 4) & 0x01;
+    combine_JPIPE2      = (syncZone.colorFlags >> 5) & 0x01;
+
+    combine_JRGB        = (syncZone.speedAndBrightnessFlags & 0x80) >> 7;
 }
 
-void MSIMysticLightController::GetDeviceSettings(bool &stripe_or_fan, FAN_TYPE &fan_type,
-                                                 unsigned char &corsair_device_quantity,
-                                                 bool &is_LL120Outer_individual)
+void MSIMysticLightController::GetDeviceSettings
+    (
+    bool                &stripe_or_fan,
+    MSI_FAN_TYPE        &fan_type,
+    unsigned char       &corsair_device_quantity,
+    bool                &is_LL120Outer_individual
+    )
 {
-    CorsairZoneData &settingsZone = data.j_corsair;
-    stripe_or_fan = settingsZone.fan_flags & 1u;
-    fan_type = static_cast<FAN_TYPE >((settingsZone.fan_flags & 14u) >> 1u);
-    corsair_device_quantity = (settingsZone.corsair_quantity & 252u) >> 2u;
-    is_LL120Outer_individual = settingsZone.is_individual & 1u;
+    CorsairZoneData &settingsZone   = data.j_corsair;
+    stripe_or_fan                   = settingsZone.fan_flags & 0x01;
+    fan_type                        = (MSI_FAN_TYPE )((settingsZone.fan_flags & 14u) >> 1);
+    corsair_device_quantity         = (settingsZone.corsair_quantity & 0xFC) >> 2;
+    is_LL120Outer_individual        = settingsZone.is_individual & 0x01;
 }

Controllers/MSIMysticLightController/MSIMysticLightController.h

@@ -14,105 +14,105 @@
 
 #pragma once
 
-enum ZONE
+enum MSI_ZONE
 {
-    J_RGB_1 = 1,
-    J_RGB_2 = 174,
-    J_PIPE_1 = 11,
-    J_PIPE_2 = 21,
-    J_RAINBOW_1 = 31,
-    J_RAINBOW_2 = 42,
-    J_CORSAIR = 53,
-    J_CORSAIR_OUTERLL120 = 64,
-    ON_BOARD_LED = 74,
-    ON_BOARD_LED_1 = 84,
-    ON_BOARD_LED_2 = 94,
-    ON_BOARD_LED_3 = 104,
-    ON_BOARD_LED_4 = 114,
-    ON_BOARD_LED_5 = 124,
-    ON_BOARD_LED_6 = 134,
-    ON_BOARD_LED_7 = 144,
-    ON_BOARD_LED_8 = 154,
-    ON_BOARD_LED_9 = 164
+    MSI_ZONE_J_RGB_1                = 1,
+    MSI_ZONE_J_RGB_2                = 174,
+    MSI_ZONE_J_PIPE_1               = 11,
+    MSI_ZONE_J_PIPE_2               = 21,
+    MSI_ZONE_J_RAINBOW_1            = 31,
+    MSI_ZONE_J_RAINBOW_2            = 42,
+    MSI_ZONE_J_CORSAIR              = 53,
+    MSI_ZONE_J_CORSAIR_OUTERLL120   = 64,
+    MSI_ZONE_ON_BOARD_LED           = 74,
+    MSI_ZONE_ON_BOARD_LED_1         = 84,
+    MSI_ZONE_ON_BOARD_LED_2         = 94,
+    MSI_ZONE_ON_BOARD_LED_3         = 104,
+    MSI_ZONE_ON_BOARD_LED_4         = 114,
+    MSI_ZONE_ON_BOARD_LED_5         = 124,
+    MSI_ZONE_ON_BOARD_LED_6         = 134,
+    MSI_ZONE_ON_BOARD_LED_7         = 144,
+    MSI_ZONE_ON_BOARD_LED_8         = 154,
+    MSI_ZONE_ON_BOARD_LED_9         = 164
 };
 
 struct ZoneDescription
 {
     std::string name;
-    ZONE value;
+    MSI_ZONE    value;
 };
 
-enum EFFECT
+enum MSI_MODE
 {
-    DISABLE,
-    STATIC,
-    BREATHING,
-    FLASHING,
-    DOUBLE_FLASHING,
-    LIGHTNING,
-    MSI_MARQUEE,
-    METEOR,
-    WATER_DROP,
-    MSI_RAINBOW,
-    POP,
-    RAP,
-    JAZZ,
-    PLAY,
-    MOVIE,
-    COLOR_RING,
-    PLANETARY,
-    DOUBLE_METEOR,
-    ENERGY,
-    BLINK,
-    CLOCK,
-    COLOR_PULSE,
-    COLOR_SHIFT,
-    COLOR_WAVE,
-    MARQUEE,
-    RAINBOW,
-    RAINBOW_WAVE,
-    VISOR,
-    JRAINBOW,
-    RAINBOW_FLASHING,
-    RAINBOW_DOUBLE_FLASHING,
-    RANDOM,
-    FAN_CONTROL,
-    DISABLE_2,
-    COLOR_RING_FLASHING,
-    COLOR_RING_DOUBLE_FLASHING,
-    STACK,
-    CORSAIR_QUE,
-    FIRE,
-    LAVA
+    MSI_MODE_DISABLE                    = 0,
+    MSI_MODE_STATIC                     = 1,
+    MSI_MODE_BREATHING                  = 2,
+    MSI_MODE_FLASHING                   = 3,
+    MSI_MODE_DOUBLE_FLASHING            = 4,
+    MSI_MODE_LIGHTNING                  = 5,
+    MSI_MODE_MSI_MARQUEE                = 6,
+    MSI_MODE_METEOR                     = 7,
+    MSI_MODE_WATER_DROP                 = 8,
+    MSI_MODE_MSI_RAINBOW                = 9,
+    MSI_MODE_POP                        = 10,
+    MSI_MODE_RAP                        = 11,
+    MSI_MODE_JAZZ                       = 12,
+    MSI_MODE_PLAY                       = 13,
+    MSI_MODE_MOVIE                      = 14,
+    MSI_MODE_COLOR_RING                 = 15,
+    MSI_MODE_PLANETARY                  = 16,
+    MSI_MODE_DOUBLE_METEOR              = 17,
+    MSI_MODE_ENERGY                     = 18,
+    MSI_MODE_BLINK                      = 19,
+    MSI_MODE_CLOCK                      = 20,
+    MSI_MODE_COLOR_PULSE                = 21,
+    MSI_MODE_COLOR_SHIFT                = 22,
+    MSI_MODE_COLOR_WAVE                 = 23,
+    MSI_MODE_MARQUEE                    = 24,
+    MSI_MODE_RAINBOW                    = 25,
+    MSI_MODE_RAINBOW_WAVE               = 26,
+    MSI_MODE_VISOR                      = 27,
+    MSI_MODE_JRAINBOW                   = 28,
+    MSI_MODE_RAINBOW_FLASHING           = 29,
+    MSI_MODE_RAINBOW_DOUBLE_FLASHING    = 30,
+    MSI_MODE_RANDOM                     = 31,
+    MSI_MODE_FAN_CONTROL                = 32,
+    MSI_MODE_DISABLE_2                  = 33,
+    MSI_MODE_COLOR_RING_FLASHING        = 34,
+    MSI_MODE_COLOR_RING_DOUBLE_FLASHING = 35,
+    MSI_MODE_STACK                      = 36,
+    MSI_MODE_CORSAIR_QUE                = 37,
+    MSI_MODE_FIRE                       = 38,
+    MSI_MODE_LAVA                       = 39,
 };
 
-enum SPEED
+enum MSI_SPEED
 {
-    LOW,
-    MEDIUM,
-    HIGH
+    MSI_SPEED_LOW                       = 0,
+    MSI_SPEED_MEDIUM                    = 1,
+    MSI_SPEED_HIGH                      = 2,
 };
 
-enum FAN_TYPE
+enum MSI_FAN_TYPE
 {
-    SP,
-    HD,
-    LL
+    MSI_FAN_TYPE_SP                     = 0,
+    MSI_FAN_TYPE_HD                     = 1,
+    MSI_FAN_TYPE_LL                     = 2,
 };
 
-enum BRIGHTNESS
+enum MSI_BRIGHTNESS
 {
-    OFF,
-    LEVEL_10,
-    LEVEL_20,
-    LEVEL_30,
-    LEVEL_40,
-    LEVEL_50,
-    LEVEL_60,
-    LEVEL_70,
-    LEVEL_80,
-    LEVEL_90,
-    LEVEL_100
+    MSI_BRIGHTNESS_OFF                  = 0,
+    MSI_BRIGHTNESS_LEVEL_10             = 1,
+    MSI_BRIGHTNESS_LEVEL_20             = 2,
+    MSI_BRIGHTNESS_LEVEL_30             = 3,
+    MSI_BRIGHTNESS_LEVEL_40             = 4,
+    MSI_BRIGHTNESS_LEVEL_50             = 5,
+    MSI_BRIGHTNESS_LEVEL_60             = 6,
+    MSI_BRIGHTNESS_LEVEL_70             = 7,
+    MSI_BRIGHTNESS_LEVEL_80             = 8,
+    MSI_BRIGHTNESS_LEVEL_90             = 9,
+    MSI_BRIGHTNESS_LEVEL_100            = 10, 
 };
 
 struct Color
@@ -124,54 +124,51 @@ struct Color
 
 struct CorsairZoneData
 {
-    unsigned char effect = EFFECT::STATIC;
-    Color color { std::numeric_limits<unsigned char>::max(), 0, 0 };
-    unsigned char fan_flags = 40;
+    unsigned char effect                    = MSI_MODE_STATIC;
+    Color         color                     { 0, 0, 0 };
+    unsigned char fan_flags                 = 40;
     unsigned char corsair_quantity;
     unsigned char padding[3];
-
-    unsigned char is_individual = 0;
+    unsigned char is_individual             = 0;
 };
 
 struct ZoneData
 {
-    unsigned char effect = EFFECT::STATIC;
-    Color color { std::numeric_limits<unsigned char>::max(), 0u, 0u };
-    unsigned char speedAndBrightnessFlags = 40u;
-    Color color2 { 0, std::numeric_limits<unsigned char>::max(), 0u };
-    unsigned char colorFlags = 128u;
-
-    const unsigned char padding = 0u;
+    unsigned char effect                    = MSI_MODE_STATIC;
+    Color         color                     { 0, 0, 0 };
+    unsigned char speedAndBrightnessFlags   = 40;
+    Color         color2                    { 0, 0, 0 };
+    unsigned char colorFlags                = 128;
+    const unsigned char padding             = 0;
 };
 
 struct RainbowZoneData : ZoneData
 {
-    unsigned char cycle_or_led_num = 20u;
+    unsigned char cycle_or_led_num          = 20;
 };
 
 struct FeaturePacket
 {
-    const unsigned char report_id = 82u; // Report ID
-    ZoneData j_rgb_1; // 1
-    ZoneData j_pipe_1; // 11
-    ZoneData j_pipe_2; // 21
-    RainbowZoneData j_rainbow_1; // 31
-    RainbowZoneData j_rainbow_2; // 42
-    CorsairZoneData j_corsair; // 53
-    ZoneData j_corsair_outerll120; // 64
-    ZoneData on_board_led; // 74
-    ZoneData on_board_led_1; // 84
-    ZoneData on_board_led_2; // 94
-    ZoneData on_board_led_3; // 104
-    ZoneData on_board_led_4; // 114
-    ZoneData on_board_led_5; // 124
-    ZoneData on_board_led_6; // 134
-    ZoneData on_board_led_7; // 144
-    ZoneData on_board_led_8; // 154
-    ZoneData on_board_led_9; // 164
-    ZoneData j_rgb_2; // 174
-
-    unsigned char save_data = 0u; // 184
+    const unsigned char report_id           = 0x52; // Report ID
+    ZoneData            j_rgb_1;                    // 1
+    ZoneData            j_pipe_1;                   // 11
+    ZoneData            j_pipe_2;                   // 21
+    RainbowZoneData     j_rainbow_1;                // 31
+    RainbowZoneData     j_rainbow_2;                // 42
+    CorsairZoneData     j_corsair;                  // 53
+    ZoneData            j_corsair_outerll120;       // 64
+    ZoneData            on_board_led;               // 74
+    ZoneData            on_board_led_1;             // 84
+    ZoneData            on_board_led_2;             // 94
+    ZoneData            on_board_led_3;             // 104
+    ZoneData            on_board_led_4;             // 114
+    ZoneData            on_board_led_5;             // 124
+    ZoneData            on_board_led_6;             // 134
+    ZoneData            on_board_led_7;             // 144
+    ZoneData            on_board_led_8;             // 154
+    ZoneData            on_board_led_9;             // 164
+    ZoneData            j_rgb_2;                    // 174
+    unsigned char       save_data           = 0;    // 184
 };
 
 
@@ -181,25 +178,116 @@ public:
     MSIMysticLightController(hid_device* handle, const char *path);
     ~MSIMysticLightController();
 
-    unsigned int    GetZoneMinLedCount(ZONE zone);
-    unsigned int    GetZoneMaxLedCount(ZONE zone);
-    unsigned int    GetZoneLedCount(ZONE zone);
-    void            SetZoneLedCount(ZONE zone, unsigned int led_count);
+    unsigned int    GetZoneMinLedCount
+                        (
+                        MSI_ZONE        zone
+                        );
+
+    unsigned int    GetZoneMaxLedCount
+                        (
+                        MSI_ZONE        zone
+                        );
+
+    unsigned int    GetZoneLedCount
+                        (
+                        MSI_ZONE        zone
+                        );
+
+    void            SetZoneLedCount
+                        (
+                        MSI_ZONE        zone,
+                        unsigned int    led_count
+                        );
+
+    void            SetMode
+                        (
+                        MSI_ZONE        zone,
+                        MSI_MODE        mode,
+                        MSI_SPEED       speed,
+                        MSI_BRIGHTNESS  brightness,
+                        bool            rainbow_color
+                        );
+
+    void            GetMode
+                        (
+                        MSI_ZONE        zone,
+                        MSI_MODE        &mode,
+                        MSI_SPEED       &speed,
+                        MSI_BRIGHTNESS  &brightness,
+                        bool            &rainbow_color
+                        );
+
+    void            SetZoneColor
+                        (
+                        MSI_ZONE        zone,
+                        unsigned char   red1,
+                        unsigned char   grn1,
+                        unsigned char   blu1,
+                        unsigned char   red2,
+                        unsigned char   grn2,
+                        unsigned char   blu2
+                        );
+
+    void            SetCycleCount
+                        (
+                        MSI_ZONE        zone,
+                        unsigned char   cycle_num
+                        );
+
+    unsigned char   GetCycleCount
+                        (
+                        MSI_ZONE        zone
+                        );
 
-    void            SetMode(ZONE zone, EFFECT mode, SPEED speed, BRIGHTNESS brightness, bool rainbow_color);
-    void            GetMode(ZONE zone, EFFECT &mode, SPEED &speed, BRIGHTNESS &brightness, bool &rainbow_color);
-    void            SetZoneColor(ZONE zone, unsigned char r1, unsigned char g1, unsigned char b1, unsigned char r2, unsigned char g2, unsigned char b2);
-    void            SetCycleCount(ZONE zone, unsigned char cycle_num);
-    unsigned char   GetCycleCount(ZONE zone);
     std::pair<Color, Color>
-                    GetZoneColor(ZONE zone);
+                    GetZoneColor(MSI_ZONE zone);
+
     bool            Update();
 
-    void            SetDeviceSettings(bool stripe_or_fan, FAN_TYPE fan_type, unsigned char corsair_device_quantity, bool is_LL120Outer_individual);
-    void            GetDeviceSettings(bool &stripe_or_fan, FAN_TYPE &fan_type, unsigned char &corsair_device_quantity, bool &is_LL120Outer_individual);
-    bool            SetVolume(unsigned char main, unsigned char left, unsigned char right);
-    void            SetBoardSyncSettings(bool onboard_sync, bool combine_JRGB, bool combine_JPIPE1, bool combine_JPIPE2, bool combine_JRAINBOW1, bool combine_JRAINBOW2, bool combine_crossair);
-    void            GetBoardSyncSettings(bool &onboard_sync, bool &combine_JRGB, bool &combine_JPIPE1, bool &combine_JPIPE2, bool &combine_JRAINBOW1, bool &combine_JRAINBOW2, bool &combine_crossair);
+    void            SetDeviceSettings
+                        (
+                        bool            stripe_or_fan,
+                        MSI_FAN_TYPE    fan_type,
+                        unsigned char   corsair_device_quantity,
+                        bool            is_LL120Outer_individual
+                        );
+
+    void            GetDeviceSettings
+                        (
+                        bool            &stripe_or_fan,
+                        MSI_FAN_TYPE    &fan_type,
+                        unsigned char   &corsair_device_quantity,
+                        bool            &is_LL120Outer_individual
+                        );
+
+    bool            SetVolume
+                        (
+                        unsigned char   main,
+                        unsigned char   left,
+                        unsigned char   right
+                        );
+
+    void            SetBoardSyncSettings
+                        (
+                        bool            onboard_sync,
+                        bool            combine_JRGB,
+                        bool            combine_JPIPE1,
+                        bool            combine_JPIPE2,
+                        bool            combine_JRAINBOW1,
+                        bool            combine_JRAINBOW2,
+                        bool            combine_crossair
+                        );
+
+    void            GetBoardSyncSettings
+                        (
+                        bool            &onboard_sync,
+                        bool            &combine_JRGB,
+                        bool            &combine_JPIPE1,
+                        bool            &combine_JPIPE2,
+                        bool            &combine_JRAINBOW1,
+                        bool            &combine_JRAINBOW2,
+                        bool            &combine_crossair
+                        );
 
     std::string     GetDeviceName();
     std::string     GetDeviceLocation();
@@ -212,9 +300,9 @@ private:
     bool            ReadFwVersion();
     void            ReadSerial();
     void            ReadName();
-    ZoneData*       GetZoneData(ZONE zone);
+    ZoneData*       GetZoneData(MSI_ZONE zone);
     RainbowZoneData*
-                    GetRainbowZoneData(ZONE zone);
+                    GetRainbowZoneData(MSI_ZONE zone);
     static unsigned char   BitSet(unsigned char value, bool bit, unsigned int position);
 
     hid_device*             dev;

Controllers/MSIMysticLightController/MSIMysticLightControllerDetect.cpp

@@ -7,20 +7,23 @@
 
 static const unsigned short msi_pid_table[] =
 {
-    0x7C67, // MS_7C67
+    0x3EA4, // MS_3EA4
+    0x4559, // MS_4459
+
     0x7B10, // MS_7B10
-    0x7C87, // MS_7C87
-    0x7B93, // MS_7B93
+    0x7B93, // MSI B450 Gaming Pro Carbon AC
+    0x7B94, // MS_7B94
+    0x7B96, // MS_7B96
+
     0x7C34, // MS_7C34
     0x7C35, // MS_7C35
     0x7C36, // MS_7C36
     0x7C37, // MS_7C37
     0x7C42, // MS_7C42
-    0x7C84, // MS_7C84
-    0x7B94, // MS_7B94
-    0x7B96, // MS_7B96
+    0x7C56, // MS_7C56
     0x7C59, // MS_7C59
     0x7C60, // MS_7C60
+    0x7C67, // MS_7C67
     0x7C70, // MS_7C70
     0x7C71, // MS_7C71
     0x7C73, // MS_7C73
@@ -29,25 +32,25 @@ static const unsigned short msi_pid_table[] =
     0x7C77, // MS_7C77
     0x7C79, // MS_7C79
     0x7C80, // MS_7C80
-    0x7C98, // MS_7C98
-    0x7C99, // MS_7C99
     0x7C81, // MS_7C81
     0x7C82, // MS_7C82
     0x7C83, // MS_7C83
+    0x7C84, // MS_7C84
     0x7C85, // MS_7C85
     0x7C86, // MS_7C86
+    0x7C87, // MS_7C87
     0x7C88, // MS_7C88
     0x7C89, // MS_7C89
-    0x4559, // MS_4459
-    0x3EA4, // MS_3EA4
-    0x905D, // MS_905D
     0x7C90, // MS_7C90
     0x7C91, // MS_7C91
     0x7C92, // MS_7C92
     0x7C94, // MS_7C94
     0x7C95, // MS_7C95
     0x7C96, // MS_7C96
-    0x7C56  // MS_7C56
+    0x7C98, // MS_7C98
+    0x7C99, // MS_7C99
+
+    0x905D  // MS_905D
 };
 
 /******************************************************************************************\

Controllers/NZXTHue2Controller/NZXTHue2Controller.cpp

@@ -11,12 +11,19 @@
 #include <string>
 #include <cstring>
 
-NZXTHue2Controller::NZXTHue2Controller(hid_device* dev_handle)
+NZXTHue2Controller::NZXTHue2Controller(hid_device* dev_handle, unsigned int rgb_channels, unsigned int fan_channels)
 {
     dev = dev_handle;
 
+    num_fan_channels = fan_channels;
+    num_rgb_channels = rgb_channels;
+
     SendFirmwareRequest();
-    GetStripsOnChannel(HUE_2_CHANNEL_1);
+    UpdateDeviceList();
+
+    fan_cmd.resize(num_fan_channels);
+    fan_rpm.resize(num_fan_channels);
+    UpdateStatus();
 }
 
 NZXTHue2Controller::~NZXTHue2Controller()
@@ -24,39 +31,96 @@ NZXTHue2Controller::~NZXTHue2Controller()
 
 }
 
+unsigned char NZXTHue2Controller::GetFanCommand
+    (
+    unsigned char   fan_channel
+    )
+{
+    return(fan_cmd[fan_channel]);
+}
+
+unsigned short NZXTHue2Controller::GetFanRPM
+    (
+    unsigned char   fan_channel
+    )
+{
+    return(fan_rpm[fan_channel]);
+}
+
+unsigned int NZXTHue2Controller::GetNumFanChannels()
+{
+    return(num_fan_channels);
+}
+
+unsigned int NZXTHue2Controller::GetNumRGBChannels()
+{
+    return(num_rgb_channels);
+}
+
 std::string NZXTHue2Controller::GetFirmwareVersion()
 {
     return(firmware_version);
 }
 
-unsigned int NZXTHue2Controller::GetStripsOnChannel(unsigned int /*channel*/)
+void NZXTHue2Controller::SendFan
+    (
+        unsigned char       port,
+        unsigned char       mode,
+        unsigned char       speed
+    )
 {
-    unsigned int ret_val = 0;
+    unsigned char usb_buf[64];
 
-    unsigned char usb_buf[] =
-    {
-        0x20, 0x03, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00
-    };
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
 
+    /*-----------------------------------------------------*\
+    | Set up RGB packet                                     |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x62;
+    usb_buf[0x01]   = 0x01;
+    usb_buf[0x02]   = 1 << port;
+    usb_buf[port + 3] = speed;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 64);
     hid_read(dev, usb_buf, 64);
+}
 
-    for(int chan = 0; chan < 4; chan++)
+void NZXTHue2Controller::UpdateDeviceList()
+{
+    unsigned char   usb_buf[64];
+    unsigned int    ret_val = 0;
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Device Information Request packet              |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x20;
+    usb_buf[0x01]   = 0x03;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 64);
+
+    /*-----------------------------------------------------*\
+    | Receive packets until 0x21 0x03 is received           |
+    \*-----------------------------------------------------*/
+    do
+    {
+        ret_val = hid_read(dev, usb_buf, sizeof(usb_buf));
+    } while( (ret_val != 64) || (usb_buf[0] != 0x21) || (usb_buf[1] != 0x03) );
+
+    for(int chan = 0; chan < num_rgb_channels; chan++)
     {
         unsigned int start = 0x0F + (6 * chan);
         unsigned int num_leds_on_channel = 0;
@@ -90,7 +154,43 @@ unsigned int NZXTHue2Controller::GetStripsOnChannel(unsigned int /*channel*/)
         }
         channel_leds[chan] = num_leds_on_channel;
     }
-    return(ret_val);
+}
+
+void NZXTHue2Controller::UpdateStatus()
+{
+    unsigned char usb_buf[64];
+    unsigned int  ret_val = 0;
+
+    if(false)//num_fan_channels > 0)
+    {
+        /*-----------------------------------------------------*\
+        | Zero out buffer                                       |
+        \*-----------------------------------------------------*/
+        memset(usb_buf, 0, sizeof(usb_buf));
+
+        /*-----------------------------------------------------*\
+        | Read packet                                           |
+        \*-----------------------------------------------------*/
+        do
+        {
+            ret_val = hid_read(dev, usb_buf, sizeof(usb_buf));
+        } while( (ret_val != 64) || (usb_buf[0] != 0x67) || (usb_buf[1] != 0x02) );
+
+        /*-----------------------------------------------------*\
+        | Extract fan information                               |
+        \*-----------------------------------------------------*/
+        for(int fan_idx = 0; fan_idx < num_fan_channels; fan_idx++)
+        {
+            unsigned char  cmd;
+            unsigned short rpm;
+
+            cmd = usb_buf[40 + fan_idx];
+            rpm = ( usb_buf[25 + (2 * fan_idx)] << 8 ) | usb_buf[24 + (2 * fan_idx)];
+
+            fan_cmd[fan_idx] = cmd;
+            fan_rpm[fan_idx] = rpm;
+        }
+    }
 }
 
 void NZXTHue2Controller::SetChannelEffect
@@ -195,7 +295,7 @@ void NZXTHue2Controller::SendApply
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 64);
-    hid_read(dev, usb_buf, 64);
+    //hid_read(dev, usb_buf, 64);
 }
 
 void NZXTHue2Controller::SendDirect
@@ -230,7 +330,7 @@ void NZXTHue2Controller::SendDirect
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 64);
-    hid_read(dev, usb_buf, 64);
+    //hid_read(dev, usb_buf, 64);
 }
 
 void NZXTHue2Controller::SendEffect
@@ -284,20 +384,34 @@ void NZXTHue2Controller::SendEffect
     memcpy(&usb_buf[0x0A], color_data, color_count * 3);
 
     hid_write(dev, usb_buf, 64);
-    hid_read(dev, usb_buf, 64);
+    //hid_read(dev, usb_buf, 64);
 }
 
 void NZXTHue2Controller::SendFirmwareRequest()
 {
     unsigned char   usb_buf[64];
+    unsigned int    ret_val = 0;
 
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
+    /*-----------------------------------------------------*\
+    | Set up Firmware Request packet                        |
+    \*-----------------------------------------------------*/
     usb_buf[0x00]   = 0x10;
     usb_buf[0x01]   = 0x01;
 
     hid_write(dev, usb_buf, 64);
-    hid_read(dev, usb_buf, 64);
+
+    /*-----------------------------------------------------*\
+    | Receive packets until 0x11 0x01 is received           |
+    \*-----------------------------------------------------*/
+    do
+    {
+        ret_val = hid_read(dev, usb_buf, sizeof(usb_buf));
+    } while( (ret_val != 64) || (usb_buf[0] != 0x11) || (usb_buf[1] != 0x01) );
 
     snprintf(firmware_version, 16, "%u.%u.%u", usb_buf[0x11], usb_buf[0x12], usb_buf[0x13]);
 }

Controllers/NZXTHue2Controller/NZXTHue2Controller.h

@@ -54,14 +54,30 @@ enum
 class NZXTHue2Controller
 {
 public:
-    NZXTHue2Controller(hid_device* dev_handle);
+    NZXTHue2Controller(hid_device* dev_handle, unsigned int rgb_channels, unsigned int fan_channels);
     ~NZXTHue2Controller();
 
     std::string     GetFirmwareVersion();
 
-    unsigned int    GetStripsOnChannel
+    unsigned char   GetFanCommand
                         (
-                        unsigned int    channel
+                        unsigned char   fan_channel
+                        );
+
+    unsigned short  GetFanRPM
+                        (
+                        unsigned char   fan_channel
+                        );
+
+    unsigned int    GetNumFanChannels();
+
+    unsigned int    GetNumRGBChannels();
+
+    void            SendFan
+                        (
+                            unsigned char       port,
+                            unsigned char       mode,
+                            unsigned char       speed
                         );
 
     void            SetChannelEffect
@@ -80,12 +96,22 @@ public:
                         RGBColor *      colors,
                         unsigned int    num_colors
                         );
+
+    void            UpdateDeviceList();
+
+    void            UpdateStatus();
     
     unsigned int    channel_leds[HUE_2_NUM_CHANNELS];
 
 private:
     hid_device*     dev;
+    
+    std::vector<unsigned char>  fan_cmd;
+    std::vector<unsigned short> fan_rpm;
+
     char            firmware_version[16];
+    unsigned int    num_fan_channels;
+    unsigned int    num_rgb_channels;
 
     void            SendApply
                         (

Controllers/NZXTHue2Controller/NZXTHue2ControllerDetect.cpp

@@ -14,6 +14,8 @@ typedef struct
 {
     unsigned short  usb_vid;
     unsigned short  usb_pid;
+    unsigned int    num_rgb_channels;
+    unsigned int    num_fan_channels;
     const char *    name;
 } nzxt_hue_2_device;
 
@@ -24,10 +26,10 @@ static const nzxt_hue_2_device device_list[] =
     /*-----------------------------------------------------------------------------------------------------*\
     | NZXT Hue 2 devices                                                                                    |
     \*-----------------------------------------------------------------------------------------------------*/
-    { NZXT_VID,             NZXT_HUE_2_PID,                             "NZXT Hue 2"                        },
-    { NZXT_VID,             NZXT_HUE_2_AMBIENT_PID,                     "NZXT Hue 2 Ambient"                },
-    { NZXT_VID,             NZXT_SMART_DEVICE_V2_PID,                   "NZXT Smart Device V2"              },
-    { NZXT_VID,             NZXT_RGB_FAN_CONTROLLER_PID,                "NZXT RGB & Fan Controller"         },
+    { NZXT_VID,             NZXT_HUE_2_PID,                 4,  0,      "NZXT Hue 2"                        },
+    { NZXT_VID,             NZXT_HUE_2_AMBIENT_PID,         2,  0,      "NZXT Hue 2 Ambient"                },
+    { NZXT_VID,             NZXT_SMART_DEVICE_V2_PID,       2,  3,      "NZXT Smart Device V2"              },
+    { NZXT_VID,             NZXT_RGB_FAN_CONTROLLER_PID,    2,  3,      "NZXT RGB & Fan Controller"         },
 };
 
 /******************************************************************************************\
@@ -58,23 +60,19 @@ void DetectNZXTHue2Controllers(std::vector<RGBController*> &rgb_controllers)
             &&(info->product_id == device_list[device_idx].usb_pid))
             {
                 dev = hid_open_path(info->path);
-                break;
+
+                if( dev )
+                {
+                    NZXTHue2Controller* controller = new NZXTHue2Controller(dev, device_list[device_idx].num_rgb_channels, device_list[device_idx].num_fan_channels);
+
+                    RGBController_NZXTHue2* rgb_controller = new RGBController_NZXTHue2(controller);
+
+                    rgb_controller->name = device_list[device_idx].name;
+                    
+                    rgb_controllers.push_back(rgb_controller);
+                }
             }
-            else
-            {
-                info = info->next;
-            }
-        }
-
-        if( dev )
-        {
-            NZXTHue2Controller* controller = new NZXTHue2Controller(dev);
-
-            RGBController_NZXTHue2* rgb_controller = new RGBController_NZXTHue2(controller);
-
-            rgb_controller->name = device_list[device_idx].name;
-            
-            rgb_controllers.push_back(rgb_controller);
+            info = info->next;
         }
     }
 }   /* DetectNZXTHue2Controllers() */

Controllers/NZXTKrakenController/NZXTKrakenController.cpp

@@ -50,9 +50,16 @@ std::string NZXTKrakenController::GetFirmwareVersion()
 void NZXTKrakenController::UpdateStatus()
 {
     unsigned char usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
     memset(usb_buf, 0, sizeof(usb_buf));
 
-    hid_read(dev, usb_buf, sizeof(usb_buf));
+    /*-----------------------------------------------------*\
+    | Read packet                                           |
+    \*-----------------------------------------------------*/
+    hid_read(dev, usb_buf, 64);
 
     /*-----------------------------------------------------*\
     | Extract cooler information                            |
@@ -83,14 +90,28 @@ void NZXTKrakenController::UpdateEffect
     )
 {
     unsigned char color_data[9 * 3];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
     memset(color_data, 0, sizeof(color_data));
 
+    /*-----------------------------------------------------*\
+    | Fill in color data                                    |
+    \*-----------------------------------------------------*/
     if(!colors.empty() && channel != NZXT_KRAKEN_CHANNEL_RING)
     {
         colors[0] = ToLogoColor(colors[0]);
     }
 
+    /*-----------------------------------------------------*\
+    | Update color data                                     |
+    \*-----------------------------------------------------*/
     SetColor(colors, color_data);
+
+    /*-----------------------------------------------------*\
+    | Send update packet                                    |
+    \*-----------------------------------------------------*/
     SendEffect(channel, mode, direction, color_data, speed, false, seq);
 }
 
@@ -106,7 +127,7 @@ void NZXTKrakenController::SendEffect
     int             size /* = 0 */
     )
 {
-    unsigned char usb_buf[65];
+    unsigned char usb_buf[64];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -149,5 +170,5 @@ void NZXTKrakenController::SendEffect
     /*-----------------------------------------------------*\
     | Send effect                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, sizeof(usb_buf));
+    hid_write(dev, usb_buf, 64);
 }

Controllers/NZXTKrakenController/NZXTKrakenControllerDetect.cpp

@@ -17,17 +17,35 @@
 
 void DetectNZXTKrakenControllers(std::vector<RGBController*> &rgb_controllers)
 {
+    hid_device_info* info;
+    hid_device* dev;
+
     hid_init();
 
-    hid_device* dev = hid_open(NZXT_KRAKEN_VID, NZXT_KRAKEN_PID, nullptr);
-
-    if( dev )
+    for(std::size_t device_idx = 0; device_idx < 1; device_idx++)
     {
-        NZXTKrakenController* controller = new NZXTKrakenController(dev);
+        dev = NULL;
 
-        RGBController_NZXTKraken* rgb_controller = new RGBController_NZXTKraken(controller);
+        info = hid_enumerate(NZXT_KRAKEN_VID, NZXT_KRAKEN_PID);
 
-        rgb_controllers.push_back(rgb_controller);
+        //Look for NZXT Kraken devices
+        while(info)
+        {
+            if((info->vendor_id == NZXT_KRAKEN_VID)
+            &&(info->product_id == NZXT_KRAKEN_PID))
+            {
+                dev = hid_open_path(info->path);
+                
+                if( dev )
+                {
+                    NZXTKrakenController* controller = new NZXTKrakenController(dev);
+
+                    RGBController_NZXTKraken* rgb_controller = new RGBController_NZXTKraken(controller);
+
+                    rgb_controllers.push_back(rgb_controller);
+                }
+            }
+            info = info->next;
+        }
     }
-
 }

Controllers/PolychromeController/PolychromeController.cpp

@@ -86,17 +86,71 @@ bool PolychromeController::IsAsrLed()
     return(asr_led);
 }
 
-void PolychromeController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
+void PolychromeController::SetColorsAndSpeed(unsigned char red, unsigned char green, unsigned char blue, unsigned char speed)
 {
-    unsigned char colors[3] = { red, green, blue };
+    unsigned char color_speed_pkt[4] = { red, green, blue, speed };
 
     if (asr_led)
     {
-        bus->i2c_smbus_write_block_data(dev, active_mode, 3, colors);
+        switch(active_mode)
+        {
+            /*-----------------------------------------------------*\
+            | These modes take 4 bytes in R/G/B/S order             |
+            \*-----------------------------------------------------*/
+            case ASRLED_MODE_BREATHING:
+            case ASRLED_MODE_FLASHING:
+            case ASRLED_MODE_SPECTRUM_CYCLE:
+                bus->i2c_smbus_write_block_data(dev, active_mode, 4, color_speed_pkt);
+                break;
+
+            /*-----------------------------------------------------*\
+            | These modes take 3 bytes in R/G/B order               |
+            \*-----------------------------------------------------*/
+            default:
+            case ASRLED_MODE_STATIC:
+            case ASRLED_MODE_MUSIC:
+                bus->i2c_smbus_write_block_data(dev, active_mode, 3, color_speed_pkt);
+                break;
+
+            /*-----------------------------------------------------*\
+            | These modes take 1 byte - speed                       |
+            \*-----------------------------------------------------*/
+            case ASRLED_MODE_RANDOM:
+            case ASRLED_MODE_WAVE:
+                bus->i2c_smbus_write_block_data(dev, active_mode, 1, &speed);
+                break;
+
+            /*-----------------------------------------------------*\
+            | These modes take no bytes                             |
+            \*-----------------------------------------------------*/
+            case ASRLED_MODE_OFF:
+                break;
+        }
     }
     else
     {
-        bus->i2c_smbus_write_block_data(dev, POLYCHROME_REG_COLOR, 3, colors);
+        /*-----------------------------------------------------*\
+        | Polychrome firmware always writes color to fixed reg  |
+        \*-----------------------------------------------------*/
+        bus->i2c_smbus_write_block_data(dev, POLYCHROME_REG_COLOR, 3, color_speed_pkt);
+
+        switch(active_mode)
+        {
+            /*-----------------------------------------------------*\
+            | These modes don't take a speed                        |
+            \*-----------------------------------------------------*/
+            POLYCHROME_MODE_OFF:
+            POLYCHROME_MODE_STATIC:
+                break;
+
+            /*-----------------------------------------------------*\
+            | All other modes, write speed to active mode register  |
+            \*-----------------------------------------------------*/
+            default:
+                bus->i2c_smbus_write_block_data(dev, active_mode, 1, &speed);
+                break;
+        }
+
     }
 }
 
@@ -112,4 +166,4 @@ void PolychromeController::SetMode(unsigned char mode)
     {
         bus->i2c_smbus_write_block_data(dev, POLYCHROME_REG_MODE, 1, &active_mode);
     }    
-}
+}

Controllers/PolychromeController/PolychromeController.h

@@ -34,6 +34,13 @@ enum
     ASRLED_MODE_WAVE                = 0x18,     /* Wave effect mode                     */
 };
 
+enum
+{
+    ASRLED_SPEED_MIN                = 0x05,     /* Slowest speed                        */
+    ASRLED_SPEED_DEFAULT            = 0x03,     /* Default speed                        */
+    ASRLED_SPEED_MAX                = 0x00,     /* Fastest speed                        */
+};
+
 enum
 {
     POLYCHROME_REG_FIRMWARE_VER     = 0x00,     /* Firmware version Major.Minor         */
@@ -61,6 +68,13 @@ enum
     POLYCHROME_MODE_RAINBOW         = 0x1E,     /* Rainbow effect mode                  */
 };
 
+enum
+{
+    POLYCHROME_SPEED_MIN            = 0x05,     /* Slowest speed                        */
+    POLYCHROME_SPEED_DEFAULT        = 0x03,     /* Default speed                        */
+    POLYCHROME_SPEED_MAX            = 0x00,     /* Fastest speed                        */
+};
+
 class PolychromeController
 {
 public:
@@ -71,7 +85,7 @@ public:
     unsigned int    GetLEDCount();
     unsigned int    GetMode();
     bool            IsAsrLed();
-    void            SetColor(unsigned char red, unsigned char green, unsigned char blue);
+    void            SetColorsAndSpeed(unsigned char red, unsigned char green, unsigned char blue, unsigned char speed);
     void            SetMode(unsigned char mode);
     unsigned short  GetFirmwareVersion();
 

Controllers/PoseidonZRGBController/PoseidonZRGBControllerDetect.cpp

@@ -30,23 +30,25 @@ void DetectPoseidonZRGBControllers(std::vector<RGBController*>& rgb_controllers)
     {
         if((info->vendor_id == TT_POSEIDON_Z_RGB_VID)
          &&(info->product_id == TT_POSEIDON_Z_RGB_PID)
-         &&(info->interface_number == 2))
+#ifdef USE_HID_USAGE
+         &&(info->interface_number == 1)
+         &&(info->usage_page == 0xFF01))
+#else
+         &&(info->interface_number == 1))
+#endif
         {
             dev = hid_open_path(info->path);
-            break;
+            if( dev )
+            {
+                PoseidonZRGBController* controller = new PoseidonZRGBController(dev);
+
+                RGBController_PoseidonZRGB* rgb_controller = new RGBController_PoseidonZRGB(controller);
+
+                rgb_controllers.push_back(rgb_controller);
+            }
         }
-        else
-        {
             info = info->next;
-        }
     }
 
-    if( dev )
-    {
-        PoseidonZRGBController* controller = new PoseidonZRGBController(dev);
 
-        RGBController_PoseidonZRGB* rgb_controller = new RGBController_PoseidonZRGB(controller);
-
-        rgb_controllers.push_back(rgb_controller);
-    }
 }

Controllers/RGBFusion2USBController/RGBFusion2USBController.cpp

@@ -27,16 +27,17 @@ static LEDCount LedCountToEnum(unsigned int c)
     return(LEDS_1024);
 }
 
-RGBFusion2USBController::RGBFusion2USBController(hid_device* handle, const char *path) : dev(handle)
+RGBFusion2USBController::RGBFusion2USBController(hid_device* handle, const char *path, std::string mb_name) : dev(handle)
 {
-    int res = 0;
-    char text[64] {};
-    unsigned char buffer[64] {};
-
-    if( dev ) {
+    int res                     = 0;
+    char text[64]               = { 0x00 };
+    unsigned char buffer[64]    = { 0x00 };
 
+    if( dev )
+    {
         SetCalibration();
 
+        name = mb_name;
         // hid report read needs 0x60 packet or it gives IO error
         SendPacket(0x60, 0x00);
 
@@ -46,8 +47,8 @@ RGBFusion2USBController::RGBFusion2USBController(hid_device* handle, const char
         {
             report = *reinterpret_cast<IT8297Report*>(buffer);
 
-            name = std::string(report.str_product, 32);
-            name.erase(std::find(name.begin(), name.end(), '\0'), name.end());
+            description = std::string(report.str_product, 32);
+            //description.erase(std::find(description.begin(), description.end(), '\0'), name.end());
 
             snprintf(text, 11, "0x%08X", report.fw_ver);
             version = text;
@@ -55,7 +56,6 @@ RGBFusion2USBController::RGBFusion2USBController(hid_device* handle, const char
             snprintf(text, 11, "0x%08X", report.chip_id);
             chip_id = text;
         }
-
         loc = path;
 
         EnableBeat(false);
@@ -84,13 +84,13 @@ void RGBFusion2USBController::SetCalibration()
     buffer[0] = report_id;
     buffer[1] = 0x33;
 
-     // D_LED1 WS2812 GRB, 0x00RRGGBB to 0x00GGRRBB
+    // D_LED1 WS2812 GRB, 0x00RRGGBB to 0x00GGRRBB
     buffer[2] = 0x02; // B
     buffer[3] = 0x00; // G
     buffer[4] = 0x01; // R
     buffer[5] = 0x00;
 
-     // D_LED2 WS2812 GRB
+    // D_LED2 WS2812 GRB
     buffer[6] = 0x02;
     buffer[7] = 0x00;
     buffer[8] = 0x01;
@@ -102,6 +102,12 @@ void RGBFusion2USBController::SetCalibration()
     buffer[12] = 0x02;
     buffer[13] = 0x00;
 
+    // Spare set seen in some Motherboard models
+    buffer[14] = 0x00;
+    buffer[15] = 0x01;
+    buffer[16] = 0x02;
+    buffer[17] = 0x00;
+
     SendPacket(buffer);
 }
 
@@ -135,6 +141,11 @@ std::string RGBFusion2USBController::GetDeviceName()
     return(name);
 }
 
+std::string RGBFusion2USBController::GetDeviceDescription()
+{
+    return(description);
+}
+
 std::string RGBFusion2USBController::GetFWVersion()
 {
     return(version);

Controllers/RGBFusion2USBController/RGBFusion2USBController.h

@@ -157,7 +157,7 @@ struct IT8297Report
 class RGBFusion2USBController
 {
 public:
-    RGBFusion2USBController(hid_device* handle, const char *path);
+    RGBFusion2USBController(hid_device* handle, const char *path, std::string mb_name);
     ~RGBFusion2USBController();
 
     void            SetStripColors
@@ -175,6 +175,7 @@ public:
     bool            DisableBuiltinEffect(int enable_bit, int mask);
     void            SetCalibration();
     std::string     GetDeviceName();
+    std::string     GetDeviceDescription();
     std::string     GetDeviceLocation();
     std::string     GetFWVersion();
     std::string     GetSerial();
@@ -188,6 +189,7 @@ private:
     int                     mode;
     IT8297Report            report;
     std::string             name;
+    std::string             description;
     std::string             loc;
     std::string             version;
     std::string             chip_id;

Controllers/RGBFusion2USBController/RGBFusion2USBControllerDetect.cpp

@@ -1,8 +1,18 @@
 #include "RGBFusion2USBController.h"
 #include "RGBController_RGBFusion2USB.h"
+#include "dependencies/dmiinfo.h"
 
-#define IT8297_VID 0x048D
-#define IT8297_PID 0x8297
+#define IT8297_VID              0x048D
+#define IT8297_IFC              0
+#define IT8297_U                0xCC
+#define IT8297_UPG              0xFF89
+#define COUNT_RGBFUSION2_PIDS   (sizeof(RGBFusion2_pids) / sizeof(RGBFusion2_pids[ 0 ]))
+
+static const unsigned short RGBFusion2_pids[] =
+{
+    0x8297,     //PID for the ITE 8595 found on the X570
+    0x5702      //PID for the ITE 8595 found on the B550
+};
 
 /******************************************************************************************\
 *                                                                                          *
@@ -14,24 +24,47 @@
 
 void DetectRGBFusion2USBControllers(std::vector<RGBController*> &rgb_controllers)
 {
+    hid_device_info*    info;
+    hid_device*         dev;
+    DMIInfo             MB_info;
+    unsigned short      tmpPID;
+
     if (hid_init() < 0)
-        return;
-
-    hid_device_info * device_list = hid_enumerate(IT8297_VID, IT8297_PID);
-    if (!device_list)
-        return;
-
-    hid_device_info * device = device_list;
-    while (device)
     {
-        hid_device * dev = hid_open_path(device->path);
-        if (dev) {
-            RGBFusion2USBController * controller = new RGBFusion2USBController(dev, device_list->path);
-            RGBController_RGBFusion2USB * rgb_controller = new RGBController_RGBFusion2USB(controller);
-            rgb_controllers.push_back(rgb_controller);
-        }
-        device = device->next;
+        return;
     }
 
-    hid_free_enumeration(device_list);
+    for(int dev_idx = 0; dev_idx < COUNT_RGBFUSION2_PIDS; dev_idx++)
+    {
+        dev = NULL;
+
+        tmpPID = RGBFusion2_pids[dev_idx];
+        info = hid_enumerate(IT8297_VID, tmpPID);
+
+        while(info)
+        {
+            if((info->vendor_id        == IT8297_VID)
+#ifdef USE_HID_USAGE
+            &&(info->product_id        == tmpPID)
+            &&(info->usage             == IT8297_U)     //Usage and usage page required to get the correct interface
+            &&(info->usage_page        == IT8297_UPG))
+#else
+            &&(info->interface_number  == IT8297_IFC)   //Interface is only valid on Windows where there is > 1 interface
+            &&(info->product_id        == tmpPID))
+#endif
+            {
+                hid_device * dev = hid_open_path(info->path);
+                if (dev)
+                {
+                    RGBFusion2USBController * controller = new RGBFusion2USBController(dev, info->path, MB_info.getMainboard());
+                    RGBController_RGBFusion2USB * rgb_controller = new RGBController_RGBFusion2USB(controller);
+                    rgb_controllers.push_back(rgb_controller);
+                    break;
+                }
+            }
+            info = info->next;
+        }
+    }
+
+    hid_free_enumeration(info);
 }

Controllers/RedragonController/RedragonControllerDetect.cpp

@@ -10,6 +10,7 @@
 | Keyboard product IDs                                  |
 \*-----------------------------------------------------*/
 #define REDRAGON_KEYBOARD_VID           0x0C45
+#define REDRAGON_KEYBOARD_USAGE_PAGE    0xFF1C
 #define REDRAGON_K550_PID               0x5204
 #define REDRAGON_K552_PID               0x5104
 #define REDRAGON_K556_PID               0x5004
@@ -20,6 +21,7 @@
 | Mouse product IDs                                     |
 \*-----------------------------------------------------*/
 #define REDRAGON_MOUSE_VID              0x04D9
+#define REDRAGON_MOUSE_USAGE_PAGE       0xFFA0
 #define REDRAGON_M711_PID               0xFC30
 #define REDRAGON_M715_PID               0xFC39
 
@@ -28,6 +30,7 @@ typedef struct
     unsigned short  usb_vid;
     unsigned short  usb_pid;
     unsigned char   usb_interface;
+    unsigned short  usb_usage_page;
     device_type     type;
     const char *    name;
 } redragon_device;
@@ -36,22 +39,22 @@ typedef struct
 
 static const redragon_device device_list[] =
 {
-    /*-------------------------------------------------------------------------------------------------------------*\
-    | Keyboards                                                                                                     |
-    \*-------------------------------------------------------------------------------------------------------------*/
-    { REDRAGON_KEYBOARD_VID,    REDRAGON_K550_PID,          1,  DEVICE_TYPE_KEYBOARD,   "Redragon K550 Yama"        },
-    { REDRAGON_KEYBOARD_VID,    REDRAGON_K552_PID,          1,  DEVICE_TYPE_KEYBOARD,   "Redragon K552 Kumara"      },
-    { REDRAGON_KEYBOARD_VID,    REDRAGON_K556_PID,          1,  DEVICE_TYPE_KEYBOARD,   "Redragon K556 Devarajas"   },
-    { REDRAGON_KEYBOARD_VID,    TECWARE_PHANTOM_ELITE_PID,  1,  DEVICE_TYPE_KEYBOARD,   "Tecware Phantom Elite"     },
-    { REDRAGON_KEYBOARD_VID,    WARRIOR_KANE_TC235,         1,  DEVICE_TYPE_KEYBOARD,   "Warrior Kane TC235"        },
-    /*-------------------------------------------------------------------------------------------------------------*\
-    | Mice                                                                                                          |
-    \*-------------------------------------------------------------------------------------------------------------*/
-    { REDRAGON_MOUSE_VID,       REDRAGON_M711_PID,          2,  DEVICE_TYPE_MOUSE,      "Redragon M711 Cobra"       },
-    { REDRAGON_MOUSE_VID,       REDRAGON_M715_PID,          2,  DEVICE_TYPE_MOUSE,      "Redragon M715 Dagger"      },
-    /*-------------------------------------------------------------------------------------------------------------*\
-    | Mousemats                                                                                                     |
-    \*-------------------------------------------------------------------------------------------------------------*/
+    /*---------------------------------------------------------------------------------------------------------------------------------------------*\
+    | Keyboards                                                                                                                                     |
+    \*---------------------------------------------------------------------------------------------------------------------------------------------*/
+    { REDRAGON_KEYBOARD_VID,    REDRAGON_K550_PID,          1,  REDRAGON_KEYBOARD_USAGE_PAGE,   DEVICE_TYPE_KEYBOARD,   "Redragon K550 Yama"        },
+    { REDRAGON_KEYBOARD_VID,    REDRAGON_K552_PID,          1,  REDRAGON_KEYBOARD_USAGE_PAGE,   DEVICE_TYPE_KEYBOARD,   "Redragon K552 Kumara"      },
+    { REDRAGON_KEYBOARD_VID,    REDRAGON_K556_PID,          1,  REDRAGON_KEYBOARD_USAGE_PAGE,   DEVICE_TYPE_KEYBOARD,   "Redragon K556 Devarajas"   },
+    { REDRAGON_KEYBOARD_VID,    TECWARE_PHANTOM_ELITE_PID,  1,  REDRAGON_KEYBOARD_USAGE_PAGE,   DEVICE_TYPE_KEYBOARD,   "Tecware Phantom Elite"     },
+    { REDRAGON_KEYBOARD_VID,    WARRIOR_KANE_TC235,         1,  REDRAGON_KEYBOARD_USAGE_PAGE,   DEVICE_TYPE_KEYBOARD,   "Warrior Kane TC235"        },
+    /*---------------------------------------------------------------------------------------------------------------------------------------------*\
+    | Mice                                                                                                                                          |
+    \*---------------------------------------------------------------------------------------------------------------------------------------------*/
+    { REDRAGON_MOUSE_VID,       REDRAGON_M711_PID,          2,  REDRAGON_MOUSE_USAGE_PAGE,      DEVICE_TYPE_MOUSE,      "Redragon M711 Cobra"       },
+    { REDRAGON_MOUSE_VID,       REDRAGON_M715_PID,          2,  REDRAGON_MOUSE_USAGE_PAGE,      DEVICE_TYPE_MOUSE,      "Redragon M715 Dagger"      },
+    /*---------------------------------------------------------------------------------------------------------------------------------------------*\
+    | Mousemats                                                                                                                                     |
+    \*---------------------------------------------------------------------------------------------------------------------------------------------*/
 };
 
 /******************************************************************************************\
@@ -78,45 +81,46 @@ void DetectRedragonControllers(std::vector<RGBController*>& rgb_controllers)
         //Look for Redragon RGB Peripheral
         while(info)
         {
-            if((info->vendor_id == device_list[device_idx].usb_vid)
-            &&(info->product_id == device_list[device_idx].usb_pid)
+            if((info->vendor_id       == device_list[device_idx].usb_vid)
+            &&(info->product_id       == device_list[device_idx].usb_pid)
+#ifdef USE_HID_USAGE
+            &&(info->interface_number == device_list[device_idx].usb_interface)
+            &&(info->usage_page       == device_list[device_idx].usb_usage_page))
+#else
             &&(info->interface_number == device_list[device_idx].usb_interface))
+#endif
             {
                 dev = hid_open_path(info->path);
-                break;
-            }
-            else
-            {
-                info = info->next;
-            }
-        }
 
-        if( dev )
-        {
-            switch(device_list[device_idx].type)
-            {
-                case DEVICE_TYPE_KEYBOARD:
+                if( dev )
+                {
+                    switch(device_list[device_idx].type)
                     {
-                    RedragonK556Controller* controller = new RedragonK556Controller(dev);
+                        case DEVICE_TYPE_KEYBOARD:
+                            {
+                            RedragonK556Controller* controller = new RedragonK556Controller(dev);
 
-                    RGBController_RedragonK556* rgb_controller = new RGBController_RedragonK556(controller);
+                            RGBController_RedragonK556* rgb_controller = new RGBController_RedragonK556(controller);
 
-                    rgb_controller->name = device_list[device_idx].name;
-                    rgb_controllers.push_back(rgb_controller);
+                            rgb_controller->name = device_list[device_idx].name;
+                            rgb_controllers.push_back(rgb_controller);
+                            }
+                            break;
+
+                        case DEVICE_TYPE_MOUSE:
+                            {
+                            RedragonM711Controller* controller = new RedragonM711Controller(dev);
+
+                            RGBController_RedragonM711* rgb_controller = new RGBController_RedragonM711(controller);
+
+                            rgb_controller->name = device_list[device_idx].name;
+                            rgb_controllers.push_back(rgb_controller);
+                            }
+                            break;
                     }
-                    break;
-
-                case DEVICE_TYPE_MOUSE:
-                    {
-                    RedragonM711Controller* controller = new RedragonM711Controller(dev);
-
-                    RGBController_RedragonM711* rgb_controller = new RGBController_RedragonM711(controller);
-
-                    rgb_controller->name = device_list[device_idx].name;
-                    rgb_controllers.push_back(rgb_controller);
-                    }
-                    break;
+                }
             }
+            info = info->next;
         }
     }
 }

Controllers/RedragonController/RedragonK556Controller.h

@@ -63,7 +63,7 @@ enum
 enum
 {
     REDRAGON_K556_BRIGHTNESS_LOWEST                 = 0x00, /* Lowest brightness (off)  */
-    REDRAGON_K556_BRIGHTNESS_HIGHEST                = 0x05, /* Highest brightness       */
+    REDRAGON_K556_BRIGHTNESS_HIGHEST                = 0x04, /* Highest brightness       */
 };
 
 enum

Controllers/RedragonController/RedragonM711Controller.cpp

@@ -2,21 +2,6 @@
 
 #include <cstring>
 
-static void send_usb_msg(hid_device* dev, char * data_pkt, unsigned int size)
-{
-    char* usb_pkt = new char[size + 1];
-    
-    usb_pkt[0] = 0x00;
-    for(int i = 1; i < size + 1; i++)
-    {
-        usb_pkt[i] = data_pkt[i-1];
-    }
-    
-    hid_send_feature_report(dev, (unsigned char *)usb_pkt, size + 1);
-    
-    delete usb_pkt;
-}
-
 RedragonM711Controller::RedragonM711Controller(hid_device* dev_handle)
 {
     dev = dev_handle;
@@ -103,7 +88,7 @@ void RedragonM711Controller::SendMouseApply()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf, 16);
+    hid_send_feature_report(dev, (unsigned char *)usb_buf, 16);
 }
 
 void RedragonM711Controller::SendWritePacket
@@ -137,5 +122,5 @@ void RedragonM711Controller::SendWritePacket
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf, 16);
+    hid_send_feature_report(dev, (unsigned char *)usb_buf, 16);
 }

Controllers/SapphireGPUController/SapphireGPUController.cpp

@@ -0,0 +1,58 @@
+/*-----------------------------------------*\
+|  SapphireGPUController.cpp                |
+|                                           |
+|  Driver for Sapphire Nitro Glow GPU RGB   |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 7/15/2020   |
+\*-----------------------------------------*/
+
+#include "SapphireGPUController.h"
+
+SapphireGPUController::SapphireGPUController(i2c_smbus_interface* bus, sapphire_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+}
+
+SapphireGPUController::~SapphireGPUController()
+{
+
+}
+
+std::string SapphireGPUController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return(return_string);
+}
+
+unsigned char SapphireGPUController::GetRed()
+{
+    return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_GPU_REG_RED));
+}
+
+unsigned char SapphireGPUController::GetGreen()
+{
+    return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_GPU_REG_GREEN));
+}
+
+unsigned char SapphireGPUController::GetBlue()
+{
+    return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_GPU_REG_BLUE));
+}
+
+void SapphireGPUController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_GPU_REG_RED,   red);
+    bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_GPU_REG_GREEN, green);
+    bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_GPU_REG_BLUE,  blue);
+}
+
+void SapphireGPUController::SetMode(unsigned char mode, unsigned char speed)
+{
+    bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_GPU_REG_MODE, mode);
+}

Controllers/SapphireGPUController/SapphireGPUController.h

@@ -0,0 +1,55 @@
+/*-----------------------------------------*\
+|  SapphireGPUController.h                  |
+|                                           |
+|  Definitions and types for Sapphire Nitro |
+|  Glow GPU RGB lighting controller         |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 7/15/2020   |
+\*-----------------------------------------*/
+
+#include <string>
+#include "i2c_smbus.h"
+
+#pragma once
+
+typedef unsigned char	sapphire_dev_id;
+
+enum
+{
+    SAPPHIRE_GPU_REG_MODE               = 0x00,
+    SAPPHIRE_GPU_REG_BRIGHTNESS         = 0x01,
+    SAPPHIRE_GPU_REG_RED                = 0x03,
+    SAPPHIRE_GPU_REG_GREEN              = 0x04,
+    SAPPHIRE_GPU_REG_BLUE               = 0x05,
+};
+
+enum
+{
+    SAPPHIRE_GPU_MODE_SAPPHIRE_BLUE     = 0x00,
+    SAPPHIRE_GPU_MODE_RAINBOW           = 0x01,
+    SAPPHIRE_GPU_MODE_BOARD_TEMPERATURE = 0x02,
+    SAPPHIRE_GPU_MODE_FAN_SPEED         = 0x03,
+    SAPPHIRE_GPU_MODE_CUSTOM            = 0x04,
+    SAPPHIRE_GPU_MODE_OFF               = 0x05,
+};
+
+class SapphireGPUController
+{
+public:
+    SapphireGPUController(i2c_smbus_interface* bus, sapphire_dev_id dev);
+    ~SapphireGPUController();
+
+    std::string     GetDeviceLocation();
+
+    unsigned char   GetRed();
+    unsigned char   GetGreen();
+    unsigned char   GetBlue();
+
+    void            SetColor(unsigned char red, unsigned char green, unsigned char blue);
+    void            SetMode(unsigned char mode, unsigned char speed);
+
+private:
+    i2c_smbus_interface*    bus;
+    sapphire_dev_id         dev;
+
+};

Controllers/SapphireGPUController/SapphireGPUControllerDetect.cpp

@@ -0,0 +1,59 @@
+#include "SapphireGPUController.h"
+#include "RGBController.h"
+#include "RGBController_SapphireGPU.h"
+#include "i2c_smbus.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+/******************************************************************************************\
+*                                                                                          *
+*   TestForSapphireGPUController                                                           *
+*                                                                                          *
+*       Tests the given address to see if a Sapphire GPU controller exists there.  First   *
+*       does a quick write to test for a response                                          *
+*                                                                                          *
+\******************************************************************************************/
+
+bool TestForSapphireGPUController(i2c_smbus_interface* bus, unsigned char address)
+{
+    bool pass = false;
+    int res;
+
+    if(bus->i2c_smbus_read_byte_data(address, 0x06) == 0xCC)
+    {
+        pass = true;
+    }
+
+    return(false); //TODO - better detection, leaving disabled for now
+
+}   /* TestForSapphireGPUController() */
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectSapphireGPUControllers                                                           *
+*                                                                                          *
+*       Detect Sapphire GPU controllers on the enumerated I2C busses at address 0x55.      *
+*                                                                                          *
+*           bus - pointer to i2c_smbus_interface where Sapphire GPU device is connected    *
+*           dev - I2C address of Sapphire GPU device                                       *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectSapphireGPUControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
+{
+    SapphireGPUController* new_sapphire;
+    RGBController_SapphireGPU* new_controller;
+
+    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        // Check for Sapphire GPU controller at 0x55
+        if (TestForSapphireGPUController(busses[bus], 0x55))
+        {
+            new_sapphire   = new SapphireGPUController(busses[bus], 0x55);
+            new_controller = new RGBController_SapphireGPU(new_sapphire);
+            rgb_controllers.push_back(new_controller);
+        }
+    }
+
+}   /* DetectSapphireGPUControllers() */

Controllers/SteelSeriesController/SteelSeriesApexController.cpp

@@ -0,0 +1,104 @@
+/*-----------------------------------------*\
+|  SteelSeriesApexController.cpp            |
+|                                           |
+|  Driver for SteelSeries Apex 7 RGB        |
+|  Keyboard lighting controller             |
+|                                           |
+|  Eric Samuelson (edbgon) 7/5/2020         |
+\*-----------------------------------------*/
+
+#include "SteelSeriesApexController.h"
+
+#include <cstring>
+
+using namespace std::chrono_literals;
+
+static unsigned int keys[] = {0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+                              0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
+                              0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
+                              0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
+                              0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
+                              0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52,
+                              0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 
+                              0x60, 0x61, 0x62, 0x63, 0x64, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+                              0xf0 };                   
+
+SteelSeriesApexController::SteelSeriesApexController(hid_device* dev_handle)
+{
+    dev = dev_handle;
+}
+
+SteelSeriesApexController::~SteelSeriesApexController()
+{
+
+}
+
+void SteelSeriesApexController::SetMode
+    (
+    unsigned char mode,
+    std::vector<RGBColor> colors
+    )
+{
+    unsigned char mode_colors[9];
+
+    active_mode = mode;
+
+    memset(mode_colors, 0x00, sizeof(mode_colors));
+
+}
+
+void SteelSeriesApexController::SetLEDsDirect(std::vector<RGBColor> colors)
+{
+    unsigned char buf[643];
+    int num_keys = sizeof(keys)/sizeof(*keys);
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Direct packet                                  |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0;
+    buf[0x01]   = APEX7_PACKET_ID_DIRECT;
+    buf[0x02]   = num_keys;
+
+    /*-----------------------------------------------------*\
+    | Fill in color data                                    |
+    \*-----------------------------------------------------*/
+    for(int i = 0; i < num_keys; i++)
+    {
+        buf[(i*4)+3] = keys[i];
+        buf[(i*4)+4] = RGBGetRValue(colors[i]);
+        buf[(i*4)+5] = RGBGetGValue(colors[i]);
+        buf[(i*4)+6] = RGBGetBValue(colors[i]);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, buf, 643);
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void SteelSeriesApexController::SelectProfile
+    (
+    unsigned char   profile
+    )
+{
+    unsigned char buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer, set up packet and send               |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+    buf[0x00]   = 0;
+    buf[0x01]   = 0x89;
+    buf[0x02]   = profile;
+    hid_send_feature_report(dev, buf, 65);
+
+}

Controllers/SteelSeriesController/SteelSeriesApexController.h

@@ -0,0 +1,44 @@
+/*-----------------------------------------*\
+|  SteelSeriesApexController.h              |
+|                                           |
+|  Definitions and types for SteelSeries    |
+|  Apex 7 Keyboard lighting controller      |
+|                                           |
+|  Eric Samuelson (edbgon) 7/5/2020         |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    APEX7_PACKET_ID_DIRECT             = 0x3a,     /* Direct mode                */
+};
+
+class SteelSeriesApexController
+{
+public:
+    SteelSeriesApexController(hid_device* dev_handle);
+    ~SteelSeriesApexController();
+
+    void SetMode
+        (
+        unsigned char mode,
+        std::vector<RGBColor> colors
+        );
+
+    void SetLEDsDirect(std::vector<RGBColor> colors);
+
+private:
+    hid_device*             dev;
+    unsigned char           active_mode;
+
+    void    SelectProfile
+                (
+                unsigned char   profile
+                );
+};

Controllers/SteelSeriesController/SteelSeriesControllerDetect.cpp

@@ -1,9 +1,11 @@
 #include "SteelSeriesRivalController.h"
 #include "SteelSeriesSiberiaController.h"
+#include "SteelSeriesApexController.h"
 #include "SteelSeriesGeneric.h"
 #include "RGBController.h"
 #include "RGBController_SteelSeriesRival.h"
 #include "RGBController_SteelSeriesSiberia.h"
+#include "RGBController_SteelSeriesApex.h"
 #include <vector>
 #include <hidapi/hidapi.h>
 
@@ -18,7 +20,7 @@
 #define STEELSERIES_RIVAL_100_DOTA_PID              0x170c
 #define STEELSERIES_RIVAL_105_PID                   0x1814
 #define STEELSERIES_RIVAL_110_PID                   0x1729
-#define STEELSERIES_RIVAL_300_PID                   0x1384
+#define STEELSERIES_RIVAL_300_PID                   0x1710
 #define ACER_PREDATOR_RIVAL_300_PID                 0x1714
 #define STEELSERIES_RIVAL_300_CSGO_PID              0x1394
 #define STEELSERIES_RIVAL_300_CSGO_STM32_PID        0x1716
@@ -30,6 +32,10 @@
 | Headset product IDs                                   |
 \*-----------------------------------------------------*/
 #define STEELSERIES_SIBERIA_350_PID                 0x1229
+/*-----------------------------------------------------*\
+| Keyboard product IDs                                  |
+\*-----------------------------------------------------*/
+#define STEELSERIES_APEX_7_PID                      0x1612
 
 typedef struct
 {
@@ -64,13 +70,17 @@ static const steelseries_device device_list[] =
     | Headsets                                                                                                                                                          |
     \*-----------------------------------------------------------------------------------------------------------------------------------------------------------------*/
     { STEELSERIES_VID,      STEELSERIES_SIBERIA_350_PID,                3,  DEVICE_TYPE_HEADSET,    SIBERIA_350,    "SteelSeries Siberia 350"                           },
+    /*-----------------------------------------------------------------------------------------------------------------------------------------------------------------*\
+    | Keyboards                                                                                                                                                         |
+    \*-----------------------------------------------------------------------------------------------------------------------------------------------------------------*/
+    { STEELSERIES_VID,      STEELSERIES_APEX_7_PID,                     1,  DEVICE_TYPE_KEYBOARD,   APEX_7,         "SteelSeries Apex 7"                                },
 };
 
 /******************************************************************************************\
 *                                                                                          *
 *   DetectSteelSeriesControllers                                                           *
 *                                                                                          *
-*       Tests the USB address to find a SteelSeries Rival Mouse or Headset                 *
+*       Tests the USB address to find a SteelSeries Rival Mouse, Headset or Keyboard       *
 *                                                                                          *
 \******************************************************************************************/
 
@@ -108,7 +118,13 @@ void DetectSteelSeriesControllers(std::vector<RGBController*>& rgb_controllers)
             switch(device_list[device_idx].type)
             {
                 case DEVICE_TYPE_KEYBOARD:
-                    /* Not yet supported */
+                    {
+                    SteelSeriesApexController* controller = new SteelSeriesApexController(dev);
+                    
+                    RGBController_SteelSeriesApex* rgb_controller = new RGBController_SteelSeriesApex(controller);
+                    rgb_controller->name = device_list[device_idx].name;
+                    rgb_controllers.push_back(rgb_controller);
+                    }
                     break;
 
                 case DEVICE_TYPE_HEADSET:

Controllers/SteelSeriesController/SteelSeriesGeneric.h

@@ -20,5 +20,6 @@ typedef enum
     RIVAL_100   = 0x00,
     RIVAL_300   = 0x01,
     SIBERIA_350 = 0x03,
+    APEX_7		= 0x04,
 } steelseries_type;
 

Controllers/ThermaltakeRiingController/ThermaltakeRiingController.cpp

@@ -52,7 +52,7 @@ void ThermaltakeRiingController::SetMode(unsigned char mode, unsigned char speed
 
 void ThermaltakeRiingController::SendInit()
 {
-    unsigned char usb_buf[64];
+    unsigned char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -62,14 +62,15 @@ void ThermaltakeRiingController::SendInit()
     /*-----------------------------------------------------*\
     | Set up Init packet                                    |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xFE;
-    usb_buf[0x01]   = 0x33;
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0xFE;
+    usb_buf[0x02]   = 0x33;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 64);
-    hid_read(dev, usb_buf, 64);
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 65);
 }
 
 void ThermaltakeRiingController::SendRGB
@@ -81,7 +82,7 @@ void ThermaltakeRiingController::SendRGB
         unsigned char*      color_data
     )
 {
-    unsigned char usb_buf[64];
+    unsigned char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -91,19 +92,20 @@ void ThermaltakeRiingController::SendRGB
     /*-----------------------------------------------------*\
     | Set up RGB packet                                     |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x32;
-    usb_buf[0x01]   = 0x52;
-    usb_buf[0x02]   = port;
-    usb_buf[0x03]   = mode + ( speed & 0x03 );
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x32;
+    usb_buf[0x02]   = 0x52;
+    usb_buf[0x03]   = port;
+    usb_buf[0x04]   = mode + ( speed & 0x03 );
 
     /*-----------------------------------------------------*\
     | Copy in GRB color data                                |
     \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x04], color_data, (num_colors * 3));
+    memcpy(&usb_buf[0x05], color_data, (num_colors * 3));
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 64);
-    hid_read(dev, usb_buf, 64);
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 65);
 }

NetworkClient.cpp

@@ -22,6 +22,7 @@
 
 #ifdef __linux__
 #include <unistd.h>
+#include <sys/select.h>
 #endif
 
 using namespace std::chrono_literals;
@@ -62,6 +63,11 @@ unsigned short NetworkClient::GetPort()
     return port_num;
 }
 
+bool NetworkClient::GetConnected()
+{
+    return(server_connected);
+}
+
 bool NetworkClient::GetOnline()
 {
     return(server_connected && server_initialized);
@@ -190,7 +196,7 @@ void NetworkClient::ConnectionThreadFunction()
             //Wait for server controller count
             while(server_controller_count == 0)
             {
-                std::this_thread::sleep_for(100ms);
+                std::this_thread::sleep_for(5ms);
             }
 
             printf("Client: Received controller count from server: %d\r\n", server_controller_count);
@@ -200,12 +206,13 @@ void NetworkClient::ConnectionThreadFunction()
             {
                 printf("Client: Requesting controller %d\r\n", requested_controllers);
 
+                controller_data_received = false;
                 SendRequest_ControllerData(requested_controllers);
 
                 //Wait until controller is received
-                while(server_controllers.size() == requested_controllers)
+                while(controller_data_received == false)
                 {
-                    std::this_thread::sleep_for(100ms);
+                    std::this_thread::sleep_for(5ms);
                 }
 
                 requested_controllers++;
@@ -251,7 +258,6 @@ int NetworkClient::recv_select(SOCKET s, char *buf, int len, int flags)
         }
         else if(rv == 0)
         {
-            std::this_thread::sleep_for(100ms);
             continue;
         }
         else
@@ -346,8 +352,6 @@ void NetworkClient::ListenThreadFunction()
 
         } while(bytes_read != sizeof(header) - sizeof(header.pkt_magic));
 
-        //printf( "Client: Received header, now receiving data of size %d\r\n", header.pkt_size);
-
         //Header received, now receive the data
         if(header.pkt_size > 0)
         {
@@ -370,21 +374,14 @@ void NetworkClient::ListenThreadFunction()
             } while (bytes_read < header.pkt_size);
         }
 
-        //printf( "Client: Received header and data\r\n" );
-        //printf( "Client: Packet ID: %d \r\n", header.pkt_id);
-
         //Entire request received, select functionality based on request ID
         switch(header.pkt_id)
         {
             case NET_PACKET_ID_REQUEST_CONTROLLER_COUNT:
-                printf( "Client: NET_PACKET_ID_REQUEST_CONTROLLER_COUNT\r\n" );
-
                 ProcessReply_ControllerCount(header.pkt_size, data);
                 break;
 
             case NET_PACKET_ID_REQUEST_CONTROLLER_DATA:
-                printf( "Client: NET_PACKET_ID_REQUEST_CONTROLLER_DATA\r\n");
-
                 ProcessReply_ControllerData(header.pkt_size, data, header.pkt_dev_idx);
                 break;
         }
@@ -419,6 +416,20 @@ listen_done:
     ClientInfoChanged();
 }
 
+void NetworkClient::WaitOnControllerData()
+{
+    for(int i = 0; i < 1000; i++)
+    {
+        if(controller_data_received)
+        {
+            break;
+        }
+        std::this_thread::sleep_for(1ms);
+    }
+
+    return;
+}
+
 void NetworkClient::ProcessReply_ControllerCount(unsigned int data_size, char * data)
 {
     if(data_size == sizeof(unsigned int))
@@ -433,9 +444,17 @@ void NetworkClient::ProcessReply_ControllerData(unsigned int data_size, char * d
 
     new_controller->ReadDeviceDescription((unsigned char *)data);
 
-    printf("Received controller: %s\r\n", new_controller->name.c_str());
+    if(dev_idx >= server_controllers.size())
+    {
+        server_controllers.push_back(new_controller);
+    }
+    else
+    {
+        server_controllers[dev_idx]->active_mode = new_controller->active_mode;
+        delete new_controller;
+    }
 
-    server_controllers.push_back(new_controller);
+    controller_data_received = true;
 }
 
 void NetworkClient::SendData_ClientString()
@@ -475,6 +494,8 @@ void NetworkClient::SendRequest_ControllerData(unsigned int dev_idx)
 {
     NetPacketHeader reply_hdr;
 
+    controller_data_received = false;
+
     reply_hdr.pkt_magic[0] = 'O';
     reply_hdr.pkt_magic[1] = 'R';
     reply_hdr.pkt_magic[2] = 'G';

NetworkClient.h

@@ -24,6 +24,7 @@ public:
 
     void            ClientInfoChanged();
 
+    bool            GetConnected();
     const char *    GetIP();
     unsigned short  GetPort();
     bool            GetOnline();
@@ -40,6 +41,8 @@ public:
     void            ConnectionThreadFunction();
     void            ListenThreadFunction();
 
+    void            WaitOnControllerData();
+    
     void        ProcessReply_ControllerCount(unsigned int data_size, char * data);
     void        ProcessReply_ControllerData(unsigned int data_size, char * data, unsigned int dev_idx);
     
@@ -71,6 +74,7 @@ private:
     char            port_ip[20];
     unsigned short  port_num;
     bool            client_active;
+    bool            controller_data_received;
     bool            server_connected;
     bool            server_initialized;
     unsigned int    server_controller_count;

NetworkServer.cpp

@@ -71,26 +71,42 @@ unsigned int NetworkServer::GetNumClients()
 
 const char * NetworkServer::GetClientString(unsigned int client_num)
 {
+    const char * result;
+
+    ServerClientsMutex.lock();
+
     if(client_num < ServerClients.size())
     {
-        return ServerClients[client_num]->client_string.c_str();
+        result = ServerClients[client_num]->client_string.c_str();
     }
     else
     {
-        return "";
+        result = "";
     }
+
+    ServerClientsMutex.unlock();
+
+    return result;
 }
 
 const char * NetworkServer::GetClientIP(unsigned int client_num)
 {
+    const char * result;
+
+    ServerClientsMutex.lock();
+
     if(client_num < ServerClients.size())
     {
-        return ServerClients[client_num]->client_ip;
+        result = ServerClients[client_num]->client_ip;
     }
     else
     {
-        return "";
+        result = "";
     }
+
+    ServerClientsMutex.unlock();
+
+    return result;
 }
 
 void NetworkServer::RegisterClientInfoChangeCallback(NetServerCallback new_callback, void * new_callback_arg)
@@ -165,30 +181,26 @@ void NetworkServer::StartServer()
     | Start the connection thread                       |
     \*-------------------------------------------------*/
     ConnectionThread = new std::thread(&NetworkServer::ConnectionThreadFunction, this);
+    ConnectionThread->detach();
 }
 
 void NetworkServer::StopServer()
 {
     server_online = false;
 
+    ServerClientsMutex.lock();
     for(unsigned int client_idx = 0; client_idx < ServerClients.size(); client_idx++)
     {
         shutdown(ServerClients[client_idx]->client_sock, SD_RECEIVE);
         closesocket(ServerClients[client_idx]->client_sock);
-        ServerClients[client_idx]->client_listen_thread->join();
+        delete ServerClients[client_idx];
     }
 
     shutdown(server_sock, SD_RECEIVE);
     closesocket(server_sock);
 
-    ConnectionThread->join();
-
-    for(unsigned int client_idx = 0; client_idx < ServerClients.size(); client_idx++)
-    {
-        delete ServerClients[client_idx];
-    }
-
     ServerClients.clear();
+    ServerClientsMutex.unlock();
 
     /*-------------------------------------------------*\
     | Client info has changed, call the callbacks       |
@@ -248,10 +260,15 @@ void NetworkServer::ConnectionThreadFunction()
 
         client_info->client_string = "Client";
 
+        /* We need to lock before the thread could possibly finish */
+        ServerClientsMutex.lock();
+
         //Start a listener thread for the new client socket
         client_info->client_listen_thread = new std::thread(&NetworkServer::ListenThreadFunction, this, client_info);
+        client_info->client_listen_thread->detach();
 
         ServerClients.push_back(client_info);
+        ServerClientsMutex.unlock();
 
         /*-------------------------------------------------*\
         | Client info has changed, call the callbacks       |
@@ -284,7 +301,6 @@ int NetworkServer::accept_select(int sockfd, struct sockaddr *addr, socklen_t *a
         }
         else if(rv == 0)
         {
-            std::this_thread::sleep_for(100ms);
             continue;
         }
         else
@@ -316,7 +332,6 @@ int NetworkServer::recv_select(SOCKET s, char *buf, int len, int flags)
         }
         else if(rv == 0)
         {
-            std::this_thread::sleep_for(100ms);
             continue;
         }
         else
@@ -412,8 +427,6 @@ void NetworkServer::ListenThreadFunction(NetworkClientInfo * client_info)
 
         } while(bytes_read != sizeof(header) - sizeof(header.pkt_magic));
 
-        //printf( "Server: Received header, now receiving data of size %d\r\n", header.pkt_size);
-
         //Header received, now receive the data
         if(header.pkt_size > 0)
         {
@@ -436,29 +449,31 @@ void NetworkServer::ListenThreadFunction(NetworkClientInfo * client_info)
             } while (bytes_read < header.pkt_size);
         }
 
-        //printf( "Server: Received header and data\r\n" );
-        //printf( "Server: Packet ID: %d \r\n", header.pkt_id);
-
         //Entire request received, select functionality based on request ID
         switch(header.pkt_id)
         {
             case NET_PACKET_ID_REQUEST_CONTROLLER_COUNT:
-                //printf( "NET_PACKET_ID_REQUEST_CONTROLLER_COUNT\r\n" );
                 SendReply_ControllerCount(client_sock);
                 break;
 
             case NET_PACKET_ID_REQUEST_CONTROLLER_DATA:
-                //printf( "NET_PACKET_ID_REQUEST_CONTROLLER_DATA\r\n" );
                 SendReply_ControllerData(client_sock, header.pkt_dev_idx);
                 break;
 
             case NET_PACKET_ID_SET_CLIENT_NAME:
-                printf( "NET_PACKET_ID_SET_CLIENT_NAME\r\n" );
+                if(data == NULL)
+                {
+                    break;
+                }
+
                 ProcessRequest_ClientString(client_sock, header.pkt_size, data);
                 break;
 
             case NET_PACKET_ID_RGBCONTROLLER_RESIZEZONE:
-                //printf( "NET_PACKET_ID_RGBCONTROLLER_RESIZEZONE\r\n" );
+                if(data == NULL)
+                {
+                    break;
+                }
 
                 if((header.pkt_dev_idx < controllers.size()) && (header.pkt_size == (2 * sizeof(int))))
                 {
@@ -473,7 +488,10 @@ void NetworkServer::ListenThreadFunction(NetworkClientInfo * client_info)
                 break;
 
             case NET_PACKET_ID_RGBCONTROLLER_UPDATELEDS:
-                //printf( "NET_PACKET_ID_RGBCONTROLLER_UPDATELEDS\r\n" );
+                if(data == NULL)
+                {
+                    break;
+                }
 
                 if(header.pkt_dev_idx < controllers.size())
                 {
@@ -483,7 +501,10 @@ void NetworkServer::ListenThreadFunction(NetworkClientInfo * client_info)
                 break;
 
             case NET_PACKET_ID_RGBCONTROLLER_UPDATEZONELEDS:
-                //printf( "NET_PACKET_ID_RGBCONTROLLER_UPDATEZONELEDS\r\n" );
+                if(data == NULL)
+                {
+                    break;
+                }
 
                 if(header.pkt_dev_idx < controllers.size())
                 {
@@ -497,7 +518,10 @@ void NetworkServer::ListenThreadFunction(NetworkClientInfo * client_info)
                 break;
 
             case NET_PACKET_ID_RGBCONTROLLER_UPDATESINGLELED:
-                //printf( "NET_PACKET_ID_RGBCONTROLLER_UPDATESINGLELED\r\n" );
+                if(data == NULL)
+                {
+                    break;
+                }
 
                 if(header.pkt_dev_idx < controllers.size())
                 {
@@ -511,8 +535,6 @@ void NetworkServer::ListenThreadFunction(NetworkClientInfo * client_info)
                 break;
 
             case NET_PACKET_ID_RGBCONTROLLER_SETCUSTOMMODE:
-                //printf( "NET_PACKET_ID_RGBCONTROLLER_SETCUSTOMMODE\r\n" );
-
                 if(header.pkt_dev_idx < controllers.size())
                 {
                     controllers[header.pkt_dev_idx]->SetCustomMode();
@@ -520,7 +542,10 @@ void NetworkServer::ListenThreadFunction(NetworkClientInfo * client_info)
                 break;
 
             case NET_PACKET_ID_RGBCONTROLLER_UPDATEMODE:
-                //printf( "NET_PACKET_ID_RGBCONTROLLER_UPDATEMODE\r\n" );
+                if(data == NULL)
+                {
+                    break;
+                }
 
                 if(header.pkt_dev_idx < controllers.size())
                 {
@@ -538,15 +563,21 @@ listen_done:
     shutdown(client_info->client_sock, SD_RECEIVE);
     closesocket(client_info->client_sock);
 
+    ServerClientsMutex.lock();
+
     for(unsigned int this_idx = 0; this_idx < ServerClients.size(); this_idx++)
     {
         if(ServerClients[this_idx] == client_info)
         {
+            delete client_info->client_listen_thread;
+            delete client_info;
             ServerClients.erase(ServerClients.begin() + this_idx);
             break;
         }
     }
 
+    ServerClientsMutex.unlock();
+
     /*-------------------------------------------------*\
     | Client info has changed, call the callbacks       |
     \*-------------------------------------------------*/
@@ -555,6 +586,7 @@ listen_done:
 
 void NetworkServer::ProcessRequest_ClientString(SOCKET client_sock, unsigned int data_size, char * data)
 {
+    ServerClientsMutex.lock();
     for(unsigned int this_idx = 0; this_idx < ServerClients.size(); this_idx++)
     {
         if(ServerClients[this_idx]->client_sock == client_sock)
@@ -563,6 +595,7 @@ void NetworkServer::ProcessRequest_ClientString(SOCKET client_sock, unsigned int
             break;
         }
     }
+    ServerClientsMutex.unlock();
 
     /*-------------------------------------------------*\
     | Client info has changed, call the callbacks       |

NetworkServer.h

@@ -59,6 +59,7 @@ protected:
 
     std::vector<RGBController *>&       controllers;
 
+    std::mutex                          ServerClientsMutex;
     std::vector<NetworkClientInfo *>    ServerClients;
     std::thread *                       ConnectionThread;
 

OpenRGB.cpp

@@ -106,6 +106,11 @@ void DetectNvAPII2CBusses()
 {
     static NV_PHYSICAL_GPU_HANDLE   gpu_handles[64];
     static NV_S32                   gpu_count = 0;
+    NV_U32                          device_id;
+    NV_U32                          ext_device_id;
+    NV_STATUS                       res;
+    NV_U32                          revision_id;
+    NV_U32                          sub_system_id;
 
     NV_STATUS initialize = NvAPI_Initialize();
 
@@ -117,6 +122,17 @@ void DetectNvAPII2CBusses()
 
         sprintf(nvapi_bus->device_name, "NVidia NvAPI I2C on GPU %d", gpu_idx);
 
+        res = NvAPI_GPU_GetPCIIdentifiers(gpu_handles[gpu_idx], &device_id, &sub_system_id, &revision_id, &ext_device_id);
+
+        if (res == 0)
+        {
+            nvapi_bus->pci_device           = device_id >> 16;
+            nvapi_bus->pci_vendor           = device_id & 0xffff;
+            nvapi_bus->pci_subsystem_device = sub_system_id >> 16;
+            nvapi_bus->pci_subsystem_vendor = sub_system_id & 0xffff;
+            nvapi_bus->port_id              = 1;
+        }
+
         busses.push_back(nvapi_bus);
     }
 }   /* DetectNvAPII2CBusses() */
@@ -260,6 +276,11 @@ void DetectI2CBusses()
     char                    driver_path[512];
     struct dirent *         ent;
     int                     test_fd;
+    char path[1024];
+    char buff[100];
+    unsigned short pci_device, pci_vendor, pci_subsystem_device, pci_subsystem_vendor;
+    unsigned short port_id;
+    bool info;
 
     // Start looking for I2C adapters in /sys/bus/i2c/devices/
     strcpy(driver_path, "/sys/bus/i2c/devices/");
@@ -291,6 +312,74 @@ void DetectI2CBusses()
 
                     close(test_fd);
 
+                    // For now, only get PCI information from nVidia GPUs
+                    // PCI IDs are not currently obtained from the Nouveau driver
+                    // and GPUs using PCI IDs for detection will not work with it.
+                    if (sscanf(device_string, "NVIDIA i2c adapter %hu at", &port_id) == 1)
+                    {
+                        info = true;
+                        
+                        // Get PCI Device
+                        snprintf(path, sizeof(path), "%s%s%s", driver_path, ent->d_name, "/device/device");
+                        test_fd = open(path, O_RDONLY);
+                        if (test_fd < 0)
+                        {
+                            ent = readdir(dir);
+                            continue;
+                        }
+                        memset(buff, 0x00, sizeof(buff));
+                        read(test_fd, buff, sizeof(buff));
+                        buff[strlen(buff) - 1] = 0x00;
+                        pci_device = strtoul(buff, NULL, 16);
+                        close(test_fd);
+
+                        // Get PCI Vendor
+                        snprintf(path, sizeof(path), "%s%s%s", driver_path, ent->d_name, "/device/vendor");
+                        test_fd = open(path, O_RDONLY);
+                        if (test_fd < 0)
+                        {
+                            ent = readdir(dir);
+                            continue;
+                        }
+                        memset(buff, 0x00, sizeof(buff));
+                        read(test_fd, buff, sizeof(buff));
+                        buff[strlen(buff) - 1] = 0x00;
+                        pci_vendor = strtoul(buff, NULL, 16);
+                        close(test_fd);
+
+                        // Get PCI Subsystem Device
+                        snprintf(path, sizeof(path), "%s%s%s", driver_path, ent->d_name, "/device/subsystem_device");
+                        test_fd = open(path, O_RDONLY);
+                        if (test_fd < 0)
+                        {
+                            ent = readdir(dir);
+                            continue;
+                        }
+                        memset(buff, 0x00, sizeof(buff));
+                        read(test_fd, buff, sizeof(buff));
+                        buff[strlen(buff) - 1] = 0x00;
+                        pci_subsystem_device = strtoul(buff, NULL, 16);
+                        close(test_fd);
+
+                        // Get PCI Subsystem Vendor
+                        snprintf(path, sizeof(path), "%s%s%s", driver_path, ent->d_name, "/device/subsystem_vendor");
+                        test_fd = open(path, O_RDONLY);
+                        if (test_fd < 0)
+                        {
+                            ent = readdir(dir);
+                            continue;
+                        }
+                        memset(buff, 0x00, sizeof(buff));
+                        read(test_fd, buff, sizeof(buff));
+                        buff[strlen(buff) - 1] = 0x00;
+                        pci_subsystem_vendor = strtoul(buff, NULL, 16);
+                        close(test_fd);
+                    }
+                    else
+                    {
+                        info = false;
+                    }
+
                     strcpy(device_string, "/dev/");
                     strcat(device_string, ent->d_name);
                     test_fd = open(device_string, O_RDWR);
@@ -304,6 +393,13 @@ void DetectI2CBusses()
                     bus = new i2c_smbus_linux();
                     strcpy(bus->device_name, device_string);
                     bus->handle = test_fd;
+                    if (info) {
+                        bus->pci_device = pci_device;
+                        bus->pci_vendor = pci_vendor;
+                        bus->pci_subsystem_device = pci_subsystem_device;
+                        bus->pci_subsystem_vendor = pci_subsystem_vendor;
+                        bus->port_id = port_id;
+                    }
                     busses.push_back(bus);
                 }
             }
@@ -327,6 +423,9 @@ void DetectRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses, std::
 void DetectRGBFusionGPUControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
 void DetectRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
 void DetectRGBFusion2DRAMControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
+void DetectMSIGPUControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
+void DetectSapphireGPUControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
+void DetectGalaxGPUControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
 void DetectMSIMysticLightControllers(std::vector<RGBController*> &rgb_controllers);
 void DetectMSIRGBControllers(std::vector<RGBController*> &rgb_controllers);
 void DetectAuraUSBControllers(std::vector<RGBController*> &rgb_controllers);
@@ -344,6 +443,7 @@ void DetectCorsairPeripheralControllers(std::vector<RGBController*>& rgb_control
 void DetectCorsairLightingNodeControllers(std::vector<RGBController*> &rgb_controllers);
 void DetectFaustusControllers(std::vector<RGBController*> &rgb_controllers);
 void DetectHyperXKeyboardControllers(std::vector<RGBController*>& rgb_controllers);
+void DetectHyperXMouseControllers(std::vector<RGBController*>& rgb_controllers);
 void DetectThermaltakeRiingControllers(std::vector<RGBController*>& rgb_controllers);
 void DetectRGBFusion2USBControllers(std::vector<RGBController*> &rgb_controllers);
 void DetectRedragonControllers(std::vector<RGBController*>& rgb_controllers);
@@ -351,6 +451,8 @@ void DetectLogitechControllers(std::vector<RGBController*>& rgb_controllers);
 void DetectNZXTKrakenControllers(std::vector<RGBController*>& rgb_controllers);
 void DetectSteelSeriesControllers(std::vector<RGBController*>& rgb_controllers);
 void DetectGloriousModelOControllers(std::vector<RGBController*>& rgb_controllers);
+void DetectDuckyKeyboardControllers(std::vector<RGBController*>& rgb_controllers);
+void DetectEKControllers(std::vector<RGBController*>& rgb_controllers);
 
 /******************************************************************************************\
 *                                                                                          *
@@ -369,17 +471,20 @@ void DetectRGBControllers(void)
     DetectCorsairVengeanceControllers(busses, rgb_controllers);
     DetectCorsairVengeanceProControllers(busses, rgb_controllers);
     DetectCrucialControllers(busses, rgb_controllers);
+    DetectGalaxGPUControllers(busses, rgb_controllers);
     DetectHyperXDRAMControllers(busses, rgb_controllers);
     DetectPatriotViperControllers(busses, rgb_controllers);
     DetectPolychromeControllers(busses, rgb_controllers);
     DetectRGBFusionGPUControllers(busses, rgb_controllers);
+    DetectMSIGPUControllers(busses, rgb_controllers);
+    DetectSapphireGPUControllers(busses, rgb_controllers);
 
     //TODO: Implement better detection before enabling these controllers
     //DetectRGBFusion2SMBusControllers(busses, rgb_controllers);
     //DetectRGBFusion2DRAMControllers(busses, rgb_controllers);
 
     DetectRGBFusionControllers(busses, rgb_controllers);
-    DetectMSIMysticLightControllers(rgb_controllers);
+    //DetectMSIMysticLightControllers(rgb_controllers);
     DetectMSIRGBControllers(rgb_controllers);
 
     DetectAuraUSBControllers(rgb_controllers);
@@ -393,6 +498,7 @@ void DetectRGBControllers(void)
     DetectMSI3ZoneControllers(rgb_controllers);
     DetectPoseidonZRGBControllers(rgb_controllers);
     DetectHyperXKeyboardControllers(rgb_controllers);
+    //DetectHyperXMouseControllers(rgb_controllers);
     DetectCorsairPeripheralControllers(rgb_controllers);
     DetectCorsairLightingNodeControllers(rgb_controllers);
     DetectThermaltakeRiingControllers(rgb_controllers);
@@ -402,6 +508,8 @@ void DetectRGBControllers(void)
     DetectNZXTKrakenControllers(rgb_controllers);
     DetectSteelSeriesControllers(rgb_controllers);
     DetectGloriousModelOControllers(rgb_controllers);
+    DetectDuckyKeyboardControllers(rgb_controllers);
+    DetectEKControllers(rgb_controllers);
 
     DetectE131Controllers(rgb_controllers);
 

OpenRGB.pro

@@ -16,7 +16,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 #-----------------------------------------------------------------------#
 # Application Configuration                                             #
 #-----------------------------------------------------------------------#
-VERSION     = 0.21
+VERSION     = 0.31
 TARGET      = OpenRGB
 TEMPLATE    = app
 
@@ -58,13 +58,17 @@ INCLUDEPATH +=                                                          \
     Controllers/CorsairVengeanceController/                             \
     Controllers/CorsairVengeanceProController/                          \
     Controllers/CrucialController/                                      \
+    Controllers/DuckyKeyboardController/                                \
+    Controllers/GalaxGPUController/                                     \
     Controllers/GloriousModelOController/                               \
     Controllers/HuePlusController/                                      \
     Controllers/HyperXDRAMController/                                   \
     Controllers/HyperXKeyboardController/                               \
+    Controllers/HyperXMouseController/                                  \
     Controllers/LEDStripController/                                     \
     Controllers/LogitechController/                                     \
     Controllers/MSI3ZoneController/                                     \
+    Controllers/MSIGPUController/                                       \
     Controllers/MSIMysticLightController/                               \
     Controllers/MSIRGBController/                                       \
     Controllers/NZXTHue2Controller/                                     \
@@ -78,6 +82,7 @@ INCLUDEPATH +=                                                          \
     Controllers/RGBFusion2SMBusController/                              \
     Controllers/RGBFusion2USBController/                                \
     Controllers/RGBFusionGPUController/                                 \
+    Controllers/SapphireGPUController/                                  \
     Controllers/SteelSeriesController/                                  \
     Controllers/ThermaltakeRiingController/                             \
     RGBController/                                                      \
@@ -89,12 +94,14 @@ HEADERS +=                                                              \
     NetworkProtocol.h                                                   \
     NetworkServer.h                                                     \
     ProfileManager.h                                                    \
+    qt/OpenRGBClientInfoPage.h                                          \
     qt/OpenRGBDeviceInfoPage.h                                          \
     qt/OpenRGBDevicePage.h                                              \
     qt/OpenRGBDialog.h                                                  \
     i2c_smbus/i2c_smbus.h                                               \
     i2c_tools/i2c_tools.h                                               \
     net_port/net_port.h                                                 \
+    qt/DeviceView.h                                                     \
     qt/OpenRGBDialog2.h                                                 \
     qt/OpenRGBProfileSaveDialog.h                                       \
     qt/OpenRGBServerInfoPage.h                                          \
@@ -117,15 +124,21 @@ HEADERS +=                                                              \
     Controllers/CorsairVengeanceController/CorsairVengeanceController.h \
     Controllers/CorsairVengeanceProController/CorsairVengeanceProController.h \
     Controllers/CrucialController/CrucialController.h                   \
+    Controllers/DuckyKeyboardController/DuckyKeyboardController.h       \
+    Controllers/EKController/EKController.h                             \
+    Controllers/GalaxGPUController/GalaxGPUController.h                 \ 
     Controllers/GloriousModelOController/GloriousModelOController.h     \
     Controllers/HuePlusController/HuePlusController.h                   \
     Controllers/HyperXDRAMController/HyperXDRAMController.h             \
+    Controllers/HyperXKeyboardController/HyperXAlloyOriginsController.h \
     Controllers/HyperXKeyboardController/HyperXKeyboardController.h     \
+    Controllers/HyperXMouseController/HyperXPulsefireSurgeController..h \
     Controllers/LEDStripController/LEDStripController.h                 \
     Controllers/LogitechController/LogitechG203Controller.h             \
     Controllers/LogitechController/LogitechG403Controller.h             \
     Controllers/LogitechController/LogitechG810Controller.h             \
     Controllers/MSI3ZoneController/MSI3ZoneController.h                 \
+    Controllers/MSIGPUController/MSIGPUController.h                     \
     Controllers/MSIMysticLightController/MSIMysticLightController.h     \
     Controllers/MSIRGBController/MSIRGBController.h                     \
     Controllers/NZXTHue2Controller/NZXTHue2Controller.h                 \
@@ -140,8 +153,10 @@ HEADERS +=                                                              \
     Controllers/RGBFusionGPUController/RGBFusionGPUController.h         \
     Controllers/RedragonController/RedragonK556Controller.h             \
     Controllers/RedragonController/RedragonM711Controller.h             \
+    Controllers/SapphireGPUController/SapphireGPUController.h           \
     Controllers/SteelSeriesController/SteelSeriesRivalController.h      \
     Controllers/SteelSeriesController/SteelSeriesSiberiaController.h    \
+    Controllers/SteelSeriesController/SteelSeriesApexController.h       \
     Controllers/ThermaltakeRiingController/ThermaltakeRiingController.h \
     RGBController/RGBController.h                                       \
     RGBController/RGBController_AMDWraithPrism.h                        \
@@ -155,17 +170,24 @@ HEADERS +=                                                              \
     RGBController/RGBController_CorsairVengeance.h                      \
     RGBController/RGBController_CorsairVengeancePro.h                   \
     RGBController/RGBController_Crucial.h                               \
+    RGBController/RGBController_DuckyKeyboard.h                         \
     RGBController/RGBController_Dummy.h                                 \
+    RGBController/RGBController_EKController.h                          \
     RGBController/RGBController_E131.h                                  \
+    RGBController/RGBController_GalaxGPU.h                              \
     RGBController/RGBController_GloriousModelO.h                        \
     RGBController/RGBController_HuePlus.h                               \
+    RGBController/RGBController_HyperXAlloyOrigins.h                    \
     RGBController/RGBController_HyperXDRAM.h                            \
     RGBController/RGBController_HyperXKeyboard.h                        \
+    RGBController/RGBController_HyperXPulsefireSurge.h                  \
     RGBController/RGBController_LEDStrip.h                              \
     RGBController/RGBController_LogitechG203.h                          \
     RGBController/RGBController_LogitechG403.h                          \
     RGBController/RGBController_LogitechG810.h                          \
     RGBController/RGBController_MSI3Zone.h                              \
+    RGBController/RGBController_MSIGPU.h                                \
+    RGBController/RGBController_MSIGPU.h                                \
     RGBController/RGBController_MSIMysticLight.h                        \
     RGBController/RGBController_MSIRGB.h                                \
     RGBController/RGBController_Network.h                               \
@@ -181,11 +203,14 @@ HEADERS +=                                                              \
     RGBController/RGBController_RGBFusion2SMBus.h                       \
     RGBController/RGBController_RGBFusion2USB.h                         \
     RGBController/RGBController_RGBFusionGPU.h                          \
+    RGBController/RGBController_SapphireGPU.h                           \
     RGBController/RGBController_SteelSeriesRival.h                      \
     RGBController/RGBController_SteelSeriesSiberia.h                    \
+    RGBController/RGBController_SteelSeriesApex.h                       \
     RGBController/RGBController_ThermaltakeRiing.h                      \
 
 SOURCES +=                                                              \
+    dependencies/dmiinfo.cpp                                            \
     dependencies/ColorWheel/ColorWheel.cpp                              \
     dependencies/libe131/src/e131.c                                     \
     main.cpp                                                            \
@@ -194,12 +219,14 @@ SOURCES +=                                                              \
     NetworkClient.cpp                                                   \
     NetworkServer.cpp                                                   \
     ProfileManager.cpp                                                  \
+    qt/OpenRGBClientInfoPage.cpp                                        \
     qt/OpenRGBDeviceInfoPage.cpp                                        \
     qt/OpenRGBDevicePage.cpp                                            \
     qt/OpenRGBDialog.cpp                                                \
     i2c_smbus/i2c_smbus.cpp                                             \
     i2c_tools/i2c_tools.cpp                                             \
     net_port/net_port.cpp                                               \
+    qt/DeviceView.cpp                                                   \
     qt/OpenRGBDialog2.cpp                                               \
     qt/OpenRGBProfileSaveDialog.cpp                                     \
     qt/OpenRGBServerInfoPage.cpp                                        \
@@ -233,14 +260,23 @@ SOURCES +=                                                              \
     Controllers/CorsairVengeanceProController/CorsairVengeanceProControllerDetect.cpp \
     Controllers/CrucialController/CrucialController.cpp                 \
     Controllers/CrucialController/CrucialControllerDetect.cpp           \
+    Controllers/DuckyKeyboardController/DuckyKeyboardController.cpp     \
+    Controllers/DuckyKeyboardController/DuckyKeyboardControllerDetect.cpp \
+    Controllers/EKController/EKControllerDetect.cpp                     \
+    Controllers/EKController/EKController.cpp                           \
+    Controllers/GalaxGPUController/GalaxGPUController.cpp               \
+    Controllers/GalaxGPUController/GalaxGPUControllerDetect.cpp         \
     Controllers/GloriousModelOController/GloriousModelOController.cpp   \
     Controllers/GloriousModelOController/GloriousModelOControllerDetect.cpp \
     Controllers/HuePlusController/HuePlusController.cpp                 \
     Controllers/HuePlusController/HuePlusControllerDetect.cpp           \
     Controllers/HyperXDRAMController/HyperXDRAMController.cpp           \
     Controllers/HyperXDRAMController/HyperXDRAMControllerDetect.cpp     \
+    Controllers/HyperXKeyboardController/HyperXAlloyOriginsController.cpp \
     Controllers/HyperXKeyboardController/HyperXKeyboardController.cpp   \
     Controllers/HyperXKeyboardController/HyperXKeyboardControllerDetect.cpp \
+    Controllers/HyperXMouseController/HyperXMouseControllerDetect.cpp   \
+    Controllers/HyperXMouseController/HyperXPulsefireSurgeController.cpp \
     Controllers/LEDStripController/LEDStripController.cpp               \
     Controllers/LEDStripController/LEDStripControllerDetect.cpp         \
     Controllers/LogitechController/LogitechControllerDetect.cpp         \
@@ -249,6 +285,8 @@ SOURCES +=                                                              \
     Controllers/LogitechController/LogitechG810Controller.cpp           \
     Controllers/MSI3ZoneController/MSI3ZoneController.cpp               \
     Controllers/MSI3ZoneController/MSI3ZoneControllerDetect.cpp         \
+    Controllers/MSIGPUController/MSIGPUController.cpp                   \
+    Controllers/MSIGPUController/MSIGPUControllerDetect.cpp             \
     Controllers/MSIMysticLightController/MSIMysticLightController.cpp   \
     Controllers/MSIMysticLightController/MSIMysticLightControllerDetect.cpp \
     Controllers/MSIRGBController/MSIRGBController.cpp                   \
@@ -276,8 +314,11 @@ SOURCES +=                                                              \
     Controllers/RedragonController/RedragonK556Controller.cpp           \
     Controllers/RedragonController/RedragonM711Controller.cpp           \
     Controllers/RedragonController/RedragonControllerDetect.cpp         \
+    Controllers/SapphireGPUController/SapphireGPUController.cpp         \
+    Controllers/SapphireGPUController/SapphireGPUControllerDetect.cpp   \
     Controllers/SteelSeriesController/SteelSeriesRivalController.cpp    \
     Controllers/SteelSeriesController/SteelSeriesSiberiaController.cpp  \
+    Controllers/SteelSeriesController/SteelSeriesApexController.cpp     \
     Controllers/SteelSeriesController/SteelSeriesControllerDetect.cpp   \
     Controllers/ThermaltakeRiingController/ThermaltakeRiingController.cpp \
     Controllers/ThermaltakeRiingController/ThermaltakeRiingControllerDetect.cpp \
@@ -294,17 +335,23 @@ SOURCES +=                                                              \
     RGBController/RGBController_CorsairVengeance.cpp                    \
     RGBController/RGBController_CorsairVengeancePro.cpp                 \
     RGBController/RGBController_Crucial.cpp                             \
+    RGBController/RGBController_DuckyKeyboard.cpp                       \
     RGBController/RGBController_Dummy.cpp                               \
+    RGBController/RGBController_EKController.cpp                        \
+    RGBController/RGBController_GalaxGPU.cpp                            \
     RGBController/RGBController_GloriousModelO.cpp                      \
     RGBController/RGBController_HuePlus.cpp                             \
+    RGBController/RGBController_HyperXAlloyOrigins.cpp                  \
     RGBController/RGBController_HyperXDRAM.cpp                          \
     RGBController/RGBController_HyperXKeyboard.cpp                      \
+    RGBController/RGBController_HyperXPulsefireSurge.cpp                \
     RGBController/RGBController_E131.cpp                                \
     RGBController/RGBController_LEDStrip.cpp                            \
     RGBController/RGBController_LogitechG203.cpp                        \
     RGBController/RGBController_LogitechG403.cpp                        \
     RGBController/RGBController_LogitechG810.cpp                        \
     RGBController/RGBController_MSI3Zone.cpp                            \
+    RGBController/RGBController_MSIGPU.cpp                              \
     RGBController/RGBController_MSIMysticLight.cpp                      \
     RGBController/RGBController_MSIRGB.cpp                              \
     RGBController/RGBController_Network.cpp                             \
@@ -320,14 +367,17 @@ SOURCES +=                                                              \
     RGBController/RGBController_RGBFusion2SMBus.cpp                     \
     RGBController/RGBController_RGBFusion2USB.cpp                       \
     RGBController/RGBController_RGBFusionGPU.cpp                        \
+    RGBController/RGBController_SapphireGPU.cpp                         \
     RGBController/RGBController_SteelSeriesRival.cpp                    \
     RGBController/RGBController_SteelSeriesSiberia.cpp                  \
+    RGBController/RGBController_SteelSeriesApex.cpp                     \
     RGBController/RGBController_ThermaltakeRiing.cpp                    \
 
 RESOURCES +=                                                            \
     qt/resources.qrc
 
-FORMS += \
+FORMS +=                                                                \
+    qt/OpenRGBClientInfoPage.ui                                         \
     qt/OpenRGBDeviceInfoPage.ui                                         \
     qt/OpenRGBDevicePage.ui                                             \
     qt/OpenRGBDialog.ui                                                 \
@@ -351,7 +401,7 @@ win32:INCLUDEPATH +=                                                    \
     wmi/                                                                \
 
 win32:SOURCES +=                                                        \
-    dependencies/hidapi/hidapi.c                                        \
+#   dependencies/hidapi/hidapi.c                                        \
     dependencies/NVFC/nvapi.cpp                                         \
     i2c_smbus/i2c_smbus_amdadl.cpp                                      \
     i2c_smbus/i2c_smbus_i801.cpp                                        \
@@ -381,6 +431,7 @@ win32:contains(QMAKE_TARGET.arch, x86_64) {
         -lws2_32                                                        \
         -L"$$PWD/dependencies/inpout32_1501/x64/" -linpoutx64           \
         -L"$$PWD/dependencies/libusb-1.0.22/MS64/dll" -llibusb-1.0      \
+        -L"$$PWD/dependencies/hidapi-win/x64/" -lhidapi                 \
 }
 
 win32:contains(QMAKE_TARGET.arch, x86) {
@@ -388,17 +439,19 @@ win32:contains(QMAKE_TARGET.arch, x86) {
         -lws2_32                                                        \
         -L"$$PWD/dependencies/inpout32_1501/Win32/" -linpout32          \
         -L"$$PWD/dependencies/libusb-1.0.22/MS32/dll" -llibusb-1.0      \
+        -L"$$PWD/dependencies/hidapi-win/x86/" -lhidapi                 \
 }
 
 win32:DEFINES -=                                                        \
     UNICODE
 
 win32:DEFINES +=                                                        \
+    USE_HID_USAGE                                                       \
     _MBCS                                                               \
     WIN32                                                               \
     _CRT_SECURE_NO_WARNINGS                                             \
     _WINSOCK_DEPRECATED_NO_WARNINGS                                     \
-    WIN32_LEAN_AND_MEAN
+    WIN32_LEAN_AND_MEAN                                                 \
 
 win32:RC_ICONS +=                                                       \
     qt/OpenRGB.ico
@@ -427,6 +480,7 @@ win32:contains(QMAKE_TARGET.arch, x86_64) {
     copydata.commands  = $(COPY_FILE) \"$$shell_path($$PWD/dependencies/openrazer-win32/OpenRazer64.dll      )\" \"$$shell_path($$DESTDIR)\" $$escape_expand(\n\t)
     copydata.commands += $(COPY_FILE) \"$$shell_path($$PWD/dependencies/inpout32_1501/x64/inpoutx64.dll      )\" \"$$shell_path($$DESTDIR)\" $$escape_expand(\n\t)
     copydata.commands += $(COPY_FILE) \"$$shell_path($$PWD/dependencies/libusb-1.0.22/MS64/dll/libusb-1.0.dll)\" \"$$shell_path($$DESTDIR)\" $$escape_expand(\n\t)
+    copydata.commands += $(COPY_FILE) \"$$shell_path($$PWD/dependencies/hidapi-win/x64/hidapi.dll            )\" \"$$shell_path($$DESTDIR)\" $$escape_expand(\n\t)
     first.depends = $(first) copydata
     export(first.depends)
     export(copydata.commands)
@@ -437,6 +491,7 @@ win32:contains(QMAKE_TARGET.arch, x86) {
     copydata.commands  = $(COPY_FILE) \"$$shell_path($$PWD/dependencies/openrazer-win32/OpenRazer.dll        )\" \"$$shell_path($$DESTDIR)\" $$escape_expand(\n\t)
     copydata.commands += $(COPY_FILE) \"$$shell_path($$PWD/dependencies/inpout32_1501/Win32/inpout32.dll     )\" \"$$shell_path($$DESTDIR)\" $$escape_expand(\n\t)
     copydata.commands += $(COPY_FILE) \"$$shell_path($$PWD/dependencies/libusb-1.0.22/MS32/dll/libusb-1.0.dll)\" \"$$shell_path($$DESTDIR)\" $$escape_expand(\n\t)
+    copydata.commands += $(COPY_FILE) \"$$shell_path($$PWD/dependencies/hidapi-win/x86/hidapi.dll            )\" \"$$shell_path($$DESTDIR)\" $$escape_expand(\n\t)
 
     first.depends = $(first) copydata
     export(first.depends)
@@ -495,6 +550,13 @@ unix:!macx {
     INSTALLS += target desktop pixmap
 }
 
+unix:!macx:CONFIG(asan) {
+    message("ASan Mode")
+    QMAKE_CFLAGS=-fsanitize=address
+    QMAKE_CXXFLAGS=-fsanitize=address
+    QMAKE_LFLAGS=-fsanitize=address
+}
+
 #-----------------------------------------------------------------------#
 # MacOS-specific Configuration                                          #
 #-----------------------------------------------------------------------#

README.md

@@ -1,7 +1,17 @@
 ## ![OpenRGB](https://gitlab.com/CalcProgrammer1/OpenRGB/-/wikis/uploads/5b7e633ac9f63b00c8a4c72686206c3f/OpenRGB.png) (formerly OpenAuraSDK)
 
 One of the biggest complaints about RGB is the software ecosystem surrounding it.  Every manufacturer has their own app, their own brand, their own style.  If you want to mix and match devices, you end up with a ton of conflicting, functionally identical apps competing for your background resources.  On top of that, these apps are proprietary and Windows-only.  Some even require online accounts.  What if there was a way to control all of your RGB devices from a single app, on both Windows and Linux, without any nonsense?  That is what OpenRGB sets out to achieve.  One app to rule them all.
-OpenRGB is still in its early stages and already supports quite a few products.  I'm always on the lookout for good deals on more popular RGB devices to add support for.
+
+## Features
+
+* Set colors and select effect modes for a wide variety of RGB hardware
+* Save and load profiles
+* Control lighting from third party software using the OpenRGB SDK
+* Command line interface
+* Connect multiple instances of OpenRGB to synchronize lighting across multiple PCs
+* Can operate standalone or in a client/headless server configuration
+* View device information
+* No official/manufacturer software required
 
 ## Supported Devices
 
@@ -9,37 +19,34 @@ See the [Project Wiki](https://gitlab.com/CalcProgrammer1/OpenRGB/-/wikis/home)
 
 ## WARNING!
 
-This project provides a tool to probe the SMBus.  This is a potentially dangerous operation if you don't know what you're doing.  Exercise caution when clicking the Detect Devices or Dump Device buttons.  There have been reports of Gigabyte motherboards having serious issues (bricking the RGB or bricking the entire board) when dumping certain devices.  On the same lines, exercise the same caution when using the i2cdump and i2cdetect commands on Linux, as they perform the same functionality.  OpenRGB is not liable for damage caused by improper SMBus access.
+This project interacts directly with hardware using reverse engineered protocols.  While we do our best to make sure we're sending the right data, there is always some risk in sending data to hardware when we don't understand exactly how that hardware works.
 
-As of now, only Gigabyte RGB Fusion 2.0 boards have been reported to have issues.
+There have been two instances of hardware damage in OpenRGB's development and we've taken precautions to prevent it from happening again.
+
+  * The MSI Mystic Light code reportedly bricked the RGB on certain MSI boards when sending certain modes.  This code has been disabled and MSI Mystic Light motherboards will not work with OpenRGB at this time.
+  * There were reports of bricked Gigabyte Aorus Z390 motherboards caused by dumping SMBus address 0x68 in an attempt to reverse engineer the RGB.  Due to this, the SMBus Tools page on OpenRGB is hidden by default now as it has no real use to non-developers.  Additionally, the RGB Fusion 2 SMBus code is disabled by default because, although it works on boards it is meant for, probing this address (0x68) could damage Gigabyte Z390 boards.
+  * To enable the MSI Mystic Light or Gigabyte RGB Fusion 2 SMBus code, you must uncomment the functions in main.cpp and recompile.
 
 ![OpenRGB_0.11](https://gitlab.com/CalcProgrammer1/OpenRGB/-/wikis/uploads/0ef8eb3936fe715217e7e3430c0aae18/OpenRGB_new_icons.PNG)
 
 ## Windows
+
   *  Pre-built binaries are available under the Releases section on GitLab.
-
   *  If you wish to build the application yourself:
-
       1. Download the latest Visual Studio Community Edition and Qt Creator.
       2. Open the OpenRGB.pro project in Qt Creator.
       3. Use the MSVC compiler kit, either 32- or 64-bit, to build the application.
       4. Run the project from Qt Creator.  If you want to use your custom build standalone, download the latest matching Release package and replace the OpenRGB.exe in it with your new build.
-
   *  **You must run the application as Administrator the first time to allow InpOut32 to set up.  It can be run as a normal user afterwards**
 
 ### USB Access
 
-  *  Some USB devices (especially keyboards and mice) require installation of the WinUSB driver.  You can do this with Zadig:
-      - Download Zadig:  https://zadig.akeo.ie/
-      - Select "list all devices" from the menu
-      - Select the last interface (highest number) of your device
-      - With "WinUSB" selected, click Install
+  *  Previous versions of OpenRGB used the WinUSB driver, installed using Zadig.  This is no longer required, and you need to uninstall the WinUSB driver if you previously installed it.  You can uninstall the WinUSB driver by following [this guide](https://gitlab.com/CalcProgrammer1/OpenRGB/-/wikis/Frequently-Asked-Questions#i-installed-the-winusb-driver-for-a-device-and-i-wish-to-uninstall-it).
 
 ## Linux
+
   *  Pre-built binaries are not currently available for Linux
-
   *  You can build the project using Qt Creator or on the command line.
-
       1.  Install build dependencies
           - Debian: sudo apt install build-essential qtcreator qt5-default libusb-1.0-0-dev libhidapi-dev pkgconf
           - Fedora: sudo dnf install git make automake gcc gcc-c++ qt-creator qt5-devel hidapi-devel libusb-devel
@@ -47,22 +54,15 @@ As of now, only Gigabyte RGB Fusion 2.0 boards have been reported to have issues
       3.  cd OpenRGB
       4.  qmake OpenRGB.pro
       5.  make -j8
-    
-
   *  Run the application with ./OpenRGB
      
 ### SMBus Access
 
   *  SMBus access is necessary for controlling RGB RAM and certain motherboard on-board LEDs.
-
   *  If you are not trying to use OpenRGB to control RGB RAM or motherboard LEDs, you may skip this section.
-
   *  ASUS and ASRock motherboards have their RGB controller on an SMBus interface that is not accessible by an unmodified Linux kernel (for now).  I am working on getting patches submitted upstream, but for now you must patch your kernel with the provided OpenRGB.patch file.
-
   *  Allowing access to SMBus:
-
       1. Load the i2c-dev module: `sudo modprobe i2c-dev`
-
       2. Load the i2c driver for your chipset:
           -  Intel:
               - `sudo modprobe i2c-i801`
@@ -70,13 +70,10 @@ As of now, only Gigabyte RGB Fusion 2.0 boards have been reported to have issues
           -  AMD:
               - `modprobe i2c-piix4` 
               - Unmodified kernel will have one interface, patched kernel will have two.  The first at 0x0B00 and the second at 0x0B20.  The 0x0B20 interface is for motherboard LEDs.
-
   *  Instructions on patching the kernel:
       - https://gitlab.com/CalcProgrammer1/OpenRGB/-/wikis/OpenRGB-Kernel-Patch
-       
   *  Some Gigabyte/Aorus motherboards have an ACPI conflict with the SMBus controller.
       - Add `acpi_enforce_resources=lax` to your kernel command line and reboot.  The controller should now show up.
-
   *  You'll have to enable user access to your SMBus if you don't run as root.
       - List all SMBus controllers: `sudo i2cdetect -l`
       - Note the number for PIIX4, I801, and NCT6775 controllers.
@@ -85,9 +82,7 @@ As of now, only Gigabyte RGB Fusion 2.0 boards have been reported to have issues
 ### USB Access
 
   *  USB devices require udev rules to access as a normal user.
-
   *  You can run OpenRGB as root to detect all USB devices.
-
   *  Udev rules are included in this repo:
       - Copy the 60-openrgb.rules file to /etc/udev/rules.d/
       - Reload rules with `sudo udevadm control --reload-rules && sudo udevadm trigger`
@@ -97,37 +92,23 @@ As of now, only Gigabyte RGB Fusion 2.0 boards have been reported to have issues
 OpenRGB provides a network interface for controlling supported RGB devices from other software.  These projects implement the OpenRGB SDK and provide additional ways for you to control your lighting setup.
 
   * Keyboard Visualizer (by me): https://gitlab.com/CalcProgrammer1/KeyboardVisualizer
-
   * OpenRGB Python Client (by bahorn): https://github.com/bahorn/OpenRGB-PyClient
-
   * OpenRGB Python Client (by jath03): https://github.com/jath03/openrgb-python
-
   * OpenRGB Node.js Client (by vlakreeh): https://github.com/vlakreeh/openrgb
-
   * D-Bus Connector for OpenRGB (by Vinno97): https://github.com/Vinno97/OpenRGB-DBus-Connector
-
   * OpenRGB E1.31 Receiver (by me): https://gitlab.com/CalcProgrammer1/OpenRGBE131Receiver
-
   * OpenRGB.NET - C# OpenRGB Client (by diogotr7): https://github.com/diogotr7/OpenRGB.NET
 
 ## Projects Used
 
   * InpOutx64: http://www.highrez.co.uk/downloads/inpout32/
-
   * libusb: https://github.com/libusb/libusb
-
   * hidapi: https://github.com/libusb/hidapi
-
   * libe131: https://github.com/hhromic/libe131
-
   * NVFC: https://github.com/graphitemaster/NVFC
-
   * OpenRazer: https://github.com/openrazer/openrazer
-
   * OpenRazer-Win32: https://github.com/CalcProgrammer1/openrazer-win32
-
   * Qt-Plus (ColorWheel): https://github.com/liuyanghejerry/Qt-Plus
-  
   * AMD ADL Libraries: https://github.com/GPUOpen-LibrariesAndSDKs/display-library
   
 ## Projects Researched
@@ -135,31 +116,17 @@ OpenRGB provides a network interface for controlling supported RGB devices from
 While no code from these projects directly made its way into OpenRGB, these projects have been invaluable resources for protocol information.
 
   * ckb-next: https://github.com/ckb-next/ckb-next
-
   * linux_thermaltake_riing: https://github.com/chestm007/linux_thermaltake_riing
-
   * Aura Addressable Header Controller: https://gitlab.com/cneil02/aura-addressable-header-controller
-
   * OpenPyAURA: https://gitlab.com/thelastguardian/openpyaura
-
   * AsrLed: https://github.com/EUA/AsrLed
-
   * asrock-leds: https://github.com/RattyDAVE/asrock-leds
-
   * hue-plus: https://github.com/kusti8/hue-plus
-
   * rogauracore: https://github.com/wroberts/rogauracore
-
   * msi-rgb: https://github.com/nagisa/msi-rgb
-
   * OpenCorsairLink: https://github.com/audiohacked/OpenCorsairLink
-
   * msi-keyboard: https://github.com/bparker06/msi-keyboard
-
   * rivalcfg: https://github.com/flozz/rivalcfg
-  
   * VRMTool: https://github.com/rbrune/VRMtool
-
   * g810-led: https://github.com/MatMoul/g810-led
-
   * liquidctl: https://github.com/jonasmalacofilho/liquidctl

RGBController/RGBController.cpp

@@ -894,6 +894,14 @@ void RGBController::SetModeDescription(unsigned char* data_buf)
     memcpy(&mode_idx, &data_buf[data_ptr], sizeof(int));
     data_ptr += sizeof(int);
 
+    /*---------------------------------------------------------*\
+    | Check if we aren't reading beyond the list of modes.      |
+    \*---------------------------------------------------------*/
+    if(((size_t) mode_idx) >  modes.size())
+    {
+        return;
+    }
+
     /*---------------------------------------------------------*\
     | Get pointer to target mode                                |
     \*---------------------------------------------------------*/
@@ -990,8 +998,6 @@ void RGBController::SetModeDescription(unsigned char* data_buf)
 
         new_mode->colors.push_back(new_color);
     }
-
-    printf("read data ptr %d\r\n", data_ptr);
 }
 
 unsigned char * RGBController::GetColorDescription()
@@ -1051,6 +1057,14 @@ void RGBController::SetColorDescription(unsigned char* data_buf)
     memcpy(&num_colors, &data_buf[data_ptr], sizeof(unsigned short));
     data_ptr += sizeof(unsigned short);
 
+    /*---------------------------------------------------------*\
+    | Check if we aren't reading beyond the list of colors.     |
+    \*---------------------------------------------------------*/
+    if(((size_t) num_colors) > colors.size())
+    {
+        return;
+    }
+
     /*---------------------------------------------------------*\
     | Copy in colors                                            |
     \*---------------------------------------------------------*/
@@ -1132,6 +1146,14 @@ void RGBController::SetZoneColorDescription(unsigned char* data_buf)
     memcpy(&zone_idx, &data_buf[data_ptr], sizeof(zone_idx));
     data_ptr += sizeof(zone_idx);
 
+    /*---------------------------------------------------------*\
+    | Check if we aren't reading beyond the list of zones.      |
+    \*---------------------------------------------------------*/
+    if(((size_t) zone_idx) > zones.size())
+    {
+        return;
+    }
+
     /*---------------------------------------------------------*\
     | Copy in number of colors (data)                           |
     \*---------------------------------------------------------*/
@@ -1186,12 +1208,20 @@ void RGBController::SetSingleLEDColorDescription(unsigned char* data_buf)
     |       RGBColor: LED color                                 |
     \*---------------------------------------------------------*/
     int led_idx;
-    
+
     /*---------------------------------------------------------*\
     | Copy in LED index                                         |
     \*---------------------------------------------------------*/
     memcpy(&led_idx, &data_buf[0], sizeof(led_idx));
 
+    /*---------------------------------------------------------*\
+    | Check if we aren't reading beyond the list of leds.       |
+    \*---------------------------------------------------------*/
+    if(((size_t) led_idx) > leds.size())
+    {
+        return;
+    }
+
     /*---------------------------------------------------------*\
     | Copy in LED color                                         |
     \*---------------------------------------------------------*/
@@ -1266,8 +1296,6 @@ void RGBController::SetLED(unsigned int led, RGBColor color)
     if(led < colors.size())
     {
         colors[led] = color;
-
-        UpdateSingleLED(led);
     }
 }
 
@@ -1277,8 +1305,6 @@ void RGBController::SetAllLEDs(RGBColor color)
     {
         SetAllZoneLEDs(zone_idx, color);
     }
-
-    UpdateLEDs();
 }
 
 void RGBController::SetAllZoneLEDs(int zone, RGBColor color)
@@ -1287,8 +1313,6 @@ void RGBController::SetAllZoneLEDs(int zone, RGBColor color)
     {
         zones[zone].colors[color_idx] = color;
     }
-
-    UpdateZoneLEDs(zone);
 }
 
 int RGBController::GetMode()
@@ -1303,9 +1327,36 @@ void RGBController::SetMode(int mode)
     UpdateMode();
 }
 
+void RGBController::RegisterUpdateCallback(RGBControllerCallback new_callback, void * new_callback_arg)
+{
+    UpdateCallbacks.push_back(new_callback);
+    UpdateCallbackArgs.push_back(new_callback_arg);
+}
+
+void RGBController::SignalUpdate()
+{
+    UpdateMutex.lock();
+
+    /*-------------------------------------------------*\
+    | Client info has changed, call the callbacks       |
+    \*-------------------------------------------------*/
+    for(unsigned int callback_idx = 0; callback_idx < UpdateCallbacks.size(); callback_idx++)
+    {
+        UpdateCallbacks[callback_idx](UpdateCallbackArgs[callback_idx]);
+    }
+
+    UpdateMutex.unlock();
+}
 void RGBController::UpdateLEDs()
 {
     CallFlag_UpdateLEDs = true;
+
+    SignalUpdate();
+}
+
+void RGBController::UpdateMode()
+{
+    CallFlag_UpdateMode = true;
 }
 
 void RGBController::DeviceUpdateLEDs()
@@ -1313,12 +1364,23 @@ void RGBController::DeviceUpdateLEDs()
 
 }
 
+void RGBController::DeviceUpdateMode()
+{
+
+}
+
 void RGBController::DeviceCallThreadFunction()
 {
     CallFlag_UpdateLEDs = false;
+    CallFlag_UpdateMode = false;
 
     while(DeviceThreadRunning.load() == true)
     {
+        if(CallFlag_UpdateMode.load() == true)
+        {
+            DeviceUpdateMode();
+            CallFlag_UpdateMode = false;
+        }
         if(CallFlag_UpdateLEDs.load() == true)
         {
             DeviceUpdateLEDs();

RGBController/RGBController.h

@@ -14,6 +14,7 @@
 #include <string>
 #include <thread>
 #include <chrono>
+#include <mutex>
 
 typedef unsigned int RGBColor;
 
@@ -139,6 +140,8 @@ typedef struct
     matrix_map_type *       matrix_map;     /* Matrix map pointer       */
 } zone;
 
+typedef void (*RGBControllerCallback)(void *);
+
 class RGBController
 {
 public:
@@ -188,11 +191,14 @@ public:
     unsigned char *         GetSingleLEDColorDescription(int led);
     void                    SetSingleLEDColorDescription(unsigned char* data_buf);
 
+    void                    RegisterUpdateCallback(RGBControllerCallback new_callback, void * new_callback_arg);
+    void                    SignalUpdate();
+
     void                    UpdateLEDs();
     //void                    UpdateZoneLEDs(int zone);
     //void                    UpdateSingleLED(int led);
 
-    //void                    UpdateMode();
+    void                    UpdateMode();
 
     void                    DeviceCallThreadFunction();
 
@@ -207,15 +213,20 @@ public:
     virtual void            UpdateZoneLEDs(int zone)                    = 0;
     virtual void            UpdateSingleLED(int led)                    = 0;
 
-    virtual void            UpdateMode()                                = 0;
+    virtual void            DeviceUpdateMode()                          = 0;
 
     virtual void            SetCustomMode()                             = 0;
 
 private:
     std::thread*            DeviceCallThread;
     std::atomic<bool>       CallFlag_UpdateLEDs;
+    std::atomic<bool>       CallFlag_UpdateMode;
     std::atomic<bool>       DeviceThreadRunning;
     //bool                    CallFlag_UpdateZoneLEDs                     = false;
     //bool                    CallFlag_UpdateSingleLED                    = false;
     //bool                    CallFlag_UpdateMode                         = false;
+
+    std::mutex                          UpdateMutex;
+    std::vector<RGBControllerCallback>  UpdateCallbacks;
+    std::vector<void *>                 UpdateCallbackArgs;
 };

RGBController/RGBController_AMDWraithPrism.cpp

@@ -199,7 +199,7 @@ void RGBController_AMDWraithPrism::SetCustomMode()
     active_mode = 0;
 }
 
-void RGBController_AMDWraithPrism::UpdateMode()
+void RGBController_AMDWraithPrism::DeviceUpdateMode()
 {
     bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
 

RGBController/RGBController_AMDWraithPrism.h

@@ -26,7 +26,7 @@ public:
     void        UpdateSingleLED(int led);
 
     void        SetCustomMode();
-    void        UpdateMode();
+    void        DeviceUpdateMode();
 
 private:
     AMDWraithPrismController*   wraith;

RGBController/RGBController_AuraCore.cpp

@@ -102,7 +102,7 @@ void RGBController_AuraCore::SetCustomMode()
     active_mode = 0;
 }
 
-void RGBController_AuraCore::UpdateMode()
+void RGBController_AuraCore::DeviceUpdateMode()
 {
     DeviceUpdateLEDs();
 }

RGBController/RGBController_AuraCore.h

@@ -25,7 +25,7 @@ public:
     void        UpdateSingleLED(int led);
 
     void        SetCustomMode();
-    void        UpdateMode();
+    void        DeviceUpdateMode();
 
 private:
     AuraCoreController* aura;

RGBController/RGBController_AuraGPU.cpp

@@ -173,7 +173,7 @@ void RGBController_AuraGPU::SetCustomMode()
     active_mode = 0;
 }
 
-void RGBController_AuraGPU::UpdateMode()
+void RGBController_AuraGPU::DeviceUpdateMode()
 {
     int new_mode = modes[active_mode].value;
     aura_gpu->direct = false;

RGBController/RGBController_AuraGPU.h

@@ -25,7 +25,7 @@ public:
     void        UpdateSingleLED(int led);
 
     void        SetCustomMode();
-    void        UpdateMode();
+    void        DeviceUpdateMode();
 
 private:
     AuraGPUController* aura_gpu;

RGBController/RGBController_AuraSMBus.cpp

@@ -330,7 +330,7 @@ void RGBController_AuraSMBus::SetCustomMode()
     active_mode = 0;
 }
 
-void RGBController_AuraSMBus::UpdateMode()
+void RGBController_AuraSMBus::DeviceUpdateMode()
 {
     if (modes[active_mode].value == 0xFFFF)
     {

RGBController/RGBController_AuraSMBus.h

@@ -26,7 +26,7 @@ public:
     void        UpdateSingleLED(int led);
 
     void        SetCustomMode();
-    void        UpdateMode();
+    void        DeviceUpdateMode();
 
 private:
     AuraSMBusController* aura;

RGBController/RGBController_AuraUSB.cpp

@@ -175,6 +175,11 @@ void RGBController_AuraUSB::SetupZones()
 
 void RGBController_AuraUSB::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;
@@ -208,7 +213,7 @@ void RGBController_AuraUSB::SetCustomMode()
 
 }
 
-void RGBController_AuraUSB::UpdateMode()
+void RGBController_AuraUSB::DeviceUpdateMode()
 {
     unsigned char red = 0;
     unsigned char grn = 0;

RGBController/RGBController_AuraUSB.h

@@ -28,7 +28,7 @@ public:
     void        UpdateSingleLED(int led);
 
     void        SetCustomMode();
-    void        UpdateMode();
+    void        DeviceUpdateMode();
 
 private:
     AuraUSBController*  aura;

RGBController/RGBController_CMMP750Controller.cpp

@@ -11,14 +11,15 @@
 
 RGBController_CMMP750Controller::RGBController_CMMP750Controller(CMMP750Controller* cmmp_ptr)
 {
-    cmmp750     = cmmp_ptr;
+    cmmp750             = cmmp_ptr;
+    unsigned char speed = cmmp750->GetLedSpeed();
 
-    name        = cmmp750->GetDeviceName();
-    type        = DEVICE_TYPE_MOUSEMAT;
-    description = cmmp750->GetDeviceName();
-    version     = "1.0";
-    serial      = "";
-    location    = cmmp750->GetLocation();
+    name                = cmmp750->GetDeviceName();
+    type                = DEVICE_TYPE_MOUSEMAT;
+    description         = cmmp750->GetDeviceName();
+    version             = "1.0";
+    serial              = "";
+    location            = cmmp750->GetLocation();
 
     mode Static;
     Static.name       = "Static";
@@ -34,7 +35,7 @@ RGBController_CMMP750Controller::RGBController_CMMP750Controller(CMMP750Controll
     Blink.speed_min  = MP750_SPEED_SLOWEST;
     Blink.speed_max  = MP750_SPEED_FASTEST;
     Blink.color_mode = MODE_COLORS_PER_LED;
-    Blink.speed      = MP750_SPEED_NORMAL;
+    Blink.speed      = speed;
     modes.push_back(Blink);
 
     mode Breathing;
@@ -44,7 +45,7 @@ RGBController_CMMP750Controller::RGBController_CMMP750Controller(CMMP750Controll
     Breathing.speed_min  = MP750_SPEED_SLOWEST;
     Breathing.speed_max  = MP750_SPEED_FASTEST;
     Breathing.color_mode = MODE_COLORS_PER_LED;
-    Breathing.speed      = MP750_SPEED_NORMAL;
+    Breathing.speed      = speed;
     modes.push_back(Breathing);
 
     mode ColorCycle;
@@ -54,7 +55,7 @@ RGBController_CMMP750Controller::RGBController_CMMP750Controller(CMMP750Controll
     ColorCycle.speed_min  = MP750_SPEED_SLOWEST;
     ColorCycle.speed_max  = MP750_SPEED_FASTEST;
     ColorCycle.color_mode = MODE_COLORS_NONE;
-    ColorCycle.speed      = MP750_SPEED_NORMAL;
+    ColorCycle.speed      = speed;
     modes.push_back(ColorCycle);
 
     mode BreathCycle;
@@ -64,10 +65,11 @@ RGBController_CMMP750Controller::RGBController_CMMP750Controller(CMMP750Controll
     BreathCycle.speed_min  = MP750_SPEED_SLOWEST;
     BreathCycle.speed_max  = MP750_SPEED_FASTEST;
     BreathCycle.color_mode = MODE_COLORS_NONE;
-    BreathCycle.speed      = MP750_SPEED_NORMAL;
+    BreathCycle.speed      = speed;
     modes.push_back(BreathCycle);
 
     SetupZones();
+    active_mode = cmmp750->GetMode();
 }
 
 RGBController_CMMP750Controller::~RGBController_CMMP750Controller()
@@ -91,6 +93,18 @@ void RGBController_CMMP750Controller::SetupZones()
     leds.push_back(MP_led);
 
     SetupColors();
+
+    /*---------------------------------------------------------*\
+    | Initialize colors for each LED                            |
+    \*---------------------------------------------------------*/
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        unsigned char red = cmmp750->GetLedRed();
+        unsigned char grn = cmmp750->GetLedGreen();
+        unsigned char blu = cmmp750->GetLedBlue();
+
+        colors[led_idx] = ToRGBColor(red, grn, blu);
+    }
 }
 
 void RGBController_CMMP750Controller::ResizeZone(int /*zone*/, int /*new_size*/)
@@ -127,7 +141,7 @@ void RGBController_CMMP750Controller::SetCustomMode()
     active_mode = 0;
 }
 
-void RGBController_CMMP750Controller::UpdateMode()
+void RGBController_CMMP750Controller::DeviceUpdateMode()
 {
     switch(modes[active_mode].value)
     {

RGBController/RGBController_CMMP750Controller.h

@@ -25,7 +25,9 @@ public:
     void        UpdateSingleLED(int led);
 
     void        SetCustomMode();
-    void        UpdateMode();
+    void        DeviceUpdateMode();
 private:
     CMMP750Controller* cmmp750;
+
+    int         GetDeviceMode();
 };

RGBController/RGBController_CorsairLightingNode.cpp

@@ -231,6 +231,11 @@ void RGBController_CorsairLightingNode::SetupZones()
 
 void RGBController_CorsairLightingNode::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;
@@ -264,7 +269,7 @@ void RGBController_CorsairLightingNode::SetCustomMode()
     active_mode = 0;
 }
 
-void RGBController_CorsairLightingNode::UpdateMode()
+void RGBController_CorsairLightingNode::DeviceUpdateMode()
 {
     if(modes[active_mode].value == 0xFFFF)
     {

RGBController/RGBController_CorsairLightingNode.h

@@ -25,7 +25,7 @@ public:
     void        UpdateSingleLED(int led);
 
     void        SetCustomMode();
-    void        UpdateMode();
+    void        DeviceUpdateMode();
 
 private:
     CorsairLightingNodeController*   corsair;

RGBController/RGBController_CorsairPeripheral.cpp

@@ -53,7 +53,7 @@ static const char* led_names[] =
     "Key: A",               //15
     "Key: Left Windows",    //17
     "Key: Print Screen",    //18
-    "Media Mute",           //20
+    "Key: Media Mute",      //20
     "Key: Number Pad 8",    //21
     "Key: F2",              //24
     "Key: 2",               //25
@@ -63,7 +63,7 @@ static const char* led_names[] =
     "Key: Left Alt",        //29
     "Key: Scroll Lock",     //30
     "Key: Backspace",       //31
-    "Media Stop",           //32
+    "Key: Media Stop",      //32
     "Key: Number Pad 9",    //33
     "Key: F3",              //36
     "Key: 3",               //37
@@ -72,7 +72,7 @@ static const char* led_names[] =
     "Key: X",               //40
     "Key: Pause/Break",     //42
     "Key: Delete",          //43
-    "Media Previous",       //44
+    "Key: Media Previous",  //44
     "Key: F4",              //48
     "Key: 4",               //49
     "Key: R",               //50
@@ -81,7 +81,7 @@ static const char* led_names[] =
     "Key: Space",           //53
     "Key: Insert",          //54
     "Key: End",             //55
-    "Media Play/Pause",     //56
+    "Key: Media Play/Pause",//56
     "Key: Number Pad 4",    //57
     "Key: F5",              //60
     "Key: 5",               //61
@@ -90,7 +90,7 @@ static const char* led_names[] =
     "Key: V",               //64
     "Key: Home",            //66
     "Key: Page Down",       //67
-    "Media Next",           //68
+    "Key: Media Next",      //68
     "Key: Number Pad 5",    //69
     "Key: F6",              //72
     "Key: 6",               //73
@@ -117,7 +117,7 @@ static const char* led_names[] =
     "Key: K",               //99
     "Key: M",               //100
     "Key: Right Windows",   //101
-    "Key: \\",              //102
+    "Key: \\ (ANSI)",       //102
     "Key: Up Arrow",        //103
     "Key: Number Pad *",    //104
     "Key: Number Pad 2",    //105
@@ -323,7 +323,7 @@ void RGBController_CorsairPeripheral::SetCustomMode()
     active_mode = 0;
 }
 
-void RGBController_CorsairPeripheral::UpdateMode()
+void RGBController_CorsairPeripheral::DeviceUpdateMode()
 {
 
 }

RGBController/RGBController_CorsairPeripheral.h

@@ -26,7 +26,7 @@ public:
     void        UpdateSingleLED(int led);
 
     void        SetCustomMode();
-    void        UpdateMode();
+    void        DeviceUpdateMode();
 
 private:
     CorsairPeripheralController*   corsair;

RGBController/RGBController_CorsairVengeance.cpp

@@ -101,7 +101,7 @@ void RGBController_CorsairVengeance::SetCustomMode()
     active_mode = 0;
 }
 
-void RGBController_CorsairVengeance::UpdateMode()
+void RGBController_CorsairVengeance::DeviceUpdateMode()
 {
     corsair->SetMode(modes[active_mode].value);
 }

RGBController/RGBController_CorsairVengeance.h

@@ -26,7 +26,7 @@ public:
     void        UpdateSingleLED(int led);
 
     void        SetCustomMode();
-    void        UpdateMode();
+    void        DeviceUpdateMode();
 
 private:
     CorsairVengeanceController* corsair;

RGBController/RGBController_CorsairVengeancePro.cpp

@@ -219,7 +219,7 @@ void RGBController_CorsairVengeancePro::SetCustomMode()
     active_mode = 9;
 }
 
-void RGBController_CorsairVengeancePro::UpdateMode()
+void RGBController_CorsairVengeancePro::DeviceUpdateMode()
 {
     unsigned int corsair_direction = 0;
     bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);

RGBController/RGBController_CorsairVengeancePro.h

@@ -26,7 +26,7 @@ public:
     void        UpdateSingleLED(int led);
 
     void        SetCustomMode();
-    void        UpdateMode();
+    void        DeviceUpdateMode();
 
 private:
     CorsairVengeanceProController* corsair;

RGBController/RGBController_Crucial.cpp

@@ -177,7 +177,7 @@ void RGBController_Crucial::SetCustomMode()
     active_mode = 0;
 }
 
-void RGBController_Crucial::UpdateMode()
+void RGBController_Crucial::DeviceUpdateMode()
 {
     crucial->SetMode(modes[active_mode].value);
 }

RGBController/RGBController_Crucial.h

@@ -26,7 +26,7 @@ public:
     void        UpdateSingleLED(int led);
 
     void        SetCustomMode();
-    void        UpdateMode();
+    void        DeviceUpdateMode();
 
 private:
     CrucialController*  crucial;

RGBController/RGBController_DuckyKeyboard.cpp

@@ -0,0 +1,112 @@
+/*-----------------------------------------*\
+|  RGBController_DuckyKeyboard.cpp          |
+|                                           |
+|  Generic RGB Interface for Ducky RGB      |
+|  keyboard devices                         |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 7/4/2020    |
+\*-----------------------------------------*/
+
+#include "RGBController_DuckyKeyboard.h"
+
+//0xFFFFFFFF indicates an unused entry in matrix
+#define NA  0xFFFFFFFF
+
+static unsigned int matrix_map[6][23] =
+    { {   0,  NA,  12,  18,  24,  30,  NA,  42,  48,  54,  60,  NA,  66,  72,  78,  84,  90,  96, 102,  NA,  NA,  NA,  NA },
+      {   1,   7,  13,  19,  25,  31,  37,  43,  49,  55,  61,  NA,  67,  73,  85,  NA,  91,  97, 103,  NA,  NA,  NA,  NA },
+      {   2,  NA,   8,  14,  20,  26,  NA,  32,  38,  44,  50,  56,  62,  68,  74,  86,  92,  98, 104,  NA,  NA,  NA,  NA },
+      {   3,  NA,   9,  15,  21,  27,  NA,  33,  39,  45,  51,  57,  63,  69,  87,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
+      {   4,  NA,  16,  22,  28,  34,  NA,  40,  NA,  46,  52,  58,  64,  70,  82,  NA,  NA, 100,  NA,  NA,  NA,  NA,  NA },
+      {   5,  11,  17,  NA,  NA,  NA,  NA,  41,  NA,  NA,  NA,  NA,  65,  77,  83,  89,  95, 101, 107,  NA,  NA,  NA,  NA } };
+
+RGBController_DuckyKeyboard::RGBController_DuckyKeyboard(DuckyKeyboardController* ducky_ptr)
+{
+    ducky = ducky_ptr;
+
+    name        = "Ducky Keyboard Device";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "Ducky Keyboard Device";
+
+    mode Custom;
+    Custom.name       = "Custom";
+    Custom.value      = 0xFFFF;
+    Custom.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Custom.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Custom);
+
+    SetupZones();
+}
+
+RGBController_DuckyKeyboard::~RGBController_DuckyKeyboard()
+{
+
+}
+
+void RGBController_DuckyKeyboard::SetupZones()
+{
+    zone new_zone;
+
+    new_zone.name               = "Keyboard";
+    new_zone.type               = ZONE_TYPE_MATRIX;
+    new_zone.leds_min           = 155;
+    new_zone.leds_max           = 155;
+    new_zone.leds_count         = 155;
+    new_zone.matrix_map         = new matrix_map_type;
+    new_zone.matrix_map->height = 6;
+    new_zone.matrix_map->width  = 23;
+    new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+    
+    zones.push_back(new_zone);
+
+    for(int led_idx = 0; led_idx < 155; led_idx++)
+    {
+        led new_led;
+
+        new_led.name = "Keyboard LED ";
+        new_led.name.append(std::to_string(led_idx));
+
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_DuckyKeyboard::ResizeZone(int zone, int new_size)
+{
+    
+}
+    
+void RGBController_DuckyKeyboard::DeviceUpdateLEDs()
+{
+    unsigned char colordata[155*3];
+    
+    for(int color_idx = 0; color_idx < colors.size(); color_idx++)
+    {
+        colordata[(color_idx*3)+0] = RGBGetRValue(colors[color_idx]);
+        colordata[(color_idx*3)+1] = RGBGetGValue(colors[color_idx]);
+        colordata[(color_idx*3)+2] = RGBGetBValue(colors[color_idx]);
+    }
+
+    ducky->SendColors(colordata, sizeof(colordata));
+}
+
+void RGBController_DuckyKeyboard::UpdateZoneLEDs(int zone)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_DuckyKeyboard::UpdateSingleLED(int led)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_DuckyKeyboard::SetCustomMode()
+{
+
+}
+
+void RGBController_DuckyKeyboard::DeviceUpdateMode()
+{
+
+}

RGBController/RGBController_DuckyKeyboard.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_DuckyKeyboard.h            |
+|                                           |
+|  Generic RGB Interface for Ducky RGB      |
+|  keyboard devices                         |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 7/4/2020    |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "DuckyKeyboardController.h"
+
+class RGBController_DuckyKeyboard : public RGBController
+{
+public:
+    RGBController_DuckyKeyboard(DuckyKeyboardController* ducky_ptr);
+    ~RGBController_DuckyKeyboard();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+    
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    DuckyKeyboardController*    ducky;
+};

RGBController/RGBController_Dummy.cpp

@@ -43,7 +43,7 @@ void RGBController_Dummy::SetCustomMode()
 
 }
 
-void RGBController_Dummy::UpdateMode()
+void RGBController_Dummy::DeviceUpdateMode()
 {
     
 }

RGBController/RGBController_Dummy.h

@@ -24,5 +24,5 @@ public:
     void        UpdateSingleLED(int led);
 
     void        SetCustomMode();
-    void        UpdateMode();
+    void        DeviceUpdateMode();
 };

RGBController/RGBController_E131.cpp

@@ -186,7 +186,7 @@ void RGBController_E131::SetCustomMode()
 
 }
 
-void RGBController_E131::UpdateMode()
+void RGBController_E131::DeviceUpdateMode()
 {
 
 }

RGBController/RGBController_E131.h

@@ -47,7 +47,7 @@ public:
     void        UpdateSingleLED(int led);
 
     void        SetCustomMode();
-    void        UpdateMode();
+    void        DeviceUpdateMode();
 
 private:
 	std::vector<E131Device> 	devices;

RGBController/RGBController_EKController.cpp

@@ -0,0 +1,174 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_EKController.cpp                                     |
+|                                                                     |
+|  Driver for EK Loop Connect                                         |
+|                                                                     |
+|  Chris M (Dr_No)          16th Jul 2020                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+
+#include "RGBController_EKController.h"
+
+RGBController_EKController::RGBController_EKController(EKController* _dev)
+{
+    EK_dev  = _dev;
+
+    name        = EK_dev->GetDeviceName();
+    type        = DEVICE_TYPE_LEDSTRIP;
+    description = EK_dev->GetDeviceName();
+    version     = "1.0";
+    serial      = EK_dev->GetSerial();
+    location    = EK_dev->GetLocation();
+
+    mode Static;
+    Static.name                     = "Static";
+    Static.value                    = EK_MODE_STATIC;
+    Static.flags                    = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode               = MODE_COLORS_PER_LED;
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name                  = "Breathing";
+    Breathing.value                 = EK_MODE_BREATHING;
+    Breathing.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.speed_min             = EK_SPEED_SLOWEST;
+    Breathing.speed_max             = EK_SPEED_FASTEST;
+    Breathing.color_mode            = MODE_COLORS_PER_LED;
+    Breathing.speed                 = EK_SPEED_NORMAL;
+    modes.push_back(Breathing);
+
+    mode Fading;
+    Fading.name                     = "Fading";
+    Fading.value                    = EK_MODE_FADING;
+    Fading.flags                    = MODE_FLAG_HAS_SPEED;
+    Fading.speed_min                = EK_SPEED_SLOWEST;
+    Fading.speed_max                = EK_SPEED_FASTEST;
+    Fading.color_mode               = MODE_COLORS_NONE;
+    Fading.speed                    = EK_SPEED_NORMAL;
+    modes.push_back(Fading);
+
+    mode Marquee;
+    Marquee.name                    = "Marquee";
+    Marquee.value                   = EK_MODE_MARQUEE;
+    Marquee.flags                   = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Marquee.speed_min               = EK_SPEED_SLOWEST;
+    Marquee.speed_max               = EK_SPEED_FASTEST;
+    Marquee.color_mode              = MODE_COLORS_PER_LED;
+    Marquee.speed                   = EK_SPEED_NORMAL;
+    modes.push_back(Marquee);
+
+    mode Covering_Marquee;
+    Covering_Marquee.name           = "Covering Marquee";
+    Covering_Marquee.value          = EK_MODE_COVERING_MARQUEE;
+    Covering_Marquee.flags          = MODE_FLAG_HAS_SPEED;
+    Covering_Marquee.speed_min      = EK_SPEED_SLOWEST;
+    Covering_Marquee.speed_max      = EK_SPEED_FASTEST;
+    Covering_Marquee.color_mode     = MODE_COLORS_NONE;
+    Covering_Marquee.speed          = EK_SPEED_NORMAL;
+    modes.push_back(Covering_Marquee);
+
+    mode Pulse;
+    Pulse.name                      = "Pulse";
+    Pulse.value                     = EK_MODE_PULSE;
+    Pulse.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Pulse.speed_min                 = EK_SPEED_SLOWEST;
+    Pulse.speed_max                 = EK_SPEED_FASTEST;
+    Pulse.color_mode                = MODE_COLORS_PER_LED;
+    Pulse.speed                     = EK_SPEED_NORMAL;
+    modes.push_back(Pulse);
+
+    mode Spectrum_Wave;
+    Spectrum_Wave.name              = "Spectrum_Wave";
+    Spectrum_Wave.value             = EK_MODE_SPECTRUM_WAVE;
+    Spectrum_Wave.flags             = MODE_FLAG_HAS_SPEED;
+    Spectrum_Wave.speed_min         = EK_SPEED_SLOWEST;
+    Spectrum_Wave.speed_max         = EK_SPEED_FASTEST;
+    Spectrum_Wave.color_mode        = MODE_COLORS_NONE;
+    Spectrum_Wave.speed             = EK_SPEED_NORMAL;
+    modes.push_back(Spectrum_Wave);
+
+    mode Alternating;
+    Alternating.name                = "Alternating";
+    Alternating.value               = EK_MODE_ALTERNATING;
+    Alternating.flags               = MODE_FLAG_HAS_SPEED;
+    Alternating.speed_min           = EK_SPEED_SLOWEST;
+    Alternating.speed_max           = EK_SPEED_FASTEST;
+    Alternating.color_mode          = MODE_COLORS_PER_LED;
+    Alternating.speed               = EK_SPEED_NORMAL;
+    modes.push_back(Alternating);
+
+    mode Candle;
+    Candle.name                    = "Candle";
+    Candle.value                   = EK_MODE_CANDLE;
+    Candle.flags                   = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Candle.speed_min               = EK_SPEED_SLOWEST;
+    Candle.speed_max               = EK_SPEED_FASTEST;
+    Candle.color_mode              = MODE_COLORS_PER_LED;
+    Candle.speed                   = EK_SPEED_NORMAL;
+    modes.push_back(Candle);
+
+    SetupZones();
+}
+
+RGBController_EKController::~RGBController_EKController()
+{
+
+}
+
+void RGBController_EKController::SetupZones()
+{
+    zone EK_zone;
+    EK_zone.name          = "Loop Connect";
+    EK_zone.type          = ZONE_TYPE_SINGLE;
+    EK_zone.leds_min      = 1;
+    EK_zone.leds_max      = 1;
+    EK_zone.leds_count    = 1;
+    EK_zone.matrix_map    = NULL;
+    zones.push_back(EK_zone);
+
+    led EK_led;
+    EK_led.name = "EK LED";
+    leds.push_back(EK_led);
+
+    SetupColors();
+}
+
+void RGBController_EKController::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | ToDo                                                      |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_EKController::DeviceUpdateLEDs()
+{
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+    EK_dev->SetColor(red, grn, blu);
+}
+
+void RGBController_EKController::UpdateZoneLEDs(int zone)
+{
+    RGBColor      color = colors[zone];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
+    EK_dev->SetColor(red, grn, blu);
+}
+
+void RGBController_EKController::UpdateSingleLED(int led)
+{
+    UpdateZoneLEDs(led);
+}
+
+void RGBController_EKController::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_EKController::DeviceUpdateMode()
+{
+    EK_dev->SetMode(modes[active_mode].value, modes[active_mode].speed);
+}

RGBController/RGBController_EKController.h

@@ -0,0 +1,35 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_EKController.h                                       |
+|                                                                     |
+|  Driver for EK Loop Connect                                         |
+|                                                                     |
+|  Chris M (Dr_No)          16th Jul 2020                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#ifndef RGBCONTROLLER_EKCONTROLLER_H
+#define RGBCONTROLLER_EKCONTROLLER_H
+
+#include "RGBController.h"
+#include "Controllers/EKController/EKController.h"
+
+class RGBController_EKController : public RGBController
+{
+public:
+    RGBController_EKController(EKController *_dev);
+    ~RGBController_EKController();
+
+    void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+private:
+    EKController* EK_dev;
+};
+
+#endif // RGBCONTROLLER_EKCONTROLLER_H