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
514 changed files with 11180 additions and 74493 deletions
@@ -1,11 +1 @@
 *.pro.user*
-*.o
-ui_*
-moc_*
-qrc_*
-OpenRGB
-openrgb
-Makefile
-OpenRGB-x86_64.AppImage
-.qmake.stash
-.vscode
@@ -1,249 +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}"
-
-#reusable templates
-.ccache_init: &ccache_init
-  before_script:
-    - apt update
-    - apt install -y build-essential qtcreator qt5-default libusb-1.0-0-dev libhidapi-dev pkgconf wget git
-
-#-----------------------------------------------------------------------#
-# Linux (AppImage) 32-bit Build Target                                  #
-#-----------------------------------------------------------------------#
-build_linux_32:
-  <<: *ccache_init
-  image: i386/ubuntu:bionic
-  stage: build
-  script:
-  - export $(dpkg-architecture)
-  - ./scripts/build-appimage.sh
-  
-  artifacts:
-    paths:
-    - OpenRGB-i386.AppImage
-    - 60-openrgb.rules
-    - README.md
-    expire_in: 30 days
-
-#-----------------------------------------------------------------------#
-# Linux (AppImage) 64-bit Build Target                                  #
-#-----------------------------------------------------------------------#
-build_linux_64:
-  <<: *ccache_init
-  image: ubuntu:bionic
-  stage: build
-  script:
-  - export $(dpkg-architecture)
-  - ./scripts/build-appimage.sh
-  
-  artifacts:
-    paths:
-    - OpenRGB-x86_64.AppImage
-    - 60-openrgb.rules
-    - README.md
-    expire_in: 30 days
-
-#-----------------------------------------------------------------------#
-# Linux (.deb) 32-bit Build Target                                      #
-#-----------------------------------------------------------------------#
-build_linux_deb32:
-  <<: *ccache_init
-  image: i386/ubuntu:bionic
-  stage: build
-  script:
-  - apt install -y debhelper
-  - dpkg-architecture -l
-  - dpkg-buildpackage --target-arch i386 -us -B
-  - rm -v ../openrgb-dbgsym*.ddeb
-  - mv -v ../openrgb*.deb ./
-
-  artifacts:
-    paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.deb
-    expire_in: 30 days
-
-#-----------------------------------------------------------------------#
-# Linux (.deb) 64-bit Build Target                                      #
-#-----------------------------------------------------------------------#
-build_linux_deb64:
-  <<: *ccache_init
-  image: ubuntu:bionic
-  stage: build
-  script:
-  - apt install -y debhelper
-  - dpkg-architecture -l
-  - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.ddeb
-  - mv -v ../openrgb*.deb ./
-
-  artifacts:
-    paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.deb
-    expire_in: 30 days
-
-#-----------------------------------------------------------------------#
-# Windows (32-bit) Build Target                                         #
-#-----------------------------------------------------------------------#
-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: 30 days
-
-#-----------------------------------------------------------------------#
-# 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: 30 days
@@ -1,14 +0,0 @@
-<!-- 
-Found a bug?  Something isn't working as expected?  To help us keep track of the requests please start the title with [Bug Report]
-->
-
-### Description of Bug
-<!--
-Please describe the bug.  Explain steps taken to reproduce the bug and what you expect the correct behavior to be.
-->
-
-
-### Hardware Configuration
-<!--
-Please list the RGB hardware that you are using with OpenRGB.  If your bug does not relate to any one particular device or device type, or if the bug is in a part of the code not directly interacting with hardware, this is optional.
-->
@@ -1,9 +0,0 @@
-<!-- 
-Have something you would like to see added to OpenRGB? Let us know here 
-To help us keep track of the requests please start the title with [Feature Request]
-->
-
-### Feature Request
-<!--
-Please explain the new feature you would like to see added in detail.  Explain how you think it should work and provide any mock-ups, code snippets, etc. that you think will help explain the feature.
-->
@@ -1,48 +0,0 @@
-<!-- 
-When naming the support request please title the request as 
-`[New Device] <Name of new device>` 
-Please open one issue per device you would lke to add
-->
-
-### Name of device:
-<!--
-Please put the name of the product, including manufacturer, beneath this line
-->
-
-
-### Link to manufacturer's product page:
-<!--
-Please link us to the manufacturer's product page beneath this line
-->
-
-
-### Please select what type of device/interface the device uses:
-<!--
-Place an x between the brackets to check the box
-->
- [ ] Motherboard (SMBus)
- [ ] Motherboard (USB)
- [ ] RAM (SMBus)
- [ ] GPU (I2C)
- [ ] External USB (Peripheral, lighting controller, etc)
- [ ] Internal USB (lighting controller, cooler, fan hub, etc)
- [ ] I don't know (we can help you determine this)
-
-### ID information:
-<!--
-For PCI (GPU) devices we will need the Vendor ID, Device ID, Sub-Vendor ID and Sub-Device IDs
-In Windows this can be found under the device manager and on Linux this can be found with lspci -vv
-For USB devices we will need the USB VID and PID
-->
-
-
-### Please attach screenshots of the device's official control application here:
-<!--
-Screenshots of the official control software should show lists of supported modes, color selection, and zone/LED selection capabilities of the device's official software.
-->
-
-
-### Please attach device captures here:
-<!--
-For information on how to capture device packets please see https://gitlab.com/Dr_No/OpenRGB/-/wikis/OpenRGB-doesn%27t-have-my-device
-->
@@ -1,334 +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                                  #
-#       Corsair LT100                                           #
-#---------------------------------------------------------------#
-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"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0a32", 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                                      #
-#                                                               #
-#  Mice:                                                        #
-#       HyperX Pulsefire Surge                                  #
-#                                                               #
-#  Mousemats:                                                   #
-#       HyperX Fury Ultra                                       #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16be", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16d3", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="1705", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Logitech Peripheral Devices                                  #
-#                                                               #
-#   Keyboards:                                                  #
-#       Logitech G213                                           #
-#       Logitech G512                                           #
-#       Logitech G512 RGB                                       #
-#       Logitech G610                                           #
-#       Logitech G810 #1                                        #
-#       Logitech G810 #2                                        #
-#                                                               #
-#  Mice:                                                        #
-#       Logitech G203 Prodigy                                   #
-#       Logitech G203 Lightsync                                 #
-#       Logitech G403 Prodigy                                   #
-#       Logitech G403 Hero                                      #
-#       Logitech G502 Proteus Spectrum                          #
-#       Logitech G Lightspeed Wireless Gaming Mouse             #
-#       Logitech G Pro Wireless Gaming Mouse (Wired)            #
-#                                                               #
-#  Mousemats:                                                   #
-#       Logitech G Powerplay Mousepad with Lightspeed           #
-#                                                               #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c336", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c342", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33c", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c333", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c331", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c337", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c084", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c092", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c083", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08f", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c332", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08b", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c539", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c088", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c53a", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  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+                                                    #
-#---------------------------------------------------------------#
-KERNEL=="ttyACM[0-9]*", ATTR{idVendor}=="04D8", ATTR{idProduct}=="00DF", 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"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="fc4d", 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"
-
-#---------------------------------------------------------------#
-#  Sinowealth USB                                               #
-#  Glorious Model O / O-                                        #
-#  Glorious Model D / D-                                        #
-#  Everest GT-100 RGB                                           #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="258a", ATTR{idProduct}=="0036", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="258a", ATTR{idProduct}=="0033", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="258a", ATTR{idProduct}=="0029", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  SteelSeries Peripheral Devices                               #
-#                                                               #
-#  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,10 +12,9 @@
 #include <stdio.h>
 #include <stdlib.h>

-AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const char* path)
+AMDWraithPrismController::AMDWraithPrismController(libusb_device_handle* dev_handle)
 {
-    dev         = dev_handle;
-    location    = path;
+    dev = dev_handle;

    strcpy(device_name, "AMD Wraith Prism");

@@ -39,34 +38,17 @@ AMDWraithPrismController::~AMDWraithPrismController()

 }

-std::string AMDWraithPrismController::GetLocationString()
-{
-    return("HID: " + location);
-}
-
 char* AMDWraithPrismController::GetDeviceName()
 {
    return device_name;
 }

-std::string AMDWraithPrismController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
 std::string AMDWraithPrismController::GetEffectChannelString(unsigned char channel)
 {
    std::string ret_string = "";

    unsigned char usb_buf[] =
    {
-        0x00,
        0x40, 0x21, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
@@ -85,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]);

@@ -101,7 +85,6 @@ std::string AMDWraithPrismController::GetFirmwareVersionString()

    unsigned char usb_buf[] =
    {
-        0x00,
        0x12, 0x20, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
@@ -120,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)
    {
@@ -225,7 +209,6 @@ void AMDWraithPrismController::SendEnableCommand()
 {
    unsigned char usb_buf[] =
    {
-        0x00,
        0x41, 0x80, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
@@ -244,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,
@@ -271,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
@@ -290,7 +276,6 @@ void AMDWraithPrismController::SendEffectChannelUpdate
 {
    unsigned char usb_buf[] =
    {
-        0x00,
        0x51, 0x2C, 0x01, 0x00,
        0x05, 0xFF, 0x00, 0x01,
        0xFF, 0xFF, 0x00, 0xFF,
@@ -309,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,
@@ -347,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,15 +109,13 @@ enum
 class AMDWraithPrismController
 {
 public:
-    AMDWraithPrismController(hid_device* dev_handle, const char* path);
+    AMDWraithPrismController(libusb_device_handle* dev_handle);
    ~AMDWraithPrismController();

    char* GetDeviceName();

    std::string GetEffectChannelString(unsigned char channel);
    std::string GetFirmwareVersionString();
-    std::string GetLocationString();
-    std::string GetSerialString();

    void SetRingEffectChannel(unsigned char channel);

@@ -132,8 +130,7 @@ public:

 private:
    char                    device_name[32];
-    hid_device*             dev;
-    std::string             location;
+    libusb_device_handle*   dev;

    unsigned char           current_fan_mode;
    unsigned char           current_fan_speed;
@@ -1,8 +1,8 @@
-#include "Detector.h"
 #include "AMDWraithPrismController.h"
 #include "RGBController.h"
 #include "RGBController_AMDWraithPrism.h"
-#include <hidapi/hidapi.h>
+#include <vector>
+#include <libusb-1.0/libusb.h>

 #define AMD_WRAITH_PRISM_VID 0x2516
 #define AMD_WRAITH_PRISM_PID 0x0051
@@ -15,16 +15,23 @@
 *                                                                                          *
 \******************************************************************************************/

-void DetectAMDWraithPrismControllers(hid_device_info* info, const std::string&)
+void DetectAMDWraithPrismControllers(std::vector<RGBController*>& rgb_controllers)
 {
-    hid_device* dev = hid_open_path(info->path);
+    libusb_context * ctx;
+    libusb_init(&ctx);
+
+    //Look for AMD Wraith Prism
+    libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, AMD_WRAITH_PRISM_VID, AMD_WRAITH_PRISM_PID);
+
    if( dev )
    {
-        AMDWraithPrismController* controller = new AMDWraithPrismController(dev, info->path);
+        libusb_detach_kernel_driver(dev, 1);
+        libusb_claim_interface(dev, 1);
+
+        AMDWraithPrismController* controller = new AMDWraithPrismController(dev);
+
        RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+
+        rgb_controllers.push_back(rgb_controller);
    }
 }
-
-REGISTER_HID_DETECTOR_IP("AMD Wraith Prism", DetectAMDWraithPrismControllers, AMD_WRAITH_PRISM_VID, AMD_WRAITH_PRISM_PID, 1, 0xFF00);
@@ -1,342 +0,0 @@
-/*-----------------------------------------*\
-|  ASRockPolychromeSMBusController.cpp      |
-|                                           |
-|  Driver for for ASRock ASR LED and        |
-|  Polychrome RGB lighting controller       |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/14/2019  |
-\*-----------------------------------------*/
-
-#include "ASRockPolychromeSMBusController.h"
-#include <cstring>
-#include "dependencies/dmiinfo.h"
-
-using namespace std::chrono_literals;
-
-PolychromeController::PolychromeController(i2c_smbus_interface* bus, polychrome_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-
-    DMIInfo dmi;
-
-    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)
-    {
-        case ASROCK_TYPE_ASRLED:
-            device_name = "ASRock " + dmi.getMainboard();
-            asrock_type = ASROCK_TYPE_ASRLED;
-            memset(zone_led_count, 0, sizeof(zone_led_count));
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V1:
-            device_name = "ASRock " + dmi.getMainboard();
-            asrock_type = ASROCK_TYPE_POLYCHROME_V1;
-            ReadLEDConfiguration();
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V2:
-            device_name = "ASRock " + dmi.getMainboard();
-            asrock_type = ASROCK_TYPE_POLYCHROME_V2;
-            ReadLEDConfiguration();
-            break;
-
-        default:
-            asrock_type = ASROCK_TYPE_UNKNOWN;
-            break;
-    }
-}
-
-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("I2C: " + return_string);
-}
-
-std::string 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()
-{
-    // 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)
-    {
-        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);
-    }
-    else
-    {
-        return(0xFFFF);
-    }
-}
-
-void PolychromeController::ReadLEDConfiguration()
-{
-    /*---------------------------------------------------------------------------------*\
-    | The LED configuration register holds 6 bytes, so the first read should return 6   |
-    | If not, set all zone sizes to zero                                                |
-    \*---------------------------------------------------------------------------------*/
-    if (bus->i2c_smbus_read_byte_data(dev, POLYCHROME_REG_LED_CONFIG) == 0x06)
-    {
-        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));
-    }
-}
-
-unsigned int PolychromeController::GetMode()
-{
-    return(active_mode);
-}
-
-void PolychromeController::SetColorsAndSpeed(unsigned char led, unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char color_speed_pkt[4] = { red, green, blue, active_speed };
-    unsigned char select_led_pkt[1]  = { led };
-    
-    switch(asrock_type)
-    {
-        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;
-    }
-}
-
-void PolychromeController::SetMode(unsigned char zone,unsigned char mode, unsigned char speed)
-{
-    unsigned char led_count_pkt[1]  = { 0x00 };
-    active_zone                     = zone;
-    active_mode                     = mode;
-    active_speed                    = speed;
-
-    switch(asrock_type)
-    {
-        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;
-    }    
-}
@@ -1,221 +0,0 @@
-/*-----------------------------------------*\
-|  ASRockPolychromeSMBusController.h        |
-|                                           |
-|  Definitions and types for ASRock         |
-|  ASR LED and Polychrome RGB lighting      |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/13/2019  |
-\*-----------------------------------------*/
-
-#include "i2c_smbus.h"
-#include <string>
-
-#pragma once
-
-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  */
-};
-
-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     */
-};
-
-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          */
-};
-
-/*----------------------------------------------------------------------------------------------*\
-| Definitions for ASR LED                                                                        |
-\*----------------------------------------------------------------------------------------------*/
-#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_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                        */
-};
-
-class PolychromeController
-{
-public:
-    PolychromeController(i2c_smbus_interface* bus, polychrome_dev_id dev);
-    ~PolychromeController();
-
-    std::string     GetDeviceLocation();
-    std::string     GetDeviceName();
-    std::string     GetFirmwareVersion();
-    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);
-
-    unsigned char           zone_led_count[6];
-    
-private:
-    unsigned int            asrock_type;
-    std::string             device_name;
-    unsigned char           active_zone;
-    unsigned char           active_mode;
-    unsigned char           active_speed;
-    i2c_smbus_interface*    bus;
-    polychrome_dev_id       dev;
-
-    unsigned short  ReadFirmwareVersion();
-    void            ReadLEDConfiguration();
-};
@@ -1,635 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_ASRockPolychromeSMBus.cpp  |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  ASRock ASR LED and Polychrome RGB Driver |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/15/2019  |
-\*-----------------------------------------*/
-
-#include "RGBController_ASRockPolychromeSMBus.h"
-
-#define ASROCK_MAX_ZONES    4
-#define ASROCK_MAX_LEDS     22
-
-static const char* polychrome_v1_zone_names[] =
-{
-    "RGB LED 1 Header",
-    "RGB LED 2 Header",
-    "PCH",
-    "IO Cover",
-    "Audio",
-    "Addressable Header"
-};
-
-static const char* polychrome_v2_zone_names[] =
-{
-    "RGB LED 1 Header",
-    "RGB LED 2 Header",
-    "Audio",
-    "PCH",
-    "IO Cover",
-    "Addressable Header"
-};
-
-RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychrome_ptr)
-{
-    polychrome = polychrome_ptr;
-
-    name        = polychrome->GetDeviceName();
-    vendor      = "ASRock";
-    version     = polychrome->GetFirmwareVersion();
-    type        = DEVICE_TYPE_MOTHERBOARD;
-    location    = polychrome->GetDeviceLocation();
-
-    switch(polychrome->GetASRockType())
-    {
-        case ASROCK_TYPE_ASRLED:
-            {
-                description = "ASRock ASR LED Device";
-
-                mode Off;
-                Off.name       = "Off";
-                Off.value      = ASRLED_MODE_OFF;
-                Off.flags      = 0;
-                Off.color_mode = MODE_COLORS_NONE;
-                modes.push_back(Off);
-
-                mode Static;
-                Static.name       = "Static";
-                Static.value      = ASRLED_MODE_STATIC;
-                Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-                Static.color_mode = MODE_COLORS_PER_LED;
-                modes.push_back(Static);
-
-                mode Breathing;
-                Breathing.name       = "Breathing";
-                Breathing.value      = ASRLED_MODE_BREATHING;
-                Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Breathing.speed_min  = ASRLED_SPEED_MIN;
-                Breathing.speed_max  = ASRLED_SPEED_MAX;
-                Breathing.speed      = ASRLED_SPEED_DEFAULT;
-                Breathing.color_mode = MODE_COLORS_PER_LED;
-                modes.push_back(Breathing);
-
-                mode Strobe;
-                Strobe.name       = "Strobe";
-                Strobe.value      = ASRLED_MODE_STROBE;
-                Strobe.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Strobe.speed_min  = ASRLED_SPEED_MIN;
-                Strobe.speed_max  = ASRLED_SPEED_MAX;
-                Strobe.speed      = ASRLED_SPEED_DEFAULT;
-                Strobe.color_mode = MODE_COLORS_PER_LED;
-                modes.push_back(Strobe);
-
-                mode SpectrumCycle;
-                SpectrumCycle.name       = "Spectrum Cycle";
-                SpectrumCycle.value      = ASRLED_MODE_SPECTRUM_CYCLE;
-                SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED;
-                SpectrumCycle.speed_min  = ASRLED_SPEED_MIN;
-                SpectrumCycle.speed_max  = ASRLED_SPEED_MAX;
-                SpectrumCycle.speed      = ASRLED_SPEED_DEFAULT;
-                SpectrumCycle.color_mode = MODE_COLORS_NONE;
-                modes.push_back(SpectrumCycle);
-
-                mode Random;
-                Random.name       = "Random";
-                Random.value      = ASRLED_MODE_RANDOM;
-                Random.flags      = MODE_FLAG_HAS_SPEED;
-                Random.speed_min  = ASRLED_SPEED_MIN;
-                Random.speed_max  = ASRLED_SPEED_MAX;
-                Random.speed      = ASRLED_SPEED_DEFAULT;
-                Random.color_mode = MODE_COLORS_NONE;
-                modes.push_back(Random);
-
-                mode Music;
-                Music.name       = "Music";
-                Music.value      = ASRLED_MODE_MUSIC;
-                Music.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-                Music.color_mode = MODE_COLORS_PER_LED;
-                modes.push_back(Music);
-
-                mode Wave;
-                Wave.name       = "Wave";
-                Wave.value      = ASRLED_MODE_WAVE;
-                Wave.flags      = MODE_FLAG_HAS_SPEED;
-                Wave.speed_min  = ASRLED_SPEED_MIN;
-                Wave.speed_max  = ASRLED_SPEED_MAX;
-                Wave.speed      = ASRLED_SPEED_DEFAULT;
-                Wave.color_mode = MODE_COLORS_NONE;
-                modes.push_back(Wave);
-            }
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V1:
-            {
-                description = "ASRock Polychrome v1 Device";
-
-                mode Off;
-                Off.name                    = "Off";
-                Off.value                   = POLYCHROME_V1_MODE_OFF;
-                Off.flags                   = 0;
-                Off.color_mode              = MODE_COLORS_NONE;
-                modes.push_back(Off);
-
-                mode Static;
-                Static.name                 = "Static";
-                Static.value                = POLYCHROME_V1_MODE_STATIC;
-                Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-                Static.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Static);
-
-                mode Breathing;
-                Breathing.name              = "Breathing";
-                Breathing.value             = POLYCHROME_V1_MODE_BREATHING;
-                Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Breathing.speed_min         = POLYCHROME_V1_SPEED_MIN_BREATHING;
-                Breathing.speed_max         = POLYCHROME_V1_SPEED_MAX_BREATHING;
-                Breathing.speed             = POLYCHROME_V1_SPEED_DEFAULT_BREATHING;
-                Breathing.color_mode        = MODE_COLORS_PER_LED;
-                modes.push_back(Breathing);
-
-                mode Strobe;
-                Strobe.name                 = "Strobe";
-                Strobe.value                = POLYCHROME_V1_MODE_STROBE;
-                Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Strobe.speed_min            = POLYCHROME_V1_SPEED_MIN_STROBE;
-                Strobe.speed_max            = POLYCHROME_V1_SPEED_MAX_STROBE;
-                Strobe.speed                = POLYCHROME_V1_SPEED_DEFAULT_STROBE;
-                Strobe.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Strobe);
-
-                mode SpectrumCycle;
-                SpectrumCycle.name          = "Spectrum Cycle";
-                SpectrumCycle.value         = POLYCHROME_V1_MODE_SPECTRUM_CYCLE;
-                SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED;
-                SpectrumCycle.speed_min     = POLYCHROME_V1_SPEED_MIN_CYCLE;
-                SpectrumCycle.speed_max     = POLYCHROME_V1_SPEED_MAX_CYCLE;
-                SpectrumCycle.speed         = POLYCHROME_V1_SPEED_DEFAULT_CYCLE;
-                SpectrumCycle.color_mode    = MODE_COLORS_NONE;
-                modes.push_back(SpectrumCycle);
-
-                mode Random;
-                Random.name                 = "Random";
-                Random.value                = POLYCHROME_V1_MODE_RANDOM;
-                Random.flags                = MODE_FLAG_HAS_SPEED;
-                Random.speed_min            = POLYCHROME_V1_SPEED_MIN_RANDOM;
-                Random.speed_max            = POLYCHROME_V1_SPEED_MAX_RANDOM;
-                Random.speed                = POLYCHROME_V1_SPEED_DEFAULT_RANDOM;
-                Random.color_mode           = MODE_COLORS_NONE;
-                modes.push_back(Random);
-
-                mode Music;
-                Music.name                 = "Music";
-                Music.value                = POLYCHROME_V1_MODE_MUSIC;
-                Music.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-                Music.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Music);
-
-                mode Wave;
-                Wave.name                   = "Wave";
-                Wave.value                  = POLYCHROME_V1_MODE_WAVE;
-                Wave.flags                  = MODE_FLAG_HAS_SPEED;
-                Wave.speed_min              = POLYCHROME_V1_SPEED_MIN_WAVE;
-                Wave.speed_max              = POLYCHROME_V1_SPEED_MAX_WAVE;
-                Wave.speed                  = POLYCHROME_V1_SPEED_DEFAULT_WAVE;
-                Wave.color_mode             = MODE_COLORS_NONE;
-                modes.push_back(Wave);
-
-                /*---------------------------------------------------------------------*\
-                | Comment out until per zone modes are working. These are only for ARGB |
-                \*---------------------------------------------------------------------*/
-//                mode Spring;
-//                Spring.name                 = "Spring";
-//                Spring.value                = POLYCHROME_V1_MODE_SPRING;
-//                Spring.flags                = MODE_FLAG_HAS_SPEED;
-//                Spring.speed_min            = POLYCHROME_V1_SPEED_MIN_ARGB;
-//                Spring.speed_max            = POLYCHROME_V1_SPEED_MAX_ARGB;
-//                Spring.speed                = POLYCHROME_V1_SPEED_DEFAULT_SPRING;
-//                Spring.color_mode           = MODE_COLORS_PER_LED;
-//                modes.push_back(Spring);
-
-//                mode Stack;
-//                Stack.name                  = "Stack";
-//                Stack.value                 = POLYCHROME_V1_MODE_STACK;
-//                Stack.flags                 = MODE_FLAG_HAS_SPEED;
-//                Stack.speed_min             = POLYCHROME_V1_SPEED_MIN_ARGB;
-//                Stack.speed_max             = POLYCHROME_V1_SPEED_MAX_ARGB;
-//                Stack.speed                 = POLYCHROME_V1_SPEED_DEFAULT_STACK;
-//                Stack.color_mode            = MODE_COLORS_PER_LED;
-//                modes.push_back(Stack);
-
-//                mode Cram;
-//                Cram.name                   = "Cram";
-//                Cram.value                  = POLYCHROME_V1_MODE_CRAM;
-//                Cram.flags                  = MODE_FLAG_HAS_SPEED;
-//                Cram.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
-//                Cram.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
-//                Cram.speed                  = POLYCHROME_V1_SPEED_DEFAULT_CRAM;
-//                Cram.color_mode             = MODE_COLORS_PER_LED;
-//                modes.push_back(Cram);
-
-//                mode Scan;
-//                Scan.name                   = "Scan";
-//                Scan.value                  = POLYCHROME_V1_MODE_SCAN;
-//                Scan.flags                  = MODE_FLAG_HAS_SPEED;
-//                Scan.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
-//                Scan.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
-//                Scan.speed                  = POLYCHROME_V1_SPEED_DEFAULT_SCAN;
-//                Scan.color_mode             = MODE_COLORS_PER_LED;
-//                modes.push_back(Scan);
-
-//                mode Neon;
-//                Neon.name                   = "Neon";
-//                Neon.value                  = POLYCHROME_V1_MODE_NEON;
-//                Neon.flags                  = MODE_FLAG_HAS_SPEED;
-//                Neon.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
-//                Neon.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
-//                Neon.speed                  = POLYCHROME_V1_SPEED_DEFAULT_NEON;
-//                Neon.color_mode             = MODE_COLORS_PER_LED;
-//                modes.push_back(Neon);
-
-//                mode Water;
-//                Water.name                  = "Water";
-//                Water.value                 = POLYCHROME_V1_MODE_WATER;
-//                Water.flags                 = MODE_FLAG_HAS_SPEED;
-//                Water.speed_min             = POLYCHROME_V1_SPEED_MIN_ARGB;
-//                Water.speed_max             = POLYCHROME_V1_SPEED_MAX_ARGB;
-//                Water.speed                 = POLYCHROME_V1_SPEED_DEFAULT_WATER;
-//                Water.color_mode            = MODE_COLORS_PER_LED;
-//                modes.push_back(Water);
-
-//                mode Rainbow;
-//                Rainbow.name                = "Rainbow";
-//                Rainbow.value               = POLYCHROME_V1_MODE_RAINBOW;
-//                Rainbow.flags               = MODE_FLAG_HAS_SPEED;
-//                Rainbow.speed_min           = POLYCHROME_V1_SPEED_MIN_RAINBOW;
-//                Rainbow.speed_max           = POLYCHROME_V1_SPEED_MAX_RAINBOW;
-//                Rainbow.speed               = POLYCHROME_V1_SPEED_DEFAULT_RAINBOW;
-//                Rainbow.color_mode          = MODE_COLORS_NONE;
-//                modes.push_back(Rainbow);
-            }
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V2:
-            {
-                description = "ASRock Polychrome v2 Device";
-
-                mode Off;
-                Off.name       = "Off";
-                Off.value      = POLYCHROME_V2_MODE_OFF;
-                Off.flags      = 0;
-                Off.color_mode = MODE_COLORS_NONE;
-                modes.push_back(Off);
-
-                mode Static;
-                Static.name       = "Static";
-                Static.value      = POLYCHROME_V2_MODE_STATIC;
-                Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-                Static.color_mode = MODE_COLORS_PER_LED;
-                modes.push_back(Static);
-
-                mode Breathing;
-                Breathing.name       = "Breathing";
-                Breathing.value      = POLYCHROME_V2_MODE_BREATHING;
-                Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Breathing.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Breathing.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Breathing.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Breathing.color_mode = MODE_COLORS_PER_LED;
-                modes.push_back(Breathing);
-
-                mode Strobe;
-                Strobe.name       = "Strobe";
-                Strobe.value      = POLYCHROME_V2_MODE_STROBE;
-                Strobe.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Strobe.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Strobe.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Strobe.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Strobe.color_mode = MODE_COLORS_PER_LED;
-                modes.push_back(Strobe);
-
-                mode SpectrumCycle;
-                SpectrumCycle.name       = "Spectrum Cycle";
-                SpectrumCycle.value      = POLYCHROME_V2_MODE_SPECTRUM_CYCLE;
-                SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED;
-                SpectrumCycle.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                SpectrumCycle.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                SpectrumCycle.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                SpectrumCycle.color_mode = MODE_COLORS_NONE;
-                modes.push_back(SpectrumCycle);
-
-                mode Random;
-                Random.name       = "Random";
-                Random.value      = POLYCHROME_V2_MODE_RANDOM;
-                Random.flags      = MODE_FLAG_HAS_SPEED;
-                Random.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Random.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Random.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Random.color_mode = MODE_COLORS_NONE;
-                modes.push_back(Random);
-
-                mode Wave;
-                Wave.name       = "Wave";
-                Wave.value      = POLYCHROME_V2_MODE_WAVE;
-                Wave.flags      = MODE_FLAG_HAS_SPEED;
-                Wave.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Wave.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Wave.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Wave.color_mode = MODE_COLORS_NONE;
-                modes.push_back(Wave);
-
-                mode Spring;
-                Spring.name       = "Spring";
-                Spring.value      = POLYCHROME_V2_MODE_SPRING;
-                Spring.flags      = MODE_FLAG_HAS_SPEED;
-                Spring.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Spring.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Spring.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Spring.color_mode = MODE_COLORS_NONE;
-                modes.push_back(Spring);
-
-                mode Stack;
-                Stack.name       = "Stack";
-                Stack.value      = POLYCHROME_V2_MODE_STACK;
-                Stack.flags      = MODE_FLAG_HAS_SPEED;
-                Stack.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Stack.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Stack.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Stack.color_mode = MODE_COLORS_NONE;
-                modes.push_back(Stack);
-
-                mode Cram;
-                Cram.name       = "Cram";
-                Cram.value      = POLYCHROME_V2_MODE_CRAM;
-                Cram.flags      = MODE_FLAG_HAS_SPEED;
-                Cram.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Cram.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Cram.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Cram.color_mode = MODE_COLORS_NONE;
-                modes.push_back(Cram);
-
-                mode Scan;
-                Scan.name       = "Scan";
-                Scan.value      = POLYCHROME_V2_MODE_SCAN;
-                Scan.flags      = MODE_FLAG_HAS_SPEED;
-                Scan.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Scan.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Scan.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Scan.color_mode = MODE_COLORS_NONE;
-                modes.push_back(Scan);
-
-                mode Neon;
-                Neon.name       = "Neon";
-                Neon.value      = POLYCHROME_V2_MODE_NEON;
-                Neon.flags      = 0;
-                Neon.color_mode = MODE_COLORS_NONE;
-                modes.push_back(Neon);
-
-                mode Water;
-                Water.name       = "Water";
-                Water.value      = POLYCHROME_V2_MODE_WATER;
-                Water.flags      = MODE_FLAG_HAS_SPEED;
-                Water.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Water.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Water.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Water.color_mode = MODE_COLORS_NONE;
-                modes.push_back(Water);
-
-                mode Rainbow;
-                Rainbow.name       = "Rainbow";
-                Rainbow.value      = POLYCHROME_V2_MODE_RAINBOW;
-                Rainbow.flags      = MODE_FLAG_HAS_SPEED;
-                Rainbow.speed_min  = POLYCHROME_V2_SPEED_MIN;
-                Rainbow.speed_max  = POLYCHROME_V2_SPEED_MAX;
-                Rainbow.speed      = POLYCHROME_V2_SPEED_DEFAULT;
-                Rainbow.color_mode = MODE_COLORS_NONE;
-                modes.push_back(Rainbow);
-            }
-            break;
-    }
-
-    SetupZones();
-}
-
-void RGBController_Polychrome::SetupZones()
-{
-    switch(polychrome->GetASRockType())
-    {
-        /*---------------------------------------------------------*\
-        | ASR LED motherboards only have a single zone/LED          |
-        \*---------------------------------------------------------*/
-        case ASROCK_TYPE_ASRLED:
-            {
-                /*---------------------------------------------------------*\
-                | Set up zones                                              |
-                \*---------------------------------------------------------*/
-                zone* new_zone = new zone();
-
-                /*---------------------------------------------------------*\
-                | Set single zone name to "Motherboard"                     |
-                \*---------------------------------------------------------*/
-                new_zone->name          = "Motherboard";
-                new_zone->type          = ZONE_TYPE_SINGLE;
-                new_zone->leds_min      = 1;
-                new_zone->leds_max      = 1;
-                new_zone->leds_count    = 1;
-                new_zone->matrix_map    = NULL;
-
-                /*---------------------------------------------------------*\
-                | Push new zone to zones vector                             |
-                \*---------------------------------------------------------*/
-                zones.push_back(*new_zone);
-
-                /*---------------------------------------------------------*\
-                | Set up LEDs                                               |
-                \*---------------------------------------------------------*/
-                led* new_led = new led();
-
-                /*---------------------------------------------------------*\
-                | Set single LED name to "Motherboard"                      |
-                \*---------------------------------------------------------*/
-                new_led->name           = "Motherboard";
-
-                /*---------------------------------------------------------*\
-                | Push new LED to LEDs vector                               |
-                \*---------------------------------------------------------*/
-                leds.push_back(*new_led);
-            }
-            break;
-
-        /*---------------------------------------------------------*\
-        | Polychrome motherboards should set up zones based on LED  |
-        | configuration register read from device                   |
-        \*---------------------------------------------------------*/
-        case ASROCK_TYPE_POLYCHROME_V1:
-        case ASROCK_TYPE_POLYCHROME_V2:
-            {
-                /*---------------------------------------------------------*\
-                | Set up zones                                              |
-                \*---------------------------------------------------------*/
-                for(unsigned int zone_idx = 0; zone_idx < POLYCHROME_ZONE_COUNT; zone_idx++)
-                {
-                    if(polychrome->zone_led_count[zone_idx] > 0)
-                    {
-                        zone* new_zone = new zone();
-
-                        /*---------------------------------------------------------*\
-                        | Set zone name to channel name                             |
-                        \*---------------------------------------------------------*/
-                        if(polychrome->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
-                        {
-                            new_zone->name          = polychrome_v1_zone_names[zone_idx];
-                        }
-                        else
-                        {
-                            new_zone->name          = polychrome_v2_zone_names[zone_idx];
-                        }
-                        
-                        if(zone_idx == POLYCHROME_ZONE_ADDRESSABLE)
-                        {
-                            new_zone->leds_min      = 1;
-                            new_zone->leds_max      = 1;
-                            new_zone->leds_count    = 1;
-                        }
-                        else
-                        {
-                            new_zone->leds_min      = polychrome->zone_led_count[zone_idx];
-                            new_zone->leds_max      = polychrome->zone_led_count[zone_idx];
-                            new_zone->leds_count    = polychrome->zone_led_count[zone_idx];
-                        }
-
-                        if(new_zone->leds_count > 1)
-                        {
-                            new_zone->type          = ZONE_TYPE_LINEAR;
-                        }
-                        else
-                        {
-                            new_zone->type          = ZONE_TYPE_SINGLE;
-                        }
-
-                        new_zone->matrix_map        = NULL;
-
-                        /*---------------------------------------------------------*\
-                        | Push new zone to zones vector                             |
-                        \*---------------------------------------------------------*/
-                        zones.push_back(*new_zone);
-                    }
-                }
-
-                unsigned int led_count = 0;
-                /*---------------------------------------------------------*\
-                | Set up LEDs                                               |
-                \*---------------------------------------------------------*/
-                for(unsigned int zone_idx = 0; zone_idx < POLYCHROME_ZONE_COUNT; zone_idx++)
-                {
-                    if(polychrome->zone_led_count[zone_idx] > 0)
-                    {
-                        for(unsigned int led_idx = 0; led_idx < polychrome->zone_led_count[zone_idx]; led_idx++)
-                        {
-                            /*---------------------------------------------------------*\
-                            | Each zone only has one LED                                |
-                            \*---------------------------------------------------------*/
-                            led* new_led = new led();
-
-                            if(polychrome->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
-                                {
-                                    new_led->name           = polychrome_v1_zone_names[zone_idx];
-                                }
-                                else
-                                {
-                                    new_led->name           = polychrome_v2_zone_names[zone_idx];
-                                }
-
-                            new_led->name.append(" " + std::to_string(led_idx + 1));
-                            new_led->value = 0;
-
-                            if(polychrome->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
-                            {
-                                new_led->value              = zone_idx;
-                            }
-                            else if(zone_idx == POLYCHROME_ZONE_ADDRESSABLE)
-                            {
-                                new_led->value              = 0x19;
-                            }
-
-                            /*---------------------------------------------------------*\
-                            | Push new LED to LEDs vector                               |
-                            \*---------------------------------------------------------*/
-                            leds.push_back(*new_led);
-
-                            led_count++;
-
-                            if(zone_idx == POLYCHROME_ZONE_ADDRESSABLE)
-                            {
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-            break;
-    }
-
-    SetupColors();
-}
-
-void RGBController_Polychrome::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_Polychrome::DeviceUpdateLEDs()
-{
-    for (std::size_t led = 0; led < colors.size(); led++)
-    {
-        UpdateSingleLED(led);
-    }
-}
-
-void RGBController_Polychrome::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_Polychrome::UpdateSingleLED(int led)
-{
-    unsigned char red = RGBGetRValue(colors[led]);
-    unsigned char grn = RGBGetGValue(colors[led]);
-    unsigned char blu = RGBGetBValue(colors[led]);
-
-    /*---------------------------------------------------------*\
-    | If the LED value is non-zero, this LED overrides the LED  |
-    | index                                                     |
-    \*---------------------------------------------------------*/
-    if(leds[led].value != 0)
-    {
-        led = leds[led].value;
-    }
-
-    polychrome->SetColorsAndSpeed(led, red, grn, blu);
-}
-
-void RGBController_Polychrome::SetCustomMode()
-{
-    active_mode = 1;
-}
-
-void RGBController_Polychrome::DeviceUpdateMode()
-{
-    if(polychrome->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
-    {
-        for(unsigned int led_idx = 0; led_idx <= leds.size(); led_idx++)
-        {
-            polychrome->SetMode(led_idx, modes[active_mode].value, modes[active_mode].speed);
-        }
-    }
-    else
-    {
-        polychrome->SetMode(0, modes[active_mode].value, modes[active_mode].speed);
-    }
-
-    DeviceUpdateLEDs();
-}
@@ -1,31 +0,0 @@
-#include "Detector.h"
-#include "AsusAuraCoreController.h"
-#include "RGBController.h"
-#include "RGBController_AsusAuraCore.h"
-#include <hidapi/hidapi.h>
-
-#define AURA_CORE_VID 0x0B05
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAuraCoreControllers                                                              *
-*                                                                                          *
-*       Tests the USB address to see if an Asus ROG Aura Core controller exists there      *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string&)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
-    {
-        AuraCoreController* controller = new AuraCoreController(dev, info->path);
-        RGBController_AuraCore* rgb_controller = new RGBController_AuraCore(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1854);
-REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1866);
-REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1869);
@@ -1,144 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraAddressableController.cpp        |
-|                                           |
-|  Driver for ASUS Aura RGB Addressable     |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/18/2020   |
-\*-----------------------------------------*/
-
-#include "AsusAuraAddressableController.h"
-#include <cstring>
-
-AuraAddressableController::AuraAddressableController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
-{
-    /*-----------------------------------------------------*\
-    | 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 @@
-/*-----------------------------------------*\
-|  AsusAuraAddressableController.h          |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  Addressable RGB lighting controller      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/18/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include "AsusAuraUSBController.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, const char* path);
-    ~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 @@
-/*-----------------------------------------*\
-|  AsusAuraMainboardController.cpp          |
-|                                           |
-|  Driver for ASUS Aura RGB USB mainboard   |
-|  lighting controller                      |
-|                                           |
-|  Martin Hartl (inlart) 4/25/2020          |
-\*-----------------------------------------*/
-
-#include "AsusAuraMainboardController.h"
-#include <cstring>
-
-AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path), 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 @@
-/*-----------------------------------------*\
-|  AsusAuraMainboardController.h            |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB Mainboard RGB lighting controller    |
-|                                           |
-|  Martin Hartl (inlart) 4/25/2020          |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include "AsusAuraUSBController.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, const char* path);
-    ~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,75 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraMouseController.cpp              |
-|                                           |
-|  Driver for ASUS Aura RGB USB             |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 10/23/2020  |
-\*-----------------------------------------*/
-
-#include "AsusAuraMouseController.h"
-
-#include <cstring>
-
-AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-AuraMouseController::~AuraMouseController()
-{
-
-}
-
-std::string AuraMouseController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AuraMouseController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-void AuraMouseController::SendUpdate
-    (
-    unsigned char   zone,
-    unsigned char   mode,
-    unsigned char   red,
-    unsigned char   grn,
-    unsigned char   blu
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x51;
-    usb_buf[0x02]   = 0x28;
-    usb_buf[0x03]   = zone;
-    usb_buf[0x04]   = 0x00;
-    usb_buf[0x05]   = mode;
-    usb_buf[0x06]   = 0x04;
-    usb_buf[0x07]   = red;
-    usb_buf[0x08]   = grn;
-    usb_buf[0x09]   = blu;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}
@@ -1,55 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraMouseController.h                |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB RGB lighting controller              |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 10/23/2020  |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <vector>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    AURA_MOUSE_ZONE_LOGO        = 0,
-    AURA_MOUSE_ZONE_SCROLL      = 1,
-    AURA_MOUSE_ZONE_UNDERGLOW   = 2,
-    AURA_MOUSE_ZONE_ALL         = 3,
-};
-
-enum
-{
-    AURA_MOUSE_MODE_STATIC      = 0,
-    AURA_MOUSE_MODE_BREATHING   = 1,
-    AURA_MOUSE_MODE_COLOR_CYCLE = 2,
-    AURA_MOUSE_MODE_REACTIVE    = 3,
-};
-
-class AuraMouseController
-{
-public:
-    AuraMouseController(hid_device* dev_handle, const char* path);
-    virtual ~AuraMouseController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void SendUpdate
-        (
-        unsigned char   zone,
-        unsigned char   mode,
-        unsigned char   red,
-        unsigned char   grn,
-        unsigned char   blu
-        );
-
-private:
-    hid_device*                 dev;
-    std::string                 location;
-};
@@ -1,172 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraUSBController.cpp                |
-|                                           |
-|  Driver for ASUS Aura RGB USB             |
-|  lighting controller                      |
-|                                           |
-|  Martin Hartl (inlart) 4/25/2020          |
-\*-----------------------------------------*/
-
-#include "AsusAuraUSBController.h"
-#include <cstring>
-#include <stdexcept>
-
-AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-
-    GetFirmwareVersion();
-    GetConfigTable();
-}
-
-AuraUSBController::~AuraUSBController()
-{
-
-}
-
-unsigned int AuraUSBController::GetChannelCount()
-{
-    return(device_info.size());
-}
-
-std::string AuraUSBController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AuraUSBController::GetDeviceName()
-{
-    return(device_name);
-}
-
-std::string AuraUSBController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-const std::vector<AuraDeviceInfo>& AuraUSBController::GetAuraDevices() const
-{
-    return(device_info);
-}
-
-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,76 +0,0 @@
-#include "Detector.h"
-#include "AsusAuraAddressableController.h"
-#include "AsusAuraMainboardController.h"
-#include "AsusAuraMouseController.h"
-#include "RGBController.h"
-#include "RGBController_AsusAuraUSB.h"
-#include "RGBController_AsusAuraMouse.h"
-#include <stdexcept>
-#include <hidapi/hidapi.h>
-
-#define AURA_USB_VID                            0x0B05
-#define AURA_TERMINAL_PID                       0x1889
-#define AURA_ADDRESSABLE_1_PID                  0x1867
-#define AURA_ADDRESSABLE_2_PID                  0x1872
-#define AURA_ADDRESSABLE_3_PID                  0x18A3
-#define AURA_ADDRESSABLE_4_PID                  0x18A5
-#define AURA_MOTHERBOARD_1_PID                  0x18F3
-#define AURA_MOTHERBOARD_2_PID                  0x1939
-#define AURA_ROG_GLADIUS_II_CORE_PID            0x18DD
-#define AURA_ROG_GLADIUS_II_PID                 0x1845
-#define AURA_ROG_GLADIUS_II_ORIGIN_PID          0x1877
-
-void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AuraAddressableController* controller = new AuraAddressableController(dev, info->path);
-        RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        try
-        {
-            AuraMainboardController* controller = new AuraMainboardController(dev, info->path);
-            RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
-            rgb_controller->name = name;
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
-        }
-        catch(std::runtime_error&)
-        {
-            // reading the config table failed
-        }
-    }
-}
-
-void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        AuraMouseController* controller = new AuraMouseController(dev, info->path);
-        RGBController_AuraMouse* rgb_controller = new RGBController_AuraMouse(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR   ("ASUS ROG AURA Terminal",     DetectAsusAuraUSBAddressable,  AURA_USB_VID, AURA_TERMINAL_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",      DetectAsusAuraUSBAddressable,  AURA_USB_VID, AURA_ADDRESSABLE_1_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",      DetectAsusAuraUSBAddressable,  AURA_USB_VID, AURA_ADDRESSABLE_2_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",      DetectAsusAuraUSBAddressable,  AURA_USB_VID, AURA_ADDRESSABLE_3_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",      DetectAsusAuraUSBAddressable,  AURA_USB_VID, AURA_ADDRESSABLE_4_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",      DetectAsusAuraUSBMotherboards, AURA_USB_VID, AURA_MOTHERBOARD_1_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",      DetectAsusAuraUSBMotherboards, AURA_USB_VID, AURA_MOTHERBOARD_2_PID);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core",   DetectAsusAuraUSBMice,         AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID,   0, 0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II",        DetectAsusAuraUSBMice,         AURA_USB_VID, AURA_ROG_GLADIUS_II_PID,        2, 0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin", DetectAsusAuraUSBMice,         AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID, 2, 0xFF01);
@@ -1,204 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMouse.cpp          |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 10/25/2020  |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraMouse.h"
-
-RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
-{
-    aura = aura_ptr;
-
-    name        = "ASUS Aura Mouse";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_MOUSE;
-    description = "ASUS Aura Mouse Device";
-    location    = aura->GetDeviceLocation();
-    serial      = aura->GetSerialString();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = AURA_MOUSE_MODE_STATIC;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = AURA_MOUSE_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Breathing.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Breathing);
-
-    mode SpectrumCycle;
-    SpectrumCycle.name       = "Spectrum Cycle";
-    SpectrumCycle.value      = AURA_MOUSE_MODE_COLOR_CYCLE;
-    SpectrumCycle.flags      = 0;
-    SpectrumCycle.color_mode = MODE_COLORS_NONE;
-    modes.push_back(SpectrumCycle);
-
-    mode Reactive;
-    Reactive.name       = "Reactive";
-    Reactive.value      = AURA_MOUSE_MODE_REACTIVE;
-    Reactive.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Reactive.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Reactive);
-
-    SetupZones();
-}
-
-RGBController_AuraMouse::~RGBController_AuraMouse()
-{
-
-}
-
-void RGBController_AuraMouse::SetupZones()
-{
-    zone logo_zone;
-
-    logo_zone.name          = "Logo";
-    logo_zone.type          = ZONE_TYPE_SINGLE;
-    logo_zone.leds_min      = 1;
-    logo_zone.leds_max      = 1;
-    logo_zone.leds_count    = 1;
-    logo_zone.matrix_map    = NULL;
-
-    zones.push_back(logo_zone);
-
-    led logo_led;
-
-    logo_led.name           = "Logo";
-
-    leds.push_back(logo_led);
-
-    zone scroll_zone;
-
-    scroll_zone.name        = "Scroll Wheel";
-    scroll_zone.type        = ZONE_TYPE_SINGLE;
-    scroll_zone.leds_min    = 1;
-    scroll_zone.leds_max    = 1;
-    scroll_zone.leds_count  = 1;
-    scroll_zone.matrix_map  = NULL;
-
-    zones.push_back(scroll_zone);
-
-    led scroll_led;
-
-    scroll_led.name         = "Scroll Wheel";
-
-    leds.push_back(scroll_led);
-
-    zone underglow_zone;
-
-    underglow_zone.name       = "Underglow";
-    underglow_zone.type       = ZONE_TYPE_SINGLE;
-    underglow_zone.leds_min   = 1;
-    underglow_zone.leds_max   = 1;
-    underglow_zone.leds_count = 1;
-    underglow_zone.matrix_map = NULL;
-
-    zones.push_back(underglow_zone);
-
-    led underglow_led;
-
-    underglow_led.name        = "Underglow";
-
-    leds.push_back(underglow_led);
-
-    SetupColors();
-}
-
-void RGBController_AuraMouse::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
-void RGBController_AuraMouse::DeviceUpdateLEDs()
-{
-    DeviceUpdateMode();
-}
-
-void RGBController_AuraMouse::UpdateZoneLEDs(int zone)
-{
-    UpdateSingleLED(zone);
-}
-
-void RGBController_AuraMouse::UpdateSingleLED(int led)
-{
-    unsigned char red = 0;
-    unsigned char grn = 0;
-    unsigned char blu = 0;
-
-    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
-    {
-        if(led == 0)
-        {
-            red = RGBGetRValue(colors[led]);
-            grn = RGBGetGValue(colors[led]);
-            blu = RGBGetBValue(colors[led]);
-
-            aura->SendUpdate(AURA_MOUSE_ZONE_LOGO, modes[active_mode].value, red, grn, blu);
-        }
-        else if(led == 1)
-        {
-            red = RGBGetRValue(colors[led]);
-            grn = RGBGetGValue(colors[led]);
-            blu = RGBGetBValue(colors[led]);
-
-            aura->SendUpdate(AURA_MOUSE_ZONE_SCROLL, modes[active_mode].value, red, grn, blu);
-        }
-        else
-        {
-            red = RGBGetRValue(colors[led]);
-            grn = RGBGetGValue(colors[led]);
-            blu = RGBGetBValue(colors[led]);
-
-            aura->SendUpdate(AURA_MOUSE_ZONE_UNDERGLOW, modes[active_mode].value, red, grn, blu);
-        }
-    }
-    else
-    {
-        aura->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu);
-    }
-}
-
-void RGBController_AuraMouse::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_AuraMouse::DeviceUpdateMode()
-{
-    unsigned char red = 0;
-    unsigned char grn = 0;
-    unsigned char blu = 0;
-
-    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
-    {
-        red = RGBGetRValue(colors[0]);
-        grn = RGBGetGValue(colors[0]);
-        blu = RGBGetBValue(colors[0]);
-
-        aura->SendUpdate(AURA_MOUSE_ZONE_LOGO, modes[active_mode].value, red, grn, blu);
-
-        red = RGBGetRValue(colors[1]);
-        grn = RGBGetGValue(colors[1]);
-        blu = RGBGetBValue(colors[1]);
-
-        aura->SendUpdate(AURA_MOUSE_ZONE_SCROLL, modes[active_mode].value, red, grn, blu);
-
-        red = RGBGetRValue(colors[2]);
-        grn = RGBGetGValue(colors[2]);
-        blu = RGBGetBValue(colors[2]);
-
-        aura->SendUpdate(AURA_MOUSE_ZONE_UNDERGLOW, modes[active_mode].value, red, grn, blu);
-    }
-    else
-    {
-        aura->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu);
-    }
-}
@@ -1,33 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMouse.h            |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 10/25/2020  |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusAuraMouseController.h"
-
-class RGBController_AuraMouse : public RGBController
-{
-public:
-    RGBController_AuraMouse(AuraMouseController* aura_ptr);
-    ~RGBController_AuraMouse();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    AuraMouseController*  aura;
-};
@@ -1,48 +0,0 @@
-#ifdef _WIN32
-
-#include "RGBController_AsusTUFLaptopWMI.h"
-
-#include "acpiwmi.h"
-#include "Detector.h"
-#include "wmi.h"
-#include <string>
-
-static void DetectAsusTUFLaptopWMIControllers(std::vector<RGBController*>&)
-{
-    // Try to retrieve ProductID / Device name from WMI; Possibly can be rewritten to use wmi.cpp
-    // IF you encounter false detection ( e.g. if your laptop keyboard backlight uses USB interface
-    // instead of ACPI WMI) please add a WHITELIST by checking the
-    // `name` variable for model substrings like "FX505DU"
-    // For now, checking for "TUF Gaming" should suffice
-
-    Wmi wmi;
-    wmi.init();
-
-    std::vector<QueryObj> systemProduct;
-    if (wmi.query("SELECT * FROM Win32_ComputerSystemProduct", systemProduct))
-    {
-        return;
-    }
-
-    // There should only be one, a cycle is a precaution
-    if(systemProduct.size() != 1)
-    {
-        return;
-    }
-    std::string& name = systemProduct[0]["Name"];
-    if(name.find("TUF Gaming") == name.npos)
-    {
-        return;
-    }
-
-    if(AsWMI_Open())
-    {
-        RGBController* new_controller = new RGBController_AsusTUFLaptopWMI();
-        ResourceManager::get()->RegisterRGBController(new_controller);
-        // Success! No more if's
-    }
-}   /* DetectFaustusControllers() */
-
-REGISTER_DETECTOR("TUF Laptop WMI", DetectAsusTUFLaptopWMIControllers);
-
-#endif
@@ -1,143 +0,0 @@
-#ifdef _WIN32
-
-#include "RGBController_AsusTUFLaptopWMI.h"
-
-#include "acpiwmi.h"
-#include "ResourceManager.h"
-#include "Detector.h"
-#include "wmi.h"
-#include <string>
-
-using namespace std::chrono_literals;
-
-RGBController_AsusTUFLaptopWMI::RGBController_AsusTUFLaptopWMI()
-{
-    name        = "ASUS TUF Keyboard";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "WMI Device";
-    location    = "\\\\.\\ATKACPI";
-
-    modes.resize(5);
-    modes[0].name       = "Direct";
-    modes[0].value      = 4;
-    modes[0].flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    modes[0].color_mode = MODE_COLORS_PER_LED;
-
-    modes[1].name       = "Static";
-    modes[1].value      = 0;
-    modes[1].flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    modes[1].color_mode = MODE_COLORS_PER_LED;
-
-    modes[2].name       = "Breathing";
-    modes[2].value      = 1;
-    modes[2].flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    modes[2].speed_min  = 0;
-    modes[2].speed_max  = 2;
-    modes[2].color_mode = MODE_COLORS_PER_LED;
-    modes[2].speed      = 1;
-
-    modes[3].name       = "Color Cycle";
-    modes[3].value      = 2;
-    modes[3].flags      = MODE_FLAG_HAS_SPEED;
-    modes[3].speed_min  = 0;
-    modes[3].speed_max  = 2;
-    modes[3].color_mode = MODE_COLORS_NONE;
-    modes[3].speed      = 1;
-
-    modes[4].name       = "Strobe";
-    modes[4].value      = 0x0A;
-    modes[4].flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    modes[4].color_mode = MODE_COLORS_PER_LED;
-
-    SetupZones();
-}
-
-RGBController_AsusTUFLaptopWMI::~RGBController_AsusTUFLaptopWMI()
-{
-    AsWMI_Close();
-}
-
-void RGBController_AsusTUFLaptopWMI::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zone                                               |
-    \*---------------------------------------------------------*/
-    zones.resize(1);
-    zones[0].type           = ZONE_TYPE_SINGLE;
-    zones[0].name           = "Keyboard Backlight zone";
-    zones[0].leds_min       = 1;
-    zones[0].leds_max       = 1;
-    zones[0].leds_count     = 1;
-    zones[0].matrix_map     = NULL;
-
-    /*---------------------------------------------------------*\
-    | Set up LED                                                |
-    \*---------------------------------------------------------*/
-    leds.resize(1);
-    leds[0].name = "Keyboard Backlight LED";
-
-    SetupColors();
-}
-
-void RGBController_AsusTUFLaptopWMI::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AsusTUFLaptopWMI::DeviceUpdateLEDs()
-{
-    uint8_t red   = RGBGetRValue(colors[0]);
-    uint8_t green = RGBGetGValue(colors[0]);
-    uint8_t blue  = RGBGetBValue(colors[0]);
-    uint8_t speed_byte = 0;
-    uint8_t mode = modes[active_mode].value;
-    uint8_t inv = 0;
-    if(mode == 4)
-    {
-        mode = 1;
-        inv = 4; // Any invalid mode, i.e. anything other than 0, 1, 2 and 10
-    }
-    if(mode == 1 || mode == 2)
-    {
-        switch(modes[active_mode].speed)
-        {
-        case 0: speed_byte = 0xE1; break;
-        case 1: speed_byte = 0xEB; break;
-        case 2: speed_byte = 0xF5; break;
-        }
-    }
-    int high = ((mode | ((red | (green << 8)) << 8)) << 8) | 0xB3;
-    int low = blue | (speed_byte << 8);
-    AsWMI_NB_DeviceControl_2arg(0x100056, high, low);
-    if(inv)
-    {
-        //std::this_thread::sleep_for(10ms);
-        high = ((inv | ((red | (green << 8)) << 8)) << 8) | 0xB3;
-        AsWMI_NB_DeviceControl_2arg(0x100056, high, low);
-    }
-}
-
-void RGBController_AsusTUFLaptopWMI::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AsusTUFLaptopWMI::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AsusTUFLaptopWMI::SetCustomMode()
-{
-    SetMode(0);
-}
-
-void RGBController_AsusTUFLaptopWMI::DeviceUpdateMode()
-{
-    DeviceUpdateLEDs();
-}
-
-#endif
@@ -1,29 +0,0 @@
-#ifndef RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
-#define RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
-
-#ifdef _WIN32
-
-#include "RGBController.h"
-
-class RGBController_AsusTUFLaptopWMI : public RGBController
-{
-public:
-    RGBController_AsusTUFLaptopWMI();
-    virtual ~RGBController_AsusTUFLaptopWMI();
-
-    void SetupZones() override;
-
-    void ResizeZone(int zone, int new_size) override;
-
-    void DeviceUpdateLEDs() override;
-    void UpdateZoneLEDs(int zone) override;
-    void UpdateSingleLED(int led) override;
-
-    void DeviceUpdateMode() override;
-
-    void SetCustomMode() override;
-};
-
-#endif
-
-#endif // RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
@@ -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 @@
 /*-----------------------------------------*\
-|  AsusAuraUSBController.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,74 +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, const char* path);
-    virtual ~AuraUSBController();
+    AuraAddressableController(hid_device* dev_handle);
+    ~AuraAddressableController();

    unsigned int GetChannelCount();

-    std::string GetDeviceLocation();
    std::string GetDeviceName();
-    std::string GetSerialString();

-    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;
-    std::string                 location;
+        );

    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,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraCoreController.cpp               | 
+|  AuraCoreController.cpp                   | 
 |                                           |
 |  Driver for ASUS ROG Aura Core RGB        |
 |  lighting controller                      |
@@ -7,13 +7,12 @@
 |  Adam Honse (CalcProgrammer1) 4/13/2020   |
 \*-----------------------------------------*/

-#include "AsusAuraCoreController.h"
+#include "AuraCoreController.h"
 #include <cstring>

-AuraCoreController::AuraCoreController(hid_device* dev_handle, const char* path)
+AuraCoreController::AuraCoreController(hid_device* dev_handle)
 {
-    dev         = dev_handle;
-    location    = path;
+    dev = dev_handle;
 }

 AuraCoreController::~AuraCoreController()
@@ -21,22 +20,6 @@ AuraCoreController::~AuraCoreController()

 }

-std::string AuraCoreController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AuraCoreController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
 void AuraCoreController::SendBrightness
    (
    unsigned char   brightness
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraCoreController.h                 |
+|  AuraCoreController.h                     |
 |                                           |
 |  Definitions and types for ASUS ROG Aura  |
 |  Core RGB lighting controller             |
@@ -48,12 +48,9 @@ enum
 class AuraCoreController
 {
 public:
-    AuraCoreController(hid_device* dev_handle, const char* path);
+    AuraCoreController(hid_device* dev_handle);
    ~AuraCoreController();

-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
    void    SendBrightness
                (
                unsigned char   brightness
@@ -75,6 +72,5 @@ public:

 private:
    hid_device*             dev;
-    std::string             location;

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

-#include "AsusAuraGPUController.h"
+#include "AuraGPUController.h"
 #include <cstring>

 AuraGPUController::AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id dev)
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraGPUController.h                  |
+|  AuraGPUController.h                      |
 |                                           |
 |  Definitions for ASUS Aura RGB on GPUs    |
 |                                           |
@@ -1,21 +1,29 @@
 /*-----------------------------------------*\
-|  AsusAuraGPUControllerDetect.cpp          |
+|  AuraGPUControllerDetect.cpp              |
 |                                           |
 |  Driver for ASUS Aura RGB on GPUs         |
 |                                           |
 |  Jan Rettig (Klapstuhl) 14.02.2020        |
 \*-----------------------------------------*/

-#include "Detector.h"
-#include "AsusAuraGPUController.h"
+#include "AuraGPUController.h"
 #include "RGBController.h"
-#include "RGBController_AsusAuraGPU.h"
+#include "RGBController_AuraGPU.h"
 #include "i2c_smbus.h"
 #include <vector>
 #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  |
@@ -38,7 +46,7 @@ static const unsigned char aura_gpu_addresses[] =
 *                                                                                          *
 \******************************************************************************************/

-bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char address)
+bool TestForAuraGPUController(i2c_smbus_interface* bus, unsigned char address)
 {
    bool pass = false;

@@ -63,7 +71,7 @@ bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char addres
 *                                                                                          *
 \******************************************************************************************/

-void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+void DetectAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
 {
    AuraGPUController* new_aura_gpu;
    RGBController_AuraGPU* new_controller;
@@ -73,16 +81,14 @@ void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std
        // Add Aura-enabled GPU controllers
        for (unsigned int address_list_idx = 0; address_list_idx < AURA_GPU_ADDRESS_COUNT; address_list_idx++)
        {
-            if (TestForAsusAuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]))
+            if (TestForAuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]))
            {
                new_aura_gpu = new AuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]);
                new_controller = new RGBController_AuraGPU(new_aura_gpu);
                rgb_controllers.push_back(new_controller);
            }

-            std::this_thread::sleep_for(1ms);
+            Sleep(1);
        }
    }
-} /* DetectAuraGPUControllers() */
-
-REGISTER_I2C_DETECTOR("ASUS Aura GPU", DetectAsusAuraGPUControllers);
+} /* DetectAuraGPUControllers() */
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraSMBusController.cpp              |
+|  AuraSMBusController.cpp                  |
 |                                           |
 |  Driver for ASUS Aura RGB lighting        |
 |  controller                               |
@@ -7,24 +7,9 @@
 |  Adam Honse (CalcProgrammer1) 8/19/2018   |
 \*-----------------------------------------*/

-#include "AsusAuraSMBusController.h"
+#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
    {
@@ -116,7 +94,7 @@ std::string AuraSMBusController::GetDeviceLocation()
    snprintf(addr, 5, "0x%02X", dev);
    return_string.append(", address ");
    return_string.append(addr);
-    return("I2C: " + return_string);
+    return(return_string);
 }

 unsigned char AuraSMBusController::GetChannel(unsigned int led)
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraSMBusController.h                |
+|  AuraSMBusController.h                    |
 |                                           |
 |  Definitions and types for ASUS Aura RGB  |
 |  lighting controller                      |
@@ -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,19 +1,26 @@
-#include "Detector.h"
-#include "AsusAuraSMBusController.h"
+#include "AuraSMBusController.h"
 #include "RGBController.h"
-#include "RGBController_AsusAuraSMBus.h"
+#include "RGBController_AuraSMBus.h"
 #include "i2c_smbus.h"
-#include "pci_ids.h"
 #include <vector>
 #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[] =
 {
@@ -36,7 +43,6 @@ static const unsigned char aura_ram_addresses[] =
    0x66,
    0x67,
    0x39,
-    0x3A,
    0x3B,
    0x3C,
    0x3D
@@ -64,7 +70,7 @@ static const unsigned char aura_mobo_addresses[] =
 *                                                                                          *
 \******************************************************************************************/

-void AsusAuraRegisterWrite(i2c_smbus_interface* bus, aura_dev_id dev, aura_register reg, unsigned char val)
+void AuraRegisterWrite(i2c_smbus_interface* bus, aura_dev_id dev, aura_register reg, unsigned char val)
 {
    //Write Aura register
    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
@@ -83,7 +89,7 @@ void AsusAuraRegisterWrite(i2c_smbus_interface* bus, aura_dev_id dev, aura_regis
 *                                                                                          *
 \******************************************************************************************/

-bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char address)
+bool TestForAuraSMBusController(i2c_smbus_interface* bus, unsigned char address)
 {
    bool pass = false;

@@ -122,7 +128,7 @@ bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char addr
 *                                                                                          *
 \******************************************************************************************/

-void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+void DetectAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
 {
    AuraSMBusController* new_aura;
    RGBController_AuraSMBus* new_controller;
@@ -131,70 +137,62 @@ void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, s
    {
        int address_list_idx = -1;

-        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        // Remap Aura-enabled RAM modules on 0x77
+        for (unsigned int slot = 0; slot < 8; slot++)
        {
-            // Remap Aura-enabled RAM modules on 0x77
-            for (unsigned int slot = 0; slot < 8; slot++)
+            int res = busses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
+
+            if (res < 0)
            {
-                int res = busses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
+                break;
+            }

-                if (res < 0)
-                {
-                    break;
-                }
-
-                do
-                {
-                    address_list_idx++;
-
-                    if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
-                    {
-                        res = busses[bus]->i2c_smbus_write_quick(aura_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
-                    }
-                    else
-                    {
-                        break;
-                    }
-                } while (res >= 0);
+            do
+            {
+                address_list_idx++;

                if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
                {
-                    AsusAuraRegisterWrite(busses[bus], 0x77, AURA_REG_SLOT_INDEX, slot);
-                    AsusAuraRegisterWrite(busses[bus], 0x77, AURA_REG_I2C_ADDRESS, (aura_ram_addresses[address_list_idx] << 1));
+                    res = busses[bus]->i2c_smbus_write_quick(aura_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
                }
-            }
-
-            // Add Aura-enabled controllers at their remapped addresses
-            for (unsigned int address_list_idx = 0; address_list_idx < AURA_RAM_ADDRESS_COUNT; address_list_idx++)
-            {
-                if (TestForAsusAuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]))
+                else
                {
-                    new_aura = new AuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]);
-                    new_controller = new RGBController_AuraSMBus(new_aura);
-                    rgb_controllers.push_back(new_controller);
+                    break;
                }
+            } while (res >= 0);

-                std::this_thread::sleep_for(1ms);
+            if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
+            {
+                AuraRegisterWrite(busses[bus], 0x77, AURA_REG_SLOT_INDEX, slot);
+                AuraRegisterWrite(busses[bus], 0x77, AURA_REG_I2C_ADDRESS, (aura_ram_addresses[address_list_idx] << 1));
            }
        }

-        // Add Aura-enabled motherboard controllers
-        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        // Add Aura-enabled controllers at their remapped addresses
+        for (unsigned int address_list_idx = 0; address_list_idx < AURA_RAM_ADDRESS_COUNT; address_list_idx++)
        {
-            for (unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
+            if (TestForAuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]))
            {
-                if (TestForAsusAuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
-                {
-                    new_aura = new AuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]);
-                    new_controller = new RGBController_AuraSMBus(new_aura);
-                    rgb_controllers.push_back(new_controller);
-                }
-
-                std::this_thread::sleep_for(1ms);
+                new_aura = new AuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]);
+                new_controller = new RGBController_AuraSMBus(new_aura);
+                rgb_controllers.push_back(new_controller);
            }
+
+            Sleep(1);
+        }
+
+        // Add Aura-enabled motherboard controllers
+        for (unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
+        {
+            if (TestForAuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
+            {
+                new_aura = new AuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]);
+                new_controller = new RGBController_AuraSMBus(new_aura);
+                rgb_controllers.push_back(new_controller);
+            }
+
+            Sleep(1);
        }
    }

 }   /* DetectAuraSMBusControllers() */
-
-REGISTER_I2C_DETECTOR("ASUS Aura SMBus", DetectAsusAuraSMBusControllers);
@@ -1,283 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  CMARGBController.cpp                                               |
-|                                                                     |
-|  Driver for Coolermaster ARGB USB Controller                        |
-|                                                                     |
-|  Chris M (Dr_No)          10th Oct 2020                             |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#include "CMARGBcontroller.h"
-#include <cstring>
-
-static unsigned char argb_colour_index_data[2][2][2] =
-{     //B0    B1
-    { { 0x00, 0x03 },    //G0 R0
-      { 0x02, 0x06 }, }, //G1 R0
-    { { 0x01, 0x05 }, 	 //G0 R1
-      { 0x04, 0x07 }, }  //G1 R1
-};
-
-static unsigned char argb_mode_data[2][9] =
-{
-    { 0x05, 0x01, 0x02, 0x03, 0x04, 0x01, 0x01, 0x01, 0x01 },    //12v RGB Mode values
-    { 0x0A, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08, 0x09 }     //5v ARGB Mode values
-};
-
-CMARGBController::CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx)
-{
-    const int szTemp = 256;
-    wchar_t tmpName[szTemp];
-
-    dev                     = dev_handle;
-    location                = _path;
-    zone_index              = _zone_idx;
-    current_speed           = CM_ARGB_SPEED_NORMAL;
-
-    hid_get_manufacturer_string(dev, tmpName, szTemp);
-    std::wstring wName = std::wstring(tmpName);
-    device_name = std::string(wName.begin(), wName.end());
-
-    hid_get_product_string(dev, tmpName, szTemp);
-    wName = std::wstring(tmpName);
-    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
-
-    hid_get_serial_number_string(dev, tmpName, szTemp);
-    wName = std::wstring(tmpName);
-    serial = std::string(wName.begin(), wName.end());
-
-    GetStatus();
-}
-
-CMARGBController::~CMARGBController()
-{
-    hid_close(dev);
-}
-
-void CMARGBController::GetStatus()
-{
-    unsigned char buffer[0x40]          = { 0x00 };
-    int buffer_size                     = (sizeof(buffer) / sizeof(buffer[0]));
-    int header                          = zone_index - 1;
-
-    /*buffer[CM_ARGB_REPORT_BYTE]         = 0x80;
-    buffer[CM_ARGB_COMMAND_BYTE]        = 0x01;
-    buffer[CM_ARGB_FUNCTION_BYTE]       = 0x01;
-    hid_write(dev, buffer, buffer_size);
-
-    buffer[CM_ARGB_COMMAND_BYTE]        = 0x0b;
-    buffer[CM_ARGB_FUNCTION_BYTE]       = 0x03;
-    buffer[CM_ARGB_ZONE_BYTE]           = 0xFF;
-    hid_write(dev, buffer, buffer_size);
-
-    int i = 0;
-    do{
-        hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
-        i++;
-    }while( (i < 4) );
-
-    current_mode                        = argb_mode_data[1][buffer[4]];
-    current_speed                       = buffer[5];*/
-}
-
-std::string CMARGBController::GetDeviceName()
-{
-    return device_name;
-}
-
-std::string CMARGBController::GetSerial()
-{
-    return serial;
-}
-
-std::string CMARGBController::GetLocation()
-{
-    return("HID: " + location);
-}
-
-unsigned char CMARGBController::GetZoneIndex()
-{
-    return zone_index;
-}
-
-unsigned char CMARGBController::GetMode()
-{
-    return current_mode;
-}
-
-unsigned char CMARGBController::GetLedRed()
-{
-    return current_red;
-}
-
-unsigned char CMARGBController::GetLedGreen()
-{
-    return current_green;
-}
-
-unsigned char CMARGBController::GetLedBlue()
-{
-    return current_blue;
-}
-
-unsigned char CMARGBController::GetLedSpeed()
-{
-    return current_speed;
-}
-
-unsigned int CMARGBController::GetLargestColour(unsigned int red, unsigned int green, unsigned int blue)
-{
-    unsigned int largest;
-    if ( red > green )
-    {
-        ( red > blue ) ? largest = red : largest = blue;
-    }
-    else
-    {
-        ( green > blue ) ? largest = green : largest = blue;
-    }
-
-    return (largest == 0) ? 1 : largest;
-}
-
-unsigned char CMARGBController::GetColourIndex(unsigned char red, unsigned char green, unsigned char blue)
-{
-    //The Coolermaster ARGB controller uses a limited colour pallette referenced by an index
-    //Starting at 0x00 Random, 0x01 Red, 0x02 Green, 0x03 Blue, 0x04 Yellow, 0x05 Purple, 0x06 Cyan, 0x07 White
-    //The index can be calculated by normalising the input colour, rounding those values 
-    //and using them as the indicies of a 3d array containing the correct index
-    unsigned int divisor    = GetLargestColour( red, green, blue);
-    unsigned int r          = round( red / divisor );
-    unsigned int g          = round( green / divisor );
-    unsigned int b          = round( blue / divisor );
-    unsigned char idx       = argb_colour_index_data[r][g][b];
-    return idx;
-}
-
-void CMARGBController::SetMode(unsigned char mode, unsigned char speed)
-{
-    current_mode  = mode;
-    current_speed = speed;
-
-    SendUpdate();
-}
-
-void CMARGBController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
-{
-    current_red   = red;
-    current_green = green;
-    current_blue  = blue;
-
-    SendUpdate();
-}
-
-void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_count)
-{
-    const unsigned char buffer_size     = 0x41;
-    unsigned char buffer[buffer_size]   = { 0x00 };
-    unsigned char packet_count          = 0x00;
-    std::vector<unsigned char> colours;
-
-    //Set up the RGB triplets to send
-    for(int i = 0; i < led_count; i++)
-    {
-        RGBColor      colour            = led_colours[i];
-        unsigned char r                 = RGBGetRValue(colour);
-        unsigned char g                 = RGBGetGValue(colour);
-        unsigned char b                 = RGBGetBValue(colour);
-
-        colours.push_back(r);
-        colours.push_back(g);
-        colours.push_back(b);
-    }
-
-    //buffer[CM_ARGB_REPORT_BYTE]         = packet_count;
-    buffer[CM_ARGB_COMMAND_BYTE]        = 0x10;
-    buffer[CM_ARGB_FUNCTION_BYTE]       = 0x02;
-    buffer[CM_ARGB_ZONE_BYTE]           = argb_header_data[zone_index].header;
-    buffer[CM_ARGB_MODE_BYTE]           = 0x30; //30 might be the LED count??
-    unsigned char buffer_idx            = CM_ARGB_MODE_BYTE + 1;    //Start colour info from
-
-    for (std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = 0)
-    {
-        //Fill the write buffer till its full or the colour buffer is empty
-        buffer[CM_ARGB_REPORT_BYTE] = packet_count;
-        while (( buffer_idx < buffer_size) && ( it != colours.end() ))
-        {
-            buffer[buffer_idx] = *it;
-            buffer_idx++;
-            it++;
-        }
-
-        hid_write(dev, buffer, buffer_size);
-        hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
-
-        //reset the write buffer
-        memset(buffer, 0x00, sizeof(buffer) );
-        packet_count++;
-    }
-    buffer[CM_ARGB_REPORT_BYTE]         = 0x82;
-    buffer[CM_ARGB_COMMAND_BYTE]        = 0x62;
-    buffer[CM_ARGB_FUNCTION_BYTE]       = 0x00;
-    buffer[CM_ARGB_ZONE_BYTE]           = 0x73;
-    buffer[CM_ARGB_MODE_BYTE]           = 0x00;
-    buffer[CM_ARGB_COLOUR_INDEX_BYTE]   = 0x33;
-    buffer[CM_ARGB_SPEED_BYTE]          = 0x1B;
-
-    hid_write(dev, buffer, buffer_size);
-    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
-}
-
-void CMARGBController::SendUpdate()
-{
-    unsigned char buffer[0x40]          = { 0x00 };
-    int  buffer_size                    = (sizeof(buffer) / sizeof(buffer[0]));
-    bool boolARGB_header                = argb_header_data[zone_index].digital;
-    bool boolPassthru                   = ( current_mode == CM_ARGB_MODE_PASSTHRU );
-    bool boolDirect                     = ( current_mode == CM_ARGB_MODE_DIRECT );
-    unsigned char function              = boolPassthru ? 0x02 : ( boolARGB_header ? 0x03 : 0x01);
-    buffer[CM_ARGB_REPORT_BYTE]         = 0x80;
-    buffer[CM_ARGB_COMMAND_BYTE]        = boolDirect ? 0x10 : 0x01;
-    buffer[CM_ARGB_FUNCTION_BYTE]       = boolDirect ? 0x01 : function;
-
-    if ( boolDirect )
-    {
-        buffer[CM_ARGB_COMMAND_BYTE]        = 0x10;
-        buffer[CM_ARGB_FUNCTION_BYTE]       = 0x01;
-        buffer[CM_ARGB_ZONE_BYTE]           = argb_header_data[zone_index].header;
-        buffer[CM_ARGB_MODE_BYTE]           = 0x30; //30 might be the LED count??
-
-        //hid_write(dev, buffer, buffer_size);
-        //hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
-    }
-    else
-    {
-        buffer[CM_ARGB_COMMAND_BYTE]        = 0x01;
-        buffer[CM_ARGB_FUNCTION_BYTE]       = function;
-    }
-    hid_write(dev, buffer, buffer_size);
-
-
-    if ( boolARGB_header )
-    {
-        buffer[CM_ARGB_COMMAND_BYTE]        = 0x0b; //ARGB sends 0x0b (1011) RGB sends 0x04 (0100)
-        buffer[CM_ARGB_FUNCTION_BYTE]       = (false) ? 0x01 : 0x02; //This controls custom mode TODO
-        buffer[CM_ARGB_ZONE_BYTE]           = argb_header_data[zone_index].header;
-        buffer[CM_ARGB_MODE_BYTE]           = argb_mode_data[1][current_mode];
-        buffer[CM_ARGB_COLOUR_INDEX_BYTE]   = GetColourIndex( current_red, current_green, current_blue );
-        buffer[CM_ARGB_SPEED_BYTE]          = current_speed;
-
-        hid_write(dev, buffer, buffer_size);
-        hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
-    }
-    else
-    {
-        buffer[CM_ARGB_COMMAND_BYTE]                        = 0x04; //ARGB sends 0x0b (1011) RGB sends 0x04 (0100)
-        buffer[CM_ARGB_MODE_BYTE + CM_RGB_OFFSET]           = argb_mode_data[0][current_mode];
-        buffer[CM_ARGB_COLOUR_INDEX_BYTE + CM_RGB_OFFSET]   = GetColourIndex( current_red, current_green, current_blue );
-        buffer[CM_ARGB_SPEED_BYTE + CM_RGB_OFFSET]          = current_speed;
-
-        hid_write(dev, buffer, buffer_size);
-        hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
-    }
-}
@@ -1,127 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  CMARGBController.h                                                 |
-|                                                                     |
-|  Driver for Coolermaster ARGB USB Controller                        |
-|                                                                     |
-|  Chris M (Dr_No)          10th Oct 2020                             |
-|                                                                     |
-|  Simple RGB device with 5 modes                                     |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#include <string>
-#include <array>
-#include <cmath>            //Needed by round()
-#include <hidapi/hidapi.h>
-#include "RGBController.h"  //Needed to set the direct mode
-
-#pragma once
-
-#define CM_ARGB_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
-#define CM_ARGB_HEADER_DATA_SIZE (sizeof(argb_header_data) / sizeof(argb_headers) )
-#define CM_ARGB_INTERRUPT_TIMEOUT 250
-#define CM_ARGB_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
-#define CM_RGB_OFFSET -2
-#define HID_MAX_STR 255
-
-enum
-{
-    CM_ARGB_REPORT_BYTE         = 1,
-    CM_ARGB_COMMAND_BYTE        = 2,
-    CM_ARGB_FUNCTION_BYTE       = 3,
-    CM_ARGB_ZONE_BYTE           = 4,
-    CM_ARGB_MODE_BYTE           = 5,
-    CM_ARGB_COLOUR_INDEX_BYTE	= 6,
-    CM_ARGB_SPEED_BYTE          = 7
-};
-
-struct argb_headers
-{
-    const char*     name;
-    unsigned char   header;
-    bool            digital;
-    unsigned int    count;
-};
-
-static argb_headers argb_header_data[6] =
-{
-    { "RGB Header",         0xFF, false,  1 },
-    { "Digital ARGB1",      0x01, true,  12 },
-    { "Digital ARGB2",      0x02, true,  12 },
-    { "Digital ARGB3",      0x04, true,  12 },
-    { "Digital ARGB4",      0x08, true,  12 },
-    { "All Digital ARGB",   0xFF, true,  12 }
-};
-
-enum
-{
-    CM_RGB_MODE_OFF             = 0,    //Turn off
-    CM_RGB_MODE_COLOUR_CYCLE    = 1,    //Colour Cycle
-    CM_RGB_MODE_FLASH           = 2,    //Flash
-    CM_RGB_MODE_BREATHING       = 3,    //Breathing
-    CM_RGB_MODE_PASSTHRU        = 4     //Motherboard Pass Thru Mode
-};
-
-enum
-{
-    CM_ARGB_MODE_OFF            = 0,    //Turn off
-    CM_ARGB_MODE_SPECTRUM       = 1,    //Spectrum Mode
-    CM_ARGB_MODE_RELOAD         = 2,    //Reload Mode
-    CM_ARGB_MODE_RECOIL         = 3,    //Recoil Mode
-    CM_ARGB_MODE_BREATHING      = 4,    //Breathing Mode
-    CM_ARGB_MODE_REFILL         = 5,    //Refill Mode
-    CM_ARGB_MODE_DEMO           = 6,    //Demo Mode
-    CM_ARGB_MODE_FILLFLOW       = 7,    //Fill Flow Mode
-    CM_ARGB_MODE_RAINBOW        = 8,    //Rainbow Mode
-    CM_ARGB_MODE_DIRECT         = 0xFE, //Direct Led Control
-    CM_ARGB_MODE_PASSTHRU       = 0xFF  //Motherboard Pass Thru Mode
-};
-
-enum
-{
-    CM_ARGB_SPEED_SLOWEST       = 0x00, // Slowest speed
-    CM_ARGB_SPEED_SLOW          = 0x01, // Slower speed
-    CM_ARGB_SPEED_NORMAL        = 0x02, // Normal speed
-    CM_ARGB_SPEED_FAST          = 0x03, // Fast speed
-    CM_ARGB_SPEED_FASTEST       = 0x04, // Fastest speed
-};
-
-class CMARGBController
-{
-public:
-    CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx);
-    ~CMARGBController();
-
-    std::string GetDeviceName();
-    std::string GetSerial();
-    std::string GetLocation();
-
-    unsigned char GetZoneIndex();
-    unsigned char GetMode();
-    unsigned char GetLedRed();
-    unsigned char GetLedGreen();
-    unsigned char GetLedBlue();
-    unsigned char GetLedSpeed();
-    void SetMode(unsigned char mode, unsigned char speed);
-    void SetColor(unsigned char red, unsigned char green, unsigned char blue);
-    void SetLedsDirect(RGBColor * led_colours, unsigned int led_count);
-private:
-    std::string             device_name;
-    std::string             serial;
-    std::string             location;
-    hid_device*             dev;
-
-    unsigned char           zone_index;
-    unsigned char           current_mode;
-    unsigned char           current_speed;
-
-    unsigned char           current_red;
-    unsigned char           current_green;
-    unsigned char           current_blue;
-
-    unsigned int GetLargestColour(unsigned int red, unsigned int green, unsigned int blue);
-    unsigned char GetColourIndex(unsigned char red, unsigned char green, unsigned char blue);
-    void GetStatus();
-    void SendUpdate();
-
-};
@@ -8,123 +8,48 @@
 \*-------------------------------------------------------------------*/

 #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, char *_path)
-{
-    dev             = dev_handle;
-    location        = _path;
+    strcpy(device_name, "Cooler Master MP750");

-    const int szTemp = 256;
-    wchar_t tmpName[szTemp];
-
-    hid_get_manufacturer_string(dev, tmpName, szTemp);
-    std::wstring wName = std::wstring(tmpName);
-    device_name        = std::string(wName.begin(), wName.end());
-
-    hid_get_product_string(dev, tmpName, szTemp);
-    wName  = std::wstring(tmpName);
-    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
-
-    hid_get_serial_number_string(dev, tmpName, szTemp);
-    wName  = std::wstring(tmpName);
-    serial = std::string(wName.begin(), wName.end());
-
-    GetStatus();        //When setting up device get current status
+    current_mode = MP750_MODE_STATIC;
+    current_speed = MP750_SPEED_NORMAL;
 }

 CMMP750Controller::~CMMP750Controller()
 {
-    hid_close(dev);
+    libusb_release_interface(dev, interface);
+    libusb_attach_kernel_driver(dev, interface);
 }

-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;
-    }
-}
-
-std::string CMMP750Controller::GetDeviceName()
+char* CMMP750Controller::GetDeviceName()
 {
    return device_name;
 }

-std::string CMMP750Controller::GetSerial()
+char* CMMP750Controller::GetSerial()
 {
    return serial;
 }

 std::string CMMP750Controller::GetLocation()
 {
-    return("HID: " + 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;
+    return location;
 }

 void CMMP750Controller::SetMode(unsigned char mode, unsigned char speed)
@@ -146,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];
    }
@@ -157,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,26 +75,24 @@ enum
 class CMMP750Controller
 {
 public:
-    CMMP750Controller(hid_device* dev_handle, char *_path);
+    CMMP750Controller(libusb_device_handle *dev_handle, unsigned int _inAddr, unsigned int _outAddr, int _interface);
    ~CMMP750Controller();

-    std::string GetDeviceName();
-    std::string GetSerial();
+    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);

 private:
-    std::string             device_name;
-    std::string             serial;
+    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,16 +1,25 @@
-#include "Detector.h"
 #include "CMMP750Controller.h"
-#include "CMARGBcontroller.h"
 #include "RGBController.h"
 #include "RGBController_CMMP750Controller.h"
-#include "RGBController_CMARGBController.h"
-#include <hidapi/hidapi.h>
+#include <vector>
+#include <libusb-1.0/libusb.h>

-#define COOLERMASTER_VID                0x2516
+#define COOLERMASTER_VID 0x2516

-#define COOLERMASTER_MP750_XL_PID       0x0109
-#define COOLERMASTER_MP750_MEDIUM_PID   0x0105
-#define COOLERMASTER_ARGB_PID           0x1011
+#define COOLERMASTER_NUM_DEVICES (sizeof(cm_pids) / sizeof(cm_pids[ 0 ]))
+
+enum
+{
+    CM_PID = 0,
+    CM_INADDR = 1,
+    CM_OUTADDR = 2,
+    CM_INTERFACE = 3
+};
+
+static const unsigned int cm_pids[][4] =
+{ //PID, inAddr, outAddr, interface
+    { 0x0109, 0x82, 0x03, 0x00 }        //Coolermaster MP750
+};

 /******************************************************************************************\
 *                                                                                          *
@@ -20,33 +29,29 @@
 *                                                                                          *
 \******************************************************************************************/

-void DetectCoolerMasterMousemats(hid_device_info* info, const std::string&)
+void DetectCoolerMasterControllers(std::vector<RGBController*>& rgb_controllers)
 {
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        CMMP750Controller* controller                   = new CMMP750Controller(dev, info->path);
-        RGBController_CMMP750Controller* rgb_controller = new RGBController_CMMP750Controller(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
+    libusb_context * context;
+    libusb_init(&context);

-void DetectCoolerMasterARGB(hid_device_info* info, const std::string&)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
+    for(int cm_pid_idx = 0; cm_pid_idx < COOLERMASTER_NUM_DEVICES; cm_pid_idx++)
    {
-        for(std::size_t i = 0; i < CM_ARGB_HEADER_DATA_SIZE; i++)
+        //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)
        {
-            CMARGBController* controller = new CMARGBController(dev, info->path, i);
-            RGBController_CMARGBController* rgb_controller = new RGBController_CMARGBController(controller);
-            // Constructor sets the name
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
+            int status = libusb_detach_kernel_driver(dev, cm_pids[cm_pid_idx][CM_INTERFACE]);
+            status = libusb_claim_interface(dev, cm_pids[cm_pid_idx][CM_INTERFACE]);
+
+            if(status == 0)
+            {
+                // Success: Device has been claimed
+                CMMP750Controller* controller = new CMMP750Controller(dev, cm_pids[cm_pid_idx][CM_INADDR], cm_pids[cm_pid_idx][CM_OUTADDR], cm_pids[cm_pid_idx][CM_INTERFACE]);
+                RGBController_CMMP750Controller* rgb_controller = new RGBController_CMMP750Controller(controller);
+                rgb_controllers.push_back(rgb_controller);
+            }
        }
    }
-}

-REGISTER_HID_DETECTOR_IPU("Cooler Master MP750 XL",     DetectCoolerMasterMousemats, COOLERMASTER_VID, COOLERMASTER_MP750_XL_PID,     0, 0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master MP750 Medium", DetectCoolerMasterMousemats, COOLERMASTER_VID, COOLERMASTER_MP750_MEDIUM_PID, 0, 0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB",         DetectCoolerMasterARGB,      COOLERMASTER_VID, COOLERMASTER_ARGB_PID,         0, 0xFF00, 1);
+}
@@ -1,315 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  RGBController_CMARGBController.cpp                                 |
-|                                                                     |
-|  Driver for Coolermaster ARGB Controller                            |
-|                                                                     |
-|  Chris M (Dr_No)          14th Oct 2020                             |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#include "RGBController_CMARGBController.h"
-
-RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController *cmargb_ptr)
-{
-    cmargb                  = cmargb_ptr;
-    unsigned char speed     = cmargb->GetLedSpeed();
-
-    name                    = argb_header_data[cmargb->GetZoneIndex()].name;
-    vendor                  = "Cooler Master";
-    type                    = DEVICE_TYPE_LEDSTRIP;
-    description             = cmargb->GetDeviceName();
-    version                 = "1.0";
-    serial                  = cmargb->GetSerial();
-    location                = cmargb->GetLocation();
-
-    if ( argb_header_data[cmargb->GetZoneIndex()].digital)
-    {
-        mode Off;
-        Off.name                = "Turn Off";
-        Off.value               = CM_ARGB_MODE_OFF;
-        Off.color_mode          = MODE_COLORS_NONE;
-        modes.push_back(Off);
-
-        mode Reload;
-        Reload.name             = "Reload";
-        Reload.value            = CM_ARGB_MODE_RELOAD;
-        Reload.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Reload.colors_min       = 1;
-        Reload.colors_max       = 1;
-        Reload.colors.resize(Reload.colors_max);
-        Reload.speed_min        = CM_ARGB_SPEED_SLOWEST;
-        Reload.speed_max        = CM_ARGB_SPEED_FASTEST;
-        Reload.color_mode       = MODE_COLORS_RANDOM;
-        Reload.speed            = speed;
-        modes.push_back(Reload);
-
-        mode Recoil;
-        Recoil.name             = "Recoil";
-        Recoil.value            = CM_ARGB_MODE_RECOIL;
-        Recoil.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Recoil.colors_min       = 1;
-        Recoil.colors_max       = 1;
-        Recoil.colors.resize(Reload.colors_max);
-        Recoil.speed_min        = CM_ARGB_SPEED_SLOWEST;
-        Recoil.speed_max        = CM_ARGB_SPEED_FASTEST;
-        Recoil.color_mode       = MODE_COLORS_RANDOM;
-        Recoil.speed            = speed;
-        modes.push_back(Recoil);
-
-        mode Breathing;
-        Breathing.name          = "Breathing";
-        Breathing.value         = CM_ARGB_MODE_BREATHING;
-        Breathing.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Breathing.colors_min    = 1;
-        Breathing.colors_max    = 1;
-        Breathing.colors.resize(Reload.colors_max);
-        Breathing.speed_min     = CM_ARGB_SPEED_SLOWEST;
-        Breathing.speed_max     = CM_ARGB_SPEED_FASTEST;
-        Breathing.color_mode    = MODE_COLORS_RANDOM;
-        Breathing.speed         = speed;
-        modes.push_back(Breathing);
-
-        mode Refill;
-        Refill.name             = "Refill";
-        Refill.value            = CM_ARGB_MODE_REFILL;
-        Refill.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Refill.colors_min       = 1;
-        Refill.colors_max       = 1;
-        Refill.colors.resize(Reload.colors_max);
-        Refill.speed_min        = CM_ARGB_SPEED_SLOWEST;
-        Refill.speed_max        = CM_ARGB_SPEED_FASTEST;
-        Refill.color_mode       = MODE_COLORS_RANDOM;
-        Refill.speed            = speed;
-        modes.push_back(Refill);
-
-        mode Demo;
-        Demo.name               = "Demo";
-        Demo.value              = CM_ARGB_MODE_DEMO;
-        Demo.flags              = MODE_FLAG_HAS_SPEED;
-        Demo.speed_min          = CM_ARGB_SPEED_SLOWEST;
-        Demo.speed_max          = CM_ARGB_SPEED_FASTEST;
-        Demo.color_mode         = MODE_COLORS_NONE;
-        Demo.speed              = speed;
-        modes.push_back(Demo);
-
-        mode Spectrum;
-        Spectrum.name           = "Spectrum";
-        Spectrum.value          = CM_ARGB_MODE_SPECTRUM;
-        Spectrum.flags          = MODE_FLAG_HAS_SPEED;
-        Spectrum.speed_min      = CM_ARGB_SPEED_SLOWEST;
-        Spectrum.speed_max      = CM_ARGB_SPEED_FASTEST;
-        Spectrum.color_mode     = MODE_COLORS_NONE;
-        Spectrum.speed          = speed;
-        modes.push_back(Spectrum);
-
-        mode FillFlow;
-        FillFlow.name           = "Fill Flow";
-        FillFlow.value          = CM_ARGB_MODE_FILLFLOW;
-        FillFlow.flags          = MODE_FLAG_HAS_SPEED;
-        FillFlow.speed_min      = CM_ARGB_SPEED_SLOWEST;
-        FillFlow.speed_max      = CM_ARGB_SPEED_FASTEST;
-        FillFlow.color_mode     = MODE_COLORS_NONE;
-        FillFlow.speed          = speed;
-        modes.push_back(FillFlow);
-
-        mode Rainbow;
-        Rainbow.name            = "Rainbow";
-        Rainbow.value           = CM_ARGB_MODE_RAINBOW;
-        Rainbow.flags           = MODE_FLAG_HAS_SPEED;
-        Rainbow.speed_min       = CM_ARGB_SPEED_SLOWEST;
-        Rainbow.speed_max       = CM_ARGB_SPEED_FASTEST;
-        Rainbow.color_mode      = MODE_COLORS_NONE;
-        Rainbow.speed           = speed;
-        modes.push_back(Rainbow);
-
-        mode Direct;
-        Direct.name             = "Direct";
-        Direct.value            = CM_ARGB_MODE_DIRECT;
-        Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-        Direct.color_mode       = MODE_COLORS_PER_LED;
-        modes.push_back(Direct);
-
-        mode PassThru;
-        PassThru.name           = "Pass Thru";
-        PassThru.value          = CM_ARGB_MODE_PASSTHRU;
-        PassThru.color_mode     = MODE_COLORS_NONE;
-        modes.push_back(PassThru);
-    }
-    else
-    {
-        mode Off;
-        Off.name                = "Turn Off";
-        Off.value               = CM_RGB_MODE_OFF;
-        Off.color_mode          = MODE_COLORS_NONE;
-        modes.push_back(Off);
-
-        mode Breathing;
-        Breathing.name          = "Breathing";
-        Breathing.value         = CM_RGB_MODE_BREATHING;
-        Breathing.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Breathing.colors_min    = 1;
-        Breathing.colors_max    = 1;
-        Breathing.colors.resize(Breathing.colors_max);
-        Breathing.speed_min     = CM_ARGB_SPEED_SLOWEST;
-        Breathing.speed_max     = CM_ARGB_SPEED_FASTEST;
-        Breathing.color_mode    = MODE_COLORS_RANDOM;
-        Breathing.speed         = speed;
-        modes.push_back(Breathing);
-
-        mode Flash;
-        Breathing.name          = "Flash";
-        Breathing.value         = CM_RGB_MODE_FLASH;
-        Breathing.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Breathing.colors_min    = 1;
-        Breathing.colors_max    = 1;
-        Breathing.colors.resize(Breathing.colors_max);
-        Breathing.speed_min     = CM_ARGB_SPEED_SLOWEST;
-        Breathing.speed_max     = CM_ARGB_SPEED_FASTEST;
-        Breathing.color_mode    = MODE_COLORS_RANDOM;
-        Breathing.speed         = speed;
-        modes.push_back(Breathing);
-
-        mode ColourCycle;
-        ColourCycle.name          = "Colour Cycle";
-        ColourCycle.value         = CM_RGB_MODE_COLOUR_CYCLE;
-        ColourCycle.flags         = MODE_FLAG_HAS_SPEED;
-        ColourCycle.speed_min     = CM_ARGB_SPEED_SLOWEST;
-        ColourCycle.speed_max     = CM_ARGB_SPEED_FASTEST;
-        ColourCycle.color_mode    = MODE_COLORS_NONE;
-        ColourCycle.speed         = speed;
-        modes.push_back(ColourCycle);
-
-        mode PassThru;
-        PassThru.name           = "Pass Thru";
-        PassThru.value          = CM_RGB_MODE_PASSTHRU;
-        PassThru.color_mode     = MODE_COLORS_NONE;
-        modes.push_back(PassThru);
-    }
-
-    Init_Controller();         //Only processed on first run
-    SetupZones();
-    //active_mode = cmargb->GetMode();
-}
-
-RGBController_CMARGBController::~RGBController_CMARGBController()
-{
-
-}
-
-void RGBController_CMARGBController::Init_Controller()
-{
-    int zone_idx            = cmargb->GetZoneIndex();
-    int zone_led_count      = argb_header_data[zone_idx].count;
-    bool boolSingleLED      = ( zone_led_count == 1 );          //If argb_header_data[zone_idx].count == 1 then the zone is ZONE_TYPE_SINGLE
-
-    zone ARGB_zone;
-    ARGB_zone.name          = std::to_string(zone_idx);
-    ARGB_zone.type          = (boolSingleLED) ? ZONE_TYPE_SINGLE : ZONE_TYPE_LINEAR;
-    ARGB_zone.leds_min      = 0;
-    ARGB_zone.leds_max      = 64;
-    ARGB_zone.leds_count    = zone_led_count;
-    ARGB_zone.matrix_map    = NULL;
-    zones.push_back(ARGB_zone);
-}
-
-void RGBController_CMARGBController::SetupZones()
-{
-    /*-------------------------------------------------*\
-    | Clear any existing color/LED configuration        |
-    \*-------------------------------------------------*/
-    leds.clear();
-    colors.clear();
-
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        bool boolSingleLED = (zones[zone_idx].type == ZONE_TYPE_SINGLE);    //Calculated for later use
-
-        for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
-        {
-            led     new_led;
-            unsigned int i = std::stoi(zones[zone_idx].name);
-
-            if(boolSingleLED)
-            {
-                new_led.name  = i;
-                new_led.value = argb_header_data[i].header;
-            }
-            else
-            {
-                new_led.name = i;
-                new_led.name.append(" LED " + std::to_string(lp_idx));
-                new_led.value = argb_header_data[i].header;
-            }
-
-            leds.push_back(new_led);
-        }
-    }
-
-    SetupColors();
-}
-
-void RGBController_CMARGBController::ResizeZone(int zone, int new_size)
-{
-    if((size_t) zone >= zones.size())
-    {
-        return;
-    }
-
-    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
-    {
-        zones[zone].leds_count = new_size;
-
-        SetupZones();
-    }
-}
-
-void RGBController_CMARGBController::DeviceUpdateLEDs()
-{
-    /*unsigned char red = RGBGetRValue(colors[0]);
-    unsigned char grn = RGBGetGValue(colors[0]);
-    unsigned char blu = RGBGetBValue(colors[0]);
-    cmargb->SetColor(red, grn, blu);*/
-
-    //this one
-    cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed );
-    cmargb->SetLedsDirect( zones[0].colors, zones[0].leds_count );
-}
-
-void RGBController_CMARGBController::UpdateZoneLEDs(int zone)
-{
-    RGBColor      colour    = colors[zone];
-    unsigned char red       = RGBGetRValue(colour);
-    unsigned char grn       = RGBGetGValue(colour);
-    unsigned char blu       = RGBGetBValue(colour);
-    cmargb->SetColor(red, grn, blu);
-}
-
-void RGBController_CMARGBController::UpdateSingleLED(int led)
-{
-        //cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed );
-        //cmargb->SetLedsDirect( zones[0].colors, zones[0].leds_count );
-}
-
-void RGBController_CMARGBController::SetCustomMode()
-{
-    active_mode = CM_ARGB_MODE_DIRECT;
-}
-
-void RGBController_CMARGBController::DeviceUpdateMode()
-{
-    if( modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC )
-    {
-        unsigned char red = RGBGetRValue(modes[active_mode].colors[0]);
-        unsigned char grn = RGBGetGValue(modes[active_mode].colors[0]);
-        unsigned char blu = RGBGetBValue(modes[active_mode].colors[0]);
-        cmargb->SetColor(red, grn, blu);
-    }
-    else
-    {
-        cmargb->SetColor(0, 0, 0);        //If the mode is not colour specific then set colour to black for the random index
-    }
-    cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed );
-}
@@ -1,35 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  RGBController_CMARGBController.h                                   |
-|                                                                     |
-|  Driver for Coolermaster ARGB Controller                            |
-|                                                                     |
-|  Chris M (Dr_No)          14th Oct 2020                             |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "CMARGBcontroller.h"
-#include <vector>
-
-class RGBController_CMARGBController : public RGBController
-{
-public:
-    RGBController_CMARGBController(CMARGBController* cmargb_ptr);
-    ~RGBController_CMARGBController();
-
-    void        SetupZones();
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-private:
-    void        Init_Controller();
-    int         GetDeviceMode();
-
-    CMARGBController* cmargb;
-};
@@ -1,126 +0,0 @@
-/*------------------------------------------*\
-|  CorsairDominatorPlatinumController.cpp    |  
-|                                            |
-|  Drover for Corsair Domintator Platinum    |
-|  RGB RAM lighting controller               |
-|                                            |
-|  Erik Gilling (konkers)       9/25/2020    |
-\*------------------------------------------*/
-
-#include "CorsairDominatorPlatinumController.h"
-
-#include <cstring>
-
-using namespace std::chrono_literals;
-
-CorsairDominatorPlatinumController::CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-
-    led_data[0] = 0xc;
-}
-
-CorsairDominatorPlatinumController::~CorsairDominatorPlatinumController()
-{
-
-}
-
-std::string CorsairDominatorPlatinumController::GetDeviceName()
-{
-    return "Corsair Dominator Platinum RGB";
-}
-
-std::string CorsairDominatorPlatinumController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-void CorsairDominatorPlatinumController::SetAllColors
-    (
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    for(unsigned int led = 0; led < CORSAIR_PLAT_LED_COUNT; led++)
-    {
-        SetLEDColor(led, red, green, blue);
-    }
-}
-
-void CorsairDominatorPlatinumController::SetLEDColor
-    (
-    unsigned int    led,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    if(led >= CORSAIR_PLAT_LED_COUNT)
-    {
-        return;
-    }
-
-    unsigned int offset     = (led * 3) + 1;
-    led_data[offset]        = red;
-    led_data[offset + 1]    = green;
-    led_data[offset + 2]    = blue;
-}
-
-unsigned char CorsairDominatorPlatinumController::crc8
-    (
-    unsigned char   init,
-    unsigned char   poly,
-    unsigned char*  data,
-    unsigned char   len
-    )
-{
-    unsigned char crc = init;
-
-    for(unsigned int i = 0; i < len; i++)
-    {
-        unsigned char val = data[i];
-        for(unsigned char mask = 0x80; mask != 0; mask >>= 1)
-        {
-            unsigned char bit;
-            if ((val & mask) != 0)
-            {
-                bit = (crc & 0x80) ^ 0x80;
-            }
-            else
-            {
-                bit = crc & 0x80;
-            }
-
-            if (bit == 0)
-            {
-                crc <<= 1;
-            }
-            else
-            {
-                crc = (crc << 1) ^ poly;
-            }
-        }
-    }
-
-    return crc;
-}
-
-void CorsairDominatorPlatinumController::ApplyColors()
-{
-    unsigned char data[sizeof(led_data)];
-    memcpy(data, led_data, sizeof(led_data));
-    unsigned char crc = crc8(0x0, 0x7, data, sizeof(data) - 1);
-    data[sizeof(data) - 1] = crc;
-
-    bus->i2c_smbus_write_block_data(dev, 0x31, 0x20, data);
-    std::this_thread::sleep_for(800us);
-    bus->i2c_smbus_write_block_data(dev, 0x32, sizeof(data) - 0x20, data + 0x20);
-    std::this_thread::sleep_for(200us);
-}
@@ -1,42 +0,0 @@
-/*-----------------------------------------*\
-|  CorsairDominatorPlatinumController.h     |
-|                                           |
-|  Definitions and types for Corsair        |
-|  Domintator Platinum RGB RAM lighting     |
-|   controller                              |
-|                                           |
-|  Erik Gilling (konkers)       9/25/2020   |
-\*-----------------------------------------*/
-
-#include <string>
-#include "i2c_smbus.h"
-
-#pragma once
-
-typedef unsigned char corsair_dev_id;
-
-class CorsairDominatorPlatinumController
-{
-public:
-    CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev);
-    ~CorsairDominatorPlatinumController();
-
-    std::string GetDeviceName();
-    std::string GetDeviceLocation();
-
-    size_t GetLEDCount() { return CORSAIR_PLAT_LED_COUNT; }
-    void SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
-    void SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
-    void ApplyColors();
-    bool WaitReady();
-
-private:
-    static constexpr size_t CORSAIR_PLAT_LED_COUNT = 12;
-
-    unsigned char led_data[CORSAIR_PLAT_LED_COUNT * 3 + 2];
-
-    i2c_smbus_interface*    bus;
-    corsair_dev_id          dev;
-
-    static unsigned char crc8(unsigned char init, unsigned char poly, unsigned char *data, unsigned char len);
-};
@@ -1,70 +0,0 @@
-#include "Detector.h"
-#include "CorsairDominatorPlatinumController.h"
-#include "RGBController.h"
-#include "RGBController_CorsairDominatorPlatinum.h"
-#include "i2c_smbus.h"
-#include "pci_ids.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-using namespace std::chrono_literals;
-
-bool TestForCorsairDominatorPlatinumController(i2c_smbus_interface *bus, unsigned char address)
-{
-
-    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
-    if(res < 0)
-    {
-        return false;
-    }
-
-    res = bus->i2c_smbus_read_byte_data(address, 0x43);
-
-    if(res != 0x1b)
-    {
-        return false;
-    }
-
-    res = bus->i2c_smbus_read_byte_data(address, 0x44);
-
-    if(res != 0x04)
-    {
-        return false;
-    }
-
-    return true;
-}
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCorsairDominatorPlatinumControllers                                              *
-*                                                                                          *
-*       Detect Corsair Dominator Platinum controllers on the enumerated I2C busses.        *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
-*           dev - I2C address of Aura device                                               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *> &busses, std::vector<RGBController *> &rgb_controllers)
-{
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
-        {
-            for(unsigned char addr = 0x58; addr <= 0x5f; addr++)
-            {
-                if(TestForCorsairDominatorPlatinumController(busses[bus], addr))
-                {
-                    CorsairDominatorPlatinumController* new_controller        = new CorsairDominatorPlatinumController(busses[bus], addr);
-                    RGBController_CorsairDominatorPlatinum* new_rgbcontroller = new RGBController_CorsairDominatorPlatinum(new_controller);
-                    rgb_controllers.push_back(new_rgbcontroller);
-                }
-                std::this_thread::sleep_for(10ms);
-            }
-        }
-    }
-}
-
-REGISTER_I2C_DETECTOR("Corsair Dominator Platinum", DetectCorsairDominatorPlatinumControllers);
@@ -1,109 +0,0 @@
-/*-------------------------------------------------*\
-|  RGBController_CorsairDominatorPlatinum.cpp       |
-|                                                   |
-|  Corsair Vengeance Pro RGB driver                 |
-|                                                   |
-|  Erik Gilling (konkers)       9/25/2020           |
-\*-------------------------------------------------*/
-
-#include "RGBController_CorsairDominatorPlatinum.h"
-
-RGBController_CorsairDominatorPlatinum::RGBController_CorsairDominatorPlatinum(CorsairDominatorPlatinumController* corsair_ptr)
-{
-    corsair = corsair_ptr;
-
-    name        = corsair->GetDeviceName();
-    vendor      = "Corsair";
-    type        = DEVICE_TYPE_DRAM;
-    description = "Corsair Dominator Platinum RGB Device";
-    location    = corsair->GetDeviceLocation();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.speed_min  = 0;
-    Direct.speed_max  = 0;
-    Direct.speed      = 0;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-
-    active_mode = 0;
-}
-
-void RGBController_CorsairDominatorPlatinum::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zone                                               |
-    \*---------------------------------------------------------*/
-    zone new_zone;
-    new_zone.name       = "Corsair Platinum Zone";
-    new_zone.type       = ZONE_TYPE_LINEAR;
-    new_zone.leds_min   = corsair->GetLEDCount();
-    new_zone.leds_max   = corsair->GetLEDCount();
-    new_zone.leds_count = corsair->GetLEDCount();
-    new_zone.matrix_map = NULL;
-    zones.push_back(new_zone);
-
-    /*---------------------------------------------------------*\
-    | Set up LEDs                                               |
-    \*---------------------------------------------------------*/
-    for(std::size_t led_idx = 0; led_idx < zones[0].leds_count; led_idx++)
-    {
-        led *new_led  = new led();
-        new_led->name = "Corsair Platinum LED ";
-        new_led->name.append(std::to_string(led_idx));
-        leds.push_back(*new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_CorsairDominatorPlatinum::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_CorsairDominatorPlatinum::DeviceUpdateLEDs()
-{
-    for(std::size_t led = 0; led < colors.size(); led++)
-    {
-        RGBColor color    = colors[led];
-        unsigned char red = RGBGetRValue(color);
-        unsigned char grn = RGBGetGValue(color);
-        unsigned char blu = RGBGetBValue(color);
-        corsair->SetLEDColor(led, red, grn, blu);
-    }
-
-    corsair->ApplyColors();
-}
-
-void RGBController_CorsairDominatorPlatinum::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_CorsairDominatorPlatinum::UpdateSingleLED(int led)
-{
-    RGBColor color    = colors[led];
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    corsair->SetLEDColor(led, red, grn, blu);
-    corsair->ApplyColors();
-}
-
-void RGBController_CorsairDominatorPlatinum::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_CorsairDominatorPlatinum::DeviceUpdateMode()
-{
-
-}
@@ -1,32 +0,0 @@
-/*--------------------------------------------*\
-|  RGBController_CorsairDominatorPlatinum.h    |
-|                                              |
-|  Corsair Dominator Platinum RGB driver       |
-|                                              |
-|  Erik Gilling (konkers)       9/25/2020      |
-\*--------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "CorsairDominatorPlatinumController.h"
-
-class RGBController_CorsairDominatorPlatinum : public RGBController
-{
-public:
-    RGBController_CorsairDominatorPlatinum(CorsairDominatorPlatinumController* corsair_ptr);
-
-    void SetupZones();
-
-    void ResizeZone(int zone, int new_size);
-
-    void DeviceUpdateLEDs();
-    void UpdateZoneLEDs(int zone);
-    void UpdateSingleLED(int led);
-
-    void SetCustomMode();
-    void DeviceUpdateMode();
-
-private:
-    CorsairDominatorPlatinumController* corsair;
-};
@@ -1,268 +0,0 @@
-/*---------------------------------------------------------*\
-|  Processing Code for Corsair Hydro Series                 |
-|                                                           |
-|  Adam Honse ([email protected]), 8/17/2020        |
-\*---------------------------------------------------------*/
-
-#include "CorsairHydroController.h"
-
-#include <cstring>
-#include <iomanip>
-#include <sstream>
-
-CorsairHydroController::CorsairHydroController(libusb_device_handle* dev_handle)
-{
-    dev         = dev_handle;
-
-    /*-----------------------------------------------------*\
-    | Fill in location string with USB ID                   |
-    \*-----------------------------------------------------*/
-    libusb_device_descriptor descriptor;
-    libusb_get_device_descriptor(libusb_get_device(dev_handle), &descriptor);
-
-    std::stringstream location_stream;
-    location_stream << std::hex << std::setfill('0') << std::setw(4) << descriptor.idVendor << ":" << std::hex << std::setfill('0') << std::setw(4) << descriptor.idProduct;
-    location = location_stream.str();
-
-    SendInit();
-
-    SendFirmwareRequest();
-}
-
-std::string CorsairHydroController::GetFirmwareString()
-{
-    return(firmware_version);
-}
-
-std::string CorsairHydroController::GetLocation()
-{
-    return("USB: " + location);
-}
-
-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,89 +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();
-
-    std::string     GetLocation();
-
-    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;
-    std::string             location;
-
-    void            SendApplyBlink();
-    void            SendApplyPulse();
-    void            SendApplyShift();
-
-    void            SendColors
-                        (
-                            std::vector<RGBColor> & colors
-                        );
-
-    void            SendFirmwareRequest();
-
-    void            SendInit();
-
-    void            SendSpeed
-                        (
-                            unsigned char           speed
-                        );
-};
@@ -1,78 +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);
-
-    #ifdef _WIN32
-    libusb_set_option(ctx, LIBUSB_OPTION_USE_USBDK);
-    #endif
-
-    for(std::size_t device_idx = 0; device_idx < CORSAIR_NUM_DEVICES; device_idx++)
-    {
-        libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
-
-        //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);
@@ -1,138 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_CorsairHydro.cpp           |
-|                                           |
-|  Generic RGB Interface for Corsair        |
-|  Hydro Series                             |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 8/18/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController_CorsairHydro.h"
-
-RGBController_CorsairHydro::RGBController_CorsairHydro(CorsairHydroController* corsair_ptr)
-{
-    corsair = corsair_ptr;
-
-    vendor      = "Corsair";
-    description = "Corsair Hydro Series Device";
-    version     = corsair->GetFirmwareString();
-    type        = DEVICE_TYPE_COOLER;
-    location    = corsair->GetLocation();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Blinking;
-    Blinking.name       = "Blinking";
-    Blinking.value      = 1;
-    Blinking.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Blinking.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Blinking.speed_min  = 0x0F;
-    Blinking.speed_max  = 0x05;
-    Blinking.speed      = 0x0A;
-    Blinking.colors_min = 2;
-    Blinking.colors_max = 2;
-    Blinking.colors.resize(2);
-    modes.push_back(Blinking);
-
-    mode ColorShift;
-    ColorShift.name       = "Color Shift";
-    ColorShift.value      = 2;
-    ColorShift.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    ColorShift.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    ColorShift.speed_min  = 0x46;
-    ColorShift.speed_max  = 0x0F;
-    ColorShift.speed      = 0x28;
-    ColorShift.colors_min = 2;
-    ColorShift.colors_max = 2;
-    ColorShift.colors.resize(2);
-    modes.push_back(ColorShift);
-
-    mode Pulsing;
-    Pulsing.name       = "Pulsing";
-    Pulsing.value      = 3;
-    Pulsing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Pulsing.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Pulsing.speed_min  = 0x50;
-    Pulsing.speed_max  = 0x1E;
-    Pulsing.speed      = 0x37;
-    Pulsing.colors_min = 2;
-    Pulsing.colors_max = 2;
-    Pulsing.colors.resize(2);
-    modes.push_back(Pulsing);
-
-    SetupZones();
-}
-
-void RGBController_CorsairHydro::SetupZones()
-{
-    zone new_zone;
-    
-    new_zone.name       = "Pump Zone";
-    new_zone.type       = ZONE_TYPE_SINGLE;
-    new_zone.leds_min   = 1;
-    new_zone.leds_max   = 1;
-    new_zone.leds_count = 1;
-    new_zone.matrix_map = NULL;
-    zones.push_back(new_zone);
-
-    led new_led;
-
-    new_led.name        = "Pump LED";
-    leds.push_back(new_led);
-
-    SetupColors();
-}
-
-void RGBController_CorsairHydro::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_CorsairHydro::DeviceUpdateLEDs()
-{
-    DeviceUpdateMode();
-}
-
-void RGBController_CorsairHydro::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_CorsairHydro::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_CorsairHydro::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_CorsairHydro::DeviceUpdateMode()
-{
-    switch(modes[active_mode].value)
-    {
-        case 0:
-            corsair->SetFixed(colors);
-            break;
-
-        case 1:
-            corsair->SetBlink(modes[active_mode].colors, modes[active_mode].speed);
-            break;
-
-        case 2:
-            corsair->SetShift(modes[active_mode].colors, modes[active_mode].speed);
-            break;
-
-        case 3:
-            corsair->SetPulse(modes[active_mode].colors, modes[active_mode].speed);
-            break;
-    }
-}
@@ -1,32 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_CorsairHydro.h             |
-|                                           |
-|  Generic RGB Interface for Corsair        |
-|  Hydro Series                             |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 8/17/2020   |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "CorsairHydroController.h"
-
-class RGBController_CorsairHydro : public RGBController
-{
-public:
-    RGBController_CorsairHydro(CorsairHydroController* corsair_ptr);
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    CorsairHydroController*     corsair;
-};
@@ -11,12 +11,45 @@
 #include <string>
 #include <cstring>

-using namespace std::chrono_literals;
+//Include thread libraries for Windows or Linux
+#ifdef WIN32
+#include <process.h>
+#else
+#include "pthread.h"
+#include "unistd.h"
+#endif

-CorsairLightingNodeController::CorsairLightingNodeController(hid_device* dev_handle, const char* path)
+//Thread functions have different types in Windows and Linux
+#ifdef WIN32
+#define THREAD static void
+#define THREADRETURN
+#else
+#define THREAD static void*
+#define THREADRETURN return(NULL);
+#endif
+
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
 {
-    dev         = dev_handle;
-    location    = path;
+    usleep(1000 * milliseconds);
+}
+#endif
+
+THREAD keepalive_thread(void *param)
+{
+    CorsairLightingNodeController* corsair = static_cast<CorsairLightingNodeController*>(param);
+    corsair->KeepaliveThread();
+    THREADRETURN
+}
+
+CorsairLightingNodeController::CorsairLightingNodeController(libusb_device_handle* dev_handle, unsigned int dev_endpoint)
+{
+    dev = dev_handle;
+    endpoint = dev_endpoint;

    SendFirmwareRequest();

@@ -26,26 +59,24 @@ CorsairLightingNodeController::CorsairLightingNodeController(hid_device* dev_han
    | to not revert back into rainbow mode.  Start a thread |
    | to continuously send a keepalive packet every 5s      |
    \*-----------------------------------------------------*/
-    keepalive_thread_run = 1;
-    keepalive_thread = new std::thread(&CorsairLightingNodeController::KeepaliveThread, this);
+#ifdef WIN32
+    _beginthread(keepalive_thread, 0, this);
+#else
+    pthread_t thread;
+    pthread_create(&thread, NULL, &keepalive_thread, this);
+#endif
 }

 CorsairLightingNodeController::~CorsairLightingNodeController()
 {
-    keepalive_thread_run = 0;
-    keepalive_thread->join();
-    delete keepalive_thread;
 }

 void CorsairLightingNodeController::KeepaliveThread()
 {
-    while(keepalive_thread_run.load())
+    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);
    }
 }

@@ -54,22 +85,6 @@ std::string CorsairLightingNodeController::GetFirmwareString()
    return(firmware_version);
 }

-std::string CorsairLightingNodeController::GetLocationString()
-{
-    return("HID: " + location);
-}
-
-std::string CorsairLightingNodeController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
 void CorsairLightingNodeController::SetChannelEffect(unsigned char channel,
                                                unsigned char num_leds,
                                                unsigned char mode,
@@ -190,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                                       |
@@ -200,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)
    {
@@ -224,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                                       |
@@ -234,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
@@ -286,7 +293,8 @@ void CorsairLightingNodeController::SendBegin
    unsigned char   channel
    )
 {
-    unsigned char   usb_buf[65];
+    int             actual;
+    unsigned char   usb_buf[64];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -296,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
@@ -330,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                                       |
@@ -340,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()
@@ -395,7 +400,8 @@ void CorsairLightingNodeController::SendReset
    unsigned char   channel
    )
 {
-    unsigned char   usb_buf[65];
+    int             actual;
+    unsigned char   usb_buf[64];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -405,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
@@ -422,7 +426,8 @@ void CorsairLightingNodeController::SendPortState
    unsigned char   state
    )
 {
-    unsigned char   usb_buf[65];
+    int             actual;
+    unsigned char   usb_buf[64];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -432,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,12 +78,10 @@ enum
 class CorsairLightingNodeController
 {
 public:
-    CorsairLightingNodeController(hid_device* dev_handle, const char* path);
+    CorsairLightingNodeController(libusb_device_handle* dev_handle, unsigned int dev_endpoint);
    ~CorsairLightingNodeController();

    std::string     GetFirmwareString();
-    std::string     GetLocationString();
-    std::string     GetSerialString();

    unsigned int    GetStripsOnChannel(unsigned int channel);

@@ -110,12 +107,9 @@ public:
    void            KeepaliveThread();

 private:
-    hid_device*             dev;
+    libusb_device_handle*   dev;
+    unsigned int            endpoint;
    std::string             firmware_version;
-    std::string             location;
-    std::thread*            keepalive_thread;
-    std::atomic<bool>       keepalive_thread_run;
-    std::chrono::time_point<std::chrono::steady_clock> last_commit_time;

    void            SendFirmwareRequest();

@@ -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
@@ -12,32 +11,57 @@
 #define CORSAIR_LS100_PID               0x0C1E
 #define CORSAIR_1000D_OBSIDIAN_PID      0x1D00
 #define CORSAIR_SPEC_OMEGA_RGB_PID      0x1D04
-#define CORSAIR_LT100_PID               0x0C23
+
+typedef struct
+{
+    unsigned short  usb_vid;
+    unsigned short  usb_pid;
+    unsigned char   usb_endpoint;
+    unsigned char   channel_count;
+    const char *    name;
+} corsair_node_device;
+
+static const corsair_node_device device_list[6] =
+{
+    { 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"        }
+
+};

 /******************************************************************************************\
 *                                                                                          *
 *   DetectCorsairLightingNodeControllers                                                   *
 *                                                                                          *
 *       Detect devices supported by the Corsair Lighting Node Pro driver                   *
-*                                                                                          *
+*                                                                                          *                                                                                          *
 \******************************************************************************************/

-void DetectCorsairLightingNodeControllers(hid_device_info* info, const std::string& name)
+void DetectCorsairLightingNodeControllers(std::vector<RGBController*> &rgb_controllers)
 {
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
+    libusb_context * ctx;
+    libusb_init(&ctx);
+
+    for(int device_idx = 0; device_idx < 6; device_idx++)
    {
-        CorsairLightingNodeController* controller = new CorsairLightingNodeController(dev, info->path);
-        RGBController_CorsairLightingNode* rgb_controller = new RGBController_CorsairLightingNode(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        //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);
+
+        if( dev )
+        {
+            libusb_detach_kernel_driver(dev, 0);
+            libusb_claim_interface(dev, 0);
+
+            CorsairLightingNodeController* controller = new CorsairLightingNodeController(dev, device_list[device_idx].usb_endpoint);
+
+            RGBController_CorsairLightingNode* rgb_controller = new RGBController_CorsairLightingNode(controller);
+
+            rgb_controller->name = device_list[device_idx].name;
+
+            rgb_controllers.push_back(rgb_controller);
+        }
    }
 }   /* DetectCorsairLightingNodeControllers() */
-
-REGISTER_HID_DETECTOR("Corsair Lighting Node Core", DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LIGHTING_NODE_CORE_PID); // 1 channel
-REGISTER_HID_DETECTOR("Corsair Lighting Node Pro",  DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LIGHTING_NODE_PRO_PID);  // 2 channels
-REGISTER_HID_DETECTOR("Corsair Commander Pro",      DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_COMMANDER_PRO_PID);      // 2 channels
-REGISTER_HID_DETECTOR("Corsair LS100 Lighting Kit", DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LS100_PID);              // 1 channel
-REGISTER_HID_DETECTOR("Corsair 1000D Obsidian",     DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_1000D_OBSIDIAN_PID);     // 2 channels
-REGISTER_HID_DETECTOR("Corsair SPEC OMEGA RGB",     DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_SPEC_OMEGA_RGB_PID);     // 2 channels
-REGISTER_HID_DETECTOR("Corsair LT100",              DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LT100_PID);              // 2 channels
@@ -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,48 +20,31 @@ 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 };
-
-CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle, const char* path)
+static void send_usb_msg(hid_device* dev, char * data_pkt)
 {
-    dev         = dev_handle;
-    location    = path;
+    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)
+{
+    dev = dev_handle;

    ReadFirmwareInfo();

+    SpecialFunctionControl();
    LightingControl();
 }

 CorsairPeripheralController::~CorsairPeripheralController()
 {
-    if(dev)
-    {
-        hid_close(dev);
-    }
+
 }

 device_type CorsairPeripheralController::GetDeviceType()
@@ -71,42 +52,11 @@ device_type CorsairPeripheralController::GetDeviceType()
    return type;
 }

-std::string CorsairPeripheralController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-int CorsairPeripheralController::GetPhysicalLayout()
-{
-    return physical_layout;
-}
-
-int CorsairPeripheralController::GetLogicalLayout()
-{
-    return logical_layout;
-}
-
 std::string CorsairPeripheralController::GetFirmwareString()
 {
    return firmware_version;
 }

-std::string CorsairPeripheralController::GetName()
-{
-    return name;
-}
-
-std::string CorsairPeripheralController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
 void CorsairPeripheralController::SetLEDs(std::vector<RGBColor>colors)
 {
    switch(type)
@@ -122,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                                      |
@@ -164,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);
    }

    /*-----------------------------------------------------*\
@@ -189,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);

    /*-----------------------------------------------------*\
@@ -197,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);

    /*-----------------------------------------------------*\
@@ -205,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);
 }

@@ -286,18 +201,13 @@ void CorsairPeripheralController::SetLEDsKeyboardLimited(std::vector<RGBColor> c
    SubmitKeyboardLimitedColors(216);
 }

-void CorsairPeripheralController::SetName(std::string device_name)
-{
-    name = device_name;
-}
-
 /*-------------------------------------------------------------------------------------------------*\
 | Private packet sending functions.                                                                 |
 \*-------------------------------------------------------------------------------------------------*/

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

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -307,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                                       |
@@ -354,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                                       |
@@ -380,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:
@@ -474,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]);
    }
 }

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

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

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

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

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

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -637,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,52 +47,26 @@ 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, const char* path);
+    CorsairPeripheralController(hid_device* dev_handle);
    ~CorsairPeripheralController();

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

    void            SetLEDs(std::vector<RGBColor> colors);
    void            SetLEDsKeyboardFull(std::vector<RGBColor> colors);
    void            SetLEDsKeyboardLimited(std::vector<RGBColor> colors);
    void            SetLEDsMouse(std::vector<RGBColor> colors);
    void            SetLEDsMousemat(std::vector<RGBColor> colors);
-    void            SetName(std::string device_name);

 private:
    hid_device*             dev;

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

    void    LightingControl();
    void    SpecialFunctionControl();
@@ -1,7 +1,7 @@
-#include "Detector.h"
 #include "CorsairPeripheralController.h"
 #include "RGBController.h"
 #include "RGBController_CorsairPeripheral.h"
+#include <vector>
 #include <hidapi/hidapi.h>

 /*-----------------------------------------------------*\
@@ -25,7 +25,7 @@
 #define CORSAIR_K70_RGB_PID             0x1B13
 #define CORSAIR_K70_LUX_RGB_PID         0x1B33
 #define CORSAIR_K70_RGB_RAPIDFIRE_PID   0x1B38
-#define CORSAIR_K70_RGB_MK2_PID         0x1B49
+#define CORSAIR_K70_RGB_MK2_PID         0x1B38
 #define CORSAIR_K70_RGB_MK2_SE_PID      0x1B6B
 #define CORSAIR_K70_RGB_MK2_LP_PID      0x1B55

@@ -39,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                                  |
@@ -53,11 +48,40 @@
 \*-----------------------------------------------------*/
 #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;
+    unsigned short  usb_pid;
+    unsigned char   usb_interface;
+    const char *    name;
+} corsair_node_device;
+
+#define CORSAIR_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+static const corsair_node_device device_list[] =
+{
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Keyboards                                                                                             |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { CORSAIR_VID,          CORSAIR_K68_RGB,                    1,      "Corsair K68 RGB"                   },
+    { CORSAIR_VID,          CORSAIR_K70_RGB_PID,                1,      "Corsair K70 RGB"                   },
+    { CORSAIR_VID,          CORSAIR_K70_LUX_RGB_PID,            1,      "Corsair K70 LUX RGB"               },
+    { CORSAIR_VID,          CORSAIR_K70_RGB_RAPIDFIRE_PID,      1,      "Corsair K70 RGB RAPIDFIRE"         },
+    { CORSAIR_VID,          CORSAIR_K70_RGB_MK2_PID,            1,      "Corsair K70 RGB MK.2"              },
+    { CORSAIR_VID,          CORSAIR_K70_RGB_MK2_SE_PID,         1,      "Corsair K70 RGB MK.2 SE"           },
+    { CORSAIR_VID,          CORSAIR_K70_RGB_MK2_LP_PID,         1,      "Corsair K70 RGB MK.2 Low Profile"  },
+    { CORSAIR_VID,          CORSAIR_K95_RGB_PID,                1,      "Corsair K95 RGB"                   },
+    { CORSAIR_VID,          CORSAIR_K95_PLATINUM_PID,           1,      "Corsair K95 RGB PLATINUM"          },
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Mice                                                                                                  |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { CORSAIR_VID,          CORSAIR_M65_PRO_PID,                1,      "Corsair M65 PRO"                   },
+    { CORSAIR_VID,          CORSAIR_M65_RGB_ELITE_PID,          1,      "Corsair M65 RGB Elite"             },
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Mousemats                                                                                             |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { CORSAIR_VID,          CORSAIR_MM800_RGB_POLARIS_PID,      0,      "Corsair MM800 RGB Polaris"         }
+};

 /******************************************************************************************\
 *                                                                                          *
@@ -67,68 +91,47 @@
 *                                                                                          *
 \******************************************************************************************/

-void DetectCorsairPeripheralControllers(hid_device_info* info, const std::string& name)
+void DetectCorsairPeripheralControllers(std::vector<RGBController*>& rgb_controllers)
 {
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
-    {
-        CorsairPeripheralController* controller = new CorsairPeripheralController(dev, info->path);
-        controller->SetName(name);
+    hid_device_info* info;
+    hid_device* dev;

-        if(controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
+    hid_init();
+
+    for(std::size_t device_idx = 0; device_idx < CORSAIR_NUM_DEVICES; device_idx++)
+    {
+        dev = NULL;
+
+        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+
+        //Look for Corsair RGB Peripheral
+        while(info)
        {
-            RGBController_CorsairPeripheral* rgb_controller = new RGBController_CorsairPeripheral(controller);
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
+            if((info->vendor_id == device_list[device_idx].usb_vid)
+            &&(info->product_id == device_list[device_idx].usb_pid)
+            &&(info->interface_number == device_list[device_idx].usb_interface))
+            {
+                dev = hid_open_path(info->path);
+                break;
+            }
+            else
+            {
+                info = info->next;
+            }
        }
-        else
+
+        if( dev )
        {
-            delete controller;
+            CorsairPeripheralController* controller = new CorsairPeripheralController(dev);
+
+            if(controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
+            {
+                RGBController_CorsairPeripheral* rgb_controller = new RGBController_CorsairPeripheral(controller);
+
+                rgb_controller->name = device_list[device_idx].name;
+                
+                rgb_controllers.push_back(rgb_controller);
+            }
        }
    }
-}   /* DetectCorsairPeripheralControllers() */
-
-/*-----------------------------------------------------------------------------------------------------*\
-| Keyboards                                                                                             |
-\*-----------------------------------------------------------------------------------------------------*/
-//REGISTER_HID_DETECTOR_IP("Corsair K55 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K55_RGB_PID,           1, 0xFFC2); // Not per-key, disabled for now
-REGISTER_HID_DETECTOR_IP("Corsair K65 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_PID,           1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K65 LUX RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_LUX_RGB_PID,       1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K65 RGB RAPIDFIRE",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_RAPIDFIRE_PID, 1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K68 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K68_RGB,               1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_PID,           1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 LUX RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_LUX_RGB_PID,       1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB RAPIDFIRE",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_RAPIDFIRE_PID, 1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_PID,       1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2 SE",          DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_SE_PID,    1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2 Low Profile", DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_LP_PID,    1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K95 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K95_RGB_PID,           1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K95 RGB PLATINUM",         DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K95_PLATINUM_PID,      1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Strafe",                   DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_PID,            1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Strafe MK.2",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_MK2_PID,        1, 0xFFC2);
-/*-----------------------------------------------------------------------------------------------------*\
-| Mice                                                                                                  |
-\*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Corsair Glaive RGB PRO",           DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_GLAIVE_RGB_PRO_PID,    1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PID,       1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB PRO",          DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PRO_PID,   1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair M65 PRO",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_PRO_PID,           1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair M65 RGB Elite" ,           DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_RGB_ELITE_PID,     1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Scimitar PRO RGB",         DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SCIMITAR_PRO_RGB_PID,  1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Sabre RGB",                DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SABRE_RGB_PID,         1, 0xFFC2);
-
-/*-----------------------------------------------------------------------------------------------------*\
-| Mousemats                                                                                             |
-\*-----------------------------------------------------------------------------------------------------*/
-#ifdef USE_HID_USAGE
-REGISTER_HID_DETECTOR_P("Corsair MM800 RGB Polaris",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_MM800_RGB_POLARIS_PID, 0xFFC2);
-#else
-REGISTER_HID_DETECTOR_I("Corsair MM800 RGB Polaris",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_MM800_RGB_POLARIS_PID, 0);
-#endif
-/*-----------------------------------------------------------------------------------------------------*\
-| Headset Stands                                                                                        |
-\*-----------------------------------------------------------------------------------------------------*/
-#ifdef USE_HID_USAGE
-REGISTER_HID_DETECTOR_P("Corsair ST100 RGB",                DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_ST100_PID,             0xFFC2);
-#else
-REGISTER_HID_DETECTOR_I("Corsair ST100 RGB",                DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_ST100_PID,             0);
-#endif
+}
@@ -1,842 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_CorsairPeripheral.cpp      |
-|                                           |
-|  Generic RGB Interface for Corsair RGB    |
-|  keyboard, mouse, and mousemat devices    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/9/2020    |
-\*-----------------------------------------*/
-
-#include "RGBController_CorsairPeripheral.h"
-
-//0xFFFFFFFF indicates an unused entry in matrix
-#define NA  0xFFFFFFFF
-
-static unsigned int matrix_map[6][23] =
-    { {   0,  NA,  10,  18,  28,  36,  NA,  46,  55,  64,  74,  NA,  84,  93, 102,   6,  15,  24,  33,  26,  35,  44,  53 },
-      {   1,  11,  19,  29,  37,  47,  56,  65,  75,  85,  94,  NA, 103,   7,  25,  NA,  42,  51,  60,  62,  72,  82,  91 },
-      {   2,  NA,  12,  20,  30,  38,  NA,  48,  57,  66,  76,  86,  95, 104,  70,  80,  34,  43,  52,  9,   17,  27, 100 },
-      {   3,  NA,  13,  21,  31,  39,  NA,  49,  58,  67,  77,  87,  96, 105,  98, 112,  NA,  NA,  NA,  45,  54,  63,  NA },
-      {   4, 111,  22,  32,  40,  50,  NA,  59,  NA,  68,  78,  88,  97, 106,  61,  NA,  NA,  81,  NA,  73,  83,  92, 109 },
-      {   5,  14,  23,  NA,  NA,  NA,  NA,  41,  NA,  NA,  NA,  NA,  69,  79,  89,  71,  90,  99, 108, 101,  NA, 110,  NA } };
-
-static unsigned int matrix_map_k95_platinum[7][24] =
-    { {  NA,  NA,  NA,  NA, 107,   8,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  16,  NA,  NA,  NA,},
-      { 113,   0,  NA,  10,  18,  28,  36,  NA,  46,  55,  64,  74,  NA,  84,  93, 102,   6,  15,  24,  33,  26,  35,  44,  53 },
-      { 114,   1,  11,  19,  29,  37,  47,  56,  65,  75,  85,  94,  NA, 103,   7,  25,  NA,  42,  51,  60,  62,  72,  82,  91 },
-      { 115,   2,  NA,  12,  20,  30,  38,  NA,  48,  57,  66,  76,  86,  95, 104,  70,  80,  34,  43,  52,  9,   17,  27, 100 },
-      { 116,   3,  NA,  13,  21,  31,  39,  NA,  49,  58,  67,  77,  87,  96, 105,  98, 112,  NA,  NA,  NA,  45,  54,  63,  NA },
-      { 117,   4, 111,  22,  32,  40,  50,  NA,  59,  NA,  68,  78,  88,  97, 106,  61,  NA,  NA,  81,  NA,  73,  83,  92, 109 },
-      { 118,   5,  14,  23,  NA,  NA,  NA,  NA,  41,  NA,  NA,  NA,  NA,  69,  79,  89,  71,  90,  99, 108, 101,  NA, 110,  NA } };
-
-static unsigned int matrix_map_k95[7][26] =
-    { {  NA,  NA,  NA, 131, 132, 133, 134,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 107,   8,  NA,  NA,  16,  NA,  NA,},
-      { 113, 114, 115,   0,  NA,  10,  18,  28,  36,  NA,  46,  55,  64,  74,  NA,  84,  93, 102,   6,  15,  24,  33,  26,  35,  44,  53 },
-      { 116, 117, 118,   1,  11,  19,  29,  37,  47,  56,  65,  75,  85,  94,  NA, 103,   7,  25,  NA,  42,  51,  60,  62,  72,  82,  91 },
-      { 119, 120, 121,   2,  NA,  12,  20,  30,  38,  NA,  48,  57,  66,  76,  86,  95, 104,  70,  80,  34,  43,  52,  9,   17,  27, 100 },
-      { 122, 123, 124,   3,  NA,  13,  21,  31,  39,  NA,  49,  58,  67,  77,  87,  96, 105,  98, 112,  NA,  NA,  NA,  45,  54,  63,  NA },
-      { 125, 126, 127,   4, 111,  22,  32,  40,  50,  NA,  59,  NA,  68,  78,  88,  97, 106,  61,  NA,  NA,  81,  NA,  73,  83,  92, 109 },
-      { 128, 129, 130,   5,  14,  23,  NA,  NA,  NA,  NA,  41,  NA,  NA,  NA,  NA,  69,  79,  89,  71,  90,  99, 108, 101,  NA, 110,  NA } };
-
-/*---------------------------------------------------------*\
-| Normal Corsair Layout                                     |
-\*---------------------------------------------------------*/
-static const char* zone_names[] =
-{
-    "Keyboard",
-};
-
-static const unsigned int zone_sizes[] =
-{
-    113
-};
-
-static const zone_type zone_types[] =
-{
-    ZONE_TYPE_MATRIX,
-};
-
-/*---------------------------------------------------------*\
-| K95 Platinum                                              |
-\*---------------------------------------------------------*/
-static const char* zone_names_k95_platinum[] =
-{
-    "Keyboard",
-    "Light Bar"
-};
-
-static const unsigned int zone_sizes_k95_platinum[] =
-{
-    119,
-    19
-};
-
-static const zone_type zone_types_k95_platinum[] =
-{
-    ZONE_TYPE_MATRIX,
-    ZONE_TYPE_LINEAR
-};
-
-/*---------------------------------------------------------*\
-| K95 non-Platinum                                          |
-\*---------------------------------------------------------*/
-static const char* zone_names_k95[] =
-{
-    "Keyboard",
-};
-
-static const unsigned int zone_sizes_k95[] =
-{
-    135
-};
-
-static const zone_type zone_types_k95[] =
-{
-    ZONE_TYPE_MATRIX
-};
-
-
-static const char* led_names[] =
-{
-    "Key: Escape",          //0
-    "Key: `",               //1
-    "Key: Tab",             //2
-    "Key: Caps Lock",       //3
-    "Key: Left Shift",      //4
-    "Key: Left Control",    //5
-    "Key: F12",             //6
-    "Key: =",               //7
-    "Key: Lock",            //8
-    "Key: Number Pad 7",    //9
-    "Key: F1",              //12
-    "Key: 1",               //13
-    "Key: Q",               //14
-    "Key: A",               //15
-    "Key: Left Windows",    //17
-    "Key: Print Screen",    //18
-    "Key: Media Mute",      //20
-    "Key: Number Pad 8",    //21
-    "Key: F2",              //24
-    "Key: 2",               //25
-    "Key: W",               //26
-    "Key: S",               //27
-    "Key: Z",               //28
-    "Key: Left Alt",        //29
-    "Key: Scroll Lock",     //30
-    "Key: Backspace",       //31
-    "Key: Media Stop",      //32
-    "Key: Number Pad 9",    //33
-    "Key: F3",              //36
-    "Key: 3",               //37
-    "Key: E",               //38
-    "Key: D",               //39
-    "Key: X",               //40
-    "Key: Pause/Break",     //42
-    "Key: Delete",          //43
-    "Key: Media Previous",  //44
-    "Key: F4",              //48
-    "Key: 4",               //49
-    "Key: R",               //50
-    "Key: F",               //51
-    "Key: C",               //52
-    "Key: Space",           //53
-    "Key: Insert",          //54
-    "Key: End",             //55
-    "Key: Media Play/Pause",//56
-    "Key: Number Pad 4",    //57
-    "Key: F5",              //60
-    "Key: 5",               //61
-    "Key: T",               //62
-    "Key: G",               //63
-    "Key: V",               //64
-    "Key: Home",            //66
-    "Key: Page Down",       //67
-    "Key: Media Next",      //68
-    "Key: Number Pad 5",    //69
-    "Key: F6",              //72
-    "Key: 6",               //73
-    "Key: Y",               //74
-    "Key: H",               //75
-    "Key: B",               //76
-    "Key: Page Up",         //78
-    "Key: Right Shift",     //79
-    "Key: Num Lock",        //80
-    "Key: Number Pad 6",    //81
-    "Key: F7",              //84
-    "Key: 7",               //85
-    "Key: U",               //86
-    "Key: J",               //87
-    "Key: N",               //88
-    "Key: Right Alt",       //89
-    "Key: ]",               //90
-    "Key: Right Control",   //91
-    "Key: Number Pad /",    //92
-    "Key: Number Pad 1",    //93
-    "Key: F8",              //96
-    "Key: 8",               //97
-    "Key: I",               //98
-    "Key: K",               //99
-    "Key: M",               //100
-    "Key: Right Windows",   //101
-    "Key: \\ (ANSI)",       //102
-    "Key: Up Arrow",        //103
-    "Key: Number Pad *",    //104
-    "Key: Number Pad 2",    //105
-    "Key: F9",              //108
-    "Key: 9",               //109
-    "Key: O",               //110
-    "Key: L",               //111
-    "Key: ,",               //112
-    "Key: Menu",            //113
-    "Key: Left Arrow",      //115
-    "Key: Number Pad -",    //116
-    "Key: Number Pad 3",    //117
-    "Key: F10",             //120
-    "Key: 0",               //121
-    "Key: P",               //122
-    "Key: ;",               //123
-    "Key: .",               //124
-    "Key: Enter",           //126
-    "Key: Down Arrow",      //127
-    "Key: Number Pad +",    //128
-    "Key: Number Pad 0",    //129
-    "Key: F11",             //132
-    "Key: -",               //133
-    "Key: [",               //134
-    "Key: '",               //135
-    "Key: /",               //136
-    "Key: Brightness",      //137
-    "Key: Right Arrow",     //139
-    "Key: Number Pad Enter",//140
-    "Key: Number Pad .",    //141
-    "Key: / (ISO)",
-    "Key: \\ (ISO)",
-};
-
-static const char* led_names_k95_plat[] =
-{
-    "Key: Escape",          //0
-    "Key: `",               //1
-    "Key: Tab",             //2
-    "Key: Caps Lock",       //3
-    "Key: Left Shift",      //4
-    "Key: Left Control",    //5
-    "Key: F12",             //6
-    "Key: =",               //7
-    "Key: Lock",            //8
-    "Key: Number Pad 7",    //9
-    "Key: F1",              //12
-    "Key: 1",               //13
-    "Key: Q",               //14
-    "Key: A",               //15
-    "Key: Left Windows",    //17
-    "Key: Print Screen",    //18
-    "Key: Media Mute",      //20
-    "Key: Number Pad 8",    //21
-    "Key: F2",              //24
-    "Key: 2",               //25
-    "Key: W",               //26
-    "Key: S",               //27
-    "Key: Z",               //28
-    "Key: Left Alt",        //29
-    "Key: Scroll Lock",     //30
-    "Key: Backspace",       //31
-    "Key: Media Stop",      //32
-    "Key: Number Pad 9",    //33
-    "Key: F3",              //36
-    "Key: 3",               //37
-    "Key: E",               //38
-    "Key: D",               //39
-    "Key: X",               //40
-    "Key: Pause/Break",     //42
-    "Key: Delete",          //43
-    "Key: Media Previous",  //44
-    "Key: F4",              //48
-    "Key: 4",               //49
-    "Key: R",               //50
-    "Key: F",               //51
-    "Key: C",               //52
-    "Key: Space",           //53
-    "Key: Insert",          //54
-    "Key: End",             //55
-    "Key: Media Play/Pause",//56
-    "Key: Number Pad 4",    //57
-    "Key: F5",              //60
-    "Key: 5",               //61
-    "Key: T",               //62
-    "Key: G",               //63
-    "Key: V",               //64
-    "Key: Home",            //66
-    "Key: Page Down",       //67
-    "Key: Media Next",      //68
-    "Key: Number Pad 5",    //69
-    "Key: F6",              //72
-    "Key: 6",               //73
-    "Key: Y",               //74
-    "Key: H",               //75
-    "Key: B",               //76
-    "Key: Page Up",         //78
-    "Key: Right Shift",     //79
-    "Key: Num Lock",        //80
-    "Key: Number Pad 6",    //81
-    "Key: F7",              //84
-    "Key: 7",               //85
-    "Key: U",               //86
-    "Key: J",               //87
-    "Key: N",               //88
-    "Key: Right Alt",       //89
-    "Key: ]",               //90
-    "Key: Right Control",   //91
-    "Key: Number Pad /",    //92
-    "Key: Number Pad 1",    //93
-    "Key: F8",              //96
-    "Key: 8",               //97
-    "Key: I",               //98
-    "Key: K",               //99
-    "Key: M",               //100
-    "Key: Right Windows",   //101
-    "Key: \\ (ANSI)",       //102
-    "Key: Up Arrow",        //103
-    "Key: Number Pad *",    //104
-    "Key: Number Pad 2",    //105
-    "Key: F9",              //108
-    "Key: 9",               //109
-    "Key: O",               //110
-    "Key: L",               //111
-    "Key: ,",               //112
-    "Key: Menu",            //113
-    "Key: Left Arrow",      //115
-    "Key: Number Pad -",    //116
-    "Key: Number Pad 3",    //117
-    "Key: F10",             //120
-    "Key: 0",               //121
-    "Key: P",               //122
-    "Key: ;",               //123
-    "Key: .",               //124
-    "Key: Enter",           //126
-    "Key: Down Arrow",      //127
-    "Key: Number Pad +",    //128
-    "Key: Number Pad 0",    //129
-    "Key: F11",             //132
-    "Key: -",               //133
-    "Key: [",               //134
-    "Key: '",               //135
-    "Key: /",               //136
-    "Key: Brightness",      //137
-    "Key: Right Arrow",     //139
-    "Key: Number Pad Enter",//140
-    "Key: Number Pad .",    //141
-    "Key: / (ISO)",
-    "Key: \\ (ISO)",
-    "Key: Macro G1",
-    "Key: Macro G2",
-    "Key: Macro G3",
-    "Key: Macro G4",
-    "Key: Macro G5",
-    "Key: Macro G6",
-    "Light Bar 1",
-    "Light Bar 2",
-    "Light Bar 3",
-    "Light Bar 4",
-    "Light Bar 5",
-    "Light Bar 6",
-    "Light Bar 7",
-    "Light Bar 8",
-    "Light Bar 9",
-    "Light Bar 10",
-    "Light Bar 11",
-    "Light Bar 12",
-    "Light Bar 13",
-    "Light Bar 14",
-    "Light Bar 15",
-    "Light Bar 16",
-    "Light Bar 17",
-    "Light Bar 18",
-    "Light Bar 19"
-};
-
-static const char* led_names_k95[] =
-{
-    "Key: Escape",          //0
-    "Key: `",               //1
-    "Key: Tab",             //2
-    "Key: Caps Lock",       //3
-    "Key: Left Shift",      //4
-    "Key: Left Control",    //5
-    "Key: F12",             //6
-    "Key: =",               //7
-    "Key: Lock",            //8
-    "Key: Number Pad 7",    //9
-    "Key: F1",              //12
-    "Key: 1",               //13
-    "Key: Q",               //14
-    "Key: A",               //15
-    "Key: Left Windows",    //17
-    "Key: Print Screen",    //18
-    "Key: Media Mute",      //20
-    "Key: Number Pad 8",    //21
-    "Key: F2",              //24
-    "Key: 2",               //25
-    "Key: W",               //26
-    "Key: S",               //27
-    "Key: Z",               //28
-    "Key: Left Alt",        //29
-    "Key: Scroll Lock",     //30
-    "Key: Backspace",       //31
-    "Key: Media Stop",      //32
-    "Key: Number Pad 9",    //33
-    "Key: F3",              //36
-    "Key: 3",               //37
-    "Key: E",               //38
-    "Key: D",               //39
-    "Key: X",               //40
-    "Key: Pause/Break",     //42
-    "Key: Delete",          //43
-    "Key: Media Previous",  //44
-    "Key: F4",              //48
-    "Key: 4",               //49
-    "Key: R",               //50
-    "Key: F",               //51
-    "Key: C",               //52
-    "Key: Space",           //53
-    "Key: Insert",          //54
-    "Key: End",             //55
-    "Key: Media Play/Pause",//56
-    "Key: Number Pad 4",    //57
-    "Key: F5",              //60
-    "Key: 5",               //61
-    "Key: T",               //62
-    "Key: G",               //63
-    "Key: V",               //64
-    "Key: Home",            //66
-    "Key: Page Down",       //67
-    "Key: Media Next",      //68
-    "Key: Number Pad 5",    //69
-    "Key: F6",              //72
-    "Key: 6",               //73
-    "Key: Y",               //74
-    "Key: H",               //75
-    "Key: B",               //76
-    "Key: Page Up",         //78
-    "Key: Right Shift",     //79
-    "Key: Num Lock",        //80
-    "Key: Number Pad 6",    //81
-    "Key: F7",              //84
-    "Key: 7",               //85
-    "Key: U",               //86
-    "Key: J",               //87
-    "Key: N",               //88
-    "Key: Right Alt",       //89
-    "Key: ]",               //90
-    "Key: Right Control",   //91
-    "Key: Number Pad /",    //92
-    "Key: Number Pad 1",    //93
-    "Key: F8",              //96
-    "Key: 8",               //97
-    "Key: I",               //98
-    "Key: K",               //99
-    "Key: M",               //100
-    "Key: Right Windows",   //101
-    "Key: \\ (ANSI)",       //102
-    "Key: Up Arrow",        //103
-    "Key: Number Pad *",    //104
-    "Key: Number Pad 2",    //105
-    "Key: F9",              //108
-    "Key: 9",               //109
-    "Key: O",               //110
-    "Key: L",               //111
-    "Key: ,",               //112
-    "Key: Menu",            //113
-    "Key: Left Arrow",      //115
-    "Key: Number Pad -",    //116
-    "Key: Number Pad 3",    //117
-    "Key: F10",             //120
-    "Key: 0",               //121
-    "Key: P",               //122
-    "Key: ;",               //123
-    "Key: .",               //124
-    "Key: Enter",           //126
-    "Key: Down Arrow",      //127
-    "Key: Number Pad +",    //128
-    "Key: Number Pad 0",    //129
-    "Key: F11",             //132
-    "Key: -",               //133
-    "Key: [",               //134
-    "Key: '",               //135
-    "Key: /",               //136
-    "Key: Brightness",      //137
-    "Key: Right Arrow",     //139
-    "Key: Number Pad Enter",//140
-    "Key: Number Pad .",    //141
-    "Key: / (ISO)",
-    "Key: \\ (ISO)",
-    "Key: Macro G1",
-    "Key: Macro G2",
-    "Key: Macro G3",
-    "Key: Macro G4",
-    "Key: Macro G5",
-    "Key: Macro G6",
-    "Key: Macro G7",
-    "Key: Macro G8",
-    "Key: Macro G9",
-    "Key: Macro G10",
-    "Key: Macro G11",
-    "Key: Macro G12",
-    "Key: Macro G13",
-    "Key: Macro G14",
-    "Key: Macro G15",
-    "Key: Macro G16",
-    "Key: Macro G17",
-    "Key: Macro G18",
-    "Key: MR",
-    "Key: M1",
-    "Key: M2",
-    "Key: M3",
-};
-
-static const char* corsair_mouse_leds[] =
-{
-    "Mouse LED 1",
-    "Mouse LED 2",
-    "Mouse LED 3",
-    "Mouse LED 4",
-    "Mouse LED 5",
-    "Mouse LED 6",
-    "Mouse LED 7",
-    "Mouse LED 8",
-    "Mouse LED 9",
-    "Mouse LED 10",
-    "Mouse LED 11",
-    "Mouse LED 12",
-    "Mouse LED 13",
-    "Mouse LED 14",
-    "Mouse LED 15",
-};
-
-static const char* corsair_m65_elite_leds[] =
-{
-    "",
-    "",
-    "Logo",
-    "DPI",
-    "Scroll Wheel",
-    "",
-    "",
-    "",
-    "",
-    "",
-    "",
-    "",
-    "",
-    "",
-    "",
-};
-
-static const char* corsair_sabre_rgb_leds[] =
-{
-    "",
-    "Underglow",
-    "Logo",
-    "DPI",
-    "Scroll Wheel",
-    "",
-    "",
-    "",
-    "",
-    "",
-    "",
-    "",
-    "",
-    "",
-    ""
-};
-
-static const char* corsair_harpoon_pro_leds[] =
-{
-    "",
-    "",
-    "",
-    "Logo",
-    "",
-    "",
-    "",
-    "",
-    "",
-    "",
-    "",
-    "",
-    "",
-    "",
-    "",
-};
-
-RGBController_CorsairPeripheral::RGBController_CorsairPeripheral(CorsairPeripheralController* corsair_ptr)
-{
-    corsair = corsair_ptr;
-
-    name        = corsair->GetName();
-    vendor      = "Corsair";
-    description = "Corsair RGB Peripheral Device";
-    type        = corsair->GetDeviceType();
-    version     = corsair->GetFirmwareString();
-    location    = corsair->GetDeviceLocation();
-    serial      = corsair->GetSerialString();
-
-    physical_layout = corsair->GetPhysicalLayout();
-    logical_layout  = corsair->GetLogicalLayout();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-}
-
-RGBController_CorsairPeripheral::~RGBController_CorsairPeripheral()
-{
-    /*---------------------------------------------------------*\
-    | Delete the matrix map                                     |
-    \*---------------------------------------------------------*/
-    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
-    {
-        if(zones[zone_index].matrix_map != NULL)
-        {
-            delete zones[zone_index].matrix_map;
-        }
-    }
-}
-
-void RGBController_CorsairPeripheral::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Determine number of zones                                 |
-    |   For now, keyboard has 2 zones and mousemat has 1        |
-    \*---------------------------------------------------------*/
-    unsigned int num_zones = 0;
-
-    switch(type)
-    {
-        case DEVICE_TYPE_KEYBOARD:
-            if (logical_layout == CORSAIR_TYPE_K95_PLAT)
-            {
-                num_zones = 2;
-                break;
-            }
-            num_zones = 1;
-            break;
-
-        case DEVICE_TYPE_MOUSE:
-        case DEVICE_TYPE_MOUSEMAT:
-            num_zones = 1;
-            break;
-
-        case DEVICE_TYPE_HEADSET_STAND:
-            num_zones = 2;
-            break;
-    }
-
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    unsigned int total_led_count = 0;
-    for(unsigned int zone_idx = 0; zone_idx < num_zones; zone_idx++)
-    {
-        zone new_zone;
-        switch(type)
-        {
-            case DEVICE_TYPE_KEYBOARD:
-                if (logical_layout == CORSAIR_TYPE_K95_PLAT)
-                {
-                    new_zone.name                   = zone_names_k95_platinum[zone_idx];
-                    new_zone.type                   = zone_types_k95_platinum[zone_idx];
-                    new_zone.leds_min               = zone_sizes_k95_platinum[zone_idx];
-                    new_zone.leds_max               = zone_sizes_k95_platinum[zone_idx];
-                    new_zone.leds_count             = zone_sizes_k95_platinum[zone_idx];
-
-                    if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
-                    {
-                        new_zone.matrix_map         = new matrix_map_type;
-                        new_zone.matrix_map->height = 7;
-                        new_zone.matrix_map->width  = 24;
-                        new_zone.matrix_map->map    = (unsigned int *)&matrix_map_k95_platinum;
-                    }
-                    else
-                    {
-                        new_zone.matrix_map         = NULL;
-                    }
-                }
-                else if (logical_layout == CORSAIR_TYPE_K95)
-                {
-                    new_zone.name                   = zone_names_k95[zone_idx];
-                    new_zone.type                   = zone_types_k95[zone_idx];
-                    new_zone.leds_min               = zone_sizes_k95[zone_idx];
-                    new_zone.leds_max               = zone_sizes_k95[zone_idx];
-                    new_zone.leds_count             = zone_sizes_k95[zone_idx];
-
-                    if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
-                    {
-                        new_zone.matrix_map         = new matrix_map_type;
-                        new_zone.matrix_map->height = 7;
-                        new_zone.matrix_map->width  = 26;
-                        new_zone.matrix_map->map    = (unsigned int *)&matrix_map_k95;
-                    }
-                    else
-                    {
-                        new_zone.matrix_map         = NULL;
-                    }
-                }
-                else //default layout
-                {
-                    new_zone.name                   = zone_names[zone_idx];
-                    new_zone.type                   = zone_types[zone_idx];
-                    new_zone.leds_min               = zone_sizes[zone_idx];
-                    new_zone.leds_max               = zone_sizes[zone_idx];
-                    new_zone.leds_count             = zone_sizes[zone_idx];
-
-                    if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
-                    {
-                        new_zone.matrix_map         = new matrix_map_type;
-                        new_zone.matrix_map->height = 6;
-                        new_zone.matrix_map->width  = 23;
-                        new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
-                    }
-                    else
-                    {
-                        new_zone.matrix_map         = NULL;
-                    }
-                }
-                break;
-
-
-            case DEVICE_TYPE_MOUSE:
-                new_zone.name           = "Mouse Zone";
-                new_zone.type           = ZONE_TYPE_SINGLE;
-                new_zone.leds_min       = 15;
-                new_zone.leds_max       = 15;
-                new_zone.leds_count     = 15;
-                new_zone.matrix_map     = NULL;
-                break;
-
-            case DEVICE_TYPE_MOUSEMAT:
-                new_zone.name           = "Mousemat Zone";
-                new_zone.type           = ZONE_TYPE_LINEAR;
-                new_zone.leds_min       = 15;
-                new_zone.leds_max       = 15;
-                new_zone.leds_count     = 15;
-                new_zone.matrix_map     = NULL;
-                break;
-
-            case DEVICE_TYPE_HEADSET_STAND:
-                if(zone_idx == 0)
-                {
-                    new_zone.name           = "Base LED Strip";
-                    new_zone.type           = ZONE_TYPE_LINEAR;
-                    new_zone.leds_min       = 8;
-                    new_zone.leds_max       = 8;
-                    new_zone.leds_count     = 8;
-                    new_zone.matrix_map     = NULL;
-                }
-                else
-                {
-                    new_zone.name           = "Logo";
-                    new_zone.type           = ZONE_TYPE_SINGLE;
-                    new_zone.leds_min       = 1;
-                    new_zone.leds_max       = 1;
-                    new_zone.leds_count     = 1;
-                    new_zone.matrix_map     = NULL;
-                }
-                break;
-        }
-
-        zones.push_back(new_zone);
-
-        total_led_count += new_zone.leds_count;
-    }
-
-    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
-    {
-        led new_led;
-
-        switch(type)
-        {
-            case DEVICE_TYPE_KEYBOARD:
-                if(logical_layout == CORSAIR_TYPE_K95_PLAT)
-                {
-                    new_led.name = led_names_k95_plat[led_idx];
-                }
-                else if(logical_layout == CORSAIR_TYPE_K95)
-                {
-                    new_led.name = led_names_k95[led_idx];
-                }
-                else
-                {
-                    new_led.name = led_names[led_idx];
-                }
-                break;
-
-            case DEVICE_TYPE_MOUSE:
-                if(name == "Corsair M65 RGB Elite")
-                {
-                    new_led.name = corsair_m65_elite_leds[led_idx];
-                }
-                else if(name == "Corsair Harpoon RGB PRO")
-                {
-                    new_led.name = corsair_harpoon_pro_leds[led_idx];
-                }
-                else if(name == "Corsair Sabre RGB")
-                {
-                    new_led.name = corsair_sabre_rgb_leds[led_idx];
-                }
-                else
-                {
-                    new_led.name = corsair_mouse_leds[led_idx];
-                }
-                break;
-            
-            case DEVICE_TYPE_MOUSEMAT:
-            case DEVICE_TYPE_HEADSET_STAND:
-                new_led.name = "Mousemat LED ";
-                new_led.name.append(std::to_string(led_idx + 1));
-                break;
-        }
-        
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_CorsairPeripheral::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_CorsairPeripheral::DeviceUpdateLEDs()
-{
-    corsair->SetLEDs(colors);
-}
-
-void RGBController_CorsairPeripheral::UpdateZoneLEDs(int /*zone*/)
-{
-    corsair->SetLEDs(colors);
-}
-
-void RGBController_CorsairPeripheral::UpdateSingleLED(int /*led*/)
-{
-    corsair->SetLEDs(colors);
-}
-
-void RGBController_CorsairPeripheral::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_CorsairPeripheral::DeviceUpdateMode()
-{
-
-}
@@ -36,7 +36,7 @@ std::string CorsairVengeanceController::GetDeviceLocation()
    snprintf(addr, 5, "0x%02X", dev);
    return_string.append(", address ");
    return_string.append(addr);
-    return("I2C: " + return_string);
+    return(return_string);
 }

 unsigned int CorsairVengeanceController::GetLEDCount()
@@ -1,9 +1,7 @@
-#include "Detector.h"
 #include "CorsairVengeanceController.h"
 #include "RGBController.h"
 #include "RGBController_CorsairVengeance.h"
 #include "i2c_smbus.h"
-#include "pci_ids.h"
 #include <vector>
 #include <stdio.h>
 #include <stdlib.h>
@@ -59,74 +57,69 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses

    for (unsigned int bus = 0; bus < busses.size(); bus++)
    {
-        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        // Check for Corsair controller at 0x58
+        if (TestForCorsairVengeanceController(busses[bus], 0x58))
        {
-            // Check for Corsair controller at 0x58
-            if (TestForCorsairVengeanceController(busses[bus], 0x58))
-            {
-                new_corsair = new CorsairVengeanceController(busses[bus], 0x58);
-                new_controller = new RGBController_CorsairVengeance(new_corsair);
-                rgb_controllers.push_back(new_controller);
-            }
+            new_corsair = new CorsairVengeanceController(busses[bus], 0x58);
+            new_controller = new RGBController_CorsairVengeance(new_corsair);
+            rgb_controllers.push_back(new_controller);
+        }

-            // Check for Corsair controller at 0x59
-            if (TestForCorsairVengeanceController(busses[bus], 0x59))
-            {
-                new_corsair = new CorsairVengeanceController(busses[bus], 0x59);
-                new_controller = new RGBController_CorsairVengeance(new_corsair);
-                rgb_controllers.push_back(new_controller);
-            }
+        // Check for Corsair controller at 0x59
+        if (TestForCorsairVengeanceController(busses[bus], 0x59))
+        {
+            new_corsair = new CorsairVengeanceController(busses[bus], 0x59);
+            new_controller = new RGBController_CorsairVengeance(new_corsair);
+            rgb_controllers.push_back(new_controller);
+        }

-            // Check for Corsair controller at 0x5A
-            if (TestForCorsairVengeanceController(busses[bus], 0x5A))
-            {
-                new_corsair = new CorsairVengeanceController(busses[bus], 0x5A);
-                new_controller = new RGBController_CorsairVengeance(new_corsair);
-                rgb_controllers.push_back(new_controller);
-            }
+        // Check for Corsair controller at 0x5A
+        if (TestForCorsairVengeanceController(busses[bus], 0x5A))
+        {
+            new_corsair = new CorsairVengeanceController(busses[bus], 0x5A);
+            new_controller = new RGBController_CorsairVengeance(new_corsair);
+            rgb_controllers.push_back(new_controller);
+        }

-            // Check for Corsair controller at 0x5B
-            if (TestForCorsairVengeanceController(busses[bus], 0x5B))
-            {
-                new_corsair = new CorsairVengeanceController(busses[bus], 0x5B);
-                new_controller = new RGBController_CorsairVengeance(new_corsair);
-                rgb_controllers.push_back(new_controller);
-            }
+        // Check for Corsair controller at 0x5B
+        if (TestForCorsairVengeanceController(busses[bus], 0x5B))
+        {
+            new_corsair = new CorsairVengeanceController(busses[bus], 0x5B);
+            new_controller = new RGBController_CorsairVengeance(new_corsair);
+            rgb_controllers.push_back(new_controller);
+        }

-            // Check for Corsair controller at 0x5C
-            if (TestForCorsairVengeanceController(busses[bus], 0x5C))
-            {
-                new_corsair = new CorsairVengeanceController(busses[bus], 0x5C);
-                new_controller = new RGBController_CorsairVengeance(new_corsair);
-                rgb_controllers.push_back(new_controller);
-            }
+        // Check for Corsair controller at 0x5C
+        if (TestForCorsairVengeanceController(busses[bus], 0x5C))
+        {
+            new_corsair = new CorsairVengeanceController(busses[bus], 0x5C);
+            new_controller = new RGBController_CorsairVengeance(new_corsair);
+            rgb_controllers.push_back(new_controller);
+        }

-            // Check for Corsair controller at 0x5D
-            if (TestForCorsairVengeanceController(busses[bus], 0x5D))
-            {
-                new_corsair = new CorsairVengeanceController(busses[bus], 0x5D);
-                new_controller = new RGBController_CorsairVengeance(new_corsair);
-                rgb_controllers.push_back(new_controller);
-            }
+        // Check for Corsair controller at 0x5D
+        if (TestForCorsairVengeanceController(busses[bus], 0x5D))
+        {
+            new_corsair = new CorsairVengeanceController(busses[bus], 0x5D);
+            new_controller = new RGBController_CorsairVengeance(new_corsair);
+            rgb_controllers.push_back(new_controller);
+        }

-            // Check for Corsair controller at 0x5E
-            if (TestForCorsairVengeanceController(busses[bus], 0x5E))
-            {
-                new_corsair = new CorsairVengeanceController(busses[bus], 0x5E);
-                new_controller = new RGBController_CorsairVengeance(new_corsair);
-                rgb_controllers.push_back(new_controller);
-            }
+        // Check for Corsair controller at 0x5E
+        if (TestForCorsairVengeanceController(busses[bus], 0x5E))
+        {
+            new_corsair = new CorsairVengeanceController(busses[bus], 0x5E);
+            new_controller = new RGBController_CorsairVengeance(new_corsair);
+            rgb_controllers.push_back(new_controller);
+        }

-            // Check for Corsair controller at 0x5F
-            if (TestForCorsairVengeanceController(busses[bus], 0x5F))
-            {
-                new_corsair = new CorsairVengeanceController(busses[bus], 0x5F);
-                new_controller = new RGBController_CorsairVengeance(new_corsair);
-                rgb_controllers.push_back(new_controller);
-            }
+        // Check for Corsair controller at 0x5F
+        if (TestForCorsairVengeanceController(busses[bus], 0x5F))
+        {
+            new_corsair = new CorsairVengeanceController(busses[bus], 0x5F);
+            new_controller = new RGBController_CorsairVengeance(new_corsair);
+            rgb_controllers.push_back(new_controller);
        }
    }

-}   /* 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)
 {
@@ -47,7 +56,7 @@ std::string CorsairVengeanceProController::GetDeviceLocation()
    snprintf(addr, 5, "0x%02X", dev);
    return_string.append(", address ");
    return_string.append(addr);
-    return("I2C: " + return_string);
+    return(return_string);
 }

 unsigned int CorsairVengeanceProController::GetLEDCount()
@@ -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,14 +1,21 @@
-#include "Detector.h"
 #include "CorsairVengeanceProController.h"
 #include "RGBController.h"
 #include "RGBController_CorsairVengeancePro.h"
 #include "i2c_smbus.h"
-#include "pci_ids.h"
 #include <vector>
 #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

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

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

@@ -67,74 +74,69 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus

    for (unsigned int bus = 0; bus < busses.size(); bus++)
    {
-        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        // Check for Corsair controller at 0x58
+        if (TestForCorsairVengeanceProController(busses[bus], 0x58))
        {
-            // Check for Corsair controller at 0x58
-            if (TestForCorsairVengeanceProController(busses[bus], 0x58))
-            {
-                new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x58);
-                new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-                rgb_controllers.push_back(new_controller);
-            }
+            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x58);
+            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
+        }

-            // Check for Corsair controller at 0x59
-            if (TestForCorsairVengeanceProController(busses[bus], 0x59))
-            {
-                new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x59);
-                new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-                rgb_controllers.push_back(new_controller);
-            }
+        // Check for Corsair controller at 0x59
+        if (TestForCorsairVengeanceProController(busses[bus], 0x59))
+        {
+            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x59);
+            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
+        }

-            // Check for Corsair controller at 0x5A
-            if (TestForCorsairVengeanceProController(busses[bus], 0x5A))
-            {
-                new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5A);
-                new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-                rgb_controllers.push_back(new_controller);
-            }
+        // Check for Corsair controller at 0x5A
+        if (TestForCorsairVengeanceProController(busses[bus], 0x5A))
+        {
+            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5A);
+            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
+        }

-            // Check for Corsair controller at 0x5B
-            if (TestForCorsairVengeanceProController(busses[bus], 0x5B))
-            {
-                new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5B);
-                new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-                rgb_controllers.push_back(new_controller);
-            }
+        // Check for Corsair controller at 0x5B
+        if (TestForCorsairVengeanceProController(busses[bus], 0x5B))
+        {
+            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5B);
+            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
+        }

-            // Check for Corsair controller at 0x5C
-            if (TestForCorsairVengeanceProController(busses[bus], 0x5C))
-            {
-                new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5C);
-                new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-                rgb_controllers.push_back(new_controller);
-            }
+        // Check for Corsair controller at 0x5C
+        if (TestForCorsairVengeanceProController(busses[bus], 0x5C))
+        {
+            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5C);
+            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
+        }

-            // Check for Corsair controller at 0x5D
-            if (TestForCorsairVengeanceProController(busses[bus], 0x5D))
-            {
-                new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5D);
-                new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-                rgb_controllers.push_back(new_controller);
-            }
+        // Check for Corsair controller at 0x5D
+        if (TestForCorsairVengeanceProController(busses[bus], 0x5D))
+        {
+            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5D);
+            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
+        }

-            // Check for Corsair controller at 0x5E
-            if (TestForCorsairVengeanceProController(busses[bus], 0x5E))
-            {
-                new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5E);
-                new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-                rgb_controllers.push_back(new_controller);
-            }
+        // Check for Corsair controller at 0x5E
+        if (TestForCorsairVengeanceProController(busses[bus], 0x5E))
+        {
+            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5E);
+            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
+        }

-            // Check for Corsair controller at 0x5F
-            if (TestForCorsairVengeanceProController(busses[bus], 0x5F))
-            {
-                new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5F);
-                new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
-                rgb_controllers.push_back(new_controller);
-            }
+        // Check for Corsair controller at 0x5F
+        if (TestForCorsairVengeanceProController(busses[bus], 0x5F))
+        {
+            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5F);
+            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
        }
    }

-}   /* DetectCorsairVengeanceProControllers() */
-
-REGISTER_I2C_DETECTOR("Corsair Vengeance Pro", DetectCorsairVengeanceProControllers);
+}   /* DetectCorsairVengeanceProControllers() */
@@ -15,9 +15,6 @@ CrucialController::CrucialController(i2c_smbus_interface* bus, crucial_dev_id de
 {
    this->bus = bus;
    this->dev = dev;
-
-    // We don't know what mode the sticks are in until we set one.
-    this->last_mode = CRUCIAL_MODE_UNKNOWN;
 }

 CrucialController::~CrucialController()
@@ -37,7 +34,7 @@ std::string CrucialController::GetDeviceLocation()
    snprintf(addr, 5, "0x%02X", dev);
    return_string.append(", address ");
    return_string.append(addr);
-    return("I2C: " + return_string);
+    return(return_string);
 }

 unsigned int CrucialController::GetLEDCount()
@@ -47,11 +44,7 @@ unsigned int CrucialController::GetLEDCount()

 void CrucialController::SetMode(unsigned char mode)
 {
-    // Don't set a mode if we've already set the same one before.
-    // This is mostly useful for direct mode and updating colors often.
-    if (mode == last_mode) return;
    SendEffectMode(mode, 0x10);
-    last_mode = mode;
 }

 void CrucialController::SetAllColorsDirect(RGBColor* colors)
@@ -87,8 +80,6 @@ void CrucialController::SendEffectMode(unsigned char mode, unsigned char speed)

 void CrucialController::SendDirectColors(RGBColor* color_buf)
 {
-    SetMode(CRUCIAL_MODE_STATIC);
-
    //Red Channels
    CrucialRegisterWrite(0x8300, RGBGetRValue(color_buf[0]));
    CrucialRegisterWrite(0x8301, RGBGetRValue(color_buf[1]));
@@ -18,7 +18,6 @@ typedef unsigned short	crucial_register;

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

@@ -1,9 +1,7 @@
-#include "Detector.h"
 #include "CrucialController.h"
 #include "RGBController.h"
 #include "RGBController_Crucial.h"
 #include "i2c_smbus.h"
-#include "pci_ids.h"
 #include <vector>
 #include <stdio.h>
 #include <stdlib.h>
@@ -75,21 +73,16 @@ void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses, std::ve

    for (unsigned int bus = 0; bus < busses.size(); bus++)
    {
-        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        // Add Crucial controllers
+        for (unsigned int address_list_idx = 0; address_list_idx < CRUCIAL_ADDRESS_COUNT; address_list_idx++)
        {
-            // Add Crucial controllers
-            for (unsigned int address_list_idx = 0; address_list_idx < CRUCIAL_ADDRESS_COUNT; address_list_idx++)
+            if (TestForCrucialController(busses[bus], crucial_addresses[address_list_idx]))
            {
-                if (TestForCrucialController(busses[bus], crucial_addresses[address_list_idx]))
-                {
-                    new_crucial = new CrucialController(busses[bus], crucial_addresses[address_list_idx]);
-                    new_controller = new RGBController_Crucial(new_crucial);
-                    rgb_controllers.push_back(new_controller);
-                }
+                new_crucial = new CrucialController(busses[bus], crucial_addresses[address_list_idx]);
+                new_controller = new RGBController_Crucial(new_crucial);
+                rgb_controllers.push_back(new_controller);
            }
        }
    }

 }   /* DetectCrucialControllers() */
-
-REGISTER_I2C_DETECTOR("Crucial", DetectCrucialControllers);
@@ -1,544 +0,0 @@
-#include "Detector.h"
-#include "RGBController.h"
-#include "RGBController_Debug.h"
-#include "RGBController_Dummy.h"
-#include "SettingsManager.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <fcntl.h>
-#include <string.h>
-#include <fstream>
-#include <iostream>
-#include <string>
-
-
-//0xFFFFFFFF indicates an unused entry in matrix
-#define NA  0xFFFFFFFF
-
-static unsigned int debug_keyboard_matrix_map[6][23] =
-    { {   0,  NA,  16,  30,  44,  54,  NA,  65,  75,  84,  95,  NA,   8,  23 ,  38,   6 ,  22,  36,  49,  NA,  NA,  NA,  NA },
-      {   1,  17,  31,  45,  55,  66,  76,  85,  96,   9,  24,  NA,  39,   7 ,  37,  NA ,  60,  70,  80,  52,  63,  73,  82 },
-      {   2,  NA,  18,  32,  46,  56,  NA,  67,  77,  86,  97,  10,  25,  40 ,  90,  101,  50,  61,  71,  51,  62,  72,  93 },
-      {   3,  NA,  19,  33,  47,  57,  NA,  68,  78,  87,  98,  11,  26,  41 ,  28,  14 ,  NA,  NA,  NA,  92, 103,  53,  NA },
-      {   4,  20,  34,  48,  58,  69,  NA,  79,  NA,  88,  99,  12,  27,  42 ,  81,  NA ,  NA, 102,  NA,  64,  74,  83, 104 },
-      {   5,  21,  35,  NA,  NA,  NA,  NA,  59,  NA,  NA,  NA,  NA,  89,  100,  13,  91 ,  15,  29,  43,  94,  NA, 105,  NA } };
-
-static const char *led_names[] =
-{
-    "Key: Escape",
-    "Key: `",
-    "Key: Tab",
-    "Key: Caps Lock",
-    "Key: Left Shift",
-    "Key: Left Control",
-    "Key: F12",
-    "Key: =",
-    "Key: F9",
-    "Key: 9",
-    "Key: O",
-    "Key: L",
-    "Key: ,",
-    "Key: Menu",
-    "Key: Enter (ISO)",
-    "Key: Left Arrow",
-    "Key: F1",
-    "Key: 1",
-    "Key: Q",
-    "Key: A",
-    "Key: \\ (ISO)",
-    "Key: Left Windows",
-    "Key: Print Screen",
-    "Key: F10",
-    "Key: 0",
-    "Key: P",
-    "Key: ;",
-    "Key: .",
-    "Key: Enter",
-    "Key: Down Arrow",
-    "Key: F2",
-    "Key: 2",
-    "Key: W",
-    "Key: S",
-    "Key: Z",
-    "Key: Left Alt",
-    "Key: Scroll Lock",
-    "Key: Backspace",
-    "Key: F11",
-    "Key: -",
-    "Key: [",
-    "Key: '",
-    "Key: /",
-    "Key: Right Arrow",
-    "Key: F3",
-    "Key: 3",
-    "Key: E",
-    "Key: D",
-    "Key: X",
-    "Key: Pause/Break",
-    "Key: Delete",
-    "Key: Number Pad 7",
-    "Key: Num Lock",
-    "Key: Number Pad 6",
-    "Key: F4",
-    "Key: 4",
-    "Key: R",
-    "Key: F",
-    "Key: C",
-    "Key: Space",
-    "Key: Insert",
-    "Key: End",
-    "Key: Number Pad 8",
-    "Key: Number Pad /",
-    "Key: Number Pad 1",
-    "Key: F5",
-    "Key: 5",
-    "Key: T",
-    "Key: G",
-    "Key: V",
-    "Key: Home",
-    "Key: Page Down",
-    "Key: Number Pad 9",
-    "Key: Number Pad *",
-    "Key: Number Pad 2",
-    "Key: F6",
-    "Key: 6",
-    "Key: Y",
-    "Key: H",
-    "Key: B",
-    "Key: Page Up",
-    "Key: Right Shift",
-    "Key: Number Pad -",
-    "Key: Number Pad 3",
-    "Key: F7",
-    "Key: 7",
-    "Key: U",
-    "Key: J",
-    "Key: N",
-    "Key: Right Alt",
-    "Key: ]",
-    "Key: Right Control",
-    "Key: Number Pad 4",
-    "Key: Number Pad +",
-    "Key: Number Pad 0",
-    "Key: F8",
-    "Key: 8",
-    "Key: I",
-    "Key: K",
-    "Key: M",
-    "Key: Right Windows",
-    "Key: \\ (ANSI)",
-    "Key: Up Arrow",
-    "Key: Number Pad 5",
-    "Key: Number Pad Enter",
-    "Key: Number Pad .",
-    "RGB Strip 1",
-    "RGB Strip 2",
-    "RGB Strip 3",
-    "RGB Strip 4",
-    "RGB Strip 5",
-    "RGB Strip 6",
-    "RGB Strip 7",
-    "RGB Strip 8",
-    "RGB Strip 9",
-    "RGB Strip 10",
-    "RGB Strip 11",
-    "RGB Strip 12",
-    "RGB Strip 13",
-    "RGB Strip 14",
-    "RGB Strip 15",
-    "RGB Strip 16",
-    "RGB Strip 17",
-    "RGB Strip 18",
-    "Key: Media Previous",
-    "Key: Media Play/Pause",
-    "Key: Media Next",
-    "Key: Media Mute"
-};
-
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectDebugControllers                                                                 *
-*                                                                                          *
-*       Add dummy controllers based on the DebugDevices key in the settings json           *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectDebugControllers(std::vector<RGBController*> &rgb_controllers)
-{
-    json            debug_settings;
-    
-    /*-------------------------------------------------*\
-    | Get Debug Device settings from settings manager   |
-    \*-------------------------------------------------*/
-    debug_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("DebugDevices");
-
-    /*-------------------------------------------------*\
-    | If the Debug settings contains devices, process   |
-    \*-------------------------------------------------*/
-    if(debug_settings.contains("devices"))
-    {
-        for(unsigned int device_idx = 0; device_idx < debug_settings["devices"].size(); device_idx++)
-        {
-            std::string type = "";
-
-            if(debug_settings["devices"][device_idx].contains("type"))
-            {
-                type = debug_settings["devices"][device_idx]["type"];
-            }
-
-            if(type == "motherboard")
-            {
-                /*---------------------------------------------------------*\
-                | Create a dummy motherboard                                |
-                \*---------------------------------------------------------*/
-                RGBController_Dummy* dummy_motherboard = new RGBController_Dummy();
-
-                dummy_motherboard->name                     = "Debug Motherboard";
-                dummy_motherboard->type                     = DEVICE_TYPE_MOTHERBOARD;
-                dummy_motherboard->description              = "Debug Motherboard Device";
-                dummy_motherboard->location                 = "Debug Motherboard Location";
-                dummy_motherboard->version                  = "Debug Motherboard Version";
-                dummy_motherboard->serial                   = "Debug Motherboard Serial";
-
-                /*---------------------------------------------------------*\
-                | Create a direct mode for the dummy motherboard            |
-                \*---------------------------------------------------------*/
-                mode dummy_motherboard_direct_mode;
-
-                dummy_motherboard_direct_mode.name          = "Direct";
-                dummy_motherboard_direct_mode.value         = 0;
-                dummy_motherboard_direct_mode.flags         = MODE_FLAG_HAS_PER_LED_COLOR;
-                dummy_motherboard_direct_mode.color_mode    = MODE_COLORS_PER_LED;
-
-                dummy_motherboard->modes.push_back(dummy_motherboard_direct_mode);
-
-                /*---------------------------------------------------------*\
-                | Create a single zone/LED for the dummy motherboard        |
-                \*---------------------------------------------------------*/
-                zone dummy_motherboard_single_zone;
-
-                dummy_motherboard_single_zone.name          = "Single Zone";
-                dummy_motherboard_single_zone.type          = ZONE_TYPE_SINGLE;
-                dummy_motherboard_single_zone.leds_min      = 1;
-                dummy_motherboard_single_zone.leds_max      = 1;
-                dummy_motherboard_single_zone.leds_count    = 1;
-                dummy_motherboard_single_zone.matrix_map    = NULL;
-
-                dummy_motherboard->zones.push_back(dummy_motherboard_single_zone);
-
-                led dummy_motherboard_single_led;
-
-                dummy_motherboard_single_led.name           = "Single LED";
-
-                dummy_motherboard->leds.push_back(dummy_motherboard_single_led);
-
-                /*---------------------------------------------------------*\
-                | Create a linear zone for the dummy motherboard            |
-                \*---------------------------------------------------------*/
-                zone dummy_motherboard_linear_zone;
-
-                dummy_motherboard_linear_zone.name          = "Linear Zone";
-                dummy_motherboard_linear_zone.type          = ZONE_TYPE_LINEAR;
-                dummy_motherboard_linear_zone.leds_min      = 10;
-                dummy_motherboard_linear_zone.leds_max      = 10;
-                dummy_motherboard_linear_zone.leds_count    = 10;
-                dummy_motherboard_linear_zone.matrix_map    = NULL;
-
-                dummy_motherboard->zones.push_back(dummy_motherboard_linear_zone);
-
-                for(std::size_t led_idx = 0; led_idx < 10; led_idx++)
-                {
-                    led dummy_motherboard_linear_led;
-
-                    dummy_motherboard_linear_led.name       = "Linear LED " + std::to_string(led_idx);
-
-                    dummy_motherboard->leds.push_back(dummy_motherboard_linear_led);
-                }
-
-                dummy_motherboard->SetupColors();
-
-                /*---------------------------------------------------------*\
-                | Push the dummy motherboard onto the controller list       |
-                \*---------------------------------------------------------*/
-                rgb_controllers.push_back(dummy_motherboard);
-            }
-            else if(type == "dram")
-            {
-                /*---------------------------------------------------------*\
-                | Create a dummy DRAM                                       |
-                \*---------------------------------------------------------*/
-                RGBController_Dummy* dummy_dram = new RGBController_Dummy();
-
-                dummy_dram->name                            = "Debug DRAM";
-                dummy_dram->type                            = DEVICE_TYPE_DRAM;
-                dummy_dram->description                     = "Debug DRAM Device";
-                dummy_dram->location                        = "Debug DRAM Location";
-                dummy_dram->version                         = "Debug DRAM Version";
-                dummy_dram->serial                          = "Debug DRAM Serial";
-
-                /*---------------------------------------------------------*\
-                | Create a direct mode for the dummy DRAM                   |
-                \*---------------------------------------------------------*/
-                mode dummy_dram_direct_mode;
-
-                dummy_dram_direct_mode.name                 = "Direct";
-                dummy_dram_direct_mode.value                = 0;
-                dummy_dram_direct_mode.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-                dummy_dram_direct_mode.color_mode           = MODE_COLORS_PER_LED;
-
-                dummy_dram->modes.push_back(dummy_dram_direct_mode);
-
-                /*---------------------------------------------------------*\
-                | Create a single zone/LED for the dummy DRAM               |
-                \*---------------------------------------------------------*/
-                zone dummy_dram_single_zone;
-
-                dummy_dram_single_zone.name                 = "Single Zone";
-                dummy_dram_single_zone.type                 = ZONE_TYPE_SINGLE;
-                dummy_dram_single_zone.leds_min             = 1;
-                dummy_dram_single_zone.leds_max             = 1;
-                dummy_dram_single_zone.leds_count           = 1;
-                dummy_dram_single_zone.matrix_map           = NULL;
-
-                dummy_dram->zones.push_back(dummy_dram_single_zone);
-
-                led dummy_dram_single_led;
-
-                dummy_dram_single_led.name                  = "Single LED";
-
-                dummy_dram->leds.push_back(dummy_dram_single_led);
-
-                /*---------------------------------------------------------*\
-                | Create a linear zone for the dummy DRAM                   |
-                \*---------------------------------------------------------*/
-                zone dummy_dram_linear_zone;
-
-                dummy_dram_linear_zone.name                 = "Linear Zone";
-                dummy_dram_linear_zone.type                 = ZONE_TYPE_LINEAR;
-                dummy_dram_linear_zone.leds_min             = 5;
-                dummy_dram_linear_zone.leds_max             = 5;
-                dummy_dram_linear_zone.leds_count           = 5;
-                dummy_dram_linear_zone.matrix_map           = NULL;
-
-                dummy_dram->zones.push_back(dummy_dram_linear_zone);
-
-                for(std::size_t led_idx = 0; led_idx < 5; led_idx++)
-                {
-                    led dummy_dram_linear_led;
-
-                    dummy_dram_linear_led.name              = "Linear LED " + std::to_string(led_idx);
-
-                    dummy_dram->leds.push_back(dummy_dram_linear_led);
-                }
-
-                dummy_dram->SetupColors();
-
-                /*---------------------------------------------------------*\
-                | Push the dummy DRAM onto the controller list              |
-                \*---------------------------------------------------------*/
-                rgb_controllers.push_back(dummy_dram);
-            }
-            else if(type == "gpu")
-            {
-                /*---------------------------------------------------------*\
-                | Create a dummy GPU                                        |
-                \*---------------------------------------------------------*/
-                RGBController_Dummy* dummy_gpu = new RGBController_Dummy();
-
-                dummy_gpu->name                             = "Debug GPU";
-                dummy_gpu->type                             = DEVICE_TYPE_GPU;
-                dummy_gpu->description                      = "Debug GPU Device";
-                dummy_gpu->location                         = "Debug GPU Location";
-                dummy_gpu->version                          = "Debug GPU Version";
-                dummy_gpu->serial                           = "Debug GPU Serial";
-
-                /*---------------------------------------------------------*\
-                | Create a direct mode for the dummy GPU                    |
-                \*---------------------------------------------------------*/
-                mode dummy_gpu_direct_mode;
-
-                dummy_gpu_direct_mode.name                  = "Direct";
-                dummy_gpu_direct_mode.value                 = 0;
-                dummy_gpu_direct_mode.flags                 = MODE_FLAG_HAS_PER_LED_COLOR;
-                dummy_gpu_direct_mode.color_mode            = MODE_COLORS_PER_LED;
-
-                dummy_gpu->modes.push_back(dummy_gpu_direct_mode);
-
-                /*---------------------------------------------------------*\
-                | Create a single zone/LED for the dummy GPU                |
-                \*---------------------------------------------------------*/
-                zone dummy_gpu_single_zone;
-
-                dummy_gpu_single_zone.name                  = "Single Zone";
-                dummy_gpu_single_zone.type                  = ZONE_TYPE_SINGLE;
-                dummy_gpu_single_zone.leds_min              = 1;
-                dummy_gpu_single_zone.leds_max              = 1;
-                dummy_gpu_single_zone.leds_count            = 1;
-                dummy_gpu_single_zone.matrix_map            = NULL;
-
-                dummy_gpu->zones.push_back(dummy_gpu_single_zone);
-
-                led dummy_gpu_single_led;
-
-                dummy_gpu_single_led.name                   = "Single LED";
-
-                dummy_gpu->leds.push_back(dummy_gpu_single_led);
-
-                /*---------------------------------------------------------*\
-                | Create a linear zone for the dummy GPU                    |
-                \*---------------------------------------------------------*/
-                zone dummy_gpu_linear_zone;
-
-                dummy_gpu_linear_zone.name                  = "Linear Zone";
-                dummy_gpu_linear_zone.type                  = ZONE_TYPE_LINEAR;
-                dummy_gpu_linear_zone.leds_min              = 15;
-                dummy_gpu_linear_zone.leds_max              = 15;
-                dummy_gpu_linear_zone.leds_count            = 15;
-                dummy_gpu_linear_zone.matrix_map            = NULL;
-
-                dummy_gpu->zones.push_back(dummy_gpu_linear_zone);
-
-                for(std::size_t led_idx = 0; led_idx < 15; led_idx++)
-                {
-                    led dummy_gpu_linear_led;
-
-                    dummy_gpu_linear_led.name               = "Linear LED " + std::to_string(led_idx);
-
-                    dummy_gpu->leds.push_back(dummy_gpu_linear_led);
-                }
-
-                dummy_gpu->SetupColors();
-
-                /*---------------------------------------------------------*\
-                | Push the dummy GPU onto the controller list               |
-                \*---------------------------------------------------------*/
-                rgb_controllers.push_back(dummy_gpu);
-            }
-            else if(type == "keyboard")
-            {
-                /*---------------------------------------------------------*\
-                | Create a dummy Keyboard                                   |
-                \*---------------------------------------------------------*/
-                RGBController_Dummy* dummy_keyboard = new RGBController_Dummy();
-
-                dummy_keyboard->name                             = "Debug Keyboard";
-                dummy_keyboard->type                             = DEVICE_TYPE_KEYBOARD;
-                dummy_keyboard->description                      = "Debug Keyboard Device";
-                dummy_keyboard->location                         = "Debug Keyboard Location";
-                dummy_keyboard->version                          = "Debug Keyboard Version";
-                dummy_keyboard->serial                           = "Debug Keyboard Serial";
-
-                /*---------------------------------------------------------*\
-                | Create a direct mode for the dummy GPU                    |
-                \*---------------------------------------------------------*/
-                mode dummy_gpu_direct_mode;
-
-                dummy_gpu_direct_mode.name                  = "Direct";
-                dummy_gpu_direct_mode.value                 = 0;
-                dummy_gpu_direct_mode.flags                 = MODE_FLAG_HAS_PER_LED_COLOR;
-                dummy_gpu_direct_mode.color_mode            = MODE_COLORS_PER_LED;
-
-                dummy_keyboard->modes.push_back(dummy_gpu_direct_mode);
-
-                /*---------------------------------------------------------*\
-                | Create a matrix zone for the debug Keyboard               |
-                \*---------------------------------------------------------*/
-                zone dummy_keyboard_matrix_zone;
-
-                dummy_keyboard_matrix_zone.name                  = "Keyboard Matrix Zone";
-                dummy_keyboard_matrix_zone.type                  = ZONE_TYPE_MATRIX;
-                dummy_keyboard_matrix_zone.leds_min              = 106;
-                dummy_keyboard_matrix_zone.leds_max              = 106;
-                dummy_keyboard_matrix_zone.leds_count            = 106;
-                dummy_keyboard_matrix_zone.matrix_map            = new matrix_map_type;
-                dummy_keyboard_matrix_zone.matrix_map->height    = 6;
-                dummy_keyboard_matrix_zone.matrix_map->width     = 23;
-                dummy_keyboard_matrix_zone.matrix_map->map       = (unsigned int*)&debug_keyboard_matrix_map;
-
-                dummy_keyboard->zones.push_back(dummy_keyboard_matrix_zone);
-
-                /*---------------------------------------------------------*\
-                | Create a linear zone for the dummy GPU                    |
-                \*---------------------------------------------------------*/
-                zone dummy_keyboard_linear_zone;
-
-                dummy_keyboard_linear_zone.name                  = "Linear Zone";
-                dummy_keyboard_linear_zone.type                  = ZONE_TYPE_LINEAR;
-                dummy_keyboard_linear_zone.leds_min              = 18;
-                dummy_keyboard_linear_zone.leds_max              = 18;
-                dummy_keyboard_linear_zone.leds_count            = 18;
-                dummy_keyboard_linear_zone.matrix_map            = NULL;
-
-                dummy_keyboard->zones.push_back(dummy_keyboard_linear_zone);
-
-                for(std::size_t led_idx = 0; led_idx < 124; led_idx++)
-                {
-                    led dummy_keyboard_led;
-                    dummy_keyboard_led.name = led_names[led_idx];
-                    dummy_keyboard->leds.push_back(dummy_keyboard_led);
-                }
-
-                dummy_keyboard->SetupColors();
-
-                /*---------------------------------------------------------*\
-                | Push the dummy Keyboard onto the controller list          |
-                \*---------------------------------------------------------*/
-                rgb_controllers.push_back(dummy_keyboard);
-            }
-            else if(type == "argb")
-            {
-                /*---------------------------------------------------------*\
-                | Create a dummy ARGB                                       |
-                \*---------------------------------------------------------*/
-                RGBController_Debug* dummy_argb = new RGBController_Debug();
-
-                dummy_argb->name                            = "Debug ARGB";
-                dummy_argb->type                            = DEVICE_TYPE_LEDSTRIP;
-                dummy_argb->description                     = "Debug ARGB Device";
-                dummy_argb->location                        = "Debug ARGB Location";
-                dummy_argb->version                         = "Debug ARGB Version";
-                dummy_argb->serial                          = "Debug ARGB Serial";
-
-                /*---------------------------------------------------------*\
-                | Create a direct mode for the dummy ARGB                   |
-                \*---------------------------------------------------------*/
-                mode dummy_argb_direct_mode;
-
-                dummy_argb_direct_mode.name                 = "Direct";
-                dummy_argb_direct_mode.value                = 0;
-                dummy_argb_direct_mode.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-                dummy_argb_direct_mode.color_mode           = MODE_COLORS_PER_LED;
-
-                dummy_argb->modes.push_back(dummy_argb_direct_mode);
-                
-                /*---------------------------------------------------------*\
-                | Create a linear zone for the dummy ARGB                   |
-                \*---------------------------------------------------------*/
-                zone dummy_argb_linear_zone;
-
-                dummy_argb_linear_zone.name                 = "Resizable zone";
-                dummy_argb_linear_zone.type                 = ZONE_TYPE_LINEAR;
-                dummy_argb_linear_zone.leds_min             = 1;
-                dummy_argb_linear_zone.leds_max             = 100;
-                dummy_argb_linear_zone.leds_count           = 0;
-                dummy_argb_linear_zone.matrix_map           = NULL;
-
-                dummy_argb->zones.push_back(dummy_argb_linear_zone);
-
-                dummy_argb->SetupColors();
-                dummy_argb->ResizeZone(0, 60);
-
-                /*---------------------------------------------------------*\
-                | Push the dummy ARGB onto the controller list              |
-                \*---------------------------------------------------------*/
-                rgb_controllers.push_back(dummy_argb);
-            }
-        }
-    }
-
-}   /* DetectDebugControllers() */
-
-REGISTER_DETECTOR("Debug Controllers", DetectDebugControllers);
@@ -1,49 +0,0 @@
-#include "RGBController_Debug.h"
-
-#include <algorithm>
-#include <cstring>
-
-RGBController_Debug::RGBController_Debug()
-{
-
-}
-
-void RGBController_Debug::ResizeZone(int index, int new_size)
-{
-    //Make sure that it isn't out of bounds (negative numbers)
-    if(new_size < int(zones[index].leds_min))
-    {
-         new_size = zones[index].leds_min;
-    }
-
-    // Same thing as the above line except for over 100
-    if(new_size > int(zones[index].leds_max))
-    {
-        new_size = zones[index].leds_max;
-    }
-
-    // Store the previous amount of LEDs
-    int old_size = zones[index].leds_count;
-
-    // Set the LED count in the zone to the new ammount
-    zones[index].leds_count = new_size;
-
-    // Set the new ammount of LEDs for to the new size
-    size_t old_leds_size = leds.size();
-
-    // Add the new ammount of LEDs to the old ammount
-    size_t new_leds_size = leds.size() - old_size + new_size;
-    
-    leds.resize(std::max(old_leds_size, new_leds_size));
-
-    memmove(&leds[zones[index].start_idx] + old_leds_size, &leds[zones[index].start_idx] + new_leds_size, (old_leds_size - zones[index].start_idx - old_size) * sizeof(led));
-
-    leds.resize(new_leds_size);
-
-    for(int i = 0; i < new_size; ++i)
-    {
-        leds[zones[index].start_idx + i].name = "Linear LED " + std::to_string(i);
-    }
-    
-    SetupColors();
-}
@@ -1,15 +0,0 @@
-#ifndef RGBCONTROLLER_DEBUG_H
-#define RGBCONTROLLER_DEBUG_H
-
-#include "RGBController_Dummy.h"
-
-// A variation of Dummy controller that allows the zones to be resized
-
-class RGBController_Debug : public RGBController_Dummy
-{
-public:
-    RGBController_Debug();
-    void ResizeZone(int zone, int newSize) override;
-};
-
-#endif // RGBCONTROLLER_DEBUG_H
@@ -1,204 +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, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-
-    SendInitialize();
-}
-
-DuckyKeyboardController::~DuckyKeyboardController()
-{
-    
-}
-
-std::string DuckyKeyboardController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string DuckyKeyboardController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-void DuckyKeyboardController::SendColors
-    (
-    unsigned char*  color_data,
-    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,45 +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, const char* path);
-    ~DuckyKeyboardController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void SendColors
-            (
-            unsigned char*  color_data,
-            unsigned int    color_data_size
-            );
-
-private:
-    hid_device*             dev;
-    std::string             location;
-
-    void SendInitialize();
-    void SendInitializeColorPacket();
-    unsigned int SendColorDataPacket
-        (
-        unsigned char   packet_id,
-        unsigned char*  color_data,
-        unsigned int    color_size
-        );
-    void SendTerminateColorPacket();
-};
@@ -1,39 +0,0 @@
-#include "Detector.h"
-#include "DuckyKeyboardController.h"
-#include "RGBController.h"
-#include "RGBController_DuckyKeyboard.h"
-#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
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectDuckyKeyboardControllers                                                         *
-*                                                                                          *
-*       Tests the USB address to see if a Ducky RGB Keyboard controller exists there.      *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectDuckyKeyboardControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
-    {
-        DuckyKeyboardController* controller = new DuckyKeyboardController(dev, info->path);
-        RGBController_DuckyKeyboard* rgb_controller = new RGBController_DuckyKeyboard(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}   /* DetectDuckyKeyboardControllers() */
-
-REGISTER_HID_DETECTOR_I("Ducky Shine 7/Ducky One 2 RGB", DetectDuckyKeyboardControllers, DUCKY_VID, DUCKY_SHINE_7_ONE_2_RGB_PID, 1);
-REGISTER_HID_DETECTOR_I("Ducky One 2 RGB TKL",           DetectDuckyKeyboardControllers, DUCKY_VID, DUCKY_ONE_2_RGB_TKL_PID,     1);
@@ -1,281 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_DuckyKeyboard.cpp          |
-|                                           |
-|  Generic RGB Interface for Ducky RGB      |
-|  keyboard devices                         |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 7/4/2020    |
-\*-----------------------------------------*/
-
-#include "RGBController_DuckyKeyboard.h"
-
-//0xFFFFFFFF indicates an unused entry in matrix
-#define NA  0xFFFFFFFF
-
-static unsigned int matrix_map[6][23] =
-    { {   0,  NA,  12,  18,  24,  30,  NA,  42,  48,  54,  60,  NA,  66,  72,  78,  84,  90,  96, 102, 108, 114, 120, 126 },
-      {   1,   7,  13,  19,  25,  31,  37,  43,  49,  55,  61,  NA,  67,  73,  85,  NA,  91,  97, 103, 109, 115, 121, 127 },
-      {   2,  NA,   8,  14,  20,  26,  NA,  32,  38,  44,  50,  56,  62,  68,  74,  86,  92,  98, 104, 110, 116, 122, 128 },
-      {   3,  NA,   9,  15,  21,  27,  NA,  33,  39,  45,  51,  57,  63,  69,  87,  NA,  NA,  NA,  NA, 111, 117, 123,  NA },
-      {   4,  NA,  16,  22,  28,  34,  NA,  40,  NA,  46,  52,  58,  64,  70,  82,  NA,  NA, 100,  NA, 112, 118, 124, 131 },
-      {   5,  11,  17,  NA,  NA,  NA,  NA,  41,  NA,  NA,  NA,  NA,  65,  77,  83,  89,  95, 101, 107, 113,  NA, 125,  NA } };
-
-static const char* zone_names[] =
-{
-    "Keyboard"
-};
-
-static zone_type zone_types[] =
-{
-    ZONE_TYPE_MATRIX,
-};
-
-static const unsigned int zone_sizes[] =
-{
-    132
-};
-
-static const char *led_names[] =
-{
-    "Key: Escape",
-    "Key: `",
-    "Key: Tab",
-    "Key: Caps Lock",
-    "Key: Left Shift",
-    "Key: Left Control",
-    "Unused",
-    "Key: 1",
-    "Key: Q",
-    "Key: A",
-    "Unused",
-    "Key: Left Windows",
-    "Key: F1",
-    "Key: 2",
-    "Key: W",
-    "Key: S",
-    "Key: Z",
-    "Key: Left Alt",
-    "Key: F2",
-    "Key: 3",
-    "Key: E",
-    "Key: D",
-    "Key: X",
-    "Unused",
-    "Key: F3",
-    "Key: 4",
-    "Key: R",
-    "Key: F",
-    "Key: C",
-    "Unused",
-    "Key: F4",
-    "Key: 5",
-    "Key: T",
-    "Key: G",
-    "Key: V",
-    "Unused",
-    "Unused",
-    "Key: 6",
-    "Key: Y",
-    "Key: H",
-    "Key: B",
-    "Key: Space",
-    "Key: F5",
-    "Key: 7",
-    "Key: U",
-    "Key: J",
-    "Key: N",
-    "Unused",
-    "Key: F6",
-    "Key: 8",
-    "Key: I",
-    "Key: K",
-    "Key: M",
-    "Unused",
-    "Key: F7",
-    "Key: 9",
-    "Key: O",
-    "Key: L",
-    "Key: ,",
-    "Unused",
-    "Key: F8",
-    "Key: 0",
-    "Key: P",
-    "Key: ;",
-    "Key: .",
-    "Key: Right Alt",
-    "Key: F9",
-    "Key: -",
-    "Key: [",
-    "Key: '",
-    "Key: /",
-    "Unused",
-    "Key: F10",
-    "Key: =",
-    "Key: ]",
-    "Unused",
-    "Unused",
-    "Key: Right Windows",
-    "Key: F11",
-    "Unused",
-    "Unused",
-    "Unused",
-    "Key: Right Shift",
-    "Key: Right Fn",
-    "Key: F12",
-    "Key: Backspace",
-    "Key: \\ (ANSI)",
-    "Key: Enter",
-    "Unused",
-    "Key: Right Control",
-    "Key: Print Screen",
-    "Key: Insert",
-    "Key: Delete",
-    "Unused",
-    "Unused",
-    "Key: Left Arrow",
-    "Key: Scroll Lock",
-    "Key: Home",
-    "Key: End",
-    "Unused",
-    "Key: Up Arrow",
-    "Key: Down Arrow",
-    "Key: Pause/Break",
-    "Key: Page Up",
-    "Key: Page Down",
-    "Unused",
-    "Unused",
-    "Key: Right Arrow",
-    "Key: Calculator",
-    "Key: Num Lock",
-    "Key: Number Pad 7",
-    "Key: Number Pad 4",
-    "Key: Number Pad 1",
-    "Key: Number Pad 0",
-    "Key: Media Mute",
-    "Key: Number Pad /",
-    "Key: Number Pad 8",
-    "Key: Number Pad 5",
-    "Key: Number Pad 2",
-    "Unused",
-    "Key: Media Volume Down",
-    "Key: Number Pad *",
-    "Key: Number Pad 9",
-    "Key: Number Pad 6",
-    "Key: Number Pad 3",
-    "Key: Number Pad .",
-    "Key: Media Volume Up",
-    "Key: Number Pad -",
-    "Key: Number Pad +",
-    "Unused",
-    "Unused",
-    "Key: Number Pad Enter",
-};
-
-RGBController_DuckyKeyboard::RGBController_DuckyKeyboard(DuckyKeyboardController* ducky_ptr)
-{
-    ducky = ducky_ptr;
-
-    name        = "Ducky Keyboard Device";
-    vendor      = "Ducky";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "Ducky Keyboard Device";
-    location    = ducky->GetDeviceLocation();
-    serial      = ducky->GetSerialString();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0xFFFF;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-}
-
-RGBController_DuckyKeyboard::~RGBController_DuckyKeyboard()
-{
-    /*---------------------------------------------------------*\
-    | Delete the matrix map                                     |
-    \*---------------------------------------------------------*/
-    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
-    {
-        if(zones[zone_index].matrix_map != NULL)
-        {
-            delete zones[zone_index].matrix_map;
-        }
-    }
-}
-
-void RGBController_DuckyKeyboard::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    unsigned int total_led_count = 0;
-    for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
-    {
-        zone new_zone;
-        new_zone.name               = zone_names[zone_idx];
-        new_zone.type               = zone_types[zone_idx];
-        new_zone.leds_min           = zone_sizes[zone_idx];
-        new_zone.leds_max           = zone_sizes[zone_idx];
-        new_zone.leds_count         = zone_sizes[zone_idx];
-        new_zone.matrix_map         = new matrix_map_type;
-        new_zone.matrix_map->height = 6;
-        new_zone.matrix_map->width  = 23;
-        new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
-        zones.push_back(new_zone);
-
-        total_led_count += zone_sizes[zone_idx];
-    }
-
-    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
-    {
-        led new_led;
-        new_led.name = led_names[led_idx];
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_DuckyKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-    
-void RGBController_DuckyKeyboard::DeviceUpdateLEDs()
-{
-    unsigned char colordata[155*3];
-    
-    for(std::size_t color_idx = 0; color_idx < colors.size(); color_idx++)
-    {
-        colordata[(color_idx*3)+0] = RGBGetRValue(colors[color_idx]);
-        colordata[(color_idx*3)+1] = RGBGetGValue(colors[color_idx]);
-        colordata[(color_idx*3)+2] = RGBGetBValue(colors[color_idx]);
-    }
-
-    ducky->SendColors(colordata, sizeof(colordata));
-}
-
-void RGBController_DuckyKeyboard::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_DuckyKeyboard::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_DuckyKeyboard::SetCustomMode()
-{
-
-}
-
-void RGBController_DuckyKeyboard::DeviceUpdateMode()
-{
-
-}
@@ -1,33 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_DuckyKeyboard.h            |
-|                                           |
-|  Generic RGB Interface for Ducky RGB      |
-|  keyboard devices                         |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 7/4/2020    |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "DuckyKeyboardController.h"
-
-class RGBController_DuckyKeyboard : public RGBController
-{
-public:
-    RGBController_DuckyKeyboard(DuckyKeyboardController* ducky_ptr);
-    ~RGBController_DuckyKeyboard();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-    
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    DuckyKeyboardController*    ducky;
-};
@@ -1,274 +0,0 @@
-#include "Detector.h"
-#include "RGBController.h"
-#include "RGBController_E131.h"
-#include "SettingsManager.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <fcntl.h>
-#include <string.h>
-#include <fstream>
-#include <iostream>
-#include <string>
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectE131Controllers                                                                  *
-*                                                                                          *
-*       Detect devices supported by the E131 driver                                        *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectE131Controllers(std::vector<RGBController*> &rgb_controllers)
-{
-    json                e131_settings;
-
-    std::vector<std::vector<E131Device>> device_lists; 
-	E131Device dev;
-
-    /*-------------------------------------------------*\
-    | Get E1.31 settings from settings manager          |
-    \*-------------------------------------------------*/
-    e131_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("E131Devices");
-
-    /*-------------------------------------------------*\
-    | If the E1.31 settings contains devices, process   |
-    \*-------------------------------------------------*/
-    if(e131_settings.contains("devices"))
-    {
-        for(unsigned int device_idx = 0; device_idx < e131_settings["devices"].size(); device_idx++)
-        {
-            /*-------------------------------------------------*\
-            | Clear E1.31 device data                           |
-            \*-------------------------------------------------*/
-            dev.name           = "";
-            dev.ip             = "";
-            dev.type           = ZONE_TYPE_SINGLE;
-            dev.num_leds       = 0;
-            dev.rgb_order      = E131_RGB_ORDER_RBG;
-            dev.matrix_order   = E131_MATRIX_ORDER_HORIZONTAL_TOP_LEFT;
-            dev.matrix_width   = 0;
-            dev.matrix_height  = 0;
-            dev.start_channel  = 1;
-            dev.start_universe = 1;
-
-            if(e131_settings["devices"][device_idx].contains("name"))
-            {
-                dev.name = e131_settings["devices"][device_idx]["name"];
-            }
-
-            if(e131_settings["devices"][device_idx].contains("ip"))
-            {
-                dev.ip = e131_settings["devices"][device_idx]["ip"];
-            }
-
-            if(e131_settings["devices"][device_idx].contains("num_leds"))
-            {
-                dev.num_leds = e131_settings["devices"][device_idx]["num_leds"];
-            }
-
-            if(e131_settings["devices"][device_idx].contains("start_universe"))
-            {
-                dev.start_universe = e131_settings["devices"][device_idx]["start_universe"];
-            }
-
-            if(e131_settings["devices"][device_idx].contains("start_channel"))
-            {
-                dev.start_channel = e131_settings["devices"][device_idx]["start_channel"];
-            }
-
-            if(e131_settings["devices"][device_idx].contains("matrix_order"))
-            {
-                std::string matrix_order_val = e131_settings["devices"][device_idx]["matrix_order"];
-
-                if(matrix_order_val == "HORIZONTAL_TOP_LEFT")
-                {
-                    dev.matrix_order = E131_MATRIX_ORDER_HORIZONTAL_TOP_LEFT;
-                }
-                else if(matrix_order_val == "HORIZONTAL_TOP_RIGHT")
-                {
-                    dev.matrix_order = E131_MATRIX_ORDER_HORIZONTAL_TOP_RIGHT;
-                }
-                else if(matrix_order_val == "HORIZONTAL_BOTTOM_LEFT")
-                {
-                    dev.matrix_order = E131_MATRIX_ORDER_HORIZONTAL_BOTTOM_LEFT;
-                }
-                else if(matrix_order_val == "HORIZONTAL_BOTTOM_RIGHT")
-                {
-                    dev.matrix_order = E131_MATRIX_ORDER_HORIZONTAL_BOTTOM_RIGHT;
-                }
-                else if(matrix_order_val == "VERTICAL_TOP_LEFT")
-                {
-                    dev.matrix_order = E131_MATRIX_ORDER_VERTICAL_TOP_LEFT;
-                }
-                else if(matrix_order_val == "VERTICAL_TOP_RIGHT")
-                {
-                    dev.matrix_order = E131_MATRIX_ORDER_VERTICAL_TOP_RIGHT;
-                }
-                else if(matrix_order_val == "VERTICAL_BOTTOM_LEFT")
-                {
-                    dev.matrix_order = E131_MATRIX_ORDER_VERTICAL_BOTTOM_LEFT;
-                }
-                else if(matrix_order_val == "VERTICAL_BOTTOM_RIGHT")
-                {
-                    dev.matrix_order = E131_MATRIX_ORDER_VERTICAL_BOTTOM_RIGHT;
-                }
-                else
-                {
-                    dev.matrix_order = e131_settings["devices"][device_idx]["matrix_order"];
-                }
-            }
-
-            if(e131_settings["devices"][device_idx].contains("rgb_order"))
-            {
-                std::string rgb_order_val = e131_settings["devices"][device_idx]["rgb_order"];
-
-                if(rgb_order_val == "RGB")
-                {
-                    dev.rgb_order = E131_RGB_ORDER_RGB;
-                }
-                else if(rgb_order_val == "RBG")
-                {
-                    dev.rgb_order = E131_RGB_ORDER_RBG;
-                }
-                else if(rgb_order_val == "GRB")
-                {
-                    dev.rgb_order = E131_RGB_ORDER_GRB;
-                }
-                else if(rgb_order_val == "GBR")
-                {
-                    dev.rgb_order = E131_RGB_ORDER_GBR;
-                }
-                else if(rgb_order_val == "BRG")
-                {
-                    dev.rgb_order = E131_RGB_ORDER_BGR;
-                }
-                else if(rgb_order_val == "BGR")
-                {
-                    dev.rgb_order = E131_RGB_ORDER_BGR;
-                }
-                else
-                {
-                    dev.rgb_order = e131_settings["devices"][device_idx]["rgb_order"];
-                }
-            }
-
-            if(e131_settings["devices"][device_idx].contains("matrix_width"))
-            {
-                dev.matrix_width = e131_settings["devices"][device_idx]["matrix_width"];
-            }
-
-            if(e131_settings["devices"][device_idx].contains("matrix_height"))
-            {
-                dev.matrix_height = e131_settings["devices"][device_idx]["matrix_height"];
-            }
-            
-            if(e131_settings["devices"][device_idx].contains("type"))
-            {
-                std::string type_val = e131_settings["devices"][device_idx]["type"];
-
-                if(type_val == "SINGLE")
-                {
-                    dev.type = ZONE_TYPE_SINGLE;
-                }
-                else if(type_val == "LINEAR")
-                {
-                    dev.type = ZONE_TYPE_LINEAR;
-                }
-                else if(type_val == "MATRIX")
-                {
-                    dev.type = ZONE_TYPE_MATRIX;
-                }
-                else
-                {
-                    dev.type = e131_settings["devices"][device_idx]["type"];
-                }
-            }
-
-            /*---------------------------------------------------------*\
-            | Determine whether to create a new list or add this device |
-            | to an existing list.  A device is added to an existing    |
-            | list if both devices share one or more universes for the  |
-            | same output destination                                   |
-            \*---------------------------------------------------------*/
-            bool device_added_to_existing_list = false;
-
-            /*---------------------------------------------------------*\
-            | Only track grouping for multicast controllers.  Unicast   |
-            | controllers are currently not grouped.                    |
-            \*---------------------------------------------------------*/
-            if(dev.ip == "")
-            {
-                for(unsigned int list_idx = 0; list_idx < device_lists.size(); list_idx++)
-                {
-                    for(unsigned int device_idx = 0; device_idx < device_lists[list_idx].size(); device_idx++)
-                    {
-                        /*---------------------------------------------------------*\
-                        | Determine if there is any overlap between this device and |
-                        | any existing device list                                  |
-                        | Offset the end by two - one because the range is 1-512    |
-                        | rather than 0-511, and one because the start channel is   |
-                        | included in the first set of 3 channels.                  |
-                        \*---------------------------------------------------------*/
-                        unsigned int dev_start  = dev.start_universe;
-                        unsigned int list_start = device_lists[list_idx][device_idx].start_universe;
-                        unsigned int dev_end    = dev.start_universe + ((dev.start_channel + (3 * dev.num_leds) - 2) / 512);
-                        unsigned int list_end   = device_lists[list_idx][device_idx].start_universe + ((device_lists[list_idx][device_idx].start_channel + (3 * device_lists[list_idx][device_idx].num_leds) - 2) / 512);
-
-                        bool overlap = !(dev_end < list_start || list_end < dev_start);
-
-                        /*---------------------------------------------------------*\
-                        | Check if any universes used by this new device exist in   |
-                        | the existing device.  If so, add the new device to the    |
-                        | existing list.                                            |
-                        \*---------------------------------------------------------*/
-                        if(overlap)
-                        {
-                            device_lists[list_idx].push_back(dev);
-                            device_added_to_existing_list = true;
-                            break;
-                        }
-                    }
-
-                    if(device_added_to_existing_list)
-                    {
-                        break;
-                    }
-                }
-
-                /*---------------------------------------------------------*\
-                | If the device did not overlap with existing devices,      |
-                | create a new list for it                                  |
-                \*---------------------------------------------------------*/
-                if(!device_added_to_existing_list)
-                {
-                    std::vector<E131Device> new_list;
-
-                    new_list.push_back(dev);
-
-                    device_lists.push_back(new_list);
-                }
-            }
-            else
-            {
-                std::vector<E131Device> tmp_device_list;
-                tmp_device_list.push_back(dev);
-
-                RGBController_E131* rgb_controller;
-                rgb_controller = new RGBController_E131(tmp_device_list);
-                rgb_controllers.push_back(rgb_controller);
-            }
-        }
-
-        for(unsigned int list_idx = 0; list_idx < device_lists.size(); list_idx++)
-        {
-            RGBController_E131* rgb_controller;
-            rgb_controller = new RGBController_E131(device_lists[list_idx]);
-            rgb_controllers.push_back(rgb_controller);
-        }
-    }
-
-}   /* DetectE131Controllers() */
-
-REGISTER_DETECTOR("E1.31", DetectE131Controllers);
@@ -1,451 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_LEDStrip.cpp               |
-|                                           |
-|  Generic RGB Interface for OpenAuraSDK    |
-|  E1.31 Streaming ACN interface            |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 10/18/2019  |
-\*-----------------------------------------*/
-
-#include "RGBController_E131.h"
-#include <e131.h>
-#include <math.h>
-
-using namespace std::chrono_literals;
-
-RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
-{
-    bool multicast = false;
-
-    devices = device_list;
-
-    name        = "E1.31 Device Group";
-    type        = DEVICE_TYPE_LEDSTRIP;
-    description = "E1.31 Streaming ACN Device";
-    location    = "E1.31: ";
-
-    /*-----------------------------------------*\
-    | If this controller only represents a      |
-    | single device, use the device name for the|
-    | controller name                           |
-    \*-----------------------------------------*/
-    if(devices.size() == 1)
-    {
-        name    = devices[0].name;
-    }
-
-    /*-----------------------------------------*\
-    | Append the destination address to the     |
-    | location field                            |
-    \*-----------------------------------------*/
-    if((devices.size() == 1) && (devices[0].ip != ""))
-    {
-        location += "Unicast " + devices[0].ip + ", ";
-    }
-    else
-    {
-        location   += "Multicast, ";
-        multicast = true;
-    }
-
-    /*-----------------------------------------*\
-    | Calculate universe list                   |
-    | Use this to fill in the location field    |
-    \*-----------------------------------------*/
-    std::vector<unsigned int> universe_list;
-
-    for(unsigned int device_idx = 0; device_idx < devices.size(); device_idx++)
-    {
-        unsigned int total_universes = ceil( ( ( devices[device_idx].num_leds * 3 ) + devices[device_idx].start_channel ) / 512.0f );
-
-        for(unsigned int univ_idx = 0; univ_idx < total_universes; univ_idx++)
-        {
-            bool found = false;
-
-            for(unsigned int univ_list_idx = 0; univ_list_idx < universe_list.size(); univ_list_idx++)
-            {
-                if((devices[device_idx].start_universe + univ_idx) == universe_list[univ_list_idx])
-                {
-                    found = true;
-                    break;
-                }
-            }
-
-            if(!found)
-            {
-                universe_list.push_back(devices[device_idx].start_universe + univ_idx);
-            }
-        }
-    }
-
-    /*-----------------------------------------*\
-    | Append "Universe" and make plural if there|
-    | are multiple universes in use             |
-    \*-----------------------------------------*/
-    location   += "Universe";
-
-    if(universe_list.size() > 1)
-    {
-        location += "s ";
-    }
-    else
-    {
-        location += " ";
-    }
-
-    /*-----------------------------------------*\
-    | Append comma separated list of universes  |
-    \*-----------------------------------------*/
-    for(unsigned int univ_list_idx = 0; univ_list_idx < universe_list.size(); univ_list_idx++)
-    {
-        location += std::to_string(universe_list[univ_list_idx]);
-        
-        if(univ_list_idx < (universe_list.size() - 1))
-        {
-            location += ", ";
-        }
-    }
-
-    /*-----------------------------------------*\
-    | Set up modes                              |
-    \*-----------------------------------------*/
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    /*-----------------------------------------*\
-    | Create E1.31 socket                       |
-    \*-----------------------------------------*/
-    sockfd = e131_socket();
-    
-    keepalive_delay = 0ms;
-
-    SetupZones();
-
-    for (std::size_t device_idx = 0; device_idx < devices.size(); device_idx++)
-    {
-        /*-----------------------------------------*\
-        | Update keepalive delay                    |
-        \*-----------------------------------------*/
-        if(devices[device_idx].keepalive_time > 0)
-        {
-            if(keepalive_delay.count() == 0 || keepalive_delay.count() > devices[device_idx].keepalive_time)
-            {
-                keepalive_delay = std::chrono::milliseconds(devices[device_idx].keepalive_time);
-            }
-        }
-
-        /*-----------------------------------------*\
-        | Add Universes                             |
-        \*-----------------------------------------*/
-        unsigned int total_universes = ceil( ( ( devices[device_idx].num_leds * 3 ) + devices[device_idx].start_channel ) / 512.0f );
-
-        for (unsigned int univ_idx = 0; univ_idx < total_universes; univ_idx++)
-        {
-            unsigned int universe = devices[device_idx].start_universe + univ_idx;
-            bool universe_exists = false;
-
-            for (std::size_t pkt_idx = 0; pkt_idx < packets.size(); pkt_idx++)
-            {
-                if(universes[pkt_idx] == universe)
-                {
-                    universe_exists = true;
-                }
-            }
-
-            if(!universe_exists)
-            {
-                e131_packet_t   packet;
-                e131_addr_t     dest_addr;
-
-                e131_pkt_init(&packet, universe, 512);
-
-                if(multicast)
-                {
-                    e131_multicast_dest(&dest_addr, universe, E131_DEFAULT_PORT);
-                }
-                else
-                {
-                    e131_unicast_dest(&dest_addr, devices[0].ip.c_str(), E131_DEFAULT_PORT);
-                }
-
-                packets.push_back(packet);
-                universes.push_back(universe);
-                dest_addrs.push_back(dest_addr);
-            }
-        }
-
-        /*-----------------------------------------*\
-        | Generate matrix maps                      |
-        \*-----------------------------------------*/
-        if(devices[device_idx].type == ZONE_TYPE_MATRIX)
-        {
-            unsigned int led_idx = 0;
-            matrix_map_type * new_map = new matrix_map_type;
-
-            new_map->width = devices[device_idx].matrix_width;
-            new_map->height = devices[device_idx].matrix_height;
-            new_map->map = new unsigned int[devices[device_idx].matrix_width * devices[device_idx].matrix_height];
-
-            switch(devices[device_idx].matrix_order)
-            {
-                case E131_MATRIX_ORDER_HORIZONTAL_TOP_LEFT:
-                    for(unsigned int y = 0; y < new_map->height; y++)
-                    {
-                        for(unsigned int x = 0; x < new_map->width; x++)
-                        {
-                            new_map->map[(y * new_map->width) + x] = led_idx;
-                            led_idx++;
-                        }
-                    }
-                    break;
-                case E131_MATRIX_ORDER_HORIZONTAL_TOP_RIGHT:
-                    for(unsigned int y = 0; y < new_map->height; y++)
-                    {
-                        for(int x = new_map->width - 1; x >= 0; x--)
-                        {
-                            new_map->map[(y * new_map->width) + x] = led_idx;
-                            led_idx++;
-                        }
-                    }
-                    break;
-                case E131_MATRIX_ORDER_HORIZONTAL_BOTTOM_LEFT:
-                    for(int y = new_map->height; y >= 0; y--)
-                    {
-                        for(unsigned int x = 0; x < new_map->width; x++)
-                        {
-                            new_map->map[(y * new_map->width) + x] = led_idx;
-                            led_idx++;
-                        }
-                    }
-                    break;
-                case E131_MATRIX_ORDER_HORIZONTAL_BOTTOM_RIGHT:
-                    for(int y = new_map->height; y >= 0; y--)
-                    {
-                        for(int x = new_map->width - 1; x >= 0; x--)
-                        {
-                            new_map->map[(y * new_map->width) + x] = led_idx;
-                            led_idx++;
-                        }
-                    }
-                    break;
-                case E131_MATRIX_ORDER_VERTICAL_TOP_LEFT:
-                    for(unsigned int x = 0; x < new_map->width; x++)
-                    {
-                        for(unsigned int y = 0; y < new_map->height; y++)
-                        {
-                            new_map->map[(y * new_map->width) + x] = led_idx;
-                            led_idx++;
-                        }
-                    }
-                    break;
-                case E131_MATRIX_ORDER_VERTICAL_TOP_RIGHT:
-                    for(int x = new_map->width - 1; x >= 0; x--)
-                    {
-                        for(unsigned int y = 0; y < new_map->height; y++)
-                        {
-                            new_map->map[(y * new_map->width) + x] = led_idx;
-                            led_idx++;
-                        }
-                    }
-                    break;
-                case E131_MATRIX_ORDER_VERTICAL_BOTTOM_LEFT:
-                    for(unsigned int x = 0; x < new_map->width; x++)
-                    {
-                        for(int y = new_map->height - 1; y >= 0; y--)
-                        {
-                            new_map->map[(y * new_map->width) + x] = led_idx;
-                            led_idx++;
-                        }
-                    }
-                    break;
-                case E131_MATRIX_ORDER_VERTICAL_BOTTOM_RIGHT:
-                    for(int x = new_map->width - 1; x >= 0; x--)
-                    {
-                        for(int y = new_map->height - 1; y >= 0; y--)
-                        {
-                            new_map->map[(y * new_map->width) + x] = led_idx;
-                            led_idx++;
-                        }
-                    }
-                    break;
-            }
-            zones[device_idx].matrix_map = new_map;
-        }
-	}
-
-    if(keepalive_delay.count() > 0)
-    {
-        keepalive_thread_run = 1;
-        keepalive_thread = new std::thread(&RGBController_E131::KeepaliveThreadFunction, this);
-    }
-    else
-    {
-        keepalive_thread_run = 0;
-        keepalive_thread = nullptr;
-    }
-}
-
-RGBController_E131::~RGBController_E131()
-{
-    keepalive_thread_run = 0;
-    keepalive_thread->join();
-    delete keepalive_thread;
-    /*---------------------------------------------------------*\
-    | Delete the matrix map                                     |
-    \*---------------------------------------------------------*/
-    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
-    {
-        if(zones[zone_index].matrix_map != NULL)
-        {
-            if(zones[zone_index].matrix_map->map != NULL)
-            {
-                delete zones[zone_index].matrix_map->map;
-            }
-
-            delete zones[zone_index].matrix_map;
-        }
-    }
-}
-
-void RGBController_E131::SetupZones()
-{
-    /*-----------------------------------------*\
-    | Add Zones                                 |
-    \*-----------------------------------------*/
-    for(std::size_t zone_idx = 0; zone_idx < devices.size(); zone_idx++)
-    {
-        zone led_zone;
-        led_zone.name           = devices[zone_idx].name;
-        led_zone.type           = devices[zone_idx].type;
-        led_zone.leds_min       = devices[zone_idx].num_leds;
-        led_zone.leds_max       = devices[zone_idx].num_leds;
-        led_zone.leds_count     = devices[zone_idx].num_leds;
-        led_zone.matrix_map     = NULL;
-
-        zones.push_back(led_zone);
-    }
-
-    /*-----------------------------------------*\
-    | Add LEDs                                  |
-    \*-----------------------------------------*/
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
-        {
-            led new_led;
-
-            new_led.name = zones[zone_idx].name + " LED ";
-            new_led.name.append(std::to_string(led_idx));
-
-            leds.push_back(new_led);
-        }
-    }
-
-    SetupColors();
-}
-
-void RGBController_E131::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_E131::DeviceUpdateLEDs()
-{
-    int color_idx = 0;
-
-    last_update_time = std::chrono::steady_clock::now();
-    
-    for(std::size_t device_idx = 0; device_idx < devices.size(); device_idx++)
-    {
-        unsigned int total_universes = ceil( ( ( devices[device_idx].num_leds * 3 ) + devices[device_idx].start_channel ) / 512.0f );
-        unsigned int channel_idx = devices[device_idx].start_channel;
-        unsigned int led_idx = 0;
-        unsigned int rgb_idx = 0;
-        bool         done = false;
-
-        for (unsigned int univ_idx = 0; univ_idx < total_universes; univ_idx++)
-        {
-            unsigned int universe = devices[device_idx].start_universe + univ_idx;
-
-            for(std::size_t packet_idx = 0; packet_idx < packets.size(); packet_idx++)
-            {
-                if(!done && (universes[packet_idx] == universe))
-                {
-                    while(!done && (channel_idx <= 512))
-                    {
-                        switch(rgb_idx)
-                        {
-                            case 0:
-                                packets[packet_idx].dmp.prop_val[channel_idx] = RGBGetRValue( colors[color_idx] );
-                                rgb_idx = 1;
-                                break;
-                            case 1:
-                                packets[packet_idx].dmp.prop_val[channel_idx] = RGBGetGValue( colors[color_idx] );
-                                rgb_idx = 2;
-                                break;
-                            case 2:
-                                packets[packet_idx].dmp.prop_val[channel_idx] = RGBGetBValue( colors[color_idx] );
-                                rgb_idx = 0;
-                                led_idx++;
-                                color_idx++;
-                                break;
-                        }
-
-                        if(led_idx >= devices[device_idx].num_leds)
-                        {
-                            done = true;
-                        }
-
-                        channel_idx++;
-                    }
-                }
-            }
-
-            channel_idx = 1;
-        }
-    }
-
-    for(std::size_t packet_idx = 0; packet_idx < packets.size(); packet_idx++)
-    {
-        e131_send(sockfd, &packets[packet_idx], &dest_addrs[packet_idx]);
-        packets[packet_idx].frame.seq_number++;
-    }
-}
-
-void RGBController_E131::UpdateZoneLEDs(int /*zone*/)
-{
-	DeviceUpdateLEDs();
-}
-
-void RGBController_E131::UpdateSingleLED(int /*led*/)
-{
-	DeviceUpdateLEDs();
-}
-
-void RGBController_E131::SetCustomMode()
-{
-
-}
-
-void RGBController_E131::DeviceUpdateMode()
-{
-
-}
-
-void RGBController_E131::KeepaliveThreadFunction()
-{
-    while(keepalive_thread_run.load())
-    {
-        if((std::chrono::steady_clock::now() - last_update_time) > ( keepalive_delay * 0.95f ) )
-        {
-            UpdateLEDs();
-        }
-        std::this_thread::sleep_for(keepalive_delay / 2);
-    }
-}
@@ -1,86 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_E131.h                     |
-|                                           |
-|  Generic RGB Interface for OpenAuraSDK    |
-|  E1.31 Streaming ACN interface            |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 10/18/2019  |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include <e131.h>
-#include <chrono>
-#include <thread>
-
-typedef unsigned int e131_rgb_order;
-
-enum
-{
-    E131_RGB_ORDER_RGB,
-    E131_RGB_ORDER_RBG,
-    E131_RGB_ORDER_GRB,
-    E131_RGB_ORDER_GBR,
-    E131_RGB_ORDER_BRG,
-    E131_RGB_ORDER_BGR
-};
-
-enum
-{
-    E131_MATRIX_ORDER_HORIZONTAL_TOP_LEFT,
-    E131_MATRIX_ORDER_HORIZONTAL_TOP_RIGHT,
-    E131_MATRIX_ORDER_HORIZONTAL_BOTTOM_LEFT,
-    E131_MATRIX_ORDER_HORIZONTAL_BOTTOM_RIGHT,
-    E131_MATRIX_ORDER_VERTICAL_TOP_LEFT,
-    E131_MATRIX_ORDER_VERTICAL_TOP_RIGHT,
-    E131_MATRIX_ORDER_VERTICAL_BOTTOM_LEFT,
-    E131_MATRIX_ORDER_VERTICAL_BOTTOM_RIGHT
-};
-
-typedef unsigned int e131_matrix_order;
-
-struct E131Device
-{
-    std::string name;
-    std::string ip;
-    unsigned int num_leds;
-    unsigned int start_universe;
-    unsigned int start_channel;
-    unsigned int keepalive_time;
-    e131_rgb_order rgb_order;
-    zone_type type;
-    unsigned int matrix_width;
-    unsigned int matrix_height;
-    e131_matrix_order matrix_order;
-};
-
-class RGBController_E131 : public RGBController
-{
-public:
-    RGBController_E131(std::vector<E131Device> device_list);
-    ~RGBController_E131();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-    void        KeepaliveThreadFunction();
-
-private:
-	std::vector<E131Device> 	devices;
-    std::vector<e131_packet_t> 	packets;
-	std::vector<e131_addr_t> 	dest_addrs;
-	std::vector<unsigned int> 	universes;
-	int 						sockfd;
-    std::thread *               keepalive_thread;
-    std::atomic<bool>           keepalive_thread_run;
-    std::chrono::milliseconds                           keepalive_delay;
-    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
-};
@@ -1,130 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  EKController.cpp                                                   |
-|                                                                     |
-|  Driver for EK Loop Connect                                         |
-|                                                                     |
-|  Chris M (Dr_No)          16th Jul 2020                             |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#include "EKController.h"
-
-static unsigned char ek_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 ek_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, char *_path)
-{
-    const int szTemp = 256;
-    wchar_t tmpName[szTemp];
-
-    dev = dev_handle;
-
-    hid_get_manufacturer_string(dev, tmpName, szTemp);
-    std::wstring wName = std::wstring(tmpName);
-    device_name = std::string(wName.begin(), wName.end());
-
-    hid_get_product_string(dev, tmpName, szTemp);
-    wName = std::wstring(tmpName);
-    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
-
-    hid_get_serial_number_string(dev, tmpName, szTemp);
-    wName = std::wstring(tmpName);
-    serial = std::string(wName.begin(), wName.end());
-
-    location = _path;
-
-    current_mode  = EK_MODE_STATIC;
-    current_speed = EK_SPEED_NORMAL;
-}
-
-EKController::~EKController()
-{
-    hid_close(dev);
-}
-
-std::string EKController::GetDeviceName()
-{
-    return device_name;
-}
-
-std::string EKController::GetSerial()
-{
-    return serial;
-}
-
-std::string EKController::GetLocation()
-{
-    return("HID: " + 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] = ek_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] = ek_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(ek_colour_mode_data[0]) / sizeof(ek_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, char *_path);
-    ~EKController();
-
-    std::string GetDeviceName();
-    std::string GetSerial();
-    std::string GetLocation();
-
-    void SetMode(unsigned char mode, unsigned char speed);
-    void SetColor(unsigned char red, unsigned char green, unsigned char blue);
-
-private:
-    std::string             device_name;
-    std::string             serial;
-    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,31 +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
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectEKControllers                                                                    *
-*                                                                                          *
-*       Tests the USB address to see if any EK Controllers exists there.                   *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectEKControllers(hid_device_info* info, const std::string&)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        EKController* controller = new EKController(dev, info->path);
-        RGBController_EKController* rgb_controller = new RGBController_EKController(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-    info = info->next;
-}   /* DetectEKControllers() */
-
-REGISTER_HID_DETECTOR_IPU("EK Loop Connect", DetectEKControllers, EK_VID, EK_LOOP_CONNECT, 0, 0xFFA0, 1);
@@ -1,174 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  RGBController_EKController.cpp                                     |
-|                                                                     |
-|  Driver for EK Loop Connect                                         |
-|                                                                     |
-|  Chris M (Dr_No)          16th Jul 2020                             |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#include "RGBController_EKController.h"
-
-RGBController_EKController::RGBController_EKController(EKController* _dev)
-{
-    EK_dev  = _dev;
-
-    name        = EK_dev->GetDeviceName();
-    vendor      = "EK";
-    type        = DEVICE_TYPE_LEDSTRIP;
-    description = EK_dev->GetDeviceName();
-    version     = "1.0";
-    serial      = EK_dev->GetSerial();
-    location    = EK_dev->GetLocation();
-
-    mode Static;
-    Static.name                     = "Static";
-    Static.value                    = EK_MODE_STATIC;
-    Static.flags                    = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode               = MODE_COLORS_PER_LED;
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = EK_MODE_BREATHING;
-    Breathing.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    Breathing.speed_min             = EK_SPEED_SLOWEST;
-    Breathing.speed_max             = EK_SPEED_FASTEST;
-    Breathing.color_mode            = MODE_COLORS_PER_LED;
-    Breathing.speed                 = EK_SPEED_NORMAL;
-    modes.push_back(Breathing);
-
-    mode Fading;
-    Fading.name                     = "Fading";
-    Fading.value                    = EK_MODE_FADING;
-    Fading.flags                    = MODE_FLAG_HAS_SPEED;
-    Fading.speed_min                = EK_SPEED_SLOWEST;
-    Fading.speed_max                = EK_SPEED_FASTEST;
-    Fading.color_mode               = MODE_COLORS_NONE;
-    Fading.speed                    = EK_SPEED_NORMAL;
-    modes.push_back(Fading);
-
-    mode Marquee;
-    Marquee.name                    = "Marquee";
-    Marquee.value                   = EK_MODE_MARQUEE;
-    Marquee.flags                   = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    Marquee.speed_min               = EK_SPEED_SLOWEST;
-    Marquee.speed_max               = EK_SPEED_FASTEST;
-    Marquee.color_mode              = MODE_COLORS_PER_LED;
-    Marquee.speed                   = EK_SPEED_NORMAL;
-    modes.push_back(Marquee);
-
-    mode Covering_Marquee;
-    Covering_Marquee.name           = "Covering Marquee";
-    Covering_Marquee.value          = EK_MODE_COVERING_MARQUEE;
-    Covering_Marquee.flags          = MODE_FLAG_HAS_SPEED;
-    Covering_Marquee.speed_min      = EK_SPEED_SLOWEST;
-    Covering_Marquee.speed_max      = EK_SPEED_FASTEST;
-    Covering_Marquee.color_mode     = MODE_COLORS_NONE;
-    Covering_Marquee.speed          = EK_SPEED_NORMAL;
-    modes.push_back(Covering_Marquee);
-
-    mode Pulse;
-    Pulse.name                      = "Pulse";
-    Pulse.value                     = EK_MODE_PULSE;
-    Pulse.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    Pulse.speed_min                 = EK_SPEED_SLOWEST;
-    Pulse.speed_max                 = EK_SPEED_FASTEST;
-    Pulse.color_mode                = MODE_COLORS_PER_LED;
-    Pulse.speed                     = EK_SPEED_NORMAL;
-    modes.push_back(Pulse);
-
-    mode Spectrum_Wave;
-    Spectrum_Wave.name              = "Spectrum_Wave";
-    Spectrum_Wave.value             = EK_MODE_SPECTRUM_WAVE;
-    Spectrum_Wave.flags             = MODE_FLAG_HAS_SPEED;
-    Spectrum_Wave.speed_min         = EK_SPEED_SLOWEST;
-    Spectrum_Wave.speed_max         = EK_SPEED_FASTEST;
-    Spectrum_Wave.color_mode        = MODE_COLORS_NONE;
-    Spectrum_Wave.speed             = EK_SPEED_NORMAL;
-    modes.push_back(Spectrum_Wave);
-
-    mode Alternating;
-    Alternating.name                = "Alternating";
-    Alternating.value               = EK_MODE_ALTERNATING;
-    Alternating.flags               = MODE_FLAG_HAS_SPEED;
-    Alternating.speed_min           = EK_SPEED_SLOWEST;
-    Alternating.speed_max           = EK_SPEED_FASTEST;
-    Alternating.color_mode          = MODE_COLORS_PER_LED;
-    Alternating.speed               = EK_SPEED_NORMAL;
-    modes.push_back(Alternating);
-
-    mode Candle;
-    Candle.name                    = "Candle";
-    Candle.value                   = EK_MODE_CANDLE;
-    Candle.flags                   = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    Candle.speed_min               = EK_SPEED_SLOWEST;
-    Candle.speed_max               = EK_SPEED_FASTEST;
-    Candle.color_mode              = MODE_COLORS_PER_LED;
-    Candle.speed                   = EK_SPEED_NORMAL;
-    modes.push_back(Candle);
-
-    SetupZones();
-}
-
-RGBController_EKController::~RGBController_EKController()
-{
-
-}
-
-void RGBController_EKController::SetupZones()
-{
-    zone EK_zone;
-    EK_zone.name          = "Loop Connect";
-    EK_zone.type          = ZONE_TYPE_SINGLE;
-    EK_zone.leds_min      = 1;
-    EK_zone.leds_max      = 1;
-    EK_zone.leds_count    = 1;
-    EK_zone.matrix_map    = NULL;
-    zones.push_back(EK_zone);
-
-    led EK_led;
-    EK_led.name = "EK LED";
-    leds.push_back(EK_led);
-
-    SetupColors();
-}
-
-void RGBController_EKController::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | ToDo                                                      |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_EKController::DeviceUpdateLEDs()
-{
-    unsigned char red = RGBGetRValue(colors[0]);
-    unsigned char grn = RGBGetGValue(colors[0]);
-    unsigned char blu = RGBGetBValue(colors[0]);
-    EK_dev->SetColor(red, grn, blu);
-}
-
-void RGBController_EKController::UpdateZoneLEDs(int zone)
-{
-    RGBColor      color = colors[zone];
-    unsigned char red   = RGBGetRValue(color);
-    unsigned char grn   = RGBGetGValue(color);
-    unsigned char blu   = RGBGetBValue(color);
-    EK_dev->SetColor(red, grn, blu);
-}
-
-void RGBController_EKController::UpdateSingleLED(int led)
-{
-    UpdateZoneLEDs(led);
-}
-
-void RGBController_EKController::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_EKController::DeviceUpdateMode()
-{
-    EK_dev->SetMode(modes[active_mode].value, modes[active_mode].speed);
-}
@@ -1,35 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  RGBController_EKController.h                                       |
-|                                                                     |
-|  Driver for EK Loop Connect                                         |
-|                                                                     |
-|  Chris M (Dr_No)          16th Jul 2020                             |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#ifndef RGBCONTROLLER_EKCONTROLLER_H
-#define RGBCONTROLLER_EKCONTROLLER_H
-
-#include "RGBController.h"
-#include "Controllers/EKController/EKController.h"
-
-class RGBController_EKController : public RGBController
-{
-public:
-    RGBController_EKController(EKController *_dev);
-    ~RGBController_EKController();
-
-    void        SetupZones();
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-private:
-    EKController* EK_dev;
-};
-
-#endif // RGBCONTROLLER_EKCONTROLLER_H
@@ -1,98 +0,0 @@
-#include "Detector.h"
-#include "EVGAGPUv1Controller.h"
-#include "EVGAGPUv2Controller.h"
-#include "RGBController.h"
-#include "RGBController_EVGAGPUv1.h"
-#include "RGBController_EVGAGPUv2.h"
-#include "i2c_smbus.h"
-#include "pci_ids.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-enum
-{
-    EVGA_RGB_V1,
-    EVGA_RGB_V2,
-};
-
-typedef struct
-{
-    int             pci_vendor;
-    int             pci_device;
-    int             pci_subsystem_vendor;
-    int             pci_subsystem_device;
-    int             gpu_rgb_version;
-    const char *    name;
-} gpu_pci_device;
-
-#define GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const gpu_pci_device device_list[] =
-{
-    { NVIDIA_VEN,   NVIDIA_GTX1070_DEV,     EVGA_SUB_VEN,   EVGA_GTX1070_FTW_SUB_DEV,       EVGA_RGB_V1,    "EVGA GeForce GTX 1070 FTW"             },
-    { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,     EVGA_SUB_VEN,   EVGA_GTX1080_FTW_SUB_DEV,       EVGA_RGB_V1,    "EVGA GeForce GTX 1080 FTW"             },
-    { NVIDIA_VEN,   NVIDIA_RTX2070_OC_DEV,  EVGA_SUB_VEN,   EVGA_RTX2070_XC_OC_SUB_DEV,     EVGA_RGB_V2,    "EVGA GeForce RTX 2070 XC OC"           },
-    { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,    EVGA_SUB_VEN,   EVGA_RTX2070S_XC_ULTRA_SUB_DEV, EVGA_RGB_V2,    "EVGA GeForce RTX 2070 SUPER XC ULTRA"  },
-    { NVIDIA_VEN,   NVIDIA_RTX2080_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_GAMING_SUB_DEV, EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC GAMING"       },
-};
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectEVGAGPUControllers                                                               *
-*                                                                                          *
-*       Detect EVGA GPU controllers on the enumerated I2C busses at address 0x49.          *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where EVGA GPU device is connected        *
-*           dev - I2C address of EVGA GPU device                                           *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectEVGAGPUControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
-{
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        for(unsigned int dev_idx = 0; dev_idx < 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)
-            {
-                switch(device_list[dev_idx].gpu_rgb_version)
-                {
-                    case EVGA_RGB_V1:
-                        {
-                            EVGAGPUv1Controller*     new_controller;
-                            RGBController_EVGAGPUv1* new_rgbcontroller;
-
-                            new_controller          = new EVGAGPUv1Controller(busses[bus], 0x49);
-                            new_rgbcontroller       = new RGBController_EVGAGPUv1(new_controller);
-                            new_rgbcontroller->name = device_list[dev_idx].name;
-                            rgb_controllers.push_back(new_rgbcontroller);
-                        }
-                        break;
-
-                    case EVGA_RGB_V2:
-                        {
-                            EVGAGPUv2Controller*     new_controller;
-                            RGBController_EVGAGPUv2* new_rgbcontroller;
-
-                            new_controller          = new EVGAGPUv2Controller(busses[bus], 0x49);
-                            new_rgbcontroller       = new RGBController_EVGAGPUv2(new_controller);
-                            new_rgbcontroller->name = device_list[dev_idx].name;
-                            rgb_controllers.push_back(new_rgbcontroller);
-                        }
-                        break;
-                }
-            }
-        }
-    }
-}   /* DetectEVGAGPUControllers() */
-
-REGISTER_I2C_DETECTOR("EVGA GPU", DetectEVGAGPUControllers);
@@ -1,63 +0,0 @@
-/*-----------------------------------------*\
-|  EVGAGPUv1Controller.cpp                  |
-|                                           |
-|  Driver for EVGA GPU RGB V1 (Pascal)      |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 9/11/2020   |
-\*-----------------------------------------*/
-
-#include "EVGAGPUv1Controller.h"
-
-EVGAGPUv1Controller::EVGAGPUv1Controller(i2c_smbus_interface* bus, evga_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-}
-
-EVGAGPUv1Controller::~EVGAGPUv1Controller()
-{
-
-}
-
-std::string EVGAGPUv1Controller::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-unsigned char EVGAGPUv1Controller::GetMode()
-{
-    return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V1_REG_MODE));
-}
-
-unsigned char EVGAGPUv1Controller::GetRed()
-{
-    return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V1_REG_RED));
-}
-
-unsigned char EVGAGPUv1Controller::GetGreen()
-{
-    return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V1_REG_GREEN));
-}
-
-unsigned char EVGAGPUv1Controller::GetBlue()
-{
-    return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V1_REG_BLUE));
-}
-
-void EVGAGPUv1Controller::SetColor(unsigned char red, unsigned char green, unsigned char blue)
-{
-    bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V1_REG_RED,   red);
-    bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V1_REG_GREEN, green);
-    bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V1_REG_BLUE,  blue);
-}
-
-void EVGAGPUv1Controller::SetMode(unsigned char mode)
-{
-    bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V1_REG_MODE, mode);
-}
@@ -1,53 +0,0 @@
-/*-----------------------------------------*\
-|  EVGAGPUv1Controller.h                    |
-|                                           |
-|  Definitions and types for EVGA GPU RGB   |
-|  V1 (Pascal) lighting controller          |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 9/11/2020   |
-\*-----------------------------------------*/
-
-#include <string>
-#include "i2c_smbus.h"
-
-#pragma once
-
-typedef unsigned char	evga_dev_id;
-
-enum
-{
-    EVGA_GPU_V1_REG_MODE                = 0x0C,
-    EVGA_GPU_V1_REG_RED                 = 0x09,
-    EVGA_GPU_V1_REG_GREEN               = 0x0A,
-    EVGA_GPU_V1_REG_BLUE                = 0x0B,
-};
-
-enum
-{
-    EVGA_GPU_V1_MODE_OFF                = 0x00,
-    EVGA_GPU_V1_MODE_CUSTOM             = 0x01,
-    EVGA_GPU_V1_MODE_RAINBOW            = 0x02,
-    EVGA_GPU_V1_MODE_BREATHING          = 0x05,
-};
-
-class EVGAGPUv1Controller
-{
-public:
-    EVGAGPUv1Controller(i2c_smbus_interface* bus, evga_dev_id dev);
-    ~EVGAGPUv1Controller();
-
-    std::string     GetDeviceLocation();
-
-    unsigned char   GetMode();
-    unsigned char   GetRed();
-    unsigned char   GetGreen();
-    unsigned char   GetBlue();
-
-    void            SetColor(unsigned char red, unsigned char green, unsigned char blue);
-    void            SetMode(unsigned char mode);
-
-private:
-    i2c_smbus_interface*    bus;
-    evga_dev_id             dev;
-
-};
@@ -1,68 +0,0 @@
-/*-----------------------------------------*\
-|  EVGAGPUv2Controller.cpp                  |
-|                                           |
-|  Driver for EVGA GPU RGB V2 (Turing)      |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 9/13/2020   |
-\*-----------------------------------------*/
-
-#include "EVGAGPUv2Controller.h"
-
-EVGAGPUv2Controller::EVGAGPUv2Controller(i2c_smbus_interface* bus, evga_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-}
-
-EVGAGPUv2Controller::~EVGAGPUv2Controller()
-{
-
-}
-
-std::string EVGAGPUv2Controller::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-unsigned char EVGAGPUv2Controller::GetRed()
-{
-    return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_RED));
-}
-
-unsigned char EVGAGPUv2Controller::GetGreen()
-{
-    return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_GREEN));
-}
-
-unsigned char EVGAGPUv2Controller::GetBlue()
-{
-    return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_BLUE));
-}
-
-void EVGAGPUv2Controller::SetColor(unsigned char red, unsigned char green, unsigned char blue)
-{
-    bus->i2c_smbus_write_byte_data(dev, 0x0E,                               0xE5);
-    bus->i2c_smbus_write_byte_data(dev, 0x0E,                               0xE9);
-    bus->i2c_smbus_write_byte_data(dev, 0x0E,                               0xF5);
-    bus->i2c_smbus_write_byte_data(dev, 0x0E,                               0xF9);
-    
-    bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_RED,        red);
-    bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_GREEN,      green);
-    bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_BLUE,       blue);
-    bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_BRIGHTNESS, 0x64);
-
-    bus->i2c_smbus_write_byte_data(dev, 0x08,                               0x01);
-    bus->i2c_smbus_write_byte_data(dev, 0x0E,                               0xF0);
-    bus->i2c_smbus_write_byte_data(dev, 0x0E,                               0xE0);
-}
-
-void EVGAGPUv2Controller::SetMode(unsigned char mode)
-{
-    bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_MODE, mode);
-}
@@ -1,57 +0,0 @@
-/*-----------------------------------------*\
-|  EVGAGPUv2Controller.h                    |
-|                                           |
-|  Definitions and types for EVGA GPU RGB   |
-|  V2 (Turing) lighting controller          |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 9/13/2020   |
-\*-----------------------------------------*/
-
-#include <string>
-#include "i2c_smbus.h"
-
-#pragma once
-
-typedef unsigned char	evga_dev_id;
-
-enum
-{
-    EVGA_GPU_V2_REG_MODE                = 0x60,
-    EVGA_GPU_V2_REG_COLOR_A_RED         = 0x6C,
-    EVGA_GPU_V2_REG_COLOR_A_GREEN       = 0x6D,
-    EVGA_GPU_V2_REG_COLOR_A_BLUE        = 0x6E,
-    EVGA_GPU_V2_REG_COLOR_A_BRIGHTNESS  = 0x6F,
-    EVGA_GPU_V2_REG_COLOR_B_RED         = 0x70,
-    EVGA_GPU_V2_REG_COLOR_B_GREEN       = 0x71,
-    EVGA_GPU_V2_REG_COLOR_B_BLUE        = 0x72,
-    EVGA_GPU_V2_REG_COLOR_B_BRIGHTNESS  = 0x73,
-};
-
-enum
-{
-    EVGA_GPU_V2_MODE_OFF                = 0x00,
-    EVGA_GPU_V2_MODE_CUSTOM             = 0x01,
-    EVGA_GPU_V2_MODE_RAINBOW            = 0x0F,
-    EVGA_GPU_V2_MODE_BREATHING          = 0x22,
-};
-
-class EVGAGPUv2Controller
-{
-public:
-    EVGAGPUv2Controller(i2c_smbus_interface* bus, evga_dev_id dev);
-    ~EVGAGPUv2Controller();
-
-    std::string     GetDeviceLocation();
-
-    unsigned char   GetRed();
-    unsigned char   GetGreen();
-    unsigned char   GetBlue();
-
-    void            SetColor(unsigned char red, unsigned char green, unsigned char blue);
-    void            SetMode(unsigned char mode);
-
-private:
-    i2c_smbus_interface*    bus;
-    evga_dev_id             dev;
-
-};
@@ -1,137 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_EVGAGPUv1.cpp              |
-|                                           |
-|  Generic RGB Interface for OpenRGB EVGA   |
-|  GPU V1 (Pascal) Driver                   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 9/11/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController_EVGAGPUv1.h"
-
-RGBController_EVGAGPUv1::RGBController_EVGAGPUv1(EVGAGPUv1Controller* evga_ptr)
-{
-    evga = evga_ptr;
-
-    name        = "EVGA GPU";
-    vendor      = "EVGA";
-    description = "EVGA RGB v1 GPU Device";
-    location    = evga->GetDeviceLocation();
-
-    type = DEVICE_TYPE_GPU;
-
-    mode Off;
-    Off.name       = "Off";
-    Off.value      = EVGA_GPU_V1_MODE_OFF;
-    Off.flags      = 0;
-    Off.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = EVGA_GPU_V1_MODE_CUSTOM;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Rainbow;
-    Rainbow.name       = "Rainbow";
-    Rainbow.value      = EVGA_GPU_V1_MODE_RAINBOW;
-    Rainbow.flags      = 0;
-    Rainbow.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Rainbow);
-
-    mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = EVGA_GPU_V1_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Breathing.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Breathing);
-
-    SetupZones();
-
-    // Initialize active mode and stored color
-
-    unsigned char raw_active_mode = evga->GetMode();
-
-    active_mode = 0;
-    for(unsigned int i = 0; i < modes.size(); i++)
-    {
-        if (modes[i].value == raw_active_mode)
-        {
-            active_mode = i;
-            break;
-        }
-    }
-
-    unsigned char r = evga->GetRed();
-    unsigned char g = evga->GetGreen();
-    unsigned char b = evga->GetBlue();
-
-    RGBColor color = ToRGBColor(r, g, b);
-    colors[0] = color;
-}
-
-void RGBController_EVGAGPUv1::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | This device only has one LED, so create a single zone and |
-    | LED for it                                                |
-    \*---------------------------------------------------------*/
-    zone* new_zone = new zone();
-    led*  new_led  = new led();
-
-    new_zone->name          = "GPU Zone";
-    new_zone->type          = ZONE_TYPE_SINGLE;
-    new_zone->leds_min      = 1;
-    new_zone->leds_max      = 1;
-    new_zone->leds_count    = 1;
-    new_zone->matrix_map    = NULL;
-
-    new_led->name           = "GPU LED";
-
-    /*---------------------------------------------------------*\
-    | Push the zone and LED on to device vectors                |
-    \*---------------------------------------------------------*/
-    leds.push_back(*new_led);
-    zones.push_back(*new_zone);
-
-    SetupColors();
-}
-
-void RGBController_EVGAGPUv1::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_EVGAGPUv1::DeviceUpdateLEDs()
-{
-    RGBColor      color = colors[0];
-    unsigned char red   = RGBGetRValue(color);
-    unsigned char grn   = RGBGetGValue(color);
-    unsigned char blu   = RGBGetBValue(color);
-
-    evga->SetColor(red, grn, blu);
-}
-
-void RGBController_EVGAGPUv1::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_EVGAGPUv1::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_EVGAGPUv1::SetCustomMode()
-{
-    active_mode = 1;
-}
-
-void RGBController_EVGAGPUv1::DeviceUpdateMode()
-{
-    evga->SetMode((unsigned char)modes[(unsigned int)active_mode].value);
-}
@@ -1,33 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_EVGAGPUv1.h                |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  EVGA GPU RGB V1 (Pascal) Driver          |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 9/11/2020   |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "EVGAGPUv1Controller.h"
-
-class RGBController_EVGAGPUv1 : public RGBController
-{
-public:
-    RGBController_EVGAGPUv1(EVGAGPUv1Controller* evga_ptr);
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    EVGAGPUv1Controller* evga;
-};
@@ -1,119 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_EVGAGPUv2.cpp              |
-|                                           |
-|  Generic RGB Interface for OpenRGB EVGA   |
-|  GPU V2 (Pascal) Driver                   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 9/13/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController_EVGAGPUv2.h"
-
-RGBController_EVGAGPUv2::RGBController_EVGAGPUv2(EVGAGPUv2Controller* evga_ptr)
-{
-    evga = evga_ptr;
-
-    name        = "EVGA GPU";
-    vendor      = "EVGA";
-    description = "EVGA RGB v2 GPU Device";
-    location    = evga->GetDeviceLocation();
-
-    type = DEVICE_TYPE_GPU;
-
-    mode Off;
-    Off.name       = "Off";
-    Off.value      = EVGA_GPU_V2_MODE_OFF;
-    Off.flags      = 0;
-    Off.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = EVGA_GPU_V2_MODE_CUSTOM;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    // mode Rainbow;
-    // Rainbow.name       = "Rainbow";
-    // Rainbow.value      = EVGA_GPU_V2_MODE_RAINBOW;
-    // Rainbow.flags      = 0;
-    // Rainbow.color_mode = MODE_COLORS_NONE;
-    // modes.push_back(Rainbow);
-
-    // mode Breathing;
-    // Breathing.name       = "Breathing";
-    // Breathing.value      = EVGA_GPU_V2_MODE_BREATHING;
-    // Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    // Breathing.color_mode = MODE_COLORS_PER_LED;
-    // modes.push_back(Breathing);
-
-    SetupZones();
-
-    // Initialize active mode
-    active_mode = 0;
-}
-
-void RGBController_EVGAGPUv2::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | This device only has one LED, so create a single zone and |
-    | LED for it                                                |
-    \*---------------------------------------------------------*/
-    zone* new_zone = new zone();
-    led*  new_led  = new led();
-
-    new_zone->name          = "GPU Zone";
-    new_zone->type          = ZONE_TYPE_SINGLE;
-    new_zone->leds_min      = 1;
-    new_zone->leds_max      = 1;
-    new_zone->leds_count    = 1;
-    new_zone->matrix_map    = NULL;
-
-    new_led->name           = "GPU LED";
-
-    /*---------------------------------------------------------*\
-    | Push the zone and LED on to device vectors                |
-    \*---------------------------------------------------------*/
-    leds.push_back(*new_led);
-    zones.push_back(*new_zone);
-
-    SetupColors();
-}
-
-void RGBController_EVGAGPUv2::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_EVGAGPUv2::DeviceUpdateLEDs()
-{
-    RGBColor      color = colors[0];
-    unsigned char red   = RGBGetRValue(color);
-    unsigned char grn   = RGBGetGValue(color);
-    unsigned char blu   = RGBGetBValue(color);
-
-    evga->SetColor(red, grn, blu);
-}
-
-void RGBController_EVGAGPUv2::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_EVGAGPUv2::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_EVGAGPUv2::SetCustomMode()
-{
-    active_mode = 1;
-}
-
-void RGBController_EVGAGPUv2::DeviceUpdateMode()
-{
-    evga->SetMode((unsigned char)modes[(unsigned int)active_mode].value);
-}
@@ -1,33 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_EVGAGPUv2.h                |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  EVGA GPU RGB V2 (Turing) Driver          |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 9/13/2020   |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "EVGAGPUv2Controller.h"
-
-class RGBController_EVGAGPUv2 : public RGBController
-{
-public:
-    RGBController_EVGAGPUv2(EVGAGPUv2Controller* evga_ptr);
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    EVGAGPUv2Controller* evga;
-};
@@ -1,74 +0,0 @@
-/*---------------------------------------------------------*\
-|  Processing Code for Espurna Interface                    |
-|                                                           |
-|  Adam Honse ([email protected]), 9/11/2020        |
-\*---------------------------------------------------------*/
-
-#include "EspurnaController.h"
-
-#include <fstream>
-#include <iostream>
-#include <string>
-#include <string.h>
-
-EspurnaController::EspurnaController()
-{
-
-}
-
-EspurnaController::~EspurnaController()
-{
-}
-
-void EspurnaController::Initialize(char* ledstring)
-{
-    LPSTR   apikey = NULL;
-    LPSTR   source = NULL;
-    LPSTR   udpport_baud = NULL;
-    LPSTR   next = NULL;
-    
-    source = strtok_s(ledstring, ",", &next);
-    
-    //Check for either the UDP port or the serial baud rate
-    if (strlen(next))
-    {
-        udpport_baud = strtok_s(next, ",", &next);
-    }
-
-    //Espurna protocol requires API key
-    if (strlen(next))
-    {
-        apikey = strtok_s(next, ",", &next);
-    }
-
-    InitializeEspurna(source, udpport_baud, apikey);
-}
-
-void EspurnaController::InitializeEspurna(char * clientname, char * port, char * apikey)
-{
-    client_name = clientname;
-    port_name   = port;
-
-    strcpy(espurna_apikey, apikey);
-    tcpport = new net_port;
-    tcpport->tcp_client(client_name.c_str(), port_name.c_str());
-}
-
-std::string EspurnaController::GetLocation()
-{
-    return("TCP: " + client_name + ":" + port_name);
-}
-
-void EspurnaController::SetLEDs(std::vector<RGBColor> colors)
-{
-    if (tcpport != NULL)
-    {
-        RGBColor color = colors[0];
-
-        char get_request[1024];
-        snprintf(get_request, 1024, "GET /api/rgb?apikey=%s&value=%%23%02X%02X%02X HTTP/1.1\r\nHost: %s\r\n\r\n", espurna_apikey, RGBGetRValue(color), RGBGetGValue(color), RGBGetBValue(color), client_name.c_str());
-        tcpport->tcp_client_connect();
-        tcpport->tcp_client_write(get_request, strlen(get_request));
-        tcpport->tcp_close();
-    }
-}
@@ -1,49 +0,0 @@
-/*---------------------------------------------------------*\
-|  Definitions for Espurna Interface                        |
-|                                                           |
-|  Adam Honse ([email protected]), 9/11/2020        |
-\*---------------------------------------------------------*/
-
-#ifndef ESPURNA_H
-#define ESPURNA_H
-
-#include "RGBController.h"
-#include "net_port.h"
-#include <vector>
-
-
-#ifndef TRUE
-#define TRUE true
-#define FALSE false
-#endif
-
-#ifndef WIN32
-#define LPSTR           char *
-#define strtok_s        strtok_r
-#endif
-
-class EspurnaController
-{
-public:
-    EspurnaController();
-    ~EspurnaController();
-
-    void        Initialize(char* ledstring);
-    void        InitializeEspurna(char* clientname, char* port, char * apikey);
-
-    std::string GetLocation();
-
-    void        SetLEDs(std::vector<RGBColor> colors);
-
-private:
-    int baud_rate;
-
-    char led_string[1024];
-    std::string port_name;
-    std::string client_name;
-    char espurna_apikey[128];
-
-    net_port *tcpport;
-};
-
-#endif
@@ -1,74 +0,0 @@
-#include "Detector.h"
-#include "EspurnaController.h"
-#include "RGBController.h"
-#include "RGBController_Espurna.h"
-#include "SettingsManager.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectEspurnaControllers                                                               *
-*                                                                                          *
-*       Detect devices supported by the Espurna driver                                     *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectEspurnaControllers(std::vector<RGBController*> &rgb_controllers)
-{
-    EspurnaController*      new_espurna;
-    RGBController_Espurna*  new_controller;
-    json                    espurna_settings;
-
-    /*-------------------------------------------------*\
-    | Get Espurna settings from settings manager        |
-    \*-------------------------------------------------*/
-    espurna_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("EspurnaDevices");
-
-    /*-------------------------------------------------*\
-    | If the Espurna settings contains devices, process |
-    \*-------------------------------------------------*/
-    if(espurna_settings.contains("devices"))
-    {
-        for(unsigned int device_idx = 0; device_idx < espurna_settings["devices"].size(); device_idx++)
-        {
-            std::string ip;
-            std::string port;
-            std::string apikey;
-
-            if(espurna_settings["devices"][device_idx].contains("ip"))
-            {
-                ip = espurna_settings["devices"][device_idx]["ip"];
-            }
-
-            if(espurna_settings["devices"][device_idx].contains("port"))
-            {
-                if(espurna_settings["devices"][device_idx]["port"].type() == json::value_t::string)
-                {
-                    port = espurna_settings["devices"][device_idx]["port"];
-                }
-                else
-                {
-                    port = std::to_string((unsigned int)espurna_settings["devices"][device_idx]["port"]);
-                }
-            }
-
-            if(espurna_settings["devices"][device_idx].contains("apikey"))
-            {
-                apikey = espurna_settings["devices"][device_idx]["apikey"];
-            }
-
-            std::string value = ip + "," + port + "," + apikey;
-
-            new_espurna = new EspurnaController();
-            new_espurna->Initialize((char *)value.c_str());
-
-            new_controller = new RGBController_Espurna(new_espurna);
-            rgb_controllers.push_back(new_controller);
-        }
-    }
-
-}   /* DetectEspurnaControllers() */
-
-REGISTER_DETECTOR("Espurna", DetectEspurnaControllers);
@@ -1,79 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_Espurna.cpp                |
-|                                           |
-|  Generic RGB Interface for Espurna        |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/20/2019   |
-\*-----------------------------------------*/
-
-#include "RGBController_Espurna.h"
-
-RGBController_Espurna::RGBController_Espurna(EspurnaController* espurna_ptr)
-{
-    espurna = espurna_ptr;
-
-    name        = "Espurna";
-    type        = DEVICE_TYPE_LIGHT;
-    description = "Espurna Device";
-    location    = espurna->GetLocation();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-}
-
-void RGBController_Espurna::SetupZones()
-{
-    zone led_zone;
-    led_zone.name       = "RGB Light";
-    led_zone.type       = ZONE_TYPE_SINGLE;
-    led_zone.leds_min   = 1;
-    led_zone.leds_max   = 1;
-    led_zone.leds_count = 1;
-    led_zone.matrix_map = NULL;
-    zones.push_back(led_zone);
-
-    led new_led;
-    new_led.name = "RGB Light";
-
-    leds.push_back(new_led);
-
-    SetupColors();
-}
-
-void RGBController_Espurna::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_Espurna::DeviceUpdateLEDs()
-{
-    espurna->SetLEDs(colors);
-}
-
-void RGBController_Espurna::UpdateZoneLEDs(int /*zone*/)
-{
-    espurna->SetLEDs(colors);
-}
-
-void RGBController_Espurna::UpdateSingleLED(int /*led*/)
-{
-    espurna->SetLEDs(colors);
-}
-
-void RGBController_Espurna::SetCustomMode()
-{
-
-}
-
-void RGBController_Espurna::DeviceUpdateMode()
-{
-
-}
@@ -1,31 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_Espurna.h                  |
-|                                           |
-|  Generic RGB Interface for Espurna        |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 9/11/2020   |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "EspurnaController.h"
-
-class RGBController_Espurna : public RGBController
-{
-public:
-    RGBController_Espurna(EspurnaController* espurna_ptr);
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    EspurnaController* espurna;
-};
@@ -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("I2C: " + 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);
-}
--- 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