Add file headers to network files and some minor code cleanup

.gitignore

@@ -1,8 +1 @@
 *.pro.user*
-*.o
-ui_*
-moc_*
-qrc_*
-OpenRGB
-Makefile
-OpenRGB-x86_64.AppImage

.gitlab-ci.yml

@@ -1,181 +0,0 @@
-# swy: some useful references; the MSVC part of the CI script is based on the one from bind9, by Michał Kępień:
-# https://gitlab.com/gitlab-org/ci-cd/shared-runners/images/gcp/windows-containers/blob/master/cookbooks/preinstalled-software/README.md
-# https://gitlab.isc.org/isc-projects/bind9/commit/facc6a051fcac70fbbc61cb92a37be8c3e4db5ec#587d266bb27a4dc3022bbed44dfa19849df3044c_718_731
-# 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
-  - windows
-  - windows-1809
-  
-stages:
-  - build
-
-before_script:
- - echo "started by ${GITLAB_USER_NAME}"
-
-#-----------------------------------------------------------------------#
-# Linux (AppImage) Build Target                                         #
-#-----------------------------------------------------------------------#
-build_linux:
-  image: ubuntu:bionic
-  stage: build
-  script:
-  - apt update
-  - apt install -y build-essential qtcreator qt5-default libusb-1.0-0-dev libhidapi-dev pkgconf wget git
-  - ./scripts/build-appimage.sh
-  
-  artifacts:
-    paths:
-    - OpenRGB-x86_64.AppImage
-    expire_in: 1337 years
-
-#-----------------------------------------------------------------------#
-# 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
-  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 x64 & 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.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_
-  
-  - _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_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
-  - _fold_final_
-  
-  - _fold_start_ 'run qmake and generate the msvc nmake makefile'
-  - mkdir _build; cd _build
-  - ..\_qt\5.15.0\msvc2019_64\bin\qmake ..\OpenRGB.pro
-  - _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_64\bin\windeployqt --no-angle --no-translations --no-opengl-sw --no-system-d3d-compiler --no-compiler-runtime --no-webkit2 .\release\
-  - _fold_final_
-  
-  - _fold_start_ 'compressing the release folder so that we can upload it as artifact'
-  - mv release 'OpenRGB Windows 64-bit'
-  - ${datetime} = Get-Date ([datetime]::UtcNow) -Format "yyyy-MM-ddTHH-mm-ss"
-  - ${revision} = ((git rev-parse --short HEAD) | Out-String).Trim()
-  - ${rversion} = (((Get-Content '..\OpenRGB.pro' | Select-String -Pattern "VERSION     =") | Out-String).Trim().Split("="))[1].Trim()
-  - 7z a -mx9 -r -y "OpenRGB_${rversion}_64_${revision}_nightly_${datetime}.7z" 'OpenRGB Windows 64-bit'
-  - _fold_final_
-#  cache:
-#    key: same-key
-#    paths:
-#    - C:\vcpkg\installed\
-  artifacts:
-    paths:
-    - _build/*.7z
-    expire_in: 1337 years

60-openrgb.rules

@@ -1,216 +0,0 @@
-#---------------------------------------------------------------#
-#  OpenRGB udev rules                                           #
-#                                                               #
-#   Adam Honse (CalcProgrammer1)                    5/29/2020   #
-#---------------------------------------------------------------#
-
-#---------------------------------------------------------------#
-#  User I2C/SMBus Access                                        #
-#---------------------------------------------------------------#
-KERNEL=="i2c-[0-99]*", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  User hidraw Access                                           #
-#---------------------------------------------------------------#
-KERNEL=="hidraw*", SUBSYSTEM=="hidraw", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  AMD Wraith Prism                                             #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0051", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  ASUS Aura Core Devices                                       #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1854", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1869", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1866", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  ASUS Aura USB Devices                                        #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1867", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1872", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1889", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a3", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18f3", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Cooler Master Peripheral Devices                             #
-#                                                               #
-#  Mousemats:                                                   #
-#       Cooler Master MP750                                     #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0109", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Corsair Lighting Node Devices                                #
-#                                                               #
-#       Corsair Lighting Node Core                              #
-#       Corsair Lighting Node Pro                               #
-#       Corsair Commander Pro                                   #
-#       Corsair LS100                                           #
-#       Corsair 1000D Obsidian                                  #
-#       Corsair Spec Omega RGB                                  #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c1a", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c0b", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c10", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c1e", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1d00", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1d04", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Corsair Peripheral Devices                                   #
-#                                                               #
-#  Keyboards:                                                   #
-#       Corsair K55 RGB                                         #
-#       Corsair K65 RGB                                         #
-#       Corsair K65 RGB Lux                                     #
-#       Corsair K65 RGB Rapidfire                               #
-#       Corsair K68 RGB                                         #
-#       Corsair K70 RGB                                         #
-#       Corsair K70 RGB Lux                                     #
-#       Corsair K70 RGB Rapidfire                               #
-#       Corsair K70 RGB MK2                                     #
-#       Corsair K70 RGB MK2 SE                                  #
-#       Corsair K70 RGB MK2 LP                                  #
-#       Corsair K95 RGB                                         #
-#       Corsair K95 Platinum                                    #
-#       Corsair Strafe                                          #
-#       Corsair Strafe MK2                                      #
-#                                                               #
-#  Mice:                                                        #
-#       Corsair M65 Pro                                         #
-#       Corsair M65 RGB Elite                                   #
-#                                                               #
-#  Mousemats:                                                   #
-#       Corsair MM800 RGB Polaris                               #
-#                                                               #
-#  Headset Stands:                                              #
-#       Corsair ST100                                           #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b3d", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b17", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b37", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b39", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b4f", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b13", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b33", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b38", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b49", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b6b", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b55", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b11", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b2d", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b20", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b48", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b2e", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b5a", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b3b", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0a34", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  HyperX Peripheral Devices                                    #
-#                                                               #
-#  Keyboards:                                                   #
-#       HyperX Alloy Elite                                      #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16be", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Logitech Peripheral Devices                                  #
-#                                                               #
-#  Mice:                                                        #
-#       Logitech G203 Prodigy                                   #
-#       Logitech G403 Prodigy                                   #
-#       Logitech G403 Hero                                      #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c084", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c083", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08f", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  MSI/SteelSeries 3-Zone Laptop Keyboard                       #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1770", ATTR{idProduct}=="FF00", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  NZXT Hue 2 Devices                                           #
-#                                                               #
-#       NZXT Hue 2                                              #
-#       NZXT Smart Device V2                                    #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2001", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2006", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  NZXT Kraken                                                  #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="170e", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Redragon Peripheral Devices                                  #
-#                                                               #
-#  Keyboards:                                                   #
-#       Redragon K550 Yama                                      #
-#       Redragon K552 Kumara                                    #
-#       Redragon K556 Devarajas                                 #
-#       Tecware Phantom Elite                                   #
-#                                                               #
-#  Mice:                                                        #
-#       Redragon M711 Cobra                                     #
-#       Redragon M715 Dagger                                    #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0c45", ATTR{idProduct}=="5204", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0c45", ATTR{idProduct}=="5104", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0c45", ATTR{idProduct}=="5004", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0c45", ATTR{idProduct}=="652f", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="fc30", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="fc39", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Gigabyte/Aorus RGB Fusion 2 USB                              #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="048d", ATTR{idProduct}=="8297", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  SteelSeries Peripheral Devices                               #
-#                                                               #
-#  Mice:                                                        #
-#       SteelSeries Rival 100                                   #
-#       SteelSeries Rival 100 DotA 2 Edition                    #
-#       SteelSeries Rival 105                                   #
-#       SteelSeries Rival 110                                   #
-#       SteelSeries Rival 300                                   #
-#       Acer Predator Gaming Mouse (Rival 300)                  #
-#       SteelSeries Rival 300 CS:GO Fade Edition                #
-#       SteelSeries Rival 300 CS:GO Fade Edition (stm32)        #
-#       SteelSeries Rival 300 CS:GO Hyperbeast Edition          #
-#       SteelSeries Rival 300 Dota 2 Edition                    #
-#       SteelSeries Rival 300 HP Omen Edition                   #
-#  Headsets:                                                    #
-#       SteelSeries Siberia 350                                 #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1702", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="170c", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1814", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1729", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1384", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1714", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1394", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1716", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="171a", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1392", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1718", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1229", TAG+="uaccess"
-
-
-#---------------------------------------------------------------#
-#  Thermaltake Poseidon Z RGB Keyboard                          #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="3006", TAG+="uaccess"

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -12,7 +12,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle)
+AMDWraithPrismController::AMDWraithPrismController(libusb_device_handle* dev_handle)
 {
     dev = dev_handle;
 
@@ -49,7 +49,6 @@ std::string AMDWraithPrismController::GetEffectChannelString(unsigned char chann
 
     unsigned char usb_buf[] =
     {
-        0x00,
         0x40, 0x21, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00,
@@ -68,10 +67,12 @@ std::string AMDWraithPrismController::GetEffectChannelString(unsigned char chann
         0x00, 0x00, 0x00, 0x00,
     };
 
-    usb_buf[0x03] = channel;
+    int             actual;
 
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
+    usb_buf[0x02] = channel;
+
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);
 
     ret_string.append((char *)&usb_buf[0x08]);
 
@@ -84,7 +85,6 @@ std::string AMDWraithPrismController::GetFirmwareVersionString()
 
     unsigned char usb_buf[] =
     {
-        0x00,
         0x12, 0x20, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00,
@@ -103,10 +103,11 @@ std::string AMDWraithPrismController::GetFirmwareVersionString()
         0x00, 0x00, 0x00, 0x00,
     };
 
+    int             actual;
     unsigned char   fw_buf[16] = {0x00};
 
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);
 
     for(int char_idx = 0; char_idx < 16; char_idx+=2)
     {
@@ -208,7 +209,6 @@ void AMDWraithPrismController::SendEnableCommand()
 {
     unsigned char usb_buf[] =
     {
-        0x00,
         0x41, 0x80, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00,
@@ -227,15 +227,16 @@ void AMDWraithPrismController::SendEnableCommand()
         0x00, 0x00, 0x00, 0x00,
     };
 
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
+    int             actual;
+
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);
 }
 
 void AMDWraithPrismController::SendApplyCommand()
 {
     unsigned char usb_buf[] =
     {
-        0x00,
         0x51, 0x28, 0x00, 0x00,
         0xE0, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00,
@@ -254,8 +255,10 @@ void AMDWraithPrismController::SendApplyCommand()
         0x00, 0x00, 0x00, 0x00,
     };
 
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
+    int             actual;
+
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);
 }
 
 void AMDWraithPrismController::SendEffectChannelUpdate
@@ -273,7 +276,6 @@ void AMDWraithPrismController::SendEffectChannelUpdate
 {
     unsigned char usb_buf[] =
     {
-        0x00,
         0x51, 0x2C, 0x01, 0x00,
         0x05, 0xFF, 0x00, 0x01,
         0xFF, 0xFF, 0x00, 0xFF,
@@ -292,26 +294,27 @@ void AMDWraithPrismController::SendEffectChannelUpdate
         0xFF, 0xFF, 0xFF, 0xFF
     };
 
-    usb_buf[0x05]   = effect_channel;
-    usb_buf[0x06]   = speed;
-    usb_buf[0x07]   = (direction ? 0x01 : 0x00) | (random_color ? 0x80 : 0x00);
-    usb_buf[0x08]   = mode;
+    int             actual;
 
-    usb_buf[0x0A]   = brightness;
+    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[0x0B]   = red;
-    usb_buf[0x0C]   = green;
-    usb_buf[0x0D]   = blue;
+    usb_buf[0x09]   = brightness;
 
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
+    usb_buf[0x0A]   = red;
+    usb_buf[0x0B]   = green;
+    usb_buf[0x0C]   = blue;
+
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);
 }
 
 void AMDWraithPrismController::SendChannelRemap(unsigned char ring_channel, unsigned char logo_channel, unsigned char fan_channel)
 {
     unsigned char usb_buf[] =
     {
-        0x00,
         0x51, 0xA0, 0x01, 0x00,
         0x00, 0x03, 0x00, 0x00,
         0x05, 0x06, 0x07, 0x07,
@@ -330,14 +333,16 @@ void AMDWraithPrismController::SendChannelRemap(unsigned char ring_channel, unsi
         0x00, 0x00, 0x00, 0x00,
     };
 
-    usb_buf[0x09] = logo_channel;
-    usb_buf[0x0A] = fan_channel;
+    int             actual;
 
-    for(int led = 0x0B; led <= 0x19; led++)
+    usb_buf[0x08] = logo_channel;
+    usb_buf[0x09] = fan_channel;
+
+    for(int led = 0x0A; led <= 0x18; led++)
     {
         usb_buf[led] = ring_channel;
     }
 
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);
 }

Controllers/AMDWraithPrismController/AMDWraithPrismController.h

@@ -8,7 +8,7 @@
 \*-----------------------------------------*/
 
 #include <string>
-#include <hidapi/hidapi.h>
+#include <libusb-1.0/libusb.h>
 
 #pragma once
 
@@ -109,7 +109,7 @@ enum
 class AMDWraithPrismController
 {
 public:
-    AMDWraithPrismController(hid_device* dev_handle);
+    AMDWraithPrismController(libusb_device_handle* dev_handle);
     ~AMDWraithPrismController();
 
     char* GetDeviceName();
@@ -130,7 +130,7 @@ public:
 
 private:
     char                    device_name[32];
-    hid_device*             dev;
+    libusb_device_handle*   dev;
 
     unsigned char           current_fan_mode;
     unsigned char           current_fan_speed;

Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp

@@ -2,7 +2,8 @@
 #include "RGBController.h"
 #include "RGBController_AMDWraithPrism.h"
 #include <vector>
-#include <hidapi/hidapi.h>
+#include <libusb-1.0/libusb.h>
+
 #define AMD_WRAITH_PRISM_VID 0x2516
 #define AMD_WRAITH_PRISM_PID 0x0051
 
@@ -16,36 +17,21 @@
 
 void DetectAMDWraithPrismControllers(std::vector<RGBController*>& rgb_controllers)
 {
-    hid_device_info* info;
-    hid_device* dev = NULL;
-
-    hid_init();
-
-    info = hid_enumerate(AMD_WRAITH_PRISM_VID, AMD_WRAITH_PRISM_PID);
+    libusb_context * ctx;
+    libusb_init(&ctx);
 
     //Look for AMD Wraith Prism
-    while(info)
+    libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, AMD_WRAITH_PRISM_VID, AMD_WRAITH_PRISM_PID);
+
+    if( dev )
     {
-        if((info->vendor_id == AMD_WRAITH_PRISM_VID)
-         &&(info->product_id == AMD_WRAITH_PRISM_PID)
-#if USE_HID_USAGE
-         &&(info->interface_number == 1)
-         &&(info->usage_page == 0xFF00))
-#else
-         &&(info->interface_number == 1))
-#endif
-        {
-            dev = hid_open_path(info->path);
-        
-            if( dev )
-            {
-                AMDWraithPrismController* controller = new AMDWraithPrismController(dev);
+        libusb_detach_kernel_driver(dev, 1);
+        libusb_claim_interface(dev, 1);
 
-                RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
+        AMDWraithPrismController* controller = new AMDWraithPrismController(dev);
 
-                rgb_controllers.push_back(rgb_controller);
-            }
-        }
-        info = info->next;
+        RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
+
+        rgb_controllers.push_back(rgb_controller);
     }
 }

Controllers/AuraAddressableController/AuraAddressableController.cpp

@@ -0,0 +1,269 @@
+/*-----------------------------------------*\
+|  AuraAddressableController.cpp            |
+|                                           |
+|  Driver for ASUS Aura RGB Addressable     |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/18/2020   |
+\*-----------------------------------------*/
+
+#include "AuraAddressableController.h"
+#include <cstring>
+
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
+
+AuraAddressableController::AuraAddressableController(hid_device* dev_handle)
+{
+    dev = dev_handle;
+
+    GetFirmwareVersion();
+    GetConfigTable();
+}
+
+AuraAddressableController::~AuraAddressableController()
+{
+
+}
+
+unsigned int AuraAddressableController::GetChannelCount()
+{
+    return( 1 );
+}
+
+std::string AuraAddressableController::GetDeviceName()
+{
+    return(device_name);
+}
+
+void AuraAddressableController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
+{
+    unsigned char   led_data[60];
+    unsigned int    leds_sent = 0;
+
+    while(leds_sent < num_colors)
+    {
+        unsigned int leds_to_send = 20;
+
+        if((num_colors - leds_sent) < leds_to_send)
+        {
+            leds_to_send = num_colors - leds_sent;
+        }
+
+        for(int led_idx = 0; led_idx < leds_to_send; led_idx++)
+        {
+            led_data[(led_idx * 3) + 0] = RGBGetRValue(colors[led_idx + leds_sent]);
+            led_data[(led_idx * 3) + 1] = RGBGetGValue(colors[led_idx + leds_sent]);
+            led_data[(led_idx * 3) + 2] = RGBGetBValue(colors[led_idx + leds_sent]);
+        }
+
+        SendDirect
+        (
+            channel,
+            leds_sent,
+            leds_to_send,
+            led_data
+        );
+
+        leds_sent += leds_to_send;
+    }
+
+    SendDirectApply(channel);
+}
+
+void AuraAddressableController::SetMode
+    (
+    unsigned char mode,
+    unsigned char red,
+    unsigned char grn,
+    unsigned char blu
+    )
+{
+    for(int channel_idx = 0; channel_idx < GetChannelCount(); channel_idx++)
+    {
+        SendEffect
+        (
+            channel_idx,
+            mode,
+            red,
+            grn,
+            blu
+        );
+    }
+}
+
+void AuraAddressableController::GetConfigTable()
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up config table request packet                    |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_REQUEST_CONFIG_TABLE;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Copy the firmware string if the reply ID is correct   |
+    \*-----------------------------------------------------*/
+    if(usb_buf[1] == 0x30)
+    {
+        memcpy(config_table, &usb_buf[4], 60);
+
+        for(int i = 0; i < 60; i+=6)
+        {
+            printf("%02X %02X %02X %02X %02X %02X\r\n", config_table[i + 0],
+                                                        config_table[i + 1],
+                                                        config_table[i + 2],
+                                                        config_table[i + 3],
+                                                        config_table[i + 4],
+                                                        config_table[i + 5]);
+        }
+    }
+}
+
+void AuraAddressableController::GetFirmwareVersion()
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up firmware version request packet                |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_REQUEST_FIRMWARE_VERSION;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Copy the firmware string if the reply ID is correct   |
+    \*-----------------------------------------------------*/
+    if(usb_buf[1] == 0x02)
+    {
+        memcpy(device_name, &usb_buf[2], 16);
+    }
+}
+
+void AuraAddressableController::SendEffect
+    (
+    unsigned char   channel,
+    unsigned char   mode,
+    unsigned char   red,
+    unsigned char   grn,
+    unsigned char   blu
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_CONTROL_MODE_EFFECT;
+    usb_buf[0x02]   = channel;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = mode;
+
+    /*-----------------------------------------------------*\
+    | Copy in color data bytes                              |
+    \*-----------------------------------------------------*/
+    usb_buf[0x05]   = red;
+    usb_buf[0x06]   = grn;
+    usb_buf[0x07]   = blu;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+}
+
+void AuraAddressableController::SendDirect
+    (
+    unsigned char   device,
+    unsigned char   start_led,
+    unsigned char   led_count,
+    unsigned char*  led_data
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_CONTROL_MODE_DIRECT;
+    usb_buf[0x02]   = device;
+    usb_buf[0x03]   = start_led;
+    usb_buf[0x04]   = led_count;
+
+    /*-----------------------------------------------------*\
+    | Copy in color data bytes                              |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x05], led_data, led_count * 3);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+}
+
+void AuraAddressableController::SendDirectApply
+    (
+    unsigned char   channel
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_CONTROL_MODE_DIRECT;
+    usb_buf[0x02]   = 0x80 | channel;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+}

Controllers/AuraAddressableController/AuraAddressableController.h

@@ -1,16 +1,15 @@
 /*-----------------------------------------*\
-|  AuraUSBController.h                      |
+|  AuraAddressableController.h              |
 |                                           |
 |  Definitions and types for ASUS Aura      |
-|  USB RGB lighting controller              |
+|  Addressable RGB lighting controller      |
 |                                           |
-|  Martin Hartl (inlart) 4/25/2020          |
+|  Adam Honse (CalcProgrammer1) 1/18/2020   |
 \*-----------------------------------------*/
 
 #include "RGBController.h"
 
 #include <string>
-#include <vector>
 #include <hidapi/hidapi.h>
 
 #pragma once
@@ -37,71 +36,66 @@ enum
 
 enum
 {
+    AURA_CONTROL_MODE_EFFECT            = 0x3B,     /* Effect control mode                  */
+    AURA_CONTROL_MODE_DIRECT            = 0x40,     /* Direct control mode                  */
     AURA_REQUEST_FIRMWARE_VERSION       = 0x82,     /* Request firmware string              */
     AURA_REQUEST_CONFIG_TABLE           = 0xB0,     /* Request configuration table          */
-    AURA_CONTROL_MODE_DIRECT            = 0x40,     /* Direct control mode                  */
 };
 
-enum class AuraDeviceType
-{
-    FIXED,
-    ADDRESSABLE,
-};
-
-struct AuraDeviceInfo
-{
-    unsigned char effect_channel;
-    unsigned char direct_channel;
-    unsigned char num_leds;
-    AuraDeviceType device_type;
-};
-
-class AuraUSBController
+class AuraAddressableController
 {
 public:
-    AuraUSBController(hid_device* dev_handle);
-    virtual ~AuraUSBController();
+    AuraAddressableController(hid_device* dev_handle);
+    ~AuraAddressableController();
 
     unsigned int GetChannelCount();
 
     std::string GetDeviceName();
 
-    const std::vector<AuraDeviceInfo>& GetAuraDevices() const;
-
-    virtual void SetChannelLEDs
+    void SetChannelLEDs
         (
         unsigned char   channel,
         RGBColor *      colors,
         unsigned int    num_colors
-        ) = 0;
+        );
 
-    virtual void SetMode
+    void SetMode
+        (
+        unsigned char mode,
+        unsigned char red,
+        unsigned char grn,
+        unsigned char blu
+        );
+
+private:
+    char                    device_name[16];
+    unsigned char           config_table[60];
+    hid_device*             dev;
+    unsigned int            led_count;
+    
+    void GetConfigTable();
+
+    void GetFirmwareVersion();
+
+    void SendEffect
         (
         unsigned char   channel,
         unsigned char   mode,
         unsigned char   red,
         unsigned char   grn,
         unsigned char   blu
-        ) = 0;
-
-protected:
-    hid_device*                 dev;
-    unsigned char               config_table[60];
-    std::vector<AuraDeviceInfo> device_info;
+        );
 
     void SendDirect
         (
         unsigned char   device,
         unsigned char   start_led,
         unsigned char   led_count,
-        unsigned char*  led_data,
-        bool apply = false
+        unsigned char*  led_data
         );
-private:
-    char                        device_name[16];
-    unsigned int                led_count;
 
-    void GetConfigTable();
-
-    void GetFirmwareVersion();
+    void    SendDirectApply
+                (
+                unsigned char   channel
+                );
 };

Controllers/AuraAddressableController/AuraAddressableControllerDetect.cpp

@@ -0,0 +1,47 @@
+#include "AuraAddressableController.h"
+#include "RGBController.h"
+#include "RGBController_AuraAddressable.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#define AURA_ADDRESSABLE_VID 0x0B05
+
+#define NUM_PIDS 4
+static const unsigned short pid_table[] =
+    {
+    0x1867,
+    0x1872,
+    0x1889,
+    0x18A3
+    };
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAuraAddressableControllers                                                       *
+*                                                                                          *
+*       Tests the USB address to see if an Asus Aura addressable RGB header controller     *
+*       exists there.                                                                      *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAuraAddressableControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device* dev;
+
+    //Look for Asus Aura addressable RGB header controller
+    hid_init();
+
+    for(int pid_idx = 0; pid_idx < NUM_PIDS; pid_idx++)
+    {
+        dev = hid_open(AURA_ADDRESSABLE_VID, pid_table[pid_idx], 0);
+
+        if( dev )
+        {
+            AuraAddressableController* controller = new AuraAddressableController(dev);
+
+            RGBController_AuraAddressable* rgb_controller = new RGBController_AuraAddressable(controller);
+
+            rgb_controllers.push_back(rgb_controller);
+        }
+    }
+}

Controllers/AuraGPUController/AuraGPUControllerDetect.cpp

@@ -14,7 +14,16 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-using namespace std::chrono_literals;
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
 
 /*-------------------------------------------------------------*\
 | This list contains the available I2C addresses for Aura GPUs  |
@@ -79,7 +88,7 @@ void DetectAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::ve
                 rgb_controllers.push_back(new_controller);
             }
 
-            std::this_thread::sleep_for(1ms);
+            Sleep(1);
         }
     }
 } /* DetectAuraGPUControllers() */

Controllers/AuraSMBusController/AuraSMBusControllerDetect.cpp

@@ -6,7 +6,16 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-using namespace std::chrono_literals;
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
 
 /*----------------------------------------------------------------------*\
 | This list contains the available SMBus addresses for mapping Aura RAM  |
@@ -169,7 +178,7 @@ void DetectAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::
                 rgb_controllers.push_back(new_controller);
             }
 
-            std::this_thread::sleep_for(1ms);
+            Sleep(1);
         }
 
         // Add Aura-enabled motherboard controllers
@@ -182,7 +191,7 @@ void DetectAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::
                 rgb_controllers.push_back(new_controller);
             }
 
-            std::this_thread::sleep_for(1ms);
+            Sleep(1);
         }
     }
 

Controllers/AuraUSBController/AuraAddressableController.cpp

@@ -1,144 +0,0 @@
-/*-----------------------------------------*\
-|  AuraAddressableController.cpp            |
-|                                           |
-|  Driver for ASUS Aura RGB Addressable     |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/18/2020   |
-\*-----------------------------------------*/
-
-#include "AuraAddressableController.h"
-#include <cstring>
-
-AuraAddressableController::AuraAddressableController(hid_device* dev_handle) : AuraUSBController(dev_handle)
-{
-    /*-----------------------------------------------------*\
-    | Add addressable devices                               |
-    \*-----------------------------------------------------*/
-    for(int i = 0; i < config_table[0x02]; ++i)
-    {
-        device_info.push_back({0x01, (unsigned char)i, 0x01, AuraDeviceType::ADDRESSABLE});
-    }
-}
-
-AuraAddressableController::~AuraAddressableController()
-{
-
-}
-
-void AuraAddressableController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
-{
-    unsigned char   led_data[60];
-    unsigned int    leds_sent = 0;
-
-    while(leds_sent < num_colors)
-    {
-        unsigned int leds_to_send = 20;
-
-        if((num_colors - leds_sent) < leds_to_send)
-        {
-            leds_to_send = num_colors - leds_sent;
-        }
-
-        for(int led_idx = 0; led_idx < leds_to_send; led_idx++)
-        {
-            led_data[(led_idx * 3) + 0] = RGBGetRValue(colors[led_idx + leds_sent]);
-            led_data[(led_idx * 3) + 1] = RGBGetGValue(colors[led_idx + leds_sent]);
-            led_data[(led_idx * 3) + 2] = RGBGetBValue(colors[led_idx + leds_sent]);
-        }
-
-        SendDirect
-        (
-            channel,
-            leds_sent,
-            leds_to_send,
-            led_data
-        );
-
-        leds_sent += leds_to_send;
-    }
-
-    SendDirectApply(channel);
-}
-
-void AuraAddressableController::SetMode
-    (
-    unsigned char   channel,
-    unsigned char   mode,
-    unsigned char   red,
-    unsigned char   grn,
-    unsigned char   blu
-    )
-{
-    SendEffect
-    (
-        channel,
-        mode,
-        red,
-        grn,
-        blu
-    );
-}
-
-void AuraAddressableController::SendEffect
-    (
-    unsigned char   channel,
-    unsigned char   mode,
-    unsigned char   red,
-    unsigned char   grn,
-    unsigned char   blu
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_ADDRESSABLE_CONTROL_MODE_EFFECT;
-    usb_buf[0x02]   = channel;
-    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = mode;
-
-    /*-----------------------------------------------------*\
-    | Copy in color data bytes                              |
-    \*-----------------------------------------------------*/
-    usb_buf[0x05]   = red;
-    usb_buf[0x06]   = grn;
-    usb_buf[0x07]   = blu;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}
-
-void AuraAddressableController::SendDirectApply
-    (
-    unsigned char   channel
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_CONTROL_MODE_DIRECT;
-    usb_buf[0x02]   = 0x80 | channel;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}

Controllers/AuraUSBController/AuraAddressableController.h

@@ -1,60 +0,0 @@
-/*-----------------------------------------*\
-|  AuraAddressableController.h              |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  Addressable RGB lighting controller      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/18/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include "AuraUSBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    AURA_ADDRESSABLE_CONTROL_MODE_EFFECT            = 0x3B,     /* Effect control mode                  */
-};
-
-class AuraAddressableController : public AuraUSBController
-{
-public:
-    AuraAddressableController(hid_device* dev_handle);
-    ~AuraAddressableController();
-
-    void SetChannelLEDs
-        (
-        unsigned char   channel,
-        RGBColor *      colors,
-        unsigned int    num_colors
-        );
-
-    void SetMode
-        (
-        unsigned char   channel,
-        unsigned char   mode,
-        unsigned char   red,
-        unsigned char   grn,
-        unsigned char   blu
-        );
-
-private:
-
-    void SendEffect
-        (
-        unsigned char   channel,
-        unsigned char   mode,
-        unsigned char   red,
-        unsigned char   grn,
-        unsigned char   blu
-        );
-
-    void    SendDirectApply
-        (
-        unsigned char   channel
-        );
-};

Controllers/AuraUSBController/AuraMainboardController.cpp

@@ -1,199 +0,0 @@
-/*-----------------------------------------*\
-|  AuraMainboardController.cpp              |
-|                                           |
-|  Driver for ASUS Aura RGB USB mainboard   |
-|  lighting controller                      |
-|                                           |
-|  Martin Hartl (inlart) 4/25/2020          |
-\*-----------------------------------------*/
-
-#include "AuraMainboardController.h"
-#include <cstring>
-
-AuraMainboardController::AuraMainboardController(hid_device* dev_handle) : AuraUSBController(dev_handle), mode(AURA_MODE_DIRECT)
-{
-    /*-----------------------------------------------------*\
-    | Add mainboard device                                  |
-    \*-----------------------------------------------------*/
-    device_info.push_back({0x00, 0x04, config_table[0x1B], AuraDeviceType::FIXED});
-
-    /*-----------------------------------------------------*\
-    | Add addressable devices                               |
-    \*-----------------------------------------------------*/
-    for(int i = 0; i < config_table[0x02]; ++i)
-    {
-        device_info.push_back({0x01, (unsigned char)i, 0x01, AuraDeviceType::ADDRESSABLE});
-    }
-}
-
-AuraMainboardController::~AuraMainboardController()
-{
-}
-
-void AuraMainboardController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
-{
-    unsigned char   led_data[60];
-    unsigned int    leds_sent = 0;
-
-    while(leds_sent < num_colors)
-    {
-        unsigned int leds_to_send = 20;
-
-        if((num_colors - leds_sent) < leds_to_send)
-        {
-            leds_to_send = num_colors - leds_sent;
-        }
-
-        for(int led_idx = 0; led_idx < leds_to_send; led_idx++)
-        {
-            led_data[(led_idx * 3) + 0] = RGBGetRValue(colors[led_idx + leds_sent]);
-            led_data[(led_idx * 3) + 1] = RGBGetGValue(colors[led_idx + leds_sent]);
-            led_data[(led_idx * 3) + 2] = RGBGetBValue(colors[led_idx + leds_sent]);
-        }
-
-        SendDirect
-        (
-            device_info[channel].direct_channel,
-            leds_sent,
-            leds_to_send,
-            led_data,
-            leds_sent + leds_to_send >= num_colors
-        );
-
-        leds_sent += leds_to_send;
-    }
-
-    SendCommit();
-}
-
-void AuraMainboardController::SetMode
-    (
-    unsigned char   channel,
-    unsigned char   mode,
-    unsigned char   red,
-    unsigned char   grn,
-    unsigned char   blu
-    )
-{
-    this->mode = mode;
-    RGBColor color = ToRGBColor(red, grn, blu);
-
-    SendEffect(device_info[channel].effect_channel, mode);
-    if(mode == AURA_MODE_DIRECT)
-    {
-        return;
-    }
-
-    unsigned char   led_data[60];
-    unsigned char   start_led = 0;
-
-    for(std::size_t i = 0; i < channel; ++i)
-    {
-        start_led += device_info[i].num_leds;
-    }
-
-    for(std::size_t led_idx = 0; led_idx < device_info[channel].num_leds; led_idx++)
-    {
-        led_data[(led_idx * 3) + 0] = RGBGetRValue(color);
-        led_data[(led_idx * 3) + 1] = RGBGetGValue(color);
-        led_data[(led_idx * 3) + 2] = RGBGetBValue(color);
-    }
-
-    SendColor
-    (
-        channel,
-        start_led,
-        device_info[channel].num_leds,
-        led_data,
-        device_info[channel].device_type == AuraDeviceType::FIXED
-    );
-
-    SendCommit();
-}
-
-void AuraMainboardController::SendEffect
-    (
-    unsigned char   channel,
-    unsigned char   mode
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_EFFECT;
-    usb_buf[0x02]   = channel;
-    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = 0x00;
-    usb_buf[0x05]   = mode;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}
-
-void AuraMainboardController::SendColor
-    (
-    unsigned char   channel,
-    unsigned char   start_led,
-    unsigned char   led_count,
-    unsigned char*  led_data,
-    bool            fixed
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_EFFECT_COLOR;
-    usb_buf[0x02]   = channel;
-    usb_buf[0x03]   = fixed ? 0xFF : 0x00;
-    usb_buf[0x04]   = 0x00;
-
-    /*-----------------------------------------------------*\
-    | Copy in color data bytes                              |
-    \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x05 + 3 * start_led], led_data, led_count * 3);
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}
-
-void AuraMainboardController::SendCommit()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_COMMIT;
-    usb_buf[0x02]   = 0x55;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}

Controllers/AuraUSBController/AuraMainboardController.h

@@ -1,66 +0,0 @@
-/*-----------------------------------------*\
-|  AuraMainboardController.h                |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB Mainboard RGB lighting controller    |
-|                                           |
-|  Martin Hartl (inlart) 4/25/2020          |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include "AuraUSBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    AURA_MAINBOARD_CONTROL_MODE_EFFECT            = 0x35,     /* Effect control mode                  */
-    AURA_MAINBOARD_CONTROL_MODE_EFFECT_COLOR      = 0x36,     /* Effect color control mode            */
-    AURA_MAINBOARD_CONTROL_MODE_COMMIT            = 0x3F,     /* Commit mode                          */
-};
-
-class AuraMainboardController : public AuraUSBController
-{
-public:
-    AuraMainboardController(hid_device* dev_handle);
-    ~AuraMainboardController();
-
-    void SetChannelLEDs
-        (
-        unsigned char   channel,
-        RGBColor *      colors,
-        unsigned int    num_colors
-        );
-
-    void SetMode
-        (
-        unsigned char   channel,
-        unsigned char   mode,
-        unsigned char   red,
-        unsigned char   grn,
-        unsigned char   blu
-        );
-
-private:
-    unsigned int mode;
-
-    void SendEffect
-        (
-        unsigned char   channel,
-        unsigned char   mode
-        );
-
-    void SendColor
-        (
-        unsigned char   channel,
-        unsigned char   start_led,
-        unsigned char   led_count,
-        unsigned char*  led_data,
-        bool            fixed
-        );
-
-    void SendCommit();
-};

Controllers/AuraUSBController/AuraUSBController.cpp

@@ -1,155 +0,0 @@
-/*-----------------------------------------*\
-|  AuraUSBController.cpp                    |
-|                                           |
-|  Driver for ASUS Aura RGB USB             |
-|  lighting controller                      |
-|                                           |
-|  Martin Hartl (inlart) 4/25/2020          |
-\*-----------------------------------------*/
-
-#include "AuraUSBController.h"
-#include <cstring>
-#include <stdexcept>
-
-AuraUSBController::AuraUSBController(hid_device* dev_handle)
-{
-    dev = dev_handle;
-
-    GetFirmwareVersion();
-    GetConfigTable();
-}
-
-AuraUSBController::~AuraUSBController()
-{
-
-}
-
-unsigned int AuraUSBController::GetChannelCount()
-{
-    return(device_info.size());
-}
-
-std::string AuraUSBController::GetDeviceName()
-{
-    return(device_name);
-}
-
-const std::vector<AuraDeviceInfo>& AuraUSBController::GetAuraDevices() const
-{
-    return(device_info);
-}
-
-void AuraUSBController::GetConfigTable()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up config table request packet                    |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_REQUEST_CONFIG_TABLE;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Copy the firmware string if the reply ID is correct   |
-    \*-----------------------------------------------------*/
-    if(usb_buf[1] == 0x30)
-    {
-        memcpy(config_table, &usb_buf[4], 60);
-
-        for(int i = 0; i < 60; i+=6)
-        {
-            printf("%02X %02X %02X %02X %02X %02X\r\n", config_table[i + 0],
-                                                        config_table[i + 1],
-                                                        config_table[i + 2],
-                                                        config_table[i + 3],
-                                                        config_table[i + 4],
-                                                        config_table[i + 5]);
-        }
-    }
-    else
-    {
-        if(dev)
-        {
-            hid_close(dev);
-        }
-        throw std::runtime_error("Could not read config table");
-    }
-}
-
-void AuraUSBController::GetFirmwareVersion()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up firmware version request packet                |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_REQUEST_FIRMWARE_VERSION;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Copy the firmware string if the reply ID is correct   |
-    \*-----------------------------------------------------*/
-    if(usb_buf[1] == 0x02)
-    {
-        memcpy(device_name, &usb_buf[2], 16);
-    }
-}
-
-void AuraUSBController::SendDirect
-    (
-    unsigned char   device,
-    unsigned char   start_led,
-    unsigned char   led_count,
-    unsigned char*  led_data,
-    bool apply /* = false */
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_CONTROL_MODE_DIRECT;
-    usb_buf[0x02]   = apply ? 0x80 : 0x00;
-    usb_buf[0x02]  |= device;
-    usb_buf[0x03]   = start_led;
-    usb_buf[0x04]   = led_count;
-
-    /*-----------------------------------------------------*\
-    | Copy in color data bytes                              |
-    \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x05], led_data, led_count * 3);
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}

Controllers/AuraUSBController/AuraUSBControllerDetect.cpp

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

Controllers/CoolerMasterController/CMMP750Controller.cpp

@@ -8,21 +8,24 @@
 \*-------------------------------------------------------------------*/
 
 #include "CMMP750Controller.h"
+#include <cstring>
+#include <stdio.h>
+#include <stdlib.h>
 
-CMMP750Controller::CMMP750Controller(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path)
+CMMP750Controller::CMMP750Controller(libusb_device_handle* dev_handle, unsigned int _inAddr, unsigned int _outAddr, int _interface)
 {
-    int tmp_size = wcslen(_vendor);
-
     dev = dev_handle;
+    inAddr = _inAddr;
+    outAddr = _outAddr;
+    interface = _interface;
 
-    for (int i=0; ( i<tmp_size && i<CM_DEVICE_NAME_SIZE); i++)
-    {
-        device_name[i] = (char)_vendor[i];
-    }
-    for (int j=0; ( j<wcslen(_vendor) && tmp_size+j<CM_DEVICE_NAME_SIZE); j++)
-        device_name[tmp_size+j] = (char)_device_name[j];
+    libusb_device* device = libusb_get_device(dev);
+    int bus = libusb_get_bus_number(device);
+    int bus_addr = libusb_get_device_address(device);
+    int port = libusb_get_port_number(device);
+    location = "Bus: " + std::to_string(bus) + "  Addr: " + std::to_string(bus_addr) + "  Port: " + std::to_string(port);
 
-    location = _path;
+    strcpy(device_name, "Cooler Master MP750");
 
     current_mode = MP750_MODE_STATIC;
     current_speed = MP750_SPEED_NORMAL;
@@ -30,7 +33,8 @@ CMMP750Controller::CMMP750Controller(hid_device* dev_handle, wchar_t *_vendor, w
 
 CMMP750Controller::~CMMP750Controller()
 {
-    hid_close(dev);
+    libusb_release_interface(dev, interface);
+    libusb_attach_kernel_driver(dev, interface);
 }
 
 char* CMMP750Controller::GetDeviceName()
@@ -67,6 +71,7 @@ void CMMP750Controller::SetColor(unsigned char red, unsigned char green, unsigne
 
 void CMMP750Controller::SendUpdate()
 {
+    int actual = 0;
     unsigned char buffer[0x40] = { 0x00 };
     int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
 
@@ -89,5 +94,7 @@ void CMMP750Controller::SendUpdate()
         buffer[CM_SPEED_BYTE] = speed_mode_data[current_mode][current_speed];
     }
 
-    hid_write(dev, buffer, buffer_size);
-}
+    //Nothing will be done with the "actual" transfer length
+    libusb_interrupt_transfer(dev, outAddr, buffer, buffer_size, nullptr, CM_INTERRUPT_TIMEOUT);
+}
+

Controllers/CoolerMasterController/CMMP750Controller.h

@@ -16,15 +16,12 @@
 
 #include <string>
 #include <array>
-#include <hidapi/hidapi.h>
+#include <libusb-1.0/libusb.h>
 
 #pragma once
 
 #define CM_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data) / sizeof(colour_mode_data[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 ]))
-#define HID_MAX_STR 255
 
 enum
 {
@@ -56,10 +53,10 @@ static unsigned char colour_mode_data[][6] =
 static unsigned char speed_mode_data[][9] =
 {
     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },/* Static                       */
-    { 0xFF, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00 },/* Blinking                     */
-    { 0xFF, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00 },/* Breathing                    */
-    { 0xFF, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00 },/* Colour Cycle                 */
-    { 0xFF, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00 } /* Colour Breath                */
+    { 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xE0, 0xFF },/* Blinking                     */
+    { 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xE0, 0xFF },/* Breathing                    */
+    { 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xE0, 0xFF },/* Colour Cycle                 */
+    { 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xE0, 0xFF } /* Colour Breath                */
 };
 
 enum
@@ -78,7 +75,7 @@ enum
 class CMMP750Controller
 {
 public:
-    CMMP750Controller(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path);
+    CMMP750Controller(libusb_device_handle *dev_handle, unsigned int _inAddr, unsigned int _outAddr, int _interface);
     ~CMMP750Controller();
 
     char* GetDeviceName();
@@ -92,7 +89,10 @@ private:
     char                    device_name[32];
     char                    serial[32];
     std::string             location;
-    hid_device*             dev;
+    libusb_device_handle*   dev;
+    unsigned char           inAddr;
+    unsigned char           outAddr;
+    int                     interface;
 
     unsigned char           current_mode;
     unsigned char           current_speed;

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -1,25 +1,24 @@
 #include "CMMP750Controller.h"
 #include "RGBController.h"
 #include "RGBController_CMMP750Controller.h"
-#include <hidapi/hidapi.h>
+#include <vector>
+#include <libusb-1.0/libusb.h>
 
-#define COOLERMASTER_VID                0x2516
-
-#define COOLERMASTER_MP750_XL_PID       0x0109
-#define COOLERMASTER_MP750_MEDIUM_PID   0x0105
+#define COOLERMASTER_VID 0x2516
 
 #define COOLERMASTER_NUM_DEVICES (sizeof(cm_pids) / sizeof(cm_pids[ 0 ]))
 
 enum
 {
     CM_PID = 0,
-    CM_INTERFACE = 1
+    CM_INADDR = 1,
+    CM_OUTADDR = 2,
+    CM_INTERFACE = 3
 };
 
 static const unsigned int cm_pids[][4] =
-{  // PID,      Interface
-    { COOLERMASTER_MP750_XL_PID,        0x00 },     //Coolermaster MP750 (Extra Large)
-    { COOLERMASTER_MP750_MEDIUM_PID,    0x00 }      //Coolermaster MP750 (Medium)
+{ //PID, inAddr, outAddr, interface
+    { 0x0109, 0x82, 0x03, 0x00 }        //Coolermaster MP750
 };
 
 /******************************************************************************************\
@@ -32,35 +31,27 @@ static const unsigned int cm_pids[][4] =
 
 void DetectCoolerMasterControllers(std::vector<RGBController*>& rgb_controllers)
 {
-    hid_device_info* info;
+    libusb_context * context;
+    libusb_init(&context);
 
-    //Look for the passed in cm_pids
-    hid_init();
-    info = hid_enumerate(0x0, 0x0);
-
-    while(info)
+    for(int cm_pid_idx = 0; cm_pid_idx < COOLERMASTER_NUM_DEVICES; cm_pid_idx++)
     {
-        hid_device* dev = NULL;
-        if(info->vendor_id == COOLERMASTER_VID)
-        {
-            for(int cm_pid_idx = 0; cm_pid_idx < COOLERMASTER_NUM_DEVICES; cm_pid_idx++)
-            {
-                if((info->product_id        == cm_pids[cm_pid_idx][CM_PID])
-                 &&(info->interface_number  == cm_pids[cm_pid_idx][CM_INTERFACE]))
-                {
-                    dev = hid_open_path(info->path);
-                    break;
-                }
-            }
-        }
+        //Look for the passed in cm_pids
+        libusb_device_handle * dev = libusb_open_device_with_vid_pid(context, COOLERMASTER_VID, cm_pids[cm_pid_idx][CM_PID]);
 
         if(dev)
         {
-            CMMP750Controller* controller = new CMMP750Controller(dev, info->manufacturer_string, info->product_string, info->path);
-            RGBController_CMMP750Controller* rgb_controller = new RGBController_CMMP750Controller(controller);
-            rgb_controllers.push_back(rgb_controller);
+            int status = libusb_detach_kernel_driver(dev, cm_pids[cm_pid_idx][CM_INTERFACE]);
+            status = libusb_claim_interface(dev, cm_pids[cm_pid_idx][CM_INTERFACE]);
+
+            if(status == 0)
+            {
+                // Success: Device has been claimed
+                CMMP750Controller* controller = new CMMP750Controller(dev, cm_pids[cm_pid_idx][CM_INADDR], cm_pids[cm_pid_idx][CM_OUTADDR], cm_pids[cm_pid_idx][CM_INTERFACE]);
+                RGBController_CMMP750Controller* rgb_controller = new RGBController_CMMP750Controller(controller);
+                rgb_controllers.push_back(rgb_controller);
+            }
         }
-        info = info->next;
     }
-    hid_free_enumeration(info);
+
 }

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

@@ -28,7 +28,16 @@
 #define THREADRETURN return(NULL);
 #endif
 
-using namespace std::chrono_literals;
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
 
 THREAD keepalive_thread(void *param)
 {
@@ -37,9 +46,10 @@ THREAD keepalive_thread(void *param)
     THREADRETURN
 }
 
-CorsairLightingNodeController::CorsairLightingNodeController(hid_device* dev_handle)
+CorsairLightingNodeController::CorsairLightingNodeController(libusb_device_handle* dev_handle, unsigned int dev_endpoint)
 {
     dev = dev_handle;
+    endpoint = dev_endpoint;
 
     SendFirmwareRequest();
 
@@ -65,11 +75,8 @@ void CorsairLightingNodeController::KeepaliveThread()
 {
     while(1)
     {
-        if((std::chrono::steady_clock::now() - last_commit_time) > std::chrono::seconds(5))
-        {
-            SendCommit();
-        }
-        std::this_thread::sleep_for(1s);
+        SendCommit();
+        Sleep(5000);
     }
 }
 
@@ -198,7 +205,7 @@ void CorsairLightingNodeController::SetChannelLEDs(unsigned char channel, RGBCol
 void CorsairLightingNodeController::SendFirmwareRequest()
 {
     int             actual;
-    unsigned char   usb_buf[65];
+    unsigned char   usb_buf[64];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -208,14 +215,13 @@ void CorsairLightingNodeController::SendFirmwareRequest()
     /*-----------------------------------------------------*\
     | Set up Firmware Version Request packet                |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_FIRMWARE;
+    usb_buf[0x00]   = CORSAIR_LIGHTING_NODE_PACKET_ID_FIRMWARE;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    actual = hid_read(dev, usb_buf, 17);
+    libusb_interrupt_transfer(dev, endpoint, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x80 + endpoint, usb_buf, 64, &actual, 0);
 
     if(actual > 0)
     {
@@ -232,7 +238,8 @@ void CorsairLightingNodeController::SendDirect
     unsigned char*  color_data
     )
 {
-    unsigned char   usb_buf[65];
+    int             actual;
+    unsigned char   usb_buf[64];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -242,51 +249,43 @@ void CorsairLightingNodeController::SendDirect
     /*-----------------------------------------------------*\
     | Set up Direct packet                                  |
     \*-----------------------------------------------------*/
-    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;
+    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;
 
     /*-----------------------------------------------------*\
     | Copy in color data bytes                              |
     \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x06], color_data, count);
+    memcpy(&usb_buf[0x05], color_data, count);
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 17);
+    libusb_interrupt_transfer(dev, endpoint, usb_buf, 64, &actual, 0);
 }
 
 void CorsairLightingNodeController::SendCommit()
 {
-    unsigned char   usb_buf[65];
+    int             actual;
+    unsigned char   usb_buf[64];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
     \*-----------------------------------------------------*/
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
-    /*-----------------------------------------------------*\
-    | Update last commit time                               |
-    \*-----------------------------------------------------*/
-    last_commit_time = std::chrono::steady_clock::now();
-
     /*-----------------------------------------------------*\
     | Set up Commit packet                                  |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_COMMIT;
-    usb_buf[0x02]   = 0xFF;
+    usb_buf[0x00]   = CORSAIR_LIGHTING_NODE_PACKET_ID_COMMIT;
+    usb_buf[0x01]   = 0xFF;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 17);
+    libusb_interrupt_transfer(dev, endpoint, usb_buf, 64, &actual, 0);
 }
 
 void CorsairLightingNodeController::SendBegin
@@ -294,7 +293,8 @@ void CorsairLightingNodeController::SendBegin
     unsigned char   channel
     )
 {
-    unsigned char   usb_buf[65];
+    int             actual;
+    unsigned char   usb_buf[64];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -304,15 +304,13 @@ void CorsairLightingNodeController::SendBegin
     /*-----------------------------------------------------*\
     | Set up Begin packet                                   |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_BEGIN;
-    usb_buf[0x02]   = channel;
+    usb_buf[0x00]   = CORSAIR_LIGHTING_NODE_PACKET_ID_BEGIN;
+    usb_buf[0x01]   = channel;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 17);
+    libusb_interrupt_transfer(dev, endpoint, usb_buf, 64, &actual, 0);
 }
 
 void CorsairLightingNodeController::SendEffectConfig
@@ -338,7 +336,8 @@ void CorsairLightingNodeController::SendEffectConfig
     unsigned short  temperature_2
     )
 {
-    unsigned char   usb_buf[65];
+    int             actual;
+    unsigned char   usb_buf[64];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -348,49 +347,47 @@ void CorsairLightingNodeController::SendEffectConfig
     /*-----------------------------------------------------*\
     | Set up Effect Config packet                           |
     \*-----------------------------------------------------*/
-    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;
+    usb_buf[0x00]   = CORSAIR_LIGHTING_NODE_PACKET_ID_EFFECT_CONFIG;
+    usb_buf[0x01]   = channel;
+    usb_buf[0x02]   = count * 10;
+    usb_buf[0x03]   = led_type;
 
     /*-----------------------------------------------------*\
     | Set up mode parameters                                |
     \*-----------------------------------------------------*/
-    usb_buf[0x05]   = mode;
-    usb_buf[0x06]   = speed;
-    usb_buf[0x07]   = direction;
-    usb_buf[0x08]   = change_style;
-    usb_buf[0x09]   = 0;
+    usb_buf[0x04]   = mode;
+    usb_buf[0x05]   = speed;
+    usb_buf[0x06]   = direction;
+    usb_buf[0x07]   = change_style;
+    usb_buf[0x08]   = 0;
 
     /*-----------------------------------------------------*\
     | Set up mode colors                                    |
     \*-----------------------------------------------------*/
-    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;
+    usb_buf[0x09]   = color_0_red;
+    usb_buf[0x10]   = color_0_green;
+    usb_buf[0x11]   = color_0_blue;
+    usb_buf[0x12]   = color_1_red;
+    usb_buf[0x13]   = color_1_green;
+    usb_buf[0x14]   = color_1_blue;
+    usb_buf[0x15]   = color_2_red;
+    usb_buf[0x16]   = color_2_green;
+    usb_buf[0x17]   = color_2_blue;
 
     /*-----------------------------------------------------*\
     | Set up temperatures                                   |
     \*-----------------------------------------------------*/
-    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);
+    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);
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 17);
+    libusb_interrupt_transfer(dev, endpoint, usb_buf, 64, &actual, 0);
 }
 
 void CorsairLightingNodeController::SendTemperature()
@@ -403,7 +400,8 @@ void CorsairLightingNodeController::SendReset
     unsigned char   channel
     )
 {
-    unsigned char   usb_buf[65];
+    int             actual;
+    unsigned char   usb_buf[64];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -413,15 +411,13 @@ void CorsairLightingNodeController::SendReset
     /*-----------------------------------------------------*\
     | Set up Reset packet                                   |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_RESET;
-    usb_buf[0x02]   = channel;
+    usb_buf[0x00]   = CORSAIR_LIGHTING_NODE_PACKET_ID_RESET;
+    usb_buf[0x01]   = channel;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 17);
+    libusb_interrupt_transfer(dev, endpoint, usb_buf, 64, &actual, 0);
 }
 
 void CorsairLightingNodeController::SendPortState
@@ -430,7 +426,8 @@ void CorsairLightingNodeController::SendPortState
     unsigned char   state
     )
 {
-    unsigned char   usb_buf[65];
+    int             actual;
+    unsigned char   usb_buf[64];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -440,16 +437,14 @@ void CorsairLightingNodeController::SendPortState
     /*-----------------------------------------------------*\
     | Set up Port State packet                              |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_PORT_STATE;
-    usb_buf[0x02]   = channel;
-    usb_buf[0x03]   = state;
+    usb_buf[0x00]   = CORSAIR_LIGHTING_NODE_PACKET_ID_PORT_STATE;
+    usb_buf[0x01]   = channel;
+    usb_buf[0x02]   = state;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 17);
+    libusb_interrupt_transfer(dev, endpoint, usb_buf, 64, &actual, 0);
 }
 
 void CorsairLightingNodeController::SendBrightness()

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.h

@@ -5,9 +5,8 @@
 \*---------------------------------------------------------*/
 
 #include "RGBController.h"
-#include <chrono>
 #include <vector>
-#include <hidapi/hidapi.h>
+#include <libusb-1.0/libusb.h>
 
 #pragma once
 
@@ -79,7 +78,7 @@ enum
 class CorsairLightingNodeController
 {
 public:
-    CorsairLightingNodeController(hid_device* dev_handle);
+    CorsairLightingNodeController(libusb_device_handle* dev_handle, unsigned int dev_endpoint);
     ~CorsairLightingNodeController();
 
     std::string     GetFirmwareString();
@@ -108,9 +107,9 @@ public:
     void            KeepaliveThread();
 
 private:
-    hid_device*             dev;
+    libusb_device_handle*   dev;
+    unsigned int            endpoint;
     std::string             firmware_version;
-    std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
 
     void            SendFirmwareRequest();
 

Controllers/CorsairLightingNodeController/CorsairLightingNodeControllerDetect.cpp

@@ -2,7 +2,7 @@
 #include "RGBController.h"
 #include "RGBController_CorsairLightingNode.h"
 #include <vector>
-#include <hidapi/hidapi.h>
+#include <libusb-1.0/libusb.h>
 
 #define CORSAIR_VID                     0x1B1C
 #define CORSAIR_LIGHTING_NODE_CORE_PID  0x0C1A
@@ -16,20 +16,20 @@ typedef struct
 {
     unsigned short  usb_vid;
     unsigned short  usb_pid;
+    unsigned char   usb_endpoint;
     unsigned char   channel_count;
     const char *    name;
 } corsair_node_device;
 
-#define CORSAIR_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const corsair_node_device device_list[] =
+static const corsair_node_device device_list[6] =
 {
-    { CORSAIR_VID,          CORSAIR_LIGHTING_NODE_CORE_PID,     1,      "Corsair Lighting Node Core"    },
-    { CORSAIR_VID,          CORSAIR_LIGHTING_NODE_PRO_PID,      2,      "Corsair Lighting Node Pro"     },
-    { CORSAIR_VID,          CORSAIR_COMMANDER_PRO_PID,          2,      "Corsair Commander Pro"         },
-    { CORSAIR_VID,          CORSAIR_LS100_PID,                  1,      "Corsair LS100 Lighting Kit"    },
-    { CORSAIR_VID,          CORSAIR_1000D_OBSIDIAN_PID,         2,      "Corsair 1000D Obsidian"        },
-    { CORSAIR_VID,          CORSAIR_SPEC_OMEGA_RGB_PID,         2,      "Corsair SPEC OMEGA RGB"        }
+    { CORSAIR_VID,          CORSAIR_LIGHTING_NODE_CORE_PID,     1,      1,      "Corsair Lighting Node Core"    },
+    { CORSAIR_VID,          CORSAIR_LIGHTING_NODE_PRO_PID,      1,      2,      "Corsair Lighting Node Pro"     },
+    { CORSAIR_VID,          CORSAIR_COMMANDER_PRO_PID,          2,      2,      "Corsair Commander Pro"         },
+    { CORSAIR_VID,          CORSAIR_LS100_PID,                  1,      1,      "Corsair LS100 Lighting Kit"    },
+    { CORSAIR_VID,          CORSAIR_1000D_OBSIDIAN_PID,         2,      2,      "Corsair 1000D Obsidian"        },
+    { CORSAIR_VID,          CORSAIR_SPEC_OMEGA_RGB_PID,         1,      2,      "Corsair SPEC OMEGA RGB"        }
+
 };
 
 /******************************************************************************************\
@@ -37,43 +37,31 @@ static const corsair_node_device device_list[] =
 *   DetectCorsairLightingNodeControllers                                                   *
 *                                                                                          *
 *       Detect devices supported by the Corsair Lighting Node Pro driver                   *
-*                                                                                          *
+*                                                                                          *                                                                                          *
 \******************************************************************************************/
 
 void DetectCorsairLightingNodeControllers(std::vector<RGBController*> &rgb_controllers)
 {
-    hid_device_info* info;
-    hid_device* dev;
+    libusb_context * ctx;
+    libusb_init(&ctx);
 
-    hid_init();
-
-    for(std::size_t device_idx = 0; device_idx < CORSAIR_NUM_DEVICES; device_idx++)
+    for(int device_idx = 0; device_idx < 6; device_idx++)
     {
-        dev = NULL;
+        //Look for Corsair Lighting Node Device
+        libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
 
-        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
-
-        //Look for Corsair Lighting Node Devices
-        while(info)
+        if( dev )
         {
-            if((info->vendor_id == device_list[device_idx].usb_vid)
-            &&(info->product_id == device_list[device_idx].usb_pid))
-            {
-                dev = hid_open_path(info->path);
+            libusb_detach_kernel_driver(dev, 0);
+            libusb_claim_interface(dev, 0);
 
-                if( dev )
-                {
-                    CorsairLightingNodeController* controller = new CorsairLightingNodeController(dev);
+            CorsairLightingNodeController* controller = new CorsairLightingNodeController(dev, device_list[device_idx].usb_endpoint);
 
-                    RGBController_CorsairLightingNode* rgb_controller = new RGBController_CorsairLightingNode(controller);
+            RGBController_CorsairLightingNode* rgb_controller = new RGBController_CorsairLightingNode(controller);
 
-                    rgb_controller->name = device_list[device_idx].name;
+            rgb_controller->name = device_list[device_idx].name;
 
-                    rgb_controllers.push_back(rgb_controller);
-                }
-            }
-
-            info = info->next;
+            rgb_controllers.push_back(rgb_controller);
         }
     }
 }   /* DetectCorsairLightingNodeControllers() */

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

@@ -11,8 +11,6 @@
 
 #include <cstring>
 
-using namespace std::chrono_literals;
-
 static unsigned int keys[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0C, 0x0D, 0x0E, 0x0F, 0x11, 0x12,
                               0x14, 0x15, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x24, 0x25, 0x26,
                               0x27, 0x28, 0x2A, 0x2B, 0x2C, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
@@ -22,7 +20,17 @@ static unsigned int keys[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x
                               116,  117,  120,  121,  122,  123,  124,  126,  127,  128,  129,  132,  133,  134,  135,
                               136,  137,  139,  140,  141};
 
-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++;
+}
 
 CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle)
 {
@@ -30,6 +38,7 @@ CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle)
 
     ReadFirmwareInfo();
 
+    SpecialFunctionControl();
     LightingControl();
 }
 
@@ -63,26 +72,6 @@ void CorsairPeripheralController::SetLEDs(std::vector<RGBColor>colors)
         case DEVICE_TYPE_MOUSEMAT:
             SetLEDsMousemat(colors);
             break;
-
-        case DEVICE_TYPE_HEADSET_STAND:
-            /*-----------------------------------------------------*\
-            | The logo zone of the ST100 is in the middle of the    |
-            | base LED strip, so remap the colors so that the logo  |
-            | is the last LED in the sequence.                      |
-            \*-----------------------------------------------------*/
-            std::vector<RGBColor> remap_colors;
-            remap_colors.resize(colors.size());
-
-            for(int i = 0; i < 9; i++)
-            {
-                remap_colors[st100[i]] = colors[i];
-            }
-
-            /*-----------------------------------------------------*\
-            | The ST100 uses the mousemat protocol                  |
-            \*-----------------------------------------------------*/
-            SetLEDsMousemat(remap_colors);
-            break;
     }
 }
 
@@ -218,7 +207,7 @@ void CorsairPeripheralController::SetLEDsKeyboardLimited(std::vector<RGBColor> c
 
 void CorsairPeripheralController::LightingControl()
 {
-    char usb_buf[65];
+    char usb_buf[64];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -228,44 +217,39 @@ void CorsairPeripheralController::LightingControl()
     /*-----------------------------------------------------*\
     | Set up Lighting Control packet                        |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x02]           = CORSAIR_PROPERTY_LIGHTING_CONTROL;
-    usb_buf[0x03]           = CORSAIR_LIGHTING_CONTROL_SOFTWARE;
+    usb_buf[0x00]           = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x01]           = CORSAIR_PROPERTY_LIGHTING_CONTROL;
+    usb_buf[0x02]           = CORSAIR_LIGHTING_CONTROL_SOFTWARE;
 
     /*-----------------------------------------------------*\
-    | Lighting control byte needs to be 3 for keyboards and |
-    | headset stand, 1 for mice and mousepads               |
+    | Lighting control byte needs to be 3 for keyboards, 1  |
+    | for mice and mousepads                                |
     \*-----------------------------------------------------*/
     switch(type)
     {
         default:
         case DEVICE_TYPE_KEYBOARD:
-            usb_buf[0x05]   = 0x03;
+            usb_buf[0x04]   = 0x03;
             break;
 
         case DEVICE_TYPE_MOUSE:
-            usb_buf[0x05]   = 0x01;
+            usb_buf[0x04]   = 0x01;
             break;
 
         case DEVICE_TYPE_MOUSEMAT:
-            usb_buf[0x05]   = 0x04;
-            break;
-
-        case DEVICE_TYPE_HEADSET_STAND:
-            usb_buf[0x05]   = 0x03;
+            usb_buf[0x04]   = 0x04;
             break;
     }
     
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    send_usb_msg(dev, usb_buf);
 }
 
 void CorsairPeripheralController::SpecialFunctionControl()
 {
-    char usb_buf[65];
+    char usb_buf[64];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -275,22 +259,19 @@ void CorsairPeripheralController::SpecialFunctionControl()
     /*-----------------------------------------------------*\
     | Set up Lighting Control packet                        |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x02]           = CORSAIR_PROPERTY_SPECIAL_FUNCTION;
-    usb_buf[0x03]           = CORSAIR_LIGHTING_CONTROL_SOFTWARE;
+    usb_buf[0x00]           = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x01]           = CORSAIR_PROPERTY_SPECIAL_FUNCTION;
+    usb_buf[0x02]           = CORSAIR_LIGHTING_CONTROL_SOFTWARE;
     
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    send_usb_msg(dev, usb_buf);
 }
 
 void CorsairPeripheralController::ReadFirmwareInfo()
 {
-    int  actual;
-    char usb_buf[65];
-    char offset = 0;
+    char usb_buf[64];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -300,44 +281,22 @@ void CorsairPeripheralController::ReadFirmwareInfo()
     /*-----------------------------------------------------*\
     | Set up Read Firmware Info packet                      |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = CORSAIR_COMMAND_READ;
-    usb_buf[0x02]   = CORSAIR_PROPERTY_FIRMWARE_INFO;
+    usb_buf[0x00]   = CORSAIR_COMMAND_READ;
+    usb_buf[0x01]   = 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.                                     |
+    | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char*)usb_buf, 65);
-    actual = hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000);
-
-    if(actual == 0)
-    {
-        /*-------------------------------------------------*\
-        | Zero out buffer                                   |
-        \*-------------------------------------------------*/
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        /*-------------------------------------------------*\
-        | Set up Read Firmware Info packet                  |
-        \*-------------------------------------------------*/
-        usb_buf[0x00]   = 0x00;
-        usb_buf[0x01]   = CORSAIR_COMMAND_READ;
-        usb_buf[0x02]   = CORSAIR_PROPERTY_FIRMWARE_INFO;
-
-        hid_send_feature_report(dev, (unsigned char*)usb_buf, 65);
-        actual = hid_get_feature_report(dev, (unsigned char*)usb_buf, 65);
-        offset = 1;
-    }
+    send_usb_msg(dev, usb_buf);
+    hid_get_feature_report(dev, (unsigned char*)usb_buf, 64);
 
     /*-----------------------------------------------------*\
     | Get device type                                       |
     |   0xC0    Device is a keyboard                        |
     |   0xC1    Device is a mouse                           |
-    |   0xC2    Device is a mousepad or headset stand       |
+    |   0xC2    Device is a mousepad                        |
     \*-----------------------------------------------------*/
-    switch((unsigned char)usb_buf[0x14 + offset])
+    switch((unsigned char)usb_buf[0x14])
     {
         case 0xC0:
             type = DEVICE_TYPE_KEYBOARD;
@@ -345,26 +304,10 @@ void CorsairPeripheralController::ReadFirmwareInfo()
 
         case 0xC1:
             type = DEVICE_TYPE_MOUSE;
-            SpecialFunctionControl();
             break;
 
         case 0xC2:
-            {
-                unsigned short pid = (unsigned short)(usb_buf[0x0F] << 8) + (unsigned char)(usb_buf[0x0E]);
-
-                switch(pid)
-                {
-                    case 0x0A34:
-                        type = DEVICE_TYPE_HEADSET_STAND;
-                        SpecialFunctionControl();
-                        break;
-                    
-                    default:
-                        type = DEVICE_TYPE_MOUSEMAT;
-                        SpecialFunctionControl();
-                        break;
-                }
-            }
+            type = DEVICE_TYPE_MOUSEMAT;
             break;
 
         default:
@@ -377,7 +320,7 @@ void CorsairPeripheralController::ReadFirmwareInfo()
     \*-----------------------------------------------------*/
     if(type != DEVICE_TYPE_UNKNOWN)
     {
-        firmware_version = std::to_string(usb_buf[0x09 + offset]) + "." + std::to_string(usb_buf[0x08 + offset]);
+        firmware_version = std::to_string(usb_buf[0x09]) + "." + std::to_string(usb_buf[0x08]);
     }
 }
 
@@ -388,7 +331,7 @@ void CorsairPeripheralController::StreamPacket
     unsigned char*  data_ptr
     )
 {
-    char usb_buf[65];
+    char usb_buf[64];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -398,20 +341,19 @@ void CorsairPeripheralController::StreamPacket
     /*-----------------------------------------------------*\
     | Set up Stream packet                                  |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = CORSAIR_COMMAND_STREAM;
-    usb_buf[0x02]   = packet_id;
-    usb_buf[0x03]   = data_sz;
+    usb_buf[0x00]   = CORSAIR_COMMAND_STREAM;
+    usb_buf[0x01]   = packet_id;
+    usb_buf[0x02]   = data_sz;
 
     /*-----------------------------------------------------*\
     | Copy in data bytes                                    |
     \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x05], data_ptr, data_sz);
+    memcpy(&usb_buf[0x04], data_ptr, data_sz);
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    send_usb_msg(dev, usb_buf);
 }
 
 void CorsairPeripheralController::SubmitKeyboardFullColors
@@ -421,7 +363,7 @@ void CorsairPeripheralController::SubmitKeyboardFullColors
     unsigned char   finish_val
     )
 {
-    char usb_buf[65];
+    char usb_buf[64];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -431,17 +373,16 @@ void CorsairPeripheralController::SubmitKeyboardFullColors
     /*-----------------------------------------------------*\
     | Set up Submit Keyboard 24-Bit Colors packet           |
     \*-----------------------------------------------------*/
-    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;
+    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;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    send_usb_msg(dev, usb_buf);
 }
 
 void CorsairPeripheralController::SubmitKeyboardLimitedColors
@@ -449,7 +390,7 @@ void CorsairPeripheralController::SubmitKeyboardLimitedColors
     unsigned char   byte_count
     )
 {
-    char usb_buf[65];
+    char usb_buf[64];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -459,15 +400,14 @@ void CorsairPeripheralController::SubmitKeyboardLimitedColors
     /*-----------------------------------------------------*\
     | Set up Submit Keyboard 9-Bit Colors packet            |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x02]   = CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_9;
-    usb_buf[0x05]   = byte_count;
+    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x01]   = CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_9;
+    usb_buf[0x04]   = byte_count;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    send_usb_msg(dev, usb_buf);
 }
 
 void CorsairPeripheralController::SubmitMouseColors
@@ -476,7 +416,7 @@ void CorsairPeripheralController::SubmitMouseColors
     RGBColor *      color_data
     )
 {
-    char usb_buf[65];
+    char usb_buf[64];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -486,27 +426,26 @@ void CorsairPeripheralController::SubmitMouseColors
     /*-----------------------------------------------------*\
     | Set up Submit Mouse Colors packet                     |
     \*-----------------------------------------------------*/
-    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;
+    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x01]   = CORSAIR_PROPERTY_SUBMIT_MOUSE_COLOR;
+    usb_buf[0x02]   = num_zones;
+    usb_buf[0x03]   = 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) + 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]);
+        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]);
     }
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    send_usb_msg(dev, usb_buf);
 }
 
 void CorsairPeripheralController::SubmitMousematColors
@@ -515,7 +454,7 @@ void CorsairPeripheralController::SubmitMousematColors
     RGBColor *      color_data
     )
 {
-    char usb_buf[65];
+    char usb_buf[64];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -525,25 +464,24 @@ void CorsairPeripheralController::SubmitMousematColors
     /*-----------------------------------------------------*\
     | Set up Submit Mouse Colors packet                     |
     \*-----------------------------------------------------*/
-    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;
+    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x01]   = CORSAIR_PROPERTY_SUBMIT_MOUSE_COLOR;
+    usb_buf[0x02]   = num_zones;
+    usb_buf[0x03]   = 0x00;
 
     /*-----------------------------------------------------*\
-    | Copy in colors in <RED> <GREEN> <BLUE> order          |
+    | 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 * 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]);
+        //usb_buf[(zone_idx * 4) + 4] = 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]);
     }
 
     /*-----------------------------------------------------*\
-    | Send packet using feature reports, as headset stand   |
-    | seems to not update completely using HID writes       |
+    | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-}
+    send_usb_msg(dev, usb_buf);
+}

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -25,7 +25,7 @@
 #define CORSAIR_K70_RGB_PID             0x1B13
 #define CORSAIR_K70_LUX_RGB_PID         0x1B33
 #define CORSAIR_K70_RGB_RAPIDFIRE_PID   0x1B38
-#define CORSAIR_K70_RGB_MK2_PID         0x1B49
+#define CORSAIR_K70_RGB_MK2_PID         0x1B38
 #define CORSAIR_K70_RGB_MK2_SE_PID      0x1B6B
 #define CORSAIR_K70_RGB_MK2_LP_PID      0x1B55
 
@@ -39,9 +39,6 @@
 | 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
 
@@ -51,12 +48,6 @@
 \*-----------------------------------------------------*/
 #define CORSAIR_MM800_RGB_POLARIS_PID   0x1B3B
 
-/*-----------------------------------------------------*\
-| Headset Stand product IDs                             |
-|   List taken from ckb-next                            |
-\*-----------------------------------------------------*/
-#define CORSAIR_ST100_PID               0x0A34
-
 typedef struct
 {
     unsigned short  usb_vid;
@@ -72,10 +63,6 @@ static const corsair_node_device device_list[] =
     /*-----------------------------------------------------------------------------------------------------*\
     | Keyboards                                                                                             |
     \*-----------------------------------------------------------------------------------------------------*/
-//  { CORSAIR_VID,          CORSAIR_K55_RGB_PID,                1,      "Corsair K55 RGB"                   }, //Not per-key, disabled for now
-    { CORSAIR_VID,          CORSAIR_K65_RGB_PID,                1,      "Corsair K65 RGB"                   },
-    { CORSAIR_VID,          CORSAIR_K65_LUX_RGB_PID,            1,      "Corsair K65 LUX RGB"               },
-    { CORSAIR_VID,          CORSAIR_K65_RGB_RAPIDFIRE_PID,      1,      "Corsair K65 RGB RAPIDFIRE"         },
     { CORSAIR_VID,          CORSAIR_K68_RGB,                    1,      "Corsair K68 RGB"                   },
     { CORSAIR_VID,          CORSAIR_K70_RGB_PID,                1,      "Corsair K70 RGB"                   },
     { CORSAIR_VID,          CORSAIR_K70_LUX_RGB_PID,            1,      "Corsair K70 LUX RGB"               },
@@ -85,24 +72,15 @@ static const corsair_node_device device_list[] =
     { CORSAIR_VID,          CORSAIR_K70_RGB_MK2_LP_PID,         1,      "Corsair K70 RGB MK.2 Low Profile"  },
     { CORSAIR_VID,          CORSAIR_K95_RGB_PID,                1,      "Corsair K95 RGB"                   },
     { CORSAIR_VID,          CORSAIR_K95_PLATINUM_PID,           1,      "Corsair K95 RGB PLATINUM"          },
-    { CORSAIR_VID,          CORSAIR_STRAFE_PID,                 1,      "Corsair Strafe"                    },
-    { CORSAIR_VID,          CORSAIR_STRAFE_MK2_PID,             1,      "Corsair Strafe MK.2"               },
     /*-----------------------------------------------------------------------------------------------------*\
     | Mice                                                                                                  |
     \*-----------------------------------------------------------------------------------------------------*/
-    { CORSAIR_VID,          CORSAIR_GLAIVE_RGB_PRO_PID,         1,      "Corsair Glaive RGB PRO"            },
-    { CORSAIR_VID,          CORSAIR_HARPOON_RGB_PID,            1,      "Corsair Harpoon RGB"               },
-    { CORSAIR_VID,          CORSAIR_HARPOON_RGB_PRO_PID,        1,      "Corsair Harpoon RGB PRO"           },
     { CORSAIR_VID,          CORSAIR_M65_PRO_PID,                1,      "Corsair M65 PRO"                   },
     { CORSAIR_VID,          CORSAIR_M65_RGB_ELITE_PID,          1,      "Corsair M65 RGB Elite"             },
     /*-----------------------------------------------------------------------------------------------------*\
     | Mousemats                                                                                             |
     \*-----------------------------------------------------------------------------------------------------*/
-    { CORSAIR_VID,          CORSAIR_MM800_RGB_POLARIS_PID,      0,      "Corsair MM800 RGB Polaris"         },
-    /*-----------------------------------------------------------------------------------------------------*\
-    | Headset Stands                                                                                        |
-    \*-----------------------------------------------------------------------------------------------------*/
-    { CORSAIR_VID,          CORSAIR_ST100_PID,                  0,      "Corsair ST100 RGB"                 }
+    { CORSAIR_VID,          CORSAIR_MM800_RGB_POLARIS_PID,      0,      "Corsair MM800 RGB Polaris"         }
 };
 
 /******************************************************************************************\
@@ -130,31 +108,30 @@ 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/CorsairVengeanceProController/CorsairVengeanceProController.cpp

@@ -10,7 +10,16 @@
 #include "CorsairVengeanceProController.h"
 #include <cstring>
 
-using namespace std::chrono_literals;
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
 
 CorsairVengeanceProController::CorsairVengeanceProController(i2c_smbus_interface* bus, corsair_dev_id dev)
 {
@@ -80,9 +89,9 @@ void CorsairVengeanceProController::SetLEDColor(unsigned int led, unsigned char
 void CorsairVengeanceProController::ApplyColors()
 {
     bus->i2c_smbus_write_byte_data(dev, 0x26, 0x02);
-    std::this_thread::sleep_for(1ms);
+    Sleep(1);
     bus->i2c_smbus_write_byte_data(dev, 0x21, 0x00);
-    std::this_thread::sleep_for(1ms);
+    Sleep(1);
 
     for (int i = 0; i < 10; i++)
     {
@@ -110,9 +119,9 @@ void CorsairVengeanceProController::SetEffect(unsigned char mode,
     effect_mode = mode;
 
     bus->i2c_smbus_write_byte_data(dev, 0x26, 0x01);
-    std::this_thread::sleep_for(1ms);
+    Sleep(1);
     bus->i2c_smbus_write_byte_data(dev, 0x21, 0x00);
-    std::this_thread::sleep_for(1ms);
+    Sleep(1);
 
     unsigned char random_byte;
 
@@ -156,7 +165,7 @@ bool CorsairVengeanceProController::WaitReady()
     while (bus->i2c_smbus_read_byte_data(dev, 0x41) != 0x00)
     {
         i++;
-        std::this_thread::sleep_for(1ms);
+        Sleep(1);
     }
 
     return false;

Controllers/CorsairVengeanceProController/CorsairVengeanceProControllerDetect.cpp

@@ -6,7 +6,16 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-using namespace std::chrono_literals;
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
 
 /******************************************************************************************\
 *                                                                                          *
@@ -41,7 +50,7 @@ bool TestForCorsairVengeanceProController(i2c_smbus_interface* bus, unsigned cha
         }
     }
 
-    std::this_thread::sleep_for(10ms);
+    Sleep(10);
     
     return(pass);
 

Controllers/DuckyKeyboardController/DuckyKeyboardController.cpp

@@ -1,187 +0,0 @@
-/*-----------------------------------------*\
-|  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

@@ -1,41 +0,0 @@
-/*-----------------------------------------*\
-|  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

@@ -1,81 +0,0 @@
-#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/GloriousModelOController/GloriousModelOController.cpp

@@ -1,278 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_GloriousModelO.cpp         |
-|                                           |
-|  Definitions and types for Glorious       |
-|  and other Mice                           |
-|                                           |
-|  Niels Westphal (crashniels) 20/5/2020    |
-\*-----------------------------------------*/
-
-#include "GloriousModelOController.h"
-#include <cstring>
-
-using namespace std::chrono_literals;
-
-GloriousModelOController::GloriousModelOController(hid_device* dev_handle)
-{
-    dev = dev_handle;
-
-    strcpy(device_name, "Glorious Mouse");
-    led_count = 1;
-
-    current_mode      = GLORIOUS_MODE_STATIC;
-    current_speed     = GLORIOUS_SPEED_NORMAL;
-    current_direction = GLORIOUS_DIRECTION_UP;
-
-}
-
-GloriousModelOController::~GloriousModelOController()
-{
-
-}
-
-std::string GloriousModelOController::GetDeviceName()
-{
-    return(device_name);
-}
-
-
-
-unsigned int GloriousModelOController::GetLEDCount()
-{
-    return(led_count);
-}
-
-void GloriousModelOController::SetLEDColor(RGBColor* color_buf)
-{
-    unsigned char usb_buf[520] =
-    {
-        0x04, 0x11, 0x00, 0x7b,
-        0x00, 0x00, 0x00, 0x00, 0x64, 0x06, 0x04, 0x24,
-        0xf0, 0x03, 0x07, 0x0f, 0x1f, 0x31, 0x63, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff,
-        0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
-        0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x02, 0x41, 0x01, 0x40, 0xff, 0xff, 0xff,
-        0x42, 0x07, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00,
-        0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff,
-        0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x43,
-        0x42, 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,
-        0x42, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00,
-        0x42, 0x02, 0xff, 0x00, 0x00, 0x01, 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, 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, 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,
-        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, 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, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00
-    };
-
-    usb_buf[0x0B] = 0x24;
-    usb_buf[0x35] = GLORIOUS_MODE_STATIC;
-    usb_buf[0x38] = 0x40; //max brightness
-    usb_buf[0x39] = RGBGetRValue(color_buf[0]);
-    usb_buf[0x3A] = RGBGetBValue(color_buf[0]);
-    usb_buf[0x3B] = RGBGetGValue(color_buf[0]);
-
-    //DPI Button
-    /*
-    usb_buf[0x0B] = 0x44; //third DPI
-    usb_buf[0x26] = red;
-    usb_buf[0x27] = blue;
-    usb_buf[0x28] = green;
-    */
-
-    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
-    std::this_thread::sleep_for(1ms);
-}
-
-void GloriousModelOController::SetMode(unsigned char mode,
-                                       unsigned char speed,
-                                       unsigned char direction,
-                                       RGBColor* color_buf)
-{
-    unsigned char usb_buf[520] =
-    {
-        0x04, 0x11, 0x00, 0x7b,
-        0x00, 0x00, 0x00, 0x00, 0x64, 0x06, 0x04, 0x24,
-        0xf0, 0x03, 0x07, 0x0f, 0x1f, 0x31, 0x63, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff,
-        0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
-        0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x02, 0x41, 0x01, 0x40, 0xff, 0xff, 0xff,
-        0x42, 0x07, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00,
-        0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff,
-        0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x43,
-        0x42, 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,
-        0x42, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00,
-        0x42, 0x02, 0xff, 0x00, 0x00, 0x01, 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, 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, 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,
-        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, 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, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00
-    };
-
-    usb_buf[0x35] = mode;
-
-    switch (mode)
-    {
-    case GLORIOUS_MODE_OFF:
-        usb_buf[0x81] = 0x00; //mode 0 either 0x00 or 0x03
-        break;
-    case GLORIOUS_MODE_RAINBOW:
-        usb_buf[0x36] = speed;
-        usb_buf[0x37] = direction;
-        break;
-    case GLORIOUS_MODE_SPECTRUM_BREATING:
-        //colours not yet researched
-        usb_buf[0x3C] = speed; //speed for mode 3
-        usb_buf[0x3D] = 0x07;  //maybe some kind of bank change?+
-        //usb_buf[0x3D] = 0x06;
-        usb_buf[0x3E] = RGBGetRValue(color_buf[0]);  //mode 3 red 1
-        usb_buf[0x3F] = RGBGetBValue(color_buf[0]);  //mode 3 blue 1
-        usb_buf[0x40] = RGBGetGValue(color_buf[0]);  //mode 3 green 1
-        usb_buf[0x41] = RGBGetRValue(color_buf[1]);  //mode 3 red 2
-        usb_buf[0x42] = RGBGetBValue(color_buf[1]);  //mode 3 blue 2
-        usb_buf[0x43] = RGBGetGValue(color_buf[1]);  //mode 3 green 2
-        usb_buf[0x44] = RGBGetRValue(color_buf[2]);  //mode 3 red 3
-        usb_buf[0x45] = RGBGetBValue(color_buf[2]);  //mode 3 blue 3
-        usb_buf[0x46] = RGBGetGValue(color_buf[2]);  //mode 3 green 3
-        usb_buf[0x47] = RGBGetRValue(color_buf[3]);  //mode 3 red 4
-        usb_buf[0x48] = RGBGetBValue(color_buf[3]);  //mode 3 blue 4
-        usb_buf[0x49] = RGBGetGValue(color_buf[3]);  //mode 3 green 4
-        usb_buf[0x4A] = RGBGetRValue(color_buf[4]);  //mode 3 red 5
-        usb_buf[0x4B] = RGBGetBValue(color_buf[4]);  //mode 3 blue 5
-        usb_buf[0x4C] = RGBGetGValue(color_buf[4]);  //mode 3 green 5
-        usb_buf[0x4D] = RGBGetRValue(color_buf[5]);  //mode 3 red 6
-        usb_buf[0x4E] = RGBGetBValue(color_buf[5]);  //mode 3 blue 6
-        usb_buf[0x4F] = RGBGetGValue(color_buf[5]);  //mode 3 green 6
-        usb_buf[0x50] = RGBGetRValue(color_buf[6]);  //mode 3 red 7
-        usb_buf[0x51] = RGBGetBValue(color_buf[6]);  //mode 3 blue 7
-        usb_buf[0x52] = RGBGetGValue(color_buf[6]);  //mode 3 green 7
-        break;
-    case GLORIOUS_MODE_TAIL:
-        usb_buf[0x53] = speed; //Speed for mode 4
-        break;
-    case GLORIOUS_MODE_SPECTRUM_CYCLE:
-        usb_buf[0x54] = speed; //Speed for mode 1,2,5
-        break;
-    case GLORIOUS_MODE_RAVE:
-        usb_buf[0x74] = speed; //Speed for mode 7
-        usb_buf[0x75] = RGBGetRValue(color_buf[0]); //mode 7 red 1
-        usb_buf[0x76] = RGBGetBValue(color_buf[0]); //mode 7 blue 1
-        usb_buf[0x77] = RGBGetGValue(color_buf[0]); //mode 7 green 1
-        usb_buf[0x78] = RGBGetRValue(color_buf[1]); //mode 7 red 2
-        usb_buf[0x79] = RGBGetBValue(color_buf[1]); //mode 7 blue 2
-        usb_buf[0x7A] = RGBGetGValue(color_buf[1]); //mode 7 green 2
-        break;
-    case GLORIOUS_MODE_WAVE:
-        usb_buf[0x7C] = speed; //Speed for mode 9
-        break;
-    case GLORIOUS_MODE_BREATHING:
-        usb_buf[0x7D] = speed;
-        usb_buf[0x7E] = RGBGetRValue(color_buf[0]); //mode 0a red
-        usb_buf[0x7F] = RGBGetBValue(color_buf[0]); //mode 0a blue
-        usb_buf[0x80] = RGBGetGValue(color_buf[0]); //mode 0a green
-    default:
-        break;
-    }
-
-    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
-    std::this_thread::sleep_for(1ms);
-}

Controllers/GloriousModelOController/GloriousModelOController.h

@@ -1,71 +0,0 @@
-/*-----------------------------------------*\
-|  GloriousModelOController.h               |
-|                                           |
-|  Definitions and types for Glorious       |
-|  and other Mice                           |
-|                                           |
-|  Niels Westphal (crashniels) 20/5/2020    |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <vector>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    GLORIOUS_MODE_OFF = 0x00, //does nothing
-    GLORIOUS_MODE_RAINBOW = 0x01,
-    GLORIOUS_MODE_STATIC = 0x02,
-    GLORIOUS_MODE_SPECTRUM_BREATING = 0x03,
-    GLORIOUS_MODE_TAIL = 0x04,
-    GLORIOUS_MODE_SPECTRUM_CYCLE = 0x05,
-    GLORIOUS_MODE_RAVE = 0x07,
-    GLORIOUS_MODE_EPILEPSY = 0x08, //not in the official software
-    GLORIOUS_MODE_WAVE = 0x09,
-    GLORIOUS_MODE_BREATHING = 0x0a,
-};
-
-enum
-{
-    GLORIOUS_SPEED_SLOW = 0x41,
-    GLORIOUS_SPEED_NORMAL = 0x42,
-    GLORIOUS_SPEED_FAST = 0x43,
-};
-
-enum
-{
-    GLORIOUS_DIRECTION_UP = 0x00,
-    GLORIOUS_DIRECTION_DOWN = 0x01,
-};
-
-enum
-{
-    GLORIOUS_MODE_BREATING_SLOW = 0x01,
-    GLORIOUS_MODE_BREATING_NORMAL = 0x02,
-    GLORIOUS_MODE_BREATING_FAST = 0x03,
-};
-
-class GloriousModelOController
-{
-public:
-    GloriousModelOController(hid_device* dev_handle);
-    ~GloriousModelOController();
-
-    std::string     GetDeviceName();
-    unsigned int    GetLEDCount();
-
-    void            SetLEDColor(RGBColor* color_buf);
-    void            SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor* color_buf);
-private:
-    hid_device*             dev;
-
-    char                    device_name[32];
-    unsigned int            led_count;
-
-    unsigned char           current_mode;
-    unsigned char           current_speed;
-    unsigned char           current_direction;
-
-};

Controllers/GloriousModelOController/GloriousModelOControllerDetect.cpp

@@ -1,60 +0,0 @@
-#include "GloriousModelOController.h"
-#include "RGBController.h"
-#include "RGBController_GloriousModelO.h"
-#include <vector>
-#include <hidapi/hidapi.h>
-
-#define Glorious_Model_O_VID 0x258A
-#define Glorious_Model_O_PID 0x0036
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectGloriousModelController                                                          *
-*                                                                                          *
-*       Tests the USB address to see if a Glorious Model O controller exists there.        *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectGloriousModelOControllers(std::vector<RGBController*>& rgb_controllers)
-{
-    hid_device_info* info;
-    hid_device* dev = NULL;
-
-    hid_init();
-
-    dev = NULL;
-
-    info = hid_enumerate(Glorious_Model_O_VID, Glorious_Model_O_PID);
-
-    //Look for Glorious Model O
-    while(info)
-    {
-        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;
-        }
-        else
-        {
-            info = info->next;
-        }
-    }
-
-    if( dev )
-    {
-        GloriousModelOController* controller = new GloriousModelOController(dev);
-
-        RGBController_GloriousModelO* rgb_controller = new RGBController_GloriousModelO(controller);
-
-        rgb_controller->name = "Glorious Mouse";
-
-        rgb_controllers.push_back(rgb_controller);
-    }
-}

Controllers/Hue2Controller/Hue2Controller.cpp

@@ -4,123 +4,54 @@
 |  Adam Honse (calcprogrammer1@gmail.com), 12/29/2016       |
 \*---------------------------------------------------------*/
 
-#include "NZXTHue2Controller.h"
+#include "Hue2Controller.h"
 
 #include <fstream>
 #include <iostream>
 #include <string>
 #include <cstring>
 
-NZXTHue2Controller::NZXTHue2Controller(hid_device* dev_handle, unsigned int rgb_channels, unsigned int fan_channels)
+Hue2Controller::Hue2Controller(libusb_device_handle* dev_handle)
 {
     dev = dev_handle;
 
-    num_fan_channels = fan_channels;
-    num_rgb_channels = rgb_channels;
-
-    SendFirmwareRequest();
-    UpdateDeviceList();
-
-    fan_cmd.resize(num_fan_channels);
-    fan_rpm.resize(num_fan_channels);
-    UpdateStatus();
+    GetStripsOnChannel(HUE_2_CHANNEL_1);
 }
 
-NZXTHue2Controller::~NZXTHue2Controller()
+Hue2Controller::~Hue2Controller()
 {
 
 }
 
-unsigned char NZXTHue2Controller::GetFanCommand
-    (
-    unsigned char   fan_channel
-    )
+unsigned int Hue2Controller::GetStripsOnChannel(unsigned int /*channel*/)
 {
-    return(fan_cmd[fan_channel]);
-}
+    unsigned int ret_val = 0;
 
-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);
-}
-
-void NZXTHue2Controller::SendFan
-    (
-        unsigned char       port,
-        unsigned char       mode,
-        unsigned char       speed
-    )
-{
-    unsigned char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | 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);
-}
-
-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
+    unsigned char usb_buf[] =
     {
-        ret_val = hid_read(dev, usb_buf, sizeof(usb_buf));
-    } while( (ret_val != 64) || (usb_buf[0] != 0x21) || (usb_buf[1] != 0x03) );
+        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
+    };
+    int             actual = 0;
 
-    for(int chan = 0; chan < num_rgb_channels; chan++)
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x81, usb_buf, 64, &actual, 0);
+
+    for(int chan = 0; chan < 4; chan++)
     {
         unsigned int start = 0x0F + (6 * chan);
         unsigned int num_leds_on_channel = 0;
@@ -154,46 +85,10 @@ void NZXTHue2Controller::UpdateDeviceList()
         }
         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
+void Hue2Controller::SetChannelEffect
     (
     unsigned char   channel,
     unsigned char   mode,
@@ -223,7 +118,7 @@ void NZXTHue2Controller::SetChannelEffect
     SendEffect(channel, mode, speed, direction, num_colors, &color_data[0]);
 }
 
-void NZXTHue2Controller::SetChannelLEDs
+void Hue2Controller::SetChannelLEDs
     (
     unsigned char   channel,
     RGBColor *      colors,
@@ -267,11 +162,12 @@ void NZXTHue2Controller::SetChannelLEDs
 | Private packet sending functions.                                                                 |
 \*-------------------------------------------------------------------------------------------------*/
 
-void NZXTHue2Controller::SendApply
+void Hue2Controller::SendApply
     (
     unsigned char   channel
     )
 {
+    int             actual;
     unsigned char   usb_buf[64];
 
     /*-----------------------------------------------------*\
@@ -294,11 +190,11 @@ void NZXTHue2Controller::SendApply
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 64);
-    //hid_read(dev, usb_buf, 64);
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x81, usb_buf, 64, &actual, 0);
 }
 
-void NZXTHue2Controller::SendDirect
+void Hue2Controller::SendDirect
     (
     unsigned char   channel,
     unsigned char   group,
@@ -306,6 +202,7 @@ void NZXTHue2Controller::SendDirect
     unsigned char*  color_data
     )
 {
+    int             actual;
     unsigned char   usb_buf[64];
 
     /*-----------------------------------------------------*\
@@ -329,11 +226,11 @@ void NZXTHue2Controller::SendDirect
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 64);
-    //hid_read(dev, usb_buf, 64);
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x81, usb_buf, 64, &actual, 0);
 }
 
-void NZXTHue2Controller::SendEffect
+void Hue2Controller::SendEffect
     (
     unsigned char   channel,
     unsigned char   mode,
@@ -343,6 +240,7 @@ void NZXTHue2Controller::SendEffect
     unsigned char*  color_data
     )
 {
+    int             actual;
     unsigned char   usb_buf[64];
 
     /*-----------------------------------------------------*\
@@ -383,35 +281,6 @@ void NZXTHue2Controller::SendEffect
     \*-----------------------------------------------------*/
     memcpy(&usb_buf[0x0A], color_data, color_count * 3);
 
-    hid_write(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);
-
-    /*-----------------------------------------------------*\
-    | 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]);
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x81, usb_buf, 64, &actual, 0);
 }

Controllers/Hue2Controller/Hue2Controller.h

@@ -5,9 +5,8 @@
 \*---------------------------------------------------------*/
 
 #include "RGBController.h"
-#include <string>
 #include <vector>
-#include <hidapi/hidapi.h>
+#include <libusb-1.0/libusb.h>
 
 #pragma once
 
@@ -51,33 +50,15 @@ enum
     HUE_2_NUM_MODES                         /* Number of Hue 2 modes        */
 };
 
-class NZXTHue2Controller
+class Hue2Controller
 {
 public:
-    NZXTHue2Controller(hid_device* dev_handle, unsigned int rgb_channels, unsigned int fan_channels);
-    ~NZXTHue2Controller();
+    Hue2Controller(libusb_device_handle* dev_handle);
+    ~Hue2Controller();
 
-    std::string     GetFirmwareVersion();
-
-    unsigned char   GetFanCommand
+    unsigned int    GetStripsOnChannel
                         (
-                        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
+                        unsigned int    channel
                         );
 
     void            SetChannelEffect
@@ -96,22 +77,11 @@ 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;
+    libusb_device_handle*   dev;
 
     void            SendApply
                         (
@@ -135,6 +105,4 @@ private:
                         unsigned char   color_count,
                         unsigned char*  color_data
                         );
-
-    void            SendFirmwareRequest();
 };

Controllers/Hue2Controller/Hue2ControllerDetect.cpp

@@ -0,0 +1,53 @@
+#include "Hue2Controller.h"
+#include "RGBController.h"
+#include "RGBController_Hue2.h"
+#include <vector>
+#include <libusb-1.0/libusb.h>
+
+#define NZXT_HUE_2_VID 0x1E71
+#define NZXT_HUE_2_PID 0x2001
+#define NZXT_SMART_DEVICE_V2_PID 0x2006
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectHue2Controllers                                                                  *
+*                                                                                          *
+*       Detect devices supported by the Hue2 driver                                        *
+*                                                                                          *                                                                                          *
+\******************************************************************************************/
+
+void DetectHue2Controllers(std::vector<RGBController*> &rgb_controllers)
+{
+    libusb_context * ctx;
+    libusb_init(&ctx);
+
+    //Look for NZXT Hue 2
+    libusb_device_handle * hue_2_dev = libusb_open_device_with_vid_pid(ctx, NZXT_HUE_2_VID, NZXT_HUE_2_PID);
+
+    if( hue_2_dev )
+    {
+        libusb_detach_kernel_driver(hue_2_dev, 0);
+        libusb_claim_interface(hue_2_dev, 0);
+
+        Hue2Controller* controller = new Hue2Controller(hue_2_dev);
+
+        RGBController_Hue2* rgb_controller = new RGBController_Hue2(controller);
+
+        rgb_controllers.push_back(rgb_controller);
+    }
+
+    //Look for NZXT Smart Device V2
+    libusb_device_handle * smart_dev_2_dev = libusb_open_device_with_vid_pid(ctx, NZXT_HUE_2_VID, NZXT_SMART_DEVICE_V2_PID);
+
+    if( smart_dev_2_dev )
+    {
+        libusb_detach_kernel_driver(smart_dev_2_dev, 0);
+        libusb_claim_interface(smart_dev_2_dev, 0);
+
+        Hue2Controller* controller = new Hue2Controller(smart_dev_2_dev);
+
+        RGBController_Hue2* rgb_controller = new RGBController_Hue2(controller);
+
+        rgb_controllers.push_back(rgb_controller);
+    }
+}   /* DetectHuePlusControllers() */

Controllers/HuePlusController/HuePlusController.cpp

@@ -11,7 +11,16 @@
 #include <string>
 #include <cstring>
 
-using namespace std::chrono_literals;
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
 
 HuePlusController::HuePlusController()
 {
@@ -55,7 +64,7 @@ unsigned int HuePlusController::GetLEDsOnChannel(unsigned int channel)
     serialport->serial_write((char *)serial_buf, 2);
     serialport->serial_flush_tx();
 
-    std::this_thread::sleep_for(50ms);
+    Sleep(50);
 
     int bytes_read = serialport->serial_read((char *)serial_buf, 5);
 
@@ -235,5 +244,5 @@ void HuePlusController::SendPacket
     /*-----------------------------------------------------*\
     | Delay to allow Hue+ device to ready for next packet   |
     \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(20ms);
+    Sleep(20);
 }

Controllers/HyperXDRAMController/HyperXDRAMControllerDetect.cpp

@@ -6,7 +6,16 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-using namespace std::chrono_literals;
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
 
 /******************************************************************************************\
 *                                                                                          *
@@ -67,7 +76,7 @@ void DetectHyperXDRAMControllers(std::vector<i2c_smbus_interface*> &busses, std:
         {
             busses[bus]->i2c_smbus_write_byte_data(0x37, 0x00, 0xFF);
 
-            std::this_thread::sleep_for(1ms);
+            Sleep(1);
             
             for(int slot_addr = 0x50; slot_addr <= 0x57; slot_addr++)
             {
@@ -80,7 +89,7 @@ void DetectHyperXDRAMControllers(std::vector<i2c_smbus_interface*> &busses, std:
                     slots_valid |= (1 << (slot_addr - 0x50));
                 }
 
-                std::this_thread::sleep_for(1ms);
+                Sleep(1);
             }
 
             if(slots_valid != 0)

Controllers/HyperXKeyboardController/HyperXAlloyOriginsController.cpp

@@ -1,116 +0,0 @@
-/*-----------------------------------------*\
-|  HyperXAlloyOriginsController.cpp         |
-|                                           |
-|  Driver for HyperX Alloy Origins RGB      |
-|  Keyboard lighting controller             |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 7/11/2020   |
-\*-----------------------------------------*/
-
-#include "HyperXAlloyOriginsController.h"
-
-#include <cstring>
-
-HyperXAlloyOriginsController::HyperXAlloyOriginsController(hid_device* dev_handle)
-{
-    dev = dev_handle;
-}
-
-HyperXAlloyOriginsController::~HyperXAlloyOriginsController()
-{
-
-}
-
-void HyperXAlloyOriginsController::SetLEDsDirect(std::vector<RGBColor> colors)
-{
-    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[1], 64);
-}
-
-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[1], 64);
-}

Controllers/HyperXKeyboardController/HyperXAlloyOriginsController.h

@@ -1,34 +0,0 @@
-/*-----------------------------------------*\
-|  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

@@ -11,17 +11,26 @@
 
 #include <cstring>
 
-using namespace std::chrono_literals;
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
+
 
 static unsigned int keys[] = {0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14,
-                              0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x20, 0x21, 0x22,
-                              0x23, 0x24, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
-                              0x31, 0x32, 0x33, 0x34, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3E, 0x3F, 0x41,
-                              0x44, 0x45, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x51, 0x54, 0x55,
-                              0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5E, 0x5F, 0x61, 0x64, 0x65, 0x68, 0x69, 0x6A,
-                              0x6B, 0x6C, 0x6E, 0x6F, 0x74, 0x75, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
-                              0x7F, 0x81, 0x84, 0x85, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x91,
-                              0x94, 0x95 };
+                              0x15, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1D, 0x1E, 0x20, 0x21, 0x22, 0x23, 0x24,
+                              0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32,
+                              0x33, 0x34, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3E, 0x3F, 0x41, 0x44, 0x45,
+                              0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x51, 0x54, 0x55, 0x58, 0x59,
+                              0x5A, 0x5B, 0x5C, 0x5E, 0x5F, 0x61, 0x64, 0x65, 0x68, 0x69, 0x6A, 0x6B, 0x6C,
+                              0x6E, 0x6F, 0x74, 0x75, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x81,
+                              0x84, 0x85, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x91, 0x94, 0x95 };
 
 static unsigned int extended_red[] = {0x08, 0x48, 0x88, 0x09, 0x89, 0x0A, 0x8A, 0x0B, 0x8B, 0x0C, 0x8C, 0x0D, 0x8D, 0x0E, 0x8F, 0x8E, 0x0F, 0x4F, 0x92, 0x13, 0x93, 0x12 };
 static unsigned int extended_grn[] = {0x29, 0x28, 0x78, 0x19, 0x79, 0x1A, 0x7A, 0x1B, 0x7B, 0x1C, 0x7C, 0x1D, 0x7D, 0x1E, 0x6E, 0x7E, 0x1F, 0x6F, 0x82, 0x23, 0x83, 0x22 };
@@ -98,17 +107,17 @@ void HyperXKeyboardController::SetMode
         mode_colors[8]
         );
 
-    std::this_thread::sleep_for(100ms);
+    Sleep(100);
 }
 
 void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
 {
-    unsigned char red_color_data[106];
-    unsigned char grn_color_data[106];
-    unsigned char blu_color_data[106];
+    unsigned char red_color_data[104];
+    unsigned char grn_color_data[104];
+    unsigned char blu_color_data[104];
     unsigned char ext_color_data[150];
 
-    for(std::size_t i = 0; i < 106; i++)
+    for(std::size_t i = 0; i < 104; i++)
     {
         red_color_data[i] = RGBGetRValue(colors[i]);
         grn_color_data[i] = RGBGetGValue(colors[i]);
@@ -117,9 +126,9 @@ void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
 
     for(std::size_t i = 0; i < 22; i++)
     {
-        ext_color_data[extended_red[i]] = RGBGetRValue(colors[i + 106]);
-        ext_color_data[extended_grn[i]] = RGBGetGValue(colors[i + 106]);
-        ext_color_data[extended_blu[i]] = RGBGetBValue(colors[i + 106]);
+        ext_color_data[extended_red[i]] = RGBGetRValue(colors[i + 104]);
+        ext_color_data[extended_grn[i]] = RGBGetGValue(colors[i + 104]);
+        ext_color_data[extended_blu[i]] = RGBGetBValue(colors[i + 104]);
     }
 
     SendDirect
@@ -128,7 +137,7 @@ void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
         red_color_data
         );
 
-    std::this_thread::sleep_for(5ms);
+    Sleep(5);
 
     SendDirect
         (
@@ -136,7 +145,7 @@ void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
         grn_color_data
         );
 
-    std::this_thread::sleep_for(5ms);
+    Sleep(5);
 
     SendDirect
         (
@@ -144,22 +153,22 @@ void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
         blu_color_data
         );
 
-    //std::this_thread::sleep_for(5ms);
+    Sleep(5);
 
-    //SendDirectExtended
-    //    (
-    //    ext_color_data
-    //    );
+    SendDirectExtended
+        (
+        ext_color_data
+        );
 }
 
 void HyperXKeyboardController::SetLEDs(std::vector<RGBColor> colors)
 {
-    unsigned char red_color_data[106];
-    unsigned char grn_color_data[106];
-    unsigned char blu_color_data[106];
+    unsigned char red_color_data[104];
+    unsigned char grn_color_data[104];
+    unsigned char blu_color_data[104];
     unsigned char ext_color_data[150];
 
-    for(std::size_t i = 0; i < 106; i++)
+    for(std::size_t i = 0; i < 104; i++)
     {
         red_color_data[i] = RGBGetRValue(colors[i]);
         grn_color_data[i] = RGBGetGValue(colors[i]);
@@ -168,9 +177,9 @@ void HyperXKeyboardController::SetLEDs(std::vector<RGBColor> colors)
 
     for(std::size_t i = 0; i < 22; i++)
     {
-        ext_color_data[extended_red[i]] = RGBGetRValue(colors[i + 106]);
-        ext_color_data[extended_grn[i]] = RGBGetGValue(colors[i + 106]);
-        ext_color_data[extended_blu[i]] = RGBGetBValue(colors[i + 106]);
+        ext_color_data[extended_red[i]] = RGBGetRValue(colors[i + 104]);
+        ext_color_data[extended_grn[i]] = RGBGetGValue(colors[i + 104]);
+        ext_color_data[extended_blu[i]] = RGBGetBValue(colors[i + 104]);
     }
 
     SendColor
@@ -180,7 +189,7 @@ void HyperXKeyboardController::SetLEDs(std::vector<RGBColor> colors)
         red_color_data
         );
 
-    std::this_thread::sleep_for(5ms);
+    Sleep(5);
 
     SendColor
         (
@@ -189,7 +198,7 @@ void HyperXKeyboardController::SetLEDs(std::vector<RGBColor> colors)
         grn_color_data
         );
 
-    std::this_thread::sleep_for(5ms);
+    Sleep(5);
 
     SendColor
         (
@@ -198,7 +207,7 @@ void HyperXKeyboardController::SetLEDs(std::vector<RGBColor> colors)
         blu_color_data
         );
 
-    std::this_thread::sleep_for(5ms);
+    Sleep(5);
     
     SendExtendedColor
         (
@@ -366,7 +375,7 @@ void HyperXKeyboardController::SendColor
     /*-----------------------------------------------------*\
     | Fill in color data                                    |
     \*-----------------------------------------------------*/
-    for(int i = 0; i < 106; i++)
+    for(int i = 0; i < 104; i++)
     {
         buf[keys[i]] = color_data[i];
     }
@@ -431,12 +440,11 @@ void HyperXKeyboardController::SendDirect
     buf[0x00]   = 0x07;
     buf[0x01]   = HYPERX_PACKET_ID_DIRECT;
     buf[0x02]   = color_channel;
-    buf[0x03]   = 0xA0;
 
     /*-----------------------------------------------------*\
     | Fill in color data                                    |
     \*-----------------------------------------------------*/
-    for(int i = 0; i < 106; i++)
+    for(int i = 0; i < 104; i++)
     {
         buf[keys[i]] = color_data[i];
     }
@@ -465,7 +473,6 @@ 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,38 +1,11 @@
-#include "HyperXAlloyOriginsController.h"
 #include "HyperXKeyboardController.h"
 #include "RGBController.h"
-#include "RGBController_HyperXAlloyOrigins.h"
 #include "RGBController_HyperXKeyboard.h"
 #include <vector>
 #include <hidapi/hidapi.h>
 
-/*-----------------------------------------------------*\
-| HyperX keyboard vendor IDs                            |
-\*-----------------------------------------------------*/
 #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
-{
-    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[] =
-{
-    /*-----------------------------------------------------------------------------------------------------*\
-    | 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"                      },
-};
 
 /******************************************************************************************\
 *                                                                                          *
@@ -49,59 +22,30 @@ void DetectHyperXKeyboardControllers(std::vector<RGBController*>& rgb_controller
 
     hid_init();
 
-    for(std::size_t device_idx = 0; device_idx < HYPERX_NUM_DEVICES; device_idx++)
+    info = hid_enumerate(HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_PID);
+
+    //Look for HyperX Keyboard, Interface 2
+    while(info)
     {
-        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 == HYPERX_KEYBOARD_VID)
+         &&(info->product_id == HYPERX_ALLOY_ELITE_PID)
+         &&(info->interface_number == 2))
+        {
+            dev = hid_open_path(info->path);
+            break;
+        }
+        else
         {
-            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);
-
-                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);
-                }
-            }
-
             info = info->next;
         }
     }
+
+    if( dev )
+    {
+        HyperXKeyboardController* controller = new HyperXKeyboardController(dev);
+
+        RGBController_HyperXKeyboard* rgb_controller = new RGBController_HyperXKeyboard(controller);
+
+        rgb_controllers.push_back(rgb_controller);
+    }
 }

Controllers/LogitechController/LogitechControllerDetect.cpp

@@ -1,196 +0,0 @@
-#include "LogitechG203Controller.h"
-#include "LogitechG403Controller.h"
-#include "LogitechG810Controller.h"
-#include "RGBController.h"
-#include "RGBController_LogitechG203.h"
-#include "RGBController_LogitechG403.h"
-#include "RGBController_LogitechG810.h"
-#include <vector>
-#include <hidapi/hidapi.h>
-
-/*-----------------------------------------------------*\
-| Logitech vendor ID                                    |
-\*-----------------------------------------------------*/
-#define LOGITECH_VID                    0x046D
-/*-----------------------------------------------------*\
-| Keyboard product IDs                                  |
-\*-----------------------------------------------------*/
-#define LOGITECH_G810_1_PID             0xC337
-#define LOGITECH_G810_2_PID             0xC331
-#define LOGITECH_G512_PID               0xC342
-/*-----------------------------------------------------*\
-| Mouse product IDs                                     |
-\*-----------------------------------------------------*/
-#define LOGITECH_G203_PID               0xC084
-#define LOGITECH_G403_PID               0xC083
-#define LOGITECH_G403H_PID              0xC08F
-
-typedef struct
-{
-    unsigned short  usb_vid;
-    unsigned short  usb_pid;
-    unsigned char   usb_interface;
-    device_type     type;
-    const char *    name;
-} logitech_device;
-
-#define LOGITECH_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const logitech_device device_list[] =
-{
-    /*-------------------------------------------------------------------------------------------------------------*\
-    | Keyboards                                                                                                     |
-    \*-------------------------------------------------------------------------------------------------------------*/
-    { LOGITECH_VID,             LOGITECH_G810_1_PID,    1,  DEVICE_TYPE_KEYBOARD,   "Logitech G810 Orion Spectrum"  },
-    { LOGITECH_VID,             LOGITECH_G810_2_PID,    1,  DEVICE_TYPE_KEYBOARD,   "Logitech G810 Orion Spectrum"  },
-    { LOGITECH_VID,             LOGITECH_G512_PID,      1,  DEVICE_TYPE_KEYBOARD,   "Logitech G512"                 },
-    /*-------------------------------------------------------------------------------------------------------------*\
-    | Mice                                                                                                          |
-    \*-------------------------------------------------------------------------------------------------------------*/
-    { LOGITECH_VID,             LOGITECH_G203_PID,      1,  DEVICE_TYPE_MOUSE,      "Logitech G203 Prodigy"         },
-    { LOGITECH_VID,             LOGITECH_G403_PID,      1,  DEVICE_TYPE_MOUSE,      "Logitech G403 Prodigy"         },
-    { LOGITECH_VID,             LOGITECH_G403H_PID,     1,  DEVICE_TYPE_MOUSE,      "Logitech G403 Hero"            },
-    /*-------------------------------------------------------------------------------------------------------------*\
-    | Mousemats                                                                                                     |
-    \*-------------------------------------------------------------------------------------------------------------*/
-};
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectLogitechControllers                                                              *
-*                                                                                          *
-*       Tests the USB address to see if a Logitech RGB Keyboard controller exists there.   *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectLogitechControllers(std::vector<RGBController*>& rgb_controllers)
-{
-    hid_init();
-
-    for(int device_idx = 0; device_idx < LOGITECH_NUM_DEVICES; device_idx++)
-    {
-        switch(device_list[device_idx].type)
-        {
-        /*-------------------------------------------------------------------------------------------------*\
-        | 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:
-            {
-                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 == 0xFF43)
-                    &&(info->usage == 0x0602))
-#else
-                    &&(info->interface_number == device_list[device_idx].usb_interface))
-#endif
-                    {
-                        hid_device* dev_usage_0x0602 = hid_open_path(info->path);
-
-                        if(dev_usage_0x0602)
-                        {
-#ifdef USE_HID_USAGE
-                            hid_device_info* tmp_info_0x0604 = info;
-
-                            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
-                        }
-                    }
-                    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;
-        }
-
-    }
-}

Controllers/LogitechController/LogitechG203Controller.cpp

@@ -1,73 +0,0 @@
-/*-----------------------------------------*\
-|  LogitechG203Controller.cpp               |
-|                                           |
-|  Driver for Logitech G203 Prodigy mouse   |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 5/17/2020   |
-\*-----------------------------------------*/
-
-#include "LogitechG203Controller.h"
-
-#include <cstring>
-
-LogitechG203Controller::LogitechG203Controller(hid_device* dev_handle)
-{
-    dev = dev_handle;
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void LogitechG203Controller::SendMouseMode
-    (
-    unsigned char       mode,
-    unsigned short      speed,
-    unsigned char       red,
-    unsigned char       green,
-    unsigned char       blue
-    )
-{
-    char usb_buf[20];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Lighting Control packet                        |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x11;
-    usb_buf[0x01]           = 0xFF;
-    usb_buf[0x02]           = 0x0E;
-    usb_buf[0x03]           = 0x3C;
-    usb_buf[0x04]           = 0x00;
-
-    usb_buf[0x05]           = mode;
-
-    usb_buf[0x06]           = red;
-    usb_buf[0x07]           = green;
-    usb_buf[0x08]           = blue;
-
-    speed = 1000 + 4750 * (LOGITECH_G203_SPEED_FASTEST - speed);
-    if(mode == LOGITECH_G203_MODE_CYCLE)
-    {
-        usb_buf[0x0B]   = speed >> 8;
-        usb_buf[0x0C]   = speed & 0xFF;
-        usb_buf[0x0D]   = 0x64;
-    }
-    else if(mode == LOGITECH_G203_MODE_BREATHING)
-    {
-        usb_buf[0x09]   = speed >> 8;
-        usb_buf[0x0A]   = speed & 0xFF;
-        usb_buf[0x0C]   = 0x64;
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 20);
-    hid_read(dev, (unsigned char *)usb_buf, 20);
-}

Controllers/LogitechController/LogitechG203Controller.h

@@ -1,51 +0,0 @@
-/*-----------------------------------------*\
-|  LogitechG203Controller.h                 |
-|                                           |
-|  Definitions and types for Logitech G203  |
-|  Prodigy mouse lighting controller        |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 5/17/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    LOGITECH_G203_MODE_OFF               = 0x00,
-    LOGITECH_G203_MODE_STATIC            = 0x01,
-    LOGITECH_G203_MODE_CYCLE             = 0x02,
-    LOGITECH_G203_MODE_BREATHING         = 0x03,
-};
-
-enum
-{
-    LOGITECH_G203_SPEED_SLOWEST          = 0x00, /* Slowest speed                */
-    LOGITECH_G203_SPEED_SLOW             = 0x01, /* Slow speed                   */
-    LOGITECH_G203_SPEED_NORMAL           = 0x02, /* Normal speed                 */
-    LOGITECH_G203_SPEED_FAST             = 0x03, /* Fast speed                   */
-    LOGITECH_G203_SPEED_FASTEST          = 0x04, /* Fastest speed                */
-};
-
-class LogitechG203Controller
-{
-public:
-    LogitechG203Controller(hid_device* dev_handle);
-    ~LogitechG203Controller();
-
-    void        SendMouseMode
-                   (
-                   unsigned char       mode,
-                   unsigned short      speed,
-                   unsigned char       red,
-                   unsigned char       green,
-                   unsigned char       blue
-                   );
-
-private:
-    hid_device*             dev;
-};

Controllers/LogitechController/LogitechG403Controller.cpp

@@ -1,75 +0,0 @@
-/*-----------------------------------------*\
-|  LogitechG403Controller.cpp               |
-|                                           |
-|  Driver for Logitech G403 Prodigy mouse   |
-|  lighting controller                      |
-|                                           |
-|  Martin Hartl (inlart) 5/19/2020          |
-\*-----------------------------------------*/
-
-#include "LogitechG403Controller.h"
-
-#include <cstring>
-
-LogitechG403Controller::LogitechG403Controller(hid_device* dev_handle)
-{
-    dev = dev_handle;
-}
-
-LogitechG403Controller::~LogitechG403Controller()
-{
-    hid_close(dev);
-}
-
-void LogitechG403Controller::SendMouseMode
-    (
-    unsigned char       mode,
-    std::uint16_t       speed,
-    unsigned char       channel,
-    unsigned char       red,
-    unsigned char       green,
-    unsigned char       blue
-    )
-{
-    unsigned char usb_buf[20];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Lighting Control packet                        |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x11;
-    usb_buf[0x01]           = 0xFF;
-    usb_buf[0x02]           = 0x0E;
-    usb_buf[0x03]           = 0x3C;
-    usb_buf[0x04]           = channel;
-
-    usb_buf[0x05]           = mode;
-
-    usb_buf[0x06]           = red;
-    usb_buf[0x07]           = green;
-    usb_buf[0x08]           = blue;
-
-    speed = 1000 + 4750 * (LOGITECH_G403_SPEED_FASTEST - speed);
-    if(mode == LOGITECH_G403_MODE_CYCLE)
-    {
-        usb_buf[0x0B]   = speed >> 8;
-        usb_buf[0x0C]   = speed & 0xFF;
-        usb_buf[0x0D]   = 0x64;
-    }
-    else if(mode == LOGITECH_G403_MODE_BREATHING)
-    {
-        usb_buf[0x09]   = speed >> 8;
-        usb_buf[0x0A]   = speed & 0xFF;
-        usb_buf[0x0C]   = 0x64;
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 20);
-    hid_read(dev, usb_buf, 20);
-}

Controllers/LogitechController/LogitechG403Controller.h

@@ -1,52 +0,0 @@
-/*-----------------------------------------*\
-|  LogitechG403Controller.h                 |
-|                                           |
-|  Definitions and types for Logitech G403  |
-|  Prodigy mouse lighting controller        |
-|                                           |
-|  Martin Hartl (inlart) 5/19/2020          |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    LOGITECH_G403_MODE_OFF               = 0x00,
-    LOGITECH_G403_MODE_STATIC            = 0x01,
-    LOGITECH_G403_MODE_CYCLE             = 0x02,
-    LOGITECH_G403_MODE_BREATHING         = 0x03,
-};
-
-enum
-{
-    LOGITECH_G403_SPEED_SLOWEST          = 0x00, /* Slowest speed                */
-    LOGITECH_G403_SPEED_SLOW             = 0x01, /* Slow speed                   */
-    LOGITECH_G403_SPEED_NORMAL           = 0x02, /* Normal speed                 */
-    LOGITECH_G403_SPEED_FAST             = 0x03, /* Fast speed                   */
-    LOGITECH_G403_SPEED_FASTEST          = 0x04, /* Fastest speed                */
-};
-
-class LogitechG403Controller
-{
-public:
-    LogitechG403Controller(hid_device* dev_handle);
-    ~LogitechG403Controller();
-
-    void        SendMouseMode
-                   (
-                    unsigned char       mode,
-                    unsigned short      speed,
-                    unsigned char       channel,
-                    unsigned char       red,
-                    unsigned char       green,
-                    unsigned char       blue
-                   );
-
-private:
-    hid_device*             dev;
-};

Controllers/LogitechController/LogitechG810Controller.cpp

@@ -1,169 +0,0 @@
-/*-----------------------------------------*\
-|  LogitechG810Controller.cpp               |
-|                                           |
-|  Driver for Logitech G810 Orion Spectrum  |
-|  keyboard light controller                |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/11/2020   |
-\*-----------------------------------------*/
-
-#include "LogitechG810Controller.h"
-#include <cstring>
-
-LogitechG810Controller::LogitechG810Controller(hid_device* dev_handle_0x11, hid_device* dev_handle_0x12)
-{
-    dev_pkt_0x11 = dev_handle_0x11;
-    dev_pkt_0x12 = dev_handle_0x12;
-}
-
-LogitechG810Controller::~LogitechG810Controller()
-{
-
-}
-
-void LogitechG810Controller::Commit()
-{
-    SendCommit();
-}
-
-void LogitechG810Controller::SetDirect
-    (
-    unsigned char       zone,
-    unsigned char       frame_count,
-    unsigned char *     frame_data
-    )
-{
-    SendDirectFrame(zone, frame_count, frame_data);
-}
-
-void LogitechG810Controller::SetMode
-    (
-    unsigned char       mode,
-    unsigned short      speed,
-    unsigned char       red,
-    unsigned char       green,
-    unsigned char       blue
-    )
-{
-    SendMode(LOGITECH_G810_ZONE_MODE_KEYBOARD, mode, speed, red, green, blue);
-    SendMode(LOGITECH_G810_ZONE_MODE_LOGO,     mode, speed, red, green, blue);
-
-    SendCommit();
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void LogitechG810Controller::SendCommit()
-{
-    char usb_buf[20];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Commit packet                                  |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x11;
-    usb_buf[0x01]           = 0xFF;
-    usb_buf[0x02]           = 0x0C;
-    usb_buf[0x03]           = 0x5D;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev_pkt_0x11, (unsigned char *)usb_buf, 20);
-    hid_read(dev_pkt_0x11, (unsigned char *)usb_buf, 20);
-}
-
-void LogitechG810Controller::SendDirectFrame
-    (
-    unsigned char       zone,
-    unsigned char       frame_count,
-    unsigned char *     frame_data
-    )
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Lighting Control packet                        |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x12;
-    usb_buf[0x01]           = 0xFF;
-    usb_buf[0x02]           = 0x0C;
-    usb_buf[0x03]           = 0x3D;
-    usb_buf[0x05]           = zone;
-    usb_buf[0x07]           = frame_count;
-
-    /*-----------------------------------------------------*\
-    | Copy in frame data                                    |
-    \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x08], frame_data, frame_count * 4);
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev_pkt_0x12, (unsigned char *)usb_buf, 64);
-    hid_read(dev_pkt_0x11, (unsigned char *)usb_buf, 20);
-}
-
-void LogitechG810Controller::SendMode
-    (
-    unsigned char       zone,
-    unsigned char       mode,
-    unsigned short      speed,
-    unsigned char       red,
-    unsigned char       green,
-    unsigned char       blue
-    )
-{
-    char usb_buf[20];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Lighting Control packet                        |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x11;
-    usb_buf[0x01]           = 0xFF;
-    usb_buf[0x02]           = 0x0D;
-    usb_buf[0x03]           = 0x3D;
-    usb_buf[0x04]           = zone;
-
-    usb_buf[0x05]           = mode;
-
-    usb_buf[0x06]           = red;
-    usb_buf[0x07]           = green;
-    usb_buf[0x08]           = blue;
-
-    speed = 1000 + 4750 * (LOGITECH_G810_SPEED_FASTEST - speed);
-    if(mode == LOGITECH_G810_MODE_CYCLE)
-    {
-        usb_buf[0x0B]   = speed >> 8;
-        usb_buf[0x0C]   = speed & 0xFF;
-        usb_buf[0x0D]   = 0x64;
-    }
-    else if(mode == LOGITECH_G810_MODE_BREATHING)
-    {
-        usb_buf[0x09]   = speed >> 8;
-        usb_buf[0x0A]   = speed & 0xFF;
-        usb_buf[0x0C]   = 0x64;
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev_pkt_0x11, (unsigned char *)usb_buf, 20);
-    hid_read(dev_pkt_0x11, (unsigned char *)usb_buf, 20);
-}

Controllers/LogitechController/LogitechG810Controller.h

@@ -1,95 +0,0 @@
-/*-----------------------------------------*\
-|  LogitechG810Controller.h                 |
-|                                           |
-|  Definitions and types for Logitech G810  |
-|  Orion Spectrum keyboard light controller |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/11/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    LOGITECH_G810_ZONE_MODE_KEYBOARD     = 0x00,
-    LOGITECH_G810_ZONE_MODE_LOGO         = 0x01,
-};
-
-enum
-{
-    LOGITECH_G810_ZONE_DIRECT_KEYBOARD   = 0x01,
-    LOGITECH_G810_ZONE_DIRECT_MEDIA      = 0x02,
-    LOGITECH_G810_ZONE_DIRECT_LOGO       = 0x10,
-    LOGITECH_G810_ZONE_DIRECT_INDICATORS = 0x40,
-};
-
-enum
-{
-    LOGITECH_G810_MODE_OFF               = 0x00,
-    LOGITECH_G810_MODE_STATIC            = 0x01,
-    LOGITECH_G810_MODE_BREATHING         = 0x02,
-    LOGITECH_G810_MODE_CYCLE             = 0x03,
-    LOGITECH_G810_MODE_WAVE              = 0x04,
-};
-
-enum
-{
-    LOGITECH_G810_SPEED_SLOWEST          = 0x00, /* Slowest speed                */
-    LOGITECH_G810_SPEED_SLOW             = 0x01, /* Slow speed                   */
-    LOGITECH_G810_SPEED_NORMAL           = 0x02, /* Normal speed                 */
-    LOGITECH_G810_SPEED_FAST             = 0x03, /* Fast speed                   */
-    LOGITECH_G810_SPEED_FASTEST          = 0x04, /* Fastest speed                */
-};
-
-class LogitechG810Controller
-{
-public:
-    LogitechG810Controller(hid_device* dev_handle_0x11, hid_device* dev_handle_0x12);
-    ~LogitechG810Controller();
-
-    void        Commit();
-    
-    void        SetDirect
-                    (
-                    unsigned char       zone,
-                    unsigned char       frame_count,
-                    unsigned char *     frame_data
-                    );
-
-    void        SetMode
-                    (
-                    unsigned char       mode,
-                    unsigned short      speed,
-                    unsigned char       red,
-                    unsigned char       green,
-                    unsigned char       blue
-                    );
-
-private:
-    hid_device* dev_pkt_0x11;
-    hid_device* dev_pkt_0x12;
-
-    void        SendDirectFrame
-                    (
-                    unsigned char       zone,
-                    unsigned char       frame_count,
-                    unsigned char *     frame_data
-                    );
-
-    void        SendMode
-                    (
-                    unsigned char       zone,
-                    unsigned char       mode,
-                    unsigned short      speed,
-                    unsigned char       red,
-                    unsigned char       green,
-                    unsigned char       blue
-                    );
-
-    void        SendCommit();
-};

Controllers/MSIGPUController/MSIGPUController.cpp

@@ -1,74 +0,0 @@
-/*-----------------------------------------*\
-|  MSIGPUController.cpp                    |
-|                                          |
-|  Driver for MSI GPUs                     |
-|                                          |
-\*-----------------------------------------*/
-
-#include "MSIGPUController.h"
-#include <cstring>
-
-MSIGPUController::MSIGPUController(i2c_smbus_interface* bus)
-{
-    this->bus = bus;
-    this->dev = 0x68;
-
-    strcpy(device_name, "MSI RTX GPU");
-}
-
-MSIGPUController::~MSIGPUController()
-{
-
-}
-
-std::string MSIGPUController::GetDeviceName()
-{
-    return(device_name);
-}
-
-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

@@ -1,79 +0,0 @@
-/*-----------------------------------------*\
-|  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   GetDeviceName();
-    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:
-    char                    device_name[16];
-    i2c_smbus_interface *   bus;
-    msi_gpu_dev_id          dev;
-};

Controllers/MSIGPUController/MSIGPUControllerDetect.cpp

@@ -1,86 +0,0 @@
-/*-----------------------------------------*\
-|  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>
-
-/******************************************************************************************\
-*                                                                                          *
-*   IsMSIGPUController                                                                     *
-*                                                                                          *
-*       Compare PCI IDs                                                                    *
-*                                                                                          *
-\******************************************************************************************/
-
-bool IsMSIGPUController(i2c_smbus_interface* bus)
-{
-    bool pass = false;
-
-    if (bus->port_id != 1)
-    {
-        return(pass);
-    }
-
-    // MSI RTX 2080S Gaming X Trio
-    if (bus->pci_device == 0x1e81 &&
-        bus->pci_vendor == 0x10de &&
-        bus->pci_subsystem_device == 0xc724 &&
-        bus->pci_subsystem_vendor == 0x1462)
-    {
-        pass = true;
-    }
-
-    // MSI RTX 2070S Gaming X Trio
-    if (bus->pci_device == 0x1e84 &&
-        bus->pci_vendor == 0x10de &&
-        bus->pci_subsystem_device == 0xc726 &&
-        bus->pci_subsystem_vendor == 0x1462)
-    {
-        pass = true;
-    }
-
-    // MSI RTX 2080 Ti Sea Hawk EK X
-    if (bus->pci_device == 0x1e07 &&
-        bus->pci_vendor == 0x10de &&
-        bus->pci_subsystem_device == 0x3717 &&
-        bus->pci_subsystem_vendor == 0x1462)
-    {
-        pass = true;
-    }
-
-    return(pass);
-}   /* IsMSIGPUController() */
-
-
-/******************************************************************************************\
-*                                                                                          *
-*   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++)
-    {
-        if (IsMSIGPUController(busses[bus]))
-        {
-            new_msi_gpu = new MSIGPUController(busses[bus]);
-            new_controller = new RGBController_MSIGPU(new_msi_gpu);
-            rgb_controllers.push_back(new_controller);
-        }
-    }
-} /* DetectMSIGPUControllers() */

Controllers/MSIMysticLightController/MSIMysticLightController.cpp

@@ -35,34 +35,25 @@ MSIMysticLightController::~MSIMysticLightController()
     }
 }
 
-unsigned int MSIMysticLightController::GetZoneMinLedCount
-    (
-    MSI_ZONE            /*zone*/
-    )
+unsigned int MSIMysticLightController::GetZoneMinLedCount(ZONE /*zone*/)
 {
-    return 1;
+    return 1u;
 }
 
-unsigned int MSIMysticLightController::GetZoneMaxLedCount
-    (
-    MSI_ZONE            zone
-    )
+unsigned int MSIMysticLightController::GetZoneMaxLedCount(ZONE zone)
 {
-    switch(zone)
+    switch (zone)
     {
-    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
+    case J_RAINBOW_1:
+    case J_RAINBOW_2:
+    case J_CORSAIR:
+        return 4u; // TODO: It can be different by zone and by mobo
     default:
-        return 1;
+        return 1u;
     }
 }
 
-unsigned int MSIMysticLightController::GetZoneLedCount
-    (
-    MSI_ZONE            zone
-    )
+unsigned int MSIMysticLightController::GetZoneLedCount(ZONE zone)
 {
     RainbowZoneData *requestedZone = GetRainbowZoneData(zone);
 
@@ -74,11 +65,7 @@ unsigned int MSIMysticLightController::GetZoneLedCount
     return requestedZone->cycle_or_led_num;
 }
 
-void MSIMysticLightController::SetZoneLedCount
-    (
-    MSI_ZONE            zone,
-    unsigned int        led_count
-    )
+void MSIMysticLightController::SetZoneLedCount(ZONE zone, unsigned int led_count)
 {
     RainbowZoneData *requestedZone = GetRainbowZoneData(zone);
 
@@ -91,14 +78,7 @@ void MSIMysticLightController::SetZoneLedCount
     requestedZone->cycle_or_led_num = led_count;
 }
 
-void MSIMysticLightController::SetMode
-    (
-    MSI_ZONE            zone,
-    MSI_MODE            mode,
-    MSI_SPEED           speed,
-    MSI_BRIGHTNESS      brightness,
-    bool                rainbow_color
-    )
+void MSIMysticLightController::SetMode(ZONE zone, EFFECT mode, SPEED speed, BRIGHTNESS brightness, bool rainbow_color)
 {
     ZoneData* zoneData = GetZoneData(zone);
     if(!zoneData)
@@ -133,18 +113,12 @@ std::string MSIMysticLightController::GetSerial()
 
 bool MSIMysticLightController::ReadSettings()
 {
-    /*-----------------------------------------------------*\
-    | Read packet from hardware, return true if successful  |
-    \*-----------------------------------------------------*/
-    return(hid_get_feature_report(dev, (unsigned char *)&data, sizeof(data)) == sizeof data);
+    return hid_get_feature_report(dev, reinterpret_cast<unsigned char *>(&data), sizeof data) == sizeof data;
 }
 
 bool MSIMysticLightController::Update()
 {
-    /*-----------------------------------------------------*\
-    | Send packet to hardware, return true if successful    |
-    \*-----------------------------------------------------*/
-    return(hid_send_feature_report(dev, (unsigned char *)&data, sizeof(data)) == sizeof data);
+    return hid_send_feature_report(dev, reinterpret_cast<unsigned char *>(&data), sizeof data) == sizeof data;
 }
 
 void MSIMysticLightController::SaveOnUpdate(bool save)
@@ -152,40 +126,26 @@ void MSIMysticLightController::SaveOnUpdate(bool save)
     data.save_data = save;
 }
 
-void MSIMysticLightController::SetZoneColor
-    (
-    MSI_ZONE            zone,
-    unsigned char       red1,
-    unsigned char       grn1,
-    unsigned char       blu1,
-    unsigned char       red2,
-    unsigned char       grn2,
-    unsigned char       blu2
-    )
+void MSIMysticLightController::SetZoneColor(ZONE zone, unsigned char r1, unsigned char g1, unsigned char b1, unsigned char r2, unsigned char g2, unsigned char b2)
 {
     ZoneData* zoneData = GetZoneData(zone);
-
     if(!zoneData)
     {
         return;
     }
 
-    zoneData->color.R = red1;
-    zoneData->color.G = grn1;
-    zoneData->color.B = blu1;
+    zoneData->color.R = r1;
+    zoneData->color.G = g1;
+    zoneData->color.B = b1;
 
-    zoneData->color2.R = red2;
-    zoneData->color2.G = grn2;
-    zoneData->color2.B = blu2;
+    zoneData->color2.R = r2;
+    zoneData->color2.G = g2;
+    zoneData->color2.B = b2;
 }
 
-std::pair<Color, Color> MSIMysticLightController::GetZoneColor
-    (
-    MSI_ZONE            zone
-    )
+std::pair<Color, Color> MSIMysticLightController::GetZoneColor(ZONE zone)
 {
     ZoneData *zoneData = GetZoneData(zone);
-
     if (!zoneData)
     {
         return std::make_pair(Color{}, Color{});
@@ -198,67 +158,61 @@ std::pair<Color, Color> MSIMysticLightController::GetZoneColor
                           Color{zoneData->color2.R, zoneData->color2.G, zoneData->color2.B});
 }
 
-ZoneData *MSIMysticLightController::GetZoneData
-    (
-    MSI_ZONE            zone
-    )
+ZoneData *MSIMysticLightController::GetZoneData(ZONE zone)
 {
-    switch(zone)
+    switch (zone)
     {
-    case MSI_ZONE_J_RGB_1:
+    case J_RGB_1:
         return &data.j_rgb_1;
-    case MSI_ZONE_J_RGB_2:
+    case J_RGB_2:
         return &data.j_rgb_2;
-    case MSI_ZONE_J_RAINBOW_1:
+    case J_RAINBOW_1:
         return &data.j_rainbow_1;
-    case MSI_ZONE_J_RAINBOW_2:
+    case J_RAINBOW_2:
         return &data.j_rainbow_2;
-    case MSI_ZONE_J_PIPE_1:
+    case J_PIPE_1:
         return &data.j_pipe_1;
-    case MSI_ZONE_J_PIPE_2:
+    case J_PIPE_2:
         return &data.j_pipe_2;
-    case MSI_ZONE_ON_BOARD_LED:
+    case ON_BOARD_LED:
         return &data.on_board_led;
-    case MSI_ZONE_ON_BOARD_LED_1:
+    case ON_BOARD_LED_1:
         return &data.on_board_led_1;
-    case MSI_ZONE_ON_BOARD_LED_2:
+    case ON_BOARD_LED_2:
         return &data.on_board_led_2;
-    case MSI_ZONE_ON_BOARD_LED_3:
+    case ON_BOARD_LED_3:
         return &data.on_board_led_3;
-    case MSI_ZONE_ON_BOARD_LED_4:
+    case ON_BOARD_LED_4:
         return &data.on_board_led_4;
-    case MSI_ZONE_ON_BOARD_LED_5:
+    case ON_BOARD_LED_5:
         return &data.on_board_led_5;
-    case MSI_ZONE_ON_BOARD_LED_6:
+    case ON_BOARD_LED_6:
         return &data.on_board_led_6;
-    case MSI_ZONE_ON_BOARD_LED_7:
+    case ON_BOARD_LED_7:
         return &data.on_board_led_7;
-    case MSI_ZONE_ON_BOARD_LED_8:
+    case ON_BOARD_LED_8:
         return &data.on_board_led_8;
-    case MSI_ZONE_ON_BOARD_LED_9:
+    case ON_BOARD_LED_9:
         return &data.on_board_led_9;
-    case MSI_ZONE_J_CORSAIR_OUTERLL120:
+    case J_CORSAIR_OUTERLL120:
         return &data.j_corsair_outerll120;
     default:
-    case MSI_ZONE_J_CORSAIR:
+    case J_CORSAIR:
         break;
     }
 
     return nullptr;
 }
 
-RainbowZoneData *MSIMysticLightController::GetRainbowZoneData
-    (
-    MSI_ZONE            zone
-    )
+RainbowZoneData *MSIMysticLightController::GetRainbowZoneData(ZONE zone)
 {
-    switch(zone)
+    switch (zone)
     {
-    case MSI_ZONE_J_RAINBOW_1:
+    case J_RAINBOW_1:
         return &data.j_rainbow_1;
-    case MSI_ZONE_J_RAINBOW_2:
+    case J_RAINBOW_2:
         return &data.j_rainbow_2;
-    case MSI_ZONE_J_CORSAIR:
+    case J_CORSAIR:
     default:
         return nullptr;
     }
@@ -266,98 +220,39 @@ RainbowZoneData *MSIMysticLightController::GetRainbowZoneData
 
 bool MSIMysticLightController::ReadFwVersion()
 {
-    unsigned char request[64];
+    // 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 response[64];
-    int ret_val = 64;
 
-    /*-----------------------------------------------------*\
-    | First read the APROM                                  |
-    | Checksum also available at report ID 180, with MSB    |
-    | stored at index 0x08 and LSB at 0x09                  |
-    \*-----------------------------------------------------*/
+    std::fill_n(request + 2, sizeof request - 2, 204);
+    num &= hid_write(dev, request, 64);
+    num &= hid_read(dev, response, 64);
 
-    /*-----------------------------------------------------*\
-    | 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] & 0x0F;
+    unsigned char lowValue  = response[2] & 15;
 
-    /*-----------------------------------------------------*\
-    | Build firmware string <high>.<low>                    |
-    \*-----------------------------------------------------*/
     version_APROM = std::to_string(static_cast<int>(highValue)).append(".").append(std::to_string(static_cast<int>(lowValue)));
 
-    /*-----------------------------------------------------*\
-    | First read the LDROM                                  |
-    | Checksum also available at report ID 184, with MSB    |
-    | stored at index 0x08 and LSB at 0x09                  |
-    \*-----------------------------------------------------*/
+    // 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);
 
-    /*-----------------------------------------------------*\
-    | Set up LDROM Firmware Version Request packet          |
-    \*-----------------------------------------------------*/
-    request[0x00]   = 0x01;
-    request[0x01]   = 0xB6;
+    highValue = response[2] >> 4u;
+    lowValue = response[2] & 15u;
 
-    /*-----------------------------------------------------*\
-    | 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)));
 
-    /*-----------------------------------------------------*\
-    | If return value is zero it means an HID transfer      |
-    | failed                                                |
-    \*-----------------------------------------------------*/
-    return(ret_val > 0);
+    return num == 1;
 }
 
 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());
 }
@@ -365,53 +260,27 @@ 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,
-    MSI_FAN_TYPE    fan_type,
-    unsigned char   corsair_device_quantity,
-    bool            is_LL120Outer_individual
-    )
+void MSIMysticLightController::SetDeviceSettings(bool is_fan, FAN_TYPE fan_type,
+                                                 unsigned char corsair_device_quantity,
+                                                 bool is_LL120Outer_individual) 
 {
-    /*-----------------------------------------------------*\
-    | 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);
+    // 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);
 }
 
-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);
@@ -440,78 +309,41 @@ bool MSIMysticLightController::SetVolume
     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);
 
-    /*-----------------------------------------------------*\
-    | 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);
+    syncZone.speedAndBrightnessFlags = BitSet(syncZone.speedAndBrightnessFlags, combine_JRGB, 7u);
 }
 
-void MSIMysticLightController::GetMode
-    (
-    MSI_ZONE            zone,
-    MSI_MODE            &mode,
-    MSI_SPEED           &speed,
-    MSI_BRIGHTNESS      &brightness,
-    bool        &rainbow_color
-    ) 
+void MSIMysticLightController::GetMode(ZONE zone, EFFECT &mode, SPEED &speed, BRIGHTNESS &brightness, bool &rainbow_color) 
 {
-    /*-----------------------------------------------------*\
-    | Get data for given zone                               |
-    \*-----------------------------------------------------*/
     ZoneData *zoneData = GetZoneData(zone);
-
-    /*-----------------------------------------------------*\
-    | Return if zone is invalid                             |
-    \*-----------------------------------------------------*/
     if (!zoneData)
     {
         return;
     }
 
-    /*-----------------------------------------------------*\
-    | 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;
+    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;
 }
 
-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
-    (
-    MSI_ZONE            zone,
-    unsigned char       cycle_num
-    )
+void MSIMysticLightController::SetCycleCount(ZONE zone, unsigned char cycle_num)
 {
     RainbowZoneData *requestedZone = GetRainbowZoneData(zone);
 
@@ -523,10 +355,7 @@ void MSIMysticLightController::SetCycleCount
     requestedZone->cycle_or_led_num = cycle_num;
 }
 
-unsigned char MSIMysticLightController::GetCycleCount
-    (
-    MSI_ZONE            zone
-    )
+unsigned char MSIMysticLightController::GetCycleCount(ZONE zone)
 {
     RainbowZoneData *requestedZone = GetRainbowZoneData(zone);
 
@@ -538,43 +367,28 @@ unsigned char MSIMysticLightController::GetCycleCount
     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;
 
-    /*-----------------------------------------------------*\
-    | 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;
+    combine_JRGB = (syncZone.speedAndBrightnessFlags & 128u) >> 7u;
 }
 
-void MSIMysticLightController::GetDeviceSettings
-    (
-    bool                &stripe_or_fan,
-    MSI_FAN_TYPE        &fan_type,
-    unsigned char       &corsair_device_quantity,
-    bool                &is_LL120Outer_individual
-    )
+void MSIMysticLightController::GetDeviceSettings(bool &stripe_or_fan, FAN_TYPE &fan_type,
+                                                 unsigned char &corsair_device_quantity,
+                                                 bool &is_LL120Outer_individual)
 {
-    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;
+    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;
 }

Controllers/MSIMysticLightController/MSIMysticLightController.h

@@ -14,105 +14,105 @@
 
 #pragma once
 
-enum MSI_ZONE
+enum ZONE
 {
-    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
+    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
 };
 
 struct ZoneDescription
 {
     std::string name;
-    MSI_ZONE    value;
+    ZONE value;
 };
 
-enum MSI_MODE
+enum EFFECT
 {
-    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,
+    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
 };
 
-enum MSI_SPEED
+enum SPEED
 {
-    MSI_SPEED_LOW                       = 0,
-    MSI_SPEED_MEDIUM                    = 1,
-    MSI_SPEED_HIGH                      = 2,
+    LOW,
+    MEDIUM,
+    HIGH
 };
 
-enum MSI_FAN_TYPE
+enum FAN_TYPE
 {
-    MSI_FAN_TYPE_SP                     = 0,
-    MSI_FAN_TYPE_HD                     = 1,
-    MSI_FAN_TYPE_LL                     = 2,
+    SP,
+    HD,
+    LL
 };
 
-enum MSI_BRIGHTNESS
+enum BRIGHTNESS
 {
-    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, 
+    OFF,
+    LEVEL_10,
+    LEVEL_20,
+    LEVEL_30,
+    LEVEL_40,
+    LEVEL_50,
+    LEVEL_60,
+    LEVEL_70,
+    LEVEL_80,
+    LEVEL_90,
+    LEVEL_100
 };
 
 struct Color
@@ -124,51 +124,54 @@ struct Color
 
 struct CorsairZoneData
 {
-    unsigned char effect                    = MSI_MODE_STATIC;
-    Color         color                     { 0, 0, 0 };
-    unsigned char fan_flags                 = 40;
+    unsigned char effect = EFFECT::STATIC;
+    Color color { std::numeric_limits<unsigned char>::max(), 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                    = 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;
+    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;
 };
 
 struct RainbowZoneData : ZoneData
 {
-    unsigned char cycle_or_led_num          = 20;
+    unsigned char cycle_or_led_num = 20u;
 };
 
 struct FeaturePacket
 {
-    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
+    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
 };
 
 
@@ -178,116 +181,25 @@ public:
     MSIMysticLightController(hid_device* handle, const char *path);
     ~MSIMysticLightController();
 
-    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
-                        );
+    unsigned int    GetZoneMinLedCount(ZONE zone);
+    unsigned int    GetZoneMaxLedCount(ZONE zone);
+    unsigned int    GetZoneLedCount(ZONE zone);
+    void            SetZoneLedCount(ZONE zone, unsigned int led_count);
 
+    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(MSI_ZONE zone);
-
+                    GetZoneColor(ZONE zone);
     bool            Update();
 
-    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
-                        );
+    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);
 
     std::string     GetDeviceName();
     std::string     GetDeviceLocation();
@@ -300,9 +212,9 @@ private:
     bool            ReadFwVersion();
     void            ReadSerial();
     void            ReadName();
-    ZoneData*       GetZoneData(MSI_ZONE zone);
+    ZoneData*       GetZoneData(ZONE zone);
     RainbowZoneData*
-                    GetRainbowZoneData(MSI_ZONE zone);
+                    GetRainbowZoneData(ZONE zone);
     static unsigned char   BitSet(unsigned char value, bool bit, unsigned int position);
 
     hid_device*             dev;

Controllers/MSIMysticLightController/MSIMysticLightControllerDetect.cpp

@@ -1,53 +1,52 @@
 #include "MSIMysticLightController.h"
 #include "RGBController_MSIMysticLight.h"
+#include <algorithm>
 
-#define MSI_USB_VID 0x1462
+#define MSI_VID 0x1462
 
-#define NUM_MSI_PIDS 41
-
-static const unsigned short msi_pid_table[] =
+constexpr unsigned short SupportedPIDs[41] =
 {
-    0x7C67, // MS_7C67
-    0x7B10, // MS_7B10
-    0x7C87, // MS_7C87
-    0x7B93, // MS_7B93
-    0x7C34, // MS_7C34
-    0x7C35, // MS_7C35
-    0x7C36, // MS_7C36
-    0x7C37, // MS_7C37
-    0x7C42, // MS_7C42
-    0x7C84, // MS_7C84
-    0x7B94, // MS_7B94
-    0x7B96, // MS_7B96
-    0x7C59, // MS_7C59
-    0x7C60, // MS_7C60
-    0x7C70, // MS_7C70
-    0x7C71, // MS_7C71
-    0x7C73, // MS_7C73
-    0x7C75, // MS_7C75
-    0x7C76, // MS_7C76
-    0x7C77, // MS_7C77
-    0x7C79, // MS_7C79
-    0x7C80, // MS_7C80
-    0x7C98, // MS_7C98
-    0x7C99, // MS_7C99
-    0x7C81, // MS_7C81
-    0x7C82, // MS_7C82
-    0x7C83, // MS_7C83
-    0x7C85, // MS_7C85
-    0x7C86, // MS_7C86
-    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
+    31847, // MS_7C67
+    31504, // MS_7B10
+    31879, // MS_7C87
+    31635, // MS_7B93
+    31796, // MS_7C34
+    31797, // MS_7C35
+    31798, // MS_7C36
+    31799, // MS_7C37
+    31810, // MS_7C42
+    31876, // MS_7C84
+    31636, // MS_7B94
+    31638, // MS_7B96
+    31833, // MS_7C59
+    31840, // MS_7C60
+    31856, // MS_7C70
+    31857, // MS_7C71
+    31859, // MS_7C73
+    31861, // MS_7C75
+    31862, // MS_7C76
+    31863, // MS_7C77
+    31865, // MS_7C79
+    31872, // MS_7C80
+    31896, // MS_7C98
+    31897, // MS_7C99
+    31873, // MS_7C81
+    31874, // MS_7C82
+    31875, // MS_7C83
+    31877, // MS_7C85
+    31878, // MS_7C86
+    31880, // MS_7C88
+    31881, // MS_7C89
+    17497, // MS_4459
+    16036, // MS_3EA4
+    36957, // MS_905D
+    31888, // MS_7C90
+    31889, // MS_7C91
+    31890, // MS_7C92
+    31892, // MS_7C94
+    31893, // MS_7C95
+    31894, // MS_7C96
+    31830  // MS_7C56
 };
 
 /******************************************************************************************\
@@ -60,39 +59,32 @@ static const unsigned short msi_pid_table[] =
 
 void DetectMSIMysticLightControllers(std::vector<RGBController*> &rgb_controllers)
 {
-    hid_device_info* info;
-    hid_device* dev;
-
-    hid_init();
-
-    for(int device_idx = 0; device_idx < NUM_MSI_PIDS; device_idx++)
+    if(hid_init() < 0)
     {
-        dev = NULL;
-
-        info = hid_enumerate(MSI_USB_VID, msi_pid_table[device_idx]);
-
-        //Look for MSI Mystic Light Controller
-        while(info)
-        {
-            if((info->vendor_id == MSI_USB_VID)
-            &&(info->product_id == msi_pid_table[device_idx]))
-            {
-                dev = hid_open_path(info->path);
-                break;
-            }
-            else
-            {
-                info = info->next;
-            }
-        }
-
-        if( dev )
-        {
-            MSIMysticLightController * controller = new MSIMysticLightController(dev, info->path);
-
-            RGBController_MSIMysticLight * rgb_controller = new RGBController_MSIMysticLight(controller);
-            
-            rgb_controllers.push_back(rgb_controller);
-        }
+        return;
     }
+
+    hid_device_info * device_list = hid_enumerate(MSI_VID, 0);
+    if(!device_list)
+    {
+        return;
+    }
+
+    hid_device_info * device = device_list;
+    while(device)
+    {
+        if(std::find(std::begin(SupportedPIDs), std::end(SupportedPIDs), device->product_id) != std::end(SupportedPIDs))
+        {
+        hid_device * dev = hid_open_path(device->path);
+            if(dev)
+            {
+                MSIMysticLightController * controller = new MSIMysticLightController(dev, device_list->path);
+                RGBController_MSIMysticLight * rgb_controller = new RGBController_MSIMysticLight(controller);
+                rgb_controllers.push_back(rgb_controller);
+            }
+        }
+        device = device->next;
+    }
+
+    hid_free_enumeration(device_list);
 }

Controllers/NZXTHue2Controller/NZXTHue2ControllerDetect.cpp

@@ -1,78 +0,0 @@
-#include "NZXTHue2Controller.h"
-#include "RGBController.h"
-#include "RGBController_NZXTHue2.h"
-#include <vector>
-#include <hidapi/hidapi.h>
-
-#define NZXT_VID                    0x1E71
-#define NZXT_HUE_2_PID              0x2001
-#define NZXT_HUE_2_AMBIENT_PID      0x2002
-#define NZXT_SMART_DEVICE_V2_PID    0x2006
-#define NZXT_RGB_FAN_CONTROLLER_PID 0x2009
-
-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;
-
-#define NZXT_HUE_2_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const nzxt_hue_2_device device_list[] =
-{
-    /*-----------------------------------------------------------------------------------------------------*\
-    | NZXT Hue 2 devices                                                                                    |
-    \*-----------------------------------------------------------------------------------------------------*/
-    { 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"         },
-};
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectNZXTHue2Controllers                                                              *
-*                                                                                          *
-*       Detect devices supported by the NZXT Hue 2 driver                                  *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectNZXTHue2Controllers(std::vector<RGBController*> &rgb_controllers)
-{
-    hid_device_info* info;
-    hid_device* dev;
-
-    hid_init();
-
-    for(std::size_t device_idx = 0; device_idx < NZXT_HUE_2_NUM_DEVICES; device_idx++)
-    {
-        dev = NULL;
-
-        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
-
-        //Look for NZXT Hue 2 devices
-        while(info)
-        {
-            if((info->vendor_id == device_list[device_idx].usb_vid)
-            &&(info->product_id == device_list[device_idx].usb_pid))
-            {
-                dev = hid_open_path(info->path);
-
-                if( dev )
-                {
-                    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);
-                }
-            }
-            info = info->next;
-        }
-    }
-}   /* DetectNZXTHue2Controllers() */

Controllers/NZXTKrakenController/NZXTKrakenController.cpp

@@ -10,6 +10,9 @@
 #include <sstream>
 #include <cstring>
 
+const int NZXT_KRAKEN_READ_ENDPOINT = 0x81;
+const int NZXT_KRAKEN_WRITE_ENDPOINT = 0x01;
+
 static void SetColor(const std::vector<RGBColor>& colors, unsigned char* color_data)
 {
     for (std::size_t idx = 0; idx < colors.size(); idx++)
@@ -27,7 +30,7 @@ static RGBColor ToLogoColor(RGBColor rgb)
     return ToRGBColor(RGBGetGValue(rgb), RGBGetRValue(rgb), RGBGetBValue(rgb));
 }
 
-NZXTKrakenController::NZXTKrakenController(hid_device* dev_handle)
+NZXTKrakenController::NZXTKrakenController(libusb_device_handle* dev_handle)
 {
     dev = dev_handle;
 
@@ -39,7 +42,7 @@ NZXTKrakenController::NZXTKrakenController(hid_device* dev_handle)
 
 NZXTKrakenController::~NZXTKrakenController()
 {
-    hid_close(dev);
+
 }
 
 std::string NZXTKrakenController::GetFirmwareVersion()
@@ -49,17 +52,11 @@ std::string NZXTKrakenController::GetFirmwareVersion()
 
 void NZXTKrakenController::UpdateStatus()
 {
+    int actual;
     unsigned char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
     memset(usb_buf, 0, sizeof(usb_buf));
 
-    /*-----------------------------------------------------*\
-    | Read packet                                           |
-    \*-----------------------------------------------------*/
-    hid_read(dev, usb_buf, 64);
+    libusb_interrupt_transfer(dev, NZXT_KRAKEN_READ_ENDPOINT, usb_buf, sizeof(usb_buf), &actual, 0);
 
     /*-----------------------------------------------------*\
     | Extract cooler information                            |
@@ -90,28 +87,14 @@ 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);
 }
 
@@ -127,7 +110,8 @@ void NZXTKrakenController::SendEffect
     int             size /* = 0 */
     )
 {
-    unsigned char usb_buf[64];
+    int actual;
+    unsigned char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -170,5 +154,13 @@ void NZXTKrakenController::SendEffect
     /*-----------------------------------------------------*\
     | Send effect                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 64);
+    libusb_interrupt_transfer
+    (
+        dev,
+        NZXT_KRAKEN_WRITE_ENDPOINT,
+        usb_buf,
+        sizeof(usb_buf),
+        &actual,
+        0
+    );
 }

Controllers/NZXTKrakenController/NZXTKrakenController.h

@@ -9,7 +9,7 @@
 #include "RGBController.h"
 #include <vector>
 #include <string>
-#include <hidapi/hidapi.h>
+#include <libusb-1.0/libusb.h>
 
 enum NZXTKrakenChannel_t
 {
@@ -46,7 +46,7 @@ enum
 class NZXTKrakenController
 {
 public:
-    NZXTKrakenController(hid_device* dev_handle);
+    NZXTKrakenController(libusb_device_handle* dev_handle);
     ~NZXTKrakenController();
 
     std::string GetFirmwareVersion();
@@ -76,7 +76,7 @@ private:
         int             size = 0
         );
 
-    hid_device*   dev;
+    libusb_device_handle*   dev;
 
     // -- status
     std::string             firmware_version;

Controllers/NZXTKrakenController/NZXTKrakenControllerDetect.cpp

@@ -2,7 +2,7 @@
 #include "RGBController.h"
 #include "RGBController_NZXTKraken.h"
 #include <vector>
-#include <hidapi/hidapi.h>
+#include <libusb-1.0/libusb.h>
 
 #define NZXT_KRAKEN_VID 0x1E71
 #define NZXT_KRAKEN_PID 0x170E
@@ -17,35 +17,21 @@
 
 void DetectNZXTKrakenControllers(std::vector<RGBController*> &rgb_controllers)
 {
-    hid_device_info* info;
-    hid_device* dev;
+    libusb_context * ctx;
+    libusb_init(&ctx);
 
-    hid_init();
+    libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, NZXT_KRAKEN_VID, NZXT_KRAKEN_PID);
 
-    for(std::size_t device_idx = 0; device_idx < 1; device_idx++)
+    if( dev )
     {
-        dev = NULL;
+        libusb_detach_kernel_driver(dev, 0);
+        libusb_claim_interface(dev, 0);
 
-        info = hid_enumerate(NZXT_KRAKEN_VID, NZXT_KRAKEN_PID);
+        NZXTKrakenController* controller = new NZXTKrakenController(dev);
 
-        //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);
 
-                    RGBController_NZXTKraken* rgb_controller = new RGBController_NZXTKraken(controller);
-
-                    rgb_controllers.push_back(rgb_controller);
-                }
-            }
-            info = info->next;
-        }
+        rgb_controllers.push_back(rgb_controller);
     }
+
 }

Controllers/PatriotViperController/PatriotViperControllerDetect.cpp

@@ -6,7 +6,16 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-using namespace std::chrono_literals;
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
 
 /******************************************************************************************\
 *                                                                                          *
@@ -35,13 +44,13 @@ void DetectPatriotViperControllers(std::vector<i2c_smbus_interface*> &busses, st
             // Tests SPD addresses in order: 0x00, 0x40, 0x41, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68
             busses[bus]->i2c_smbus_write_byte_data(0x36, 0x00, 0xFF);
 
-            std::this_thread::sleep_for(1ms);
+            Sleep(1);
 
             if(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x00) == 0x23)
             {
                 busses[bus]->i2c_smbus_write_byte_data(0x37, 0x00, 0xFF);
 
-                std::this_thread::sleep_for(1ms);
+                Sleep(1);
 
                 if((busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x40) == 0x85)
                  &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x41) == 0x02)
@@ -58,7 +67,7 @@ void DetectPatriotViperControllers(std::vector<i2c_smbus_interface*> &busses, st
                 }
             }
 
-            std::this_thread::sleep_for(1ms);
+            Sleep(1);
         }
 
         if(slots_valid != 0)

Controllers/PolychromeController/PolychromeController.cpp

@@ -15,33 +15,49 @@ PolychromeController::PolychromeController(i2c_smbus_interface* bus, polychrome_
     this->bus = bus;
     this->dev = dev;
     
-    unsigned short fw_version    = GetFirmwareVersion();
-    unsigned char  major_version = fw_version >> 8;
-    unsigned char  minor_version = fw_version & 0xFF;
+    switch (GetFirmwareVersion())
+    {
+    case FIRMWARE_VER_1_PT_10:
+        led_count = 1;
+        asr_led = true;
+        strcpy(device_name, "ASRock ASR LED FW 1.10");
+        break;
 
-    /*-----------------------------------------------------*\
-    | Determine whether the device uses ASR LED or          |
-    | Polychrome protocol by checking firmware version.     |
-    | Versions 1.xx and 2.xx use ASR LED, 3.xx uses         |
-    | Polychrome                                            |
-    \*-----------------------------------------------------*/
-    if((major_version < 0x03) && (major_version > 0x00))
-    {
-        snprintf(device_name, 32, "ASRock ASR LED FW %d.%02d", major_version, minor_version);
-        led_count   = 1;
-        asr_led     = true;
+    case FIRMWARE_VER_2_PT_00:
+        led_count = 1;
+        asr_led = true;
+        strcpy(device_name, "ASRock ASR LED FW 2.00");
+        break;
+
+    case FIRMWARE_VER_2_PT_08:
+        led_count = 1;
+        asr_led = true;
+        strcpy(device_name, "ASRock ASR LED FW 2.08");
+        break;
+
+    case FIRMWARE_VER_2_PT_10:
+        led_count = 1;
+        asr_led = true;
+        strcpy(device_name, "ASRock ASR LED FW 2.10");
+        break;
+
+    case FIRMWARE_VER_3_PT_00:
+        led_count = 1;
+        asr_led = false;
+        strcpy(device_name, "ASRock Polychrome FW 3.00");
+        break;
+
+    case FIRMWARE_VER_3_PT_04:
+        led_count = 1;
+        asr_led = false;
+        strcpy(device_name, "ASRock Polychrome FW 3.04");
+        break;
+
+    default:
+        led_count = 0;
+        strcpy(device_name, "");
+        break;
     }
-    else if(major_version == 0x03)
-    {
-        snprintf(device_name, 32, "ASRock Polychrome FW %d.%02d", major_version, minor_version);
-        led_count   = 1;
-        asr_led     = false;
-    }
-    else
-    {
-        led_count   = 0;
-    }
-    
 }
 
 PolychromeController::~PolychromeController()
@@ -86,71 +102,17 @@ bool PolychromeController::IsAsrLed()
     return(asr_led);
 }
 
-void PolychromeController::SetColorsAndSpeed(unsigned char red, unsigned char green, unsigned char blue, unsigned char speed)
+void PolychromeController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
 {
-    unsigned char color_speed_pkt[4] = { red, green, blue, speed };
+    unsigned char colors[3] = { red, green, blue };
 
     if (asr_led)
     {
-        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;
-        }
+        bus->i2c_smbus_write_block_data(dev, active_mode, 3, colors);
     }
     else
     {
-        /*-----------------------------------------------------*\
-        | 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;
-        }
-
+        bus->i2c_smbus_write_block_data(dev, POLYCHROME_REG_COLOR, 3, colors);
     }
 }
 
@@ -166,4 +128,4 @@ void PolychromeController::SetMode(unsigned char mode)
     {
         bus->i2c_smbus_write_block_data(dev, POLYCHROME_REG_MODE, 1, &active_mode);
     }    
-}
+}

Controllers/PolychromeController/PolychromeController.h

@@ -14,6 +14,16 @@
 
 typedef unsigned char	polychrome_dev_id;
 
+enum
+{
+    FIRMWARE_VER_1_PT_10            = 0x010A,   /* Firmware nu51_1.10                   */
+    FIRMWARE_VER_2_PT_00            = 0x0200,   /* Firmware nu51_2.00                   */
+    FIRMWARE_VER_2_PT_08            = 0x0208,   /* Firmware nu51_2.08                   */
+    FIRMWARE_VER_2_PT_10            = 0x020A,   /* Firmware nu51_2.10                   */
+    FIRMWARE_VER_3_PT_00            = 0x0300,   /* Firmware nu51_3.00                   */
+    FIRMWARE_VER_3_PT_04            = 0x0304,   /* Firmware nu51_3.04                   */
+};
+
 enum
 {
     ASRLED_REG_FIRMWARE_VER         = 0x00,     /* Firmware version Major.Minor         */
@@ -34,13 +44,6 @@ 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         */
@@ -68,13 +71,6 @@ 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:
@@ -85,7 +81,7 @@ public:
     unsigned int    GetLEDCount();
     unsigned int    GetMode();
     bool            IsAsrLed();
-    void            SetColorsAndSpeed(unsigned char red, unsigned char green, unsigned char blue, unsigned char speed);
+    void            SetColor(unsigned char red, unsigned char green, unsigned char blue);
     void            SetMode(unsigned char mode);
     unsigned short  GetFirmwareVersion();
 

Controllers/PoseidonZRGBController/PoseidonZRGBController.cpp

@@ -11,7 +11,16 @@
 
 #include <cstring>
 
-using namespace std::chrono_literals;
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
 
 static unsigned int keys[] = {0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x15,
                               0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23,
@@ -48,7 +57,7 @@ void PoseidonZRGBController::SetMode(unsigned char mode, unsigned char direction
         active_speed
         );
 
-    std::this_thread::sleep_for(200ms);
+    Sleep(200);
 }
 
 void PoseidonZRGBController::SetLEDsDirect(std::vector<RGBColor> colors)
@@ -98,7 +107,7 @@ void PoseidonZRGBController::SetLEDsDirect(std::vector<RGBColor> colors)
     \*-----------------------------------------------------*/
     hid_send_feature_report(dev, red_grn_buf, 264);
 
-    std::this_thread::sleep_for(5ms);
+    Sleep(5);
      
     hid_send_feature_report(dev, blu_buf, 264);
 }
@@ -123,7 +132,7 @@ void PoseidonZRGBController::SetLEDs(std::vector<RGBColor> colors)
         red_color_data
         );
 
-    std::this_thread::sleep_for(10ms);
+    Sleep(10);
 
     SendColor
         (
@@ -132,7 +141,7 @@ void PoseidonZRGBController::SetLEDs(std::vector<RGBColor> colors)
         grn_color_data
         );
 
-    std::this_thread::sleep_for(10ms);
+    Sleep(10);
 
     SendColor
         (
@@ -141,7 +150,7 @@ void PoseidonZRGBController::SetLEDs(std::vector<RGBColor> colors)
         blu_color_data
         );
 
-    std::this_thread::sleep_for(10ms);
+    Sleep(10);
 
     SendControl
         (

Controllers/PoseidonZRGBController/PoseidonZRGBControllerDetect.cpp

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

@@ -1,78 +0,0 @@
-/*-----------------------------------------*\
-|  RGBFusion2DRAMController.cpp             |
-|                                           |
-|  Driver for Gigabyte Aorus RGB Fusion 2   |
-|  DRAM lighting controller                 |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/7/2020    |
-\*-----------------------------------------*/
-
-#include "RGBFusion2DRAMController.h"
-
-#include <cstring>
-#include <stdio.h>
-#include <stdlib.h>
-
-RGBFusion2DRAMController::RGBFusion2DRAMController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev)
-{
-    /*-----------------------------------------------------*\
-    | Initialize pointers                                   |
-    \*-----------------------------------------------------*/
-    this->bus = bus;
-    this->dev = dev;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(led_data, 0, sizeof(led_data));
-
-    /*-----------------------------------------------------*\
-    | Initialize controller with 6 LEDs and mask 0x3B       |
-    | This is hard coded for Aorus RGB RAM                  |
-    \*-----------------------------------------------------*/
-    led_data[RGB_FUSION_2_DRAM_LED_EN_MASK] = 0x3B;
-    led_count = 6;
-
-    /*-----------------------------------------------------*\
-    | Initialize brightness to 100%                         |
-    \*-----------------------------------------------------*/
-    led_data[RGB_FUSION_2_DRAM_IDX_BRIGHTNESS] = 0x64;
-}
-
-unsigned int RGBFusion2DRAMController::GetLEDCount()
-{
-    return(led_count);
-}
-
-std::string RGBFusion2DRAMController::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 RGBFusion2DRAMController::Apply()
-{
-    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_2_DRAM_APPLY_ADDR, RGB_FUSION_2_DRAM_ACTION_APPLY);
-}
-
-void RGBFusion2DRAMController::SetLEDEffect
-    (
-    unsigned int    led,
-    int             mode,
-    unsigned int    speed,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    led_data[RGB_FUSION_2_DRAM_IDX_MODE]    = mode;
-    led_data[RGB_FUSION_2_DRAM_IDX_RED]     = red;
-    led_data[RGB_FUSION_2_DRAM_IDX_GREEN]   = green;
-    led_data[RGB_FUSION_2_DRAM_IDX_BLUE]    = blue;
-
-    bus->i2c_smbus_write_block_data(dev, RGB_FUSION_2_DRAM_LED_START_ADDR, 32, led_data);
-}

Controllers/RGBFusion2DRAMController/RGBFusion2DRAMController.h

@@ -1,72 +0,0 @@
-/*-----------------------------------------*\
-|  RGBFusion2DRAMController.h               |
-|                                           |
-|  Definitions and types for Gigabyte Aorus |
-|  RGB Fusion 2 DRAM lighting controller    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/7/2020    |
-\*-----------------------------------------*/
-
-#include <string>
-#include "i2c_smbus.h"
-
-#pragma once
-
-typedef unsigned char   rgb_fusion_dev_id;
-
-enum
-{
-    RGB_FUSION_2_DRAM_LED_EN_MASK       = 0x00,     /* LED enable bitfield                          */
-    RGB_FUSION_2_DRAM_IDX_MODE          = 0x09,     /* Mode index                                   */
-    RGB_FUSION_2_DRAM_IDX_BRIGHTNESS    = 0x0A,     /* Brightness index                             */
-    RGB_FUSION_2_DRAM_IDX_BLUE          = 0x0C,     /* Blue index                                   */
-    RGB_FUSION_2_DRAM_IDX_GREEN         = 0x0D,     /* Green index                                  */
-    RGB_FUSION_2_DRAM_IDX_RED           = 0x0E,     /* Red index                                    */
-//  RGB_FUSION_2_DRAM_TIMER_1_LSB       = 0x08,     /* Timer 1 LSB. Valid timer values [0-65535]    */
-//  RGB_FUSION_2_DRAM_TIMER_1_MSB       = 0x09,     /* Timer 1 MSB. Timer unis are milliseconds     */
-//  RGB_FUSION_2_DRAM_TIMER_2_LSB       = 0x0A,     /* Timer 2 LSB                                  */
-//  RGB_FUSION_2_DRAM_TIMER_2_MSB       = 0x0B,     /* Timer 2 MSB                                  */
-//  RGB_FUSION_2_DRAM_TIMER_3_LSB       = 0x0C,     /* Timer 3 LSB                                  */
-//  RGB_FUSION_2_DRAM_TIMER_3_MSB       = 0x0D,     /* Timer 3 MSB                                  */
-//  RGB_FUSION_2_DRAM_IDX_OPT_1	        = 0x0E,	    /* Option 1. Use case varies by mode            */
-//  RGB_FUSION_2_DRAM_IDX_OPT_2	        = 0x0F,	    /* Option 2. Use case varies by mode            */
-};
-
-enum
-{
-    RGB_FUSION_2_DRAM_LED_START_ADDR    = 0x20,
-    RGB_FUSION_2_DRAM_APPLY_ADDR        = 0x28,
-};
-
-enum
-{
-    RGB_FUSION_2_DRAM_ACTION_APPLY	    = 0x0F,
-};
-
-class RGBFusion2DRAMController
-{
-public:
-    RGBFusion2DRAMController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev);
-    ~RGBFusion2DRAMController();
-
-    std::string     GetDeviceLocation();
-    unsigned int    GetLEDCount();
-    void	        Apply();
-    
-    void            SetLEDEffect
-                        (
-                        unsigned int    led,
-                        int             mode,
-                        unsigned int    speed,
-                        unsigned char   red,
-                        unsigned char   green,
-                        unsigned char   blue
-                        );
-
-private:
-    unsigned int            led_count;
-    i2c_smbus_interface*    bus;
-    rgb_fusion_dev_id       dev;
-
-    unsigned char           led_data[32];
-};

Controllers/RGBFusion2DRAMController/RGBFusion2DRAMControllerDetect.cpp

@@ -1,67 +0,0 @@
-#include "RGBFusion2DRAMController.h"
-#include "RGBController.h"
-#include "RGBController_RGBFusion2DRAM.h"
-#include "i2c_smbus.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string>
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForRGBFusion2DRAMController                                                        *
-*                                                                                          *
-*       Tests the given address to see if an RGB 2 Fusion DRAMcontroller exists there.     *
-*       First does a quick write to test for a response                                    *
-*                                                                                          *
-\******************************************************************************************/
-
-bool TestForRGBFusion2DRAMController(i2c_smbus_interface* bus, unsigned char address)
-{
-    bool pass = false;
-
-    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
-    if (res >= 0)
-    {
-        pass = true;
-
-        // res = bus->i2c_smbus_read_byte_data(address, 0xF2);
-
-        // if (res != 0xC4)
-        // {
-        //     pass = false;
-        // }
-    }
-
-    return(pass);
-
-}   /* TestForRGBFusion2DRAMController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectRGBFusion2DRAMControllers                                                        *
-*                                                                                          *
-*       Detect RGB Fusion 2 controllers on the enumerated I2C busses at address 0x67.      *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where RGB Fusion device is connected      *
-*           dev - I2C address of RGB Fusion device                                         *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectRGBFusion2DRAMControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
-{
-    RGBFusion2DRAMController* new_rgb_fusion;
-    RGBController_RGBFusion2DRAM* new_controller;
-
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        // Check for RGB Fusion 2 DRAM controller at 0x67
-        if (TestForRGBFusion2DRAMController(busses[bus], 0x67))
-        {
-            new_rgb_fusion = new RGBFusion2DRAMController(busses[bus], 0x67);
-            new_controller = new RGBController_RGBFusion2DRAM(new_rgb_fusion);
-            rgb_controllers.push_back(new_controller);
-        }
-    }
-
-}   /* DetectRGBFusion2DRAMControllers() */

Controllers/RGBFusion2SMBusController/RGBFusion2SMBusController.cpp

@@ -1,139 +0,0 @@
-/*-----------------------------------------*\
-|  RGBFusion2SMBusController.cpp            |
-|                                           |
-|  Driver for Gigabyte Aorus RGB Fusion 2   |
-|  SMBus lighting controller                |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 3/12/2020   |
-|  Matt Harper                  5/5/2020    |
-\*-----------------------------------------*/
-
-#include "RGBFusion2SMBusController.h"
-#include <cstring>
-#include <stdio.h>
-#include <stdlib.h>
-
-#ifdef DEBUG
-#include <iostream>
-#include <iomanip>
-#endif
-
-RGBFusion2SMBusController::RGBFusion2SMBusController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-
-    memset(led_data, 0, 10*16);
-
-    led_count = 10;	// Protocol supports 10 'slots'
-}
-
-unsigned int RGBFusion2SMBusController::GetLEDCount()
-{
-    return(led_count);
-}
-
-std::string RGBFusion2SMBusController::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);
-}
-
-/* Writes are performed in 32 byte chunks. If we need to write the second 16 bytes,
-* we must necessarily write the first 16 as well. Given that reading the existing state
-* from the device is not yet possible, unfortunately we may overwrite existing device
-* states if the state transition did not occur within in the same OpenRGB instance.
-* That is to say, the current behavior is non-deal but the best we have
-*/
-void RGBFusion2SMBusController::WriteLED(int led)
-{
-    unsigned short register_offset = led / 2;	// Relying on integer division to truncate
-    unsigned short write_register = RGB_FUSION_2_LED_START_ADDR + 2*register_offset;
-
-    // Adjust if we are writing the second 16 bytes
-    if(led % 2)
-    {
-        led -= 1;
-    }
-
-    #ifdef DEBUG
-    std::cout << std::hex << write_register << "\t";
-    for(int i = 0; i < 2; i++)
-    {
-        for(int j = 0; j < 16; j++)
-        {
-            std::cout << std::setw(2) << std::setfill('0') << std::hex << (int)led_data[led+i][j] << " ";
-        }
-        std::cout << " ";
-    }
-    std::cout << std::endl;
-    #endif
-
-    bus->i2c_smbus_write_block_data(RGB_FUSION_2_SMBUS_ADDR, write_register, 32, led_data[led]);
-}
-
-void RGBFusion2SMBusController::Apply()
-{
-    // Protocol expects terminating sequence 0x01ff written to register 0x17
-    bus->i2c_smbus_write_word_data(RGB_FUSION_2_SMBUS_ADDR,
-                   RGB_FUSION_2_APPLY_ADDR,
-                   RGB_FUSION_2_ACTION_APPLY);
-}
-
-void RGBFusion2SMBusController::SetLEDEffect
-    (
-    unsigned int    led,
-    int             mode,
-    unsigned int    speed,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    led_data[led][RGB_FUSION_2_IDX_MODE]        = mode;
-    led_data[led][RGB_FUSION_2_IDX_RED]         = red;
-    led_data[led][RGB_FUSION_2_IDX_GREEN]       = green;
-    led_data[led][RGB_FUSION_2_IDX_BLUE]        = blue;
-    led_data[led][RGB_FUSION_2_IDX_BRIGHTNESS]  = 0x64;
-
-    switch (mode)
-    {
-        case RGB_FUSION_2_MODE_PULSE:
-        // Timer 1: On time
-        // Timer 2: Off time
-        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x20 * speed;
-        led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x03 * speed;
-        led_data[led][RGB_FUSION_2_TIMER_2_LSB] = 0x20 * speed;
-        led_data[led][RGB_FUSION_2_TIMER_2_MSB] = 0x03 * speed;
-        break;
-
-        case RGB_FUSION_2_MODE_COLOR_CYCLE:
-            // Timer 1: Cycle time
-            led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x00;
-            led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x03 * speed;
-            led_data[led][RGB_FUSION_2_IDX_OPT_1]   = 0x07;		// Number of colors to cycle through. Valid range [1-7]
-            led_data[led][RGB_FUSION_2_IDX_OPT_2]   = 0x00;		// Color cycle, or color cycle and pulse. [0,1]
-        break;
-
-        case RGB_FUSION_2_MODE_FLASHING:
-            /* Timer 1: On time
-             * Timer 2: Interval
-             * Timer 3: Cycle time */
-        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x64;
-                led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0;
-                led_data[led][RGB_FUSION_2_TIMER_2_LSB] = 0xc8;
-                led_data[led][RGB_FUSION_2_TIMER_2_MSB] = 0;
-                led_data[led][RGB_FUSION_2_TIMER_3_LSB] = 0xd0;
-                led_data[led][RGB_FUSION_2_TIMER_3_MSB] = 0x07;
-
-            led_data[led][RGB_FUSION_2_IDX_OPT_1] = speed;		// Controls number of flashes
-        break;
-    }
-
-    WriteLED(led);
-}
-

Controllers/RGBFusion2SMBusController/RGBFusion2SMBusController.h

@@ -1,103 +0,0 @@
-/*-----------------------------------------*\
-|  RGBFusion2SMBusController.h              |
-|                                           |
-|  Definitions and types for Gigabyte Aorus |
-|  RGB Fusion 2 SMBus lighting controller   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 3/12/2020   |
-\*-----------------------------------------*/
-
-#include <string>
-#include "i2c_smbus.h"
-
-#pragma once
-
-typedef unsigned char	rgb_fusion_dev_id;
-
-enum
-{
-    RGB_FUSION_2_IDX_MODE           = 0x01,     /* Mode index                                   */
-    RGB_FUSION_2_IDX_BRIGHTNESS     = 0x02,     /* Brightness index                             */
-    RGB_FUSION_2_IDX_MAX_BRIGHTNESS = 0x02,     /* Max brightness index                         */
-    RGB_FUSION_2_IDX_MIN_BRIGHTNESS = 0x03,     /* Minimum brightness index                     */
-    RGB_FUSION_2_IDX_BLUE           = 0x04,     /* Blue index                                   */
-    RGB_FUSION_2_IDX_GREEN          = 0x05,     /* Green index                                  */
-    RGB_FUSION_2_IDX_RED            = 0x06,     /* Red index                                    */
-    RGB_FUSION_2_IDX_WHITE	        = 0x07,	    /* White index			                        */
-    RGB_FUSION_2_TIMER_1_LSB        = 0x08,     /* Timer 1 LSB. Valid timer values [0-65535] 	*/
-    RGB_FUSION_2_TIMER_1_MSB        = 0x09,     /* Timer 1 MSB. Timer unis are milliseconds   	*/
-    RGB_FUSION_2_TIMER_2_LSB        = 0x0A,     /* Timer 2 LSB                      		    */
-    RGB_FUSION_2_TIMER_2_MSB        = 0x0B,     /* Timer 2 MSB                      		    */
-    RGB_FUSION_2_TIMER_3_LSB        = 0x0C,     /* Timer 3 LSB                      		    */
-    RGB_FUSION_2_TIMER_3_MSB        = 0x0D,     /* Timer 3 MSB                      		    */
-    RGB_FUSION_2_IDX_OPT_1	        = 0x0E,	    /* Option 1. Use case varies by mode		    */
-    RGB_FUSION_2_IDX_OPT_2	        = 0x0F,	    /* Option 2. Use case varies by mode		    */
-};
-
-enum
-{
-    RGB_FUSION_2_APPLY_ADDR	        = 0x17,
-    RGB_FUSION_2_LED_START_ADDR     = 0x20,
-    RGB_FUSION_2_SMBUS_ADDR	        = 0x68,
-};
-
-enum
-{
-    RGB_FUSION_2_ACTION_APPLY	    = 0x01ff,
-};
-
-enum
-{
-    RGB_FUSION_2_MODE_PULSE         = 0x01,     /* Pulse mode                       */
-    RGB_FUSION_2_MODE_MUSIC	        = 0x02,	    /* Music mode			            */
-    RGB_FUSION_2_MODE_COLOR_CYCLE   = 0x03,     /* Color cycle mode                 */
-    RGB_FUSION_2_MODE_STATIC        = 0x04,     /* Static color mode                */
-    RGB_FUSION_2_MODE_FLASHING      = 0x05,     /* Flashing / Double Flashing mode  */
-    RGB_FUSION_2_MODE_TRANSITION    = 0x09,	    /* Gradual transition from current  */
-    RGB_FUSION_2_MODE_DIGITAL_A	    = 0x0A,	    /* Wave mode			            */
-    RGB_FUSION_2_MODE_DIGITAL_B	    = 0x0B,	    /* 				                    */
-    RGB_FUSION_2_MODE_DIGITAL_C	    = 0x0C,	    /* 				                    */
-    RGB_FUSION_2_MODE_DIGITAL_D	    = 0x0D,	    /* 				                    */
-    RGB_FUSION_2_MODE_DIGITAL_E	    = 0x0E,	    /* 				                    */
-    RGB_FUSION_2_MODE_DIGITAL_F	    = 0x0F,	    /* 				                    */
-    RGB_FUSION_2_MODE_DIGITAL_G	    = 0x10,	    /* 				                    */
-    RGB_FUSION_2_MODE_DIGITAL_H	    = 0x11,	    /* 				                    */
-    RGB_FUSION_2_MODE_DIGITAL_I	    = 0x12,	    /* 				                    */
-};
-
-enum
-{
-    RGB_FUSION_2_SPEED_FAST         = 0x01,
-    RGB_FUSION_2_SPEED_NORMAL       = 0x02,
-    RGB_FUSION_2_SPEED_SLOW         = 0x04,
-};
-
-class RGBFusion2SMBusController
-{
-public:
-    RGBFusion2SMBusController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev);
-    ~RGBFusion2SMBusController();
-
-    std::string     GetDeviceLocation();
-    unsigned int    GetLEDCount();
-    void	        Apply();
-    
-    void            SetLEDEffect
-                        (
-                        unsigned int    led,
-                        int             mode,
-                        unsigned int    speed,
-                        unsigned char   red,
-                        unsigned char   green,
-                        unsigned char   blue
-                        );
-
-private:
-    unsigned int            led_count;
-    i2c_smbus_interface*    bus;
-    rgb_fusion_dev_id       dev;
-
-    unsigned char           led_data[10][16];
-
-    void		    WriteLED(int);
-};

Controllers/RGBFusion2SMBusController/RGBFusion2SMBusControllerDetect.cpp

@@ -1,73 +0,0 @@
-#include "RGBFusion2SMBusController.h"
-#include "RGBController.h"
-#include "RGBController_RGBFusion2SMBus.h"
-#include "i2c_smbus.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string>
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForRGBFusion2SMBusController                                                       *
-*                                                                                          *
-*       Tests the given address to see if an RGB 2 Fusion controller exists there.  First  *
-*       does a quick write to test for a response                                          *
-*                                                                                          *
-\******************************************************************************************/
-
-bool TestForRGBFusion2SMBusController(i2c_smbus_interface* bus, unsigned char address)
-{
-    bool pass = false;
-
-    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
-    if (res >= 0)
-    {
-        pass = true;
-
-        // res = bus->i2c_smbus_read_byte_data(address, 0xF2);
-
-        // if (res != 0xC4)
-        // {
-        //     pass = false;
-        // }
-    }
-
-    return(pass);
-
-}   /* TestForRGBFusion2SMBusController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectRGBFusion2SMBusControllers                                                       *
-*                                                                                          *
-*       Detect RGB Fusion 2 controllers on the enumerated I2C busses at address 0x68.      *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where RGB Fusion device is connected      *
-*           dev - I2C address of RGB Fusion device                                         *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
-{
-    RGBFusion2SMBusController* new_rgb_fusion;
-    RGBController_RGBFusion2SMBus* new_controller;
-
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        // TODO - Is this necessary? Or an artifact of my own system?
-        // Skip dmcd devices
-        std::string device_name = std::string(busses[bus]->device_name);
-        if (device_name.find("dmdc") == std::string::npos)
-        {
-            // Check for RGB Fusion 2 controller at 0x68
-            if (TestForRGBFusion2SMBusController(busses[bus], 0x68))
-            {
-                new_rgb_fusion = new RGBFusion2SMBusController(busses[bus], 0x68);
-                new_controller = new RGBController_RGBFusion2SMBus(new_rgb_fusion);
-                rgb_controllers.push_back(new_controller);
-            }
-        }
-    }
-
-}   /* DetectRGBFusion2SMBusControllers() */

Controllers/RGBFusion2USBController/RGBFusion2USBController.cpp

@@ -27,7 +27,7 @@ static LEDCount LedCountToEnum(unsigned int c)
     return(LEDS_1024);
 }
 
-RGBFusion2USBController::RGBFusion2USBController(hid_device* handle, const char *path, std::string mb_name) : dev(handle)
+RGBFusion2USBController::RGBFusion2USBController(hid_device* handle, const char *path) : dev(handle)
 {
     int res = 0;
     char text[64] {};
@@ -46,9 +46,8 @@ RGBFusion2USBController::RGBFusion2USBController(hid_device* handle, const char
         {
             report = *reinterpret_cast<IT8297Report*>(buffer);
 
-            name = mb_name;
-            description = std::string(report.str_product, 32);
-            description.erase(std::find(name.begin(), name.end(), '\0'), name.end());
+            name = std::string(report.str_product, 32);
+            name.erase(std::find(name.begin(), name.end(), '\0'), name.end());
 
             snprintf(text, 11, "0x%08X", report.fw_ver);
             version = text;
@@ -136,11 +135,6 @@ 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, std::string mb_name);
+    RGBFusion2USBController(hid_device* handle, const char *path);
     ~RGBFusion2USBController();
 
     void            SetStripColors
@@ -175,7 +175,6 @@ 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();
@@ -189,7 +188,6 @@ 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,17 +1,8 @@
 #include "RGBFusion2USBController.h"
 #include "RGBController_RGBFusion2USB.h"
-#include "dependencies/dmiinfo.h"
 
-#define IT8297_VID              0x048D
-#define IT8297_IFC              0
-#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
-};
+#define IT8297_VID 0x048D
+#define IT8297_PID 0x8297
 
 /******************************************************************************************\
 *                                                                                          *
@@ -23,45 +14,24 @@ static const unsigned short RGBFusion2_pids[] =
 
 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;
-    }
 
-    for(int dev_idx = 0; dev_idx < COUNT_RGBFUSION2_PIDS; dev_idx++)
+    hid_device_info * device_list = hid_enumerate(IT8297_VID, IT8297_PID);
+    if (!device_list)
+        return;
+
+    hid_device_info * device = device_list;
+    while (device)
     {
-        dev = NULL;
-
-        tmpPID = RGBFusion2_pids[dev_idx];
-        info = hid_enumerate(IT8297_VID, tmpPID);
-
-        while(info)
-        {
-            if((info->vendor_id        == IT8297_VID)
-            && (info->interface_number == IT8297_IFC)
-#ifdef USE_HID_USAGE
-            &&(info->product_id        == tmpPID)
-            &&(info->usage_page        == IT8297_UPG))
-#else
-            &&(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);
-                }
-            }
-            info = info->next;
+        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;
     }
 
-    hid_free_enumeration(info);
+    hid_free_enumeration(device_list);
 }

Controllers/RedragonController/RedragonControllerDetect.cpp

@@ -10,18 +10,14 @@
 | 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
-#define TECWARE_PHANTOM_ELITE_PID       0x652F
-#define WARRIOR_KANE_TC235              0x8520
+
 
 /*-----------------------------------------------------*\
 | Mouse product IDs                                     |
 \*-----------------------------------------------------*/
 #define REDRAGON_MOUSE_VID              0x04D9
-#define REDRAGON_MOUSE_USAGE_PAGE       0xFFA0
 #define REDRAGON_M711_PID               0xFC30
 #define REDRAGON_M715_PID               0xFC39
 
@@ -30,7 +26,6 @@ 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;
@@ -39,22 +34,19 @@ typedef struct
 
 static const redragon_device device_list[] =
 {
-    /*---------------------------------------------------------------------------------------------------------------------------------------------*\
-    | 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                                                                                                                                     |
-    \*---------------------------------------------------------------------------------------------------------------------------------------------*/
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Keyboards                                                                                             |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { REDRAGON_KEYBOARD_VID,    REDRAGON_K550_PID,  1,  DEVICE_TYPE_KEYBOARD,   "Redragon K550 Yama"        },
+    { REDRAGON_KEYBOARD_VID,    REDRAGON_K556_PID,  1,  DEVICE_TYPE_KEYBOARD,   "Redragon K556 Devarajas"   },
+    /*-----------------------------------------------------------------------------------------------------*\
+    | 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                                                                                             |
+    \*-----------------------------------------------------------------------------------------------------*/
 };
 
 /******************************************************************************************\
@@ -81,46 +73,45 @@ 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)
-#ifdef USE_HID_USAGE
-            &&(info->interface_number == device_list[device_idx].usb_interface)
-            &&(info->usage_page       == device_list[device_idx].usb_usage_page))
-#else
+            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))
-#endif
             {
                 dev = hid_open_path(info->path);
+                break;
+            }
+            else
+            {
+                info = info->next;
+            }
+        }
 
-                if( dev )
-                {
-                    switch(device_list[device_idx].type)
+        if( dev )
+        {
+            switch(device_list[device_idx].type)
+            {
+                case DEVICE_TYPE_KEYBOARD:
                     {
-                        case DEVICE_TYPE_KEYBOARD:
-                            {
-                            RedragonK556Controller* controller = new RedragonK556Controller(dev);
+                    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);
-                            }
-                            break;
+                    rgb_controller->name = device_list[device_idx].name;
+                    rgb_controllers.push_back(rgb_controller);
+                    }
+                    break;
 
-                        case DEVICE_TYPE_MOUSE:
-                            {
-                            RedragonM711Controller* controller = new RedragonM711Controller(dev);
+                case DEVICE_TYPE_MOUSE:
+                    {
+                    RedragonM711Controller* controller = new RedragonM711Controller(dev);
 
-                            RGBController_RedragonM711* rgb_controller = new RGBController_RedragonM711(controller);
+                    RGBController_RedragonM711* rgb_controller = new RGBController_RedragonM711(controller);
 
-                            rgb_controller->name = device_list[device_idx].name;
-                            rgb_controllers.push_back(rgb_controller);
-                            }
-                            break;
+                    rgb_controller->name = device_list[device_idx].name;
+                    rgb_controllers.push_back(rgb_controller);
                     }
-                }
+                    break;
             }
-            info = info->next;
         }
     }
 }

Controllers/RedragonController/RedragonM711Controller.cpp

@@ -2,66 +2,24 @@
 
 #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;
-
-    unsigned char active_profile = 0x00;
-
-    SendWritePacket(0x002C, 1, &active_profile);
-    SendMouseApply();
-}
-
-void RedragonM711Controller::SendMouseColor
-    (
-    unsigned char       red,
-    unsigned char       green,
-    unsigned char       blue
-    )
-{
-    unsigned char color_buf[3];
-
-    color_buf[0] = red;
-    color_buf[1] = green;
-    color_buf[2] = blue;
-
-    SendWritePacket(0x0449, 3, color_buf);
-}
-
-void RedragonM711Controller::SendMouseMode
-    (
-    unsigned char       mode,
-    unsigned char       speed
-    )
-{
-    unsigned char mode_buf[3];
-
-    mode_buf[0] = 0x01; //On
-    mode_buf[1] = speed;
-    mode_buf[2] = mode;
-
-    SendWritePacket(0x044C, 3, mode_buf);
-}
-
-void RedragonM711Controller::SendMouseMode
-    (
-    unsigned char       mode,
-    unsigned char       speed,
-    unsigned char       red,
-    unsigned char       green,
-    unsigned char       blue
-    )
-{
-    unsigned char color_mode_buf[6];
-
-    color_mode_buf[0] = red;
-    color_mode_buf[1] = green;
-    color_mode_buf[2] = blue;
-    color_mode_buf[3] = 0x01; //On
-    color_mode_buf[4] = speed;
-    color_mode_buf[5] = mode;
-
-    SendWritePacket(0x0449, 6, color_mode_buf);
 }
 
 /*-------------------------------------------------------------------------------------------------*\
@@ -88,14 +46,16 @@ void RedragonM711Controller::SendMouseApply()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, (unsigned char *)usb_buf, 16);
+    send_usb_msg(dev, usb_buf, 16);
 }
 
-void RedragonM711Controller::SendWritePacket
+void RedragonM711Controller::SendMouseMode
     (
-    unsigned short      address,
-    unsigned char       data_size,
-    unsigned char *     data
+    unsigned char       mode,
+    unsigned char       speed,
+    unsigned char       red,
+    unsigned char       green,
+    unsigned char       blue
     )
 {
     char usb_buf[16];
@@ -110,17 +70,21 @@ void RedragonM711Controller::SendWritePacket
     \*-----------------------------------------------------*/
     usb_buf[0x00]           = 0x02;
     usb_buf[0x01]           = 0xF3;
-    usb_buf[0x02]           = address & 0xFF;
-    usb_buf[0x03]           = address >> 8;
-    usb_buf[0x04]           = data_size;
+    usb_buf[0x02]           = 0x49;
+    usb_buf[0x03]           = 0x04;
+    usb_buf[0x04]           = 0x06;
+
+    usb_buf[0x08]           = red;
+    usb_buf[0x09]           = green;
+    usb_buf[0x0A]           = blue;
+
+    usb_buf[0x0B]           = 0x01; //on
+
+    usb_buf[0x0C]           = speed;
+    usb_buf[0x0D]           = mode;
 
-    /*-----------------------------------------------------*\
-    | Copy in data bytes                                    |
-    \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x08], data, data_size);
-    
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, (unsigned char *)usb_buf, 16);
+    send_usb_msg(dev, usb_buf, 16);
 }

Controllers/RedragonController/RedragonM711Controller.h

@@ -32,19 +32,6 @@ public:
 
     void        SendMouseApply();
 
-    void        SendMouseColor
-                    (
-                    unsigned char       red,
-                    unsigned char       green,
-                    unsigned char       blue
-                    );
-
-    void        SendMouseMode
-                   (
-                   unsigned char       mode,
-                   unsigned char       speed
-                   );
-
     void        SendMouseMode
                    (
                    unsigned char       mode,
@@ -56,11 +43,4 @@ public:
 
 private:
     hid_device*             dev;
-
-    void        SendWritePacket
-                    (
-                    unsigned short      address,
-                    unsigned char       data_size,
-                    unsigned char *     data
-                    );
 };

Controllers/SteelSeriesController/SteelSeriesApexController.cpp

@@ -1,117 +0,0 @@
-/*-----------------------------------------*\
-|  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 color_mode;
-    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[642];
-    int num_keys = sizeof(keys)/sizeof(*keys);
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Direct packet                                  |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = APEX7_PACKET_ID_DIRECT;
-    buf[0x01]   = num_keys;
-
-    /*-----------------------------------------------------*\
-    | Fill in color data                                    |
-    \*-----------------------------------------------------*/
-    for(int i = 0; i < num_keys; i++)
-    {
-        buf[(i*4)+2] = keys[i];
-        buf[(i*4)+3] = RGBGetRValue(colors[i]);
-        buf[(i*4)+4] = RGBGetGValue(colors[i]);
-        buf[(i*4)+5] = RGBGetBValue(colors[i]);
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 642);
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void SteelSeriesApexController::SelectProfile
-    (
-    unsigned char   profile
-    )
-{
-    unsigned char buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer, set up first packet and send         |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-    buf[0x00]   = 0x69;
-    hid_send_feature_report(dev, buf, 64);
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer, set up second packet and send        |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-    buf[0x00]   = 0x89;
-    buf[0x01]   = profile;
-    hid_send_feature_report(dev, buf, 64);
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer, set up third packet and send         |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-    buf[0x00]   = 0x41;
-    hid_send_feature_report(dev, buf, 64);
-    
-}

Controllers/SteelSeriesController/SteelSeriesApexController.h

@@ -1,44 +0,0 @@
-/*-----------------------------------------*\
-|  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,156 +0,0 @@
-#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>
-
-/*-----------------------------------------------------*\
-| Vendor ID                                             |
-\*-----------------------------------------------------*/
-#define STEELSERIES_VID                             0x1038
-/*-----------------------------------------------------*\
-| Mouse product IDs                                     |
-\*-----------------------------------------------------*/
-#define STEELSERIES_RIVAL_100_PID                   0x1702
-#define STEELSERIES_RIVAL_100_DOTA_PID              0x170c
-#define STEELSERIES_RIVAL_105_PID                   0x1814
-#define STEELSERIES_RIVAL_110_PID                   0x1729
-#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
-#define STEELSERIES_RIVAL_300_CSGO_HYPERBEAST_PID   0x171a
-#define STEELSERIES_RIVAL_300_DOTA_PID              0x1392
-#define STEELSERIES_RIVAL_300_HP_PID                0x1718
-#define STEELSERIES_RIVAL_300_BLACKOPS_PID          0x1710
-/*-----------------------------------------------------*\
-| Headset product IDs                                   |
-\*-----------------------------------------------------*/
-#define STEELSERIES_SIBERIA_350_PID                 0x1229
-/*-----------------------------------------------------*\
-| Keyboard product IDs                                  |
-\*-----------------------------------------------------*/
-#define STEELSERIES_APEX_7_PID                      0x1612
-
-typedef struct
-{
-    unsigned short  usb_vid;
-    unsigned short  usb_pid;
-    unsigned char   usb_interface;
-    device_type     type;
-    steelseries_type    proto_type;
-    const char *    name;
-} steelseries_device;
-
-#define STEELSERIES_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const steelseries_device device_list[] = 
-{
-    /*-----------------------------------------------------------------------------------------------------------------------------------------------------------------*\
-    | Mice                                                                                                                                                              |
-    \*-----------------------------------------------------------------------------------------------------------------------------------------------------------------*/
-    { STEELSERIES_VID,      STEELSERIES_RIVAL_100_PID,                  0,  DEVICE_TYPE_MOUSE,      RIVAL_100,      "SteelSeries Rival 100"                             },
-    { STEELSERIES_VID,      STEELSERIES_RIVAL_100_DOTA_PID,             0,  DEVICE_TYPE_MOUSE,      RIVAL_100,      "SteelSeries Rival 100 DotA 2 Edition"              },
-    { STEELSERIES_VID,      STEELSERIES_RIVAL_105_PID,                  0,  DEVICE_TYPE_MOUSE,      RIVAL_100,      "SteelSeries Rival 105"                             },
-    { STEELSERIES_VID,      STEELSERIES_RIVAL_110_PID,                  0,  DEVICE_TYPE_MOUSE,      RIVAL_100,      "SteelSeries Rival 110"                             },
-    { STEELSERIES_VID,      STEELSERIES_RIVAL_300_PID,                  0,  DEVICE_TYPE_MOUSE,      RIVAL_300,      "SteelSeries Rival 300"                             },
-    { STEELSERIES_VID,      ACER_PREDATOR_RIVAL_300_PID,                0,  DEVICE_TYPE_MOUSE,      RIVAL_300,      "Acer Predator Gaming Mouse (Rival 300)"            },
-    { STEELSERIES_VID,      STEELSERIES_RIVAL_300_CSGO_PID,             0,  DEVICE_TYPE_MOUSE,      RIVAL_300,      "SteelSeries Rival 300 CS:GO Fade Edition"          },
-    { STEELSERIES_VID,      STEELSERIES_RIVAL_300_CSGO_STM32_PID,       0,  DEVICE_TYPE_MOUSE,      RIVAL_300,      "SteelSeries Rival 300 CS:GO Fade Edition (stm32)"  },
-    { STEELSERIES_VID,      STEELSERIES_RIVAL_300_CSGO_HYPERBEAST_PID,  0,  DEVICE_TYPE_MOUSE,      RIVAL_300,      "SteelSeries Rival 300 CS:GO Hyperbeast Edition"    },
-    { STEELSERIES_VID,      STEELSERIES_RIVAL_300_DOTA_PID,             0,  DEVICE_TYPE_MOUSE,      RIVAL_300,      "SteelSeries Rival 300 Dota 2 Edition"              },
-    { STEELSERIES_VID,      STEELSERIES_RIVAL_300_HP_PID,               0,  DEVICE_TYPE_MOUSE,      RIVAL_300,      "SteelSeries Rival 300 HP Omen Edition"             },
-    { STEELSERIES_VID,      STEELSERIES_RIVAL_300_BLACKOPS_PID,         0,  DEVICE_TYPE_MOUSE,      RIVAL_300,      "SteelSeries Rival 300 Black Ops Edition"           },
-    /*-----------------------------------------------------------------------------------------------------------------------------------------------------------------*\
-    | 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, Headset or Keyboard       *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectSteelSeriesControllers(std::vector<RGBController*>& rgb_controllers)
-{
-    hid_device_info* info;
-    hid_device* dev;
-
-    hid_init();
-
-    for(int device_idx = 0; device_idx < STEELSERIES_NUM_DEVICES; device_idx++)
-    {
-        dev = NULL;
-
-        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
-
-        //Look for SteelSeries 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);
-                break;
-            }
-            else
-            {
-                info = info->next;
-            }
-        }
-
-        if(dev)
-        {
-            switch(device_list[device_idx].type)
-            {
-                case DEVICE_TYPE_KEYBOARD:
-                    {
-                    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:
-                    {
-                    SteelSeriesSiberiaController* controller = new SteelSeriesSiberiaController(dev);
-
-                    RGBController_SteelSeriesSiberia* rgb_controller = new RGBController_SteelSeriesSiberia(controller);
-                    rgb_controller->name = device_list[device_idx].name;
-                    rgb_controllers.push_back(rgb_controller);
-                    }
-                    break;
-
-                case DEVICE_TYPE_MOUSE:
-                    {
-                    SteelSeriesRivalController* controller = new SteelSeriesRivalController(dev, device_list[device_idx].proto_type);
-
-                    RGBController_SteelSeriesRival* rgb_controller = new RGBController_SteelSeriesRival(controller);
-                    rgb_controller->name = device_list[device_idx].name;
-                    rgb_controllers.push_back(rgb_controller);
-                    }
-                    break;
-
-                case DEVICE_TYPE_MOUSEMAT:
-                    /* Not yet supported */
-                    break;
-            }
-        }
-    }
-}

Controllers/SteelSeriesController/SteelSeriesGeneric.h

@@ -1,25 +0,0 @@
-/*-----------------------------------------*\
-|  SteelSeriesGeneric.h                     |
-|                                           |
-|  Definitions and types for the SteelSeries|
-|  Devices.                                 |
-|                                           |
-|  B Horn (bahorn) 17/5/2020                |
-\*-----------------------------------------*/
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-/* Allows us to handle variation in the protocol.
- * Defined in a single enum so we can keep the device_list struct the same
- * for every possible device. */
-typedef enum
-{
-    RIVAL_100   = 0x00,
-    RIVAL_300   = 0x01,
-    SIBERIA_350 = 0x03,
-    APEX_7		= 0x04,
-} steelseries_type;
-

Controllers/SteelSeriesController/SteelSeriesRivalController.cpp

@@ -1,156 +0,0 @@
-/*-----------------------------------------*\
-|  SteelSeriesRivalController.h             |
-|                                           |
-|  Definitions and types for SteelSeries    |
-|  Rival lighting controller                |
-|                                           |
-|  B Horn (bahorn) 13/5/2020                |
-\*-----------------------------------------*/
-
-#include "SteelSeriesRivalController.h"
-#include <cstring>
-#include <stdio.h>
-#include <stdlib.h>
-
-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(unsigned int i = 1; i < size + 1; i++)
-    {
-        usb_pkt[i] = data_pkt[i-1];
-    }
-    
-    hid_write(dev, (unsigned char *)usb_pkt, size + 1);
-    
-    delete usb_pkt;
-}
-
-SteelSeriesRivalController::SteelSeriesRivalController
-    (
-    hid_device*         dev_handle,
-    steelseries_type    proto_type
-    )
-{
-    dev = dev_handle;
-    proto = proto_type;
-}
-
-SteelSeriesRivalController::~SteelSeriesRivalController()
-{
-
-}
-
-char* SteelSeriesRivalController::GetDeviceName()
-{
-    return device_name;
-}
-
-steelseries_type SteelSeriesRivalController::GetMouseType()
-{
-    return proto;
-}
-
-/* Saves to the internal configuration */
-void SteelSeriesRivalController::Save()
-{
-    char usb_buf[9];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    usb_buf[0x00]       = 0x09;
-    send_usb_msg(dev, usb_buf, 9);
-}
-
-
-void SteelSeriesRivalController::SetLightEffect
-    (
-    unsigned char   zone_id,
-    unsigned char   effect
-    )
-{
-    char usb_buf[9];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    switch (proto) {
-        case RIVAL_100:
-            usb_buf[0x00]       = 0x07;
-            usb_buf[0x01]       = 0x00;
-            break;
-        case RIVAL_300:
-            usb_buf[0x00]       = 0x07;
-            usb_buf[0x01]       = zone_id + 1;
-            break;
-    }
-    usb_buf[0x02]       = effect;
-    send_usb_msg(dev, usb_buf, 9);
-}
-
-
-void SteelSeriesRivalController::SetLightEffectAll
-    (
-    unsigned char   effect
-    )
-{
-    switch(proto)
-    {
-        case RIVAL_100:
-            SetLightEffect(0, effect);
-            break;
-
-        case RIVAL_300:
-            SetLightEffect(0, effect);
-            SetLightEffect(1, effect);
-            break;
-    }
-
-}
-
-
-void SteelSeriesRivalController::SetColor
-    (
-    unsigned char   zone_id,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    char usb_buf[9];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    switch (proto)
-    {
-        case RIVAL_100:
-            usb_buf[0x00]       = 0x05;
-            usb_buf[0x01]       = 0x00;
-            break;
-    
-        case RIVAL_300:
-            usb_buf[0x00]       = 0x08;
-            usb_buf[0x01]       = zone_id + 1;
-            break;
-    }
-    usb_buf[0x02]       = red;
-    usb_buf[0x03]       = green;
-    usb_buf[0x04]       = blue;
-
-    send_usb_msg(dev, usb_buf, 9);
-}
-
-void SteelSeriesRivalController::SetColorAll
-    (
-        unsigned char   red,
-        unsigned char   green,
-        unsigned char   blue
-    )
-{
-    switch(proto)
-    {
-        case RIVAL_100:
-            SetColor(0, red, green, blue);
-            break;
-
-        case RIVAL_300:
-            SetColor(0, red, green, blue);
-            SetColor(1, red, green, blue);
-            break;
-    }
-}
-

Controllers/SteelSeriesController/SteelSeriesRivalController.h

@@ -1,79 +0,0 @@
-/*-----------------------------------------*\
-|  SteelSeriesRivalController.h             |
-|                                           |
-|  Definitions and types for SteelSeries    |
-|  Rival lighting controller                |
-|                                           |
-|  B Horn (bahorn) 13/5/2020                |
-\*-----------------------------------------*/
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#include "SteelSeriesGeneric.h"
-
-#pragma once
-
-/* Mode, we then use these to set actual effect based on speed. */
-enum
-{
-    STEELSERIES_RIVAL_STATIC = 0x00,
-    STEELSERIES_RIVAL_PULSATE = 0x01
-};
-
-/* Effects */
-enum
-{
-    STEELSERIES_RIVAL_EFFECT_STATIC = 0x01,
-    STEELSERIES_RIVAL_EFFECT_PULSATE_MIN = 0x02,
-    STEELSERIES_RIVAL_EFFECT_PULSATE_MID = 0x03,
-    STEELSERIES_RIVAL_EFFECT_PULSATE_MAX = 0x04
-};
-
-class SteelSeriesRivalController
-{
-public:
-    SteelSeriesRivalController
-        (
-        hid_device*         dev_handle,
-        steelseries_type    proto_type
-        );
-
-    ~SteelSeriesRivalController();
-
-    char* GetDeviceName();
-
-    steelseries_type GetMouseType();
-
-    void Save();
-
-    void SetLightEffect
-            (
-            unsigned char   zone_id,
-            unsigned char   effect
-            );
-
-    void SetLightEffectAll
-            (
-            unsigned char   effect
-            );
-
-    void SetColor
-            (
-            unsigned char   zone_id,
-            unsigned char   red,
-            unsigned char   green,
-            unsigned char   blue
-            );
-    void SetColorAll
-            (
-                unsigned char red,
-                unsigned char green,
-                unsigned char blue
-            );
-
-private:
-    char                    device_name[32];
-    hid_device*             dev;
-    steelseries_type        proto;
-};

Controllers/SteelSeriesController/SteelSeriesSiberiaController.cpp

@@ -1,92 +0,0 @@
-/*-----------------------------------------*\
-|  SteelSeriesSiberiaController.cpp         |
-|                                           |
-|  Definitions and types for SteelSeries    |
-|  Siberia lighting controller              |
-|                                           |
-|  E Karlsson (pilophae) 18/6/2020          |
-|  
-\*-----------------------------------------*/
-
-#include "SteelSeriesSiberiaController.h"
-#include <cstring>
-
-static void send_usb_msg(hid_device* dev, char * data_pkt, unsigned int size)
-{
-    char* usb_pkt = new char[16];
-    memset(usb_pkt, 0x00, sizeof(usb_pkt));
-    
-    // Report number
-    usb_pkt[0] = 0x01;
-    // Magic
-    usb_pkt[1] = 0x00;
-    // Command
-    usb_pkt[2] = data_pkt[0];
-    // Payload length
-    usb_pkt[3] = size - 1;
-
-    for(unsigned int i = 0; i < (size - 1); i++)
-    {
-        usb_pkt[4 + i] = data_pkt[1 + i];
-    }
-    
-    hid_write(dev, (unsigned char *)usb_pkt, 16);
-    
-    delete[] usb_pkt;
-}
-
-SteelSeriesSiberiaController::SteelSeriesSiberiaController
-    (
-    hid_device*         dev_handle
-    )
-{
-    dev = dev_handle;
-}
-
-SteelSeriesSiberiaController::~SteelSeriesSiberiaController()
-{
-}
-
-char* SteelSeriesSiberiaController::GetDeviceName()
-{
-    return device_name;
-}
-
-void SteelSeriesSiberiaController::SetColor
-    (
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    char usb_buf[4];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    
-    // Command 1
-    usb_buf[0] = 0x95;
-    usb_buf[1] = 0x80;
-    usb_buf[2] = 0xbf;
-    send_usb_msg(dev, usb_buf, 3);
-
-    // Command 2
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    usb_buf[0] = 0x80;
-    usb_buf[1] = 0x52;
-    usb_buf[2] = 0x20;
-    send_usb_msg(dev, usb_buf, 3);
-
-    // Command 3 (Set color)
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    usb_buf[0] = 0x83;
-    usb_buf[1] = red;
-    usb_buf[2] = green;
-    usb_buf[3] = blue;
-    send_usb_msg(dev, usb_buf, 4);
-
-    // Command 4
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    usb_buf[0] = 0x93;
-    usb_buf[1] = 0x03;
-    usb_buf[2] = 0x80;
-    send_usb_msg(dev, usb_buf, 3);
-}

Controllers/SteelSeriesController/SteelSeriesSiberiaController.h

@@ -1,37 +0,0 @@
-/*-----------------------------------------*\
-|  SteelSeriesSiberiaController.h           |
-|                                           |
-|  Definitions and types for SteelSeries    |
-|  Siberia lighting controller              |
-|                                           |
-|  E Karlsson (pilophae) 18/6/2020          |
-\*-----------------------------------------*/
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-class SteelSeriesSiberiaController
-{
-public:
-    SteelSeriesSiberiaController
-        (
-        hid_device*         dev_handle
-        );
-
-    ~SteelSeriesSiberiaController();
-
-    char* GetDeviceName();
-
-    void SetColor
-            (
-            unsigned char   red,
-            unsigned char   green,
-            unsigned char   blue
-            );
-
-private:
-    char                    device_name[32];
-    hid_device*             dev;
-};

Controllers/ThermaltakeRiingController/ThermaltakeRiingController.cpp

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

Controllers/ThermaltakeRiingController/ThermaltakeRiingController.h

@@ -9,7 +9,7 @@
 
 #include "RGBController.h"
 #include <vector>
-#include <hidapi/hidapi.h>
+#include <libusb-1.0/libusb.h>
 
 #pragma once
 
@@ -47,14 +47,14 @@ enum
 class ThermaltakeRiingController
 {
 public:
-    ThermaltakeRiingController(hid_device* dev_handle);
+    ThermaltakeRiingController(libusb_device_handle* dev_handle);
     ~ThermaltakeRiingController();
 
     void            SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors);
     void            SetMode(unsigned char mode, unsigned char speed);
 
 private:
-    hid_device*     dev;
+    libusb_device_handle*   dev;
 
     unsigned char   current_mode;
     unsigned char   current_speed;

Controllers/ThermaltakeRiingController/ThermaltakeRiingControllerDetect.cpp

@@ -2,7 +2,7 @@
 #include "RGBController.h"
 #include "RGBController_ThermaltakeRiing.h"
 #include <vector>
-#include <hidapi/hidapi.h>
+#include <libusb-1.0/libusb.h>
 
 #define THERMALTAKE_RIING_VID       0x264A
 #define THERMALTAKE_RIING_PID_BEGIN 0x1FA5
@@ -18,34 +18,19 @@
 
 void DetectThermaltakeRiingControllers(std::vector<RGBController*>& rgb_controllers)
 {
-    hid_device_info* info;
-    hid_device* dev;
-
-    hid_init();
+    libusb_context * ctx;
+    libusb_init(&ctx);
 
     for(int pid = THERMALTAKE_RIING_PID_BEGIN; pid <= THERMALTAKE_RIING_PID_END; pid++)
     {
-        dev = NULL;
-
-        info = hid_enumerate(THERMALTAKE_RIING_VID, pid);
-
         //Look for Thermaltake Riing device
-        while(info)
-        {
-            if((info->vendor_id == THERMALTAKE_RIING_VID)
-            &&(info->product_id == pid))
-            {
-                dev = hid_open_path(info->path);
-                break;
-            }
-            else
-            {
-                info = info->next;
-            }
-        }
+        libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, THERMALTAKE_RIING_VID, pid);
 
-        if(dev)
+        if( dev )
         {
+            libusb_detach_kernel_driver(dev, 0);
+            libusb_claim_interface(dev, 0);
+
             ThermaltakeRiingController* controller = new ThermaltakeRiingController(dev);
 
             RGBController_ThermaltakeRiing* rgb_controller = new RGBController_ThermaltakeRiing(controller);

NetworkClient.cpp

@@ -10,52 +10,23 @@
 #include "RGBController_Network.h"
 #include <cstring>
 
-#ifdef _WIN32
+#ifdef WIN32
 #include <Windows.h>
-#define MSG_NOSIGNAL 0
-#endif
-
-#ifdef __APPLE__
+#else
 #include <unistd.h>
-#define MSG_NOSIGNAL 0
-#endif
 
-#ifdef __linux__
-#include <unistd.h>
-#include <sys/select.h>
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
 #endif
 
-using namespace std::chrono_literals;
-
 NetworkClient::NetworkClient(std::vector<RGBController *>& control) : controllers(control)
 {
     strcpy(port_ip, "127.0.0.1");
-    port_num                = OPENRGB_SDK_PORT;
+    port_num                = 1337;
     server_connected        = false;
     server_controller_count = 0;
-
-    ListenThread            = NULL;
-    ConnectionThread        = NULL;
-}
-
-void NetworkClient::ClientInfoChanged()
-{
-    ClientInfoChangeMutex.lock();
-
-    /*-------------------------------------------------*\
-    | Client info has changed, call the callbacks       |
-    \*-------------------------------------------------*/
-    for(unsigned int callback_idx = 0; callback_idx < ClientInfoChangeCallbacks.size(); callback_idx++)
-    {
-        ClientInfoChangeCallbacks[callback_idx](ClientInfoChangeCallbackArgs[callback_idx]);
-    }
-
-    ClientInfoChangeMutex.unlock();
-}
-
-const char * NetworkClient::GetIP()
-{
-    return(port_ip);
 }
 
 unsigned short NetworkClient::GetPort()
@@ -63,20 +34,9 @@ unsigned short NetworkClient::GetPort()
     return port_num;
 }
 
-bool NetworkClient::GetConnected()
-{
-    return(server_connected);
-}
-
 bool NetworkClient::GetOnline()
 {
-    return(server_connected && server_initialized);
-}
-
-void NetworkClient::RegisterClientInfoChangeCallback(NetClientCallback new_callback, void * new_callback_arg)
-{
-    ClientInfoChangeCallbacks.push_back(new_callback);
-    ClientInfoChangeCallbackArgs.push_back(new_callback_arg);
+    return server_connected;
 }
 
 void NetworkClient::SetIP(const char *new_ip)
@@ -107,165 +67,88 @@ void NetworkClient::SetPort(unsigned short new_port)
 
 void NetworkClient::StartClient()
 {
+    unsigned int requested_controllers;
+
     //Start a TCP server and launch threads
     char port_str[6];
     snprintf(port_str, 6, "%d", port_num);
 
     port.tcp_client(port_ip, port_str);
 
-    client_active = true;
+    requested_controllers   = 0;
 
     //Start the connection thread
     ConnectionThread = new std::thread(&NetworkClient::ConnectionThreadFunction, this);
 
-    /*-------------------------------------------------*\
-    | Client info has changed, call the callbacks       |
-    \*-------------------------------------------------*/
-    ClientInfoChanged();
+    //Start the listener thread
+    ListenThread = new std::thread(&NetworkClient::ListenThreadFunction, this);
+
+    //Wait for server to connect
+    while(!server_connected)
+    {
+        Sleep(100);
+    }
+
+    //Once server is connected, send client string
+    SendData_ClientString();
+
+    //Request number of controllers
+    SendRequest_ControllerCount();
+
+    //Wait for server controller count
+    while(server_controller_count == 0)
+    {
+        Sleep(100);
+    }
+
+    printf("Client: Received controller count from server: %d\r\n", server_controller_count);
+
+    //Once count is received, request controllers
+    while(requested_controllers < server_controller_count)
+    {
+        printf("Client: Requesting controller %d\r\n", requested_controllers);
+
+        SendRequest_ControllerData(requested_controllers);
+
+        //Wait until controller is received
+        while(server_controllers.size() == requested_controllers)
+        {
+            Sleep(100);
+        }
+
+        requested_controllers++;
+    }
+
+    //All controllers received, add them to master list
+    printf("Client: All controllers received, adding them to master list\r\n");
+    for(std::size_t controller_idx = 0; controller_idx < server_controllers.size(); controller_idx++)
+    {
+        controllers.push_back(server_controllers[controller_idx]);
+    }
 }
 
 void NetworkClient::StopClient()
 {
-    server_connected = false;
-    client_active    = false;
 
-    shutdown(client_sock, SD_RECEIVE);
-    closesocket(client_sock);
-    if(ListenThread)
-        ListenThread->join();
-    ConnectionThread->join();
-
-    /*-------------------------------------------------*\
-    | Client info has changed, call the callbacks       |
-    \*-------------------------------------------------*/
-    ClientInfoChanged();
 }
 
 void NetworkClient::ConnectionThreadFunction()
 {
-    unsigned int requested_controllers;
-
     //This thread manages the connection to the server
-    while(client_active == true)
-    {
-        if(server_connected == false)
-        {
-            //Connect to server and reconnect if the connection is lost
-            server_initialized = false;
-
-            //Try to connect to server
-            if(port.tcp_client_connect() == true)
-            {
-                client_sock = port.sock;
-                printf( "Connected to server\n" );
-
-                //Server is now connected
-                server_connected = true;
-
-                //Start the listener thread
-                ListenThread = new std::thread(&NetworkClient::ListenThreadFunction, this);
-
-                //Server is not initialized
-                server_initialized = false;
-
-                /*-------------------------------------------------*\
-                | Client info has changed, call the callbacks       |
-                \*-------------------------------------------------*/
-                ClientInfoChanged();
-            }
-            else
-            {
-                printf( "Connection attempt failed\n" );
-            }
-        }
-
-        if(server_initialized == false && server_connected == true)
-        {
-            requested_controllers   = 0;
-            server_controller_count = 0;
-
-            //Wait for server to connect
-            std::this_thread::sleep_for(100ms);
-
-            //Once server is connected, send client string
-            SendData_ClientString();
-
-            //Request number of controllers
-            SendRequest_ControllerCount();
-
-            //Wait for server controller count
-            while(server_controller_count == 0)
-            {
-                std::this_thread::sleep_for(5ms);
-            }
-
-            printf("Client: Received controller count from server: %d\r\n", server_controller_count);
-
-            //Once count is received, request controllers
-            while(requested_controllers < server_controller_count)
-            {
-                printf("Client: Requesting controller %d\r\n", requested_controllers);
-
-                controller_data_received = false;
-                SendRequest_ControllerData(requested_controllers);
-
-                //Wait until controller is received
-                while(controller_data_received == false)
-                {
-                    std::this_thread::sleep_for(5ms);
-                }
-
-                requested_controllers++;
-            }
-
-            //All controllers received, add them to master list
-            printf("Client: All controllers received, adding them to master list\r\n");
-            for(std::size_t controller_idx = 0; controller_idx < server_controllers.size(); controller_idx++)
-            {
-                controllers.push_back(server_controllers[controller_idx]);
-            }
-
-            server_initialized = true;
-
-            /*-------------------------------------------------*\
-            | Client info has changed, call the callbacks       |
-            \*-------------------------------------------------*/
-            ClientInfoChanged();
-        }
-
-        std::this_thread::sleep_for(1s);
-    }
-}
-
-int NetworkClient::recv_select(SOCKET s, char *buf, int len, int flags)
-{
-    fd_set              set;
-    struct timeval      timeout;
-
     while(1)
     {
-        timeout.tv_sec      = 5;
-        timeout.tv_usec     = 0;
-        
-        FD_ZERO(&set);      /* clear the set */
-        FD_SET(s, &set);    /* add our file descriptor to the set */
+        //Connect to server and reconnect if the connection is lost
 
-        int rv = select(s + 1, &set, NULL, NULL, &timeout);
+        //Try to connect to server
+        port.tcp_client_connect();
 
-        if(rv == SOCKET_ERROR || server_connected == false)
-        {
-            return 0;
-        }
-        else if(rv == 0)
-        {
-            continue;
-        }
-        else
-        {
-            // socket has something to read
-            return(recv(s, buf, len, flags));
-        }
-        
+        printf( "Connected to server\n" );
+
+        server_connected = true;
+        break;
+
+        //Wait 1 second between tries;
+        Sleep(1000);
     }
 }
 
@@ -273,19 +156,17 @@ void NetworkClient::ListenThreadFunction()
 {
     printf("Network client listener started\n");
     //This thread handles messages received from the server
-    while(server_connected == true)
+    while(1)
     {
         NetPacketHeader header;
-        int             bytes_read  = 0;
         char *          data        = NULL;
+        int             bytes_read  = 0;
 
         //Read first byte of magic
-        bytes_read = recv_select(client_sock, &header.pkt_magic[0], 1, 0);
-
-        if(bytes_read <= 0)
+        do
         {
-            goto listen_done;
-        }
+            bytes_read = port.tcp_listen(&header.pkt_magic[0], 1);
+        } while(bytes_read == 0);
 
         //Test first character of magic - 'O'
         if(header.pkt_magic[0] != 'O')
@@ -294,12 +175,10 @@ void NetworkClient::ListenThreadFunction()
         }
 
         //Read second byte of magic
-        bytes_read = recv_select(client_sock, &header.pkt_magic[1], 1, 0);
-
-        if(bytes_read <= 0)
+        do
         {
-            goto listen_done;
-        }
+            bytes_read = port.tcp_listen(&header.pkt_magic[1], 1);
+        } while(bytes_read == 0);
 
         //Test second character of magic - 'R'
         if(header.pkt_magic[1] != 'R')
@@ -308,12 +187,10 @@ void NetworkClient::ListenThreadFunction()
         }
 
         //Read third byte of magic
-        bytes_read = recv_select(client_sock, &header.pkt_magic[2], 1, 0);
-
-        if(bytes_read <= 0)
+        do
         {
-            goto listen_done;
-        }
+            bytes_read = port.tcp_listen(&header.pkt_magic[2], 1);
+        } while(bytes_read == 0);
 
         //Test third character of magic - 'G'
         if(header.pkt_magic[2] != 'G')
@@ -322,12 +199,10 @@ void NetworkClient::ListenThreadFunction()
         }
 
         //Read fourth byte of magic
-        bytes_read = recv_select(client_sock, &header.pkt_magic[3], 1, 0);
-
-        if(bytes_read <= 0)
+        do
         {
-            goto listen_done;
-        }
+            bytes_read = port.tcp_listen(&header.pkt_magic[3], 1);
+        } while(bytes_read == 0);
 
         //Test fourth character of magic - 'B'
         if(header.pkt_magic[3] != 'B')
@@ -339,90 +214,45 @@ void NetworkClient::ListenThreadFunction()
         bytes_read = 0;
         do
         {
-            int tmp_bytes_read = 0;
-
-            tmp_bytes_read = recv_select(client_sock, (char *)&header.pkt_dev_idx + bytes_read, sizeof(header) - sizeof(header.pkt_magic) - bytes_read, 0);
-
-            bytes_read += tmp_bytes_read;
-
-            if(tmp_bytes_read <= 0)
-            {
-                goto listen_done;
-            }
-
+            bytes_read += port.tcp_listen((char *)&header.pkt_dev_idx + bytes_read, sizeof(header) - sizeof(header.pkt_magic) - bytes_read);
         } while(bytes_read != sizeof(header) - sizeof(header.pkt_magic));
 
-        //printf( "Client: Received header, now receiving data of size %d\r\n", header.pkt_size);
+        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)
         {
-            bytes_read = 0;
+            unsigned int bytes_read = 0;
 
             data = new char[header.pkt_size];
 
             do
             {
-                int tmp_bytes_read = 0;
-
-                tmp_bytes_read = recv_select(client_sock, &data[bytes_read], header.pkt_size - bytes_read, 0);
-
-                if(tmp_bytes_read <= 0)
-                {
-                    goto listen_done;
-                }
-                bytes_read += tmp_bytes_read;
-
+                bytes_read += port.tcp_listen(&data[bytes_read], header.pkt_size - bytes_read);
             } while (bytes_read < header.pkt_size);
         }
 
-        //printf( "Client: Received header and data\r\n" );
-        //printf( "Client: Packet ID: %d \r\n", header.pkt_id);
+        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;
         }
 
         delete[] data;
     }
-
-listen_done:
-    printf( "Client socket has been closed");
-    server_initialized = false;
-    server_connected = false;
-
-    for(int server_controller_idx = 0; server_controller_idx < server_controllers.size(); server_controller_idx++)
-    {
-        for(int controller_idx = 0; controller_idx < controllers.size(); controller_idx++)
-        {
-            if(controllers[controller_idx] == server_controllers[server_controller_idx])
-            {
-                controllers.erase(controllers.begin() + controller_idx);
-                break;
-            }
-        }
-
-        delete server_controllers[server_controller_idx];
-    }
-
-    server_controllers.clear();
-
-    /*-------------------------------------------------*\
-    | Client info has changed, call the callbacks       |
-    \*-------------------------------------------------*/
-    ClientInfoChanged();
 }
 
 void NetworkClient::ProcessReply_ControllerCount(unsigned int data_size, char * data)
@@ -442,8 +272,6 @@ void NetworkClient::ProcessReply_ControllerData(unsigned int data_size, char * d
     printf("Received controller: %s\r\n", new_controller->name.c_str());
 
     server_controllers.push_back(new_controller);
-
-    controller_data_received = true;
 }
 
 void NetworkClient::SendData_ClientString()
@@ -459,8 +287,8 @@ void NetworkClient::SendData_ClientString()
     reply_hdr.pkt_id       = NET_PACKET_ID_SET_CLIENT_NAME;
     reply_hdr.pkt_size     = strlen(client_name.c_str()) + 1;
 
-    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
-    send(client_sock, (char *)client_name.c_str(), reply_hdr.pkt_size, MSG_NOSIGNAL);
+    port.tcp_client_write((char *)&reply_hdr, sizeof(NetPacketHeader));
+    port.tcp_client_write((char *)client_name.c_str(), reply_hdr.pkt_size);
 }
 
 void NetworkClient::SendRequest_ControllerCount()
@@ -476,13 +304,13 @@ void NetworkClient::SendRequest_ControllerCount()
     reply_hdr.pkt_id       = NET_PACKET_ID_REQUEST_CONTROLLER_COUNT;
     reply_hdr.pkt_size     = 0;
 
-    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
+    port.tcp_client_write((char *)&reply_hdr, sizeof(NetPacketHeader));
 }
 
 void NetworkClient::SendRequest_ControllerData(unsigned int dev_idx)
 {
     NetPacketHeader reply_hdr;
-
+    
     reply_hdr.pkt_magic[0] = 'O';
     reply_hdr.pkt_magic[1] = 'R';
     reply_hdr.pkt_magic[2] = 'G';
@@ -492,14 +320,14 @@ void NetworkClient::SendRequest_ControllerData(unsigned int dev_idx)
     reply_hdr.pkt_id       = NET_PACKET_ID_REQUEST_CONTROLLER_DATA;
     reply_hdr.pkt_size     = 0;
 
-    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
+    port.tcp_client_write((char *)&reply_hdr, sizeof(NetPacketHeader));
 }
 
 void NetworkClient::SendRequest_RGBController_ResizeZone(unsigned int dev_idx, int zone, int new_size)
 {
     NetPacketHeader reply_hdr;
     int             reply_data[2];
-
+    
     reply_hdr.pkt_magic[0] = 'O';
     reply_hdr.pkt_magic[1] = 'R';
     reply_hdr.pkt_magic[2] = 'G';
@@ -512,14 +340,14 @@ void NetworkClient::SendRequest_RGBController_ResizeZone(unsigned int dev_idx, i
     reply_data[0]          = zone;
     reply_data[1]          = new_size;
 
-    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
-    send(client_sock, (char *)&reply_data, sizeof(reply_data), MSG_NOSIGNAL);
+    port.tcp_client_write((char *)&reply_hdr, sizeof(NetPacketHeader));
+    port.tcp_client_write((char *)&reply_data, sizeof(reply_data));
 }
 
 void NetworkClient::SendRequest_RGBController_UpdateLEDs(unsigned int dev_idx, unsigned char * data, unsigned int size)
 {
     NetPacketHeader reply_hdr;
-
+    
     reply_hdr.pkt_magic[0] = 'O';
     reply_hdr.pkt_magic[1] = 'R';
     reply_hdr.pkt_magic[2] = 'G';
@@ -529,14 +357,14 @@ void NetworkClient::SendRequest_RGBController_UpdateLEDs(unsigned int dev_idx, u
     reply_hdr.pkt_id       = NET_PACKET_ID_RGBCONTROLLER_UPDATELEDS;
     reply_hdr.pkt_size     = size;
 
-    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
-    send(client_sock, (char *)data, size, 0);
+    port.tcp_client_write((char *)&reply_hdr, sizeof(NetPacketHeader));
+    port.tcp_client_write((char *)data, size);
 }
 
 void NetworkClient::SendRequest_RGBController_UpdateZoneLEDs(unsigned int dev_idx, unsigned char * data, unsigned int size)
 {
     NetPacketHeader reply_hdr;
-
+    
     reply_hdr.pkt_magic[0] = 'O';
     reply_hdr.pkt_magic[1] = 'R';
     reply_hdr.pkt_magic[2] = 'G';
@@ -546,14 +374,14 @@ void NetworkClient::SendRequest_RGBController_UpdateZoneLEDs(unsigned int dev_id
     reply_hdr.pkt_id       = NET_PACKET_ID_RGBCONTROLLER_UPDATEZONELEDS;
     reply_hdr.pkt_size     = size;
 
-    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
-    send(client_sock, (char *)data, size, MSG_NOSIGNAL);
+    port.tcp_client_write((char *)&reply_hdr, sizeof(NetPacketHeader));
+    port.tcp_client_write((char *)data, size);
 }
 
 void NetworkClient::SendRequest_RGBController_UpdateSingleLED(unsigned int dev_idx, unsigned char * data, unsigned int size)
 {
     NetPacketHeader reply_hdr;
-
+    
     reply_hdr.pkt_magic[0] = 'O';
     reply_hdr.pkt_magic[1] = 'R';
     reply_hdr.pkt_magic[2] = 'G';
@@ -563,14 +391,14 @@ void NetworkClient::SendRequest_RGBController_UpdateSingleLED(unsigned int dev_i
     reply_hdr.pkt_id       = NET_PACKET_ID_RGBCONTROLLER_UPDATESINGLELED;
     reply_hdr.pkt_size     = size;
 
-    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
-    send(client_sock, (char *)data, size, MSG_NOSIGNAL);
+    port.tcp_client_write((char *)&reply_hdr, sizeof(NetPacketHeader));
+    port.tcp_client_write((char *)data, size);
 }
 
 void NetworkClient::SendRequest_RGBController_SetCustomMode(unsigned int dev_idx)
 {
     NetPacketHeader reply_hdr;
-
+    
     reply_hdr.pkt_magic[0] = 'O';
     reply_hdr.pkt_magic[1] = 'R';
     reply_hdr.pkt_magic[2] = 'G';
@@ -580,13 +408,13 @@ void NetworkClient::SendRequest_RGBController_SetCustomMode(unsigned int dev_idx
     reply_hdr.pkt_id       = NET_PACKET_ID_RGBCONTROLLER_SETCUSTOMMODE;
     reply_hdr.pkt_size     = 0;
 
-    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
+    port.tcp_client_write((char *)&reply_hdr, sizeof(NetPacketHeader));
 }
 
 void NetworkClient::SendRequest_RGBController_UpdateMode(unsigned int dev_idx, unsigned char * data, unsigned int size)
 {
     NetPacketHeader reply_hdr;
-
+    
     reply_hdr.pkt_magic[0] = 'O';
     reply_hdr.pkt_magic[1] = 'R';
     reply_hdr.pkt_magic[2] = 'G';
@@ -596,6 +424,6 @@ void NetworkClient::SendRequest_RGBController_UpdateMode(unsigned int dev_idx, u
     reply_hdr.pkt_id       = NET_PACKET_ID_RGBCONTROLLER_UPDATEMODE;
     reply_hdr.pkt_size     = size;
 
-    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
-    send(client_sock, (char *)data, size, MSG_NOSIGNAL);
+    port.tcp_client_write((char *)&reply_hdr, sizeof(NetPacketHeader));
+    port.tcp_client_write((char *)data, size);
 }

NetworkClient.h

@@ -10,27 +10,19 @@
 #include "NetworkProtocol.h"
 #include "net_port.h"
 
-#include <mutex>
 #include <thread>
 
 #pragma once
 
-typedef void (*NetClientCallback)(void *);
-
 class NetworkClient
 {
 public:
     NetworkClient(std::vector<RGBController *>& control);
 
-    void            ClientInfoChanged();
-
-    bool            GetConnected();
     const char *    GetIP();
     unsigned short  GetPort();
     bool            GetOnline();
 
-    void            RegisterClientInfoChangeCallback(NetClientCallback new_callback, void * new_callback_arg);
-
     void            SetIP(const char *new_ip);
     void            SetName(const char *new_name);
     void            SetPort(unsigned short new_port);
@@ -59,30 +51,18 @@ public:
 
     void        SendRequest_RGBController_UpdateMode(unsigned int dev_idx, unsigned char * data, unsigned int size);
 
-    std::vector<RGBController *>  server_controllers;
-
 protected:
     std::vector<RGBController *>& controllers;
-
+    std::vector<RGBController *>  server_controllers;
 
 private:
-    SOCKET          client_sock;
     std::string     client_name;
     net_port        port;
     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;
 
     std::thread *   ConnectionThread;
     std::thread *   ListenThread;
-
-    std::mutex                          ClientInfoChangeMutex;
-    std::vector<NetClientCallback>      ClientInfoChangeCallbacks;
-    std::vector<void *>                 ClientInfoChangeCallbackArgs;
-
-    int recv_select(SOCKET s, char *buf, int len, int flags);
 };

NetworkProtocol.h

@@ -8,12 +8,6 @@
 
 #pragma once
 
-/*-----------------------------------------*\
-| Default OpenRGB SDK port is 6742          |
-| This is "ORGB" on a phone keypad          |
-\*-----------------------------------------*/
-#define OPENRGB_SDK_PORT 6742
-
 typedef struct NetPacketHeader
 {
     char                pkt_magic[4];               /* Magic value "ORGB" identifies beginning of packet    */

NetworkServer.cpp

@@ -28,14 +28,16 @@ const char yes = 1;
 #include <Windows.h>
 #else
 #include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
 #endif
 
-using namespace std::chrono_literals;
-
-
 NetworkServer::NetworkServer(std::vector<RGBController *>& control) : controllers(control)
 {
-    port_num      = OPENRGB_SDK_PORT;
+    port_num      = 1337;
     server_online = false;
 }
 
@@ -71,42 +73,26 @@ unsigned int NetworkServer::GetNumClients()
 
 const char * NetworkServer::GetClientString(unsigned int client_num)
 {
-    const char * result;
-
-    ServerClientsMutex.lock();
-
     if(client_num < ServerClients.size())
     {
-        result = ServerClients[client_num]->client_string.c_str();
+        return ServerClients[client_num]->client_string.c_str();
     }
     else
     {
-        result = "";
+        return "";
     }
-
-    ServerClientsMutex.unlock();
-
-    return result;
 }
 
 const char * NetworkServer::GetClientIP(unsigned int client_num)
 {
-    const char * result;
-
-    ServerClientsMutex.lock();
-
     if(client_num < ServerClients.size())
     {
-        result = ServerClients[client_num]->client_ip;
+        return ServerClients[client_num]->client_ip;
     }
     else
     {
-        result = "";
+        return "";
     }
-
-    ServerClientsMutex.unlock();
-
-    return result;
 }
 
 void NetworkServer::RegisterClientInfoChangeCallback(NetServerCallback new_callback, void * new_callback_arg)
@@ -148,7 +134,6 @@ void NetworkServer::StartServer()
     server_sock = socket(AF_INET, SOCK_STREAM, 0);
     if (server_sock == INVALID_SOCKET)
     {
-        printf("Error: network socket could not be created\n");
         WSACleanup();
         return;
     }
@@ -165,7 +150,6 @@ void NetworkServer::StartServer()
     \*-------------------------------------------------*/
     if (bind(server_sock, (sockaddr*)&myAddress, sizeof(myAddress)) == SOCKET_ERROR)
     {
-        printf("Error: Could not bind network socket \nIs port %hu already being used?\n", GetPort());
         WSACleanup();
         return;
     }
@@ -181,26 +165,30 @@ 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);
-        delete ServerClients[client_idx];
+        ServerClients[client_idx]->client_listen_thread->join();
     }
 
     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       |
@@ -212,7 +200,7 @@ void NetworkServer::ConnectionThreadFunction()
 {
     //This thread handles client connections
 
-    printf("Network connection thread started on port %hu\n", GetPort());
+    printf("Network connection thread started\n");
     while(server_online == true)
     {
         /*-------------------------------------------------*\
@@ -260,15 +248,10 @@ 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,14 +267,13 @@ int NetworkServer::accept_select(int sockfd, struct sockaddr *addr, socklen_t *a
 {
     fd_set              set;
     struct timeval      timeout;
+    timeout.tv_sec      = 5;
+    timeout.tv_usec     = 0;
 
     while(1)
     {
-        timeout.tv_sec          = 5;
-        timeout.tv_usec         = 0;
-
-        FD_ZERO(&set);          /* clear the set */
-        FD_SET(sockfd, &set);   /* add our file descriptor to the set */
+        FD_ZERO(&set);      /* clear the set */
+        FD_SET(sockfd, &set);    /* add our file descriptor to the set */
 
         int rv = select(sockfd + 1, &set, NULL, NULL, &timeout);
 
@@ -315,12 +297,11 @@ int NetworkServer::recv_select(SOCKET s, char *buf, int len, int flags)
 {
     fd_set              set;
     struct timeval      timeout;
+    timeout.tv_sec      = 5;
+    timeout.tv_usec     = 0;
 
     while(1)
     {
-        timeout.tv_sec      = 5;
-        timeout.tv_usec     = 0;
-
         FD_ZERO(&set);      /* clear the set */
         FD_SET(s, &set);    /* add our file descriptor to the set */
 
@@ -357,7 +338,7 @@ void NetworkServer::ListenThreadFunction(NetworkClientInfo * client_info)
         //Read first byte of magic
         bytes_read = recv_select(client_sock, &header.pkt_magic[0], 1, 0);
 
-        if(bytes_read <= 0)
+        if(bytes_read == 0)
         {
             goto listen_done;
         }
@@ -371,7 +352,7 @@ void NetworkServer::ListenThreadFunction(NetworkClientInfo * client_info)
         //Read second byte of magic
         bytes_read = recv_select(client_sock, &header.pkt_magic[1], 1, 0);
 
-        if(bytes_read <= 0)
+        if(bytes_read == 0)
         {
             goto listen_done;
         }
@@ -385,7 +366,7 @@ void NetworkServer::ListenThreadFunction(NetworkClientInfo * client_info)
         //Read third byte of magic
         bytes_read = recv_select(client_sock, &header.pkt_magic[2], 1, 0);
 
-        if(bytes_read <= 0)
+        if(bytes_read == 0)
         {
             goto listen_done;
         }
@@ -399,7 +380,7 @@ void NetworkServer::ListenThreadFunction(NetworkClientInfo * client_info)
         //Read fourth byte of magic
         bytes_read = recv_select(client_sock, &header.pkt_magic[3], 1, 0);
 
-        if(bytes_read <= 0)
+        if(bytes_read == 0)
         {
             goto listen_done;
         }
@@ -420,7 +401,7 @@ void NetworkServer::ListenThreadFunction(NetworkClientInfo * client_info)
 
             bytes_read += tmp_bytes_read;
 
-            if(tmp_bytes_read <= 0)
+            if(tmp_bytes_read == 0)
             {
                 goto listen_done;
             }
@@ -442,7 +423,7 @@ void NetworkServer::ListenThreadFunction(NetworkClientInfo * client_info)
 
                 tmp_bytes_read = recv_select(client_sock, &data[bytes_read], header.pkt_size - bytes_read, 0);
 
-                if(tmp_bytes_read <= 0)
+                if(tmp_bytes_read == 0)
                 {
                     goto listen_done;
                 }
@@ -553,21 +534,15 @@ 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       |
     \*-------------------------------------------------*/
@@ -576,7 +551,6 @@ 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)
@@ -585,7 +559,6 @@ void NetworkServer::ProcessRequest_ClientString(SOCKET client_sock, unsigned int
             break;
         }
     }
-    ServerClientsMutex.unlock();
 
     /*-------------------------------------------------*\
     | Client info has changed, call the callbacks       |

NetworkServer.h

@@ -12,7 +12,6 @@
 
 #include <mutex>
 #include <thread>
-#include <chrono>
 
 #pragma once
 
@@ -59,7 +58,6 @@ protected:
 
     std::vector<RGBController *>&       controllers;
 
-    std::mutex                          ServerClientsMutex;
     std::vector<NetworkClientInfo *>    ServerClients;
     std::thread *                       ConnectionThread;
 

OpenRGB.cpp

@@ -18,7 +18,6 @@
 #include "i2c_smbus_i801.h"
 #include "i2c_smbus_nct6775.h"
 #include "i2c_smbus_nvapi.h"
-#include "i2c_smbus_amdadl.h"
 #include "super_io.h"
 #include "wmi.h"
 #else /* WIN32 */
@@ -106,11 +105,6 @@ 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();
 
@@ -122,51 +116,10 @@ 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() */
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAMDADLI2CBusses (Windows)                                                        *
-*                                                                                          *
-*       Detects available AMD ADL I2C adapters and enumerates                              *
-*       i2c_smbus_interface objects for them.  Only enumerates Bus Nr 1                    *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectADLI2C()
-{
-    int adl_status;
-    int gpu_count = 0;
-    ADL_CONTEXT_HANDLE gpu_handle;
-
-    i2c_smbus_amdadl * adl_bus = new i2c_smbus_amdadl(gpu_handle);
-
-    adl_status = adl_bus->ADL_Initialize();
-
-    if(0 != adl_status)
-    {
-        printf_s("ADL Status %d \n", adl_status);
-    }
-    else
-    {
-        sprintf(adl_bus->device_name, "AMD ADL I2C on GPU %d", gpu_count);
-        busses.push_back(adl_bus);
-    }
-}   /* DetectAMDADLI2CBusses() */
-
 /******************************************************************************************\
 *                                                                                          *
 *   DetectI2CBusses (Windows)                                                              *
@@ -252,9 +205,6 @@ void DetectI2CBusses()
     // Detect NVidia NvAPI I2C adapters
     DetectNvAPII2CBusses();
 
-    // Detect AMD ADL I2C adadpters
-    DetectADLI2C();
-
 }   /* DetectI2CBusses() */
 
 #else /* WIN32 */
@@ -276,11 +226,6 @@ 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/");
@@ -309,77 +254,9 @@ void DetectI2CBusses()
                     memset(device_string, 0x00, sizeof(device_string));
                     read(test_fd, device_string, sizeof(device_string));
                     device_string[strlen(device_string) - 1] = 0x00;
-
+                    
                     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);
@@ -393,13 +270,6 @@ 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);
                 }
             }
@@ -421,15 +291,12 @@ void DetectPatriotViperControllers(std::vector<i2c_smbus_interface*> &busses, st
 void DetectPolychromeControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
 void DetectRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
 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 DetectMSIMysticLightControllers(std::vector<RGBController*> &rgb_controllers);
 void DetectMSIRGBControllers(std::vector<RGBController*> &rgb_controllers);
-void DetectAuraUSBControllers(std::vector<RGBController*> &rgb_controllers);
+void DetectAuraAddressableControllers(std::vector<RGBController*> &rgb_controllers);
 void DetectAuraCoreControllers(std::vector<RGBController*> &rgb_controllers);
 void DetectLEDStripControllers(std::vector<RGBController*> &rgb_controllers);
-void DetectNZXTHue2Controllers(std::vector<RGBController*> &rgb_controllers);
+void DetectHue2Controllers(std::vector<RGBController*> &rgb_controllers);
 void DetectHuePlusControllers(std::vector<RGBController*> &rgb_controllers);
 void DetectOpenRazerControllers(std::vector<RGBController*> &rgb_controllers);
 void DetectE131Controllers(std::vector<RGBController*> &rgb_controllers);
@@ -444,11 +311,7 @@ void DetectHyperXKeyboardControllers(std::vector<RGBController*>& rgb_controller
 void DetectThermaltakeRiingControllers(std::vector<RGBController*>& rgb_controllers);
 void DetectRGBFusion2USBControllers(std::vector<RGBController*> &rgb_controllers);
 void DetectRedragonControllers(std::vector<RGBController*>& rgb_controllers);
-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);
 
 /******************************************************************************************\
 *                                                                                          *
@@ -471,20 +334,15 @@ void DetectRGBControllers(void)
     DetectPatriotViperControllers(busses, rgb_controllers);
     DetectPolychromeControllers(busses, rgb_controllers);
     DetectRGBFusionGPUControllers(busses, rgb_controllers);
-    DetectMSIGPUControllers(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);
     DetectMSIRGBControllers(rgb_controllers);
 
-    DetectAuraUSBControllers(rgb_controllers);
+    DetectAuraAddressableControllers(rgb_controllers);
     DetectAuraCoreControllers(rgb_controllers);
     DetectLEDStripControllers(rgb_controllers);
-    DetectNZXTHue2Controllers(rgb_controllers);
+    DetectHue2Controllers(rgb_controllers);
     DetectHuePlusControllers(rgb_controllers);
 
     DetectAMDWraithPrismControllers(rgb_controllers);
@@ -497,11 +355,7 @@ void DetectRGBControllers(void)
     DetectThermaltakeRiingControllers(rgb_controllers);
     DetectRGBFusion2USBControllers(rgb_controllers);
     DetectRedragonControllers(rgb_controllers);
-    DetectLogitechControllers(rgb_controllers);
     DetectNZXTKrakenControllers(rgb_controllers);
-    DetectSteelSeriesControllers(rgb_controllers);
-    DetectGloriousModelOControllers(rgb_controllers);
-    DetectDuckyKeyboardControllers(rgb_controllers);
 
     DetectE131Controllers(rgb_controllers);
 

OpenRGB.pro

@@ -1,28 +1,11 @@
-#-----------------------------------------------------------------------#
-# OpenRGB 0.x QMake Project                                             #
-#                                                                       #
-#   Adam Honse (CalcProgrammer1)                        5/25/2020       #
-#-----------------------------------------------------------------------#
-
-#-----------------------------------------------------------------------#
-# Qt Configuration                                                      #
-#-----------------------------------------------------------------------#
-QT +=                                                                   \
-    core                                                                \
-    gui                                                                 \
+QT       += core gui
 
 greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 
-#-----------------------------------------------------------------------#
-# Application Configuration                                             #
-#-----------------------------------------------------------------------#
-VERSION     = 0.21
-TARGET      = OpenRGB
-TEMPLATE    = app
+TARGET = OpenRGB
+TEMPLATE = app
 
-#-----------------------------------------------------------------------#
-# Automatically generated build information                             #
-#-----------------------------------------------------------------------#
+VERSION         = 0.11
 win32:BUILDDATE = $$system(date /t)
 unix:BUILDDATE  = $$system(date -R)
 GIT_COMMIT_ID   = $$system(git --git-dir $$_PRO_FILE_PWD_/.git --work-tree $$_PRO_FILE_PWD_ rev-parse HEAD)
@@ -36,11 +19,11 @@ DEFINES +=                                                              \
     GIT_COMMIT_DATE=\\"\"\"$$GIT_COMMIT_DATE\\"\"\"                     \
     GIT_BRANCH=\\"\"\"$$GIT_BRANCH\\"\"\"
 
-#-----------------------------------------------------------------------#
-# OpenRGB Common                                                        #
-#-----------------------------------------------------------------------#
+RC_ICONS = qt/OpenRGB.ico
+
 INCLUDEPATH +=                                                          \
     dependencies/ColorWheel                                             \
+    dependencies/hidapi                                                 \
     dependencies/libe131/src/                                           \
     i2c_smbus/                                                          \
     i2c_tools/                                                          \
@@ -48,7 +31,7 @@ INCLUDEPATH +=                                                          \
     serial_port/                                                        \
     super_io/                                                           \
     Controllers/AMDWraithPrismController/                               \
-    Controllers/AuraUSBController/                                      \
+    Controllers/AuraAddressableController/                              \
     Controllers/AuraCoreController/                                     \
     Controllers/AuraGPUController/                                      \
     Controllers/AuraSMBusController/                                    \
@@ -58,148 +41,29 @@ INCLUDEPATH +=                                                          \
     Controllers/CorsairVengeanceController/                             \
     Controllers/CorsairVengeanceProController/                          \
     Controllers/CrucialController/                                      \
-    Controllers/DuckyKeyboardController/                                \
-    Controllers/GloriousModelOController/                               \
+    Controllers/Hue2Controller/                                         \
     Controllers/HuePlusController/                                      \
     Controllers/HyperXDRAMController/                                   \
     Controllers/HyperXKeyboardController/                               \
     Controllers/LEDStripController/                                     \
-    Controllers/LogitechController/                                     \
     Controllers/MSI3ZoneController/                                     \
-    Controllers/MSIGPUController/                                       \
     Controllers/MSIMysticLightController/                               \
     Controllers/MSIRGBController/                                       \
-    Controllers/NZXTHue2Controller/                                     \
     Controllers/NZXTKrakenController/                                   \
     Controllers/PatriotViperController/                                 \
     Controllers/PolychromeController/                                   \
     Controllers/PoseidonZRGBController/                                 \
     Controllers/RedragonController/                                     \
     Controllers/RGBFusionController/                                    \
-    Controllers/RGBFusion2DRAMController/                               \
-    Controllers/RGBFusion2SMBusController/                              \
     Controllers/RGBFusion2USBController/                                \
     Controllers/RGBFusionGPUController/                                 \
-    Controllers/SteelSeriesController/                                  \
     Controllers/ThermaltakeRiingController/                             \
     RGBController/                                                      \
     qt/
 
-HEADERS +=                                                              \
-    dependencies/ColorWheel/ColorWheel.h                                \
-    NetworkClient.h                                                     \
-    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/OpenRGBDialog2.h                                                 \
-    qt/OpenRGBProfileSaveDialog.h                                       \
-    qt/OpenRGBServerInfoPage.h                                          \
-    qt/OpenRGBSoftwareInfoPage.h                                        \
-    qt/OpenRGBSystemInfoPage.h                                          \
-    qt/OpenRGBZoneResizeDialog.h                                        \
-    serial_port/find_usb_serial_port.h                                  \
-    serial_port/serial_port.h                                           \
-    super_io/super_io.h                                                 \
-    Controllers/AMDWraithPrismController/AMDWraithPrismController.h     \
-    Controllers/AuraUSBController/AuraUSBController.h                   \
-    Controllers/AuraUSBController/AuraAddressableController.h           \
-    Controllers/AuraUSBController/AuraMainboardController.h             \
-    Controllers/AuraCoreController/AuraCoreController.h                 \
-    Controllers/AuraGPUController/AuraGPUController.h                   \
-    Controllers/AuraSMBusController/AuraSMBusController.h               \
-    Controllers/CoolerMasterController/CMMP750Controller.h              \
-    Controllers/CorsairLightingNodeController/CorsairLightingNodeController.h \
-    Controllers/CorsairPeripheralController/CorsairPeripheralController.h \
-    Controllers/CorsairVengeanceController/CorsairVengeanceController.h \
-    Controllers/CorsairVengeanceProController/CorsairVengeanceProController.h \
-    Controllers/CrucialController/CrucialController.h                   \
-    Controllers/DuckyKeyboardController/DuckyKeyboardController.h       \
-    Controllers/GloriousModelOController/GloriousModelOController.h     \
-    Controllers/HuePlusController/HuePlusController.h                   \
-    Controllers/HyperXDRAMController/HyperXDRAMController.h             \
-    Controllers/HyperXKeyboardController/HyperXAlloyOriginsController.h \
-    Controllers/HyperXKeyboardController/HyperXKeyboardController.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                 \
-    Controllers/NZXTKrakenController/NZXTKrakenController.h             \
-    Controllers/PatriotViperController/PatriotViperController.h         \
-    Controllers/PolychromeController/PolychromeController.h             \
-    Controllers/PoseidonZRGBController/PoseidonZRGBController.h         \
-    Controllers/RGBFusionController/RGBFusionController.h               \
-    Controllers/RGBFusion2DRAMController/RGBFusion2DRAMController.h     \
-    Controllers/RGBFusion2SMBusController/RGBFusion2SMBusController.h   \
-    Controllers/RGBFusion2USBController/RGBFusion2USBController.h       \
-    Controllers/RGBFusionGPUController/RGBFusionGPUController.h         \
-    Controllers/RedragonController/RedragonK556Controller.h             \
-    Controllers/RedragonController/RedragonM711Controller.h             \
-    Controllers/SteelSeriesController/SteelSeriesRivalController.h      \
-    Controllers/SteelSeriesController/SteelSeriesSiberiaController.h    \
-    Controllers/SteelSeriesController/SteelSeriesApexController.h       \
-    Controllers/ThermaltakeRiingController/ThermaltakeRiingController.h \
-    RGBController/RGBController.h                                       \
-    RGBController/RGBController_AMDWraithPrism.h                        \
-    RGBController/RGBController_AuraUSB.h                               \
-    RGBController/RGBController_AuraCore.h                              \
-    RGBController/RGBController_AuraGPU.h                               \
-    RGBController/RGBController_AuraSMBus.h                             \
-    RGBController/RGBController_CMMP750Controller.h                     \
-    RGBController/RGBController_CorsairLightingNode.h                   \
-    RGBController/RGBController_CorsairPeripheral.h                     \
-    RGBController/RGBController_CorsairVengeance.h                      \
-    RGBController/RGBController_CorsairVengeancePro.h                   \
-    RGBController/RGBController_Crucial.h                               \
-    RGBController/RGBController_DuckyKeyboard.h                         \
-    RGBController/RGBController_Dummy.h                                 \
-    RGBController/RGBController_E131.h                                  \
-    RGBController/RGBController_GloriousModelO.h                        \
-    RGBController/RGBController_HuePlus.h                               \
-    RGBController/RGBController_HyperXAlloyOrigins.h                    \
-    RGBController/RGBController_HyperXDRAM.h                            \
-    RGBController/RGBController_HyperXKeyboard.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                               \
-    RGBController/RGBController_NZXTHue2.h                              \
-    RGBController/RGBController_NZXTKraken.h                            \
-    RGBController/RGBController_PatriotViper.h                          \
-    RGBController/RGBController_Polychrome.h                            \
-    RGBController/RGBController_PoseidonZRGB.h                          \
-    RGBController/RGBController_RedragonK556.h                          \
-    RGBController/RGBController_RedragonM711.h                          \
-    RGBController/RGBController_RGBFusion.h                             \
-    RGBController/RGBController_RGBFusion2DRAM.h                        \
-    RGBController/RGBController_RGBFusion2SMBus.h                       \
-    RGBController/RGBController_RGBFusion2USB.h                         \
-    RGBController/RGBController_RGBFusionGPU.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/hidapi/hidapi.c                                        \
     dependencies/libe131/src/e131.c                                     \
     main.cpp                                                            \
     cli.cpp                                                             \
@@ -207,7 +71,6 @@ SOURCES +=                                                              \
     NetworkClient.cpp                                                   \
     NetworkServer.cpp                                                   \
     ProfileManager.cpp                                                  \
-    qt/OpenRGBClientInfoPage.cpp                                        \
     qt/OpenRGBDeviceInfoPage.cpp                                        \
     qt/OpenRGBDevicePage.cpp                                            \
     qt/OpenRGBDialog.cpp                                                \
@@ -225,10 +88,8 @@ SOURCES +=                                                              \
     super_io/super_io.cpp                                               \
     Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp   \
     Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp \
-    Controllers/AuraUSBController/AuraUSBController.cpp                 \
-    Controllers/AuraUSBController/AuraAddressableController.cpp         \
-    Controllers/AuraUSBController/AuraMainboardController.cpp           \
-    Controllers/AuraUSBController/AuraUSBControllerDetect.cpp           \
+    Controllers/AuraAddressableController/AuraAddressableController.cpp \
+    Controllers/AuraAddressableController/AuraAddressableControllerDetect.cpp \
     Controllers/AuraCoreController/AuraCoreController.cpp               \
     Controllers/AuraCoreController/AuraCoreControllerDetect.cpp         \
     Controllers/AuraGPUController/AuraGPUController.cpp                 \
@@ -247,33 +108,22 @@ SOURCES +=                                                              \
     Controllers/CorsairVengeanceProController/CorsairVengeanceProControllerDetect.cpp \
     Controllers/CrucialController/CrucialController.cpp                 \
     Controllers/CrucialController/CrucialControllerDetect.cpp           \
-    Controllers/DuckyKeyboardController/DuckyKeyboardController.cpp     \
-    Controllers/DuckyKeyboardController/DuckyKeyboardControllerDetect.cpp \
-    Controllers/GloriousModelOController/GloriousModelOController.cpp   \
-    Controllers/GloriousModelOController/GloriousModelOControllerDetect.cpp \
+    Controllers/Hue2Controller/Hue2Controller.cpp                       \
+    Controllers/Hue2Controller/Hue2ControllerDetect.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/LEDStripController/LEDStripController.cpp               \
     Controllers/LEDStripController/LEDStripControllerDetect.cpp         \
-    Controllers/LogitechController/LogitechControllerDetect.cpp         \
-    Controllers/LogitechController/LogitechG203Controller.cpp           \
-    Controllers/LogitechController/LogitechG403Controller.cpp           \
-    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                   \
     Controllers/MSIRGBController/MSIRGBControllerDetect.cpp             \
-    Controllers/NZXTHue2Controller/NZXTHue2Controller.cpp               \
-    Controllers/NZXTHue2Controller/NZXTHue2ControllerDetect.cpp         \
     Controllers/NZXTKrakenController/NZXTKrakenController.cpp           \
     Controllers/NZXTKrakenController/NZXTKrakenControllerDetect.cpp     \
     Controllers/PatriotViperController/PatriotViperController.cpp       \
@@ -284,10 +134,6 @@ SOURCES +=                                                              \
     Controllers/PoseidonZRGBController/PoseidonZRGBControllerDetect.cpp \
     Controllers/RGBFusionController/RGBFusionController.cpp             \
     Controllers/RGBFusionController/RGBFusionControllerDetect.cpp       \
-    Controllers/RGBFusion2DRAMController/RGBFusion2DRAMController.cpp   \
-    Controllers/RGBFusion2DRAMController/RGBFusion2DRAMControllerDetect.cpp \
-    Controllers/RGBFusion2SMBusController/RGBFusion2SMBusController.cpp \
-    Controllers/RGBFusion2SMBusController/RGBFusion2SMBusControllerDetect.cpp \
     Controllers/RGBFusion2USBController/RGBFusion2USBController.cpp     \
     Controllers/RGBFusion2USBController/RGBFusion2USBControllerDetect.cpp \
     Controllers/RGBFusionGPUController/RGBFusionGPUController.cpp       \
@@ -295,16 +141,12 @@ SOURCES +=                                                              \
     Controllers/RedragonController/RedragonK556Controller.cpp           \
     Controllers/RedragonController/RedragonM711Controller.cpp           \
     Controllers/RedragonController/RedragonControllerDetect.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 \
     RGBController/RGBController.cpp                                     \
     RGBController/E131ControllerDetect.cpp                              \
     RGBController/RGBController_AMDWraithPrism.cpp                      \
-    RGBController/RGBController_AuraUSB.cpp                             \
+    RGBController/RGBController_AuraAddressable.cpp                     \
     RGBController/RGBController_AuraCore.cpp                            \
     RGBController/RGBController_AuraGPU.cpp                             \
     RGBController/RGBController_AuraSMBus.cpp                           \
@@ -314,24 +156,17 @@ SOURCES +=                                                              \
     RGBController/RGBController_CorsairVengeance.cpp                    \
     RGBController/RGBController_CorsairVengeancePro.cpp                 \
     RGBController/RGBController_Crucial.cpp                             \
-    RGBController/RGBController_DuckyKeyboard.cpp                       \
     RGBController/RGBController_Dummy.cpp                               \
-    RGBController/RGBController_GloriousModelO.cpp                      \
+    RGBController/RGBController_Hue2.cpp                                \
     RGBController/RGBController_HuePlus.cpp                             \
-    RGBController/RGBController_HyperXAlloyOrigins.cpp                  \
     RGBController/RGBController_HyperXDRAM.cpp                          \
     RGBController/RGBController_HyperXKeyboard.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                             \
-    RGBController/RGBController_NZXTHue2.cpp                            \
     RGBController/RGBController_NZXTKraken.cpp                          \
     RGBController/RGBController_PatriotViper.cpp                        \
     RGBController/RGBController_Polychrome.cpp                          \
@@ -339,20 +174,96 @@ SOURCES +=                                                              \
     RGBController/RGBController_RedragonK556.cpp                        \
     RGBController/RGBController_RedragonM711.cpp                        \
     RGBController/RGBController_RGBFusion.cpp                           \
-    RGBController/RGBController_RGBFusion2DRAM.cpp                      \
-    RGBController/RGBController_RGBFusion2SMBus.cpp                     \
     RGBController/RGBController_RGBFusion2USB.cpp                       \
     RGBController/RGBController_RGBFusionGPU.cpp                        \
-    RGBController/RGBController_SteelSeriesRival.cpp                    \
-    RGBController/RGBController_SteelSeriesSiberia.cpp                  \
-    RGBController/RGBController_SteelSeriesApex.cpp                     \
     RGBController/RGBController_ThermaltakeRiing.cpp                    \
 
-RESOURCES +=                                                            \
+HEADERS +=                                                              \
+    dependencies/ColorWheel/ColorWheel.h                                \
+    NetworkClient.h                                                     \
+    NetworkProtocol.h                                                   \
+    NetworkServer.h                                                     \
+    ProfileManager.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/OpenRGBDialog2.h                                                 \
+    qt/OpenRGBProfileSaveDialog.h                                       \
+    qt/OpenRGBServerInfoPage.h                                          \
+    qt/OpenRGBSoftwareInfoPage.h                                        \
+    qt/OpenRGBSystemInfoPage.h                                          \
+    qt/OpenRGBZoneResizeDialog.h                                        \
+    serial_port/find_usb_serial_port.h                                  \
+    serial_port/serial_port.h                                           \
+    super_io/super_io.h                                                 \
+    Controllers/AMDWraithPrismController/AMDWraithPrismController.h     \
+    Controllers/AuraAddressableController/AuraAddressableController.h   \
+    Controllers/AuraCoreController/AuraCoreController.h                 \
+    Controllers/AuraGPUController/AuraGPUController.h                   \
+    Controllers/AuraSMBusController/AuraSMBusController.h               \
+    Controllers/CoolerMasterController/CMMP750Controller.h              \
+    Controllers/CorsairLightingNodeController/CorsairLightingNodeController.h \
+    Controllers/CorsairPeripheralController/CorsairPeripheralController.h \
+    Controllers/CorsairVengeanceController/CorsairVengeanceController.h \
+    Controllers/CorsairVengeanceProController/CorsairVengeanceProController.h \
+    Controllers/CrucialController/CrucialController.h                   \
+    Controllers/Hue2Controller/Hue2Controller.h                         \
+    Controllers/HuePlusController/HuePlusController.h                   \
+    Controllers/HyperXDRAMController/HyperXDRAMController.h             \
+    Controllers/HyperXKeyboardController/HyperXKeyboardController.h     \
+    Controllers/LEDStripController/LEDStripController.h                 \
+    Controllers/MSI3ZoneController/MSI3ZoneController.h                 \
+    Controllers/MSIMysticLightController/MSIMysticLightController.h     \
+    Controllers/MSIRGBController/MSIRGBController.h                     \
+    Controllers/PatriotViperController/PatriotViperController.h         \
+    Controllers/PolychromeController/PolychromeController.h             \
+    Controllers/PoseidonZRGBController/PoseidonZRGBController.h         \
+    Controllers/RGBFusionController/RGBFusionController.h               \
+    Controllers/RGBFusion2USBController/RGBFusion2USBController.h       \
+    Controllers/RGBFusionGPUController/RGBFusionGPUController.h         \
+    Controllers/RedragonController/RedragonK556Controller.h             \
+    Controllers/RedragonController/RedragonM711Controller.h             \
+    Controllers/ThermaltakeRiingController/ThermaltakeRiingController.h \
+    RGBController/RGBController.h                                       \
+    RGBController/RGBController_AMDWraithPrism.h                        \
+    RGBController/RGBController_AuraAddressable.h                       \
+    RGBController/RGBController_AuraCore.h                              \
+    RGBController/RGBController_AuraGPU.h                               \
+    RGBController/RGBController_AuraSMBus.h                             \
+    RGBController/RGBController_CMMP750Controller.h                     \
+    RGBController/RGBController_CorsairLightingNode.h                   \
+    RGBController/RGBController_CorsairPeripheral.h                     \
+    RGBController/RGBController_CorsairVengeance.h                      \
+    RGBController/RGBController_CorsairVengeancePro.h                   \
+    RGBController/RGBController_Crucial.h                               \
+    RGBController/RGBController_Dummy.h                                 \
+    RGBController/RGBController_E131.h                                  \
+    RGBController/RGBController_Hue2.h                                  \
+    RGBController/RGBController_HuePlus.h                               \
+    RGBController/RGBController_HyperXDRAM.h                            \
+    RGBController/RGBController_HyperXKeyboard.h                        \
+    RGBController/RGBController_LEDStrip.h                              \
+    RGBController/RGBController_MSI3Zone.h                              \
+    RGBController/RGBController_MSIMysticLight.h                        \
+    RGBController/RGBController_MSIRGB.h                                \
+    RGBController/RGBController_Network.h                               \
+    RGBController/RGBController_PatriotViper.h                          \
+    RGBController/RGBController_Polychrome.h                            \
+    RGBController/RGBController_PoseidonZRGB.h                          \
+    RGBController/RGBController_RedragonK556.h                          \
+    RGBController/RGBController_RedragonM711.h                          \
+    RGBController/RGBController_RGBFusion.h                             \
+    RGBController/RGBController_RGBFusion2USB.h                         \
+    RGBController/RGBController_RGBFusionGPU.h                          \
+    RGBController/RGBController_ThermaltakeRiing.h                      \
+
+RESOURCES += \
     qt/resources.qrc
 
-FORMS +=                                                                \
-    qt/OpenRGBClientInfoPage.ui                                         \
+FORMS += \
     qt/OpenRGBDeviceInfoPage.ui                                         \
     qt/OpenRGBDevicePage.ui                                             \
     qt/OpenRGBDialog.ui                                                 \
@@ -363,12 +274,10 @@ FORMS +=                                                                \
     qt/OpenRGBSystemInfoPage.ui                                         \
     qt/OpenRGBZoneResizeDialog.ui                                       \
 
-#-----------------------------------------------------------------------#
-# Windows-specific Configuration                                        #
-#-----------------------------------------------------------------------#
+#-----------------------------------------------
+# Windows specific project configuration
+#-----------------------------------------------
 win32:INCLUDEPATH +=                                                    \
-    dependencies/display-library/include                                \
-    dependencies/hidapi                                                 \
     dependencies/inpout32_1501/Win32/                                   \
     dependencies/libusb-1.0.22/include                                  \
     dependencies/NVFC                                                   \
@@ -376,9 +285,7 @@ win32:INCLUDEPATH +=                                                    \
     wmi/                                                                \
 
 win32:SOURCES +=                                                        \
-#   dependencies/hidapi/hidapi.c                                        \
     dependencies/NVFC/nvapi.cpp                                         \
-    i2c_smbus/i2c_smbus_amdadl.cpp                                      \
     i2c_smbus/i2c_smbus_i801.cpp                                        \
     i2c_smbus/i2c_smbus_nct6775.cpp                                     \
     i2c_smbus/i2c_smbus_nvapi.cpp                                       \
@@ -389,9 +296,6 @@ win32:SOURCES +=                                                        \
     RGBController/RGBController_OpenRazerWindows.cpp                    \
 
 win32:HEADERS +=                                                        \
-    dependencies/display-library/include/adl_defines.h                  \
-    dependencies/display-library/include/adl_sdk.h                      \
-    dependencies/display-library/include/adl_structures.h               \
     dependencies/inpout32_1501/Win32/inpout32.h                         \
     dependencies/NVFC/nvapi.h                                           \
     i2c_smbus/i2c_smbus_i801.h                                          \
@@ -406,7 +310,6 @@ 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) {
@@ -414,48 +317,21 @@ 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:RC_ICONS +=                                                       \
-    qt/OpenRGB.ico
-
-#-------------------------------------------------------------------#
-# Windows GitLab CI Configuration                                   #
-#-------------------------------------------------------------------#
-win32:CONFIG(debug, debug|release) {
-    win32:DESTDIR = debug
-}
-
-win32:CONFIG(release, debug|release) {
-    win32:DESTDIR = release
-}
-
-win32:OBJECTS_DIR = _intermediate_$$DESTDIR/.obj
-win32:MOC_DIR     = _intermediate_$$DESTDIR/.moc
-win32:RCC_DIR     = _intermediate_$$DESTDIR/.qrc
-win32:UI_DIR      = _intermediate_$$DESTDIR/.ui
-
-#-------------------------------------------------------------------#
-# Copy dependencies to output directory                             #
-#-------------------------------------------------------------------#
+    WIN32_LEAN_AND_MEAN
 
+# Copy OpenRazer.dll to output directory
 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)
+    copydata.commands = $(COPY_FILE) \"$$shell_path($$PWD\\dependencies\\openrazer-win32\\OpenRazer64.dll)\" \"$$shell_path($$OUT_PWD)\"
     first.depends = $(first) copydata
     export(first.depends)
     export(copydata.commands)
@@ -463,79 +339,29 @@ win32:contains(QMAKE_TARGET.arch, x86_64) {
 }
 
 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)
-
+    copydata.commands = $(COPY_FILE) \"$$shell_path($$PWD\\dependencies\\openrazer-win32\\OpenRazer.dll)\" \"$$shell_path($$OUT_PWD)\"
     first.depends = $(first) copydata
     export(first.depends)
     export(copydata.commands)
     QMAKE_EXTRA_TARGETS += first copydata
 }
 
-#-----------------------------------------------------------------------#
-# Linux-specific Configuration                                          #
-#-----------------------------------------------------------------------#
-unix:!macx {
-    INCLUDEPATH +=                                                      \
+#-----------------------------------------------
+# Linux specific project configuration
+#-----------------------------------------------
+unix:INCLUDEPATH +=                                                     \
 
-    HEADERS +=                                                          \
+unix:HEADERS +=                                                         \
     i2c_smbus/i2c_smbus_linux.h                                         \
     RGBController/RGBController_Faustus.h                               \
 
-    LIBS +=                                                             \
+unix:LIBS +=                                                            \
     -lusb-1.0                                                           \
     -lstdc++fs                                                          \
 
-    #-------------------------------------------------------------------#
-    # Determine which hidapi to use based on availability               #
-    #   Prefer hidraw backend, then libusb                              #
-    #-------------------------------------------------------------------#
-    packagesExist(hidapi-hidraw) {
-        LIBS += -lhidapi-hidraw
-    } else {
-        packagesExist(hidapi-libusb) {
-            LIBS += -lhidapi-libusb
-        } else {
-            LIBS += -lhidapi
-        }
-    }
-
-    SOURCES +=                                                          \
+unix:SOURCES +=                                                         \
     i2c_smbus/i2c_smbus_linux.cpp                                       \
     serial_port/find_usb_serial_port_linux.cpp                          \
     RGBController/OpenRazerDetect.cpp                                   \
     RGBController/RGBController_Faustus.cpp                             \
     RGBController/RGBController_OpenRazer.cpp                           \
-
-    #-------------------------------------------------------------------#
-    # Set up install paths                                              #
-    # These install paths are used for AppImage and .deb packaging      #
-    #-------------------------------------------------------------------#
-    isEmpty(PREFIX) {
-        PREFIX = /usr
-    }
-
-    target.path=$$PREFIX/bin/
-    desktop.path=$$PREFIX/share/applications/
-    desktop.files+=qt/OpenRGB.desktop
-    pixmap.path=$$PREFIX/share/pixmaps/
-    pixmap.files+=qt/OpenRGB.png
-    INSTALLS += target desktop pixmap
-}
-
-#-----------------------------------------------------------------------#
-# MacOS-specific Configuration                                          #
-#-----------------------------------------------------------------------#
-QMAKE_MACOSX_DEPLOYMENT_TARGET = 10.15
-
-macx:ICON = qt/OpenRGB.icns
-
-unix:macx {
-    INCLUDEPATH +=                                                      \
-    /usr/local/include                                                  \
-
-    LIBS +=                                                             \
-    -L/usr/local/lib -lusb-1.0 -lhidapi                                 \
-}

README.md

@@ -1,17 +1,7 @@
 ## ![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.
-
-## 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
+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.
 
 ## Supported Devices
 
@@ -23,16 +13,18 @@ This project provides a tool to probe the SMBus.  This is a potentially dangerou
 
 As of now, only Gigabyte RGB Fusion 2.0 boards have been reported to have issues.
 
-![OpenRGB_0.11](https://gitlab.com/CalcProgrammer1/OpenRGB/-/wikis/uploads/0ef8eb3936fe715217e7e3430c0aae18/OpenRGB_new_icons.PNG)
+![OpenRGB_0.11](https://gitlab.com/CalcProgrammer1/OpenRGB/-/wikis/uploads/2a913ece50cfa1ab2210f63e4846df4f/OpenRGB_0.11.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
@@ -40,29 +32,35 @@ As of now, only Gigabyte RGB Fusion 2.0 boards have been reported to have issues
   *  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
+      - Select the last interface of your device
       - With "WinUSB" selected, click Install
 
 ## 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
+
+  *  You can build the project using Qt Creator or on the command line.  The commands listed here work for Debian-based distros.
+
+      1.  sudo apt install build-essential qtcreator qt5-default libusb-1.0-0-dev
       2.  git clone https://gitlab.com/CalcProgrammer1/OpenRGB
       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,10 +68,13 @@ 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.
@@ -82,51 +83,55 @@ 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/
+
+  *  Udev rules can be found here:
+      - https://drive.google.com/drive/folders/1tWVbeOLiLns_IhgyNDWqSK3ZKtP-6oYM?usp=sharing
+      - Copy the .rules files to /etc/udev/rules.d/
       - Reload rules with `sudo udevadm control --reload-rules && sudo udevadm trigger`
-
-## OpenRGB SDK
-
-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
+      - Add your user to the `plugdev` group:  `sudo adduser username plugdev`
 
 ## 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
 
 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
+
+  * msi-keyboard: https://github.com/bparker06/msi-keyboard

RGBController/OpenRazerDevices.h

@@ -39,7 +39,7 @@ static const razer_zone blackwidow_2019_zone =
 
 static const razer_device blackwidow_2019_device =
 {
-    "Razer BlackWidow 2019",
+    "Razer Blackwidow 2019",
     DEVICE_TYPE_KEYBOARD,
     true,
     6,
@@ -167,7 +167,7 @@ static const razer_zone blackwidow_elite_zone =
 
 static const razer_device blackwidow_elite_device =
 {
-    "Razer BlackWidow Elite",
+    "Razer Blackwidow Elite",
     DEVICE_TYPE_KEYBOARD,
     true,
     6,
@@ -199,7 +199,7 @@ static const razer_zone blackwidow_chroma_v2_zone =
 
 static const razer_device blackwidow_chroma_v2_device =
 {
-    "Razer BlackWidow Chroma V2",
+    "Razer Blackwidow Chroma V2",
     DEVICE_TYPE_KEYBOARD,
     true,
     6,
@@ -412,12 +412,8 @@ static const razer_device huntsman_device =
 |  Zone "Keyboard"                                              |
 |       Matrix                                                  |
 |       6 Rows, 22 Columns                                      |
-|                                                               |
-| Zone "Underglow"                                              |
-|       Matrix                                                  |
-|       3 Rows, 22 Columns                                      |
 \*-------------------------------------------------------------*/
-static const razer_zone huntsman_elite_keyboard_zone =
+static const razer_zone huntsman_elite_zone =
 {
     "Keyboard",
     ZONE_TYPE_MATRIX,
@@ -425,24 +421,16 @@ static const razer_zone huntsman_elite_keyboard_zone =
     22
 };
 
-static const razer_zone huntsman_elite_underglow_zone =
-{
-    "Underglow",
-    ZONE_TYPE_MATRIX,
-    3,
-    22
-};
-
 static const razer_device huntsman_elite_device =
 {
     "Razer Huntsman Elite",
     DEVICE_TYPE_KEYBOARD,
     true,
-    9,
+    6,
     22,
     {
-        &huntsman_elite_keyboard_zone,
-        &huntsman_elite_underglow_zone,
+        &huntsman_elite_zone,
+        NULL,
         NULL,
         NULL,
         NULL,
@@ -1329,9 +1317,17 @@ static const razer_device deathadder_elite_device =
 /*-------------------------------------------------------------*\
 |  Razer Diamondback Chroma                                     |
 |                                                               |
-|  Zone "LED Strip"                                             |
+|  Zone "Right"                                                 |
 |       Linear                                                  |
-|       19 LEDs                                                 |
+|       7 LEDs                                                  |
+|                                                               |
+|  Zone "Bottom"                                                |
+|       Linear                                                  |
+|       5 LEDs                                                  |
+|                                                               |
+|  Zone "Left"                                                  |
+|       Linear                                                  |
+|       7 LEDs                                                  |
 |                                                               |
 |  Zone "Logo"                                                  |
 |       Single                                                  |
@@ -1341,12 +1337,28 @@ static const razer_device deathadder_elite_device =
 |       Single                                                  |
 |       1 LED                                                   |
 \*-------------------------------------------------------------*/
-static const razer_zone diamondback_chroma_led_strip_zone =
+static const razer_zone diamondback_chroma_right_zone =
 {
-    "LED Strip",
+    "Right LED Strip",
     ZONE_TYPE_LINEAR,
     1,
-    19
+    7
+};
+
+static const razer_zone diamondback_chroma_bottom_zone =
+{
+    "Bottom LED Strip",
+    ZONE_TYPE_LINEAR,
+    1,
+    5
+};
+
+static const razer_zone diamondback_chroma_left_zone =
+{
+    "Left LED Strip",
+    ZONE_TYPE_LINEAR,
+    1,
+    7
 };
 
 static const razer_zone diamondback_chroma_logo_zone =
@@ -1373,11 +1385,11 @@ static const razer_device diamondback_chroma_device =
     1,
     21,
     {
-        &diamondback_chroma_led_strip_zone,
+        &diamondback_chroma_right_zone,
+        &diamondback_chroma_bottom_zone,
+        &diamondback_chroma_left_zone,
         &diamondback_chroma_logo_zone,
         &diamondback_chroma_scroll_wheel_zone,
-        NULL,
-        NULL,
         NULL
     }
 };
@@ -2505,7 +2517,7 @@ static const razer_zone base_station_zone =
 static const razer_device base_station_device =
 {
     "Razer Base Station Chroma",
-    DEVICE_TYPE_HEADSET_STAND,
+    DEVICE_TYPE_UNKNOWN,
     true,
     1,
     15,

RGBController/RGBController.cpp

@@ -1,7 +1,16 @@
 #include "RGBController.h"
 #include <cstring>
 
-using namespace std::chrono_literals;
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
 
 RGBController::RGBController()
 {
@@ -13,22 +22,6 @@ RGBController::~RGBController()
 {
     DeviceThreadRunning = false;
     DeviceCallThread->join();
-
-    /*---------------------------------------------------------*\
-    | Delete the matrix map                                     |
-    \*---------------------------------------------------------*/
-    for(int zone_index = 0; zone_index < zones.size(); zone_index++)
-    {
-        if(zones[zone_index].matrix_map != NULL)
-        {
-            if(zones[zone_index].matrix_map->map != NULL)
-            {
-                delete[] zones[zone_index].matrix_map->map;
-            }
-
-            delete zones[zone_index].matrix_map;
-        }
-    }
 }
 
 unsigned char * RGBController::GetDeviceDescription()
@@ -1266,6 +1259,8 @@ void RGBController::SetLED(unsigned int led, RGBColor color)
     if(led < colors.size())
     {
         colors[led] = color;
+
+        UpdateSingleLED(led);
     }
 }
 
@@ -1275,6 +1270,8 @@ void RGBController::SetAllLEDs(RGBColor color)
     {
         SetAllZoneLEDs(zone_idx, color);
     }
+
+    UpdateLEDs();
 }
 
 void RGBController::SetAllZoneLEDs(int zone, RGBColor color)
@@ -1283,6 +1280,8 @@ void RGBController::SetAllZoneLEDs(int zone, RGBColor color)
     {
         zones[zone].colors[color_idx] = color;
     }
+
+    UpdateZoneLEDs(zone);
 }
 
 int RGBController::GetMode()
@@ -1320,7 +1319,7 @@ void RGBController::DeviceCallThreadFunction()
         }
         else
         {
-           std::this_thread::sleep_for(1ms);
+            Sleep(1);
         }
     }
 }
@@ -1347,8 +1346,6 @@ std::string device_type_to_str(device_type type)
         return "Mousemat";
     case DEVICE_TYPE_HEADSET:
         return "Headset";
-    case DEVICE_TYPE_HEADSET_STAND:
-        return "Headset Stand";
     default:
         return "Unknown";
     }

RGBController/RGBController.h

@@ -13,7 +13,6 @@
 #include <vector>
 #include <string>
 #include <thread>
-#include <chrono>
 
 typedef unsigned int RGBColor;
 
@@ -113,7 +112,6 @@ enum
     DEVICE_TYPE_MOUSE,
     DEVICE_TYPE_MOUSEMAT,
     DEVICE_TYPE_HEADSET,
-    DEVICE_TYPE_HEADSET_STAND,
     DEVICE_TYPE_UNKNOWN
 };
 

RGBController/RGBController_AuraAddressable.cpp

@@ -1,22 +1,22 @@
 /*-----------------------------------------*\
-|  RGBController_AuraUSB.cpp                |
+|  RGBController_AuraAddressable.cpp        |
 |                                           |
 |  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
+|  addressable controller driver            |
 |                                           |
 |  Adam Honse (CalcProgrammer1) 1/18/2020   |
 \*-----------------------------------------*/
 
-#include "RGBController_AuraUSB.h"
+#include "RGBController_AuraAddressable.h"
 
-RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* aura_ptr)
+RGBController_AuraAddressable::RGBController_AuraAddressable(AuraAddressableController* aura_ptr)
 {
     aura = aura_ptr;
 
-    name        = "ASUS Aura USB";
+    name        = "ASUS Aura Addressable";
     version     = aura->GetDeviceName();
     type        = DEVICE_TYPE_MOTHERBOARD;
-    description = "ASUS Aura USB Device";
+    description = "ASUS Aura Addressable Device";
 
     mode Direct;
     Direct.name       = "Direct";
@@ -99,12 +99,12 @@ RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* aura_ptr)
     SetupZones();
 }
 
-RGBController_AuraUSB::~RGBController_AuraUSB()
+RGBController_AuraAddressable::~RGBController_AuraAddressable()
 {
 
 }
 
-void RGBController_AuraUSB::SetupZones()
+void RGBController_AuraAddressable::SetupZones()
 {
     /*-------------------------------------------------*\
     | Only set LED count on the first run               |
@@ -126,42 +126,33 @@ void RGBController_AuraUSB::SetupZones()
     /*-------------------------------------------------*\
     | Set zones and leds                                |
     \*-------------------------------------------------*/
-    int addressableCounter = 1;
     for (unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
     {
-        AuraDeviceInfo device_info = aura->GetAuraDevices()[channel_idx];
+        char ch_idx_string[2];
+        sprintf(ch_idx_string, "%d", channel_idx + 1);
 
+        zones[channel_idx].name     = "Aura Channel ";
+        zones[channel_idx].name.append(ch_idx_string);
         zones[channel_idx].type     = ZONE_TYPE_LINEAR;
 
-        if(device_info.device_type == AuraDeviceType::FIXED)
+        zones[channel_idx].leds_min   = 0;
+        zones[channel_idx].leds_max   = AURA_ADDRESSABLE_MAX_LEDS;
+
+        if(first_run)
         {
-            zones[channel_idx].name       = "Aura Mainboard";
-            zones[channel_idx].leds_min   = device_info.num_leds;
-            zones[channel_idx].leds_max   = device_info.num_leds;
-            zones[channel_idx].leds_count = device_info.num_leds;
+            zones[channel_idx].leds_count = 0;
         }
-        else
-        {
-            zones[channel_idx].name       = "Aura Addressable ";
-            zones[channel_idx].name.append(std::to_string(addressableCounter));
-            zones[channel_idx].leds_min   = 0;
-            zones[channel_idx].leds_max   = AURA_ADDRESSABLE_MAX_LEDS;
-
-            addressableCounter++;
-
-            if(first_run)
-            {
-                zones[channel_idx].leds_count = 0;
-            }
-        }
-
 
         for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
         {
+            char led_idx_string[4];
+            sprintf(led_idx_string, "%d", led_ch_idx + 1);
+
             led new_led;
-            new_led.name = zones[channel_idx].name;
+            new_led.name = "Aura Channel ";
+            new_led.name.append(ch_idx_string);
             new_led.name.append(", LED ");
-            new_led.name.append(std::to_string(led_ch_idx + 1));
+            new_led.name.append(led_idx_string);
             new_led.value = channel_idx;
 
             leds.push_back(new_led);
@@ -173,7 +164,7 @@ void RGBController_AuraUSB::SetupZones()
     SetupColors();
 }
 
-void RGBController_AuraUSB::ResizeZone(int zone, int new_size)
+void RGBController_AuraAddressable::ResizeZone(int zone, int new_size)
 {
     if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
     {
@@ -183,7 +174,7 @@ void RGBController_AuraUSB::ResizeZone(int zone, int new_size)
     }
 }
 
-void RGBController_AuraUSB::DeviceUpdateLEDs()
+void RGBController_AuraAddressable::DeviceUpdateLEDs()
 {
     for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
@@ -191,24 +182,24 @@ void RGBController_AuraUSB::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_AuraUSB::UpdateZoneLEDs(int zone)
+void RGBController_AuraAddressable::UpdateZoneLEDs(int zone)
 {
     aura->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count);
 }
 
-void RGBController_AuraUSB::UpdateSingleLED(int led)
+void RGBController_AuraAddressable::UpdateSingleLED(int led)
 {
     unsigned int channel = leds[led].value;
 
     aura->SetChannelLEDs(channel, zones[channel].colors, zones[channel].leds_count);
 }
 
-void RGBController_AuraUSB::SetCustomMode()
+void RGBController_AuraAddressable::SetCustomMode()
 {
 
 }
 
-void RGBController_AuraUSB::UpdateMode()
+void RGBController_AuraAddressable::UpdateMode()
 {
     unsigned char red = 0;
     unsigned char grn = 0;
@@ -221,11 +212,5 @@ void RGBController_AuraUSB::UpdateMode()
         blu = RGBGetBValue(modes[active_mode].colors[0]);
     }
 
-    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        if(zones[zone_idx].leds_count > 0)
-        {
-            aura->SetMode(zone_idx, modes[active_mode].value, red, grn, blu);
-        }
-    }
+    aura->SetMode(modes[active_mode].value, red, grn, blu);
 }

RGBController/RGBController_AuraAddressable.h

@@ -1,23 +1,23 @@
 /*-----------------------------------------*\
-|  RGBController_AuraUSB.h                  |
+|  RGBController_AuraAddressable.h          |
 |                                           |
 |  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
+|  addressable controller driver            |
 |                                           |
 |  Adam Honse (CalcProgrammer1) 1/18/2020   |
 \*-----------------------------------------*/
 
 #pragma once
 #include "RGBController.h"
-#include "AuraUSBController.h"
+#include "AuraAddressableController.h"
 
 #define AURA_ADDRESSABLE_MAX_LEDS       120
 
-class RGBController_AuraUSB : public RGBController
+class RGBController_AuraAddressable : public RGBController
 {
 public:
-    RGBController_AuraUSB(AuraUSBController* aura_ptr);
-    ~RGBController_AuraUSB();
+    RGBController_AuraAddressable(AuraAddressableController* aura_ptr);
+    ~RGBController_AuraAddressable();
 
     void        SetupZones();
 
@@ -31,7 +31,7 @@ public:
     void        UpdateMode();
 
 private:
-    AuraUSBController*  aura;
+    AuraAddressableController*  aura;
     std::vector<unsigned int>   leds_channel;
     std::vector<unsigned int>   zones_channel;
 };