Add file headers to network files and some minor code cleanup

Fix crash when stopping server
Clean up server page
2020-05-09 15:47:51 -05:00 · 2020-05-09 15:44:07 -05:00 · 2020-05-09 15:21:55 -05:00 · 2020-05-08 23:23:25 -05:00 · 2020-05-08 22:25:46 -05:00 · 2020-05-08 22:25:13 -05:00
370 changed files with 4269 additions and 30176 deletions
@@ -1,8 +1 @@
 *.pro.user*
-*.o
-ui_*
-moc_*
-qrc_*
-OpenRGB
-Makefile
-OpenRGB-x86_64.AppImage
@@ -1,197 +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) 32-bit Build Target                                  #
-#-----------------------------------------------------------------------#
-build_linux_32:
-  image: i386/ubuntu:bionic
-  stage: build
-  script:
-  - apt update
-  - apt install -y build-essential qtcreator qt5-default libusb-1.0-0-dev libhidapi-dev pkgconf wget git
-  - ./scripts/build-appimage-32.sh
-  
-  artifacts:
-    paths:
-    - OpenRGB-i386.AppImage
-    expire_in: 1337 years
-
-#-----------------------------------------------------------------------#
-# Linux (AppImage) 64-bit Build Target                                  #
-#-----------------------------------------------------------------------#
-build_linux_64:
-  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
@@ -1,299 +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"
-
-#---------------------------------------------------------------#
-#  Aorus Devices                                                #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1044", ATTR{idProduct}=="7a42", 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 Hydro Series Devices                                 #
-#                                                               #
-#       Corsair H100i Pro RGB                                   #
-#       Corsair H115i Pro RGB                                   #
-#       Corsair H150i Pro RGB                                   #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c15", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c13", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c12", 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 G203 Lightsync                                 #
-#       Logitech G403 Prodigy                                   #
-#       Logitech G403 Hero                                      #
-#       Logitech G502 Proteus Spectrum                          #
-#       Logitech G Lightspeed Wireless Gaming Mouse             #
-#       Logitech G Pro Wireless Gaming Mouse (Wired)            #
-#       Logitech G Powerplay Mousepad with Lightspeed           #
-#                                                               #
-#   Keyboards:                                                  #
-#       Logitech G512                                           #
-#       Logitech G512 RGB                                       #
-#       Logitech G810 #1                                        #
-#       Logitech G810 #2                                        #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c084", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c092", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c083", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08f", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c332", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c539", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c088", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c53a", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c342", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33c", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c337", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c331", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  MSI Mysticlight                                              #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="3EA4", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="4559", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B10", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B93", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B94", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B96", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C34", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C35", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C36", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C37", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C42", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C56", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C59", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C60", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C67", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C70", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C71", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C73", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C75", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C76", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C77", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C79", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C80", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C81", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C82", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C83", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C84", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C85", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C86", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C87", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C88", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C89", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C90", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C91", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C92", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C94", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C95", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C96", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C98", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C99", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="905D", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  MSI/SteelSeries 3-Zone Laptop Keyboard                       #
-#---------------------------------------------------------------#
-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"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="048d", ATTR{idProduct}=="5702", 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"
@@ -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);
 }
@@ -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;
@@ -1,9 +1,9 @@
-#include "Detector.h"
 #include "AMDWraithPrismController.h"
 #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

@@ -17,38 +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);
    }
 }
-
-REGISTER_DETECTOR("AMD Wraith Prism", DetectAMDWraithPrismControllers);
@@ -1,116 +0,0 @@
-/*-----------------------------------------*\
-|  ATC800Controller.cpp                     |
-|                                           |
-|  Driver for Aorus ATC800 CPU Cooler       |
-|                                           |
-|                                           |
-|  Felipe Cavalcanti    08/13/2020          |
-\*-----------------------------------------*/
-
-#include "ATC800Controller.h"
-
-#include <cstring>
-
-ATC800Controller::ATC800Controller(hid_device* dev_handle)
-{
-    dev = dev_handle;
-}
-
-ATC800Controller::~ATC800Controller()
-{
-    hid_close(dev);
-}
-
-void ATC800Controller::SendCoolerMode
-    (
-    unsigned char       mode,
-    unsigned short      /*speed*/,
-    unsigned char       channel,
-    unsigned char       red,
-    unsigned char       green,
-    unsigned char       blue
-    )
-{
-    unsigned char usb_buf[9];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Lighting Control packet                        |
-    \*-----------------------------------------------------*/
-    if (channel == AORUS_ATC800_TOP_ZONE)
-    {
-        usb_buf[0x00] = 0x00;
-        usb_buf[0x01] = 0xbe;
-        usb_buf[0x08] = 0xcc;
-
-        hid_send_feature_report(dev, usb_buf, 9);
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        usb_buf[0x00] = 0x00;
-        usb_buf[0x01] = 0xc9;
-        usb_buf[0x02] = mode;
-        usb_buf[0x03] = 0x3c;
-        usb_buf[0x04] = 0x02;
-        usb_buf[0x05] = 0x00;
-        usb_buf[0x06] = 0x00;
-
-        hid_send_feature_report(dev, usb_buf, 9);
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        usb_buf[0x00] = 0x00;
-        usb_buf[0x01] = 0xbc;
-        usb_buf[0x02] = red;
-        usb_buf[0x03] = green;
-        usb_buf[0x04] = blue;
-
-        hid_send_feature_report(dev, usb_buf, 9);
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        usb_buf[0x00] = 0x00;
-        usb_buf[0x01] = 0xb6;
-    }
-    else if (channel == AORUS_ATC800_FANS_ZONE)
-    {
-        hid_send_feature_report(dev, usb_buf, 9);
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        usb_buf[0x00]           = 0x00;
-        usb_buf[0x01]           = 0xc9;
-        usb_buf[0x02]           = mode;
-        usb_buf[0x03]           = 0x3c;
-        usb_buf[0x04]           = 0x02;
-        usb_buf[0x05]           = 0x00;
-        usb_buf[0x06]           = 0x01;
-    
-        hid_send_feature_report(dev, usb_buf, 9);
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        usb_buf[0x00]           = 0x00;
-        usb_buf[0x01]           = 0xb0;
-        usb_buf[0x02]           = mode;
-        usb_buf[0x03]           = red;
-        usb_buf[0x04]           = green;
-        usb_buf[0x05]           = blue;
-
-        usb_buf[0x06]           = red;
-
-        usb_buf[0x07]           = green;
-        usb_buf[0x08]           = blue;
-
-        for(int i = 0xb0; i <= 0xb3; i++)
-        {
-            usb_buf[0x01]       = i; //zone b0->b3
-            hid_send_feature_report(dev, usb_buf, 9);
-        }
-    }
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    usb_buf[0x00] = 0x00;
-    usb_buf[0x01] = 0xb6;
-
-    hid_send_feature_report(dev, usb_buf, 9);
-}
@@ -1,59 +0,0 @@
-/*-----------------------------------------*\
-|  ATC800Controller.h                       |
-|                                           |
-|  Definitions and types for ATC800 CPU     |
-|  Cooler                                   |
-|                                           |
-|  Felipe Cavalcanti     08/13/2020         |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    AORUS_ATC800_MODE_OFF               = 0x00,
-    AORUS_ATC800_MODE_STATIC            = 0x01,
-    AORUS_ATC800_MODE_PULSE             = 0x02,
-    AORUS_ATC800_MODE_FLASHING          = 0x04,
-    AORUS_ATC800_MODE_DOUBLE_FLASH      = 0x05,
-};
-
-enum
-{
-    AORUS_ATC800_SPEED_SLOWEST          = 0x00, /* Slowest speed                */
-    AORUS_ATC800_SPEED_SLOW             = 0x01, /* Slow speed                   */
-    AORUS_ATC800_SPEED_NORMAL           = 0x02, /* Normal speed                 */
-    AORUS_ATC800_SPEED_FAST             = 0x03, /* Fast speed                   */
-    AORUS_ATC800_SPEED_FASTEST          = 0x04, /* Fastest speed                */
-};
-
-enum
-{
-    AORUS_ATC800_FANS_ZONE              = 0,
-    AORUS_ATC800_TOP_ZONE               = 1
-};
-
-class ATC800Controller
-{
-public:
-    ATC800Controller(hid_device* dev_handle);
-    ~ATC800Controller();
-
-    void        SendCoolerMode
-                    (
-                    unsigned char       mode,
-                    unsigned short      speed,
-                    unsigned char       channel,
-                    unsigned char       red,
-                    unsigned char       green,
-                    unsigned char       blue
-                    );
-
-private:
-    hid_device*             dev;
-};
@@ -1,87 +0,0 @@
-#include "Detector.h"
-#include "RGBController.h"
-#include "ATC800Controller.h"
-#include "RGBController_AorusATC800.h"
-#include <vector>
-#include <hidapi/hidapi.h>
-
-/*-----------------------------------------------------*\
-| Vendor ID                                             |
-\*-----------------------------------------------------*/
-#define HOLTEK_VID                            0x1044
-
-/*-----------------------------------------------------*\
-| Controller product ids                                |
-\*-----------------------------------------------------*/
-#define ATC_800_CONTROLLER_PID                0x7A42
-
-typedef struct
-{
-    unsigned short  usb_vid;
-    unsigned short  usb_pid;
-    char            usb_interface;
-    device_type     type;
-    const char *    name;
-} device;
-
-#define NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const device device_list[] =
-{
-    { HOLTEK_VID,             ATC_800_CONTROLLER_PID,                  0,  DEVICE_TYPE_KEYBOARD,   "Aorus ATC800 CPU Cooler"                             },
-};
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAorusCPUCoolerControllers                                                        *
-*                                                                                          *
-*       Tests the USB address to see if a Aorus RGB CPU Cooler exists there.               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAorusCPUCoolerControllers(std::vector<RGBController*>& rgb_controllers)
-{
-    hid_init();
-
-    for(unsigned int device_idx = 0; device_idx < NUM_DEVICES; device_idx++)
-    {
-        hid_device_info* info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
-
-        while(info)
-        {
-            if((info->vendor_id == device_list[device_idx].usb_vid)
-            &&(info->product_id == device_list[device_idx].usb_pid)
-#ifdef USE_HID_USAGE                    
-            &&(info->interface_number == device_list[device_idx].usb_interface)
-            &&(info->usage_page == 0xFF01)
-            &&(info->usage == 1))
-#else
-            &&(info->interface_number == device_list[device_idx].usb_interface))
-#endif
-            {
-                hid_device* dev = hid_open_path(info->path);
-
-                if(dev)
-                {
-                    switch(device_list[device_idx].usb_pid)
-                    {
-                    case ATC_800_CONTROLLER_PID:
-                        {
-                            ATC800Controller* controller = new ATC800Controller(dev);
-
-                            RGBController_AorusATC800* rgb_controller = new RGBController_AorusATC800(controller);
-
-                            rgb_controller->name = device_list[device_idx].name;
-                            rgb_controllers.push_back(rgb_controller);
-                        }
-                        break;
-                    }
-                }
-            }
-        info = info->next;
-        }
-        hid_free_enumeration(info);
-    }
-}
-
-REGISTER_DETECTOR("Aorus CPU Coolers", DetectAorusCPUCoolerControllers);
@@ -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);
+}
@@ -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
+                );
 };
@@ -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);
+        }
+    }
+}
@@ -1,4 +1,3 @@
-#include "Detector.h"
 #include "AuraCoreController.h"
 #include "RGBController.h"
 #include "RGBController_AuraCore.h"
@@ -44,5 +43,3 @@ void DetectAuraCoreControllers(std::vector<RGBController*>& rgb_controllers)
        }
    }
 }
-
-REGISTER_DETECTOR("ASUS Aura Core", DetectAuraCoreControllers);
@@ -6,7 +6,6 @@
 |  Jan Rettig (Klapstuhl) 14.02.2020        |
 \*-----------------------------------------*/

-#include "Detector.h"
 #include "AuraGPUController.h"
 #include "RGBController.h"
 #include "RGBController_AuraGPU.h"
@@ -15,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  |
@@ -80,9 +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() */
-
-REGISTER_I2C_DETECTOR("ASUS Aura GPU", DetectAuraGPUControllers);
+} /* DetectAuraGPUControllers() */
@@ -10,21 +10,6 @@
 #include "AuraSMBusController.h"
 #include <cstring>

-static const char* aura_channels[] =                /* Aura channel strings                 */
-{
-    "Audio",
-    "Backplate",
-    "Back I/O",
-    "Center",
-    "Center",
-    "DRAM",
-    "PCIe",
-    "RGB Header",
-    "RGB Header 2",
-    "RGB Header",
-    "Unknown",
-};
-
 AuraSMBusController::AuraSMBusController(i2c_smbus_interface* bus, aura_dev_id dev)
 {
    this->bus = bus;
@@ -60,7 +45,7 @@ AuraSMBusController::AuraSMBusController(i2c_smbus_interface* bus, aura_dev_id d
    {
        direct_reg  = AURA_REG_COLORS_DIRECT_V2;
        effect_reg  = AURA_REG_COLORS_EFFECT_V2;
-        channel_cfg = AURA_CONFIG_CHANNEL_V1;
+        channel_cfg = AURA_CONFIG_CHANNEL_V2;
    }
    // AUMA0-E6K5-0106 - Second generation motherboard controller
    else if (strcmp(device_name, "AUMA0-E6K5-0106") == 0)
@@ -83,13 +68,6 @@ AuraSMBusController::AuraSMBusController(i2c_smbus_interface* bus, aura_dev_id d
        effect_reg = AURA_REG_COLORS_EFFECT_V2;
        channel_cfg = AURA_CONFIG_CHANNEL_V2;
    }
-    // AUMA0-E8K4-0101 - Second generation motherboard controller
-    else if (strcmp(device_name, "AUMA0-E8K4-0101") == 0)
-    {
-        direct_reg = AURA_REG_COLORS_DIRECT_V2;
-        effect_reg = AURA_REG_COLORS_EFFECT_V2;
-        channel_cfg = AURA_CONFIG_CHANNEL_V2;
-    }
    // Assume first generation controller if string does not match
    else
    {
@@ -66,6 +66,21 @@ enum
    AURA_LED_CHANNEL_RGB_HEADER_3       = 0x91,     /* RGB Header 3 LED channel             */
 };

+static const char* aura_channels[] =                /* Aura channel strings                 */
+{
+    "Audio",
+    "Backplate",
+    "Back I/O",
+    "Center",
+    "Center",
+    "DRAM",
+    "PCIe",
+    "RGB Header",
+    "RGB Header 2",
+    "RGB Header",
+    "Unknown",
+};
+
 enum
 {
    AURA_CONFIG_LED_COUNT               = 0x02,     /* LED Count configuration offset       */
@@ -1,4 +1,3 @@
-#include "Detector.h"
 #include "AuraSMBusController.h"
 #include "RGBController.h"
 #include "RGBController_AuraSMBus.h"
@@ -7,12 +6,21 @@
 #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  |
 \*----------------------------------------------------------------------*/
-#define AURA_RAM_ADDRESS_COUNT  23
+#define AURA_RAM_ADDRESS_COUNT  22

 static const unsigned char aura_ram_addresses[] =
 {
@@ -35,7 +43,6 @@ static const unsigned char aura_ram_addresses[] =
    0x66,
    0x67,
    0x39,
-    0x3A,
    0x3B,
    0x3C,
    0x3D
@@ -171,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
@@ -184,10 +191,8 @@ void DetectAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::
                rgb_controllers.push_back(new_controller);
            }

-            std::this_thread::sleep_for(1ms);
+            Sleep(1);
        }
    }

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

 #include "CMMP750Controller.h"
+#include <cstring>
+#include <stdio.h>
+#include <stdlib.h>

-static unsigned char colour_mode_data[][6] =
+CMMP750Controller::CMMP750Controller(libusb_device_handle* dev_handle, unsigned int _inAddr, unsigned int _outAddr, int _interface)
 {
-    { 0x01, 0x04, 0xFF, 0x00, 0xFF, 0x00 },                  /* Static                       */
-    { 0x02, 0x04, 0xFF, 0x00, 0xFF, 0x80 },                  /* Blinking                     */
-    { 0x03, 0x04, 0xFF, 0x00, 0xFF, 0x80 },                  /* Breathing                    */
-    { 0x04, 0x04, 0x80, 0x00, 0x00, 0x00 },                  /* Colour Cycle                 */
-    { 0x05, 0x04, 0x80, 0x00, 0x00, 0x00 }                   /* Colour Breath                */
-};
+    dev = dev_handle;
+    inAddr = _inAddr;
+    outAddr = _outAddr;
+    interface = _interface;

-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                */
-};
+    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);

-CMMP750Controller::CMMP750Controller(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path)
-{
-    std::size_t tmp_size    = wcslen(_vendor);
-    dev                     = dev_handle;
-    location                = _path;
+    strcpy(device_name, "Cooler Master MP750");

-    for(std::size_t i = 0; (i < tmp_size) && (i < CM_DEVICE_NAME_SIZE); i++)
-    {
-        device_name[i] = (char)_vendor[i];
-    }
-    for(std::size_t j = 0; (j < wcslen(_vendor)) && (tmp_size + j < CM_DEVICE_NAME_SIZE); j++)
-    {
-        device_name[tmp_size + j] = (char)_device_name[j];
-    }
-
-    GetStatus();        //When setting up device get current status
+    current_mode = MP750_MODE_STATIC;
+    current_speed = MP750_SPEED_NORMAL;
 }

 CMMP750Controller::~CMMP750Controller()
 {
-    hid_close(dev);
-}
-
-void CMMP750Controller::GetStatus()
-{
-    unsigned char buffer[0x40]  = { 0x00 };
-    int buffer_size             = (sizeof(buffer) / sizeof(buffer[0]));
-    buffer[0]                   = 0x07;
-
-    hid_write(dev, buffer, buffer_size);
-    hid_read(dev, buffer, buffer_size);
-
-    if((buffer[0] == 0x80) && (buffer[1] == 0x05))
-    {
-        current_mode  = buffer[2] - 1;
-        current_red   = buffer[3];
-        current_green = buffer[4];
-        current_blue  = buffer[5];
-
-        for(int i = 0; speed_mode_data[current_mode][i] >= buffer[6]; i++)
-        {
-            current_speed = i;
-        }
-    }
-    else
-    {
-        //Code should never reach here however just in case there is a failure set something
-        current_mode  = MP750_MODE_COLOR_CYCLE;      //Unicorn Spew
-        current_red   = 0xFF;
-        current_green = 0xFF;
-        current_blue  = 0xFF;
-        current_speed = MP750_SPEED_NORMAL;
-    }
+    libusb_release_interface(dev, interface);
+    libusb_attach_kernel_driver(dev, interface);
 }

 char* CMMP750Controller::GetDeviceName()
@@ -97,31 +52,6 @@ std::string CMMP750Controller::GetLocation()
    return location;
 }

-unsigned char CMMP750Controller::GetMode()
-{
-    return current_mode;
-}
-
-unsigned char CMMP750Controller::GetLedRed()
-{
-    return current_red;
-}
-
-unsigned char CMMP750Controller::GetLedGreen()
-{
-    return current_green;
-}
-
-unsigned char CMMP750Controller::GetLedBlue()
-{
-    return current_blue;
-}
-
-unsigned char CMMP750Controller::GetLedSpeed()
-{
-    return current_speed;
-}
-
 void CMMP750Controller::SetMode(unsigned char mode, unsigned char speed)
 {
    current_mode  = mode;
@@ -141,10 +71,11 @@ 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]));

-    for(std::size_t i = 0; i < CM_COLOUR_MODE_DATA_SIZE; i++)
+    for(int i = 0; i < CM_COLOUR_MODE_DATA_SIZE; i++)
    {
        buffer[i] = colour_mode_data[current_mode][i];
    }
@@ -152,16 +83,18 @@ void CMMP750Controller::SendUpdate()
   if(current_mode > MP750_MODE_BREATHING)
    { 
        //If the mode is random colours set SPEED at BYTE2
-        buffer[CM_RED_BYTE]     = speed_mode_data[current_mode][current_speed];
+        buffer[CM_RED_BYTE] = speed_mode_data[current_mode][current_speed];
    }
    else
    { 
        //Otherwise SPEED is BYTE5
-        buffer[CM_RED_BYTE]     = current_red;
-        buffer[CM_GREEN_BYTE]   = current_green;
-        buffer[CM_BLUE_BYTE]    = current_blue;
-        buffer[CM_SPEED_BYTE]   = speed_mode_data[current_mode][current_speed];
+        buffer[CM_RED_BYTE] = current_red;
+        buffer[CM_GREEN_BYTE] = current_green;
+        buffer[CM_BLUE_BYTE] = current_blue;
+        buffer[CM_SPEED_BYTE] = speed_mode_data[current_mode][current_speed];
    }

-    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);
 }
+
@@ -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[0]) / sizeof(colour_mode_data[0][0]))
+#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
 {
@@ -44,6 +41,24 @@ enum
    MP750_MODE_BREATH_CYCLE = 0x04  //Breathing Cycle Mode
 };

+static unsigned char colour_mode_data[][6] =
+{
+    { 0x01, 0x04, 0xFF, 0x00, 0xFF, 0x00 },                  /* Static                       */
+    { 0x02, 0x04, 0xFF, 0x00, 0xFF, 0x80 },                  /* Blinking                     */
+    { 0x03, 0x04, 0xFF, 0x00, 0xFF, 0x80 },                  /* Breathing                    */
+    { 0x04, 0x04, 0x80, 0x00, 0x00, 0x00 },                  /* Colour Cycle                 */
+    { 0x05, 0x04, 0x80, 0x00, 0x00, 0x00 }                   /* Colour Breath                */
+};
+
+static unsigned char speed_mode_data[][9] =
+{
+    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },/* Static                       */
+    { 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
 {
    MP750_SPEED_SLOWEST              = 0x00, /* Slowest speed                */
@@ -60,18 +75,13 @@ 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();
    char* GetSerial();
    std::string GetLocation();

-    unsigned char GetMode();
-    unsigned char GetLedRed();
-    unsigned char GetLedGreen();
-    unsigned char GetLedBlue();
-    unsigned char GetLedSpeed();
    void SetMode(unsigned char mode, unsigned char speed);
    void SetColor(unsigned char red, unsigned char green, unsigned char blue);

@@ -79,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;
@@ -88,6 +101,5 @@ private:
    unsigned char           current_green;
    unsigned char           current_blue;

-    void GetStatus();
    void SendUpdate();
 };
@@ -1,26 +1,24 @@
-#include "Detector.h"
 #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
 };

 /******************************************************************************************\
@@ -33,37 +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(COOLERMASTER_VID, 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(unsigned int cm_pid_idx = 0; cm_pid_idx < COOLERMASTER_NUM_DEVICES; cm_pid_idx++)
-            {
-                if((info->product_id        == cm_pids[cm_pid_idx][CM_PID])
-                 &&(info->interface_number  == cm_pids[cm_pid_idx][CM_INTERFACE]))
-                {
-                    dev = hid_open_path(info->path);
-                    break;
-                }
-            }
-        }
+        //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);
-        }
-        info = info->next;
-    }
-    hid_free_enumeration(info);
-}   /* DetectCoolerMasterControllers() */
+            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]);

-REGISTER_DETECTOR("Cooler Master", DetectCoolerMasterControllers);
+            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);
+            }
+        }
+    }
+
+}
@@ -1,251 +0,0 @@
-/*---------------------------------------------------------*\
-|  Processing Code for Corsair Hydro Series                 |
-|                                                           |
-|  Adam Honse ([email protected]), 8/17/2020        |
-\*---------------------------------------------------------*/
-
-#include "CorsairHydroController.h"
-
-#include <cstring>
-
-CorsairHydroController::CorsairHydroController(libusb_device_handle* dev_handle)
-{
-    dev = dev_handle;
-
-    SendInit();
-
-    SendFirmwareRequest();
-}
-
-std::string CorsairHydroController::GetFirmwareString()
-{
-    return(firmware_version);
-}
-
-void CorsairHydroController::SetBlink
-    (
-        std::vector<RGBColor> & colors,
-        unsigned char           speed
-    )
-{
-    SendColors(colors);
-    SendSpeed(speed);
-    SendApplyBlink();
-}
-
-void CorsairHydroController::SetFixed
-    (
-        std::vector<RGBColor> & colors
-    )
-{
-    SendColors(colors);
-
-    /*-----------------------------------------------------*\
-    | Fixed mode seems to just be shift mode with the same  |
-    | value for both colors                                 |
-    \*-----------------------------------------------------*/    
-    SendApplyShift();
-}
-
-void CorsairHydroController::SetPulse
-    (
-        std::vector<RGBColor> & colors,
-        unsigned char           speed
-    )
-{
-    SendColors(colors);
-    SendSpeed(speed);
-    SendApplyPulse();
-}
-
-void CorsairHydroController::SetShift
-    (
-        std::vector<RGBColor> & colors,
-        unsigned char           speed
-    )
-{
-    SendColors(colors);
-    SendSpeed(speed);
-    SendApplyShift();
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void CorsairHydroController::SendApplyBlink()
-{
-    unsigned char usb_buf[3];
-    int           actual;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Apply Blink packet                             |
-    \*-----------------------------------------------------*/
-    usb_buf[0] = 0x58;
-    usb_buf[1] = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    libusb_bulk_transfer(dev, 0x01, usb_buf, 2, &actual, 1000);
-    libusb_bulk_transfer(dev, 0x81, usb_buf, 3, &actual, 1000);
-}
-
-void CorsairHydroController::SendApplyPulse()
-{
-    unsigned char usb_buf[3];
-    int           actual;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Apply Pulse packet                             |
-    \*-----------------------------------------------------*/
-    usb_buf[0] = 0x52;
-    usb_buf[1] = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    libusb_bulk_transfer(dev, 0x01, usb_buf, 2, &actual, 1000);
-    libusb_bulk_transfer(dev, 0x81, usb_buf, 3, &actual, 1000);
-}
-
-void CorsairHydroController::SendApplyShift()
-{
-    unsigned char usb_buf[3];
-    int           actual;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Apply Shift packet                             |
-    \*-----------------------------------------------------*/
-    usb_buf[0] = 0x55;
-    usb_buf[1] = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    libusb_bulk_transfer(dev, 0x01, usb_buf, 2, &actual, 1000);
-    libusb_bulk_transfer(dev, 0x81, usb_buf, 3, &actual, 1000);
-}
-
-void CorsairHydroController::SendFirmwareRequest()
-{
-    unsigned char usb_buf[8];
-    int           actual;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Firmware Request packet                        |
-    \*-----------------------------------------------------*/
-    usb_buf[0] = 0xAA;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    libusb_bulk_transfer(dev, 0x01, usb_buf, 1, &actual, 1000);
-    libusb_bulk_transfer(dev, 0x81, usb_buf, 7, &actual, 1000);
-
-    firmware_version = std::to_string(usb_buf[3]) + "." + std::to_string(usb_buf[4]) + "." + std::to_string(usb_buf[5]) + "." + std::to_string(usb_buf[6]);
-}
-
-void CorsairHydroController::SendColors
-    (
-        std::vector<RGBColor> & colors
-    )
-{
-    unsigned char usb_buf[23];
-    int           actual;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Send Colors packet                             |
-    \*-----------------------------------------------------*/
-    usb_buf[0] = 0x56;
-    usb_buf[1] = colors.size();
-
-    /*---------------------------------------------------------*\
-    | Fill in colors from vector                                |
-    \*---------------------------------------------------------*/
-    for(std::size_t color_idx = 0; color_idx < colors.size(); color_idx++)
-    {
-        usb_buf[(color_idx * 3) + 2] = RGBGetRValue(colors[color_idx]);
-        usb_buf[(color_idx * 3) + 3] = RGBGetGValue(colors[color_idx]);
-        usb_buf[(color_idx * 3) + 4] = RGBGetBValue(colors[color_idx]);
-
-        /*---------------------------------------------------------*\
-        | If the color vector only has one entry, duplicate it, as  |
-        | the controller appears to require two colors in order to  |
-        | update.                                                   |
-        \*---------------------------------------------------------*/
-        if((color_idx == 0) && colors.size() == 1)
-        {
-            usb_buf[1]                   = colors.size() + 1;
-            usb_buf[(color_idx * 3) + 5] = RGBGetRValue(colors[color_idx]);
-            usb_buf[(color_idx * 3) + 6] = RGBGetGValue(colors[color_idx]);
-            usb_buf[(color_idx * 3) + 7] = RGBGetBValue(colors[color_idx]);
-        }
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    libusb_bulk_transfer(dev, 0x01, usb_buf, 2 + (usb_buf[1] * 3), &actual, 1000);
-    libusb_bulk_transfer(dev, 0x81, usb_buf, 3, &actual, 1000);
-}
-
-void CorsairHydroController::SendInit()
-{
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    libusb_control_transfer( dev, 0x40, 0x00, 0xffff, 0x0000, NULL, 0, 0 );
-    libusb_control_transfer( dev, 0x40, 0x02, 0x0002, 0x0000, NULL, 0, 0 );
-}
-
-void CorsairHydroController::SendSpeed
-    (
-        unsigned char           speed
-    )
-{
-    unsigned char usb_buf[3];
-    int           actual;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Send Speed packet                              |
-    \*-----------------------------------------------------*/
-    usb_buf[0] = 0x53;
-    usb_buf[1] = speed;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    libusb_bulk_transfer(dev, 0x01, usb_buf, 2, &actual, 1000);
-    libusb_bulk_transfer(dev, 0x81, usb_buf, 3, &actual, 1000);
-}
@@ -1,86 +0,0 @@
-/*---------------------------------------------------------*\
-|  Definitions for Corsair Hydro Series                     |
-|                                                           |
-|  Adam Honse ([email protected]), 8/17/2020        |
-\*---------------------------------------------------------*/
-
-#include "RGBController.h"
-#include <vector>
-#include <libusb-1.0/libusb.h>
-
-#pragma once
-
-enum
-{
-    CORSAIR_HYDRO_CMD_READ_PUMP_SPEED   = 0x31,
-    CORSAIR_HYDRO_CMD_WRITE_PUMP_MODE   = 0x32,
-    CORSAIR_HYDRO_CMD_READ_PUMP_MODE    = 0x33,
-    CORSAIR_HYDRO_CMD_READ_FAN_SPEED    = 0x41,
-    CORSAIR_HYDRO_CMD_READ_AIO_TEMP     = 0xA9,
-    CORSAIR_HYDRO_CMD_READ_FIRMWARE     = 0xAA,
-};
-
-enum
-{
-    CORSAIR_HYDRO_PUMP_MODE_QUIET       = 0x00,
-    CORSAIR_HYDRO_PUMP_MODE_BALANCED    = 0x01,
-    CORSAIR_HYDRO_PUMP_MODE_PERFORMANCE = 0x02,
-};
-
-class CorsairHydroController
-{
-public:
-    CorsairHydroController(libusb_device_handle* dev_handle);
-    ~CorsairHydroController();
-
-    unsigned char   GetFanPercent(unsigned char fan_channel);
-
-    unsigned short  GetFanRPM(unsigned char fan_channel);
-
-    std::string     GetFirmwareString();
-
-    void            SetBlink
-                        (
-                            std::vector<RGBColor> & colors,
-                            unsigned char           speed
-                        );
-
-    void            SetFixed
-                        (
-                            std::vector<RGBColor> & colors
-                        );
-
-    void            SetPulse
-                        (
-                            std::vector<RGBColor> & colors,
-                            unsigned char           speed
-                        );
-
-    void            SetShift
-                        (
-                            std::vector<RGBColor> & colors,
-                            unsigned char           speed
-                        );    
-
-private:
-    libusb_device_handle*   dev;
-    std::string             firmware_version;
-
-    void            SendApplyBlink();
-    void            SendApplyPulse();
-    void            SendApplyShift();
-
-    void            SendColors
-                        (
-                            std::vector<RGBColor> & colors
-                        );
-
-    void            SendFirmwareRequest();
-
-    void            SendInit();
-
-    void            SendSpeed
-                        (
-                            unsigned char           speed
-                        );
-};
@@ -1,74 +0,0 @@
-#include "Detector.h"
-#include "CorsairHydroController.h"
-#include "RGBController.h"
-#include "RGBController_CorsairHydro.h"
-#include <vector>
-#include <libusb-1.0/libusb.h>
-
-/*-----------------------------------------------------*\
-| Corsair vendor ID                                     |
-\*-----------------------------------------------------*/
-#define CORSAIR_VID                     0x1B1C
-
-/*-----------------------------------------------------*\
-| Keyboard Hydro Series product IDs                     |
-\*-----------------------------------------------------*/
-#define CORSAIR_H115I_PRO_RGB_PID       0x0C13
-#define CORSAIR_H100I_PRO_RGB_PID       0x0C15
-#define CORSAIR_H150I_PRO_RGB_PID       0x0C12
-
-typedef struct
-{
-    unsigned short  usb_vid;
-    unsigned short  usb_pid;
-    unsigned char   usb_interface;
-    const char *    name;
-} corsair_hydro_device;
-
-#define CORSAIR_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const corsair_hydro_device device_list[] =
-{
-    /*-----------------------------------------------------------------------------------------------------*\
-    | Coolers                                                                                               |
-    \*-----------------------------------------------------------------------------------------------------*/
-    { CORSAIR_VID,          CORSAIR_H100I_PRO_RGB_PID,          0,      "Corsair H100i PRO RGB"             },
-    { CORSAIR_VID,          CORSAIR_H115I_PRO_RGB_PID,          0,      "Corsair H115i PRO RGB"             },
-    { CORSAIR_VID,          CORSAIR_H150I_PRO_RGB_PID,          0,      "Corsair H150i PRO RGB"             },
-};
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCorsairHydroControllers                                                          *
-*                                                                                          *
-*       Tests the USB address to see if a Corsair RGB Cooler controller exists there.      *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCorsairHydroControllers(std::vector<RGBController*>& rgb_controllers)
-{
-    libusb_context * ctx;
-    libusb_init(&ctx);
-
-    for(std::size_t device_idx = 0; device_idx < CORSAIR_NUM_DEVICES; device_idx++)
-    {
-        libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
-
-        //Look for Corsair RGB Peripheral
-        if(dev)
-        {
-            libusb_detach_kernel_driver(dev, 0);
-            libusb_claim_interface(dev, 0);
-
-            CorsairHydroController* controller = new CorsairHydroController(dev);//, device_list[device_idx].usb_endpoint);
-
-            RGBController_CorsairHydro* rgb_controller = new RGBController_CorsairHydro(controller);
-
-            rgb_controller->name = device_list[device_idx].name;
-            
-            rgb_controllers.push_back(rgb_controller);
-        }
-    }
-}   /* DetectCorsairHydroControllers() */
-
-REGISTER_DETECTOR("Corsair Hydro Series", DetectCorsairHydroControllers);
@@ -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()
@@ -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();

@@ -1,9 +1,8 @@
-#include "Detector.h"
 #include "CorsairLightingNodeController.h"
 #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
@@ -17,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"        }
+
 };

 /******************************************************************************************\
@@ -38,45 +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() */
-
-REGISTER_DETECTOR("Corsair Lighting Node", DetectCorsairLightingNodeControllers);
@@ -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,31 +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 keys_k95_plat[] = {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,
-                                       0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x42, 0x43, 0x44, 0x45, 0x48, 73,   74,   75,   76,   78,
-                                       79,   80,   81,   84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   96,   97,
-                                       98,   99,   100,  101,  102,  103,  104,  105,  108,  109,  110,  111,  112,  113,  115,
-                                       116,  117,  120,  121,  122,  123,  124,  126,  127,  128,  129,  132,  133,  134,  135,
-                                       136,  137,  139,  140,  141,
-                                       0x10, 114, 0x0a, 0x16, 0x22, 0x2e, 0x3a, 0x46,
-                                       144,  145,  146,  158,  160,  147,  148,  149,  150,  151,  152,  153,
-                                       154,  155,  159,  162,  161,  156,  157};
-
-static unsigned int keys_k95[] = {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,
-                                  0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x42, 0x43, 0x44, 0x45, 0x48, 73,   74,   75,   76,   78,
-                                  79,   80,   81,   84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   96,   97,
-                                  98,   99,   100,  101,  102,  103,  104,  105,  108,  109,  110,  111,  112,  113,  115,
-                                  116,  117,  120,  121,  122,  123,  124,  126,  127,  128,  129,  132,  133,  134,  135,
-                                  136,  137,  139,  140,  141,
-                                  0x10, 114, 0x0a, 0x16, 0x22, 0x2e, 0x3a, 0x46, 0x52, 0x5e, 0x6a, 0x76, 0x3b, 0x47, 0x53,
-                                  0x5f, 0x6b, 0x77, 0x83, 0x8f, 0x0b, 0x17, 0x23, 0x2f};
-
-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)
 {
@@ -54,6 +38,7 @@ CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle)

    ReadFirmwareInfo();

+    SpecialFunctionControl();
    LightingControl();
 }

@@ -67,16 +52,6 @@ device_type CorsairPeripheralController::GetDeviceType()
    return type;
 }

-int CorsairPeripheralController::GetPhysicalLayout()
-{
-    return physical_layout;
-}
-
-int CorsairPeripheralController::GetLogicalLayout()
-{
-    return logical_layout;
-}
-
 std::string CorsairPeripheralController::GetFirmwareString()
 {
    return firmware_version;
@@ -97,34 +72,14 @@ 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;
    }
 }

 void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colors)
 {
-    unsigned char red_val[168];
-    unsigned char grn_val[168];
-    unsigned char blu_val[168];
+    unsigned char red_val[144];
+    unsigned char grn_val[144];
+    unsigned char blu_val[144];

    /*-----------------------------------------------------*\
    | Zero out buffers                                      |
@@ -139,24 +94,9 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
    for(std::size_t color_idx = 0; color_idx < colors.size(); color_idx++)
    {
        RGBColor           color = colors[color_idx];
-        if (logical_layout == CORSAIR_TYPE_K95_PLAT)
-        {
-            red_val[keys_k95_plat[color_idx]] = RGBGetRValue(color);
-            grn_val[keys_k95_plat[color_idx]] = RGBGetGValue(color);
-            blu_val[keys_k95_plat[color_idx]] = RGBGetBValue(color);
-        }
-        else if (logical_layout == CORSAIR_TYPE_K95)
-        {
-            red_val[keys_k95[color_idx]] = RGBGetRValue(color);
-            grn_val[keys_k95[color_idx]] = RGBGetGValue(color);
-            blu_val[keys_k95[color_idx]] = RGBGetBValue(color);
-        }
-        else
-        {
-            red_val[keys[color_idx]] = RGBGetRValue(color);
-            grn_val[keys[color_idx]] = RGBGetGValue(color);
-            blu_val[keys[color_idx]] = RGBGetBValue(color);
-        }
+        red_val[keys[color_idx]] = RGBGetRValue(color);
+        grn_val[keys[color_idx]] = RGBGetGValue(color);
+        blu_val[keys[color_idx]] = RGBGetBValue(color);
    }

    /*-----------------------------------------------------*\
@@ -164,7 +104,7 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
    \*-----------------------------------------------------*/
    StreamPacket(1, 60, &red_val[0]);
    StreamPacket(2, 60, &red_val[60]);
-    StreamPacket(3, 48, &red_val[120]);
+    StreamPacket(3, 24, &red_val[120]);
    SubmitKeyboardFullColors(1, 3, 1);

    /*-----------------------------------------------------*\
@@ -172,7 +112,7 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
    \*-----------------------------------------------------*/
    StreamPacket(1, 60, &grn_val[0]);
    StreamPacket(2, 60, &grn_val[60]);
-    StreamPacket(3, 48, &grn_val[120]);
+    StreamPacket(3, 24, &grn_val[120]);
    SubmitKeyboardFullColors(2, 3, 1);

    /*-----------------------------------------------------*\
@@ -180,7 +120,7 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
    \*-----------------------------------------------------*/
    StreamPacket(1, 60, &blu_val[0]);
    StreamPacket(2, 60, &blu_val[60]);
-    StreamPacket(3, 48, &blu_val[120]);
+    StreamPacket(3, 24, &blu_val[120]);
    SubmitKeyboardFullColors(3, 3, 2);
 }

@@ -267,7 +207,7 @@ void CorsairPeripheralController::SetLEDsKeyboardLimited(std::vector<RGBColor> c

 void CorsairPeripheralController::LightingControl()
 {
-    char usb_buf[65];
+    char usb_buf[64];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -277,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                                       |
@@ -324,23 +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                                       |
@@ -350,88 +281,33 @@ 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:
-            {
-                unsigned short pid = (unsigned short)(usb_buf[0x0F] << 8) + (unsigned char)(usb_buf[0x0E]);
-
-                switch(pid)
-                {
-                    case 0x2D1B:
-                    logical_layout = CORSAIR_TYPE_K95_PLAT;
-                    break;
-
-                    case 0x1B11:
-                    logical_layout = CORSAIR_TYPE_K95;
-                    break;
-
-                    default:
-                    logical_layout = CORSAIR_TYPE_NORMAL;
-                }
-            }
            type = DEVICE_TYPE_KEYBOARD;
            break;

        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:
@@ -444,22 +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]);
-    }
-
-    /*-----------------------------------------------------*\
-    | Get the correct Keyboard Layout                       |
-    \*-----------------------------------------------------*/
-    switch((unsigned char)usb_buf[0x17 + offset])
-    {
-        case CORSAIR_LAYOUT_ANSI:
-            physical_layout = CORSAIR_LAYOUT_ANSI;
-            break;
-        case CORSAIR_LAYOUT_ISO:
-            physical_layout = CORSAIR_LAYOUT_ISO;
-            break;
-        default:
-            physical_layout = CORSAIR_LAYOUT_ANSI;
+        firmware_version = std::to_string(usb_buf[0x09]) + "." + std::to_string(usb_buf[0x08]);
    }
 }

@@ -470,7 +331,7 @@ void CorsairPeripheralController::StreamPacket
    unsigned char*  data_ptr
    )
 {
-    char usb_buf[65];
+    char usb_buf[64];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -480,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
@@ -503,7 +363,7 @@ void CorsairPeripheralController::SubmitKeyboardFullColors
    unsigned char   finish_val
    )
 {
-    char usb_buf[65];
+    char usb_buf[64];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -513,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
@@ -531,7 +390,7 @@ void CorsairPeripheralController::SubmitKeyboardLimitedColors
    unsigned char   byte_count
    )
 {
-    char usb_buf[65];
+    char usb_buf[64];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -541,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
@@ -558,7 +416,7 @@ void CorsairPeripheralController::SubmitMouseColors
    RGBColor *      color_data
    )
 {
-    char usb_buf[65];
+    char usb_buf[64];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -568,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
@@ -597,7 +454,7 @@ void CorsairPeripheralController::SubmitMousematColors
    RGBColor *      color_data
    )
 {
-    char usb_buf[65];
+    char usb_buf[64];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -607,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);
+}
@@ -47,30 +47,12 @@ enum
    CORSAIR_COLOR_CHANNEL_BLUE      = 0x03
 };

-enum
-{
-    CORSAIR_LAYOUT_ANSI             = 0x00,
-    CORSAIR_LAYOUT_ISO              = 0x01,
-    CORSAIR_LAYOUT_ABNT             = 0x02,
-    CORSAIR_LAYOUT_JIS              = 0x03,
-    CORSAIR_LAYOUT_DUBEOLSIK        = 0x04
-};
-
-enum
-{
-    CORSAIR_TYPE_NORMAL             = 0,
-    CORSAIR_TYPE_K95_PLAT           = 1,
-    CORSAIR_TYPE_K95                = 2
-};
-
 class CorsairPeripheralController
 {
 public:
    CorsairPeripheralController(hid_device* dev_handle);
    ~CorsairPeripheralController();

-    int             GetLogicalLayout();
-    int             GetPhysicalLayout();
    device_type     GetDeviceType();
    std::string     GetFirmwareString();

@@ -85,8 +67,6 @@ private:

    std::string             firmware_version;
    device_type             type;
-    int                     physical_layout;   //ANSI, ISO, etc.
-    int                     logical_layout;    //Normal, K95 or K95 Platinum

    void    LightingControl();
    void    SpecialFunctionControl();
@@ -1,4 +1,3 @@
-#include "Detector.h"
 #include "CorsairPeripheralController.h"
 #include "RGBController.h"
 #include "RGBController_CorsairPeripheral.h"
@@ -26,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

@@ -40,13 +39,8 @@
 | 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
-#define CORSAIR_SCIMITAR_PRO_RGB_PID    0x1B3E
-#define CORSAIR_SABRE_RGB_PID           0x1B2F

 /*-----------------------------------------------------*\
 | Mousepad product IDs                                  |
@@ -54,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;
@@ -75,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"               },
@@ -88,26 +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"             },
-    { CORSAIR_VID,          CORSAIR_SCIMITAR_PRO_RGB_PID,       1,      "Corsair Scimitar PRO RGB"          },
-    { CORSAIR_VID,          CORSAIR_SABRE_RGB_PID,              1,      "Corsair Sabre RGB"                 },
    /*-----------------------------------------------------------------------------------------------------*\
    | Mousemats                                                                                             |
    \*-----------------------------------------------------------------------------------------------------*/
-    { CORSAIR_VID,          CORSAIR_MM800_RGB_POLARIS_PID,      0,      "Corsair MM800 RGB Polaris"         },
-    /*-----------------------------------------------------------------------------------------------------*\
-    | Headset Stands                                                                                        |
-    \*-----------------------------------------------------------------------------------------------------*/
-    { CORSAIR_VID,          CORSAIR_ST100_PID,                  0,      "Corsair ST100 RGB"                 }
+    { CORSAIR_VID,          CORSAIR_MM800_RGB_POLARIS_PID,      0,      "Corsair MM800 RGB Polaris"         }
 };

 /******************************************************************************************\
@@ -135,33 +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;
        }
    }
-}   /* DetectCorsairPeripheralControllers() */
-
-REGISTER_DETECTOR("Corsair Peripheral", DetectCorsairPeripheralControllers);
+}
@@ -1,4 +1,3 @@
-#include "Detector.h"
 #include "CorsairVengeanceController.h"
 #include "RGBController.h"
 #include "RGBController_CorsairVengeance.h"
@@ -123,6 +122,4 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
        }
    }

-}   /* DetectCorsairVengeanceControllers() */
-
-REGISTER_I2C_DETECTOR("Corsair Vengeance", DetectCorsairVengeanceControllers);
+}   /* DetectCorsairVengeanceControllers() */
@@ -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;
@@ -1,4 +1,3 @@
-#include "Detector.h"
 #include "CorsairVengeanceProController.h"
 #include "RGBController.h"
 #include "RGBController_CorsairVengeancePro.h"
@@ -7,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

 /******************************************************************************************\
 *                                                                                          *
@@ -42,7 +50,7 @@ bool TestForCorsairVengeanceProController(i2c_smbus_interface* bus, unsigned cha
        }
    }

-    std::this_thread::sleep_for(10ms);
+    Sleep(10);
    
    return(pass);

@@ -131,6 +139,4 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
        }
    }

-}   /* DetectCorsairVengeanceProControllers() */
-
-REGISTER_I2C_DETECTOR("Corsair Vengeance Pro", DetectCorsairVengeanceProControllers);
+}   /* DetectCorsairVengeanceProControllers() */
@@ -1,4 +1,3 @@
-#include "Detector.h"
 #include "CrucialController.h"
 #include "RGBController.h"
 #include "RGBController_Crucial.h"
@@ -87,5 +86,3 @@ void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses, std::ve
    }

 }   /* DetectCrucialControllers() */
-
-REGISTER_I2C_DETECTOR("Crucial", DetectCrucialControllers);
@@ -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);
-}
@@ -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();
-};
@@ -1,84 +0,0 @@
-#include "Detector.h"
-#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;
-        }
-    }
-}   /* DetectDuckyKeyboardControllers() */
-
-REGISTER_DETECTOR("Ducky Keyboard", DetectDuckyKeyboardControllers);
@@ -1,130 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  EKController.cpp                                                   |
-|                                                                     |
-|  Driver for EK Loop Connect                                         |
-|                                                                     |
-|  Chris M (Dr_No)          16th Jul 2020                             |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#include "EKController.h"
-
-static unsigned char colour_mode_data[][16] =
-{
-    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
-      0x00, 0x10, 0x20, 0x01, 0x01, 0x00, 0xFF, 0x64},          // Static
-    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
-      0x00, 0x10, 0x20, 0x01, 0x02, 0x00, 0xFF, 0x64},          // Breathing
-    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
-      0x00, 0x10, 0x20, 0x01, 0x03, 0xFF, 0xFF, 0x64},          // Fading
-    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
-      0x00, 0x10, 0x20, 0x01, 0x04, 0x00, 0xFF, 0x64},          // Marquee
-    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
-      0x00, 0x10, 0x20, 0x01, 0x05, 0x00, 0xFF, 0x64},          // Covering Marquee
-    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
-      0x00, 0x10, 0x20, 0x01, 0x06, 0x00, 0xFF, 0x64},          // Pulse
-    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
-      0x00, 0x10, 0x20, 0x01, 0x07, 0x00, 0xFF, 0x64},          // Wave
-    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
-      0x00, 0x10, 0x20, 0x01, 0x08, 0x00, 0xFF, 0x64},          // Alternating
-    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
-      0x00, 0x10, 0x20, 0x01, 0x09, 0x00, 0xFF, 0x64},          // Candle
-};
-
-static unsigned char speed_mode_data[][9] =
-{
-    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   // Static
-    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 },   // Breathing
-    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 },   // Fading
-    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 },   // Marquee
-    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 },   // Covering Marquee
-    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 },   // Pulse
-    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 },   // Wave
-    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 },   // Alternating
-    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 }    // Candle
-};
-
-EKController::EKController(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path)
-{
-    std::size_t tmp_size = wcslen(_vendor);
-
-    dev = dev_handle;
-
-    for(std::size_t i = 0; (i < tmp_size) && (i < EK_DEVICE_NAME_SIZE); i++)
-    {
-        device_name[i] = (char)_vendor[i];
-    }
-
-    for(std::size_t j = 0; (j < wcslen(_vendor)) && ((tmp_size + j) < EK_DEVICE_NAME_SIZE); j++)
-    {
-        device_name[tmp_size + j] = (char)_device_name[j];
-    }
-
-    location = _path;
-
-    current_mode  = EK_MODE_STATIC;
-    current_speed = EK_SPEED_NORMAL;
-}
-
-EKController::~EKController()
-{
-    if(dev)
-    {
-        hid_close(dev);
-    }
-}
-
-char* EKController::GetDeviceName()
-{
-    return device_name;
-}
-
-char* EKController::GetSerial()
-{
-    return serial;
-}
-
-std::string EKController::GetLocation()
-{
-    return location;
-}
-
-void EKController::SetMode(unsigned char mode, unsigned char speed)
-{
-    current_mode  = mode;
-    current_speed = speed;
-
-    SendUpdate();
-}
-
-void EKController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
-{
-    current_red   = red;
-    current_green = green;
-    current_blue  = blue;
-
-    SendUpdate();
-}
-
-void EKController::SendUpdate()
-{
-    unsigned char buffer[EK_PACKET_LENGTH] = { 0x00 };
-    int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
-
-    for(std::size_t i = 0; i < EK_COLOUR_MODE_DATA_SIZE; i++)
-    {
-        buffer[i] = colour_mode_data[current_mode][i];
-    }
-
-    //Set the relevant colour info
-    buffer[EK_RED_BYTE]   = current_red;
-    buffer[EK_GREEN_BYTE] = current_green;
-    buffer[EK_BLUE_BYTE]  = current_blue;
-    buffer[EK_SPEED_BYTE] = speed_mode_data[current_mode][current_speed];
-
-    buffer[10] = 0x10;
-    buffer[47] = 0xFF;
-    buffer[48] = 0x00;
-
-    hid_write(dev, buffer, buffer_size);
-}
@@ -1,84 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  EKController.h                                                     |
-|                                                                     |
-|  Driver for EK Loop Connect                                         |
-|                                                                     |
-|  Chris M (Dr_No)          16th Jul 2020                             |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#ifndef EKCONTROLLER_H
-#define EKCONTROLLER_H
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#define EK_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
-#define EK_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
-#define EK_PACKET_LENGTH    0x3F
-
-enum
-{
-    EK_MODE_BYTE   = 12,
-    EK_SPEED_BYTE  = 14,
-    EK_RED_BYTE    = 16,
-    EK_GREEN_BYTE  = 17,
-    EK_BLUE_BYTE   = 18
-};
-
-enum
-{
-    EK_MODE_STATIC              = 0x00,                         //Static Mode
-    EK_MODE_BREATHING           = 0x01,                         //Breathing Mode
-    EK_MODE_FADING              = 0x02,                         //Fading Mode
-    EK_MODE_MARQUEE             = 0x03,                         //Marquee Mode
-    EK_MODE_COVERING_MARQUEE    = 0x04,                         //Covering Marquee Mode
-    EK_MODE_PULSE               = 0x05,                         //Pulse Mode
-    EK_MODE_SPECTRUM_WAVE       = 0x06,                         //Spectrum Wave Mode
-    EK_MODE_ALTERNATING         = 0x07,                         //Alternating Mode
-    EK_MODE_CANDLE              = 0x08                          //Candle Mode
-};
-
-enum
-{
-    EK_SPEED_SLOWEST              = 0x00, // Slowest speed
-    EK_SPEED_SLOWER               = 0x01, // Slower speed
-    EK_SPEED_SLOW                 = 0x02, // Slow speed
-    EK_SPEED_SLOWISH              = 0x03, // Slowish speed
-    EK_SPEED_NORMAL               = 0x04, // Normal speed
-    EK_SPEED_FASTISH              = 0x05, // Fastish speed
-    EK_SPEED_FAST                 = 0x06, // Fast speed
-    EK_SPEED_FASTER               = 0x07, // Faster speed
-    EK_SPEED_FASTEST              = 0x08, // Fastest speed
-};
-
-class EKController
-{
-public:
-    EKController(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path);
-    ~EKController();
-
-    char* GetDeviceName();
-    char* GetSerial();
-    std::string GetLocation();
-
-    void SetMode(unsigned char mode, unsigned char speed);
-    void SetColor(unsigned char red, unsigned char green, unsigned char blue);
-
-private:
-    char                    device_name[32];
-    char                    serial[32];
-    std::string             location;
-    hid_device*             dev;
-
-    unsigned char           current_mode;
-    unsigned char           current_speed;
-
-    unsigned char           current_red;
-    unsigned char           current_green;
-    unsigned char           current_blue;
-
-    void SendUpdate();
-};
-
-#endif // EKCONTROLLER_H
@@ -1,67 +0,0 @@
-#include "Detector.h"
-#include "EKController.h"
-#include "RGBController.h"
-#include "RGBController_EKController.h"
-#include <hidapi/hidapi.h>
-
-#define EK_VID                0x0483
-
-#define EK_LOOP_CONNECT       0x5750
-
-#define EK_NUM_DEVICES (sizeof(ek_pids) / sizeof(ek_pids[ 0 ]))
-
-enum
-{
-    EK_PID = 0,
-    EK_INTERFACE = 1
-};
-
-static const unsigned int ek_pids[][2] =
-{  // PID,      Interface
-    { EK_LOOP_CONNECT,        0x00 }     //EK Loop Connect
-};
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectEKControllers                                                                    *
-*                                                                                          *
-*       Tests the USB address to see if any EK Controllers exists there.                   *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectEKControllers(std::vector<RGBController*>& rgb_controllers)
-{
-    hid_device_info* info = NULL;
-
-    //Look for the passed in cm_pids
-    hid_init();
-    info = hid_enumerate(EK_VID, 0x0);
-
-    while(info)
-    {
-        hid_device* dev = NULL;
-        if(info->vendor_id == EK_VID)
-        {
-            for(unsigned int ek_pid_idx = 0; ek_pid_idx < EK_NUM_DEVICES; ek_pid_idx++)
-            {
-                if((info->product_id        == ek_pids[ek_pid_idx][EK_PID])
-                 &&(info->interface_number  == ek_pids[ek_pid_idx][EK_INTERFACE]))
-                {
-                    dev = hid_open_path(info->path);
-                    break;
-                }
-            }
-        }
-
-        if(dev)
-        {
-            EKController* controller = new EKController(dev, info->manufacturer_string, info->product_string, info->path);
-            RGBController_EKController* rgb_controller = new RGBController_EKController(controller);
-            rgb_controllers.push_back(rgb_controller);
-        }
-        info = info->next;
-    }
-    hid_free_enumeration(info);
-}   /* DetectEKControllers() */
-
-REGISTER_DETECTOR("EK", DetectEKControllers);
@@ -1,106 +0,0 @@
-/*-----------------------------------------*\
-|  GalaxGPUController.cpp                   |
-|                                           |
-|  Driver for Galax / KFA2 RGB on GPUs      |
-|                                           |
-|  Niels Westphal (crashniels)  12.07.2020  |
-\*-----------------------------------------*/
-
-#include "GalaxGPUController.h"
-#include <cstring>
-
-GalaxGPUController::GalaxGPUController(i2c_smbus_interface* bus, galax_gpu_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-
-    strcpy(device_name, "Galax RTX GPU");                                               // Would be nice to get the actual GPU name. Using this as a placeholder.
-}
-
-GalaxGPUController::~GalaxGPUController()
-{
-
-}
-
-std::string GalaxGPUController::GetDeviceName()
-{
-    return(device_name);
-}
-
-std::string GalaxGPUController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return(return_string);
-}
-
-unsigned char GalaxGPUController::GetLEDRed()
-{
-    return(GalaxGPURegisterRead(GALAX_RED_REGISTER));
-}
-
-unsigned char GalaxGPUController::GetLEDGreen()
-{
-    return(GalaxGPURegisterRead(GALAX_GREEN_REGISTER));
-}
-
-unsigned char GalaxGPUController::GetLEDBlue()
-{
-    return(GalaxGPURegisterRead(GALAX_BLUE_REGISTER));
-}
-
-void GalaxGPUController::SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue)                  // Direct Mode is just Static Mode without applying color changes
-{
-    GalaxGPURegisterWrite(GALAX_RED_REGISTER, red);
-    GalaxGPURegisterWrite(GALAX_GREEN_REGISTER, green);
-    GalaxGPURegisterWrite(GALAX_BLUE_REGISTER, blue);
-}
-
-void GalaxGPUController::SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
-{
-    GalaxGPURegisterWrite(GALAX_RED_REGISTER, red);
-    GalaxGPURegisterWrite(GALAX_GREEN_REGISTER, green);
-    GalaxGPURegisterWrite(GALAX_BLUE_REGISTER, blue);
-}
-
-void GalaxGPUController::SetMode(unsigned char mode)
-{
-    switch(mode)
-    {
-    case 1:
-        GalaxGPURegisterWrite(GALAX_MODE_REGISTER_1, GALAX_MODE_STATIC_VALUE_1);
-        GalaxGPURegisterWrite(GALAX_MODE_REGISTER_2, GALAX_MODE_STATIC_VALUE_2);
-        break;
-
-    case 2:
-        GalaxGPURegisterWrite(GALAX_MODE_REGISTER_1, GALAX_MODE_BREATHING_VALUE_1);
-        GalaxGPURegisterWrite(GALAX_MODE_REGISTER_2, GALAX_MODE_BREATHING_VALUE_2);
-        break;
-
-    case 3:
-        GalaxGPURegisterWrite(GALAX_MODE_REGISTER_1, GALAX_MODE_RAINBOW_VALUE_1);
-        GalaxGPURegisterWrite(GALAX_MODE_REGISTER_2, GALAX_MODE_RAINBOW_VALUE_2);
-        break;
-
-    case 4:
-        GalaxGPURegisterWrite(GALAX_MODE_REGISTER_1, GALAX_MODE_CYCLE_BREATHING_VALUE_1);
-        GalaxGPURegisterWrite(GALAX_MODE_REGISTER_2, GALAX_MODE_CYCLE_BREATHING_VALUE_2);
-        break;
-
-    default:
-        break;
-    }
-}
-
-unsigned char GalaxGPUController::GalaxGPURegisterRead(unsigned char reg)
-{
-    return(bus->i2c_smbus_read_byte_data(dev, reg));
-}
-
-void GalaxGPUController::GalaxGPURegisterWrite(unsigned char reg, unsigned char val)
-{
-    bus->i2c_smbus_write_byte_data(dev, reg, val);
-}
@@ -1,67 +0,0 @@
-/*-----------------------------------------*\
-|  GalaxGPUController.h                     |
-|                                           |
-|  Driver for Galax / KFA2 RGB on GPUs      |
-|                                           |
-|  Niels Westphal (crashniels)  12.07.2020  |
-\*-----------------------------------------*/
-
-#include <string>
-#include "i2c_smbus.h"
-
-#pragma once
-
-typedef unsigned char galax_gpu_dev_id;
-
-enum
-{
-    /* RGB Registers */
-    GALAX_RED_REGISTER                      = 0x02, /* Red Register */
-    GALAX_GREEN_REGISTER                    = 0x03, /* Green Register */
-    GALAX_BLUE_REGISTER                     = 0x04, /* Blue Register */
-    /* MODE Registers */
-    GALAX_MODE_REGISTER_1                   = 0x05, /* Mode Register 1 */
-    GALAX_MODE_REGISTER_2                   = 0x06, /* Mode Register 2 */
-};
-
-enum
-{
-    /* Static Mode Values */
-    GALAX_MODE_STATIC_VALUE_1               = 0x00,
-    GALAX_MODE_STATIC_VALUE_2               = 0x01,
-    /* Breathing Mode Values */
-    GALAX_MODE_BREATHING_VALUE_1            = 0x04,
-    GALAX_MODE_BREATHING_VALUE_2            = 0x00,
-    /* Rainbow Mode Values */
-    GALAX_MODE_RAINBOW_VALUE_1              = 0x84,
-    GALAX_MODE_RAINBOW_VALUE_2              = 0x02,
-    /* Cycle Breathing Mode Values */
-    GALAX_MODE_CYCLE_BREATHING_VALUE_1      = 0x84,
-    GALAX_MODE_CYCLE_BREATHING_VALUE_2      = 0x40,
-};
-
-class GalaxGPUController
-{
-public:
-    GalaxGPUController(i2c_smbus_interface* bus, galax_gpu_dev_id);
-    ~GalaxGPUController();
-
-    std::string   GetDeviceName();
-    std::string   GetDeviceLocation();
-    unsigned char GetLEDRed();
-    unsigned char GetLEDGreen();
-    unsigned char GetLEDBlue();
-    void          SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue);
-    void          SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue);
-    void          SetMode(unsigned char mode);
-
-    unsigned char GalaxGPURegisterRead(unsigned char reg);
-    void          GalaxGPURegisterWrite(unsigned char reg, unsigned char val);
-
-    bool          direct = false;                                                // Temporary solution to check if we are in "Direct" mode
-
-private:
-    char                    device_name[16];
-    i2c_smbus_interface *   bus;
-    galax_gpu_dev_id        dev;
-};
@@ -1,71 +0,0 @@
-/*-----------------------------------------*\
-|  GalaxGPUControllerDetect.cpp             |
-|                                           |
-|  Driver for Galax / KFA2 RGB on GPUs      |
-|                                           |
-|  Niels Westphal (crashniels)  12.07.2020  |
-\*-----------------------------------------*/
-
-#include "Detector.h"
-#include "GalaxGPUController.h"
-#include "RGBController.h"
-#include "RGBController_GalaxGPU.h"
-#include "i2c_smbus.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-using namespace std::chrono_literals;
-
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForGalaxGPUController                                                              *
-*                                                                                          *
-*       Tests the given address to see if a Galax GPU controller exists there.             *
-*                                                                                          *
-\******************************************************************************************/
-
-bool TestForGalaxGPUController(i2c_smbus_interface* bus, unsigned char address)
-{
-    bool pass = false;
-
-    unsigned char res  = bus->i2c_smbus_read_byte_data(address, 0x00);
-    unsigned char res2 = bus->i2c_smbus_read_byte_data(address, 0x01);
-    if(res == 0x27 && res2 == 0x10)
-    {
-        pass = true;
-    }
-
-    return(pass);
-
-}   /* TestForGalaxGPUController() */
-
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectGalaxGPUControllers                                                              *
-*                                                                                          *
-*       Detect Galax GPU controllers on the enumerated I2C busses.                         *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectGalaxGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
-{
-    GalaxGPUController* new_GalaxGPU;
-    RGBController_GalaxGPU* new_controller;
-
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        // Check for GALAX controller at 0x23
-        if (TestForGalaxGPUController(busses[bus], 0x23))
-        {
-            new_GalaxGPU = new GalaxGPUController(busses[bus], 0x23);
-            new_controller = new RGBController_GalaxGPU(new_GalaxGPU);
-            rgb_controllers.push_back(new_controller);
-        }
-    }
-
-} /* DetectGalaxGPUControllers() */
-
-REGISTER_I2C_DETECTOR("Galax GPU", DetectGalaxGPUControllers);
@@ -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);
-}
@@ -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;
-
-};
@@ -1,60 +0,0 @@
-#include "Detector.h"
-#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();
-    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);
-    }
-}   /* DetectGloriousModelOControllers() */
-
-REGISTER_DETECTOR("Glorious Model O", DetectGloriousModelOControllers);
@@ -1,87 +0,0 @@
-/*-----------------------------------------------*\
-|  HoltekA070Controller.cpp                       |
-|                                                 |
-|  Driver for Holtek USB Gaming Mouse [04d9:a070] |
-|                                                 |
-|  Santeri Pikarinen (santeri3700) 8/01/2020      |
-\*-----------------------------------------------*/
-
-#include "HoltekA070Controller.h"
-
-#include <cstring>
-
-HoltekA070Controller::HoltekA070Controller(hid_device* dev_handle)
-{
-    dev = dev_handle;
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void HoltekA070Controller::SendCustomColor
-    (
-    unsigned char       red,
-    unsigned char       green,
-    unsigned char       blue
-    )
-{
-    char usb_buf[8];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up RGB Control packet                             |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x07;  // PACKET SIZE?
-    usb_buf[0x01]           = 0x0a;  // SET RGB
-    usb_buf[0x02]           = 0x00;  // SAVE (does not work with SET RGB)
-    usb_buf[0x03]           = red;   // RED
-    usb_buf[0x04]           = green; // GREEN
-    usb_buf[0x05]           = blue;  // BLUE
-    usb_buf[0x06]           = 0x00;  // PADDING?
-    usb_buf[0x07]           = 0x00;  // PADDING?
-
-    // So far no saving function has been discovered for the "SET RGB" command.
-    // Such functionality might not even exist for the A070 series.
-    // The chosen RGB color will therefore reset after a power cycle.
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, (unsigned char *)usb_buf, sizeof(usb_buf));
-}
-
-void HoltekA070Controller::SendMode
-    (
-    unsigned char       mode
-    )
-{
-
-    char usb_buf[8];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up lighting mode control packet                   |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x07; // PACKET SIZE?
-    usb_buf[0x01]           = 0x0b; // SET LIGHTING MODE
-    usb_buf[0x02]           = 0x01; // SAVE
-    usb_buf[0x03]           = mode; // MODE 01-04
-    usb_buf[0x04]           = 0x00; // PADDING?
-    usb_buf[0x05]           = 0x00; // PADDING?
-    usb_buf[0x06]           = 0x00; // PADDING?
-    usb_buf[0x07]           = 0x00; // PADDING?
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, (unsigned char *)usb_buf, sizeof(usb_buf));
-}
@@ -1,44 +0,0 @@
-/*---------------------------------------------------------------*\
-|  HoltekA070Controller.h                                         |
-|                                                                 |
-|  Definitions and types for Holtek USB Gaming Mouse [04d9:a070]  |
-|                                                                 |
-|  Santeri Pikarinen (santeri3700) 8/01/2020                      |
-\*---------------------------------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    HOLTEK_A070_MODE_STATIC            = 0x01,
-    HOLTEK_A070_MODE_BREATHING_SLOW    = 0x02,
-    HOLTEK_A070_MODE_BREATHING_MEDIUM  = 0x03,
-    HOLTEK_A070_MODE_BREATHING_FAST    = 0x04
-};
-
-class HoltekA070Controller
-{
-public:
-    HoltekA070Controller(hid_device* dev_handle);
-    ~HoltekA070Controller();
-
-    void        SendCustomColor
-                   (
-                   unsigned char       red,
-                   unsigned char       green,
-                   unsigned char       blue
-                   );
-
-    void        SendMode
-                   (
-                   unsigned char       mode
-                   );
-
-private:
-    hid_device*             dev;
-};
@@ -1,89 +0,0 @@
-#include "Detector.h"
-#include "HoltekA070Controller.h"
-#include "RGBController.h"
-#include "RGBController_HoltekA070.h"
-#include <vector>
-#include <hidapi/hidapi.h>
-
-/*-----------------------------------------------------*\
-| Holtek Semiconductor Inc. vendor ID                   |
-\*-----------------------------------------------------*/
-#define HOLTEK_VID                    0x04D9
-/*-----------------------------------------------------*\
-| Mouse product IDs                                     |
-\*-----------------------------------------------------*/
-#define HOLTEK_A070_PID               0xA070
-
-typedef struct
-{
-    unsigned short  usb_vid;
-    unsigned short  usb_pid;
-    unsigned char   usb_interface;
-    device_type     type;
-    const char *    name;
-} holtek_device;
-
-#define HOLTEK_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const holtek_device device_list[] =
-{
-    /*-------------------------------------------------------------------------------------------------------------*\
-    | Mice                                                                                                          |
-    \*-------------------------------------------------------------------------------------------------------------*/
-    { HOLTEK_VID,             HOLTEK_A070_PID,      1,  DEVICE_TYPE_MOUSE,      "Holtek USB Gaming Mouse"         },
-};
-
-void DetectHoltekControllers(std::vector<RGBController*>& rgb_controllers)
-{
-    hid_init();
-
-    for(unsigned int device_idx = 0; device_idx < HOLTEK_NUM_DEVICES; device_idx++)
-    {
-        switch(device_list[device_idx].type)
-        {
-        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 HOLTEK_A070_PID:
-                                {
-                                    HoltekA070Controller* controller = new HoltekA070Controller(dev);
-
-                                    RGBController_HoltekA070* rgb_controller = new RGBController_HoltekA070(controller);
-
-                                    rgb_controller->name = device_list[device_idx].name;
-                                    rgb_controllers.push_back(rgb_controller);
-                                }
-                                break;
-                            }
-                        }
-                    }
-                    info = info->next;
-                }
-                hid_free_enumeration(info);
-            }
-            break;
-        }
-
-    }
-}   /* DetectHoltekControllers() */
-
-REGISTER_DETECTOR("Holtek", DetectHoltekControllers);
@@ -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(unsigned 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(unsigned 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);
 }
@@ -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();
 };
@@ -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() */
@@ -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);
 }
@@ -1,4 +1,3 @@
-#include "Detector.h"
 #include "HuePlusController.h"
 #include "RGBController.h"
 #include "RGBController_HuePlus.h"
@@ -18,23 +17,16 @@

 void DetectHuePlusControllers(std::vector<RGBController*> &rgb_controllers)
 {
-    size_t i;
    HuePlusController* new_hueplus;
    RGBController_HuePlus* new_controller;

-    std::vector<std::string *> ports = find_usb_serial_port(NZXT_HUE_PLUS_VID, NZXT_HUE_PLUS_PID);
-
-    for (i = 0; i < ports.size(); i++)
+    std::string portname = find_usb_serial_port(NZXT_HUE_PLUS_VID, NZXT_HUE_PLUS_PID);
+    if( portname != "" )
    {
-        if( *ports[i] != "" )
-        {
-            new_hueplus = new HuePlusController();
-            new_hueplus->Initialize((char *)ports[i]->c_str());
+        new_hueplus = new HuePlusController();
+        new_hueplus->Initialize((char *)portname.c_str());

-            new_controller = new RGBController_HuePlus(new_hueplus);
-            rgb_controllers.push_back(new_controller);
-        }
+        new_controller = new RGBController_HuePlus(new_hueplus);
+        rgb_controllers.push_back(new_controller);
    }
 }   /* DetectHuePlusControllers() */
-
-REGISTER_DETECTOR("NZXT Hue+", DetectHuePlusControllers);
@@ -188,8 +188,8 @@ enum
 static const unsigned char slot_base[4] =
 {
    HYPERX_REG_SLOT0_LED0_RED,                      /* SPD 0x50 maps to slot 0              */
-    HYPERX_REG_SLOT2_LED0_RED,                      /* SPD 0x51 maps to slot 2              */
-    HYPERX_REG_SLOT1_LED0_RED,                      /* SPD 0x52 maps to slot 1              */
+    HYPERX_REG_SLOT1_LED0_RED,                      /* SPD 0x51 maps to slot 1              */
+    HYPERX_REG_SLOT2_LED0_RED,                      /* SPD 0x52 maps to slot 2              */
    HYPERX_REG_SLOT3_LED0_RED                       /* SPD 0x53 maps to slot 3              */
 };

@@ -1,4 +1,3 @@
-#include "Detector.h"
 #include "HyperXDRAMController.h"
 #include "RGBController.h"
 #include "RGBController_HyperXDRAM.h"
@@ -7,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

 /******************************************************************************************\
 *                                                                                          *
@@ -68,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++)
            {
@@ -81,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)
@@ -94,5 +102,3 @@ void DetectHyperXDRAMControllers(std::vector<i2c_smbus_interface*> &busses, std:
    }

 }   /* DetectHyperXDRAMControllers() */
-
-REGISTER_I2C_DETECTOR("HyperX DRAM", DetectHyperXDRAMControllers);
@@ -1,131 +0,0 @@
-/*-----------------------------------------*\
-|  HyperXAlloyOriginsController.cpp         |
-|                                           |
-|  Driver for HyperX Alloy Origins RGB      |
-|  Keyboard lighting controller             |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 7/11/2020   |
-\*-----------------------------------------*/
-
-#include "HyperXAlloyOriginsController.h"
-
-#include <cstring>
-
-// Skip these indices in the color output
-static unsigned int skip_idx[] = { 6, 23, 29, 41, 47, 59, 70, 71, 75, 76, 87, 88, 93, 99, 100, 102, 108, 113, 114, 120, 123, 124 };
-
-HyperXAlloyOriginsController::HyperXAlloyOriginsController(hid_device* dev_handle)
-{
-    dev = dev_handle;
-}
-
-HyperXAlloyOriginsController::~HyperXAlloyOriginsController()
-{
-
-}
-
-void HyperXAlloyOriginsController::SetLEDsDirect(std::vector<RGBColor> colors)
-{
-    /*-----------------------------------------------------*\
-    | Insert color data for unused positions                |
-    \*-----------------------------------------------------*/
-    for(unsigned int skip_cnt = 0; skip_cnt < (sizeof(skip_idx) / sizeof(skip_idx[0])); skip_cnt++)
-    {
-        colors.insert(colors.begin() + skip_idx[skip_cnt], 0x00000000);
-    }
-
-    /*-----------------------------------------------------*\
-    | Set up variables to track progress of color transmit  |
-    | Do this after inserting blanks                        |
-    \*-----------------------------------------------------*/
-    int colors_to_send = colors.size();
-    int colors_sent    = 0;
-
-    SendDirectInitialization();
-
-    for(int pkt_idx = 0; pkt_idx < 9; pkt_idx++)
-    {
-        if(colors_to_send > 16)
-        {
-            SendDirectColorPacket(&colors[colors_sent], 16);
-            colors_sent    += 16;
-            colors_to_send -= 16;
-        }
-        else if(colors_to_send > 0)
-        {
-            SendDirectColorPacket(&colors[colors_sent], colors_to_send);
-            colors_sent    += colors_to_send;
-            colors_to_send -= colors_to_send;
-        }
-        else
-        {
-            RGBColor temp = 0x00000000;
-            SendDirectColorPacket(&temp, 1);
-        }
-    }
-}
-
-void HyperXAlloyOriginsController::SendDirectInitialization()
-{
-    unsigned char buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Direct Initialization packet                   |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x00;
-    buf[0x01]   = 0x04;
-    buf[0x02]   = 0xF2;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 65);
-}
-
-void HyperXAlloyOriginsController::SendDirectColorPacket
-    (
-    RGBColor*       color_data,
-    unsigned int    color_count
-    )
-{
-    unsigned char buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Direct Initialization packet                   |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x00;
-
-    /*-----------------------------------------------------*\
-    | The maximum number of colors per packet is 16         |
-    \*-----------------------------------------------------*/
-    if(color_count > 16)
-    {
-        color_count = 16;
-    }
-
-    /*-----------------------------------------------------*\
-    | Copy in color data                                    |
-    \*-----------------------------------------------------*/
-    for(unsigned int color_idx = 0; color_idx < color_count; color_idx++)
-    {
-        buf[(color_idx * 4) + 1] = 0x81;
-        buf[(color_idx * 4) + 2] = RGBGetRValue(color_data[color_idx]);
-        buf[(color_idx * 4) + 3] = RGBGetGValue(color_data[color_idx]);
-        buf[(color_idx * 4) + 4] = RGBGetBValue(color_data[color_idx]);
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 65);
-}
@@ -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
-                );
-};
@@ -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,7 +153,7 @@ void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
        blu_color_data
        );

-    std::this_thread::sleep_for(5ms);
+    Sleep(5);

    SendDirectExtended
        (
@@ -154,12 +163,12 @@ void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)

 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];
    }
@@ -401,7 +410,7 @@ void HyperXKeyboardController::SendExtendedColor
    /*-----------------------------------------------------*\
    | Fill in color data                                    |
    \*-----------------------------------------------------*/
-    for(int i = 0x08; i < 0x94; i++)
+    for(int i = 0x08; i <= 0x93; i++)
    {
        buf[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,12 +473,11 @@ 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                                    |
    \*-----------------------------------------------------*/
-    for(int i = 0x08; i < 0x94; i++)
+    for(int i = 0x08; i <= 0x93; i++)
    {
        buf[i] = color_data[i];
    }
@@ -1,41 +1,11 @@
-#include "Detector.h"
-#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
-#define HYPERX_ALLOY_ORIGINS_CORE_PID   0x16E6
-
-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"                      },
-    { HYPERX_KEYBOARD_VID,  HYPERX_ALLOY_ORIGINS_CORE_PID,  3,  "HyperX Alloy Origins Core"                 },
-};
+#define HYPERX_KEYBOARD_VID         0x0951
+#define HYPERX_ALLOY_ELITE_PID      0x16BE

 /******************************************************************************************\
 *                                                                                          *
@@ -52,61 +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;
        }
    }
-}   /* DetectHyperXKeyboardControllers() */

-REGISTER_DETECTOR("HyperX Keyboard", DetectHyperXKeyboardControllers);
+    if( dev )
+    {
+        HyperXKeyboardController* controller = new HyperXKeyboardController(dev);
+
+        RGBController_HyperXKeyboard* rgb_controller = new RGBController_HyperXKeyboard(controller);
+
+        rgb_controllers.push_back(rgb_controller);
+    }
+}
@@ -1,84 +0,0 @@
-#include "Detector.h"
-#include "HyperXPulsefireSurgeController.h"
-#include "RGBController.h"
-#include "RGBController_HyperXPulsefireSurge.h"
-#include <vector>
-#include <hidapi/hidapi.h>
-
-/*-----------------------------------------------------*\
-| HyperX keyboard vendor IDs                            |
-\*-----------------------------------------------------*/
-#define HYPERX_VID                  0x0951
-#define HYPERX_PULSEFIRE_SURGE_PID  0x16D3
-
-typedef struct
-{
-    unsigned short  usb_vid;
-    unsigned short  usb_pid;
-    unsigned char   usb_interface;
-    const char *    name;
-} hyperx_device;
-
-#define HYPERX_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const hyperx_device device_list[] =
-{
-    /*-----------------------------------------------------------------------------------------------------*\
-    | Mice                                                                                                  |
-    \*-----------------------------------------------------------------------------------------------------*/
-    { HYPERX_VID,           HYPERX_PULSEFIRE_SURGE_PID, 1,      "HyperX Pulsefire Surge"                    },
-};
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectHyperXMouseControllers                                                           *
-*                                                                                          *
-*       Tests the USB address to see if a HyperX Mouse controller exists there.            *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectHyperXMouseControllers(std::vector<RGBController*>& rgb_controllers)
-{
-    hid_device_info* info;
-    hid_device* dev = NULL;
-
-    hid_init();
-
-    for(std::size_t device_idx = 0; device_idx < HYPERX_NUM_DEVICES; device_idx++)
-    {
-        dev = NULL;
-
-        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
-
-        //Look for HyperX RGB Peripheral
-        while(info)
-        {
-            if((info->vendor_id        == device_list[device_idx].usb_vid)
-             &&(info->product_id       == device_list[device_idx].usb_pid)
-    #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 )
-                {
-                    HyperXPulsefireSurgeController* controller = new HyperXPulsefireSurgeController(dev);
-
-                    RGBController_HyperXPulsefireSurge* rgb_controller = new RGBController_HyperXPulsefireSurge(controller);
-
-                    rgb_controller->name = device_list[device_idx].name;
-                    
-                    rgb_controllers.push_back(rgb_controller);
-                }
-            }
-
-            info = info->next;
-        }
-    }
-}   /* DetectHyperXMouseControllers() */
-
-REGISTER_DETECTOR("HyperX Mouse", DetectHyperXMouseControllers);
@@ -1,125 +0,0 @@
-/*-----------------------------------------*\
-|  HyperXPulsefireSurgeController.cpp       |
-|                                           |
-|  Driver for HyperX Pulsefire Surge        |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 7/25/2020   |
-\*-----------------------------------------*/
-
-#include "HyperXPulsefireSurgeController.h"
-
-#include <cstring>
-
-HyperXPulsefireSurgeController::HyperXPulsefireSurgeController(hid_device* dev_handle)
-{
-    dev = dev_handle;
-}
-
-HyperXPulsefireSurgeController::~HyperXPulsefireSurgeController()
-{
-
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void HyperXPulsefireSurgeController::SelectProfile
-    (
-    unsigned char   profile
-    )
-{
-    unsigned char buf[264];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Select Profile packet                          |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x07;
-    buf[0x01]   = HYPERX_PULSEFIRE_SURGE_PACKET_ID_SELECT_PROFILE;
-    buf[0x02]   = profile;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 264);
-}
-
-void HyperXPulsefireSurgeController::SetProfileBrightness
-    (
-    unsigned char   profile,
-    unsigned char   brightness
-    )
-{
-    unsigned char buf[264];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Select Profile packet                          |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x07;
-    buf[0x01]   = HYPERX_PULSEFIRE_SURGE_PACKET_ID_SET_BRIGHTNESS;
-    buf[0x02]   = profile;
-    buf[0x03]   = 0x01;
-    buf[0x04]   = 0x01;
-    buf[0x05]   = 0x01;
-    buf[0x06]   = brightness;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 264);
-}
-
-void HyperXPulsefireSurgeController::SendDirect
-    (
-    RGBColor*       color_data
-    )
-{
-    unsigned char buf[264];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Select Profile packet                          |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x07;
-    buf[0x01]   = HYPERX_PULSEFIRE_SURGE_PACKET_ID_DIRECT;
-    buf[0x03]   = 0xA0;
-
-    for(int red_idx = 0; red_idx < 32; red_idx++)
-    {
-        buf[0x08 + red_idx] = RGBGetRValue(color_data[red_idx]);
-    }
-
-    for(int grn_idx = 0; grn_idx < 32; grn_idx++)
-    {
-        buf[0x28 + grn_idx] = RGBGetGValue(color_data[grn_idx]);
-    }
-
-    for(int blu_idx = 0; blu_idx < 32; blu_idx++)
-    {
-        buf[0x48 + blu_idx] = RGBGetBValue(color_data[blu_idx]);
-    }
-
-    buf[0x6C] = RGBGetRValue(color_data[32]);
-    buf[0x6D] = RGBGetGValue(color_data[32]);
-    buf[0x6E] = RGBGetBValue(color_data[32]);
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 264);
-}
@@ -1,58 +0,0 @@
-/*-----------------------------------------*\
-|  HyperXPulsefireSurgeController.h         |
-|                                           |
-|  Definitions and types for HyperX         |
-|  Pulsefire Surge lighting controller      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 7/25/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    HYPERX_PULSEFIRE_SURGE_PACKET_ID_SET_CONFIGURATION  = 0x01,     /* Set profile configuration packet     */
-    HYPERX_PULSEFIRE_SURGE_PACKET_ID_SET_BRIGHTNESS     = 0x03,     /* Set profile settings and brightness  */
-    HYPERX_PULSEFIRE_SURGE_PACKET_ID_SELECT_PROFILE     = 0x07,     /* Select profile                       */
-    HYPERX_PULSEFIRE_SURGE_PACKET_ID_DIRECT             = 0x14,     /* Direct control packet                */
-};
-
-enum
-{
-    HYPERX_PULSEFIRE_SURGE_MODE_SOLID                   = 0x00,     /* Solid color mode                     */
-    HYPERX_PULSEFIRE_SURGE_MODE_CYCLE                   = 0x01,     /* Spectrum cycle mode                  */
-    HYPERX_PULSEFIRE_SURGE_MODE_BREATHING               = 0x02,     /* Breathing mode                       */
-    HYPERX_PULSEFIRE_SURGE_MODE_WAVE                    = 0x03,     /* Wave mode                            */
-    HYPERX_PULSEFIRE_SURGE_MODE_TRIGGER                 = 0x04,     /* Trigger mode                         */
-};
-
-class HyperXPulsefireSurgeController
-{
-public:
-    HyperXPulsefireSurgeController(hid_device* dev_handle);
-    ~HyperXPulsefireSurgeController();
-
-    void SelectProfile
-            (
-            unsigned char   profile
-            );
-
-    void SetProfileBrightness
-            (
-            unsigned char   profile,
-            unsigned char   brightness
-            );
-
-    void SendDirect
-            (
-            RGBColor*       color_data
-            );
-
-private:
-    hid_device*             dev;
-};
@@ -1,4 +1,3 @@
-#include "Detector.h"
 #include "LEDStripController.h"
 #include "RGBController.h"
 #include "RGBController_LEDStrip.h"
@@ -22,7 +21,7 @@
 *   DetectLEDStripControllers                                                              *
 *                                                                                          *
 *       Detect devices supported by the LEDStrip driver                                    *
-*                                                                                          *
+*                                                                                          *                                                                                          *
 \******************************************************************************************/

 void DetectLEDStripControllers(std::vector<RGBController*> &rgb_controllers)
@@ -30,11 +29,24 @@ void DetectLEDStripControllers(std::vector<RGBController*> &rgb_controllers)
    LEDStripController* new_ledstrip;
    RGBController_LEDStrip* new_controller;

+    //Get file path in executable directory
    std::ifstream infile;
+    char filename[2048];
    char arg1[64];

+#ifdef WIN32
+    GetModuleFileName(NULL, filename, 2048);
+    strcpy(filename, std::string(filename).substr(0, std::string(filename).find_last_of("\\/")).c_str());
+    strcat(filename, "\\ledstrip.txt");
+#else
+    snprintf(arg1, 64, "/proc/%d/exe", getpid());
+    readlink(arg1, filename, 1024);
+    strcpy(filename, std::string(filename).substr(0, std::string(filename).find_last_of("\\/")).c_str());
+    strcat(filename, "/ledstrip.txt");
+#endif
+
    //Open settings file
-    infile.open("ledstrip.txt");
+    infile.open(filename);

    if (infile.good())
    {
@@ -72,6 +84,5 @@ void DetectLEDStripControllers(std::vector<RGBController*> &rgb_controllers)
        }
    }

-}   /* DetectLEDStripControllers() */

-REGISTER_DETECTOR("LED Strip", DetectLEDStripControllers);
+}   /* DetectLEDStripControllers() */
@@ -1,276 +0,0 @@
-#include "Detector.h"
-#include "LogitechG203Controller.h"
-#include "LogitechG203LController.h"
-#include "LogitechG403Controller.h"
-#include "LogitechG502PSController.h"
-#include "LogitechG810Controller.h"
-#include "LogitechGProWirelessController.h"
-#include "LogitechGPowerPlayController.h"
-#include "RGBController.h"
-#include "RGBController_LogitechG203.h"
-#include "RGBController_LogitechG203L.h"
-#include "RGBController_LogitechG403.h"
-#include "RGBController_LogitechG502PS.h"
-#include "RGBController_LogitechG810.h"
-#include "RGBController_LogitechGProWireless.h"
-#include "RGBController_LogitechGPowerPlay.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
-#define LOGITECH_G512_RGB_PID                   0xC33C
-/*-----------------------------------------------------*\
-| Mouse product IDs                                     |
-\*-----------------------------------------------------*/
-#define LOGITECH_G203_PID                       0xC084
-#define LOGITECH_G203L_PID                      0xC092
-#define LOGITECH_G403_PID                       0xC083
-#define LOGITECH_G403H_PID                      0xC08F
-#define LOGITECH_G502_PS_PID                    0xC332
-#define LOGITECH_G502H_PID                      0xC08B
-#define LOGITECH_G_LIGHTSPEED_WIRELESS_PID      0xC539
-#define LOGITECH_GPRO_WIRELESS_PID              0xC088
-#define LOGITECH_G_LIGHTSPEED_POWERPLAY_PID     0xC53A
-
-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"                                     },
-    { LOGITECH_VID,             LOGITECH_G512_RGB_PID,                  1,  DEVICE_TYPE_KEYBOARD,   "Logitech G512 RGB"                                 },
-    /*-------------------------------------------------------------------------------------------------------------------------------------------------*\
-    | Mice                                                                                                                                              |
-    \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-    { LOGITECH_VID,             LOGITECH_G203_PID,                      1,  DEVICE_TYPE_MOUSE,      "Logitech G203 Prodigy"                             },
-    { LOGITECH_VID,             LOGITECH_G203L_PID,                     1,  DEVICE_TYPE_MOUSE,      "Logitech G203 Lightsync"                           },
-    { LOGITECH_VID,             LOGITECH_G403_PID,                      1,  DEVICE_TYPE_MOUSE,      "Logitech G403 Prodigy"                             },
-    { LOGITECH_VID,             LOGITECH_G403H_PID,                     1,  DEVICE_TYPE_MOUSE,      "Logitech G403 Hero"                                },
-    { LOGITECH_VID,             LOGITECH_G502_PS_PID,                   1,  DEVICE_TYPE_MOUSE,      "Logitech G502 Proteus Spectrum"                    },
-    { LOGITECH_VID,             LOGITECH_G502H_PID,                     1,  DEVICE_TYPE_MOUSE,      "Logitech G502 Hero"                                },
-    { LOGITECH_VID,             LOGITECH_G_LIGHTSPEED_WIRELESS_PID,     2,  DEVICE_TYPE_MOUSE,      "Logitech G Lightspeed Wireless Gaming Mouse"       },
-    { LOGITECH_VID,             LOGITECH_GPRO_WIRELESS_PID,             2,  DEVICE_TYPE_MOUSE,      "Logitech G Pro Wireless Gaming Mouse (Wired)"      },
-    { LOGITECH_VID,             LOGITECH_G_LIGHTSPEED_POWERPLAY_PID,    2,  DEVICE_TYPE_MOUSE,      "Logitech G Powerplay Mousepad with Lightspeed"     },
-    /*-------------------------------------------------------------------------------------------------------------------------------------------------*\
-    | 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(unsigned 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_G203L_PID:
-                                {
-                                    LogitechG203LController* controller = new LogitechG203LController(dev);
-
-                                    RGBController_LogitechG203L* rgb_controller = new RGBController_LogitechG203L(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);
-                                }
-                                break;
-
-                            case LOGITECH_G502_PS_PID:
-                            case LOGITECH_G502H_PID:
-                                {
-                                    LogitechG502PSController* controller = new LogitechG502PSController(dev);
-
-                                    RGBController_LogitechG502PS* rgb_controller = new RGBController_LogitechG502PS(controller);
-
-                                    rgb_controller->name = device_list[device_idx].name;
-                                    rgb_controllers.push_back(rgb_controller);
-                                }
-                                break;
-                            
-                            case LOGITECH_GPRO_WIRELESS_PID:
-                            case LOGITECH_G_LIGHTSPEED_WIRELESS_PID:
-                                {
-                                    LogitechGProWirelessController* controller = new LogitechGProWirelessController(dev);
-
-                                    RGBController_LogitechGProWireless* rgb_controller = new RGBController_LogitechGProWireless(controller);
-
-                                    rgb_controller->name = device_list[device_idx].name;
-                                    rgb_controllers.push_back(rgb_controller);
-                                }
-                                break;
-                            case LOGITECH_G_LIGHTSPEED_POWERPLAY_PID:
-                                {
-                                    //Add mouse
-                                    LogitechGProWirelessController* mouse_controller = new LogitechGProWirelessController(dev);
-
-                                    RGBController_LogitechGProWireless* mouse_rgb_controller = new RGBController_LogitechGProWireless(mouse_controller);
-
-                                    mouse_rgb_controller->name = device_list[device_idx].name;
-                                    rgb_controllers.push_back(mouse_rgb_controller);
-                                    
-                                    //Add Powerplay mousemat
-                                    LogitechGPowerPlayController* mousemat_controller = new LogitechGPowerPlayController(dev);
-
-                                    RGBController_LogitechGPowerPlay* mousemat_rgb_controller = new RGBController_LogitechGPowerPlay(mousemat_controller);
-
-                                    mousemat_rgb_controller->name = device_list[device_idx].name;
-                                    rgb_controllers.push_back(mousemat_rgb_controller);
-                                }
-                                break;
-                            }
-                        }
-                    }
-                    info = info->next;
-                }
-                hid_free_enumeration(info);
-            }
-            break;
-        }
-
-    }
-}   /* DetectLogitechControllers() */
-
-REGISTER_DETECTOR("Logitech", DetectLogitechControllers);
@@ -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 = 100 * 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);
-}
@@ -1,53 +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,
-};
-
-/*---------------------------------------------------------------------------------------------*\
-| Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are mutipled by 100 later to give lots of GUI steps.                                   |
-\*---------------------------------------------------------------------------------------------*/
-enum
-{
-    LOGITECH_G203_SPEED_SLOWEST          = 0xC8,    /* Slowest speed                           */
-    LOGITECH_G203_SPEED_NORMAL           = 0x32,    /* Normal speed                            */
-    LOGITECH_G203_SPEED_FASTEST          = 0x0A,    /* 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;
-};
@@ -1,140 +0,0 @@
-#include "LogitechG203LController.h"
-
-#include <cstring>
-
-LogitechG203LController::LogitechG203LController(hid_device* dev_handle)
-{
-    dev = dev_handle;
-}
-
-void LogitechG203LController::SendApply()
-{
-    unsigned char usb_buf[20];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00] = 0x11;
-    usb_buf[0x01] = 0xFF;
-    usb_buf[0x02] = 0x12;
-    usb_buf[0x03] = 0x7A;
-
-    hid_write(dev, usb_buf, 20);
-    hid_read(dev, usb_buf, 20);
-}
-
-void LogitechG203LController::SetSingleLED(int led, unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char usb_buf[20];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00] = 0x11;
-    usb_buf[0x01] = 0xFF;
-    usb_buf[0x02] = 0x12;
-    usb_buf[0x03] = 0x19;
-
-    usb_buf[0x04] = (unsigned char)led;
-    usb_buf[0x05] = red;
-    usb_buf[0x06] = green;
-    usb_buf[0x07] = blue;
-
-    usb_buf[0x08] = 0xFF;
-
-    hid_write(dev, usb_buf, 20);
-    hid_read(dev, usb_buf, 20);
-
-    SendApply();
-}
-
-void LogitechG203LController::SetMode(
-    int             mode,
-    int             speed,
-    unsigned char   bright,
-    unsigned char   dir,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue)
-{
-    unsigned char usb_buf[20];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    //Header
-    usb_buf[0x00] = 0x11;
-    usb_buf[0x01] = 0xFF;
-    usb_buf[0x02] = 0x0E;
-    usb_buf[0x03] = 0x1A;
-    //Common Data
-    usb_buf[0x04] = 0x00;
-    usb_buf[0x05] = (unsigned char)mode;
-    usb_buf[0x06] = red;
-    usb_buf[0x07] = green;
-    usb_buf[0x08] = blue;
-    //mode specific Data and position
-    if(mode == LOGITECH_G203L_MODE_STATIC) usb_buf[0x09] = 0x02;
-    if(mode == LOGITECH_G203L_MODE_CYCLE)
-    {
-        usb_buf[0x0B] = (unsigned char)((speed>>8) & 0x000000FF);
-        usb_buf[0x0C] = (unsigned char)(speed & 0x000000FF);
-        usb_buf[0x0D] = bright;
-    }
-    if(mode == LOGITECH_G203L_MODE_BREATHING)
-    {
-        usb_buf[0x09] = (unsigned char)((speed>>8) & 0x000000FF);
-        usb_buf[0x0A] = (unsigned char)(speed & 0x000000FF);
-        usb_buf[0x0C] = bright;
-    }
-    if(mode == LOGITECH_G203L_MODE_WAVE)
-    {
-        usb_buf[0x0C] = (unsigned char)(speed & 0x000000FF);
-        usb_buf[0x0D] = dir ? 0x01 : 0x06; //0x01: Left->Right   0x06: Right->Left
-        usb_buf[0x0E] = bright;
-        usb_buf[0x0F] = (unsigned char)((speed>>8) & 0x000000FF);
-    }
-    if(mode == LOGITECH_G203L_MODE_COLORMIXING)
-    {
-        usb_buf[0x0C] = (unsigned char)(speed & 0x000000FF);
-        usb_buf[0x0D] = (unsigned char)((speed>>8) & 0x000000FF);
-        usb_buf[0x0E] = bright;
-    }
-    
-    //END BYTE
-    usb_buf[0x10] = 0x01;
-
-    hid_write(dev, usb_buf, 20);
-    hid_read(dev, usb_buf, 20);
-}
-
-void LogitechG203LController::SetDevice(std::vector<RGBColor> colors)
-{
-    unsigned char usb_buf[20];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00] = 0x11;
-    usb_buf[0x01] = 0xFF;
-    usb_buf[0x02] = 0x12;
-    usb_buf[0x03] = 0x1A;
-
-    usb_buf[0x04] = 0x01;
-    usb_buf[0x05] = RGBGetRValue(colors[0]);
-    usb_buf[0x06] = RGBGetGValue(colors[0]);
-    usb_buf[0x07] = RGBGetBValue(colors[0]);
-
-    usb_buf[0x08] = 0x02;
-    usb_buf[0x09] = RGBGetRValue(colors[1]);
-    usb_buf[0x0A] = RGBGetGValue(colors[1]);
-    usb_buf[0x0B] = RGBGetBValue(colors[1]);
-
-    usb_buf[0x0C] = 0x03;
-    usb_buf[0x0D] = RGBGetRValue(colors[2]);
-    usb_buf[0x0E] = RGBGetGValue(colors[2]);
-    usb_buf[0x0F] = RGBGetBValue(colors[2]);
-    
-    usb_buf[0x10] = 0xFF;
-
-    hid_write(dev, usb_buf, 20);
-    hid_read(dev, usb_buf, 20);
-
-    SendApply();
-}
@@ -1,32 +0,0 @@
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    LOGITECH_G203L_MODE_DIRECT      = 0x07,
-    LOGITECH_G203L_MODE_OFF         = 0x00,
-    LOGITECH_G203L_MODE_STATIC      = 0x01,
-    LOGITECH_G203L_MODE_CYCLE       = 0x02,
-    LOGITECH_G203L_MODE_WAVE        = 0x03,
-    LOGITECH_G203L_MODE_BREATHING   = 0x04,
-    LOGITECH_G203L_MODE_COLORMIXING = 0x06,
-};
-
-class LogitechG203LController
-{
-public:
-    LogitechG203LController(hid_device* dev_handle);
-    ~LogitechG203LController();
-
-    void SetSingleLED(int led, unsigned char red, unsigned char green, unsigned char blue);
-    void SetMode(int mode, int speed, unsigned char brightness, unsigned char dir, unsigned char red, unsigned char green, unsigned char blue);
-    void SetDevice(std::vector<RGBColor> colors);
-
-private:
-    hid_device*             dev;
-    void SendApply();
-};
@@ -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 = 100 * 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);
-}
@@ -1,54 +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,
-};
-
-/*---------------------------------------------------------------------------------------------*\
-| Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are mutipled by 100 later to give lots of GUI steps.                                   |
-\*---------------------------------------------------------------------------------------------*/
-enum
-{
-    LOGITECH_G403_SPEED_SLOWEST          = 0xC8,    /* Slowest speed                           */
-    LOGITECH_G403_SPEED_NORMAL           = 0x32,    /* Normal speed                            */
-    LOGITECH_G403_SPEED_FASTEST          = 0x0A,    /* 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;
-};
@@ -1,77 +0,0 @@
-/*-----------------------------------------*\
-|  Logitech502PSController.cpp              |
-|                                           |
-|  Driver for Logitech G502 Proteus         |
-|  Spectrum mouse lighting controller       |
-|                                           |
-|  kernzerfall 07/28/2020                   |
-\*-----------------------------------------*/
-
-#include "LogitechG502PSController.h"
-
-#include <cstring>
-
-LogitechG502PSController::LogitechG502PSController(hid_device* dev_handle)
-{
-    dev = dev_handle;
-}
-
-LogitechG502PSController::~LogitechG502PSController()
-{
-    hid_close(dev);
-}
-
-void LogitechG502PSController::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]           = 0x02;
-    usb_buf[0x03]           = 0x3A;
-    usb_buf[0x04]           = channel;
-
-    usb_buf[0x05]           = mode;
-
-    usb_buf[0x06]           = red;
-    usb_buf[0x07]           = green;
-    usb_buf[0x08]           = blue;
-
-    speed = 100 * speed;
-    if(mode == LOGITECH_G502_PS_MODE_CYCLE)
-    {
-        usb_buf[0x0B]   = speed >> 8;
-        usb_buf[0x0C]   = speed & 0xFF;
-        usb_buf[0x0D]   = 0x64;
-    }
-    else if(mode == LOGITECH_G502_PS_MODE_BREATHING)
-    {
-        usb_buf[0x09]   = speed >> 8;
-        usb_buf[0x0A]   = speed & 0xFF;
-        usb_buf[0x0C]   = 0x64;
-    }else if(mode == LOGITECH_G502_PS_MODE_STATIC){
-        usb_buf[0x09]   = 0x02;
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 20);
-    hid_read(dev, usb_buf, 20);
-}
@@ -1,55 +0,0 @@
-/*-----------------------------------------*\
-|  Logitech502PSController.h                |
-|                                           |
-|  Definitions and types for Logitech       |
-|  G502 Proteus Spectrum mouse lighting     |
-|  controller                               |
-|                                           |
-|  kernzerfall 07/28/2020                   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    LOGITECH_G502_PS_MODE_OFF               = 0x00,
-    LOGITECH_G502_PS_MODE_STATIC            = 0x01,
-    LOGITECH_G502_PS_MODE_CYCLE             = 0x03,
-    LOGITECH_G502_PS_MODE_BREATHING         = 0x02
-};
-
-/*---------------------------------------------------------------------------------------------*\
-| Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are mutipled by 100 later to give lots of GUI steps.                                   |
-\*---------------------------------------------------------------------------------------------*/
-enum
-{
-    LOGITECH_G502_PS_SPEED_SLOWEST          = 0xC8,     /* Slowest speed                       */
-    LOGITECH_G502_PS_SPEED_NORMAL           = 0x32,     /* Normal speed                        */
-    LOGITECH_G502_PS_SPEED_FASTEST          = 0x0A,     /* Fastest speed                       */
-};
-
-class LogitechG502PSController
-{
-public:
-    LogitechG502PSController(hid_device* dev_handle);
-    ~LogitechG502PSController();
-
-    void        SendMouseMode
-                   (
-                    unsigned char       mode,
-                    unsigned short      speed,
-                    unsigned char       channel,
-                    unsigned char       red,
-                    unsigned char       green,
-                    unsigned char       blue
-                   );
-
-private:
-    hid_device*             dev;
-};
@@ -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);
-}
@@ -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();
-};
@@ -1,82 +0,0 @@
-/*-----------------------------------------*\
-|  LogitechGPowerPlayController.cpp         |
-|                                           |
-|  Driver for Logitech G PowerPlay Wireless |
-|  Charging System                          |
-|                                           |
-|  TheRogueZeta   8/31/2020                 |
-\*-----------------------------------------*/
-
-#include "LogitechGPowerPlayController.h"
-
-#include <cstring>
-
-LogitechGPowerPlayController::LogitechGPowerPlayController(hid_device* dev_handle)
-{
-    dev = dev_handle;
-}
-
-LogitechGPowerPlayController::~LogitechGPowerPlayController()
-{
-    hid_close(dev);
-}
-
-void LogitechGPowerPlayController::SendMouseMatMode
-    (
-    unsigned char       mode,
-    std::uint16_t       speed,
-    unsigned char       zone,
-    unsigned char       red,
-    unsigned char       green,
-    unsigned char       blue
-  //  unsigned char       brightness
-    )
-{
-    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]           = 0x07;
-    usb_buf[0x02]           = 0x0B;
-    usb_buf[0x03]           = 0x3E;
-
-    usb_buf[0x04]           = zone;
-    usb_buf[0x05]           = mode;
-
-    usb_buf[0x06]           = red;
-    usb_buf[0x07]           = green;
-    usb_buf[0x08]           = blue;
-
-    speed = 100 * speed;
-    if(mode == LOGITECH_G_POWERPLAY_MODE_STATIC)
-    {
-        usb_buf[0x09]   = 0x02;
-    }
-    if(mode == LOGITECH_G_POWERPLAY_MODE_CYCLE)
-    {
-        usb_buf[0x0B]   = speed >> 8;
-        usb_buf[0x0C]   = speed & 0xFF;
-        //usb_buf[0x0D]   = brightness;
-        usb_buf[0x0D]   = 0x64;
-    }
-    else if(mode == LOGITECH_G_POWERPLAY_MODE_BREATHING)
-    {
-        usb_buf[0x09]   = speed >> 8;
-        usb_buf[0x0A]   = speed & 0xFF;
-        //usb_buf[0x0C]   = brightness;
-        usb_buf[0x0C]   = 0x64;
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 20);
-    hid_read(dev, usb_buf, 20);
-}
@@ -1,55 +0,0 @@
-/*-----------------------------------------*\
-|  LogitechGPowerPlayController.h           |
-|                                           |
-|  Definitions and types for Logitech G     |
-|  PowerPlay Wireless lighting controller   |
-|                                           |
-|  TheRogueZeta   8/31/2020                 |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    LOGITECH_G_POWERPLAY_MODE_OFF               = 0x00,
-    LOGITECH_G_POWERPLAY_MODE_STATIC            = 0x01,
-    LOGITECH_G_POWERPLAY_MODE_CYCLE             = 0x02,
-    LOGITECH_G_POWERPLAY_MODE_BREATHING         = 0x03,
-};
-
-/*---------------------------------------------------------------------------------------------*\
-| Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are mutipled by 100 later to give lots of GUI steps.                                   |
-\*---------------------------------------------------------------------------------------------*/
-enum
-{
-    LOGITECH_G_POWERPLAY_SPEED_SLOWEST          = 0xC8,     /* Slowest speed                   */
-    LOGITECH_G_POWERPLAY_SPEED_NORMAL           = 0x32,     /* Normal speed                    */
-    LOGITECH_G_POWERPLAY_SPEED_FASTEST          = 0x0A,     /* Fastest speed                   */
-};
-
-class LogitechGPowerPlayController
-{
-public:
-    LogitechGPowerPlayController(hid_device* dev_handle);
-    ~LogitechGPowerPlayController();
-
-    void        SendMouseMatMode
-                   (
-                    unsigned char       mode,
-                    unsigned short      speed,
-                    unsigned char       zone,
-                    unsigned char       red,
-                    unsigned char       green,
-                    unsigned char       blue
-//                    unsigned char       brightness
-                   );
-
-private:
-    hid_device*             dev;
-};
@@ -1,82 +0,0 @@
-/*-----------------------------------------*\
-|  LogitechGProWirelessController.cpp       |
-|                                           |
-|  Driver for Logitech G Pro Wireless Gaming|
-|  Mouse lighting controller                |
-|                                           |
-|  TheRogueZeta   8/5/2020                  |
-\*-----------------------------------------*/
-
-#include "LogitechGProWirelessController.h"
-
-#include <cstring>
-
-LogitechGProWirelessController::LogitechGProWirelessController(hid_device* dev_handle)
-{
-    dev = dev_handle;
-}
-
-LogitechGProWirelessController::~LogitechGProWirelessController()
-{
-    hid_close(dev);
-}
-
-void LogitechGProWirelessController::SendMouseMode
-    (
-    unsigned char       mode,
-    std::uint16_t       speed,
-    unsigned char       zone,
-    unsigned char       red,
-    unsigned char       green,
-    unsigned char       blue
-  //  unsigned char       brightness
-    )
-{
-    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]           = 0x01;
-    usb_buf[0x02]           = 0x07;
-    usb_buf[0x03]           = 0x3C;
-
-    usb_buf[0x04]           = zone;
-    usb_buf[0x05]           = mode;
-
-    usb_buf[0x06]           = red;
-    usb_buf[0x07]           = green;
-    usb_buf[0x08]           = blue;
-
-    speed = 100 * speed;
-    if(mode == LOGITECH_G_PRO_WIRELESS_MODE_STATIC)
-    {
-        usb_buf[0x09]   = 0x02;
-    }
-    if(mode == LOGITECH_G_PRO_WIRELESS_MODE_CYCLE)
-    {
-        usb_buf[0x0B]   = speed >> 8;
-        usb_buf[0x0C]   = speed & 0xFF;
-        //usb_buf[0x0D]   = brightness;
-        usb_buf[0x0D]   = 0x64;
-    }
-    else if(mode == LOGITECH_G_PRO_WIRELESS_MODE_BREATHING)
-    {
-        usb_buf[0x09]   = speed >> 8;
-        usb_buf[0x0A]   = speed & 0xFF;
-        //usb_buf[0x0C]   = brightness;
-        usb_buf[0x0C]   = 0x64;
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 20);
-    hid_read(dev, usb_buf, 20);
-}
@@ -1,55 +0,0 @@
-/*-----------------------------------------*\
-|  LogitechGProWirelessController.h         |
-|                                           |
-|  Definitions and types for Logitech G Pro |
-|  Wireless Gaming Mouse lighting controller|
-|                                           |
-|  TheRogueZeta   8/5/2020                  |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    LOGITECH_G_PRO_WIRELESS_MODE_OFF               = 0x00,
-    LOGITECH_G_PRO_WIRELESS_MODE_STATIC            = 0x01,
-    LOGITECH_G_PRO_WIRELESS_MODE_CYCLE             = 0x02,
-    LOGITECH_G_PRO_WIRELESS_MODE_BREATHING         = 0x03,
-};
-
-/*---------------------------------------------------------------------------------------------*\
-| Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are mutipled by 100 later to give lots of GUI steps.                                   |
-\*---------------------------------------------------------------------------------------------*/
-enum
-{   
-    LOGITECH_G_PRO_WIRELESS_SPEED_SLOWEST          = 0xC8,  /* Slowest speed                   */
-    LOGITECH_G_PRO_WIRELESS_SPEED_NORMAL           = 0x32,  /* Normal speed                    */
-    LOGITECH_G_PRO_WIRELESS_SPEED_FASTEST          = 0x0A,  /* Fastest speed                   */
-};
-
-class LogitechGProWirelessController
-{
-public:
-    LogitechGProWirelessController(hid_device* dev_handle);
-    ~LogitechGProWirelessController();
-
-    void        SendMouseMode
-                   (
-                    unsigned char       mode,
-                    unsigned short      speed,
-                    unsigned char       zone,
-                    unsigned char       red,
-                    unsigned char       green,
-                    unsigned char       blue
-//                    unsigned char       brightness
-                   );
-
-private:
-    hid_device*             dev;
-};
@@ -1,4 +1,3 @@
-#include "Detector.h"
 #include "MSI3ZoneController.h"
 #include "RGBController.h"
 #include "RGBController_MSI3Zone.h"
@@ -34,6 +33,4 @@ void DetectMSI3ZoneControllers(std::vector<RGBController*>& rgb_controllers)

        rgb_controllers.push_back(rgb_controller);
    }
-}   /* DetectMSI3ZoneControllers() */
-
-REGISTER_DETECTOR("MSI 3-Zone Laptop", DetectMSI3ZoneControllers);
+}
@@ -1,67 +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;
-}
-
-MSIGPUController::~MSIGPUController()
-{
-
-}
-
-std::string MSIGPUController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return(return_string);
-}
-
-void MSIGPUController::SetRGB1(unsigned char red, unsigned char green, unsigned char blue)
-{
-    MSIGPURegisterWrite(MSI_GPU_REG_R1, red);
-    MSIGPURegisterWrite(MSI_GPU_REG_G1, green);
-    MSIGPURegisterWrite(MSI_GPU_REG_B1, blue);
-}
-
-void MSIGPUController::SetRGB2(unsigned char red, unsigned char green, unsigned char blue)
-{
-    MSIGPURegisterWrite(MSI_GPU_REG_R2, red);
-    MSIGPURegisterWrite(MSI_GPU_REG_G2, green);
-    MSIGPURegisterWrite(MSI_GPU_REG_B2, blue);
-}
-
-void MSIGPUController::SetRGB3(unsigned char red, unsigned char green, unsigned char blue)
-{
-    MSIGPURegisterWrite(MSI_GPU_REG_R3, red);
-    MSIGPURegisterWrite(MSI_GPU_REG_G3, green);
-    MSIGPURegisterWrite(MSI_GPU_REG_B3, blue);
-}
-
-void MSIGPUController::SetMode(unsigned char mode)
-{
-    MSIGPURegisterWrite(MSI_GPU_REG_MODE, mode);
-    MSIGPURegisterWrite(MSI_GPU_REG_APPLY, 0x01);
-}
-
-unsigned char MSIGPUController::MSIGPURegisterRead(unsigned char reg)
-{
-    return(bus->i2c_smbus_read_byte_data(dev, reg));
-}
-
-void MSIGPUController::MSIGPURegisterWrite(unsigned char reg, unsigned char val)
-{
-    bus->i2c_smbus_write_byte_data(dev, reg, val);
-}
@@ -1,77 +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   GetDeviceLocation();
-
-    void          SetRGB1(unsigned char red, unsigned char green, unsigned char blue);
-    void          SetRGB2(unsigned char red, unsigned char green, unsigned char blue);
-    void          SetRGB3(unsigned char red, unsigned char green, unsigned char blue);
-
-    void          SetMode(unsigned char mode);
-
-    unsigned char MSIGPURegisterRead(unsigned char reg);
-    void          MSIGPURegisterWrite(unsigned char reg, unsigned char val);
-
-private:
-    i2c_smbus_interface *   bus;
-    msi_gpu_dev_id          dev;
-};
@@ -1,121 +0,0 @@
-/*-----------------------------------------*\
-|  MSIGPUControllerDetect.cpp               |
-|                                           |
-|  Driver for MSI GPUs                      |
-|                                           |
-\*-----------------------------------------*/
-
-#include "Detector.h"
-#include "MSIGPUController.h"
-#include "RGBController.h"
-#include "RGBController_MSIGPU.h"
-#include "i2c_smbus.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-/*-----------------------------------------------------*\
-| NVidia vendor ID                                      |
-\*-----------------------------------------------------*/
-#define NVIDIA_VEN                              0x10DE
-
-/*-----------------------------------------------------*\
-| NVidia device IDs                                     |
-\*-----------------------------------------------------*/
-#define NVIDIA_GTX1070_DEV                      0x1B81
-#define NVIDIA_RTX2060_DEV                      0x1F08
-#define NVIDIA_RTX2060S_DEV                     0x1F06
-#define NVIDIA_RTX2070_DEV                      0x1F02
-#define NVIDIA_RTX2070S_DEV                     0x1E84
-#define NVIDIA_RTX2080_DEV                      0x1E87
-#define NVIDIA_RTX2080S_DEV                     0x1E81
-#define NVIDIA_RTX2080TI_DEV                    0x1E07
-
-/*-----------------------------------------------------*\
-| MSI sub-vendor ID                                     |
-\*-----------------------------------------------------*/
-#define MSI_SUB_VEN                             0x1462
-
-/*-----------------------------------------------------*\
-| MSI sub-device IDs                                    |
-\*-----------------------------------------------------*/
-#define MSI_GTX1070_GAMING_X_SUB_DEV            0x3306
-#define MSI_RTX2060S_GAMING_X_SUB_DEV           0xC752
-#define MSI_RTX2070S_GAMING_X_SUB_DEV           0x373e
-#define MSI_RTX2070S_GAMING_X_TRIO_SUB_DEV      0xC726
-#define MSI_RTX2080_GAMING_X_TRIO_SUB_DEV       0x3726
-#define MSI_RTX2080S_GAMING_X_TRIO_SUB_DEV      0xC724
-#define MSI_RTX2080TI_GAMING_X_TRIO_SUB_DEV     0x3715
-#define MSI_RTX2060_GAMING_Z_6G_SUB_DEV         0x3754
-#define MSI_RTX2060_GAMING_Z_6G_SUB_DEV_2       0x3752
-#define MSI_RTX2070_ARMOR_SUB_DEV               0x3734
-#define MSI_RTX2060S_ARMOR_OC_SUB_DEV           0xC754
-#define MSI_RTX2080_SEA_HAWK_EK_X_SUB_DEV       0x3728
-#define MSI_RTX2080TI_SEA_HAWK_EK_X_SUB_DEV     0x3717
-
-typedef struct
-{
-    int             pci_vendor;
-    int             pci_device;
-    int             pci_subsystem_vendor;
-    int             pci_subsystem_device;
-    const char *    name;
-} msi_gpu_pci_device;
-
-#define MSI_GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const msi_gpu_pci_device device_list[] =
-{
-    { NVIDIA_VEN,   NVIDIA_GTX1070_DEV,     MSI_SUB_VEN,    MSI_GTX1070_GAMING_X_SUB_DEV,           "MSI GeForce GTX 1070 Gaming X"                 },
-    { NVIDIA_VEN,   NVIDIA_RTX2060S_DEV,    MSI_SUB_VEN,    MSI_RTX2060S_GAMING_X_SUB_DEV,          "MSI GeForce RTX 2060 Super Gaming X"           },
-    { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,    MSI_SUB_VEN,    MSI_RTX2070S_GAMING_X_SUB_DEV,          "MSI GeForce RTX 2070 Super Gaming X"           },
-    { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,    MSI_SUB_VEN,    MSI_RTX2070S_GAMING_X_TRIO_SUB_DEV,     "MSI GeForce RTX 2070 Super Gaming X Trio"      },
-    { NVIDIA_VEN,   NVIDIA_RTX2080_DEV,     MSI_SUB_VEN,    MSI_RTX2080_GAMING_X_TRIO_SUB_DEV,      "MSI GeForce RTX 2080 Gaming X Trio"            },
-    { NVIDIA_VEN,   NVIDIA_RTX2080S_DEV,    MSI_SUB_VEN,    MSI_RTX2080S_GAMING_X_TRIO_SUB_DEV,     "MSI GeForce RTX 2080 Super Gaming X Trio"      },
-    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,   MSI_SUB_VEN,    MSI_RTX2080TI_GAMING_X_TRIO_SUB_DEV,    "MSI GeForce RTX 2080Ti Gaming X Trio"          },
-    { NVIDIA_VEN,   NVIDIA_RTX2060_DEV,     MSI_SUB_VEN,    MSI_RTX2060_GAMING_Z_6G_SUB_DEV,        "MSI GeForce RTX 2060 Gaming Z 6G"              },
-    { NVIDIA_VEN,   NVIDIA_RTX2060_DEV,     MSI_SUB_VEN,    MSI_RTX2060_GAMING_Z_6G_SUB_DEV_2,      "MSI GeForce RTX 2060 Gaming Z 6G"              },
-    { NVIDIA_VEN,   NVIDIA_RTX2060S_DEV,    MSI_SUB_VEN,    MSI_RTX2060S_ARMOR_OC_SUB_DEV,          "MSI GeForce RTX 2060 Super ARMOR OC"           },
-    { NVIDIA_VEN,   NVIDIA_RTX2070_DEV,     MSI_SUB_VEN,    MSI_RTX2070_ARMOR_SUB_DEV,              "MSI GeForce RTX 2070 ARMOR"                    },
-    { NVIDIA_VEN,   NVIDIA_RTX2080_DEV,     MSI_SUB_VEN,    MSI_RTX2080_SEA_HAWK_EK_X_SUB_DEV,      "MSI GeForce RTX 2080 Sea Hawk EK X"            },
-    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,   MSI_SUB_VEN,    MSI_RTX2080TI_SEA_HAWK_EK_X_SUB_DEV,    "MSI GeForce RTX 2080Ti Sea Hawk EK X"          },
-};
-
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectMSIGPUControllers                                                               *
-*                                                                                          *
-*       Detect MSI GPU controllers on the enumerated I2C busses.                          *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectMSIGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
-{
-    MSIGPUController* new_msi_gpu;
-    RGBController_MSIGPU* new_controller;
-
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        for(unsigned int dev_idx = 0; dev_idx < MSI_GPU_NUM_DEVICES; dev_idx++)
-        {
-            if (busses[bus]->port_id != 1)
-            {
-                break;
-            }
-
-            if(busses[bus]->pci_vendor           == device_list[dev_idx].pci_vendor           &&
-               busses[bus]->pci_device           == device_list[dev_idx].pci_device           &&
-               busses[bus]->pci_subsystem_vendor == device_list[dev_idx].pci_subsystem_vendor &&
-               busses[bus]->pci_subsystem_device == device_list[dev_idx].pci_subsystem_device)
-            {
-                new_msi_gpu = new MSIGPUController(busses[bus]);
-                new_controller = new RGBController_MSIGPU(new_msi_gpu);
-                new_controller->name = device_list[dev_idx].name;
-                rgb_controllers.push_back(new_controller);
-            }
-        }
-    }
-} /* DetectMSIGPUControllers() */
-
-REGISTER_I2C_DETECTOR("MSI GPU", DetectMSIGPUControllers);
@@ -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;
 }
@@ -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;
@@ -1,57 +1,52 @@
-#include "Detector.h"
 #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] =
 {
-    0x3EA4, // MS_3EA4
-    0x4559, // MS_4459
-
-    0x7B10, // MS_7B10
-    0x7B93, // MSI B450 Gaming Pro Carbon AC
-    0x7B94, // MS_7B94
-    0x7B96, // MS_7B96
-
-    0x7C34, // MS_7C34
-    0x7C35, // MS_7C35
-    0x7C36, // MS_7C36
-    0x7C37, // MS_7C37
-    0x7C42, // MS_7C42
-    0x7C56, // MS_7C56
-    0x7C59, // MS_7C59
-    0x7C60, // MS_7C60
-    0x7C67, // MS_7C67
-    0x7C70, // MS_7C70
-    0x7C71, // MS_7C71
-    0x7C73, // MS_7C73
-    0x7C75, // MS_7C75
-    0x7C76, // MS_7C76
-    0x7C77, // MS_7C77
-    0x7C79, // MS_7C79
-    0x7C80, // MS_7C80
-    0x7C81, // MS_7C81
-    0x7C82, // MS_7C82
-    0x7C83, // MS_7C83
-    0x7C84, // MS_7C84
-    0x7C85, // MS_7C85
-    0x7C86, // MS_7C86
-    0x7C87, // MS_7C87
-    0x7C88, // MS_7C88
-    0x7C89, // MS_7C89
-    0x7C90, // MS_7C90
-    0x7C91, // MS_7C91
-    0x7C92, // MS_7C92
-    0x7C94, // MS_7C94
-    0x7C95, // MS_7C95
-    0x7C96, // MS_7C96
-    0x7C98, // MS_7C98
-    0x7C99, // MS_7C99
-
-    0x905D  // MS_905D
+    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
 };

 /******************************************************************************************\
@@ -64,43 +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;
    }
-}   /* DetectMSIMysticLightControllers() */

-// The MSI Mystic Light controller is disabled due to bricking risk
-// Uncomment this line to enable.  Do so at your own risk.
-//REGISTER_DETECTOR("MSI Mystic Light", DetectMSIMysticLightControllers);
+    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);
+}
@@ -1,4 +1,3 @@
-#include "Detector.h"
 #include "MSIRGBController.h"
 #include "RGBController.h"
 #include "RGBController_MSIRGB.h"
@@ -39,5 +38,3 @@ void DetectMSIRGBControllers(std::vector<RGBController*> &rgb_controllers)
        }
    }
 }   /* DetectMSIRGBControllers() */
-
-REGISTER_DETECTOR("MSI-RGB", DetectMSIRGBControllers);
@@ -1,81 +0,0 @@
-#include "Detector.h"
-#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() */
-
-REGISTER_DETECTOR("NZXT Hue 2", DetectNZXTHue2Controllers);
@@ -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
+    );
 }
@@ -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;
@@ -1,75 +1,37 @@
-#include "Detector.h"
 #include "NZXTKrakenController.h"
 #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_X2_PID  0x170E
-#define NZXT_KRAKEN_M2_PID  0x1715
-
-typedef struct
-{
-    unsigned short  usb_vid;
-    unsigned short  usb_pid;
-    const char *    name;
-} nzxt_kraken_device;
-
-#define NZXT_KRAKEN_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const nzxt_kraken_device device_list[] =
-{
-    /*-----------------------------------------------------------------------------------------------------*\
-    | NZXT Hue 2 devices                                                                                    |
-    \*-----------------------------------------------------------------------------------------------------*/
-    { NZXT_KRAKEN_VID,      NZXT_KRAKEN_X2_PID,                         "NZXT Kraken X2"                    },
-    { NZXT_KRAKEN_VID,      NZXT_KRAKEN_M2_PID,                         "NZXT Kraken M2"                    },
-};
+#define NZXT_KRAKEN_VID 0x1E71
+#define NZXT_KRAKEN_PID 0x170E

 /******************************************************************************************\
 *                                                                                          *
 *   DetectNZXTKrakenControllers                                                            *
 *                                                                                          *
 *       Detect devices supported by the NZXTKraken driver                                  *
-*                                                                                          *
+*                                                                                          *                                                                                          *
 \******************************************************************************************/

 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 < NZXT_KRAKEN_NUM_DEVICES; device_idx++)
+    if( dev )
    {
-        dev = NULL;
+        libusb_detach_kernel_driver(dev, 0);
+        libusb_claim_interface(dev, 0);

-        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+        NZXTKrakenController* controller = new NZXTKrakenController(dev);

-        //Look for NZXT Kraken 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 )
-                {
-                    NZXTKrakenController* controller = new NZXTKrakenController(dev);
+        RGBController_NZXTKraken* rgb_controller = new RGBController_NZXTKraken(controller);

-                    RGBController_NZXTKraken* rgb_controller = new RGBController_NZXTKraken(controller);
-
-                    rgb_controller->name = device_list[device_idx].name;
-                    
-                    rgb_controllers.push_back(rgb_controller);
-                }
-            }
-            info = info->next;
-        }
+        rgb_controllers.push_back(rgb_controller);
    }
-}   /* DetectNZXTKrakenControllers() */

-REGISTER_DETECTOR("NZXT Kraken", DetectNZXTKrakenControllers);
+}
@@ -1,4 +1,3 @@
-#include "Detector.h"
 #include "PatriotViperController.h"
 #include "RGBController.h"
 #include "RGBController_PatriotViper.h"
@@ -7,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

 /******************************************************************************************\
 *                                                                                          *
@@ -36,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)
@@ -59,7 +67,7 @@ void DetectPatriotViperControllers(std::vector<i2c_smbus_interface*> &busses, st
                }
            }

-            std::this_thread::sleep_for(1ms);
+            Sleep(1);
        }

        if(slots_valid != 0)
@@ -71,5 +79,3 @@ void DetectPatriotViperControllers(std::vector<i2c_smbus_interface*> &busses, st
    }

 }   /* DetectPatriotViperControllers() */
-
-REGISTER_I2C_DETECTOR("Patriot Viper", DetectPatriotViperControllers);
@@ -10,45 +10,53 @@
 #include "PolychromeController.h"
 #include <cstring>

-using namespace std::chrono_literals;
-
 PolychromeController::PolychromeController(i2c_smbus_interface* bus, polychrome_dev_id dev)
 {
    this->bus = bus;
    this->dev = dev;
-
-    unsigned short fw_version    = ReadFirmwareVersion();
-    unsigned char  major_version = fw_version >> 8;
-
-    /*-----------------------------------------------------*\
-    | Determine whether the device uses ASR LED or          |
-    | Polychrome protocol by checking firmware version.     |
-    | Versions 1.xx and 2.xx use ASR LED, 3.xx uses         |
-    | Polychrome                                            |
-    \*-----------------------------------------------------*/
-    switch(major_version)
+    
+    switch (GetFirmwareVersion())
    {
-        case ASROCK_TYPE_ASRLED:
-            device_name = "ASRock ASR LED";
-            asrock_type = ASROCK_TYPE_ASRLED;
-            memset(zone_led_count, 0, sizeof(zone_led_count));
-            break;
+    case FIRMWARE_VER_1_PT_10:
+        led_count = 1;
+        asr_led = true;
+        strcpy(device_name, "ASRock ASR LED FW 1.10");
+        break;

-        case ASROCK_TYPE_POLYCHROME_V1:
-            device_name = "ASRock Polychrome V1";
-            asrock_type = ASROCK_TYPE_POLYCHROME_V1;
-            ReadLEDConfiguration();
-            break;
+    case FIRMWARE_VER_2_PT_00:
+        led_count = 1;
+        asr_led = true;
+        strcpy(device_name, "ASRock ASR LED FW 2.00");
+        break;

-        case ASROCK_TYPE_POLYCHROME_V2:
-            device_name = "ASRock Polychrome V2";
-            asrock_type = ASROCK_TYPE_POLYCHROME_V2;
-            ReadLEDConfiguration();
-            break;
+    case FIRMWARE_VER_2_PT_08:
+        led_count = 1;
+        asr_led = true;
+        strcpy(device_name, "ASRock ASR LED FW 2.08");
+        break;

-        default:
-            asrock_type = ASROCK_TYPE_UNKNOWN;
-            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;
    }
 }

@@ -57,44 +65,18 @@ PolychromeController::~PolychromeController()

 }

-unsigned int PolychromeController::GetASRockType()
-{
-    return(asrock_type);
-}
-
-std::string PolychromeController::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);
-}
-
-std::string PolychromeController::GetDeviceName()
+char* PolychromeController::GetDeviceName()
 {
    return(device_name);
 }

-std::string PolychromeController::GetFirmwareVersion()
-{
-    unsigned short fw_version    = ReadFirmwareVersion();
-    unsigned char  major_version = fw_version >> 8;
-    unsigned char  minor_version = fw_version & 0xFF;
-
-    return(std::to_string(major_version) + "." + std::to_string(minor_version));
-}
-
-unsigned short PolychromeController::ReadFirmwareVersion()
+unsigned short PolychromeController::GetFirmwareVersion()
 {
    // The firmware register holds two bytes, so the first read should return 2
    // If not, report invalid firmware revision FFFF
-    if (bus->i2c_smbus_read_byte_data(dev, ASROCK_REG_FIRMWARE_VER) == 0x02)
+    if (bus->i2c_smbus_read_byte_data(dev, POLYCHROME_REG_FIRMWARE_VER) == 0x02)
    {
-        std::this_thread::sleep_for(1ms);
        unsigned char major = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
        unsigned char minor = bus->i2c_smbus_read_byte(dev);

        return((major << 8) | minor);
@@ -105,31 +87,9 @@ unsigned short PolychromeController::ReadFirmwareVersion()
    }
 }

-void PolychromeController::ReadLEDConfiguration()
+unsigned int PolychromeController::GetLEDCount()
 {
-    /*---------------------------------------------------------------------------------*\
-    | The LED configuration register holds 6 bytes, so the first read should return 6   |
-    | If not, set all zone sizes to zero                                                |
-    \*---------------------------------------------------------------------------------*/
-    if (bus->i2c_smbus_read_byte_data(dev, POLYCHROME_REG_LED_CONFIG) == 0x06)
-    {
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_1]           = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_2]           = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_3]           = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_4]           = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_5]           = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_ADDRESSABLE] = bus->i2c_smbus_read_byte(dev);
-    }
-    else
-    {
-        memset(zone_led_count, 0, sizeof(zone_led_count));
-    }
+    return(led_count);
 }

 unsigned int PolychromeController::GetMode()
@@ -137,203 +97,35 @@ unsigned int PolychromeController::GetMode()
    return(active_mode);
 }

-void PolychromeController::SetColorsAndSpeed(unsigned char led, unsigned char red, unsigned char green, unsigned char blue)
+bool PolychromeController::IsAsrLed()
 {
-    unsigned char color_speed_pkt[4] = { red, green, blue, active_speed };
-    unsigned char select_led_pkt[1]  = { led };
-    
-    switch(asrock_type)
+    return(asr_led);
+}
+
+void PolychromeController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char colors[3] = { red, green, blue };
+
+    if (asr_led)
    {
-        case ASROCK_TYPE_ASRLED:
-            /*-----------------------------------------------------*\
-            | Select LED                                            |
-            \*-----------------------------------------------------*/
-            if(active_mode != ASRLED_MODE_OFF)
-            {
-                bus->i2c_smbus_write_block_data(dev, ASROCK_REG_LED_SELECT, 1, select_led_pkt);
-                std::this_thread::sleep_for(1ms);
-            }
-
-            switch(active_mode)
-            {
-                /*-----------------------------------------------------*\
-                | These modes take 4 bytes in R/G/B/S order             |
-                \*-----------------------------------------------------*/
-                case ASRLED_MODE_BREATHING:
-                case ASRLED_MODE_STROBE:
-                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, &active_speed);
-                    break;
-
-                /*-----------------------------------------------------*\
-                | These modes take no bytes                             |
-                \*-----------------------------------------------------*/
-                case ASRLED_MODE_OFF:
-                    break;
-            }
-            std::this_thread::sleep_for(1ms);
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V1:
-            /*-----------------------------------------------------*\
-            | Select LED                                            |
-            \*-----------------------------------------------------*/
-            if(active_mode != ASRLED_MODE_OFF)
-            {
-                bus->i2c_smbus_write_block_data(dev, ASROCK_REG_LED_SELECT, 1, select_led_pkt);
-                std::this_thread::sleep_for(1ms);
-            }
-
-            switch(active_mode)
-            {
-                /*-----------------------------------------------------*\
-                | These modes take 4 bytes in R/G/B/S order             |
-                \*-----------------------------------------------------*/
-                case POLYCHROME_V1_MODE_BREATHING:
-                case POLYCHROME_V1_MODE_STROBE:
-                case POLYCHROME_V1_MODE_SPECTRUM_CYCLE:
-                case POLYCHROME_V1_MODE_SPRING:
-                case POLYCHROME_V1_MODE_METEOR:
-                case POLYCHROME_V1_MODE_STACK:
-                case POLYCHROME_V1_MODE_CRAM:
-                case POLYCHROME_V1_MODE_SCAN:
-                case POLYCHROME_V1_MODE_NEON:
-                case POLYCHROME_V1_MODE_WATER:
-
-                    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 POLYCHROME_V1_MODE_STATIC:
-                case POLYCHROME_V1_MODE_MUSIC:
-                    bus->i2c_smbus_write_block_data(dev, active_mode, 3, color_speed_pkt);
-                    break;
-
-                /*-----------------------------------------------------*\
-                | These modes take 1 byte - speed                       |
-                \*-----------------------------------------------------*/
-                case POLYCHROME_V1_MODE_RANDOM:
-                case POLYCHROME_V1_MODE_WAVE:
-                case POLYCHROME_V1_MODE_RAINBOW:
-                    bus->i2c_smbus_write_block_data(dev, active_mode, 1, &active_speed);
-                    break;
-
-                /*-----------------------------------------------------*\
-                | These modes take no bytes                             |
-                \*-----------------------------------------------------*/
-                case POLYCHROME_V1_MODE_OFF:
-                    break;
-            }
-            std::this_thread::sleep_for(1ms);
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V2:
-            /*-----------------------------------------------------*\
-            | Select LED                                            |
-            \*-----------------------------------------------------*/
-            switch(active_mode)
-            {
-                case POLYCHROME_V2_MODE_OFF:
-                case POLYCHROME_V2_MODE_RAINBOW:
-                case POLYCHROME_V2_MODE_SPECTRUM_CYCLE:
-                    break;
-
-                default:
-                    bus->i2c_smbus_write_block_data(dev, ASROCK_REG_LED_SELECT, 1, select_led_pkt);
-                    std::this_thread::sleep_for(1ms);
-
-                    /*-----------------------------------------------------*\
-                    | Polychrome firmware always writes color to fixed reg  |
-                    \*-----------------------------------------------------*/
-                    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V2_REG_COLOR, 3, color_speed_pkt);
-                    std::this_thread::sleep_for(1ms);
-                    break;
-            }
-            break;
+        bus->i2c_smbus_write_block_data(dev, active_mode, 3, colors);
+    }
+    else
+    {
+        bus->i2c_smbus_write_block_data(dev, POLYCHROME_REG_COLOR, 3, colors);
    }
 }

-void PolychromeController::SetMode(unsigned char zone,unsigned char mode, unsigned char speed)
+void PolychromeController::SetMode(unsigned char mode)
 {
-    unsigned char led_count_pkt[1]  = { 0x00 };
-    active_zone                     = zone;
-    active_mode                     = mode;
-    active_speed                    = speed;
+    active_mode = mode;

-    switch(asrock_type)
+    if (asr_led)
    {
-        case ASROCK_TYPE_ASRLED:
-            bus->i2c_smbus_write_block_data(dev, ASROCK_REG_MODE, 1, &active_mode);
-            std::this_thread::sleep_for(1ms);
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V1:
-            /*-----------------------------------------------------*\
-            | Make sure set all register is set to 0                |
-            \*-----------------------------------------------------*/
-            bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_SET_ALL, 1, led_count_pkt);
-            std::this_thread::sleep_for(1ms);
-
-            /*-----------------------------------------------------*\
-            | Set the zone we are working on                        |
-            \*-----------------------------------------------------*/
-            bus->i2c_smbus_write_block_data(dev, ASROCK_REG_LED_SELECT, 1, &active_zone);
-            std::this_thread::sleep_for(1ms);
-
-            /*-----------------------------------------------------*\
-            | Write the mode                                        |
-            \*-----------------------------------------------------*/
-            bus->i2c_smbus_write_block_data(dev, ASROCK_REG_MODE, 1, &active_mode);
-            std::this_thread::sleep_for(1ms);
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V2:
-            bus->i2c_smbus_write_block_data(dev, ASROCK_REG_MODE, 1, &active_mode);
-            std::this_thread::sleep_for(1ms);
-
-            /*-----------------------------------------------------*\
-            | Select a single LED                                   |
-            \*-----------------------------------------------------*/
-            bus->i2c_smbus_write_block_data(dev, POLYCHROME_V2_REG_LED_COUNT, 0, led_count_pkt);
-            std::this_thread::sleep_for(1ms);
-
-            switch(active_mode)
-            {
-                /*-----------------------------------------------------*\
-                | These modes don't take a speed                        |
-                \*-----------------------------------------------------*/
-                case POLYCHROME_V2_MODE_OFF:
-                case POLYCHROME_V2_MODE_STATIC:
-                    break;
-
-                /*-----------------------------------------------------*\
-                | All other modes, write speed to active mode register  |
-                \*-----------------------------------------------------*/
-                default:
-                    bus->i2c_smbus_write_block_data(dev, active_mode, 1, &speed);
-                    std::this_thread::sleep_for(1ms);
-                    break;
-            }
-            break;
+        bus->i2c_smbus_write_block_data(dev, ASRLED_REG_MODE, 1, &active_mode);
+    }
+    else
+    {
+        bus->i2c_smbus_write_block_data(dev, POLYCHROME_REG_MODE, 1, &active_mode);
    }    
 }
@@ -9,7 +9,6 @@
 \*-----------------------------------------*/

 #include "i2c_smbus.h"
-#include <string>

 #pragma once

@@ -17,178 +16,59 @@ typedef unsigned char	polychrome_dev_id;

 enum
 {
-    ASROCK_TYPE_UNKNOWN                     = 0x00,     /* Unknown Type or Not ASRock Device    */
-    ASROCK_TYPE_ASRLED                      = 0x01,     /* ASRock Firmware 1.x - ASR LED        */
-    ASROCK_TYPE_POLYCHROME_V1               = 0x02,     /* ASRock Firmware 2.x - Polychrome V1  */
-    ASROCK_TYPE_POLYCHROME_V2               = 0x03,     /* ASRock Firmware 3.x - Polychrome V2  */
+    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
 {
-    /*------------------------------------------------------------------------------------------*\
-    | ASRock Common Registers                                                                    |
-    \*------------------------------------------------------------------------------------------*/
-    ASROCK_REG_FIRMWARE_VER                 = 0x00,     /* Firmware version Major.Minor         */
-    ASROCK_REG_MODE                         = 0x30,     /* Mode selection register              */
-    ASROCK_REG_LED_SELECT                   = 0x31,     /* LED selection register               */
-    /*------------------------------------------------------------------------------------------*\
-    | ASRock Polychrome V1/V2 Common Registers                                                   |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_REG_LED_CONFIG               = 0x33,     /* LED configuration register           */
-    /*------------------------------------------------------------------------------------------*\
-    | ASRock Polychrome V1 (Firmware 2.x) Registers                                              |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_REG_SET_ALL               = 0x32,     /* Set All register 0x1 = set all       */
-    POLYCHROME_V1_REG_ARGB_GRB              = 0x35,     /* ARGB bistream reversing register     */
-    /*------------------------------------------------------------------------------------------*\
-    | ASRock Polychrome V2 (Firmware 3.x) Registers                                              |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V2_REG_LED_COUNT             = 0x32,     /* Additional LED count register        */
-    POLYCHROME_V2_REG_COLOR                 = 0x34,     /* Color register: Red, Green, Blue     */
-    POLYCHROME_V2_REG_ARGB_GRB              = 0x35,     /* ARGB bistream reversing register     */
+    ASRLED_REG_FIRMWARE_VER         = 0x00,     /* Firmware version Major.Minor         */
+    ASRLED_REG_MODE                 = 0x30,     /* Mode selection register              */
+};
+
+#define ASRLED_NUM_MODES             8          /* Number of ASR LED modes              */
+
+enum
+{
+    ASRLED_MODE_OFF                 = 0x10,     /* OFF mode                             */
+    ASRLED_MODE_STATIC              = 0x11,     /* Static color mode                    */
+    ASRLED_MODE_BREATHING           = 0x12,     /* Breathing effect mode                */
+    ASRLED_MODE_FLASHING            = 0x13,     /* Flashing effect mode                 */
+    ASRLED_MODE_SPECTRUM_CYCLE      = 0x14,     /* Spectrum Cycle effect mode           */
+    ASRLED_MODE_RANDOM              = 0x15,     /* Random effect mode                   */
+    ASRLED_MODE_MUSIC               = 0x17,     /* Music effect mode                    */
+    ASRLED_MODE_WAVE                = 0x18,     /* Wave effect mode                     */
 };

 enum
 {
-    POLYCHROME_ZONE_1                       = 0x00,     /* RGB LED 1 Header                     */
-    POLYCHROME_ZONE_2                       = 0x01,     /* RGB LED 2 Header                     */
-    POLYCHROME_ZONE_3                       = 0x02,     /* Audio/PCH Zone LEDs                  */
-    POLYCHROME_ZONE_4                       = 0x03,     /* Audio/PCH Zone LEDs                  */
-    POLYCHROME_ZONE_5                       = 0x04,     /* IO Cover Zone LEDs                   */
-    POLYCHROME_ZONE_ADDRESSABLE             = 0x05,     /* Addressable LED header               */
-    POLYCHROME_ZONE_COUNT                   = 0x06,     /* Total number of zones                */
-    POLYCHROME_ZONE_ADDRESSABLE_MAX         = 0x64,     /* Maxinum number of ARGB LEDs          */
+    POLYCHROME_REG_FIRMWARE_VER     = 0x00,     /* Firmware version Major.Minor         */
+    POLYCHROME_REG_MODE             = 0x30,     /* Mode selection register              */
+    POLYCHROME_REG_COLOR            = 0x34,     /* Color register: Red, Green, Blue     */
 };

-/*----------------------------------------------------------------------------------------------*\
-| Definitions for ASR LED                                                                        |
-\*----------------------------------------------------------------------------------------------*/
-#define ASRLED_NUM_MODES                    8           /* Number of ASR LED modes              */
+#define POLYCHROME_NUM_MODES          14        /* Number of Polychrome modes           */

 enum
 {
-    ASRLED_MODE_OFF                         = 0x10,     /* OFF mode                             */
-    ASRLED_MODE_STATIC                      = 0x11,     /* Static color mode                    */
-    ASRLED_MODE_BREATHING                   = 0x12,     /* Breathing effect mode                */
-    ASRLED_MODE_STROBE                      = 0x13,     /* Strobe effect mode                   */
-    ASRLED_MODE_SPECTRUM_CYCLE              = 0x14,     /* Spectrum Cycle effect mode           */
-    ASRLED_MODE_RANDOM                      = 0x15,     /* Random effect mode                   */
-    ASRLED_MODE_MUSIC                       = 0x17,     /* Music effect mode                    */
-    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                        */
-};
-
-/*----------------------------------------------------------------------------------------------*\
-| Definitions for Polychrome V1                                                                  |
-\*----------------------------------------------------------------------------------------------*/
-#define POLYCHROME_V1_NUM_MODES             16          /* Number of Polychrome V1 modes        */
-
-enum
-{
-    POLYCHROME_V1_MODE_OFF                  = 0x10,     /* OFF mode                             */
-    POLYCHROME_V1_MODE_STATIC               = 0x11,     /* Static color mode                    */
-    POLYCHROME_V1_MODE_BREATHING            = 0x12,     /* Breating effect mode                 */
-    POLYCHROME_V1_MODE_STROBE               = 0x13,     /* Strobe effect mode                   */
-    POLYCHROME_V1_MODE_SPECTRUM_CYCLE       = 0x14,     /* Spectrum Cycle effect mode           */
-    POLYCHROME_V1_MODE_RANDOM               = 0x15,     /* Random effect mode                   */
-    POLYCHROME_V1_MODE_MUSIC                = 0x17,     /* Music effect mode                    */
-    POLYCHROME_V1_MODE_WAVE                 = 0x18,     /* Wave effect mode                     */
-    /*------------------------------------------------------------------------------------------*\
-    | Modes only available on ARGB headers                                                       |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_MODE_SPRING               = 0x19,     /* Spring effect mode                   */
-    POLYCHROME_V1_MODE_METEOR               = 0x1A,     /* Meteor effect mode                   */
-    POLYCHROME_V1_MODE_STACK                = 0x1B,     /* Stack effect mode                    */
-    POLYCHROME_V1_MODE_CRAM                 = 0x1C,     /* Cram effect mode                     */
-    POLYCHROME_V1_MODE_SCAN                 = 0x1D,     /* Scan effect mode                     */
-    POLYCHROME_V1_MODE_NEON                 = 0x1E,     /* Neon effect mode                     */
-    POLYCHROME_V1_MODE_WATER                = 0x1F,     /* Water effect mode                    */
-    POLYCHROME_V1_MODE_RAINBOW              = 0x20,     /* Rainbow chase effect mode            */
-};
-
-enum
-{
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_BREATHING                                                               |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_BREATHING       = 0x0A,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_BREATHING   = 0x02,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_BREATHING       = 0x02,     /* Fastest speed                        */
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_STROBE                                                                  |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_STROBE          = 0xA0,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_STROBE      = 0x14,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_STROBE          = 0x05,     /* Fastest speed                        */
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_SPECTRUM_CYCLE                                                          |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_CYCLE           = 0xA0,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_CYCLE       = 0x14,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_CYCLE           = 0x0A,     /* Fastest speed                        */
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_RANDOM                                                                  |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_RANDOM          = 0xA0,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_RANDOM      = 0x28,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_RANDOM          = 0x05,     /* Fastest speed                        */
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_WAVE                                                                    |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_WAVE            = 0x06,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_WAVE        = 0x02,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_WAVE            = 0x01,     /* Fastest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_SPRING      = 0x04,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_METEOR      = 0x0A,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_STACK       = 0x04,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_CRAM        = 0x04,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_SCAN        = 0x0A,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_NEON        = 0x20,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_WATER       = 0x0A,     /* Default speed                        */
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_RAINBOW                                                                 |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_RAINBOW         = 0x12,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_RAINBOW     = 0x0A,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_RAINBOW         = 0x01,     /* Fastest speed                        */
-    POLYCHROME_V1_SPEED_MIN_ARGB            = 0x20,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_MAX_ARGB            = 0x02,     /* Fastest speed                        */
-};
-
-/*----------------------------------------------------------------------------------------------*\
-| Definitions for Polychrome V2                                                                  |
-\*----------------------------------------------------------------------------------------------*/
-#define POLYCHROME_V2_NUM_MODES             14          /* Number of Polychrome V2 modes        */
-
-enum
-{
-    POLYCHROME_V2_MODE_OFF                  = 0x10,     /* OFF mode                             */
-    POLYCHROME_V2_MODE_STATIC               = 0x11,     /* Static color mode                    */
-    POLYCHROME_V2_MODE_BREATHING            = 0x12,     /* Breating effect mode                 */
-    POLYCHROME_V2_MODE_STROBE               = 0x13,     /* Strobe effect mode                   */
-    POLYCHROME_V2_MODE_SPECTRUM_CYCLE       = 0x14,     /* Spectrum Cycle effect mode           */
-    POLYCHROME_V2_MODE_RANDOM               = 0x15,     /* Random effect mode                   */
-    POLYCHROME_V2_MODE_WAVE                 = 0x17,     /* Wave effect mode                     */
-    POLYCHROME_V2_MODE_SPRING               = 0x18,     /* Spring effect mode                   */
-    POLYCHROME_V2_MODE_STACK                = 0x19,     /* Stack effect mode                    */
-    POLYCHROME_V2_MODE_CRAM                 = 0x1A,     /* Cram effect mode                     */
-    POLYCHROME_V2_MODE_SCAN                 = 0x1B,     /* Scan effect mode                     */
-    POLYCHROME_V2_MODE_NEON                 = 0x1C,     /* Neon effect mode                     */
-    POLYCHROME_V2_MODE_WATER                = 0x1D,     /* Water effect mode                    */
-    POLYCHROME_V2_MODE_RAINBOW              = 0x1E,     /* Rainbow effect mode                  */
-};
-
-enum
-{
-    POLYCHROME_V2_SPEED_MIN                 = 0x05,     /* Slowest speed                        */
-    POLYCHROME_V2_SPEED_DEFAULT             = 0x03,     /* Default speed                        */
-    POLYCHROME_V2_SPEED_MAX                 = 0x00,     /* Fastest speed                        */
+    POLYCHROME_MODE_OFF             = 0x10,     /* OFF mode                             */
+    POLYCHROME_MODE_STATIC          = 0x11,     /* Static color mode                    */
+    POLYCHROME_MODE_BREATHING       = 0x12,     /* Breating effect mode                 */
+    POLYCHROME_MODE_FLASHING        = 0x13,     /* Flashing effect mode                 */
+    POLYCHROME_MODE_SPECTRUM_CYCLE  = 0x14,     /* Spectrum Cycle effect mode           */
+    POLYCHROME_MODE_RANDOM          = 0x15,     /* Random effect mode                   */
+    POLYCHROME_MODE_WAVE            = 0x17,     /* Wave effect mode                     */
+    POLYCHROME_MODE_SPRING          = 0x18,     /* Spring effect mode                   */
+    POLYCHROME_MODE_STACK           = 0x19,     /* Stack effect mode                    */
+    POLYCHROME_MODE_CRAM            = 0x1A,     /* Cram effect mode                     */
+    POLYCHROME_MODE_SCAN            = 0x1B,     /* Scan effect mode                     */
+    POLYCHROME_MODE_NEON            = 0x1C,     /* Neon effect mode                     */
+    POLYCHROME_MODE_WATER           = 0x1D,     /* Water effect mode                    */
+    POLYCHROME_MODE_RAINBOW         = 0x1E,     /* Rainbow effect mode                  */
 };

 class PolychromeController
@@ -197,25 +77,20 @@ public:
    PolychromeController(i2c_smbus_interface* bus, polychrome_dev_id dev);
    ~PolychromeController();

-    std::string     GetDeviceLocation();
-    std::string     GetDeviceName();
-    std::string     GetFirmwareVersion();
+    char*           GetDeviceName();
+    unsigned int    GetLEDCount();
    unsigned int    GetMode();
-    unsigned int    GetASRockType();
-    void            SetColorsAndSpeed(unsigned char led, unsigned char red, unsigned char green, unsigned char blue);
-    void            SetMode(unsigned char zone, unsigned char mode, unsigned char speed);
+    bool            IsAsrLed();
+    void            SetColor(unsigned char red, unsigned char green, unsigned char blue);
+    void            SetMode(unsigned char mode);
+    unsigned short  GetFirmwareVersion();

-    unsigned char           zone_led_count[6];
-    
 private:
-    unsigned int            asrock_type;
-    std::string             device_name;
-    unsigned char           active_zone;
+    bool                    asr_led;
+    char                    device_name[32];
+    unsigned int            led_count;
    unsigned char           active_mode;
-    unsigned char           active_speed;
    i2c_smbus_interface*    bus;
    polychrome_dev_id       dev;

-    unsigned short  ReadFirmwareVersion();
-    void            ReadLEDConfiguration();
 };
@@ -1,4 +1,3 @@
-#include "Detector.h"
 #include "PolychromeController.h"
 #include "RGBController.h"
 #include "RGBController_Polychrome.h"
@@ -55,7 +54,7 @@ void DetectPolychromeControllers(std::vector<i2c_smbus_interface*>& busses, std:
        {
            new_polychrome = new PolychromeController(busses[bus], 0x6A);

-            if(new_polychrome->GetASRockType() != ASROCK_TYPE_UNKNOWN)
+            if(new_polychrome->GetLEDCount() != 0)
            {
                new_controller = new RGBController_Polychrome(new_polychrome);
                rgb_controllers.push_back(new_controller);
@@ -63,10 +62,8 @@ void DetectPolychromeControllers(std::vector<i2c_smbus_interface*>& busses, std:
            else
            {
                delete new_polychrome;
-            }
+            }   
        }
    }

 }   /* DetectPolychromeControllers() */
-
-REGISTER_I2C_DETECTOR("ASRock Polychrome", DetectPolychromeControllers);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Adam Honse	f8fe1d29fb	Add file headers to network files and some minor code cleanup	2020-05-09 15:47:51 -05:00
Adam Honse	42a9a9314d	Fix crash when stopping server	2020-05-09 15:44:07 -05:00
Adam Honse	41d9a66c1c	Clean up server page	2020-05-09 15:21:55 -05:00
Adam Honse	2437379506	Fix build on Windows	2020-05-08 23:23:25 -05:00
Adam Honse	f95e210260	Send client string after server is connected	2020-05-08 22:25:46 -05:00
Adam Honse	a5d37819d2	Add mutex on updating callbacks	2020-05-08 22:25:13 -05:00
Adam Honse	80917314df	Send and receive client string	2020-05-08 22:07:34 -05:00
Adam Honse	3d25fa9451	Add callback to NetworkServer to handle UI updates when client information changes	2020-05-08 21:53:53 -05:00
Adam Honse	5c4e2ee00a	Add IP field to client information and display client IP in the server tab's connected client list	2020-05-07 00:51:43 -05:00
Adam Honse	13b27fd966	Create a structure to hold client information in the network server and fix i2c hanging on destructor when bus is not available.	2020-05-06 23:57:54 -05:00
Adam Honse	a41a22d5d6	Functions to set IP and port and start client	2020-05-06 13:44:37 -05:00
Adam Honse	56572beba9	Fix build on Windows	2020-05-02 00:29:22 -05:00
Adam Honse	bbf98b2f72	Use select on accept call as well so that server closes on Linux	2020-05-02 00:23:55 -05:00
Adam Honse	0bba8539e4	Fix build on Linux	2020-05-01 23:05:10 -05:00
Adam Honse	4e00aac741	Add server information to user interface and provide buttons to start and stop server, change port	2020-05-01 22:38:45 -05:00
Adam Honse	f3b20da6a3	Server info WIP	2020-05-01 15:29:15 -05:00
Adam Honse	7ae3ce651d	Use condition variables and mutexes to eliminate sleeps from SMBus threading	2020-05-01 15:29:14 -05:00
Adam Honse	2307566dac	Handle all SMBus controller activity on a separate thread to avoid corrupting the SMBus data	2020-05-01 15:29:14 -05:00
Adam Honse	6101d9d43e	Use std::thread for NetworkClient threads	2020-05-01 15:29:14 -05:00
Adam Honse	c2541d9585	Use std::thread for NetworkServer threads	2020-05-01 15:29:14 -05:00
Adam Honse	89cc9fc912	Fix thread conflicts for HyperX keyboard in Direct mode	2020-05-01 15:29:14 -05:00
Adam Honse	24a7940787	Disable I2C devices until threading issues are resolved, don't start a NetworkClient in main	2020-05-01 15:29:14 -05:00
Adam Honse	2aa33821dd	Use TCP_NODELAY on client socket	2020-05-01 15:29:14 -05:00
Adam Honse	82232b4aef	Add key matrix map for Corsair K70 keyboards	2020-05-01 15:29:14 -05:00
Adam Honse	de13ca2cff	Fix memory leaks in client	2020-05-01 15:29:14 -05:00
Adam Honse	c45cf2466a	Get network client working on Windows	2020-05-01 15:29:14 -05:00
Adam Honse	f01aa31c3b	Get network server working in Windows	2020-05-01 15:29:13 -05:00
Adam Honse	c9f7fe8f3f	Add matrix map for HyperX Alloy Elite	2020-05-01 15:29:13 -05:00
Adam Honse	e7483e22a9	Add matrix map for Poseidon Z RGB keyboard	2020-05-01 15:29:13 -05:00
Adam Honse	438fc49127	Add matrix map support	2020-05-01 15:29:13 -05:00
Adam Honse	f62851dbab	Add zone types to HyperX and Poseidon Z RGB keyboard controllers	2020-05-01 15:29:13 -05:00
Adam Honse	5e3ad426e9	Add a thread to RGBController to asynchronously perform device updates. Only implemented for UpdateLEDs for now	2020-05-01 15:29:13 -05:00
Adam Honse	3622913291	Close server listener thread when read returns zero (client connection lost)	2020-05-01 15:29:13 -05:00
Adam Honse	dd0edb3f84	Send color data over the network when calling color update functions	2020-05-01 15:29:13 -05:00
Adam Honse	e1737fb971	Send mode data block when updating mode	2020-05-01 15:29:13 -05:00
Adam Honse	56df7d65b3	Implement RGBController_Network packet sending for current set of RGBController commands	2020-05-01 15:29:12 -05:00
Adam Honse	4eb926f8ef	Client now requests list of all controllers from server and adds them to the master list	2020-05-01 15:29:12 -05:00
Adam Honse	8fc98a035b	Create functions for sending replies	2020-05-01 15:29:12 -05:00
Adam Honse	5567db88f8	Create functions for sending requests	2020-05-01 15:29:12 -05:00
Adam Honse	b96d160ce2	Client requests controller count and first controller data block from server, prints response	2020-05-01 15:29:12 -05:00
Adam Honse	f44c6365c0	Run client from main	2020-05-01 15:29:12 -05:00
Adam Honse	94277e7d04	Start work on network client	2020-05-01 15:29:12 -05:00
Adam Honse	1d4393b5c4	Add RGBController function call packet functionality	2020-05-01 15:29:12 -05:00
Adam Honse	fa015dd558	Implement requests for number of controllers and controller information block	2020-05-01 15:29:12 -05:00
Adam Honse	5c7359fa60	Network server can now receive packets properly	2020-05-01 15:29:12 -05:00
Adam Honse	4dbe14febe	More work on network support, need to implement spawning of one read thread for each client socket	2020-05-01 15:29:12 -05:00
Adam Honse	c8346e1f7c	Start working on server request processing code	2020-05-01 15:29:11 -05:00
Adam Honse	095b9ce635	Initial network files	2020-05-01 15:29:11 -05:00