Add ViewSonic Elite XG270QG

Amended for code style by Adam Honse <[email protected]>

.editorconfig

@@ -0,0 +1,17 @@
+# EditorConfig helps developers define and maintain consistent coding styles between different editors and IDEs
+# editorconfig.org
+
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+
+# We recommend you to keep these unchanged
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+indent_size = 4

.gitignore

@@ -1,11 +1,113 @@
-*.pro.user*
-*.o
-ui_*
-moc_*
-qrc_*
+# This file is used to ignore files that should not be pushed to the repo.
+# ----------------------------------------------------------------------------
+
+# OpenRGB Specific
 OpenRGB
 openrgb
-Makefile
 OpenRGB-x86_64.AppImage
+
+# Directories
+.build/
+.cache/
+.moc/
+.obj/
+.pch/
+.rcc/
+.uic/
+.clangd/
+*_debug/
+*_release/
+debug/
+release/
+build/
+Build/
+.qmake.cache
 .qmake.stash
 .vscode
+.vs
+
+# Generic Files
+.DS_Store
+Thumbs.db
+
+# Binaries
+*.exe
+!dependencies/**/*.exe
+*.bat
+!dependencies/**/*.bat
+
+# C++ objects and libs
+*.slo
+*.lo
+*.o
+*.a
+*.la
+*.lai
+*.so
+*.so.*
+*.dll
+!dependencies/**/*.dll
+*.dylib
+
+# Qt-es
+object_script.*.Release
+object_script.*.Debug
+*_plugin_import.cpp
+*.pro.user
+*.pro.user.*
+*.qbs.user
+*.qbs.user.*
+*.moc
+moc_*.cpp
+moc_*.h
+qrc_*.cpp
+ui_*.h
+*.qmlc
+*.jsc
+Makefile*
+*build-*
+*.qm
+*.prl
+
+# Qt unit tests
+target_wrapper.*
+
+# QtCreator
+*.autosave
+
+# QtCreator Qml
+*.qmlproject.user
+*.qmlproject.user.*
+
+# QtCreator CMake
+CMakeLists.txt.user*
+
+# QtCreator 4.8< compilation database
+compile_commands.json
+
+# QtCreator local machine specific files for imported projects
+*creator.user*
+
+*_qmlcache.qrc
+
+# Visual Studio generated files
+*.ib_pdb_index
+*.idb
+*.ilk
+*.ncb
+*.opensdf
+*.pdb
+*.sdf
+*.sln
+*.suo
+*.vcproj
+*.vcxproj
+*vcproj.*.*.user
+*vcxproj.*
+
+# MinGW generated files
+*.Debug
+*.Release
+
+# Clang tooling files
+compile_commands.json

.gitlab-ci.yml

@@ -13,7 +13,7 @@
   - shared-windows
   - windows
   - windows-1809
-  
+
 stages:
   - build
   - test
@@ -32,12 +32,12 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 32 AppImage":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-32
   stage: build
   script:
   - export $(dpkg-architecture)
   - ./scripts/build-appimage.sh
-  
+
   artifacts:
     name: "${CI_PROJECT_NAME}_Linux_32_${CI_COMMIT_SHORT_SHA}"
     paths:
@@ -51,12 +51,12 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 64 AppImage":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
   stage: build
   script:
   - export $(dpkg-architecture)
   - ./scripts/build-appimage.sh
-  
+
   artifacts:
     name: "${CI_PROJECT_NAME}_Linux_64_${CI_COMMIT_SHORT_SHA}"
     paths:
@@ -66,9 +66,9 @@ before_script:
     expire_in: 30 days
 
 #-----------------------------------------------------------------------#
-# Linux (.deb) 32-bit Build Target                                      #
+# Linux (.deb) Debian Buster (Legacy) 32-bit Build Target               #
 #-----------------------------------------------------------------------#
-"Linux 32 deb":
+"Linux 32 .deb (Debian Buster)":
   <<: *ccache_init
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
   stage: build
@@ -87,9 +87,9 @@ before_script:
     expire_in: 30 days
 
 #-----------------------------------------------------------------------#
-# Linux (.deb) 64-bit Build Target                                      #
+# Linux (.deb) Debian Buster (Legacy) 64-bit Build Target               #
 #-----------------------------------------------------------------------#
-"Linux 64 deb":
+"Linux 64 .deb (Debian Buster)":
   <<: *ccache_init
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
   stage: build
@@ -108,10 +108,52 @@ before_script:
     expire_in: 30 days
 
 #-----------------------------------------------------------------------#
-# Linux (.rpm) 64-bit Build Target                                      #
+# Linux (.deb) Debian Bullseye 32-bit Build Target                      #
 #-----------------------------------------------------------------------#
-"Linux 64 rpm":
-  image: fedora:34
+"Linux 32 .deb (Debian Bullseye)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-32
+  stage: build
+  script:
+  - dpkg-architecture -l
+  - dpkg-buildpackage --target-arch i386 -us -B
+  - rm -v ../openrgb-dbgsym*.deb
+  - mv -v ../openrgb*.deb ./
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.deb
+    expire_in: 30 days
+
+#-----------------------------------------------------------------------#
+# Linux (.deb) Debian Bullseye 64-bit Build Target                      #
+#-----------------------------------------------------------------------#
+"Linux 64 .deb (Debian Bullseye)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
+  stage: build
+  script:
+  - dpkg-architecture -l
+  - dpkg-buildpackage -us -B
+  - rm -v ../openrgb-dbgsym*.deb
+  - mv -v ../openrgb*.deb ./
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.deb
+    expire_in: 30 days
+
+#-----------------------------------------------------------------------#
+# Linux (.rpm, f35) 64-bit Build Target                                 #
+#-----------------------------------------------------------------------#
+"Linux 64 f35 rpm":
+  image: fedora:35
   stage: build
   script:
   - dnf install rpmdevtools dnf-plugins-core -y 
@@ -133,51 +175,32 @@ before_script:
     paths:
     - openrgb*.rpm
     expire_in: 30 days
-  
+
 #-----------------------------------------------------------------------#
-# Linux (.deb) Debian Bullseye 32-bit Build Target                      #
+# Linux (.rpm, f36) 64-bit Build Target                                 #
 #-----------------------------------------------------------------------#
-"Linux 32 deb Bullseye":
-  <<: *ccache_init
-  image: i386/debian:bullseye
+"Linux 64 f36 rpm":
+  image: fedora:36
   stage: build
   script:
-  - apt update
-  - apt install -y build-essential qtcreator qtbase5-dev libusb-1.0-0-dev libhidapi-dev libmbedtls-dev pkgconf wget git file debhelper
-  - dpkg-architecture -l
-  - dpkg-buildpackage --target-arch i386 -us -B
-  - rm -v ../openrgb-dbgsym*.deb
-  - mv -v ../openrgb*.deb ./
+  - dnf install rpmdevtools dnf-plugins-core libcurl-devel -y
+  - rpmdev-setuptree
+  - ls /root/
+  - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
+  - cp ../OpenRGB /root/rpmbuild/SOURCES/ -r
+  - cd /root/rpmbuild/SOURCES
+  - tar -cf OpenRGB.tar.gz OpenRGB/
+  - cd ..
+  - dnf builddep SPECS/OpenRGB.spec -y
+  - rpmbuild -ba SPECS/OpenRGB.spec
+  - cd RPMS/x86_64/
+  - mv openrgb*.rpm ${CI_PROJECT_DIR}/
+  - cd ${CI_PROJECT_DIR}
 
   artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_64_rpm_${CI_COMMIT_SHORT_SHA}"
     paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.deb
-    expire_in: 30 days
-
-#-----------------------------------------------------------------------#
-# Linux (.deb) Debian Bullseye 64-bit Build Target                      #
-#-----------------------------------------------------------------------#
-"Linux 64 deb Bullseye":
-  <<: *ccache_init
-  image: debian:bullseye
-  stage: build
-  script:
-  - apt update
-  - apt install -y build-essential qtcreator qtbase5-dev libusb-1.0-0-dev libhidapi-dev libmbedtls-dev pkgconf wget git file debhelper
-  - dpkg-architecture -l
-  - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.deb
-  - mv -v ../openrgb*.deb ./
-
-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.deb
+    - openrgb*.rpm
     expire_in: 30 days
 
 #-----------------------------------------------------------------------#
@@ -193,9 +216,26 @@ before_script:
   - openrgb -l
   - apt remove -y openrgb
   dependencies:
-  - "Linux 32 deb"
+  - "Linux 32 .deb (Debian Buster)"
   needs:
-  - "Linux 32 deb"
+  - "Linux 32 .deb (Debian Buster)"
+
+#-----------------------------------------------------------------------#
+# Debian 64 Buster test                                                 #
+#-----------------------------------------------------------------------#
+"Debian 64 Buster":
+  image: amd64/debian:buster
+  stage: test
+  script:
+  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
+  - openrgb --version
+  - openrgb -l
+  - apt remove -y openrgb
+  dependencies:
+  - "Linux 64 .deb (Debian Buster)"
+  needs:
+  - "Linux 64 .deb (Debian Buster)"
 
 #-----------------------------------------------------------------------#
 # Debian 32 Bullseye test                                               #
@@ -210,66 +250,15 @@ before_script:
   - openrgb -l
   - apt remove -y openrgb
   dependencies:
-  - "Linux 32 deb"
+  - "Linux 32 .deb (Debian Bullseye)"
   needs:
-  - "Linux 32 deb"
-
-# #-----------------------------------------------------------------------#
-# # Ubuntu 32 18.04LTS test                                               #
-# #-----------------------------------------------------------------------#
-# "Ubuntu 32 18.04LTS":
-#   image: i386/ubuntu:bionic
-#   stage: test
-#   script:
-#   - apt update
-#   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
-#   - openrgb --version
-#   - openrgb -l
-#   - apt remove -y openrgb
-#   dependencies:
-#   - "Linux 32 deb"
-#   needs:
-#   - "Linux 32 deb"
-
-# #-----------------------------------------------------------------------#
-# # Mint 32 19.3 test                                                     #
-# #-----------------------------------------------------------------------#
-# "Mint 32 20.1":
-#   image: linuxmintd/mint19.3-i386
-#   stage: test
-#   script:
-#   - apt update
-#   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
-#   - openrgb --version
-#   - openrgb -l
-#   - apt remove -y openrgb
-#   dependencies:
-#   - "Linux 32 deb"
-#   needs:
-#   - "Linux 32 deb"
-
-#-----------------------------------------------------------------------#
-# Debian 64 Buster test                                                 #
-#-----------------------------------------------------------------------#
-"Debian 64 Buster":
-  image: debian:buster
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
-  - openrgb --version
-  - openrgb -l
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 64 deb"
-  needs:
-  - "Linux 64 deb"
+  - "Linux 32 .deb (Debian Bullseye)"
 
 #-----------------------------------------------------------------------#
 # Debian 64 Bullseye test                                               #
 #-----------------------------------------------------------------------#
 "Debian 64 Bullseye":
-  image: debian:bullseye
+  image: amd64/debian:bullseye
   stage: test
   script:
   - apt update
@@ -278,42 +267,9 @@ before_script:
   - openrgb -l
   - apt remove -y openrgb
   dependencies:
-  - "Linux 64 deb"
+  - "Linux 64 .deb (Debian Bullseye)"
   needs:
-  - "Linux 64 deb"
-
-#-----------------------------------------------------------------------#
-# Fedora 64 v34 test                                                    #
-#-----------------------------------------------------------------------#
-"Fedora 64 v34":
-  image: fedora:34
-  stage: test
-  script:
-  - yum -y localinstall ./openrgb*64.rpm
-  - openrgb --version
-  - openrgb -l
-  - yum -y remove openrgb
-  dependencies:
-  - "Linux 64 rpm"
-  needs:
-  - "Linux 64 rpm"
-
-# #-----------------------------------------------------------------------#
-# # Ubuntu 64 18.04LTS test                                               #
-# #-----------------------------------------------------------------------#
-# "Ubuntu 64 18.04LTS":
-#   image: ubuntu:bionic
-#   stage: test
-#   script:
-#   - apt update
-#   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
-#   - openrgb --version
-#   - openrgb -l
-#   - apt remove -y openrgb
-#   dependencies:
-#   - "Linux 64 deb"
-#   needs:
-#   - "Linux 64 deb"
+  - "Linux 64 .deb (Debian Bullseye)"
 
 #-----------------------------------------------------------------------#
 # Ubuntu 64 20.04LTS test                                               #
@@ -328,15 +284,15 @@ before_script:
   - openrgb -l
   - apt remove -y openrgb
   dependencies:
-  - "Linux 64 deb"
+  - "Linux 64 .deb (Debian Buster)"
   needs:
-  - "Linux 64 deb"
+  - "Linux 64 .deb (Debian Buster)"
 
 #-----------------------------------------------------------------------#
-# Ubuntu 64 20.10 test                                                  #
+# Ubuntu 64 21.10 test                                                  #
 #-----------------------------------------------------------------------#
-"Ubuntu 64 20.10":
-  image: ubuntu:groovy
+"Ubuntu 64 21.10":
+  image: ubuntu:impish
   stage: test
   script:
   - apt update
@@ -345,26 +301,41 @@ before_script:
   - openrgb -l
   - apt remove -y openrgb
   dependencies:
-  - "Linux 64 deb"
+  - "Linux 64 .deb (Debian Bullseye)"
   needs:
-  - "Linux 64 deb"
+  - "Linux 64 .deb (Debian Bullseye)"
 
 #-----------------------------------------------------------------------#
-# Mint 64 20.1 test                                                     #
+# Fedora 64 v35 test                                                    #
 #-----------------------------------------------------------------------#
-"Mint 64 20.1":
-  image: linuxmintd/mint20.1-amd64
+"Fedora 64 v35":
+  image: fedora:35
   stage: test
   script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
+  - yum -y localinstall ./openrgb*64.rpm
   - openrgb --version
   - openrgb -l
-  - apt remove -y openrgb
+  - yum -y remove openrgb
   dependencies:
-  - "Linux 64 deb"
+  - "Linux 64 f35 rpm"
   needs:
-  - "Linux 64 deb"
+  - "Linux 64 f35 rpm"
+
+#-----------------------------------------------------------------------#
+# Fedora 64 v36 test                                                    #
+#-----------------------------------------------------------------------#
+"Fedora 64 v36":
+  image: fedora:36
+  stage: test
+  script:
+  - yum -y localinstall ./openrgb*64.rpm
+  - openrgb --version
+  - openrgb -l
+  - yum -y remove openrgb
+  dependencies:
+  - "Linux 64 f36 rpm"
+  needs:
+  - "Linux 64 f36 rpm"
 
 #-----------------------------------------------------------------------#
 # Windows (32-bit) Build Target                                         #
@@ -386,42 +357,42 @@ before_script:
   - '& 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://qt-mirror.dannhauer.de/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-base.7z  'https://qt-mirror.dannhauer.de/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://qt-mirror.dannhauer.de/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://qt-mirror.dannhauer.de/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_ 'Moving results for upload'
   - mv release ../'OpenRGB Windows 32-bit'
   - _fold_final_
@@ -455,42 +426,42 @@ before_script:
   - '& 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://qt-mirror.dannhauer.de/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-base.7z  'https://qt-mirror.dannhauer.de/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://qt-mirror.dannhauer.de/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://qt-mirror.dannhauer.de/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_ 'Moving results for upload'
   - mv release ../'OpenRGB Windows 64-bit'
   - _fold_final_

.gitlab/CODEOWNERS

@@ -0,0 +1,106 @@
+# OpenRGB CODEOWNERS
+
+# Default Code Owner
+* @Calcprogrammer1
+
+CODEOWNERS @Calcprogrammer1
+
+#-----------------------------------------------------------------------------#
+# Controllers - Directories                                                   #
+#-----------------------------------------------------------------------------#
+[Controllers]
+/Controllers/AMDWraithPrismController/
+/Controllers/ASRockPolychromeSMBusController/
+/Controllers/ASRockPolychromeUSBController/
+/Controllers/AlienwareController/
+/Controllers/AlienwareKeyboardController/
+/Controllers/AnnePro2Controller/
+/Controllers/AsusAuraCoreController/
+/Controllers/AsusAuraGPUController/
+/Controllers/AsusAuraUSBController/
+/Controllers/AsusTUFLaptopController/
+/Controllers/BlinkyTapeController/
+/Controllers/CoolerMasterController/                        @Dr_No
+/Controllers/CorsairCommanderCoreController/
+/Controllers/CorsairDominatorPlatinumController/
+/Controllers/CorsairHydroController/
+/Controllers/CorsairHydroPlatinumController/
+/Controllers/CorsairLightingNodeController/
+/Controllers/CorsairPeripheralController/
+/Controllers/CorsairVengeanceController/
+/Controllers/CorsairVengeanceProController/
+/Controllers/CorsairWirelessController/
+/Controllers/CreativeController/
+/Controllers/CrucialController/
+/Controllers/DasKeyboardController/
+/Controllers/DebugController/
+/Controllers/DuckyKeyboardController/
+/Controllers/DygmaRaiseController/
+/Controllers/E131Controller/
+/Controllers/EKController/                                  @Dr_No
+/Controllers/ENESMBusController/
+/Controllers/EVGAAmpereGPUController/                       @TheRogueZeta
+/Controllers/EVGAGP102GPUController/                        
+/Controllers/EVGAPascalGPUController/                       
+/Controllers/EVGATuringGPUController/                       @TheRogueZeta
+/Controllers/EVGAUSBController/                             @Dr_No
+/Controllers/EVisionKeyboardController/
+/Controllers/EspurnaController/
+/Controllers/FanBusController/
+/Controllers/FaustusController/
+/Controllers/GainwardGPUController/
+/Controllers/GalaxGPUController/
+/Controllers/GigabyteAorusCPUCoolerController/
+/Controllers/GigabyteRGBFusion2DRAMController/
+/Controllers/GigabyteRGBFusion2GPUController/
+/Controllers/GigabyteRGBFusion2SMBusController/             @Dr_No
+/Controllers/GigabyteRGBFusion2USBController/               @Dr_No
+/Controllers/GigabyteRGBFusionController/
+/Controllers/GigabyteRGBFusionGPUController/
+/Controllers/HPOmen30LController/
+/Controllers/HoltekController/
+/Controllers/HyperXDRAMController/
+/Controllers/HyperXKeyboardController/
+/Controllers/HyperXMouseController/
+/Controllers/HyperXMousematController/
+/Controllers/LEDStripController/
+/Controllers/LianLiController/
+/Controllers/LinuxLEDController/
+/Controllers/LogitechController/                            @Dr_No
+/Controllers/MSI3ZoneController/
+/Controllers/MSIGPUController/
+/Controllers/MSIMysticLightController/
+/Controllers/MSIRGBController/
+/Controllers/NZXTHue2Controller/
+/Controllers/NZXTHuePlusController/
+/Controllers/NZXTKrakenController/
+/Controllers/OpenRazerController/
+/Controllers/PNYGPUController/
+/Controllers/PatriotViperController/
+/Controllers/PhilipsHueController/
+/Controllers/PhilipsWizController/
+/Controllers/QMKOpenRGBController/
+/Controllers/RazerController/
+/Controllers/RedragonController/
+/Controllers/RoccatController/
+/Controllers/SapphireGPUController/
+/Controllers/SinowealthController/
+/Controllers/SonyDS4Controller/
+/Controllers/SteelSeriesController/
+/Controllers/TecknetController/
+/Controllers/ThermaltakePoseidonZRGBController/
+/Controllers/ThermaltakeRiingController/
+/Controllers/ThingMController/
+/Controllers/WootingKeyboardController/                     @Dr_No
+/Controllers/YeelightController/
+/Controllers/ZalmanZSyncController/
+
+#-----------------------------------------------------------------------------#
+# Controllers - File exceptions                                               #
+#                                                                             #
+#   As sections get combined and the last rule applies any specific file      #
+#   that is an exception to the above should be explicitly named here         #
+#-----------------------------------------------------------------------------#
+[Controllers]
+/Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.cpp            @TheRogueZeta
+/Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.h              @TheRogueZeta

.gitlab/issue_templates/Bug Report.md

@@ -1,6 +1,7 @@
 <!-- 
 Found a bug?  Something isn't working as expected?
 To help us keep track of the requests please start the title with [Bug Report]
+But before that, first you should check it out with the latest pipeline.
 -->
 
 ### Description of Bug
@@ -10,7 +11,20 @@ Explain any steps taken to reproduce the bug
 and what you expect the correct behavior to be.
 -->
 
+### Attached Log
+<!--
+Please attach a verbose log, you can do it by running the exe from cmd with '--loglevel 6' flag.
+You can locate them using the Settings tab and click the 'Open Settings Folder' button.
+Important!! Please upload the logs made with the latest pipeline build of OpenRGB.
+-->
 
+### Operating System
+<!--
+Please write down which OS and which version did you encounter the issue with.
+-->
+~"OS - Linux" 
+~"OS - MacOS" 
+~"OS - Windows" 
 ### Hardware Configuration
 <!--
 Please list the RGB hardware that you are using with OpenRGB.

.gitlab/merge_request_templates/New Device.md

@@ -0,0 +1,24 @@
+
+<!--
+Please put "Initial commit for" name of the product, including manufacturer above this line
+  and a description of the additions / removals / changes done below the line.
+-->
+
+
+
+
+<!-- For admin purposes: Please leave this section as is -->
+
+# Checklist for Accepting a Merge Request for a New Device
+- [ ] The `New Device` issue raised for this device is linked to this MR with a keyword `Closes / Resolves / Implements`
+- [ ] There is a device protocol page in the [Developer Wiki](https://gitlab.com/OpenRGBDevelopers/OpenRGB-Wiki) or there is enough information / captures in the `New Device` issue to provide ongoing support.
+- [ ] The code to be merged follows the style guide and change requirements as [documented in the contributing guide](https://gitlab.com/CalcProgrammer1/OpenRGB/-/blob/master/CONTRIBUTING.md).
+<!--
+The metadata for this controller is required to produce both the udev permissions and
+ the supported device page for this device. A stub can be found in the RGBController_Dummy.cpp
+-->
+- [ ] Meta data for the device is included in `RGBController_*` file
+- [ ] This device is detected and is working on Windows 10 and / or 11
+- [ ] This device is detected and is working on Linux (Please specify distribution and releases tested)
+- [ ] Logging for Info, Warnings and Errors has been added for troubleshooting purposes
+<!-- For admin purposes: Please leave this section as is -->

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "razer-drivers-win32"]
-	path = razer-drivers-win32
-	url = https://github.com/rsandoz/razer-drivers-win32

60-openrgb.rules

@@ -1,803 +0,0 @@
-#---------------------------------------------------------------#
-#  OpenRGB udev rules                                           #
-#                                                               #
-#   Adam Honse (CalcProgrammer1)                    5/29/2020   #
-#---------------------------------------------------------------#
-
-#---------------------------------------------------------------#
-#  User I2C/SMBus Access                                        #
-#---------------------------------------------------------------#
-KERNEL=="i2c-[0-99]*", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Super I/O Access                                             #
-#---------------------------------------------------------------#
-KERNEL=="port", 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"
-
-#---------------------------------------------------------------#
-#  ASRock Devices                                               #
-#                                                               #
-#   ASRock Polychrome USB                                       #
-#   ASRock Deskmini Addressable LED Strip                       #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="26CE", ATTR{idProduct}=="01A2", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="26CE", ATTR{idProduct}=="01A6", 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"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a5", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1939", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18af", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="193c", TAG+="uaccess"          #ROG Falchion Wired
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="193e", TAG+="uaccess"          #ROG Falchion Wireless
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1875", TAG+="uaccess"          #ROG Strix Flare
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18cf", TAG+="uaccess"          #ROG Strix Flare Pink
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18f8", TAG+="uaccess"          #ROG Strix Scope
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1951", TAG+="uaccess"          #ROG Strix Scope RX
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="190c", TAG+="uaccess"          #ROG Strix Scope TKL
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a0", TAG+="uaccess"          #TUF K7 Gaming
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18dd", TAG+="uaccess"          #ROG Gladius II Core
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1845", TAG+="uaccess"          #ROG Gladius II
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1877", TAG+="uaccess"          #ROG Gladius II Origin
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18cd", TAG+="uaccess"          #ROG Gladius II Origin Pink
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18b1", TAG+="uaccess"          #ROG Gladius II Origin COD
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="189e", TAG+="uaccess"          #ROG Gladius II Wireless1
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a0", TAG+="uaccess"          #ROG Gladius II Wireless2
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e5", TAG+="uaccess"          #ROG Chakram Wireless
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e3", TAG+="uaccess"          #ROG Chakram Wired1
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1958", TAG+="uaccess"          #ROG Chakram Wired2
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1846", TAG+="uaccess"          #ROG Pugio
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1906", TAG+="uaccess"          #ROG Pugio II Wired
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1908", TAG+="uaccess"          #ROG Pugio II Wireless
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e1", TAG+="uaccess"          #ROG Strix Impact II
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1910", TAG+="uaccess"          #TUF M3 & M7
-
-#---------------------------------------------------------------#
-#  ASUS TUF Laptops (faustus)                                   #
-#---------------------------------------------------------------#
-ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_blue"
-ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_flags"
-ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_green"
-ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_mode"
-ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_red"
-ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_set"
-ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_speed"
-
-#---------------------------------------------------------------#
-#  Cooler Master Peripheral Devices                             #
-#                                                               #
-#  Mice:                                                        #
-#       Cooler Master MM711                                     #
-#  Mousemats:                                                   #
-#       Cooler Master MP750                                     #
-#  Controllers:                                                 #
-#       ARGB Device                                             #
-#       Small ARGB Device                                       #
-#  Graphics Cards:                                              #
-#       Radeon RX6000 Series Reference Cards                    #
-#  Keyboards:                                                   #
-#       Masterkeys Pro L                                        #
-#       Masterkeys Pro L White                                  #
-#       Masterkeys Pro S                                        #
-#       Masterkeys MK750                                        #
-#       Masterkeys SK630                                        #
-#       Masterkeys SK650                                        #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0101", TAG+="uaccess"          #MM711
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0109", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0105", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="1011", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="1000", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="014d", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0047", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="003c", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0067", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0089", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="008d", 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 Hydro Platinum Series Devices                        #
-#                                                               #
-#       Corsair H100i Platinum RGB                              #
-#       Corsair H100i Platinum SE RGB                           #
-#       Corsair H115i Platinum RGB                              #
-#       Corsair H100i Pro XT RGB                                #
-#       Corsair H115i Pro XT RGB                                #
-#       Corsair H150i Pro XT RGB                                #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c18", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c19", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c17", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c20", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c21", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c22", 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}=="0c23", 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                                   #
-#       Corsair Glaive RGB                                      #
-#       Corsair Glaive RGB Pro                                  #
-#       Corsair Harpoon RGB                                     #
-#       Corsair Harpoon RGB Pro                                 #
-#       Corsair Scimitar Pro RGB                                #
-#       Corsair Sabre RGB                                       #
-#                                                               #
-#  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}=="1b34", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b74", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b3c", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b75", 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}=="1b3e", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b2f", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b3b", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0a34", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Corsair Wireless Devices                                     #
-#                                                               #
-#  Keyboards:                                                   #
-#        Corsair K57 RGB Wired                                  #
-#        Corsair K57 RGB Wireless                               #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b6e", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b62", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Creative Devices                                             #
-#                                                               #
-#  Devices:                                                     #
-#        Creative SoundblasterX G6                              #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="041e", ATTR{idProduct}=="3256", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Dell G Series Devices                                        #
-#                                                               #
-#                                                               #
-#  Controllers:                                                 #
-#       Dell G Series LED Controller                            #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="187c", ATTR{idProduct}=="0550", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Ducky Keyboard Devices                                       #
-#                                                               #
-#  Keyboards:                                                   #
-#        Ducky Shine 7 One 2 RGB                                #
-#        Ducky One 2 RGB TKL                                    #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="0348", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="0356", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  EK Controller Devices                                        #
-#                                                               #
-#  Controllers:                                                 #
-#        EK Loop Connect                                        #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0483", ATTR{idProduct}=="5750", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Holtek Devices                                               #
-#                                                               #
-#  Mice:                                                        #
-#        Holtek A070                                            #
-#  Mousemats:                                                   #
-#        Holtek A1FA                                            #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="a070", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="a1fa", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  HyperX Peripheral Devices                                    #
-#                                                               #
-#  Keyboards:                                                   #
-#       HyperX Alloy Elite                                      #
-#       HyperX Alloy Elite 2                                    #
-#       HyperX Alloy FPS RGB                                    #
-#       HyperX Alloy Origins                                    #
-#       HyperX Alloy Origins Core                               #
-#                                                               #
-#  Mice:                                                        #
-#       HyperX Pulsefire Surge                                  #
-#       HyperX Pulsefire FPS Pro                                #
-#       HyperX Pulsefire Dart Wireless                          #
-#       HyperX Pulsefire Dart Wired                             #
-#                                                               #
-#  Mousemats:                                                   #
-#       HyperX Fury Ultra                                       #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16be", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="1711", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16dc", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16e5", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16e6", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16d3", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16d7", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16e1", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16e2", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="1705", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Lian Li Uni Hub                                              #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0cf2", ATTR{idProduct}=="7750", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Logitech Peripheral Devices                                  #
-#                                                               #
-#   Keyboards:                                                  #
-#       Logitech G213                                           #
-#       Logitech G512                                           #
-#       Logitech G512 RGB                                       #
-#       Logitech G610 #1                                        #
-#       Logitech G610 #2                                        #
-#       Logitech G810 #1                                        #
-#       Logitech G810 #2                                        #
-#       Logitech G813                                           #
-#       Logitech G815                                           #
-#                                                               #
-#  Mice:                                                        #
-#       Logitech G203 Prodigy                                   #
-#       Logitech G203 Lightsync                                 #
-#       Logitech G303                                           #
-#       Logitech G403 Prodigy                                   #
-#       Logitech G403 Hero                                      #
-#       Logitech G502 Proteus Spectrum                          #
-#       Logitech G502 Hero                                      #
-#       Logitech G502 Wireless                                  #
-#       Logitech G703 Wireless                                  #
-#       Logitech G900 Wireless                                  #
-#       Logitech G903 Wireless                                  #
-#       Logitech G Lightspeed Wireless Gaming Mouse             #
-#       Logitech G Pro Wireless Gaming Mouse (Wired)            #
-#       Logitech G Pro Hero Gaming Mouse (Wired)                #
-#                                                               #
-#  Mousemats:                                                   #
-#       Logitech G Powerplay Mousepad with Lightspeed           #
-#                                                               #
-#  Speakers:                                                    #
-#       Logitech G560                                           #
-#                                                               #
-#  Headsets:                                                    #
-#       Logitech G933                                           #
-#                                                               #
-#  Joysticks:                                                   #
-#       Logitech Rhino X56 Hotas (Throttle and Stick)           #
-#                                                               #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c336", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c342", TAG+="uaccess"
-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}=="c338", 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}=="c232", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33f", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c335", TAG+="uaccess"          #G910
-
-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}=="c082", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="405d", 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}=="c08d", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="407f", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c087", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4070", TAG+="uaccess"          #G703 Virtual PID
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c081", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4053", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c086", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4067", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c539", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c085", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08c", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c088", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4079", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c53a", TAG+="uaccess"          #Powerplay Mat Reciever
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="405F", TAG+="uaccess"          #Powerplay Mat Virtual PID
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0a78", TAG+="uaccess"          #G560
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0a5b", TAG+="uaccess"          #G933
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0ab5", TAG+="uaccess"          #G733
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0738", ATTR{idProduct}=="2221", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0738", ATTR{idProduct}=="A221", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Metadot Das Keyboard 4Q + 5Q                                 #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="24f0", ATTR{idProduct}=="2037", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="24f0", ATTR{idProduct}=="2020", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  MSI Mysticlight                                              #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="3EA4", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="4459", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B10", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B12", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B17", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B85", 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}=="7D06", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7D09", 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 Hue 2 Ambient                                      #
-#       NZXT Motherboard                                        #
-#       NZXT Smart Device V2                                    #
-#       NZXT Kraken X3                                          #
-#       NZXT RGB Fan Controller                                 #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2001", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2002", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2005", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2006", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2007", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2009", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="200D", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  NZXT Kraken                                                  #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="170e", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="1715", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Razer Devices                                                #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0241", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0203", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0209", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0221", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0228", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0237", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0235", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0211", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0216", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="021A", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="020F", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0224", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0233", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="023B", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0240", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="023A", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0246", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0245", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="024D", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0253", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0255", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="026A", TAG+="uaccess"      # Razer Book 13 (2020)
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="026F", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0210", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0225", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="022F", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0234", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="024C", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0205", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0220", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="022D", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0232", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0239", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="024A", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0252", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0259", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="022A", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="023F", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="025E", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0204", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0226", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0227", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0257", TAG+="uaccess"      #Huntsman Mini
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0243", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0207", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="021E", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="025D", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0208", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="022B", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0020", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="005E", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006A", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006B", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0042", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="005B", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0062", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0064", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0065", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0086", TAG+="uaccess"          #Basilisk Ultimate
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0088", TAG+="uaccess"          #Basilisk Ultimate (Wireless)
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0083", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0083", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0085", TAG+="uaccess"          #Basilisk V2
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0038", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="004F", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0037", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0016", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0054", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0043", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="005C", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006E", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0071", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="008C", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0084", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007C", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007D", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="004C", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="002F", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0060", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0059", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="005A", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0070", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006F", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0024", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0025", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0044", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0045", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0073", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0072", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006C", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0046", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="002E", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0040", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0053", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="003F", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="003E", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0041", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0036", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0050", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0067", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0013", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0039", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0048", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0032", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0034", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="008A", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0078", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007A", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007B", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0506", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0501", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F19", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0504", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0527", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0510", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F03", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F08", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F20", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F26", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F1F", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F09", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F07", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F0E", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0215", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0068", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0C00", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0C04", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0C02", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0C01", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F1D", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007E", TAG+="uaccess"          #Razer Mouse Dock Chroma
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0517", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0518", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Roccat Devices                                               #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e7d", ATTR{idProduct}=="2e2c", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e7d", ATTR{idProduct}=="2e27", 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                                    #
-#       Redragon M716 Inquisitor                                #
-#---------------------------------------------------------------#
-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}=="fc3a", 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"
-
-#---------------------------------------------------------------#
-#  Sony Devices                                                 #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="054c", ATTR{idProduct}=="05c4", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="054c", ATTR{idProduct}=="09cc", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="054c", ATTR{idProduct}=="0ba0", 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                   #
-#       SteelSeries Rival 300 Blackops Edition                  #
-#       SteelSeries Rival 310                                   #
-#       SteelSeries Rival 310 CS:GO Howl Edition                #
-#       SteelSeries Rival 310 PubG Edition			#
-#	SteelSeries Rival 650 Wireless		                #
-#       SteelSeries Rival Sensei Ten                            #
-#       SteelSeries Rival Sensei Ten CS:GO Neon Rider           #
-#       SteelSeries Rival Sensei 310                            #
-#  Headsets:                                                    #
-#       SteelSeries Siberia 350                                 #
-#  Keyboards:                                                   #
-#       SteelSeries Apex 5                                      #
-#       SteelSeries Apex 7                                      #
-#       SteelSeries Apex 7 TKL                                  #
-#       SteelSeries Apex Pro                                    #
-#       SteelSeries Apex Pro TKL                                #
-#       SteelSeries Apex M750                                   #
-#       SteelSeries Apex OG                                     #
-#       SteelSeries Apex 350                                    #
-#  Mousemats:                                                   #
-#       SteelSeries QCK Prism Cloth                             #
-#---------------------------------------------------------------#
-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}=="1710", 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}=="1720", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="171e", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1736", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1832", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1834", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1722", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1726", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="172B", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1229", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="161c", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1612", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1618", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1610", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1614", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="0616", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1202", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1206", TAG+="uaccess"
-
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="150a", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="150d", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Tecknet Devices                                              #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="fc05", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Thermaltake Poseidon Z RGB Keyboard                          #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="3006", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Thermaltake Riing Controllers                                #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1FA[5-9]", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1FA[A-F]", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1FB[0-5]", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="226[0-3]", TAG+="uaccess"
-
-#---------------------------------------------------------------#
-#  Wooting Devices                                              #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="ff01", TAG+="uaccess"          #WootingOne
-SUBSYSTEMS=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="ff02", TAG+="uaccess"          #WootingTwo
-SUBSYSTEMS=="usb", ATTR{idVendor}=="31e3", ATTR{idProduct}=="1210", TAG+="uaccess"          #WootingTwo LE
-SUBSYSTEMS=="usb", ATTR{idVendor}=="31e3", ATTR{idProduct}=="1220", TAG+="uaccess"          #WootingTwo HE
-
-#---------------------------------------------------------------#
-#  Zalman ZSync Devices                                         #
-#---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1c57", ATTR{idProduct}=="7ed0", TAG+="uaccess"

AutoStart/AutoStart-FreeBSD.cpp

@@ -0,0 +1,174 @@
+#include "AutoStart-FreeBSD.h"
+#include "LogManager.h"
+#include "filesystem.h"
+
+#include <fstream>
+#include <iostream>
+#include <unistd.h>
+#include <sstream>
+
+/*-----------------------------------------------------*\
+| FreeBSD AutoStart Implementation                      |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
+
+AutoStart::AutoStart(std::string name)
+{
+    InitAutoStart(name);
+}
+
+bool AutoStart::DisableAutoStart()
+{
+    std::error_code autostart_file_remove_errcode;
+    bool            success                         = false;
+
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
+    if(autostart_file != "")
+    {
+        /*---------------------------------------------*\
+        | If file doesn't exist, disable is successful  |
+        \*---------------------------------------------*/
+        if(!filesystem::exists(autostart_file))
+        {
+            success = true;
+        }
+        /*---------------------------------------------*\
+        | Otherwise, delete the file                    |
+        \*---------------------------------------------*/
+        else
+        {
+            success = filesystem::remove(autostart_file, autostart_file_remove_errcode);
+
+            if(!success)
+            {
+                LOG_ERROR("[AutoStart] An error occurred removing the auto start file.");
+            }
+        }
+    }
+    else
+    {
+        LOG_ERROR("Could not establish correct autostart file path.");
+    }
+
+    return(success);
+}
+
+bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
+{
+    bool        success                             = false;
+
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
+    if(autostart_file != "")
+    {
+        std::ofstream   autostart_file_stream(autostart_file, std::ios::out | std::ios::trunc);
+
+        /*---------------------------------------------*\
+        | Error out if the file could not be opened     |
+        \*---------------------------------------------*/
+        if(!autostart_file_stream)
+        {
+            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
+            success = false;
+        }
+        /*---------------------------------------------*\
+        | Otherwise, write the file                     |
+        \*---------------------------------------------*/
+        else
+        {
+            //autostart_file_stream << desktop_file;
+            autostart_file_stream.close();
+            success = !autostart_file_stream.fail();
+
+            if (!success)
+            {
+                LOG_ERROR("An error occurred writing the auto start file.");
+            }
+        }
+    }
+    else
+    {
+        LOG_ERROR("Could not establish correct autostart file path.");
+    }
+
+    return(success);
+}
+
+bool AutoStart::IsAutoStartEnabled()
+{
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
+    if(autostart_file != "")
+    {
+        return(filesystem::exists(autostart_file));
+    }
+    else
+    {
+        return(false);
+    }
+}
+
+std::string AutoStart::GetExePath()
+{
+    /*-------------------------------------------------*\
+    | Create the OpenRGB executable path                |
+    \*-------------------------------------------------*/
+    char exepath[ PATH_MAX ];
+
+    ssize_t count = readlink("/proc/self/exe", exepath, PATH_MAX);
+    
+    return(std::string(exepath, (count > 0) ? count : 0));
+}
+
+void AutoStart::InitAutoStart(std::string name)
+{
+    std::string autostart_dir;
+
+    autostart_name = name;
+
+    /*-------------------------------------------------*\
+    | Get home and config paths                         |
+    \*-------------------------------------------------*/
+    const char *xdg_config_home = getenv("XDG_CONFIG_HOME");
+    const char *home = getenv("HOME");
+
+    /*-------------------------------------------------*\
+    | Determine where the autostart .desktop files are  |
+    | kept                                              |
+    \*-------------------------------------------------*/
+    if(xdg_config_home != NULL)
+    {
+        autostart_dir = xdg_config_home;
+        autostart_dir = autostart_dir + "/autostart/";
+    }
+    else if(home != NULL)
+    {
+        autostart_dir = home;
+        autostart_dir = autostart_dir + "/.config/autostart/";
+    }
+
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
+    if(autostart_dir != "")
+    {
+        std::error_code ec;
+
+        bool success = true;
+        
+        if(!filesystem::exists(autostart_dir))
+        {
+            success = filesystem::create_directories(autostart_dir, ec);
+        }
+
+        if(success)
+        {
+            autostart_file = autostart_dir + autostart_name + ".desktop";
+        }
+    }
+}
+

AutoStart/AutoStart-FreeBSD.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <string>
+#include "AutoStart.h"
+
+class AutoStart: public AutoStartInterface
+{
+public:
+    AutoStart(std::string name);
+
+    bool            DisableAutoStart();
+    bool            EnableAutoStart(AutoStartInfo autostart_info);
+    bool            IsAutoStartEnabled();
+    std::string     GetExePath();
+
+private:
+    void            InitAutoStart(std::string name);
+    std::string     GenerateLaunchAgentFile(AutoStartInfo autostart_info);
+};

AutoStart/AutoStart-Windows.cpp

@@ -83,7 +83,7 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
         if(result == CO_E_NOTINITIALIZED)
         {
             weInitialised                           = true;
-            CoInitializeEx(NULL, COINIT_MULTITHREADED);
+            CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
             result                                  = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_ALL, IID_IShellLinkW, (void**)&shellLink);
         }
 

AutoStart/AutoStart.h

@@ -37,4 +37,8 @@ protected:
 
 #ifdef __APPLE__
 #include "AutoStart-MacOS.h"
-#endif
+#endif
+
+#ifdef __FreeBSD__
+#include "AutoStart-FreeBSD.h"
+#endif

CONTRIBUTING.md

@@ -0,0 +1,58 @@
+# Contributing to OpenRGB
+
+The OpenRGB project welcomes contributions from the community.  The project would not support the number of devices it does today without the amazing contributions from community developers.  If you want to add a new device, fix a bug, or add a feature, feel free to open a merge request on the OpenRGB GitLab (https://gitlab.com/CalcProgrammer1/OpenRGB).
+
+## Creating a Merge Request
+
+To create a merge request, log into GitLab and fork the OpenRGB project.  Push your changes to your fork and then use the Create Merge Request option.  Before opening a merge request, please review the following best practices to help your merge request get merged without excessive delay.
+
+* Please keep the scope of each merge request limited to one functional area.  If you wish to add a new device controller, for instance, don't also do code cleanup in another controller as part of the same merge request.
+* Explain what your merge request is changing, why you feel the change is necessary, and add any additional information you feel is needed to best understand your change in the merge request description.
+* Mark your merge request as a draft (start title with "Draft:") until it has been tested and verified working.
+* Follow the Style Guidelines below when making your code changes.
+* Avoid using `git merge` when updating your fork.  The OpenRGB project uses a linear git history, meaning all changes are rebased onto the tip of master.  By using `git rebase` to update your fork, you will make it easier to accept merge requests.
+
+## Style Guidelines
+
+OpenRGB is written in C++, uses the Qt framework for UI, and uses the QMake build system.  While OpenRGB does use C++, I am primarily a C programmer and prefer doing things "C Style" vs. C++ style.  C++'s object oriented programming features fit the needs of a program such as OpenRGB where there are many implementations of a single interface so I chose to write it in C++ over C.  Still, however, I prefer using C-style code where possible.  When making changes to existing code files, try to follow the existing style.  Merge requests that go out of their way to restyle code will not be accepted and will be sent back for rework.
+
+### Functional Style
+
+* Limit use of C++ std library data types
+    * For fixed-length containers, use C arrays
+    * For list constants, use const C arrays
+    * For fixed-length strings, use C char buffers ("C strings"), though using std::string is acceptable if the value will be placed in a std::string
+    * For basic types, prefer using the non-typedef'd basic types (char, short, int, etc) over typedef'd (uint8_t, uint16_t, uint32_t, etc)
+        * Unless defined in an OpenRGB API or the file is implementing an existing API using these types (such as i2c_smbus)
+    * For hard-coded values, use `#define`s over const variables unless you need a pointer to the value
+    * For variable-length containers, use std::vector
+    * For variable-length strings, use std::string
+    * `struct` should not include any functions, only variables
+    * `class` should only be used for objects containing functions
+    * Other std types may be used sparingly if necessary
+* Only use Qt libraries, types, and functionality in user interface files
+    * Anything under the qt/ folder basically
+    * Do not use QDebug, use our LogManager instead.  If you use QDebug during development, please remove it before submitting your merge request
+* Use C-style indexed for loops when iterating through an array or vector
+* Use C-style casts unless necessary
+* Avoid the `auto` type.  It makes code more difficult to read
+* Do not use `printf` or `cout` for debug messages, use LogManager instead
+* Don't define namespaces unless necessary
+
+### Non-functional Style
+
+* Set your editor's tab settings to insert spaces, using 4 spaces per tab stop
+* Always put opening and closing braces `{`, `}` on their own lines
+* Indent code inside the braces, do not indent the braces themselves
+* Capitalize hexadecimal literals (`0xFF` not `0xff`) except in the udev rules file (which must be lowercase to work)
+* No space between keyword and open parenthesis (`if(TRUE)` not `if (TRUE)`).  There are some instances of this that haven't been cleaned up in the code.
+* Generally, `snake_case` is used for variable names and `CamelCase` is used for function and class names
+* Add a header comment to new files with the filename, description, original author, and date (this is missing on most Detect files)
+* Line up `=` when doing a lot of assignments together
+* Use this comment box style when adding comments:
+
+```
+/*--------------------------------*\
+| This is a comment                |
+\*_-------------------------------*/
+```

Colors.h

@@ -0,0 +1,153 @@
+#ifndef COLORS_H
+#define COLORS_H
+
+#define COLOR_BLACK 0x000000
+#define COLOR_NAVY 0x000080
+#define COLOR_DARKBLUE 0x00008b
+#define COLOR_MEDIUMBLUE 0x0000cd
+#define COLOR_BLUE 0x0000ff
+#define COLOR_DARKGREEN 0x006400
+#define COLOR_GREEN 0x008000
+#define COLOR_TEAL 0x008080
+#define COLOR_DARKCYAN 0x008b8b
+#define COLOR_DEEPSKYBLUE 0x00bfff
+#define COLOR_DARKTURQUOISE 0x00ced1
+#define COLOR_MEDIUMSPRINGGREEN 0x00fa9a
+#define COLOR_LIME 0x00ff00
+#define COLOR_SPRINGGREEN 0x00ff7f
+#define COLOR_AQUA 0x00ffff
+#define COLOR_CYAN 0x00ffff
+#define COLOR_MIDNIGHTBLUE 0x191970
+#define COLOR_DODGERBLUE 0x1e90ff
+#define COLOR_LIGHTSEAGREEN 0x20b2aa
+#define COLOR_FORESTGREEN 0x228b22
+#define COLOR_SEAGREEN 0x2e8b57
+#define COLOR_DARKSLATEGRAY 0x2f4f4f
+#define COLOR_DARKSLATEGREY 0x2f4f4f
+#define COLOR_LIMEGREEN 0x32cd32
+#define COLOR_MEDIUMSEAGREEN 0x3cb371
+#define COLOR_TURQUOISE 0x40e0d0
+#define COLOR_ROYALBLUE 0x4169e1
+#define COLOR_STEELBLUE 0x4682b4
+#define COLOR_DARKSLATEBLUE 0x483d8b
+#define COLOR_MEDIUMTURQUOISE 0x48d1cc
+#define COLOR_INDIGO 0x4b0082
+#define COLOR_DARKOLIVEGREEN 0x556b2f
+#define COLOR_CADETBLUE 0x5f9ea0
+#define COLOR_CORNFLOWERBLUE 0x6495ed
+#define COLOR_MEDIUMAQUAMARINE 0x66cdaa
+#define COLOR_DIMGRAY 0x696969
+#define COLOR_DIMGREY 0x696969
+#define COLOR_SLATEBLUE 0x6a5acd
+#define COLOR_OLIVEDRAB 0x6b8e23
+#define COLOR_SLATEGRAY 0x708090
+#define COLOR_SLATEGREY 0x708090
+#define COLOR_LIGHTSLATEGRAY 0x778899
+#define COLOR_LIGHTSLATEGREY 0x778899
+#define COLOR_MEDIUMSLATEBLUE 0x7b68ee
+#define COLOR_LAWNGREEN 0x7cfc00
+#define COLOR_CHARTREUSE 0x7fff00
+#define COLOR_AQUAMARINE 0x7fffd4
+#define COLOR_MAROON 0x800000
+#define COLOR_PURPLE 0x800080
+#define COLOR_ELECTRIC_ULTRAMARINE 0x4000FF
+#define COLOR_OLIVE 0x808000
+#define COLOR_GRAY 0x808080
+#define COLOR_GREY 0x808080
+#define COLOR_SKYBLUE 0x87ceeb
+#define COLOR_LIGHTSKYBLUE 0x87cefa
+#define COLOR_BLUEVIOLET 0x8a2be2
+#define COLOR_DARKRED 0x8b0000
+#define COLOR_DARKMAGENTA 0x8b008b
+#define COLOR_SADDLEBROWN 0x8b4513
+#define COLOR_DARKSEAGREEN 0x8fbc8f
+#define COLOR_LIGHTGREEN 0x90ee90
+#define COLOR_MEDIUMPURPLE 0x9370db
+#define COLOR_DARKVIOLET 0x9400d3
+#define COLOR_PALEGREEN 0x98fb98
+#define COLOR_DARKORCHID 0x9932cc
+#define COLOR_YELLOWGREEN 0x9acd32
+#define COLOR_SIENNA 0xa0522d
+#define COLOR_BROWN 0xa52a2a
+#define COLOR_DARKGRAY 0xa9a9a9
+#define COLOR_DARKGREY 0xa9a9a9
+#define COLOR_LIGHTBLUE 0xadd8e6
+#define COLOR_GREENYELLOW 0xadff2f
+#define COLOR_PALETURQUOISE 0xafeeee
+#define COLOR_LIGHTSTEELBLUE 0xb0c4de
+#define COLOR_POWDERBLUE 0xb0e0e6
+#define COLOR_FIREBRICK 0xb22222
+#define COLOR_DARKGOLDENROD 0xb8860b
+#define COLOR_MEDIUMORCHID 0xba55d3
+#define COLOR_ROSYBROWN 0xbc8f8f
+#define COLOR_DARKKHAKI 0xbdb76b
+#define COLOR_SILVER 0xc0c0c0
+#define COLOR_MEDIUMVIOLETRED 0xc71585
+#define COLOR_INDIANRED 0xcd5c5c
+#define COLOR_PERU 0xcd853f
+#define COLOR_CHOCOLATE 0xd2691e
+#define COLOR_TAN 0xd2b48c
+#define COLOR_LIGHTGRAY 0xd3d3d3
+#define COLOR_LIGHTGREY 0xd3d3d3
+#define COLOR_THISTLE 0xd8bfd8
+#define COLOR_ORCHID 0xda70d6
+#define COLOR_GOLDENROD 0xdaa520
+#define COLOR_PALEVIOLETRED 0xdb7093
+#define COLOR_CRIMSON 0xdc143c
+#define COLOR_GAINSBORO 0xdcdcdc
+#define COLOR_PLUM 0xdda0dd
+#define COLOR_BURLYWOOD 0xdeb887
+#define COLOR_LIGHTCYAN 0xe0ffff
+#define COLOR_LAVENDER 0xe6e6fa
+#define COLOR_DARKSALMON 0xe9967a
+#define COLOR_VIOLET 0xee82ee
+#define COLOR_PALEGOLDENROD 0xeee8aa
+#define COLOR_LIGHTCORAL 0xf08080
+#define COLOR_KHAKI 0xf0e68c
+#define COLOR_ALICEBLUE 0xf0f8ff
+#define COLOR_HONEYDEW 0xf0fff0
+#define COLOR_AZURE 0xf0ffff
+#define COLOR_SANDYBROWN 0xf4a460
+#define COLOR_WHEAT 0xf5deb3
+#define COLOR_BEIGE 0xf5f5dc
+#define COLOR_WHITESMOKE 0xf5f5f5
+#define COLOR_MINTCREAM 0xf5fffa
+#define COLOR_GHOSTWHITE 0xf8f8ff
+#define COLOR_SALMON 0xfa8072
+#define COLOR_ANTIQUEWHITE 0xfaebd7
+#define COLOR_LINEN 0xfaf0e6
+#define COLOR_LIGHTGOLDENRODYELLOW 0xfafad2
+#define COLOR_OLDLACE 0xfdf5e6
+#define COLOR_RED 0xff0000
+#define COLOR_FUCHSIA 0xff00ff
+#define COLOR_MAGENTA 0xff00ff
+#define COLOR_DEEPPINK 0xff1493
+#define COLOR_ORANGERED 0xff4500
+#define COLOR_TOMATO 0xff6347
+#define COLOR_HOTPINK 0xff69b4
+#define COLOR_CORAL 0xff7f50
+#define COLOR_DARKORANGE 0xff8c00
+#define COLOR_LIGHTSALMON 0xffa07a
+#define COLOR_ORANGE 0xffa500
+#define COLOR_LIGHTPINK 0xffb6c1
+#define COLOR_PINK 0xffc0cb
+#define COLOR_GOLD 0xffd700
+#define COLOR_PEACHPUFF 0xffdab9
+#define COLOR_NAVAJOWHITE 0xffdead
+#define COLOR_MOCCASIN 0xffe4b5
+#define COLOR_BISQUE 0xffe4c4
+#define COLOR_MISTYROSE 0xffe4e1
+#define COLOR_BLANCHEDALMOND 0xffebcd
+#define COLOR_PAPAYAWHIP 0xffefd5
+#define COLOR_LAVENDERBLUSH 0xfff0f5
+#define COLOR_SEASHELL 0xfff5ee
+#define COLOR_CORNSILK 0xfff8dc
+#define COLOR_LEMONCHIFFON 0xfffacd
+#define COLOR_FLORALWHITE 0xfffaf0
+#define COLOR_SNOW 0xfffafa
+#define COLOR_YELLOW 0xffff00
+#define COLOR_LIGHTYELLOW 0xffffe0
+#define COLOR_IVORY 0xfffff0
+#define COLOR_WHITE 0xffffff
+
+#endif // COLORS_H

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -19,17 +19,20 @@ AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const
 
     strcpy(device_name, "AMD Wraith Prism");
 
-    current_fan_mode = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
-    current_fan_speed = 0xFF;
-    current_fan_random_color = false;
+    current_fan_mode            = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
+    current_fan_speed           = 0xFF;
+    current_fan_random_color    = false;
+    current_fan_brightness      = 0xFF;
 
-    current_logo_mode = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
-    current_logo_speed = 0xFF;
-    current_logo_random_color = false;
+    current_logo_mode           = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
+    current_logo_speed          = 0xFF;
+    current_logo_random_color   = false;
+    current_logo_brightness     = 0xFF;
 
-    current_ring_mode = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
-    current_ring_speed = 0xFF;
-    current_ring_direction = false;
+    current_ring_mode           = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
+    current_ring_speed          = 0xFF;
+    current_ring_direction      = false;
+    current_ring_brightness     = 0xFF;
 
     SendEnableCommand();
 }
@@ -147,10 +150,11 @@ std::string AMDWraithPrismController::GetFirmwareVersionString()
     return(ret_string);
 }
 
-void AMDWraithPrismController::SetFanMode(unsigned char mode, unsigned char speed, bool random_color)
+void AMDWraithPrismController::SetFanMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color)
 {
     current_fan_mode            = mode;
     current_fan_speed           = speed_values_fan_logo[mode][speed];
+    current_fan_brightness      = brightness;
     current_fan_random_color    = random_color;
 }
 
@@ -163,17 +167,18 @@ void AMDWraithPrismController::SetFanColor(unsigned char red, unsigned char gree
         false,
         current_fan_random_color,
         current_fan_mode,
-        max_brightness_fan_logo[current_fan_mode],
+        current_fan_brightness,
         red,
         green,
         blue
     );
 }
 
-void AMDWraithPrismController::SetLogoMode(unsigned char mode, unsigned char speed, bool random_color)
+void AMDWraithPrismController::SetLogoMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color)
 {
     current_logo_mode           = mode;
     current_logo_speed          = speed_values_fan_logo[mode][speed];
+    current_logo_brightness     = brightness;
     current_logo_random_color   = random_color;
 }
 
@@ -186,18 +191,19 @@ void AMDWraithPrismController::SetLogoColor(unsigned char red, unsigned char gre
         false,
         current_logo_random_color,
         current_logo_mode,
-        max_brightness_fan_logo[current_logo_mode],
+        current_logo_brightness,
         red,
         green,
         blue
     );
 }
 
-void AMDWraithPrismController::SetRingMode(unsigned char mode, unsigned char speed, bool direction, bool random_color)
+void AMDWraithPrismController::SetRingMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool direction, bool random_color)
 {
     current_ring_mode           = mode;
     current_ring_speed          = speed_values_ring[mode][speed];
     current_ring_direction      = direction;
+    current_ring_brightness     = brightness;
     current_ring_random_color   = random_color;
 }
 
@@ -212,7 +218,7 @@ void AMDWraithPrismController::SetRingColor(unsigned char red, unsigned char gre
         current_ring_direction,
         current_ring_random_color,
         mode_value_ring[current_ring_mode],
-        max_brightness_ring[current_ring_mode],
+        current_ring_brightness,
         red,
         green,
         blue

Controllers/AMDWraithPrismController/AMDWraithPrismController.h

@@ -12,13 +12,8 @@
 
 #pragma once
 
-static const unsigned char max_brightness_fan_logo[] =
-{
-    0x00,
-    0xFF,
-    0x7F,
-    0xFF
-};
+#define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX     0xFF
+#define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_CYCLE_MAX       0x7F
 
 static const unsigned char speed_values_fan_logo[][5] =
 {
@@ -28,22 +23,6 @@ static const unsigned char speed_values_fan_logo[][5] =
     { 0x3C, 0x37, 0x31, 0x2C, 0x26 },                  /* Breathing                    */
 };
 
-static const unsigned char max_brightness_ring[] =
-{
-    0xFF,
-    0xFF,
-    0x7F,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0xFF,
-    0xFF,
-    0xFF,
-    0xFF,
-    0xFF
-};
-
 static const unsigned char mode_value_ring[] =
 {
     0xFF,
@@ -121,13 +100,13 @@ public:
 
     void SetRingEffectChannel(unsigned char channel);
 
-    void SetFanMode(unsigned char mode, unsigned char speed, bool random_color);
+    void SetFanMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
     void SetFanColor(unsigned char red, unsigned char green, unsigned char blue);
 
-    void SetLogoMode(unsigned char mode, unsigned char speed, bool random_color);
+    void SetLogoMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
     void SetLogoColor(unsigned char red, unsigned char green, unsigned char blue);
 
-    void SetRingMode(unsigned char mode, unsigned char speed, bool direction, bool random_color);
+    void SetRingMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool direction, bool random_color);
     void SetRingColor(unsigned char red, unsigned char green, unsigned char blue);
 
 private:
@@ -137,14 +116,17 @@ private:
 
     unsigned char           current_fan_mode;
     unsigned char           current_fan_speed;
+    unsigned char           current_fan_brightness;
     bool                    current_fan_random_color;
 
     unsigned char           current_logo_mode;
     unsigned char           current_logo_speed;
+    unsigned char           current_logo_brightness;
     bool                    current_logo_random_color;
 
     unsigned char           current_ring_mode;
     unsigned char           current_ring_speed;
+    unsigned char           current_ring_brightness;
     bool                    current_ring_direction;
     bool                    current_ring_random_color;
 

Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp

@@ -20,7 +20,7 @@ void DetectAMDWraithPrismControllers(hid_device_info* info, const std::string&)
     hid_device* dev = hid_open_path(info->path);
     if( dev )
     {
-        AMDWraithPrismController* controller = new AMDWraithPrismController(dev, info->path);
+        AMDWraithPrismController*     controller     = new AMDWraithPrismController(dev, info->path);
         RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
         // Constructor sets the name
         ResourceManager::get()->RegisterRGBController(rgb_controller);

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

@@ -9,87 +9,121 @@
 
 #include "RGBController_AMDWraithPrism.h"
 
-RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismController* wraith_ptr)
+/**------------------------------------------------------------------*\
+    @name AMD Wraith Prism
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :warning:
+    @detectors DetectAMDWraithPrismControllers
+    @comment The Wraith Prism comes with 2 cables but is only detectable
+        and controlable when using the USB cable. `Morse Code` and `Mirage`
+        modes have not been implemented. Saving to flash is supported by
+        the device but not yet implemented.
+\*-------------------------------------------------------------------*/
+
+RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismController* controller_ptr)
 {
-    wraith = wraith_ptr;
+    controller  = controller_ptr;
 
     name        = "AMD Wraith Prism";
     vendor      = "Cooler Master";
     type        = DEVICE_TYPE_COOLER;
     description = "AMD Wraith Prism Device";
-    version     = wraith->GetFirmwareVersionString();
-    location    = wraith->GetLocationString();
+    version     = controller->GetFirmwareVersionString();
+    location    = controller->GetLocationString();
     /*-----------------------------------------------------*\
     | Don't use HID serial string, it is inconsistent on my |
     | Wraith Prism                                          |
     \*-----------------------------------------------------*/
-    serial      = "";//wraith->GetSerialString();
+    serial      = "";//controller->GetSerialString();
 
     mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name                 = "Direct";
+    Direct.value                = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.brightness_min       = 0;
+    Direct.brightness_max       = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Direct.brightness           = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Breathing.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Breathing.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Breathing.color_mode = MODE_COLORS_PER_LED;
-    Breathing.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Breathing.name              = "Breathing";
+    Breathing.value             = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.speed_min         = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Breathing.speed_max         = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Breathing.brightness_min    = 0;
+    Breathing.brightness_max    = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Breathing.brightness        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Breathing.color_mode        = MODE_COLORS_PER_LED;
+    Breathing.speed             = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(Breathing);
 
     mode ColorCycle;
-    ColorCycle.name       = "Color Cycle";
-    ColorCycle.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE;
-    ColorCycle.flags      = MODE_FLAG_HAS_SPEED;
-    ColorCycle.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    ColorCycle.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    ColorCycle.color_mode = MODE_COLORS_NONE;
-    ColorCycle.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    ColorCycle.name             = "Color Cycle";
+    ColorCycle.value            = AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE;
+    ColorCycle.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    ColorCycle.speed_min        = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    ColorCycle.speed_max        = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    ColorCycle.brightness_min   = 0;
+    ColorCycle.brightness_max   = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_CYCLE_MAX;
+    ColorCycle.brightness       = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_CYCLE_MAX;
+    ColorCycle.color_mode       = MODE_COLORS_NONE;
+    ColorCycle.speed            = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(ColorCycle);
 
     mode Rainbow;
-    Rainbow.name       = "Rainbow";
-    Rainbow.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW;
-    Rainbow.flags      = MODE_FLAG_HAS_SPEED;
-    Rainbow.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Rainbow.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Rainbow.color_mode = MODE_COLORS_NONE;
-    Rainbow.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Rainbow.name                = "Rainbow";
+    Rainbow.value               = AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW;
+    Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Rainbow.speed_min           = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Rainbow.speed_max           = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Rainbow.brightness_min      = 0;
+    Rainbow.brightness_max      = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Rainbow.brightness          = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;    //The Ring zone can not get brighter but Logo / Fan can
+    Rainbow.color_mode          = MODE_COLORS_NONE;
+    Rainbow.speed               = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(Rainbow);
 
     mode Bounce;
-    Bounce.name       = "Bounce";
-    Bounce.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE;
-    Bounce.flags      = MODE_FLAG_HAS_SPEED;
-    Bounce.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Bounce.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Bounce.color_mode = MODE_COLORS_NONE;
-    Bounce.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Bounce.name                 = "Bounce";
+    Bounce.value                = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE;
+    Bounce.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Bounce.speed_min            = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Bounce.speed_max            = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Bounce.brightness_min       = 0;
+    Bounce.brightness_max       = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Bounce.brightness           = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;    //The Ring zone can not get brighter but Logo / Fan can
+    Bounce.color_mode           = MODE_COLORS_NONE;
+    Bounce.speed                = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(Bounce);
 
     mode Chase;
-    Chase.name       = "Chase";
-    Chase.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE;
-    Chase.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Chase.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Chase.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Chase.color_mode = MODE_COLORS_PER_LED;
-    Chase.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Chase.name                  = "Chase";
+    Chase.value                 = AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE;
+    Chase.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Chase.speed_min             = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Chase.speed_max             = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Chase.brightness_min        = 0;
+    Chase.brightness_max        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Chase.brightness            = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Chase.color_mode            = MODE_COLORS_PER_LED;
+    Chase.speed                 = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(Chase);
 
     mode Swirl;
-    Swirl.name       = "Swirl";
-    Swirl.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL;
-    Swirl.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Swirl.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Swirl.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Swirl.color_mode = MODE_COLORS_PER_LED;
-    Swirl.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Swirl.name                  = "Swirl";
+    Swirl.value                 = AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL;
+    Swirl.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Swirl.speed_min             = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Swirl.speed_max             = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Swirl.brightness_min        = 0;
+    Swirl.brightness_max        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Swirl.brightness            = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Swirl.color_mode            = MODE_COLORS_PER_LED;
+    Swirl.speed                 = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(Swirl);
 
     SetupZones();
@@ -97,7 +131,7 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
 
 RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
 {
-    delete wraith;
+    delete controller;
 }
 
 void RGBController_AMDWraithPrism::SetupZones()
@@ -162,17 +196,17 @@ void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
     unsigned char red = RGBGetRValue(colors[0]);
     unsigned char grn = RGBGetGValue(colors[0]);
     unsigned char blu = RGBGetBValue(colors[0]);
-    wraith->SetLogoColor(red, grn, blu);
+    controller->SetLogoColor(red, grn, blu);
 
     red = RGBGetRValue(colors[1]);
     grn = RGBGetGValue(colors[1]);
     blu = RGBGetBValue(colors[1]);
-    wraith->SetFanColor(red, grn, blu);
+    controller->SetFanColor(red, grn, blu);
 
     red = RGBGetRValue(colors[2]);
     grn = RGBGetGValue(colors[2]);
     blu = RGBGetBValue(colors[2]);
-    wraith->SetRingColor(red, grn, blu);
+    controller->SetRingColor(red, grn, blu);
 }
 
 void RGBController_AMDWraithPrism::UpdateZoneLEDs(int zone)
@@ -184,15 +218,15 @@ void RGBController_AMDWraithPrism::UpdateZoneLEDs(int zone)
 
     if(zone == 0)
     {
-        wraith->SetLogoColor(red, grn, blu);
+        controller->SetLogoColor(red, grn, blu);
     }
     else if(zone == 1)
     {
-        wraith->SetFanColor(red, grn, blu);
+        controller->SetFanColor(red, grn, blu);
     }
     else if(zone == 2)
     {
-        wraith->SetRingColor(red, grn, blu);
+        controller->SetRingColor(red, grn, blu);
     }
 }
 
@@ -210,32 +244,36 @@ void RGBController_AMDWraithPrism::DeviceUpdateMode()
 {
     bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
 
-    wraith->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].direction, random);
+    controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
 
     switch(modes[active_mode].value)
     {
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE:
+            controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
+            controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
+            break;
+
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW:
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE:
-            wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, random);
-            wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, random);
+            controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
+            controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
             break;
         
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING:
-            wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, random);
-            wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, random);
+            controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);
+            controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);
             break;
 
         default:
             if(random)
             {
-                wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, random);
-                wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, random);
+                controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
+                controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
             }
             else
             {
-                wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, random);
-                wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, random);
+                controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].brightness, random);
+                controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].brightness, random);
             }
             break;
     }

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.h

@@ -1,33 +1,33 @@
-/*-----------------------------------------*\
-|  RGBController_AMDWraithPrism.h           |
-|                                           |
-|  Generic RGB Interface for AMD Wraith     |
-|  Prism                                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/25/2019  |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AMDWraithPrismController.h"
-
-class RGBController_AMDWraithPrism : public RGBController
-{
-public:
-    RGBController_AMDWraithPrism(AMDWraithPrismController* wraith_ptr);
-    ~RGBController_AMDWraithPrism();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    AMDWraithPrismController*   wraith;
-};
+/*-----------------------------------------*\
+|  RGBController_AMDWraithPrism.h           |
+|                                           |
+|  Generic RGB Interface for AMD Wraith     |
+|  Prism                                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AMDWraithPrismController.h"
+
+class RGBController_AMDWraithPrism : public RGBController
+{
+public:
+    RGBController_AMDWraithPrism(AMDWraithPrismController* controller_ptr);
+    ~RGBController_AMDWraithPrism();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    AMDWraithPrismController*   controller;
+};

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.cpp

@@ -12,6 +12,8 @@
 #include "dependencies/dmiinfo.h"
 #include "LogManager.h"
 
+#define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"
+
 using namespace std::chrono_literals;
 
 PolychromeController::PolychromeController(i2c_smbus_interface* bus, polychrome_dev_id dev)
@@ -35,25 +37,25 @@ PolychromeController::PolychromeController(i2c_smbus_interface* bus, polychrome_
     switch(major_version)
     {
         case ASROCK_TYPE_ASRLED:
-            LOG_TRACE("%s Device type is ASR RGB LED", ASROCK_CONTROLLER_NAME);
+            LOG_TRACE("[%s] Device type is ASR RGB LED", ASROCK_CONTROLLER_NAME);
             asrock_type = ASROCK_TYPE_ASRLED;
             memset(zone_led_count, 0, sizeof(zone_led_count));
             break;
 
         case ASROCK_TYPE_POLYCHROME_V1:
-            LOG_TRACE("%s Device type is Polychrome v1", ASROCK_CONTROLLER_NAME);
+            LOG_TRACE("[%s] Device type is Polychrome v1", ASROCK_CONTROLLER_NAME);
             asrock_type = ASROCK_TYPE_POLYCHROME_V1;
             ReadLEDConfiguration();
             break;
 
         case ASROCK_TYPE_POLYCHROME_V2:
-            LOG_TRACE("%s Device type is Polychrome v2", ASROCK_CONTROLLER_NAME);
+            LOG_TRACE("[%s] Device type is Polychrome v2", ASROCK_CONTROLLER_NAME);
             asrock_type = ASROCK_TYPE_POLYCHROME_V2;
             ReadLEDConfiguration();
             break;
 
         default:
-            LOG_TRACE("%s Got Unknown version!", ASROCK_CONTROLLER_NAME);
+            LOG_TRACE("[%s] Got Unknown version!", ASROCK_CONTROLLER_NAME);
             asrock_type = ASROCK_TYPE_UNKNOWN;
             break;
     }
@@ -96,7 +98,7 @@ unsigned short PolychromeController::ReadFirmwareVersion()
 {
     // The firmware register holds two bytes, so the first read should return 2
     // If not, report invalid firmware revision FFFF
-    LOG_DEBUG("%s Reading back device firmware version", ASROCK_CONTROLLER_NAME);
+    LOG_DEBUG("[%s] Reading back device firmware version", ASROCK_CONTROLLER_NAME);
     // Version response array needs to be 32 bytes to prevent non ASRock board from stack smashing
     unsigned char asrock_version[I2C_SMBUS_BLOCK_MAX] = { 0x00, 0x00 };
     if (bus->i2c_smbus_read_block_data(dev, ASROCK_REG_FIRMWARE_VER, asrock_version) == 0x02)
@@ -104,12 +106,12 @@ unsigned short PolychromeController::ReadFirmwareVersion()
         unsigned char major = asrock_version[0];
         unsigned char minor = asrock_version[1];
 
-        LOG_DEBUG("%s Device firmware version: v%02d.%02d", ASROCK_CONTROLLER_NAME, major, minor);
+        LOG_DEBUG("[%s] Device firmware version: v%02d.%02d", ASROCK_CONTROLLER_NAME, major, minor);
         return((major << 8) | minor);
     }
     else
     {
-        LOG_WARNING("%s Firmware readback failed; Returning 0xFFFF", ASROCK_CONTROLLER_NAME);
+        LOG_WARNING("[%s] Firmware readback failed; Returning 0xFFFF", ASROCK_CONTROLLER_NAME);
         return(0xFFFF);
     }
 }
@@ -120,7 +122,7 @@ 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                                                |
     \*---------------------------------------------------------------------------------*/
-    LOG_DEBUG("%s Reading LED config from controller", ASROCK_CONTROLLER_NAME);
+    LOG_DEBUG("[%s] Reading LED config from controller", ASROCK_CONTROLLER_NAME);
     unsigned char asrock_zone_count[I2C_SMBUS_BLOCK_MAX] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
     if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_REG_LED_CONFIG, asrock_zone_count) == 0x06)
     {
@@ -130,16 +132,16 @@ void PolychromeController::ReadLEDConfiguration()
         zone_led_count[POLYCHROME_ZONE_4]           = asrock_zone_count[3];
         zone_led_count[POLYCHROME_ZONE_5]           = asrock_zone_count[4];
         zone_led_count[POLYCHROME_ZONE_ADDRESSABLE] = asrock_zone_count[5];
-        LOG_DEBUG("%s Zone 1 LED count: %02d", ASROCK_CONTROLLER_NAME, zone_led_count[POLYCHROME_ZONE_1]);
-        LOG_DEBUG("%s Zone 2 LED count: %02d", ASROCK_CONTROLLER_NAME, zone_led_count[POLYCHROME_ZONE_2]);
-        LOG_DEBUG("%s Zone 3 LED count: %02d", ASROCK_CONTROLLER_NAME, zone_led_count[POLYCHROME_ZONE_3]);
-        LOG_DEBUG("%s Zone 4 LED count: %02d", ASROCK_CONTROLLER_NAME, zone_led_count[POLYCHROME_ZONE_4]);
-        LOG_DEBUG("%s Zone 5 LED count: %02d", ASROCK_CONTROLLER_NAME, zone_led_count[POLYCHROME_ZONE_5]);
-        LOG_DEBUG("%s Addressable Zone LED count: %02d", ASROCK_CONTROLLER_NAME, zone_led_count[POLYCHROME_ZONE_ADDRESSABLE]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_1, zone_led_count[POLYCHROME_ZONE_1]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_2, zone_led_count[POLYCHROME_ZONE_2]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_3, zone_led_count[POLYCHROME_ZONE_3]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_4, zone_led_count[POLYCHROME_ZONE_4]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_5, zone_led_count[POLYCHROME_ZONE_5]);
+        LOG_DEBUG("[%s] Addressable Zone LED count: %02d", ASROCK_CONTROLLER_NAME, zone_led_count[POLYCHROME_ZONE_ADDRESSABLE]);
     }
     else
     {
-        LOG_WARNING("%s LED config read failed", ASROCK_CONTROLLER_NAME);
+        LOG_WARNING("[%s] LED config read failed", ASROCK_CONTROLLER_NAME);
         memset(zone_led_count, 0, sizeof(zone_led_count));
     }
 }

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.h

@@ -15,8 +15,10 @@
 
 typedef unsigned char	polychrome_dev_id;
 
-#define ASROCK_CONTROLLER_NAME  "[ASRock Polychrome SMBus Controller]"
-#define ASROCK_DETECTOR_NAME    "[ASRock Polychrome SMBus Detect]"
+#define ASROCK_CONTROLLER_NAME  "ASRock Polychrome SMBus Controller"
+#define ASROCK_DETECTOR_NAME    "ASRock Polychrome SMBus Detect"
+#define VENDOR_NAME             "ASRock"
+#define SMBUS_ADDRESS           0x6A
 
 enum
 {
@@ -189,9 +191,53 @@ enum
 
 enum
 {
-    POLYCHROME_V2_SPEED_MIN                 = 0x05,     /* Slowest speed                        */
-    POLYCHROME_V2_SPEED_DEFAULT             = 0x03,     /* Default speed                        */
-    POLYCHROME_V2_SPEED_MAX                 = 0x00,     /* Fastest speed                        */
+    POLYCHROME_V2_BREATHING_SPEED_MIN               = 0x0A,     /* Slowest speed                        */
+    POLYCHROME_V2_BREATHING_SPEED_DEFAULT           = 0x06,     /* Default speed                        */
+    POLYCHROME_V2_BREATHING_SPEED_MAX               = 0x02,     /* Fastest speed                        */
+
+    POLYCHROME_V2_STROBE_SPEED_MIN                  = 0xA0,     /* Slowest speed                        */
+    POLYCHROME_V2_STROBE_SPEED_DEFAULT              = 0x4D,     /* Default speed                        */
+    POLYCHROME_V2_STROBE_SPEED_MAX                  = 0x05,     /* Fastest speed                        */
+
+    POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_MIN          = 0xA0,     /* Slowest speed                        */
+    POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_DEFAULT      = 0x50,     /* Default speed                        */
+    POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_MAX          = 0x0A,     /* Fastest speed                        */
+
+    POLYCHROME_V2_RANDOM_SPEED_MIN                  = 0xA0,     /* Slowest speed                        */
+    POLYCHROME_V2_RANDOM_SPEED_DEFAULT              = 0x4D,     /* Default speed                        */
+    POLYCHROME_V2_RANDOM_SPEED_MAX                  = 0x05,     /* Fastest speed                        */
+
+    POLYCHROME_V2_WAVE_SPEED_MIN                    = 0x06,     /* Slowest speed                        */
+    POLYCHROME_V2_WAVE_SPEED_DEFAULT                = 0x03,     /* Default speed                        */
+    POLYCHROME_V2_WAVE_SPEED_MAX                    = 0x01,     /* Fastest speed                        */
+
+    POLYCHROME_V2_SPRING_SPEED_MIN                  = 0x20,     /* Slowest speed                        */
+    POLYCHROME_V2_SPRING_SPEED_DEFAULT              = 0x11,     /* Default speed                        */
+    POLYCHROME_V2_SPRING_SPEED_MAX                  = 0x02,     /* Fastest speed                        */
+
+    POLYCHROME_V2_STACK_SPEED_MIN                   = 0x20,     /* Slowest speed                        */
+    POLYCHROME_V2_STACK_SPEED_DEFAULT               = 0x11,     /* Default speed                        */
+    POLYCHROME_V2_STACK_SPEED_MAX                   = 0x02,     /* Fastest speed                        */
+
+    POLYCHROME_V2_CRAM_SPEED_MIN                    = 0x20,     /* Slowest speed                        */
+    POLYCHROME_V2_CRAM_SPEED_DEFAULT                = 0x11,     /* Default speed                        */
+    POLYCHROME_V2_CRAM_SPEED_MAX                    = 0x02,     /* Fastest speed                        */
+
+    POLYCHROME_V2_SCAN_SPEED_MIN                    = 0x20,     /* Slowest speed                        */
+    POLYCHROME_V2_SCAN_SPEED_DEFAULT                = 0x11,     /* Default speed                        */
+    POLYCHROME_V2_SCAN_SPEED_MAX                    = 0x02,     /* Fastest speed                        */
+
+    POLYCHROME_V2_NEON_SPEED_MIN                    = 0x20,     /* Slowest speed                        */
+    POLYCHROME_V2_NEON_SPEED_DEFAULT                = 0x11,     /* Default speed                        */
+    POLYCHROME_V2_NEON_SPEED_MAX                    = 0x02,     /* Fastest speed                        */
+
+    POLYCHROME_V2_WATER_SPEED_MIN                   = 0x20,     /* Slowest speed                        */
+    POLYCHROME_V2_WATER_SPEED_DEFAULT               = 0x11,     /* Default speed                        */
+    POLYCHROME_V2_WATER_SPEED_MAX                   = 0x02,     /* Fastest speed                        */
+
+    POLYCHROME_V2_RAINBOW_SPEED_MIN                 = 0x12,     /* Slowest speed                        */
+    POLYCHROME_V2_RAINBOW_SPEED_DEFAULT             = 0x08,     /* Default speed                        */
+    POLYCHROME_V2_RAINBOW_SPEED_MAX                 = 0x02,     /* Fastest speed                        */
 };
 
 class PolychromeController

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusControllerDetect.cpp

@@ -47,40 +47,40 @@ bool TestForPolychromeSMBusController(i2c_smbus_interface* bus, unsigned char ad
 
 void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
 {
-    PolychromeController* new_polychrome;
-    RGBController_Polychrome* new_controller;
-
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
         IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            LOG_TRACE("%s Bus %02d is an Motherboard, checking for for a device at 0x6A", ASROCK_DETECTOR_NAME, bus);
-            // Check for Polychrome controller at 0x6A
-            if (TestForPolychromeSMBusController(busses[bus], 0x6A))
+            if(busses[bus]->pci_subsystem_vendor == ASROCK_SUB_VEN)
             {
-                LOG_TRACE("%s Detected a device at address 0x6A, Testing for a known controller", ASROCK_DETECTOR_NAME);
-                new_polychrome = new PolychromeController(busses[bus], 0x6A);
-
-                if(new_polychrome->GetASRockType() != ASROCK_TYPE_UNKNOWN)
+                LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
+                // Check for Polychrome controller at 0x6A
+                if(TestForPolychromeSMBusController(busses[bus], SMBUS_ADDRESS))
                 {
-                    LOG_TRACE("%s Found a known Polychrome device", ASROCK_DETECTOR_NAME);
-                    new_controller = new RGBController_Polychrome(new_polychrome);
-                    ResourceManager::get()->RegisterRGBController(new_controller);
+                    LOG_DEBUG("[%s] Detected a device at address %02X, testing for a known controller",  ASROCK_DETECTOR_NAME, SMBUS_ADDRESS);
+                    PolychromeController* controller = new PolychromeController(busses[bus], SMBUS_ADDRESS);
+
+                    if(controller->GetASRockType() != ASROCK_TYPE_UNKNOWN)
+                    {
+                        LOG_DEBUG("[%s] Found a known Polychrome device", ASROCK_DETECTOR_NAME);
+                        RGBController_Polychrome* rgb_controller = new RGBController_Polychrome(controller);
+                        ResourceManager::get()->RegisterRGBController(rgb_controller);
+                    }
+                    else
+                    {
+                        LOG_DEBUG("[%s] Not a Polychrome device or unknown type", ASROCK_DETECTOR_NAME);
+                        delete controller;
+                    }
                 }
                 else
                 {
-                    LOG_TRACE("%s Not a Polychrome device or unknown type", ASROCK_DETECTOR_NAME);
-                    delete new_polychrome;
+                    LOG_DEBUG("[%s] Bus %02d no response at %02X", ASROCK_DETECTOR_NAME, bus, SMBUS_ADDRESS);
                 }
             }
             else
             {
-                LOG_TRACE("%s Bus %02d no response at 0x6A", ASROCK_DETECTOR_NAME, bus);
-            }
-        }
-        else
-        {
-            LOG_TRACE("%s Bus %02d not a Motherboard", ASROCK_DETECTOR_NAME, bus);
+                LOG_DEBUG(SMBUS_CHECK_DEVICE_FAILURE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME);
+            } 
         }
     }
 

Controllers/ASRockPolychromeSMBusController/RGBController_ASRockPolychromeSMBus.cpp

@@ -32,17 +32,28 @@ static const char* polychrome_v2_zone_names[] =
     "Addressable Header"
 };
 
-RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychrome_ptr)
+/**------------------------------------------------------------------*\
+    @name ASRock Polychrome SMBus
+    @type SMBus
+    @save :warning:
+    @direct :x:
+    @effects :white_check_mark:
+    @detectors DetectPolychromeSMBusControllers
+    @comment ASRock Polychrome controllers will save with each update.
+        Per ARGB LED support is not possible with these devices.
+\*-------------------------------------------------------------------*/
+
+RGBController_Polychrome::RGBController_Polychrome(PolychromeController* controller_ptr)
 {
-    polychrome = polychrome_ptr;
+    controller  = controller_ptr;
 
-    name        = polychrome->GetDeviceName();
+    name        = controller->GetDeviceName();
     vendor      = "ASRock";
-    version     = polychrome->GetFirmwareVersion();
+    version     = controller->GetFirmwareVersion();
     type        = DEVICE_TYPE_MOTHERBOARD;
-    location    = polychrome->GetDeviceLocation();
+    location    = controller->GetDeviceLocation();
 
-    switch(polychrome->GetASRockType())
+    switch(controller->GetASRockType())
     {
         case ASROCK_TYPE_ASRLED:
             {
@@ -295,9 +306,9 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
                 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.speed_min         = POLYCHROME_V2_BREATHING_SPEED_MIN;
+                Breathing.speed_max         = POLYCHROME_V2_BREATHING_SPEED_MAX;
+                Breathing.speed             = POLYCHROME_V2_BREATHING_SPEED_DEFAULT;
                 Breathing.color_mode        = MODE_COLORS_PER_LED;
                 modes.push_back(Breathing);
 
@@ -305,9 +316,9 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
                 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.speed_min            = POLYCHROME_V2_STROBE_SPEED_MIN;
+                Strobe.speed_max            = POLYCHROME_V2_STROBE_SPEED_MAX;
+                Strobe.speed                = POLYCHROME_V2_STROBE_SPEED_DEFAULT;
                 Strobe.color_mode           = MODE_COLORS_PER_LED;
                 modes.push_back(Strobe);
 
@@ -315,9 +326,9 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
                 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.speed_min     = POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_MIN;
+                SpectrumCycle.speed_max     = POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_MAX;
+                SpectrumCycle.speed         = POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_DEFAULT;
                 SpectrumCycle.color_mode    = MODE_COLORS_NONE;
                 modes.push_back(SpectrumCycle);
 
@@ -325,9 +336,9 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
                 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.speed_min            = POLYCHROME_V2_RANDOM_SPEED_MIN;
+                Random.speed_max            = POLYCHROME_V2_RANDOM_SPEED_MAX;
+                Random.speed                = POLYCHROME_V2_RANDOM_SPEED_DEFAULT;
                 Random.color_mode           = MODE_COLORS_NONE;
                 modes.push_back(Random);
 
@@ -335,9 +346,9 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
                 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.speed_min              = POLYCHROME_V2_WAVE_SPEED_MIN;
+                Wave.speed_max              = POLYCHROME_V2_WAVE_SPEED_MAX;
+                Wave.speed                  = POLYCHROME_V2_WAVE_SPEED_DEFAULT;
                 Wave.color_mode             = MODE_COLORS_NONE;
                 modes.push_back(Wave);
 
@@ -345,9 +356,9 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
                 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.speed_min            = POLYCHROME_V2_SPRING_SPEED_MIN;
+                Spring.speed_max            = POLYCHROME_V2_SPRING_SPEED_MAX;
+                Spring.speed                = POLYCHROME_V2_SPRING_SPEED_DEFAULT;
                 Spring.color_mode           = MODE_COLORS_NONE;
                 modes.push_back(Spring);
 
@@ -355,9 +366,9 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
                 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.speed_min             = POLYCHROME_V2_STACK_SPEED_MIN;
+                Stack.speed_max             = POLYCHROME_V2_STACK_SPEED_MAX;
+                Stack.speed                 = POLYCHROME_V2_STACK_SPEED_DEFAULT;
                 Stack.color_mode            = MODE_COLORS_NONE;
                 modes.push_back(Stack);
 
@@ -365,9 +376,9 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
                 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.speed_min              = POLYCHROME_V2_CRAM_SPEED_MIN;
+                Cram.speed_max              = POLYCHROME_V2_CRAM_SPEED_MAX;
+                Cram.speed                  = POLYCHROME_V2_CRAM_SPEED_DEFAULT;
                 Cram.color_mode             = MODE_COLORS_NONE;
                 modes.push_back(Cram);
 
@@ -375,16 +386,19 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
                 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.speed_min              = POLYCHROME_V2_SCAN_SPEED_MIN;
+                Scan.speed_max              = POLYCHROME_V2_SCAN_SPEED_MAX;
+                Scan.speed                  = POLYCHROME_V2_SCAN_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.flags                  = MODE_FLAG_HAS_SPEED;
+                Neon.speed_min              = POLYCHROME_V2_NEON_SPEED_MIN;
+                Neon.speed_max              = POLYCHROME_V2_NEON_SPEED_MAX;
+                Neon.speed                  = POLYCHROME_V2_NEON_SPEED_DEFAULT;
                 Neon.color_mode             = MODE_COLORS_NONE;
                 modes.push_back(Neon);
 
@@ -392,9 +406,9 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
                 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.speed_min             = POLYCHROME_V2_WATER_SPEED_MIN;
+                Water.speed_max             = POLYCHROME_V2_WATER_SPEED_MAX;
+                Water.speed                 = POLYCHROME_V2_WATER_SPEED_DEFAULT;
                 Water.color_mode            = MODE_COLORS_NONE;
                 modes.push_back(Water);
 
@@ -402,9 +416,9 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
                 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.speed_min           = POLYCHROME_V2_RAINBOW_SPEED_MIN;
+                Rainbow.speed_max           = POLYCHROME_V2_RAINBOW_SPEED_MAX;
+                Rainbow.speed               = POLYCHROME_V2_RAINBOW_SPEED_DEFAULT;
                 Rainbow.color_mode          = MODE_COLORS_NONE;
                 modes.push_back(Rainbow);
             }
@@ -416,12 +430,12 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
 
 RGBController_Polychrome::~RGBController_Polychrome()
 {
-    delete polychrome;
+    delete controller;
 }
 
 void RGBController_Polychrome::SetupZones()
 {
-    switch(polychrome->GetASRockType())
+    switch(controller->GetASRockType())
     {
         /*---------------------------------------------------------*\
         | ASR LED motherboards only have a single zone/LED          |
@@ -477,14 +491,14 @@ void RGBController_Polychrome::SetupZones()
                 \*---------------------------------------------------------*/
                 for(unsigned int zone_idx = 0; zone_idx < POLYCHROME_ZONE_COUNT; zone_idx++)
                 {
-                    if(polychrome->zone_led_count[zone_idx] > 0)
+                    if(controller->zone_led_count[zone_idx] > 0)
                     {
                         zone* new_zone = new zone();
 
                         /*---------------------------------------------------------*\
                         | Set zone name to channel name                             |
                         \*---------------------------------------------------------*/
-                        if(polychrome->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
+                        if(controller->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
                         {
                             new_zone->name          = polychrome_v1_zone_names[zone_idx];
                         }
@@ -501,9 +515,9 @@ void RGBController_Polychrome::SetupZones()
                         }
                         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];
+                            new_zone->leds_min      = controller->zone_led_count[zone_idx];
+                            new_zone->leds_max      = controller->zone_led_count[zone_idx];
+                            new_zone->leds_count    = controller->zone_led_count[zone_idx];
                         }
 
                         if(new_zone->leds_count > 1)
@@ -530,16 +544,16 @@ void RGBController_Polychrome::SetupZones()
                 \*---------------------------------------------------------*/
                 for(unsigned int zone_idx = 0; zone_idx < POLYCHROME_ZONE_COUNT; zone_idx++)
                 {
-                    if(polychrome->zone_led_count[zone_idx] > 0)
+                    if(controller->zone_led_count[zone_idx] > 0)
                     {
-                        for(unsigned int led_idx = 0; led_idx < polychrome->zone_led_count[zone_idx]; led_idx++)
+                        for(unsigned int led_idx = 0; led_idx < controller->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)
+                            if(controller->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
                                 {
                                     new_led->name           = polychrome_v1_zone_names[zone_idx];
                                 }
@@ -551,7 +565,7 @@ void RGBController_Polychrome::SetupZones()
                             new_led->name.append(" " + std::to_string(led_idx + 1));
                             new_led->value = 0;
 
-                            if(polychrome->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
+                            if(controller->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
                             {
                                 new_led->value              = zone_idx;
                             }
@@ -616,7 +630,7 @@ void RGBController_Polychrome::UpdateSingleLED(int led)
         led = leds[led].value;
     }
 
-    polychrome->SetColorsAndSpeed(led, red, grn, blu);
+    controller->SetColorsAndSpeed(led, red, grn, blu);
 }
 
 void RGBController_Polychrome::SetCustomMode()
@@ -626,16 +640,16 @@ void RGBController_Polychrome::SetCustomMode()
 
 void RGBController_Polychrome::DeviceUpdateMode()
 {
-    if(polychrome->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
+    if(controller->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
     {
-        for(unsigned int led_idx = 0; led_idx <= leds.size(); led_idx++)
+        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
         {
-            polychrome->SetMode(led_idx, modes[active_mode].value, modes[active_mode].speed);
+            controller->SetMode(led_idx, modes[active_mode].value, modes[active_mode].speed);
         }
     }
     else
     {
-        polychrome->SetMode(0, modes[active_mode].value, modes[active_mode].speed);
+        controller->SetMode(0, modes[active_mode].value, modes[active_mode].speed);
     }
 
     DeviceUpdateLEDs();

Controllers/ASRockPolychromeSMBusController/RGBController_ASRockPolychromeSMBus.h

@@ -1,34 +1,34 @@
-/*-----------------------------------------*\
-|  RGBController_ASRockPolychromeSMBus.h    |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  ASRock ASR LED and Polychrome RGB Driver |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/15/2019  |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "ASRockPolychromeSMBusController.h"
-
-class RGBController_Polychrome : public RGBController
-{
-public:
-    RGBController_Polychrome(PolychromeController* polychrome_ptr);
-    ~RGBController_Polychrome();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    PolychromeController* polychrome;
-};
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeSMBus.h    |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "ASRockPolychromeSMBusController.h"
+
+class RGBController_Polychrome : public RGBController
+{
+public:
+    RGBController_Polychrome(PolychromeController* controller_ptr);
+    ~RGBController_Polychrome();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    PolychromeController* controller;
+};

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -76,11 +76,19 @@ void PolychromeUSBController::SetDeviceInfo()
     {
         if(configtable[zonecnt] == 0x1E)
         {
-            break;
+			/*-----------------------------------------------------------------------*\
+			| If we don't have this device type (0x1E) we will skip it and continue.  |
+			\*-----------------------------------------------------------------------*/
+            continue;
         }
 
         newdev_info.num_leds = configtable[zonecnt];
 
+		/*--------------------------------------------------------------------------------------------------*\
+		| We will need to know what zone type this is, so that we can look up the name and make calls later. |
+		\*--------------------------------------------------------------------------------------------------*/
+        newdev_info.zone_type = zonecnt;
+
         switch (zonecnt)
         {
             /*-----------------------------------------*\
@@ -124,6 +132,12 @@ void PolychromeUSBController::WriteZone
     bool            allzone = false
     )
 {
+
+	/*----------------------------------------------------*\
+    | Get the device info so we can look up the zone type. | 
+	\*----------------------------------------------------*/
+    PolychromeDeviceInfo device_info = GetPolychromeDevices()[zone];
+
     unsigned char usb_buf[65];
 
     /*-----------------------------------------------------*\
@@ -135,7 +149,7 @@ void PolychromeUSBController::WriteZone
     | Set up message packet with leading 00                  |
     \*-----------------------------------------------------*/
 	usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
-	usb_buf[0x03] = zone;
+    usb_buf[0x03] = device_info.zone_type; 
 	usb_buf[0x04] = mode;
 	usb_buf[0x05] = RGBGetRValue(rgb);
 	usb_buf[0x06] = RGBGetGValue(rgb);
@@ -211,9 +225,13 @@ void PolychromeUSBController::WriteHeader
 
 PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
 {
+    /*-----------------------------------------------------*\
+    | Get the device info so we can look up the zone type   |
+	\*-----------------------------------------------------*/
+    PolychromeDeviceInfo device_info = GetPolychromeDevices()[zone];
+
     unsigned char       usb_buf[65];
     PolychromeZoneInfo  zoneinfo;
-    //unsigned char       all;
     unsigned char       r;
     unsigned char       g;
     unsigned char       b;
@@ -227,7 +245,7 @@ PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
     | Set up config table request packet                    |
     \*-----------------------------------------------------*/
     usb_buf[0x01]   = POLYCHROME_USB_READ_ZONE_CONFIG;
-    usb_buf[0x03]   = zone; 
+    usb_buf[0x03]   = device_info.zone_type; 
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
@@ -248,7 +266,6 @@ PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
     zoneinfo.color  = ToRGBColor(r,g,b);  
     zoneinfo.speed  = usb_buf[0x08];
     zoneinfo.zone   = usb_buf[0x03];
-    //all             = usb_buf[0x10];
 
     return(zoneinfo);
 }

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.h

@@ -99,6 +99,7 @@ struct PolychromeDeviceInfo
 {
     unsigned char           effect_channel;
     unsigned char           num_leds;
+	unsigned char			zone_type;
     PolychromeDeviceType    device_type;
 };
 

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -13,15 +13,26 @@
 #define ASROCK_USB_MAX_ZONES        8
 #define ASROCK_ADDRESSABLE_MAX_LEDS 100
 
-RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController* polychrome_ptr)
-{
-    polychrome                  = polychrome_ptr;
+/**------------------------------------------------------------------*\
+    @name ASrock Polychrome USB
+    @type USB
+    @save :warning:
+    @direct :x:
+    @effects :white_check_mark:
+    @detectors DetectPolychromeUSBControllers
+    @comment ASRock Polychrome controllers will save with each update.
+        Per ARGB LED support is not possible with these devices.
+\*-------------------------------------------------------------------*/
 
-    name                        = polychrome->GetDeviceName();
+RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController* controller_ptr)
+{
+    controller                  = controller_ptr;
+
+    name                        = controller->GetDeviceName();
     description                 = "ASRock Polychrome USB Device";
     vendor                      = "ASRock";
     type                        = DEVICE_TYPE_MOTHERBOARD;
-    location                    = polychrome->GetDeviceLocation();
+    location                    = controller->GetDeviceLocation();
 
     mode Off;
     Off.name                    = "Off";
@@ -176,27 +187,27 @@ void RGBController_PolychromeUSB::SetupZones()
     \*-------------------------------------------------*/
     leds.clear();
     colors.clear();
-    zones.resize(polychrome->GetChannelCount());
+    zones.resize(controller->GetChannelCount());
 
     /*-------------------------------------------------*\
     | Set zones and leds                                |
     \*-------------------------------------------------*/
     for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
     {
-        PolychromeDeviceInfo device_info = polychrome->GetPolychromeDevices()[channel_idx];
+        PolychromeDeviceInfo device_info = controller->GetPolychromeDevices()[channel_idx];
 
         zones[channel_idx].type     = ZONE_TYPE_LINEAR;
 
         if(device_info.device_type== PolychromeDeviceType::ADDRESSABLE)
         {
-            zones[channel_idx].name       = polychrome_USB_zone_names[channel_idx];
+            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
             zones[channel_idx].leds_min   = 0;
             zones[channel_idx].leds_max   = ASROCK_ADDRESSABLE_MAX_LEDS;
             zones[channel_idx].leds_count = device_info.num_leds; 
         }
         else if(device_info.device_type==PolychromeDeviceType::FIXED) 
         {
-            zones[channel_idx].name       = polychrome_USB_zone_names[channel_idx];
+            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
             zones[channel_idx].leds_min   = device_info.num_leds;
             zones[channel_idx].leds_max   = device_info.num_leds;
             zones[channel_idx].leds_count = device_info.num_leds; 
@@ -226,7 +237,7 @@ void RGBController_PolychromeUSB::SetupZones()
     {
         unsigned char led = (unsigned char)leds[led_idx].value;
 
-        colors[led_idx] = polychrome->GetZoneConfig(led).color;     // TODO Get addressable instead of zone idx
+        colors[led_idx] = controller->GetZoneConfig(led).color;     // TODO Get addressable instead of zone idx
     }
 
     /*---------------------------------------------------------*\
@@ -236,7 +247,7 @@ void RGBController_PolychromeUSB::SetupZones()
      for (unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
     {
         PolychromeZoneInfo zoneinfo;
-        zoneinfo = polychrome->GetZoneConfig(channel_idx); 
+        zoneinfo = controller->GetZoneConfig(channel_idx); 
         zones_info.push_back(zoneinfo);
     }
 
@@ -273,7 +284,7 @@ void RGBController_PolychromeUSB::DeviceUpdateLEDs()
             set_mode = active_mode;
         }
 
-        polychrome->WriteZone(zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);
+        controller->WriteZone(zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);
     }
 }
 
@@ -286,7 +297,7 @@ void RGBController_PolychromeUSB::UpdateZoneLEDs(int zone)
         set_mode = active_mode;
     }
 
-    polychrome->WriteZone(zone, set_mode, zones_info[zone].speed, zones[zone].colors[0], false);
+    controller->WriteZone(zone, set_mode, zones_info[zone].speed, zones[zone].colors[0], false);
 }
 
 void RGBController_PolychromeUSB::UpdateSingleLED(int led)
@@ -299,14 +310,14 @@ void RGBController_PolychromeUSB::UpdateSingleLED(int led)
         set_mode = active_mode;
     }
 
-    polychrome->WriteZone(channel, set_mode, zones_info[channel].speed, zones[channel].colors[0], false);
+    controller->WriteZone(channel, set_mode, zones_info[channel].speed, zones[channel].colors[0], false);
 }
 
 unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)
 {
     int dev_mode;
 
-    dev_mode    = polychrome->GetZoneConfig(zone).mode;
+    dev_mode    = controller->GetZoneConfig(zone).mode;
     active_mode = dev_mode;
 
     return(active_mode);  
@@ -332,7 +343,7 @@ void RGBController_PolychromeUSB::DeviceUpdateMode()
                 set_mode = active_mode;                    
             }
 
-            polychrome->WriteZone(zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);
+            controller->WriteZone(zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);
         }
     }
 }

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h

@@ -15,7 +15,7 @@
 class RGBController_PolychromeUSB : public RGBController
 {
 public:
-    RGBController_PolychromeUSB(PolychromeUSBController* polychrome_ptr);
+    RGBController_PolychromeUSB(PolychromeUSBController* controller_ptr);
 
     void        SetupZones();
 
@@ -30,7 +30,7 @@ public:
 
 private:
     bool                            initializedMode;
-    PolychromeUSBController*        polychrome;
+    PolychromeUSBController*        controller;
     std::vector<PolychromeZoneInfo> zones_info;
 
     unsigned char GetDeviceMode(unsigned char zone);

Controllers/AlienwareController/RGBController_Alienware.cpp

@@ -12,17 +12,27 @@
 #include <thread>
 #include <chrono>
 
-RGBController_Alienware::RGBController_Alienware(AlienwareController* alienware_ptr)
-{
-    alienware                   = alienware_ptr;
+/**------------------------------------------------------------------*\
+    @name Alienware
+    @type USB
+    @save :x:
+    @direct :x:
+    @effects :white_check_mark:
+    @detectors DetectAlienwareControllers
+    @comment
+\*-------------------------------------------------------------------*/
 
-    name                        = alienware->GetDeviceName();
-    vendor                      = "Alienware Corporation";
+RGBController_Alienware::RGBController_Alienware(AlienwareController* controller_ptr)
+{
+    controller                  = controller_ptr;
+
+    name                        = controller->GetDeviceName();
+    vendor                      = "Alienware";
     type                        = DEVICE_TYPE_KEYBOARD;
     description                 = "Alienware USB Device";
-    location                    = alienware->GetDeviceLocation();
-    serial                      = alienware->GetSerialString();
-    version                     = alienware->GetFirmwareVersion();
+    location                    = controller->GetDeviceLocation();
+    serial                      = controller->GetSerialString();
+    version                     = controller->GetFirmwareVersion();
 
     mode Color;
     Color.name                 = "Static";
@@ -56,7 +66,7 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* alienware_
     Morph.value                = ALIENWARE_MODE_MORPH;
     Morph.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
     Morph.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Morph.colors_min           = 2 * alienware->GetZoneCount();
+    Morph.colors_min           = 2 * controller->GetZoneCount();
     Morph.colors_max           = Morph.colors_min;
     Morph.colors.resize(Morph.colors_max);
     Morph.speed_min            = ALIENWARE_TEMPO_MIN;
@@ -110,7 +120,7 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* alienware_
 
     SetupZones();
 
-    alienware->UpdateDim();
+    controller->UpdateDim();
 }
 
 void RGBController_Alienware::SetupZones()
@@ -118,9 +128,9 @@ void RGBController_Alienware::SetupZones()
     /*-------------------------------------------------*\
     | Set zones and leds                                |
     \*-------------------------------------------------*/
-    std::vector<const char*> zone_names = alienware->GetZoneNames();
+    std::vector<const char*> zone_names = controller->GetZoneNames();
 
-    for(unsigned int zone_idx = 0; zone_idx < alienware->GetZoneCount(); zone_idx++)
+    for(unsigned int zone_idx = 0; zone_idx < controller->GetZoneCount(); zone_idx++)
     {
         zone new_zone;
 
@@ -217,43 +227,43 @@ void RGBController_Alienware::DeviceUpdateMode()
             \*-------------------------------------------------*/
             uint16_t period = 0x07d0;
 
-            alienware->SetMode(zone_idx, current_mode.value);
+            controller->SetMode(zone_idx, current_mode.value);
             
             switch(current_mode_idx)
             {
                 case ALIENWARE_MODE_COLOR:
-                    alienware->SetPeriod(zone_idx, period);
-                    alienware->SetColor( zone_idx, colors[current_zone.start_idx]);
-                    alienware->SetTempo( zone_idx, ALIENWARE_TEMPO_MAX);
-                    alienware->SetDim(   zone_idx, modes[current_mode_idx].brightness);
+                    controller->SetPeriod(zone_idx, period);
+                    controller->SetColor( zone_idx, colors[current_zone.start_idx]);
+                    controller->SetTempo( zone_idx, ALIENWARE_TEMPO_MAX);
+                    controller->SetDim(   zone_idx, modes[current_mode_idx].brightness);
                     break;
 
                 case ALIENWARE_MODE_PULSE:
-                    alienware->SetPeriod(zone_idx, period);
-                    alienware->SetColor( zone_idx, colors[current_zone.start_idx]);
-                    alienware->SetTempo( zone_idx, current_mode.speed);
-                    alienware->SetDim(   zone_idx, modes[current_mode_idx].brightness);
+                    controller->SetPeriod(zone_idx, period);
+                    controller->SetColor( zone_idx, colors[current_zone.start_idx]);
+                    controller->SetTempo( zone_idx, current_mode.speed);
+                    controller->SetDim(   zone_idx, modes[current_mode_idx].brightness);
                     break;
 
                 case ALIENWARE_MODE_MORPH:
-                    alienware->SetPeriod(zone_idx, period);
-                    alienware->SetColor( zone_idx, current_mode.colors[zone_idx * 2], current_mode.colors[(zone_idx * 2) + 1]);
-                    alienware->SetTempo( zone_idx, current_mode.speed);
-                    alienware->SetDim(   zone_idx, modes[current_mode_idx].brightness);
+                    controller->SetPeriod(zone_idx, period);
+                    controller->SetColor( zone_idx, current_mode.colors[zone_idx * 2], current_mode.colors[(zone_idx * 2) + 1]);
+                    controller->SetTempo( zone_idx, current_mode.speed);
+                    controller->SetDim(   zone_idx, modes[current_mode_idx].brightness);
                     break;
 
                 case ALIENWARE_MODE_SPECTRUM:
                 case ALIENWARE_MODE_RAINBOW:
-                    alienware->SetPeriod(zone_idx, ALIENWARE_DURATION_SPECTRUM);
-                    alienware->SetTempo( zone_idx, current_mode.speed);
-                    alienware->SetDim(   zone_idx, modes[current_mode_idx].brightness);
+                    controller->SetPeriod(zone_idx, ALIENWARE_DURATION_SPECTRUM);
+                    controller->SetTempo( zone_idx, current_mode.speed);
+                    controller->SetDim(   zone_idx, modes[current_mode_idx].brightness);
                     break;
 
                 case ALIENWARE_MODE_BREATHING:
-                    alienware->SetPeriod(zone_idx, period);
-                    alienware->SetColor( zone_idx, colors[current_zone.start_idx], 0x0);
-                    alienware->SetTempo( zone_idx, current_mode.speed);
-                    alienware->SetDim(   zone_idx, modes[current_mode_idx].brightness);
+                    controller->SetPeriod(zone_idx, period);
+                    controller->SetColor( zone_idx, colors[current_zone.start_idx], 0x0);
+                    controller->SetTempo( zone_idx, current_mode.speed);
+                    controller->SetDim(   zone_idx, modes[current_mode_idx].brightness);
                     break;
             }
         }
@@ -262,7 +272,7 @@ void RGBController_Alienware::DeviceUpdateMode()
         | Due to rate-limiting, this can take more than one     |
         | second to execute                                     |
         \*-----------------------------------------------------*/
-        alienware->UpdateController();
+        controller->UpdateController();
 
         /*-----------------------------------------------------*\
         | Re-run update if there's anything that's changed from |

Controllers/AlienwareController/RGBController_Alienware.h

@@ -17,7 +17,7 @@
 class RGBController_Alienware : public RGBController
 {
 public:
-    RGBController_Alienware(AlienwareController* alienware_ptr);
+    RGBController_Alienware(AlienwareController* controller_ptr);
 
     void        SetupZones();
 
@@ -32,6 +32,6 @@ public:
     void        SetCustomMode();
 
 private:
-    AlienwareController*                    alienware;
+    AlienwareController*                    controller;
     std::chrono::steady_clock::time_point   last_packet_ts;
 };

Controllers/AlienwareKeyboardController/AlienwareAW510KController.cpp

@@ -0,0 +1,442 @@
+/*-----------------------------------------*\
+|  AlienwareAW510KController.cpp            |
+|                                           |
+|  Driver for Alienware AW510K              |
+|  keyboard light controller                |
+|                                           |
+|  Mohamad Sallal - msallal      05/22/2021 |
+\*-----------------------------------------*/
+
+#include "AlienwareAW510KController.h"
+#include <cstring>
+
+AlienwareAW510KController::AlienwareAW510KController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+
+    SendCommit();
+}
+
+AlienwareAW510KController::~AlienwareAW510KController()
+{
+    hid_close(dev);
+}
+
+std::string AlienwareAW510KController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AlienwareAW510KController::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 AlienwareAW510KController::SendCommit()
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Commit packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x05;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x0A]           = 0x10;
+    usb_buf[0x0B]           = 0x0A;
+    usb_buf[0x0C]           = 0x01;
+    usb_buf[0x0D]           = 0x02;
+    usb_buf[0x0E]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 20 milliseconds                                 |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(20));
+}
+
+
+void AlienwareAW510KController::SendfeatureReport
+    (
+    unsigned char   first_byte,
+    unsigned char   second_byte,
+    unsigned char   third_byte,
+    unsigned char   forth_byte
+    )
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Feature report packet                          |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = first_byte;
+    usb_buf[0x02]           = second_byte;
+    usb_buf[0x03]           = third_byte;
+    usb_buf[0x04]           = forth_byte;
+
+    /*-----------------------------------------------------*\
+    | Send Feature report packet                            |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 10 milliseconds                                 |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+}
+
+void AlienwareAW510KController::SendEdit()
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Edit packet                                    |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x01;
+    usb_buf[0x02]           = 0x00;
+    usb_buf[0x03]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 2 milliseconds                                  |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
+}
+
+void AlienwareAW510KController::SendInitialize()
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Commit packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x0E;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = 0x00;
+    usb_buf[0x04]           = 0x01;
+    usb_buf[0x05]           = 0xAD;
+    usb_buf[0x06]           = 0x80;
+    usb_buf[0x07]           = 0x10;
+    usb_buf[0x08]           = 0xA5;
+    usb_buf[0x0A]           = 0x0A;
+    usb_buf[0x12]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 2 milliseconds                                  |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
+}
+
+void AlienwareAW510KController::SetDirect
+    (
+    unsigned char   zone,
+    unsigned char   r,
+    unsigned char   g,
+    unsigned char   b
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Lighting Control packet                        |
+    \*-----------------------------------------------------*/
+
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x05;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = 0x01;
+    usb_buf[0x04]           = r;
+    usb_buf[0x05]           = g;
+    usb_buf[0x06]           = b;
+    usb_buf[0x0B]           = 0x0A;
+    usb_buf[0x0D]           = 0x01;
+    usb_buf[0x0E]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 2 milliseconds                                  |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
+}
+
+void AlienwareAW510KController::SendDirectOn
+    (
+    std::vector<SelectedKeys>     &frame_data
+    )
+{
+    SendfeatureReport(0x0E, frame_data.size(), 0x00, 0x01);
+
+    /*-----------------------------------------------*\
+    | To Guarantee the data are always %4 =0 append   |
+    | zeros at end of last packet                     |
+    \*-----------------------------------------------*/
+    for(int i = 0; i < (frame_data.size() % 4); i++)
+    {
+        SelectedKeys key;
+        key.idx     = 0x00;
+        key.red     = 0x00;
+        key.green   = 0x00;
+        key.blue    = 0x00;
+
+        frame_data.push_back(key);
+    }
+
+    unsigned char usb_buf[65];
+    unsigned int  frame_idx = 0;
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, 65);
+
+    for(unsigned int packet_idx = 0; packet_idx < frame_data.size(); packet_idx++)
+    {
+        usb_buf[0x00]           = 0x00;
+        usb_buf[0x01]           = 0x0E;
+        usb_buf[0x02]           = 0x01;
+        usb_buf[0x03]           = 0x00;
+        usb_buf[0x04]           = ++frame_idx;
+        usb_buf[0x05]           = frame_data[packet_idx].idx;
+        usb_buf[0x06]           = 0x81;
+        usb_buf[0x07]           = 0x00;
+        usb_buf[0x08]           = 0xA5;
+        usb_buf[0x0A]           = 0x0A;
+        usb_buf[0x0B]           = frame_data[packet_idx].red;
+        usb_buf[0x0C]           = frame_data[packet_idx].green;
+        usb_buf[0x0D]           = frame_data[packet_idx].blue;
+        usb_buf[0x12]           = 0x01;
+
+        usb_buf[0x14]           = frame_data[++packet_idx].idx;
+        usb_buf[0x15]           = 0x81;
+        usb_buf[0x16]           = 0x00;
+        usb_buf[0x17]           = 0xA5;
+        usb_buf[0x19]           = 0x0A;
+        usb_buf[0x1A]           = frame_data[packet_idx].red;
+        usb_buf[0x1B]           = frame_data[packet_idx].green;
+        usb_buf[0x1C]           = frame_data[packet_idx].blue;
+        usb_buf[0x21]           = 0x01;
+
+        usb_buf[0x23]           = frame_data[++packet_idx].idx;
+        usb_buf[0x24]           = 0x81;
+        usb_buf[0x25]           = 0x00;
+        usb_buf[0x26]           = 0xA5;
+        usb_buf[0x28]           = 0x0A;
+        usb_buf[0x29]           = frame_data[packet_idx].red;
+        usb_buf[0x2A]           = frame_data[packet_idx].green;
+        usb_buf[0x2B]           = frame_data[packet_idx].blue;
+        usb_buf[0x30]           = 0x01;
+
+        usb_buf[0x32]           = frame_data[++packet_idx].idx;
+        usb_buf[0x33]           = 0x81;
+        usb_buf[0x34]           = 0x00;
+        usb_buf[0x35]           = 0xA5;
+        usb_buf[0x37]           = 0x0A;
+        usb_buf[0x38]           = frame_data[packet_idx].red;
+        usb_buf[0x39]           = frame_data[packet_idx].green;
+        usb_buf[0x3A]           = frame_data[packet_idx].blue;
+        usb_buf[0x3F]           = 0x01;
+
+        hid_write(dev, (unsigned char *)usb_buf, 65);
+    }
+}
+
+
+void AlienwareAW510KController::SetMode
+    (
+    unsigned char   mode,
+    unsigned short  speed,
+    unsigned char   direction,
+    unsigned char   colorMode,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    SendMode(ALIENWARE_AW510K_ZONE_MODE_KEYBOARD, mode, speed, direction, colorMode, red, green, blue);
+    SendCommit();
+}
+
+void AlienwareAW510KController::UpdateSingleLED
+    (
+    unsigned char   led,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    SendfeatureReport(0x0E, 0x01, 0x00, 0x01);
+
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Single LED packet                              |
+    \*-----------------------------------------------------*/
+
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x0E;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = 0x00;
+    usb_buf[0x04]           = 0x01;
+    usb_buf[0x05]           = led;
+    usb_buf[0x06]           = 0x81;
+    usb_buf[0x07]           = 0x00;
+    usb_buf[0x08]           = 0xA5;
+    usb_buf[0x09]           = 0x00;
+    usb_buf[0x0A]           = 0x0A;
+    usb_buf[0x0B]           = red;
+    usb_buf[0x0C]           = green;
+    usb_buf[0x0D]           = blue;
+    usb_buf[0x12]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 20 milliseconds                                 |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(20));
+
+}
+void AlienwareAW510KController::SendMode
+    (
+    unsigned char   zone,
+    unsigned char   mode,
+    unsigned short  speed,
+    unsigned char   direction,
+    unsigned char   colorMode,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Mode Control packet                            |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x05;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = mode;
+    usb_buf[0x04]           = red;
+    usb_buf[0x05]           = green;
+    usb_buf[0x06]           = blue;
+    usb_buf[0x0A]           = speed;
+    usb_buf[0x0B]           = 0x0A;
+    usb_buf[0x0D]           = 0x01;
+    usb_buf[0x0E]           = colorMode;
+    usb_buf[0x0F]           = direction;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+}
+
+void AlienwareAW510KController::SetMorphMode
+    (
+    unsigned char   mode,
+    unsigned short  speed,
+    unsigned char   red1,
+    unsigned char   green1,
+    unsigned char   blue1,
+    unsigned char   red2,
+    unsigned char   green2,
+    unsigned char   blue2
+    )
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Morph Mode packet                              |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x05;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = mode;
+    usb_buf[0x04]           = red1;
+    usb_buf[0x05]           = green1;
+    usb_buf[0x06]           = blue1;
+    usb_buf[0x07]           = red2;
+    usb_buf[0x08]           = green2;
+    usb_buf[0x09]           = blue2;
+    usb_buf[0x0E]           = 0x02;
+    usb_buf[0x0A]           = speed;
+    usb_buf[0x0B]           = 0x0A;
+    usb_buf[0x0D]           = 0x01;
+    usb_buf[0x0E]           = ALIENWARE_AW510K_TWO_USER_DEFINED_COLOR_MODE;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+}

Controllers/AlienwareKeyboardController/AlienwareAW510KController.h

@@ -0,0 +1,156 @@
+/*-----------------------------------------*\
+|  AlienwareAW510KController.h              |
+|                                           |
+|  Definitions and types for alienware      |
+|  AW510K Keyboard                          |
+|                                           |
+|  Mohamad Sallal - msallal      05/22/2021 |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    ALIENWARE_AW510K_ZONE_MODE_KEYBOARD         = 0x01,
+    ALIENWARE_AW510K_ZONE_MODE_LOGO             = 0x07,     /* logo is only need key value, which equal 07  */
+};
+
+enum
+{
+    ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD       = 0x01,
+    ALIENWARE_AW510K_ZONE_DIRECT_MEDIA          = 0x02,
+    ALIENWARE_AW510K_ZONE_DIRECT_LOGO           = 0x07,
+    ALIENWARE_AW510K_ZONE_DIRECT_INDICATORS     = 0x40,
+};
+
+enum
+{
+    ALIENWARE_AW510K_MODE_OFF                   = 0x00,
+    ALIENWARE_AW510K_MODE_DIRECT_PER_LED        = 0x01,
+    ALIENWARE_AW510K_MODE_DIRECT                = 0x01,
+    ALIENWARE_AW510K_MODE_PULSE                 = 0x02,
+    ALIENWARE_AW510K_MODE_MORPH                 = 0x03,
+    ALIENWARE_AW510K_MODE_BREATHING             = 0x07,
+    ALIENWARE_AW510K_MODE_SPECTRUM              = 0x08,
+    ALIENWARE_AW510K_MODE_SINGLE_WAVE           = 0x0F,
+    ALIENWARE_AW510K_MODE_RAINBOW_WAVE          = 0x10,
+    ALIENWARE_AW510K_MODE_SCANNER               = 0x11,
+    ALIENWARE_AW510K_MODE_STATIC                = 0x13,
+};
+
+enum
+{
+    ALIENWARE_AW510K_SPEED_SLOWEST              = 0x2D,     /* Slowest speed                                */
+    ALIENWARE_AW510K_SPEED_NORMAL               = 0x19,     /* Normal speed                                 */
+    ALIENWARE_AW510K_SPEED_FASTEST              = 0x0A,     /* Fastest speed                                */
+};
+
+enum
+{
+    ALIENWARE_AW510K_DIRECTION_LEFT_TO_RIGHT    = 0x01,
+    ALIENWARE_AW510K_DIRECTION_RIGHT_TO_LEFT    = 0x02,
+    ALIENWARE_AW510K_DIRECTION_TOP_TO_BOTTOM    = 0x03,
+    ALIENWARE_AW510K_DIRECTION_BOTTOM_TO_TOP    = 0x04,
+};
+
+enum
+{
+    ALIENWARE_AW510K_SINGLE_COLOR_MODE          = 0x01,
+    ALIENWARE_AW510K_TWO_USER_DEFINED_COLOR_MODE= 0x02,
+    ALIENWARE_AW510K_RANBOW_COLOR_MODE          = 0x03,
+};
+
+struct SelectedKeys
+{
+    unsigned char idx;
+    unsigned char red;
+    unsigned char green;
+    unsigned char blue;
+};
+
+class AlienwareAW510KController
+{
+public:
+    AlienwareAW510KController(hid_device* dev_handle, const char* path);
+    ~AlienwareAW510KController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void        SendInitialize();
+    void        SendCommit();
+    void        SendfeatureReport
+                    (
+                    unsigned char   first_byte,
+                    unsigned char   second_byte,
+                    unsigned char   third_byte,
+                    unsigned char   forth_byte
+                    );
+
+    void        SendEdit();
+
+    void        SetDirect
+                    (
+                    unsigned char   zone,
+                    unsigned char   r,
+                    unsigned char   g,
+                    unsigned char   b
+                    );
+
+    void    SendDirectOn
+                    (
+                    std::vector<SelectedKeys>     &frame_data
+                    );
+
+    void        SetMode
+                    (
+                    unsigned char   mode,
+                    unsigned short  speed,
+                    unsigned char   direction,
+                    unsigned char   colorMode,
+                    unsigned char   red,
+                    unsigned char   green,
+                    unsigned char   blue
+                    );
+
+    void        SetMorphMode
+                    (
+                    unsigned char   mode,
+                    unsigned short  speed,
+                    unsigned char   red1,
+                    unsigned char   green1,
+                    unsigned char   blue1,
+                    unsigned char   red2,
+                    unsigned char   green2,
+                    unsigned char   blue2
+                    );
+
+    void        UpdateSingleLED
+                    (
+                    unsigned char   led,
+                    unsigned char   red,
+                    unsigned char   green,
+                    unsigned char   blue
+                    );
+
+private:
+    hid_device*             dev;
+    std::string             location;
+
+    void        SendMode
+                    (
+                    unsigned char   zone,
+                    unsigned char   mode,
+                    unsigned short  speed,
+                    unsigned char   direction,
+                    unsigned char   colorMode,
+                    unsigned char   red,
+                    unsigned char   green,
+                    unsigned char   blue
+                    );
+};

Controllers/AlienwareKeyboardController/AlienwareKeyboardControllerDetect.cpp

@@ -0,0 +1,38 @@
+#include "Detector.h"
+#include "AlienwareAW510KController.h"
+#include "RGBController.h"
+#include "RGBController_AlienwareAW510K.h"
+#include <hidapi/hidapi.h>
+
+/*-----------------------------------------------------*\
+| Alienware vendor ID                                   |
+\*-----------------------------------------------------*/
+#define ALIENWARE_VID           0x04F2
+
+/*-----------------------------------------------------*\
+| Keyboard product IDs                                  |
+\*-----------------------------------------------------*/
+#define ALIENWARE_AW510K_PID    0x1830
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAlienwareKeyboardControllers                                                     *
+*                                                                                          *
+*       Tests the USB address to see if a Alienware RGB Keyboard controller exists there.  *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAlienwareAW510KControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
+    {
+        AlienwareAW510KController*     controller     = new AlienwareAW510KController(dev, info->path);
+        RGBController_AlienwareAW510K* rgb_controller = new RGBController_AlienwareAW510K(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}   /* DetectAlienwareKeyboardControllers() */
+
+
+REGISTER_HID_DETECTOR_IPU("Alienware AW510K",   DetectAlienwareAW510KControllers,   ALIENWARE_VID,  ALIENWARE_AW510K_PID,   0x02,   0xFF00, 0x01);

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.cpp

@@ -0,0 +1,499 @@
+/*-----------------------------------------*\
+|  RGBController_AlienwareAW510K.cpp        |
+|                                           |
+|  Generic RGB Interface for alienware      |
+|  AW510K Keyboard                          |
+|                                           |
+|  Mohamad Sallal - msallal      05/22/2021 |
+\*-----------------------------------------*/
+
+#include "RGBControllerKeyNames.h"
+#include "RGBController_AlienwareAW510K.h"
+#include <iterator>
+
+//0xFFFFFFFF indicates an unused entry in matrix
+#define NA  0xFFFFFFFF
+
+int GetAW520K_WaveDirection(int input);
+
+static unsigned int matrix_map[7][24] =
+{ {  0,   NA,   1,   2,   3,   4,  NA,   5,   6,   7,   8,   9,  10,  11,  12,  NA,  13,  14,  15,  NA,  16,  NA,  NA,  NA },
+  {  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  NA,  NA,  31,  32,  33,  NA,  34,  35,  36,  37 },
+  {  38,  NA,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  NA,  52,  53,  54,  NA,  55,  56,  57,  74 },
+  {  58,  NA,  59,  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,  NA,  70,  NA,  NA,  NA,  NA,  NA,  71,  72,  73,  NA },
+  {  75,  NA,  NA,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  NA,  NA,  NA,  87,  NA,  NA,  88,  89,  90, 104 },
+  {  91,  NA,  92,  93,  NA,  94,  NA,  NA,  NA,  NA,  NA,  95,  96,  97,  98,  NA,  99, 100, 101,  NA, 102,  NA, 103,  NA },
+  {  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  105, NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA }};
+
+static const char* zone_names[] =
+{
+    "AW510K",
+};
+
+static zone_type zone_types[] =
+{
+    ZONE_TYPE_MATRIX,
+};
+
+static const unsigned int zone_sizes[] =
+{
+    106,
+};
+
+typedef struct
+{
+    const char *        name;
+    const unsigned char zone;
+    const unsigned char idx;
+} led_type;
+
+static const led_type led_names[] =
+{
+    /* Key Label                Zone,                                      Index  */
+    { KEY_EN_ESCAPE,            ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB0    },
+    { KEY_EN_F1,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x98    },
+    { KEY_EN_F2,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x90    },
+    { KEY_EN_F3,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x88    },
+    { KEY_EN_F4,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x80    },
+    { KEY_EN_F5,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x70    },
+    { KEY_EN_F6,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x68    },
+    { KEY_EN_F7,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x60    },
+    { KEY_EN_F8,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x58    },
+    { KEY_EN_F9,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x50    },
+    { KEY_EN_F10,               ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x48    },
+    { KEY_EN_F11,               ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x40    },
+    { KEY_EN_F12,               ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x38    },
+    { KEY_EN_PRINT_SCREEN,      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x30    },
+    { KEY_EN_SCROLL_LOCK,       ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x28    },
+    { KEY_EN_PAUSE_BREAK,       ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x20    },
+    { KEY_EN_MEDIA_MUTE,        ALIENWARE_AW510K_ZONE_DIRECT_MEDIA,        0x18    },
+    { KEY_EN_BACK_TICK,         ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB1    },
+    { KEY_EN_1,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xA1    },
+    { KEY_EN_2,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x99    },
+    { KEY_EN_3,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x91    },
+    { KEY_EN_4,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x89    },
+    { KEY_EN_5,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x81    },
+    { KEY_EN_6,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x79    },
+    { KEY_EN_7,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x71    },
+    { KEY_EN_8,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x69    },
+    { KEY_EN_9,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x61    },
+    { KEY_EN_0,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x59    },
+    { KEY_EN_MINUS,             ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x51    },
+    { KEY_EN_EQUALS,            ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x49    },
+    { KEY_EN_BACKSPACE,         ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x39    },
+    { KEY_EN_INSERT,            ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x31    },
+    { KEY_EN_HOME,              ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x29    },
+    { KEY_EN_PAGE_UP,           ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x21    },
+    { KEY_EN_NUMPAD_LOCK,       ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x19    },
+    { KEY_EN_NUMPAD_DIVIDE,     ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x11    },
+    { KEY_EN_NUMPAD_TIMES,      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x09    },
+    { KEY_EN_NUMPAD_MINUS,      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x01    },
+    { KEY_EN_TAB,               ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB2    },
+    { KEY_EN_Q,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xA2    },
+    { KEY_EN_W,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x9A    },
+    { KEY_EN_E,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x92    },
+    { KEY_EN_R,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x8A    },
+    { KEY_EN_T,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x82    },
+    { KEY_EN_Y,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x7A    },
+    { KEY_EN_U,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x72    },
+    { KEY_EN_I,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x6A    },
+    { KEY_EN_O,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x62    },
+    { KEY_EN_P,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x5A    },
+    { KEY_EN_LEFT_BRACKET,      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x52    },
+    { KEY_EN_RIGHT_BRACKET,     ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x4A    },
+    { KEY_EN_ANSI_BACK_SLASH,   ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x42    },//ANSI only
+    { KEY_EN_DELETE,            ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x32    },
+    { KEY_EN_END,               ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x2A    },
+    { KEY_EN_PAGE_DOWN,         ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x22    },
+    { KEY_EN_NUMPAD_7,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x1A    },
+    { KEY_EN_NUMPAD_8,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x12    },
+    { KEY_EN_NUMPAD_9,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x0A    },
+    { KEY_EN_CAPS_LOCK,         ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB3    },
+    { KEY_EN_A,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xA3    },
+    { KEY_EN_S,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x9B    },
+    { KEY_EN_D,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x93    },
+    { KEY_EN_F,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x8B    },
+    { KEY_EN_G,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x83    },
+    { KEY_EN_H,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x7B    },
+    { KEY_EN_J,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x73    },
+    { KEY_EN_K,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x6B    },
+    { KEY_EN_L,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x63    },
+    { KEY_EN_SEMICOLON,         ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x5B    },
+    { KEY_EN_QUOTE,             ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x53    },
+    { KEY_EN_ANSI_ENTER,        ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x43    },
+    { KEY_EN_NUMPAD_4,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x1B    },
+    { KEY_EN_NUMPAD_5,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x13    },
+    { KEY_EN_NUMPAD_6,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x0B    },
+    { KEY_EN_NUMPAD_PLUS,       ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x03    },
+    { KEY_EN_LEFT_SHIFT,        ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB4    },
+    { KEY_EN_Z,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xA4    },
+    { KEY_EN_X,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x9C    },
+    { KEY_EN_C,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x94    },
+    { KEY_EN_V,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x8C    },
+    { KEY_EN_B,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x84    },
+    { KEY_EN_N,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x7C    },
+    { KEY_EN_M,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x74    },
+    { KEY_EN_COMMA,             ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x6C    },
+    { KEY_EN_PERIOD,            ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x64    },
+    { KEY_EN_FORWARD_SLASH,     ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x5C    },
+    { KEY_EN_RIGHT_SHIFT,       ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x4C    },
+    { KEY_EN_UP_ARROW,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x2C    },
+    { KEY_EN_NUMPAD_1,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x1C    },
+    { KEY_EN_NUMPAD_2,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x14    },
+    { KEY_EN_NUMPAD_3,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x0C    },
+    { KEY_EN_LEFT_CONTROL,      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB5    },
+    { KEY_EN_LEFT_WINDOWS,      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xAD    },
+    { KEY_EN_LEFT_ALT,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xA5    },
+    { KEY_EN_SPACE,             ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x85    },
+    { KEY_EN_RIGHT_ALT,         ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x65    },
+    { KEY_EN_RIGHT_FUNCTION,    ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x5D    },
+    { KEY_EN_MENU,              ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x55    },
+    { KEY_EN_RIGHT_CONTROL,     ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x4D    },
+    { KEY_EN_LEFT_ARROW,        ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x35    },
+    { KEY_EN_DOWN_ARROW,        ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x2D    },
+    { KEY_EN_RIGHT_ARROW,       ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x25    },
+    { KEY_EN_NUMPAD_0,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x1D    },
+    { KEY_EN_NUMPAD_PERIOD,     ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x0D    },
+    { KEY_EN_NUMPAD_ENTER,      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x05    },
+    { "Logo",                   ALIENWARE_AW510K_ZONE_DIRECT_LOGO,         0x07    }
+};
+
+/**------------------------------------------------------------------*\
+    @name Alienware AW510 Keyboard
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAlienwareAW510KControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AlienwareAW510K::RGBController_AlienwareAW510K(AlienwareAW510KController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "Alienware AW510K Keyboard Device";
+    vendor      = "Alienware";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "Alienware AW510K Keyboard Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
+
+    mode Direct_Per_LED;
+    Direct_Per_LED.name             = "Direct";
+    Direct_Per_LED.value            = ALIENWARE_AW510K_MODE_DIRECT_PER_LED;
+    Direct_Per_LED.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct_Per_LED.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(Direct_Per_LED);
+
+    mode Static;
+    Static.name                     = "Static";
+    Static.value                    = ALIENWARE_AW510K_MODE_STATIC;
+    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min               = 1;
+    Static.colors_max               = 1;
+    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Pulse;
+    Pulse.name                      = "Pulse";
+    Pulse.value                     = ALIENWARE_AW510K_MODE_PULSE;
+    Pulse.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Pulse.color_mode                = MODE_COLORS_MODE_SPECIFIC;
+    Pulse.speed_min                 = ALIENWARE_AW510K_SPEED_SLOWEST;
+    Pulse.speed_max                 = ALIENWARE_AW510K_SPEED_NORMAL;
+    Pulse.speed                     = ALIENWARE_AW510K_SPEED_NORMAL;
+    Pulse.colors_min                = 1;
+    Pulse.colors_max                = 1;
+    Pulse.colors.resize(1);
+    modes.push_back(Pulse);
+
+    mode Morph;
+    Morph.name                      = "Morph";
+    Morph.value                     = ALIENWARE_AW510K_MODE_MORPH;
+    Morph.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Morph.color_mode                = MODE_COLORS_MODE_SPECIFIC;
+    Morph.speed_min                 = ALIENWARE_AW510K_SPEED_SLOWEST;
+    Morph.speed_max                 = ALIENWARE_AW510K_SPEED_NORMAL;
+    Morph.speed                     = ALIENWARE_AW510K_SPEED_NORMAL;
+    Morph.colors_min                = 2;
+    Morph.colors_max                = 2;
+    Morph.colors.resize(2);
+    modes.push_back(Morph);
+
+    mode Breathing;
+    Breathing.name                  = "Breathing";
+    Breathing.value                 = ALIENWARE_AW510K_MODE_BREATHING;
+    Breathing.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Breathing.colors_min            = 1;
+    Breathing.colors_max            = 1;
+    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors.resize(1);
+    Breathing.speed_min             = ALIENWARE_AW510K_SPEED_SLOWEST;
+    Breathing.speed_max             = ALIENWARE_AW510K_SPEED_FASTEST;
+    Breathing.speed                 = ALIENWARE_AW510K_SPEED_NORMAL;
+    modes.push_back(Breathing);
+
+    mode SingleWave;
+    SingleWave.name                  = "Single Wave";
+    SingleWave.value                 = ALIENWARE_AW510K_MODE_SINGLE_WAVE;
+    SingleWave.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
+    SingleWave.speed_min             = ALIENWARE_AW510K_SPEED_SLOWEST;
+    SingleWave.speed_max             = ALIENWARE_AW510K_SPEED_FASTEST;
+    SingleWave.speed                 = ALIENWARE_AW510K_SPEED_NORMAL;
+    SingleWave.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    SingleWave.colors_min            = 1;
+    SingleWave.colors_max            = 1;
+    SingleWave.colors.resize(1);
+    modes.push_back(SingleWave);
+
+    mode RainbowWave;
+    RainbowWave.name                  = "Rainbow Wave";
+    RainbowWave.value                 = ALIENWARE_AW510K_MODE_RAINBOW_WAVE;
+    RainbowWave.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
+    RainbowWave.speed_min             = ALIENWARE_AW510K_SPEED_SLOWEST;
+    RainbowWave.speed_max             = ALIENWARE_AW510K_SPEED_FASTEST;
+    RainbowWave.speed                 = ALIENWARE_AW510K_SPEED_NORMAL;
+    RainbowWave.colors_min            = 1;
+    RainbowWave.colors_max            = 1;
+    RainbowWave.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    RainbowWave.colors.resize(1);
+    modes.push_back(RainbowWave);
+
+    mode Off;
+    Off.name                          = "Off";
+    Off.value                         = ALIENWARE_AW510K_MODE_OFF;
+    Off.flags                         = 0;
+    Off.color_mode                    = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    SetupZones();
+    std::copy(colors.begin(), colors.end(),std::back_inserter(current_colors));
+}
+
+RGBController_AlienwareAW510K::~RGBController_AlienwareAW510K()
+{
+    /*---------------------------------------------------------*\
+    | Delete the matrix map                                     |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    {
+        if(zones[zone_index].matrix_map != NULL)
+        {
+            delete zones[zone_index].matrix_map;
+        }
+    }
+
+    delete controller;
+}
+
+void RGBController_AlienwareAW510K::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    unsigned int total_led_count = 0;
+
+    for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
+    {
+        zone new_zone;
+        new_zone.name                   = zone_names[zone_idx];
+        new_zone.type                   = zone_types[zone_idx];
+        new_zone.leds_min               = zone_sizes[zone_idx];
+        new_zone.leds_max               = zone_sizes[zone_idx];
+        new_zone.leds_count             = zone_sizes[zone_idx];
+
+        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
+        {
+            new_zone.matrix_map         = new matrix_map_type;
+            new_zone.matrix_map->height = 7;
+            new_zone.matrix_map->width  = 24;
+            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+        }
+        else
+        {
+            new_zone.matrix_map         = NULL;
+        }
+
+        zones.push_back(new_zone);
+
+        total_led_count += zone_sizes[zone_idx];
+    }
+
+    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
+    {
+        led new_led;
+        new_led.name  = led_names[led_idx].name;
+        new_led.value = led_names[led_idx].idx;
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AlienwareAW510K::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AlienwareAW510K::DeviceUpdateLEDs()
+{
+    std::vector<SelectedKeys>   frame_buf_keys;
+    std::vector<RGBColor>       new_colors;
+
+    std::copy(colors.begin(), colors.end(),std::back_inserter(new_colors));
+
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        if (current_colors[led_idx]==new_colors[led_idx])
+        {
+            /*-------------------------------------------------*\
+            | Don't send if key color is not changed            |
+            \*-------------------------------------------------*/
+            continue;
+        }
+
+        if(RGBGetRValue(colors[led_idx]) != 0x00 || RGBGetBValue(colors[led_idx]) != 0x00 || RGBGetBValue(colors[led_idx]) != 0x00)
+        {
+            SelectedKeys key;
+
+            key.idx     = (unsigned char)leds[led_idx].value;
+            key.red     = RGBGetRValue(colors[led_idx]);
+            key.green   = RGBGetGValue(colors[led_idx]);
+            key.blue    = RGBGetBValue(colors[led_idx]);
+
+            frame_buf_keys.push_back(key);
+        }
+        else
+        {
+            SelectedKeys key;
+
+            key.idx     = (unsigned char)leds[led_idx].value;
+            key.red     = RGBGetRValue(colors[led_idx]);
+            key.green   = RGBGetGValue(colors[led_idx]);
+            key.blue    = RGBGetBValue(colors[led_idx]);
+
+            frame_buf_keys.push_back(key);
+        }
+    }
+
+    controller->SendInitialize();
+    controller->SendfeatureReport(0x05, 0x01, 0x51, 0x00);
+    controller->SendCommit();
+
+    if(frame_buf_keys.size() > 0)
+    {
+        controller->SendDirectOn(frame_buf_keys);
+    }
+
+    std::copy(new_colors.begin(), new_colors.end(),current_colors.begin());
+}
+
+void RGBController_AlienwareAW510K::UpdateZoneLEDs(int zone)
+{
+    controller->SetDirect((unsigned char) zone, RGBGetRValue(zones[zone].colors[0]), RGBGetGValue(zones[zone].colors[0]), RGBGetBValue(zones[zone].colors[0]));
+}
+
+void RGBController_AlienwareAW510K::UpdateSingleLED(int led)
+{
+    controller->UpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
+}
+
+void RGBController_AlienwareAW510K::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_AlienwareAW510K::DeviceUpdateMode()
+{
+    if(active_mode == 0xFFFF)
+    {
+        UpdateLEDs();
+        return;
+    }
+
+    controller->SendfeatureReport(0x05, 0x01, 0x51, 0x00);
+    unsigned char red = 0;
+    unsigned char grn = 0;
+    unsigned char blu = 0;
+
+    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        red = RGBGetRValue(modes[active_mode].colors[0]);
+        grn = RGBGetGValue(modes[active_mode].colors[0]);
+        blu = RGBGetBValue(modes[active_mode].colors[0]);
+    }
+
+    switch(modes[active_mode].value)
+    {
+        case ALIENWARE_AW510K_MODE_MORPH:
+            /*-------------------------------------------------------------*\
+            | In case of morph it requires two colors (color1 and color2)   |
+            \*-------------------------------------------------------------*/
+            {
+                unsigned char red2 = RGBGetRValue(modes[active_mode].colors[1]);
+                unsigned char grn2 = RGBGetGValue(modes[active_mode].colors[1]);
+                unsigned char blu2 = RGBGetBValue(modes[active_mode].colors[1]);
+
+                controller->SetMorphMode(modes[active_mode].value, modes[active_mode].speed, red, grn, blu, red2, grn2, blu2);
+            }
+            break;
+
+        case ALIENWARE_AW510K_MODE_SPECTRUM:
+            /*-------------------------------------------------------------*\
+            | Spectrum only set mode, speed and colorMode                   |
+            \*-------------------------------------------------------------*/
+            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, 0x00, ALIENWARE_AW510K_RANBOW_COLOR_MODE, 0x00, 0x00, 0x00);
+            break;
+
+        case ALIENWARE_AW510K_MODE_SINGLE_WAVE:
+            /*-------------------------------------------------------------*\
+            | Wave only set mode, speed, direction and colorMode            |
+            \*-------------------------------------------------------------*/
+            {
+                int waveDirection = GetAW520K_WaveDirection(modes[active_mode].direction);
+                controller->SetMode(modes[active_mode].value, modes[active_mode].speed, waveDirection, ALIENWARE_AW510K_SINGLE_COLOR_MODE, red, grn, blu);
+            }
+            break;
+
+        case ALIENWARE_AW510K_MODE_RAINBOW_WAVE:
+            /*-------------------------------------------------------------*\
+            | Wave only set mode, speed, direction and colorMode            |
+            \*-------------------------------------------------------------*/
+            {
+            int waveDirection = GetAW520K_WaveDirection(modes[active_mode].direction);
+            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, waveDirection, ALIENWARE_AW510K_RANBOW_COLOR_MODE, 0x00, 0x00, 0x00);
+            }
+            break;
+
+
+        default:
+            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, 0x00, ALIENWARE_AW510K_SINGLE_COLOR_MODE, red, grn, blu);
+            break;
+    }
+}
+
+int GetAW520K_WaveDirection(int input)
+{
+    switch(input)
+    {
+        case MODE_DIRECTION_LEFT:
+            return(ALIENWARE_AW510K_DIRECTION_RIGHT_TO_LEFT);
+
+        case MODE_DIRECTION_RIGHT:
+            return(ALIENWARE_AW510K_DIRECTION_LEFT_TO_RIGHT);
+
+        case MODE_DIRECTION_UP:
+            return(ALIENWARE_AW510K_DIRECTION_BOTTOM_TO_TOP);
+
+        case MODE_DIRECTION_DOWN:
+            return(ALIENWARE_AW510K_DIRECTION_TOP_TO_BOTTOM);
+
+        default:
+            return(ALIENWARE_AW510K_DIRECTION_RIGHT_TO_LEFT);
+    }
+}
+

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.h

@@ -0,0 +1,35 @@
+/*-----------------------------------------*\
+|  RGBController_AlienwareAW510K.h          |
+|                                           |
+|  Generic RGB Interface for Alienware      |
+|  AW510K keyboard                          |
+|                                           |
+|  Mohamad Sallal - msallal      05/22/2021 |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AlienwareAW510KController.h"
+
+class RGBController_AlienwareAW510K : public RGBController
+{
+public:
+    RGBController_AlienwareAW510K(AlienwareAW510KController* controller_ptr);
+    ~RGBController_AlienwareAW510K();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+    
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    AlienwareAW510KController*  controller;
+    std::vector<RGBColor>       current_colors;
+};

Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp

@@ -7,6 +7,7 @@
 |  Sergey Gavrilov (DrZlo13) 06/06/2021     |
 \*-----------------------------------------*/
 
+#include "RGBControllerKeyNames.h"
 #include "RGBController_AnnePro2.h"
 
 #define NA              0xFFFFFFFF
@@ -44,79 +45,89 @@ typedef struct
 static const led_type led_names[] =
 {
     /* Key Label                Index  */
-    { "Key: Escape",            0       },
-    { "Key: 1",                 1       },
-    { "Key: 2",                 2       },
-    { "Key: 3",                 3       },
-    { "Key: 4",                 4       },
-    { "Key: 5",                 5       },
-    { "Key: 6",                 6       },
-    { "Key: 7",                 7       },
-    { "Key: 8",                 8       },
-    { "Key: 9",                 9       },
-    { "Key: 0",                 10      },
-    { "Key: -",                 11      },
-    { "Key: =",                 12      },
-    { "Key: Backspace",         13      },
-    { "Key: Tab",               14      },
-    { "Key: Q",                 15      },
-    { "Key: W",                 16      },
-    { "Key: E",                 17      },
-    { "Key: R",                 18      },
-    { "Key: T",                 19      },
-    { "Key: Y",                 20      },
-    { "Key: U",                 21      },
-    { "Key: I",                 22      },
-    { "Key: O",                 23      },
-    { "Key: P",                 24      },
-    { "Key: [",                 25      },
-    { "Key: ]",                 26      },
-    { "Key: \\ (ANSI)",         27      },
-    { "Key: Caps Lock",         28      },
-    { "Key: A",                 29      },
-    { "Key: S",                 30      },
-    { "Key: D",                 31      },
-    { "Key: F",                 32      },
-    { "Key: G",                 33      },
-    { "Key: H",                 34      },
-    { "Key: J",                 35      },
-    { "Key: K",                 36      },
-    { "Key: L",                 37      },
-    { "Key: ;",                 38      },
-    { "Key: '",                 39      },
-    { "Key: Enter",             40      },
-    { "Key: Left Shift",        41      },
-    { "Key: Z",                 42      },
-    { "Key: X",                 43      },
-    { "Key: C",                 44      },
-    { "Key: V",                 45      },
-    { "Key: B",                 46      },
-    { "Key: N",                 47      },
-    { "Key: M",                 48      },
-    { "Key: ,",                 49      },
-    { "Key: .",                 50      },
-    { "Key: /",                 51      },
-    { "Key: Right Shift",       52      },
-    { "Key: Left Control",      53      },
-    { "Key: Left Windows",      54      },
-    { "Key: Left Alt",          55      },
-    { "Key: Space",             56      },
-    { "Key: Right Alt",         57      },
-    { "Key: Right Fn",          58      },
-    { "Key: Menu",              59      },
-    { "Key: Right Control",     60      },
+    { KEY_EN_ESCAPE,            0       },
+    { KEY_EN_1,                 1       },
+    { KEY_EN_2,                 2       },
+    { KEY_EN_3,                 3       },
+    { KEY_EN_4,                 4       },
+    { KEY_EN_5,                 5       },
+    { KEY_EN_6,                 6       },
+    { KEY_EN_7,                 7       },
+    { KEY_EN_8,                 8       },
+    { KEY_EN_9,                 9       },
+    { KEY_EN_0,                 10      },
+    { KEY_EN_MINUS,             11      },
+    { KEY_EN_EQUALS,            12      },
+    { KEY_EN_BACKSPACE,         13      },
+    { KEY_EN_TAB,               14      },
+    { KEY_EN_Q,                 15      },
+    { KEY_EN_W,                 16      },
+    { KEY_EN_E,                 17      },
+    { KEY_EN_R,                 18      },
+    { KEY_EN_T,                 19      },
+    { KEY_EN_Y,                 20      },
+    { KEY_EN_U,                 21      },
+    { KEY_EN_I,                 22      },
+    { KEY_EN_O,                 23      },
+    { KEY_EN_P,                 24      },
+    { KEY_EN_LEFT_BRACKET,      25      },
+    { KEY_EN_RIGHT_BRACKET,     26      },
+    { KEY_EN_ANSI_BACK_SLASH,   27      },
+    { KEY_EN_CAPS_LOCK,         28      },
+    { KEY_EN_A,                 29      },
+    { KEY_EN_S,                 30      },
+    { KEY_EN_D,                 31      },
+    { KEY_EN_F,                 32      },
+    { KEY_EN_G,                 33      },
+    { KEY_EN_H,                 34      },
+    { KEY_EN_J,                 35      },
+    { KEY_EN_K,                 36      },
+    { KEY_EN_L,                 37      },
+    { KEY_EN_SEMICOLON,         38      },
+    { KEY_EN_QUOTE,             39      },
+    { KEY_EN_ANSI_ENTER,        40      },
+    { KEY_EN_LEFT_SHIFT,        41      },
+    { KEY_EN_Z,                 42      },
+    { KEY_EN_X,                 43      },
+    { KEY_EN_C,                 44      },
+    { KEY_EN_V,                 45      },
+    { KEY_EN_B,                 46      },
+    { KEY_EN_N,                 47      },
+    { KEY_EN_M,                 48      },
+    { KEY_EN_COMMA,             49      },
+    { KEY_EN_PERIOD,            50      },
+    { KEY_EN_FORWARD_SLASH,     51      },
+    { KEY_EN_RIGHT_SHIFT,       52      },
+    { KEY_EN_LEFT_CONTROL,      53      },
+    { KEY_EN_LEFT_WINDOWS,      54      },
+    { KEY_EN_LEFT_ALT,          55      },
+    { KEY_EN_SPACE,             56      },
+    { KEY_EN_RIGHT_ALT,         57      },
+    { KEY_EN_RIGHT_FUNCTION,    58      },
+    { KEY_EN_MENU,              59      },
+    { KEY_EN_RIGHT_CONTROL,     60      },
 };
 
-RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* annepro2_ptr) 
+/**------------------------------------------------------------------*\
+    @name Anne Pro 2
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectAnnePro2Controllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* controller_ptr) 
 {
-    annepro2    = annepro2_ptr;
+    controller  = controller_ptr;
 
     name        = "Anne Pro 2";
     vendor      = "Obinslab";
     type        = DEVICE_TYPE_KEYBOARD;
     description = "Obinslab Anne Pro 2 Device";
-    location    = annepro2->GetDeviceLocation();
-    serial      = annepro2->GetSerialString();
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
 
     mode Direct;
     Direct.name       = "Direct";
@@ -130,7 +141,7 @@ RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* annepro2_ptr)
 
 RGBController_AnnePro2::~RGBController_AnnePro2() 
 {
-    delete annepro2;
+    delete controller;
 }
 
 void RGBController_AnnePro2::SetupZones() 
@@ -211,7 +222,7 @@ void RGBController_AnnePro2::DeviceUpdateLEDs()
         led_real_idx++;
     }
 
-    annepro2->SendDirect(frame_buf_length, frame_buf);
+    controller->SendDirect(frame_buf_length, frame_buf);
 }
 
 void RGBController_AnnePro2::UpdateZoneLEDs(int /*zone*/) 

Controllers/AnnePro2Controller/RGBController_AnnePro2.h

@@ -14,7 +14,7 @@
 class RGBController_AnnePro2 : public RGBController
 {
 public:
-    RGBController_AnnePro2(AnnePro2Controller* annepro2_ptr);
+    RGBController_AnnePro2(AnnePro2Controller* controller_ptr);
     ~RGBController_AnnePro2();
 
     void        SetupZones();
@@ -28,5 +28,5 @@ public:
     void        DeviceUpdateMode();
 
 private:
-    AnnePro2Controller*   annepro2;
+    AnnePro2Controller*   controller;
 };

Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp

@@ -1,34 +1,38 @@
-#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
-        if(rgb_controller->type != DEVICE_TYPE_UNKNOWN)
-        {
-            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);
+#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
+        if(rgb_controller->type != DEVICE_TYPE_UNKNOWN)
+        {
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+        else
+        {
+            delete 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);

Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.cpp

@@ -1,319 +1,329 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraCore.cpp           |
-|                                           |
-|  Generic RGB Interface for ROG Aura Core  |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/17/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraCore.h"
-
-RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* aura_ptr)
-{
-    aura        = aura_ptr;
-
-    name        = "ASUS Aura Core Device";
-    vendor      = "ASUS";
-    location    = aura->GetDeviceLocation();
-    serial      = aura->GetSerialString();    
-    description = "ASUS Aura Core Device";
-    type        = DEVICE_TYPE_UNKNOWN;
-
-    if(aura->aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
-    {
-        SetupKeyboard();
-    }
-    else if(aura->aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
-    {
-        SetupGA15DH();
-    }
-
-    SetupZones();
-}
-
-void RGBController_AuraCore::SetupKeyboard()
-{
-    name        = "ASUS Aura Keyboard";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "ASUS Aura Core Device";
-
-    mode Static;
-    Static.name       = "Static";
-    Static.value      = AURA_CORE_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      = AURA_CORE_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Breathing.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Breathing);
-
-    mode ColorCycle;
-    ColorCycle.name       = "Color Cycle";
-    ColorCycle.value      = AURA_CORE_MODE_SPECTRUM_CYCLE;
-    ColorCycle.flags      = 0;
-    ColorCycle.color_mode = MODE_COLORS_NONE;
-    modes.push_back(ColorCycle);
-}
-
-void RGBController_AuraCore::SetupGA15DH()
-{
-    name        = "ASUS Aura GA15DH";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_LEDSTRIP;
-    description = "ASUS Aura Core Device";
-
-    mode Static;
-    Static.name             = "Static";
-    Static.value            = AURA_CORE_MODE_STATIC;
-    Static.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Static.colors_min       = 1;
-    Static.colors_max       = 1;
-    Static.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name          = "Breathing";
-    Breathing.value         = AURA_CORE_MODE_BREATHING;
-    Breathing.flags         = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Breathing.speed_min     = AURA_CORE_SPEED_SLOW;
-    Breathing.speed_max     = AURA_CORE_SPEED_FAST;
-    Breathing.speed         = AURA_CORE_SPEED_NORMAL;
-    Breathing.colors_min    = 1;
-    Breathing.colors_max    = 2;
-    Breathing.color_mode    = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors.resize(2);
-    modes.push_back(Breathing);
-
-    mode ColorCycle;
-    ColorCycle.name         = "Color Cycle";
-    ColorCycle.value        = AURA_CORE_MODE_SPECTRUM_CYCLE;
-    ColorCycle.flags        = MODE_FLAG_HAS_SPEED;
-    ColorCycle.speed_min    = AURA_CORE_SPEED_SLOW;
-    ColorCycle.speed_max    = AURA_CORE_SPEED_FAST;
-    ColorCycle.speed        = AURA_CORE_SPEED_NORMAL;
-    ColorCycle.color_mode   = MODE_COLORS_NONE;
-    modes.push_back(ColorCycle);
-
-    mode Rainbow;
-    Rainbow.name            = "Rainbow";
-    Rainbow.value           = AURA_CORE_MODE_RAINBOW;
-    Rainbow.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    Rainbow.speed_min       = AURA_CORE_SPEED_SLOW;
-    Rainbow.speed_max       = AURA_CORE_SPEED_FAST;
-    Rainbow.speed           = AURA_CORE_SPEED_NORMAL;
-    Rainbow.direction       = MODE_DIRECTION_RIGHT;
-    Rainbow.color_mode      = MODE_COLORS_NONE;
-    modes.push_back(Rainbow);
-
-    mode Strobe;
-    Strobe.name             = "Strobe";
-    Strobe.value            = AURA_CORE_MODE_STROBE;
-    Strobe.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Strobe.colors_min       = 1;
-    Strobe.colors_max       = 1;
-    Strobe.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-    Strobe.colors.resize(1);
-    modes.push_back(Strobe);
-
-    mode Comet;
-    Comet.name              = "Comet";
-    Comet.value             = AURA_CORE_MODE_COMET;
-    Comet.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Comet.colors_min        = 1;
-    Comet.colors_max        = 1;
-    Comet.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Comet.colors.resize(1);
-    modes.push_back(Comet);
-
-    mode Flash;
-    Flash.name              = "Flash & Dash";
-    Flash.value             = AURA_CORE_MODE_FLASHNDASH;
-    Flash.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Flash.colors_min        = 1;
-    Flash.colors_max        = 1;
-    Flash.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Flash.colors.resize(1);
-    modes.push_back(Flash);
-
-    mode Irradiation;
-    Irradiation.name        = "Irradiation";
-    Irradiation.value       = AURA_CORE_MODE_IRRADIATION;
-    Irradiation.flags       = 0;
-    Irradiation.color_mode  = MODE_COLORS_NONE;
-    modes.push_back(Irradiation);
-
-    mode Direct;
-    Static.name       = "Direct";
-    Static.value      = AURA_CORE_MODE_DIRECT;
-    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Static);
-}
-
-RGBController_AuraCore::~RGBController_AuraCore()
-{
-    delete aura;
-}
-
-void RGBController_AuraCore::SetupZones()
-{
-    zone auraZone;
-
-    if(aura->aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
-    {
-        auraZone.name       = "Keyboard";
-        auraZone.type       = ZONE_TYPE_SINGLE;
-        auraZone.leds_min   = 4;
-        auraZone.leds_max   = 4;
-        auraZone.leds_count = 4;
-        auraZone.matrix_map = NULL;
-    }
-    else if(aura->aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
-    {
-        auraZone.name       = "GA15DH";
-        auraZone.type       = ZONE_TYPE_LINEAR;
-        auraZone.leds_min   = 20;
-        auraZone.leds_max   = 20;
-        auraZone.leds_count = 20;
-        auraZone.matrix_map = NULL;
-    }
-    else
-    {
-        auraZone.leds_count = 0;
-    }
-
-    zones.push_back(auraZone);
-
-    for(unsigned int led_idx = 0; led_idx < auraZone.leds_count; led_idx++)
-    {
-        led KeyLED;
-        KeyLED.name = auraZone.name + " ";
-        KeyLED.name.append(std::to_string(led_idx + 1));
-        leds.push_back(KeyLED);
-    }
-
-    SetupColors();
-}
-
-void RGBController_AuraCore::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AuraCore::DeviceUpdateLEDs()
-{
-    UpdateZoneLEDs(0);
-}
-
-void RGBController_AuraCore::UpdateZoneLEDs(int /*zone*/)
-{
-    if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
-    {
-        std::vector<AuraColor>  aura_colors;
-        std::vector<RGBColor>&  color_set = colors;
-
-        if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-        {
-            color_set = modes[active_mode].colors;
-        }
-
-        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
-        {
-            AuraColor new_color;
-
-            new_color.red   = RGBGetRValue(color_set[led_idx]);
-            new_color.green = RGBGetGValue(color_set[led_idx]);
-            new_color.blue  = RGBGetBValue(color_set[led_idx]);
-
-            aura_colors.push_back(new_color);
-        }
-
-        aura->UpdateDirect(aura_colors);
-    }
-    else if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
-    {
-        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
-        {
-            UpdateSingleLED(led_idx);
-        }
-    }
-    else
-    {
-        UpdateSingleLED(0);
-    }
-}
-
-void RGBController_AuraCore::UpdateSingleLED(int led)
-{
-    unsigned char speed = 0xFF;
-    unsigned char red   = 0;
-    unsigned char green = 0;
-    unsigned char blue  = 0;
-    unsigned char dir   = 0;
-    mode& curr_mode     = modes[active_mode];
-
-    if(curr_mode.color_mode == MODE_COLORS_PER_LED)
-    {
-        red     = RGBGetRValue(colors[led]);
-        green   = RGBGetGValue(colors[led]);
-        blue    = RGBGetBValue(colors[led]);
-    }
-    else if(curr_mode.color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        red     = RGBGetRValue(curr_mode.colors[led]);
-        green   = RGBGetGValue(curr_mode.colors[led]);
-        blue    = RGBGetBValue(curr_mode.colors[led]);
-    }
-
-    if(curr_mode.flags & MODE_FLAG_HAS_SPEED)
-    {
-        speed   = curr_mode.speed;
-    }
-
-    if(curr_mode.flags & MODE_FLAG_HAS_DIRECTION_LR)
-    {
-        if(curr_mode.direction == MODE_DIRECTION_RIGHT)
-        {
-            dir = 1;
-        }
-    }
-
-    aura->SendUpdate
-            (
-            led,
-            curr_mode.value,
-            speed,
-            dir,
-            red,
-            green,
-            blue
-            );
-
-    aura->SendSet();
-    aura->SendApply();
-}
-
-void RGBController_AuraCore::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_AuraCore::DeviceUpdateMode()
-{
-    if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
-    {
-        aura->InitDirectMode();
-    }
-    else
-    {
-        DeviceUpdateLEDs();
-    }
-}
+/*-----------------------------------------*\
+|  RGBController_AsusAuraCore.cpp           |
+|                                           |
+|  Generic RGB Interface for ROG Aura Core  |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/17/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusAuraCore.h"
+
+/**------------------------------------------------------------------*\
+    @name Asus AURA Core
+    @type USB
+    @save :x:
+    @direct :warning:
+    @effects :white_check_mark:
+    @detectors DetectAsusAuraCoreControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "ASUS Aura Core Device";
+    vendor      = "ASUS";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();    
+    description = "ASUS Aura Core Device";
+    type        = DEVICE_TYPE_UNKNOWN;
+
+    if(controller->aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
+    {
+        SetupKeyboard();
+    }
+    else if(controller->aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
+    {
+        SetupGA15DH();
+    }
+
+    SetupZones();
+}
+
+void RGBController_AuraCore::SetupKeyboard()
+{
+    name        = "ASUS Aura Keyboard";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "ASUS Aura Core Device";
+
+    mode Static;
+    Static.name       = "Static";
+    Static.value      = AURA_CORE_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      = AURA_CORE_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Breathing);
+
+    mode ColorCycle;
+    ColorCycle.name       = "Color Cycle";
+    ColorCycle.value      = AURA_CORE_MODE_SPECTRUM_CYCLE;
+    ColorCycle.flags      = 0;
+    ColorCycle.color_mode = MODE_COLORS_NONE;
+    modes.push_back(ColorCycle);
+}
+
+void RGBController_AuraCore::SetupGA15DH()
+{
+    name        = "ASUS Aura GA15DH";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_LEDSTRIP;
+    description = "ASUS Aura Core Device";
+
+    mode Static;
+    Static.name             = "Static";
+    Static.value            = AURA_CORE_MODE_STATIC;
+    Static.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min       = 1;
+    Static.colors_max       = 1;
+    Static.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name          = "Breathing";
+    Breathing.value         = AURA_CORE_MODE_BREATHING;
+    Breathing.flags         = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Breathing.speed_min     = AURA_CORE_SPEED_SLOW;
+    Breathing.speed_max     = AURA_CORE_SPEED_FAST;
+    Breathing.speed         = AURA_CORE_SPEED_NORMAL;
+    Breathing.colors_min    = 1;
+    Breathing.colors_max    = 2;
+    Breathing.color_mode    = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors.resize(2);
+    modes.push_back(Breathing);
+
+    mode ColorCycle;
+    ColorCycle.name         = "Color Cycle";
+    ColorCycle.value        = AURA_CORE_MODE_SPECTRUM_CYCLE;
+    ColorCycle.flags        = MODE_FLAG_HAS_SPEED;
+    ColorCycle.speed_min    = AURA_CORE_SPEED_SLOW;
+    ColorCycle.speed_max    = AURA_CORE_SPEED_FAST;
+    ColorCycle.speed        = AURA_CORE_SPEED_NORMAL;
+    ColorCycle.color_mode   = MODE_COLORS_NONE;
+    modes.push_back(ColorCycle);
+
+    mode Rainbow;
+    Rainbow.name            = "Rainbow";
+    Rainbow.value           = AURA_CORE_MODE_RAINBOW;
+    Rainbow.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    Rainbow.speed_min       = AURA_CORE_SPEED_SLOW;
+    Rainbow.speed_max       = AURA_CORE_SPEED_FAST;
+    Rainbow.speed           = AURA_CORE_SPEED_NORMAL;
+    Rainbow.direction       = MODE_DIRECTION_RIGHT;
+    Rainbow.color_mode      = MODE_COLORS_NONE;
+    modes.push_back(Rainbow);
+
+    mode Strobe;
+    Strobe.name             = "Strobe";
+    Strobe.value            = AURA_CORE_MODE_STROBE;
+    Strobe.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Strobe.colors_min       = 1;
+    Strobe.colors_max       = 1;
+    Strobe.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    Strobe.colors.resize(1);
+    modes.push_back(Strobe);
+
+    mode Comet;
+    Comet.name              = "Comet";
+    Comet.value             = AURA_CORE_MODE_COMET;
+    Comet.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Comet.colors_min        = 1;
+    Comet.colors_max        = 1;
+    Comet.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Comet.colors.resize(1);
+    modes.push_back(Comet);
+
+    mode Flash;
+    Flash.name              = "Flash & Dash";
+    Flash.value             = AURA_CORE_MODE_FLASHNDASH;
+    Flash.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Flash.colors_min        = 1;
+    Flash.colors_max        = 1;
+    Flash.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Flash.colors.resize(1);
+    modes.push_back(Flash);
+
+    mode Irradiation;
+    Irradiation.name        = "Irradiation";
+    Irradiation.value       = AURA_CORE_MODE_IRRADIATION;
+    Irradiation.flags       = 0;
+    Irradiation.color_mode  = MODE_COLORS_NONE;
+    modes.push_back(Irradiation);
+
+    mode Direct;
+    Static.name       = "Direct";
+    Static.value      = AURA_CORE_MODE_DIRECT;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Static);
+}
+
+RGBController_AuraCore::~RGBController_AuraCore()
+{
+    delete controller;
+}
+
+void RGBController_AuraCore::SetupZones()
+{
+    zone auraZone;
+
+    if(controller->aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
+    {
+        auraZone.name       = "Keyboard";
+        auraZone.type       = ZONE_TYPE_SINGLE;
+        auraZone.leds_min   = 4;
+        auraZone.leds_max   = 4;
+        auraZone.leds_count = 4;
+        auraZone.matrix_map = NULL;
+    }
+    else if(controller->aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
+    {
+        auraZone.name       = "GA15DH";
+        auraZone.type       = ZONE_TYPE_LINEAR;
+        auraZone.leds_min   = 20;
+        auraZone.leds_max   = 20;
+        auraZone.leds_count = 20;
+        auraZone.matrix_map = NULL;
+    }
+    else
+    {
+        auraZone.leds_count = 0;
+    }
+
+    zones.push_back(auraZone);
+
+    for(unsigned int led_idx = 0; led_idx < auraZone.leds_count; led_idx++)
+    {
+        led KeyLED;
+        KeyLED.name = auraZone.name + " ";
+        KeyLED.name.append(std::to_string(led_idx + 1));
+        leds.push_back(KeyLED);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AuraCore::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AuraCore::DeviceUpdateLEDs()
+{
+    UpdateZoneLEDs(0);
+}
+
+void RGBController_AuraCore::UpdateZoneLEDs(int /*zone*/)
+{
+    if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
+    {
+        std::vector<AuraColor>  aura_colors;
+        std::vector<RGBColor>&  color_set = colors;
+
+        if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+        {
+            color_set = modes[active_mode].colors;
+        }
+
+        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
+        {
+            AuraColor new_color;
+
+            new_color.red   = RGBGetRValue(color_set[led_idx]);
+            new_color.green = RGBGetGValue(color_set[led_idx]);
+            new_color.blue  = RGBGetBValue(color_set[led_idx]);
+
+            aura_colors.push_back(new_color);
+        }
+
+        controller->UpdateDirect(aura_colors);
+    }
+    else if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
+    {
+        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
+        {
+            UpdateSingleLED(led_idx);
+        }
+    }
+    else
+    {
+        UpdateSingleLED(0);
+    }
+}
+
+void RGBController_AuraCore::UpdateSingleLED(int led)
+{
+    unsigned char speed = 0xFF;
+    unsigned char red   = 0;
+    unsigned char green = 0;
+    unsigned char blue  = 0;
+    unsigned char dir   = 0;
+    mode& curr_mode     = modes[active_mode];
+
+    if(curr_mode.color_mode == MODE_COLORS_PER_LED)
+    {
+        red     = RGBGetRValue(colors[led]);
+        green   = RGBGetGValue(colors[led]);
+        blue    = RGBGetBValue(colors[led]);
+    }
+    else if(curr_mode.color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        red     = RGBGetRValue(curr_mode.colors[led]);
+        green   = RGBGetGValue(curr_mode.colors[led]);
+        blue    = RGBGetBValue(curr_mode.colors[led]);
+    }
+
+    if(curr_mode.flags & MODE_FLAG_HAS_SPEED)
+    {
+        speed   = curr_mode.speed;
+    }
+
+    if(curr_mode.flags & MODE_FLAG_HAS_DIRECTION_LR)
+    {
+        if(curr_mode.direction == MODE_DIRECTION_RIGHT)
+        {
+            dir = 1;
+        }
+    }
+
+    controller->SendUpdate
+            (
+            led,
+            curr_mode.value,
+            speed,
+            dir,
+            red,
+            green,
+            blue
+            );
+
+    controller->SendSet();
+    controller->SendApply();
+}
+
+void RGBController_AuraCore::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_AuraCore::DeviceUpdateMode()
+{
+    if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
+    {
+        controller->InitDirectMode();
+    }
+    else
+    {
+        DeviceUpdateLEDs();
+    }
+}

Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.h

@@ -1,35 +1,35 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraCore.h             |
-|                                           |
-|  Generic RGB Interface for ROG Aura Core  |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/17/2020   |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AsusAuraCoreController.h"
-
-class RGBController_AuraCore : public RGBController
-{
-public:
-    RGBController_AuraCore(AuraCoreController* aura_ptr);
-    ~RGBController_AuraCore();
-
-    void        SetupKeyboard();
-    void        SetupGA15DH();
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    AuraCoreController* aura;
-};
+/*-----------------------------------------*\
+|  RGBController_AsusAuraCore.h             |
+|                                           |
+|  Generic RGB Interface for ROG Aura Core  |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/17/2020   |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AsusAuraCoreController.h"
+
+class RGBController_AuraCore : public RGBController
+{
+public:
+    RGBController_AuraCore(AuraCoreController* controller_ptr);
+    ~RGBController_AuraCore();
+
+    void        SetupKeyboard();
+    void        SetupGA15DH();
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    AuraCoreController* controller;
+};

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -8,6 +8,7 @@
 
 #include "Detector.h"
 #include "AsusAuraGPUController.h"
+#include "LogManager.h"
 #include "RGBController.h"
 #include "RGBController_AsusAuraGPU.h"
 #include "i2c_smbus.h"
@@ -28,34 +29,62 @@ typedef struct
     const char *    name;
 } gpu_pci_device;
 
+#define ASUSGPU_CONTROLLER_NAME "ASUS Aura GPU"
 #define GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
 
 static const gpu_pci_device device_list[] =
 {
-    { NVIDIA_VEN,       NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,       ASUS_GTX1060_STRIX,                     0x29,   "ASUS GTX 1060 Strix"                       },
-    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_GAMING,              0x29,   "ASUS GTX 1070 Strix Gaming"                },
-    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_OC,                  0x29,   "ASUS GTX 1070 Strix OC"                    },
-    { NVIDIA_VEN,       NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,    0x29,   "ASUS ROG Strix GTX1070 Ti A8G Gaming"      },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_GTX1080_STRIX,                     0x29,   "ASUS GTX 1080 Strix OC"                    },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_A8G_GAMING,      0x29,   "ASUS ROG Strix GTX1080 A8G Gaming"         },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_O8G_GAMING,      0x29,   "ASUS ROG Strix GTX1080 O8G Gaming"         },
-    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_GAMING,        0x29,   "ASUS ROG Strix GTX1080 Ti Gaming"          },
-    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,    0x29,   "ASUS ROG Strix GTX1080 Ti 11G Gaming"      },
-    { NVIDIA_VEN,       NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1650S_OC,             0x2A,   "ASUS ROG Strix GTX 1650S OC 4G"            },
-    { NVIDIA_VEN,       NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_GTX1660TI_OC,                  0x2A,   "ASUS ROG GTX 1660 Ti OC 6G"                },
-    { NVIDIA_VEN,       NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_EVO_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2060 EVO Gaming 6G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING, 0x2A,   "ASUS ROG STRIX RTX 2060S A8G EVO Gaming 6G"},
-    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_A8G_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2070 A8G Gaming 8G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_O8G_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2070 O8G Gaming 8G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,     0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,     0x2A,   "ASUS ROG STRIX RTX 2070S O8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080_O8G_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2080 O8G Gaming"        },
-    { NVIDIA_VEN,       NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,   0x2A,   "ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    },
-    { AMD_GPU_VEN,      AMD_VEGA10_DEV,             ASUS_SUB_VEN,       ASUS_VEGA64_STRIX,                      0x29,   "ASUS Vega 64 Strix"                        },
-    { AMD_GPU_VEN,      AMD_NAVI10_DEV,             ASUS_SUB_VEN,       ASUS_RX5700XT_STRIX_GAMING_OC,          0x2A,   "ASUS RX 5700XT Strix Gaming OC"            },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX480_STRIX_GAMING_OC,             0x29,   "ASUS ROG STRIX RX480 Gaming OC"            },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX570_STRIX_O4G_GAMING_OC,         0x29,   "ASUS RX 570 Strix O4G Gaming OC"           },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX580_STRIX_GAMING_OC,             0x29,   "ASUS RX 580 Strix Gaming OC"               }
+    { NVIDIA_VEN,       NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,       ASUS_GTX1050_STRIX_O2G_GAMING,              0x29,   "ASUS ROG Strix GTX 1050 O2G Gaming"        },
+    { NVIDIA_VEN,       NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29,   "ASUS ROG Strix GTX 1050 TI O4G Gaming"     },
+    { NVIDIA_VEN,       NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING_2,      0x29,   "ASUS ROG Strix GTX 1050 TI O4G Gaming"     },
+    { NVIDIA_VEN,       NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,       ASUS_GTX1060_STRIX_6G_GAMING,               0x29,   "ASUS GTX 1060 Strix 6G Gaming"             },
+    { NVIDIA_VEN,       NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,       ASUS_GTX1060_STRIX,                         0x29,   "ASUS GTX 1060 Strix"                       },
+    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_GAMING,                  0x29,   "ASUS GTX 1070 Strix Gaming"                },
+    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_OC,                      0x29,   "ASUS GTX 1070 Strix OC"                    },
+    { NVIDIA_VEN,       NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1070TI_8G_GAMING,         0x29,   "ASUS ROG Strix GTX1070 Ti 8G Gaming"       },
+    { NVIDIA_VEN,       NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,        0x29,   "ASUS ROG Strix GTX1070 Ti A8G Gaming"      },
+    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_GTX1080_STRIX,                         0x29,   "ASUS GTX 1080 Strix OC"                    },
+    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_A8G_GAMING,          0x29,   "ASUS ROG Strix GTX1080 A8G Gaming"         },
+    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_O8G_GAMING,          0x29,   "ASUS ROG Strix GTX1080 O8G Gaming"         },
+    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_GAMING,            0x29,   "ASUS ROG Strix GTX1080 Ti Gaming"          },
+    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,        0x29,   "ASUS ROG Strix GTX1080 Ti 11G Gaming"      },
+    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING,       0x29,   "ASUS ROG Strix GTX1080 Ti O11G Gaming"     },
+    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING_A02,   0x29,   "ASUS ROG Strix GTX1080 Ti O11G Gaming"     },
+    { NVIDIA_VEN,       NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1650S_OC,                 0x2A,   "ASUS ROG Strix GTX 1650S OC 4G"            },
+    { NVIDIA_VEN,       NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A,   "ASUS ROG Strix GTX 1660S O6G Gaming"       },
+    { NVIDIA_VEN,       NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_GTX1660TI_OC,                      0x2A,   "ASUS ROG GTX 1660 Ti OC 6G"                },
+    { NVIDIA_VEN,       NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2060 EVO Gaming 6G"     },
+    { NVIDIA_VEN,       NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2060 O6G Gaming 6G"     },
+    { NVIDIA_VEN,       NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2060 O6G EVO Gaming"    },
+    { NVIDIA_VEN,       NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2060S 8G Gaming 8G"     },
+    { NVIDIA_VEN,       NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A,   "ASUS ROG STRIX RTX 2060S A8G EVO Gaming 8G"},
+    { NVIDIA_VEN,       NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2060S O8G Gaming 8G"    },
+    { NVIDIA_VEN,       NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2060S A8G Gaming 8G"    },
+    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2070 A8G Gaming 8G"     },
+    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2070 O8G Gaming 8G"     },
+    { NVIDIA_VEN,       NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
+    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
+    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
+    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729,    0x2A,   "ASUS ROG STRIX RTX 2070S O8G Gaming"       },
+    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707,     0x2A,   "ASUS ROG STRIX RTX 2070S 8G Gaming"        },
+    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2070S O8G Gaming 8G"    },
+    { NVIDIA_VEN,       NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2080 O8G Gaming"        },
+    { NVIDIA_VEN,       NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080S_A8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2080S A8G Gaming"       },
+    { NVIDIA_VEN,       NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2080S O8G Gaming"       },
+    { NVIDIA_VEN,       NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080S_O8G_WHITE,          0x2A,   "ASUS ROG STRIX RTX 2080S O8G White"        },
+    { NVIDIA_VEN,       NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A,   "ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     },
+    { NVIDIA_VEN,       NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A,   "ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    },
+    { NVIDIA_VEN,       NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A,   "ASUS ROG STRIX RTX 2080 Ti A11G Gaming"    },
+    { NVIDIA_VEN,       NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,       ASUS_TUF_RTX_3060_TI_O8G_OC,                0x2A,   "ASUS TUF RTX 3060 Ti 8G Gaming OC"         },
+    { AMD_GPU_VEN,      AMD_VEGA10_DEV,             ASUS_SUB_VEN,       ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29,   "ASUS AREZ Strix RX Vega 56 O8G"            },
+    { AMD_GPU_VEN,      AMD_VEGA10_DEV,             ASUS_SUB_VEN,       ASUS_VEGA64_STRIX,                          0x29,   "ASUS Vega 64 Strix"                        },
+    { AMD_GPU_VEN,      AMD_NAVI10_DEV,             ASUS_SUB_VEN,       ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A,   "ASUS RX 5600XT Strix O6G Gaming"           },
+    { AMD_GPU_VEN,      AMD_NAVI10_DEV,             ASUS_SUB_VEN,       ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A,   "ASUS RX 5700XT Strix Gaming OC"            },
+    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX480_STRIX_GAMING_OC,                 0x29,   "ASUS ROG STRIX RX480 Gaming OC"            },
+    { AMD_GPU_VEN,      AMD_POLARIS11,              ASUS_SUB_VEN,       ASUS_RX560_STRIX_4G_GAMING,                 0x29,   "ASUS ROG STRIX RX560 Gaming"               },
+    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29,   "ASUS RX 570 Strix O4G Gaming OC"           },
+    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX580_STRIX_GAMING_OC,                 0x29,   "ASUS RX 580 Strix Gaming OC"               },
+    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX580_STRIX_GAMING_TOP,                0x29,   "ASUS RX 580 Strix Gaming TOP"              },
 };  
 
 /******************************************************************************************\
@@ -73,6 +102,8 @@ bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char addres
     unsigned char aura_gpu_magic_high = bus->i2c_smbus_read_byte_data(address, 0x20);                        // High Byte of magic (0x15)                        
     unsigned char aura_gpu_magic_low = bus->i2c_smbus_read_byte_data(address, 0x21);                         // Low Byte of magic (0x89)
 
+    LOG_DEBUG("[%s] Test GPU expect: 0x1589 received: 0x%02X%02X", ASUSGPU_CONTROLLER_NAME, aura_gpu_magic_high, aura_gpu_magic_low);
+
     if((aura_gpu_magic_high << 8) + aura_gpu_magic_low == AURA_GPU_MAGIC_VAL)
     {
         pass = true;
@@ -92,10 +123,7 @@ bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char addres
 
 void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses)
 {
-    AuraGPUController* new_aura_gpu;
-    RGBController_AuraGPU* new_controller;
-
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
         for(unsigned int dev_idx = 0; dev_idx < GPU_NUM_DEVICES; dev_idx++)
         {
@@ -104,16 +132,18 @@ void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses)
                busses[bus]->pci_subsystem_vendor == device_list[dev_idx].pci_subsystem_vendor &&
                busses[bus]->pci_subsystem_device == device_list[dev_idx].pci_subsystem_device)
             {
-                if (TestForAsusAuraGPUController(busses[bus], device_list[dev_idx].controller_address))
+                LOG_DEBUG(GPU_DETECT_MESSAGE, ASUSGPU_CONTROLLER_NAME, bus, device_list[dev_idx].pci_device, device_list[dev_idx].pci_subsystem_device, device_list[dev_idx].name );
+                
+                if(TestForAsusAuraGPUController(busses[bus], device_list[dev_idx].controller_address))
                 {
-                    new_aura_gpu         = new AuraGPUController(busses[bus], device_list[dev_idx].controller_address);
-                    new_controller       = new RGBController_AuraGPU(new_aura_gpu);
-                    new_controller->name = device_list[dev_idx].name;
-                    ResourceManager::get()->RegisterRGBController(new_controller);
+                    AuraGPUController*     controller     = new AuraGPUController(busses[bus], device_list[dev_idx].controller_address);
+                    RGBController_AuraGPU* rgb_controller = new RGBController_AuraGPU(controller);
+                    rgb_controller->name = device_list[dev_idx].name;
+                    ResourceManager::get()->RegisterRGBController(rgb_controller);
                 }
             }
         }
     }
 } /* DetectAsusAuraGPUControllers() */
 
-REGISTER_I2C_DETECTOR("ASUS Aura GPU", DetectAsusAuraGPUControllers);
+REGISTER_I2C_DETECTOR(ASUSGPU_CONTROLLER_NAME, DetectAsusAuraGPUControllers);

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp

@@ -1,204 +1,211 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraGPU.h              |
-|                                           |
-|  Generic RGB Interface for Asus Aura GPU  |
-|                                           |
-|  Jan Rettig (Klapstuhl) 14.02.2020        |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraGPU.h"
-
-int RGBController_AuraGPU::GetDeviceMode()
-{
-    int dev_mode = aura_gpu->AuraGPURegisterRead(AURA_GPU_REG_MODE);
-    int color_mode = MODE_COLORS_PER_LED;
-
-    if(dev_mode == AURA_GPU_MODE_STATIC)
-    {
-        if (aura_gpu->direct)
-        {
-            dev_mode = AURA_GPU_MODE_DIRECT;
-        } 
-    }
-
-    switch(dev_mode)
-    {
-    case AURA_GPU_MODE_OFF:
-    case AURA_GPU_MODE_SPECTRUM_CYCLE:
-        color_mode = MODE_COLORS_NONE;
-        break;
-    }
-
-    for(std::size_t mode = 0; mode < modes.size(); mode++)
-    {
-        if(modes[mode].value == dev_mode)
-        {
-            active_mode            = mode;
-            modes[mode].color_mode = color_mode;
-        }   
-    }
-
-    return(active_mode);
-}
-
-RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * aura_gpu_ptr)
-{
-    aura_gpu = aura_gpu_ptr;
-
-
-    name        = aura_gpu->GetDeviceName();
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_GPU;
-    description = "ASUS Aura GPU Device";
-    version     = "0.00.1";
-    location    = aura_gpu->GetDeviceLocation();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = AURA_GPU_MODE_DIRECT;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Off;
-    Off.name       = "Off";
-    Off.value      = AURA_GPU_MODE_OFF;
-    Off.flags      = 0;
-    Off.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    mode Static;
-    Static.name       = "Static";
-    Static.value      = AURA_GPU_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      = AURA_GPU_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Breathing.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Breathing);
-
-    mode Flashing;
-    Flashing.name       = "Flashing";
-    Flashing.value      = AURA_GPU_MODE_FLASHING;
-    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Flashing.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Flashing);
-
-    mode Spectrum_Cycle;
-    Spectrum_Cycle.name       = "Spectrum Cycle";
-    Spectrum_Cycle.value      = AURA_GPU_MODE_SPECTRUM_CYCLE;
-    Spectrum_Cycle.flags      = 0;
-    Spectrum_Cycle.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Spectrum_Cycle);
-
-    SetupZones();
-
-    active_mode = GetDeviceMode();
-}
-
-RGBController_AuraGPU::~RGBController_AuraGPU()
-{
-    delete aura_gpu;
-}
-
-void RGBController_AuraGPU::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zone                                               |
-    \*---------------------------------------------------------*/
-    zone aura_gpu_zone;
-    aura_gpu_zone.name          = "GPU";
-    aura_gpu_zone.type          = ZONE_TYPE_SINGLE;
-    aura_gpu_zone.leds_min      = 1;
-    aura_gpu_zone.leds_max      = 1;
-    aura_gpu_zone.leds_count    = 1;
-    aura_gpu_zone.matrix_map    = NULL;
-    zones.push_back(aura_gpu_zone);
-
-    /*---------------------------------------------------------*\
-    | Set up LED                                                |
-    \*---------------------------------------------------------*/
-    led aura_gpu_led;
-    aura_gpu_led.name = "GPU";
-    leds.push_back(aura_gpu_led);
-
-    SetupColors();
-
-    /*---------------------------------------------------------*\
-    | Initialize color                                          |
-    \*---------------------------------------------------------*/
-    unsigned char red = aura_gpu->GetLEDRed();
-    unsigned char grn = aura_gpu->GetLEDGreen();
-    unsigned char blu = aura_gpu->GetLEDBlue();
-
-    colors[0] =  ToRGBColor(red, grn, blu);
-}
-
-void RGBController_AuraGPU::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AuraGPU::DeviceUpdateLEDs()
-{
-    for(std::size_t led = 0; led < colors.size(); led++)
-    {
-        unsigned char red = RGBGetRValue(colors[led]);
-        unsigned char grn = RGBGetGValue(colors[led]);
-        unsigned char blu = RGBGetBValue(colors[led]);
-
-        if (GetMode() == 0)
-        {
-            aura_gpu->SetLEDColorsDirect(red, grn, blu);
-        }
-        else 
-        {
-            aura_gpu->SetLEDColorsEffect(red, grn, blu);
-        }
-    }
-}
-
-void RGBController_AuraGPU::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AuraGPU::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AuraGPU::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_AuraGPU::DeviceUpdateMode()
-{
-    int new_mode = modes[active_mode].value;
-    aura_gpu->direct = false;
-    
-    switch(new_mode)
-    {
-        
-    // Set all LEDs to 0 and Mode to static as a workaround for the non existing Off Mode
-    case AURA_GPU_MODE_OFF:
-        aura_gpu->SetLEDColorsEffect(0, 0, 0);
-        new_mode = AURA_GPU_MODE_STATIC;
-        break;
-    
-    // Direct mode is done by switching to Static and not applying color changes
-    case AURA_GPU_MODE_DIRECT:
-        aura_gpu->direct = true;
-        new_mode = AURA_GPU_MODE_STATIC;
-        break;
-    }
-
-    aura_gpu->SetMode(new_mode);
-}
+/*-----------------------------------------*\
+|  RGBController_AsusAuraGPU.h              |
+|                                           |
+|  Generic RGB Interface for Asus Aura GPU  |
+|                                           |
+|  Jan Rettig (Klapstuhl) 14.02.2020        |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusAuraGPU.h"
+
+int RGBController_AuraGPU::GetDeviceMode()
+{
+    int dev_mode = controller->AuraGPURegisterRead(AURA_GPU_REG_MODE);
+    int color_mode = MODE_COLORS_PER_LED;
+
+    if(dev_mode == AURA_GPU_MODE_STATIC)
+    {
+        if (controller->direct)
+        {
+            dev_mode = AURA_GPU_MODE_DIRECT;
+        } 
+    }
+
+    switch(dev_mode)
+    {
+    case AURA_GPU_MODE_OFF:
+    case AURA_GPU_MODE_SPECTRUM_CYCLE:
+        color_mode = MODE_COLORS_NONE;
+        break;
+    }
+
+    for(std::size_t mode = 0; mode < modes.size(); mode++)
+    {
+        if(modes[mode].value == dev_mode)
+        {
+            active_mode            = mode;
+            modes[mode].color_mode = color_mode;
+        }   
+    }
+
+    return(active_mode);
+}
+
+/**------------------------------------------------------------------*\
+    @name Asus Aura GPU
+    @type SMBus
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark::
+    @detectors DetectAsusAuraGPUControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = controller->GetDeviceName();
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_GPU;
+    description = "ASUS Aura GPU Device";
+    location    = controller->GetDeviceLocation();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = AURA_GPU_MODE_DIRECT;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Off;
+    Off.name       = "Off";
+    Off.value      = AURA_GPU_MODE_OFF;
+    Off.flags      = 0;
+    Off.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Static;
+    Static.name       = "Static";
+    Static.value      = AURA_GPU_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      = AURA_GPU_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Breathing);
+
+    mode Flashing;
+    Flashing.name       = "Flashing";
+    Flashing.value      = AURA_GPU_MODE_FLASHING;
+    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Flashing.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Flashing);
+
+    mode Spectrum_Cycle;
+    Spectrum_Cycle.name       = "Spectrum Cycle";
+    Spectrum_Cycle.value      = AURA_GPU_MODE_SPECTRUM_CYCLE;
+    Spectrum_Cycle.flags      = 0;
+    Spectrum_Cycle.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Spectrum_Cycle);
+
+    SetupZones();
+
+    active_mode = GetDeviceMode();
+}
+
+RGBController_AuraGPU::~RGBController_AuraGPU()
+{
+    delete controller;
+}
+
+void RGBController_AuraGPU::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Set up zone                                               |
+    \*---------------------------------------------------------*/
+    zone aura_gpu_zone;
+    aura_gpu_zone.name          = "GPU";
+    aura_gpu_zone.type          = ZONE_TYPE_SINGLE;
+    aura_gpu_zone.leds_min      = 1;
+    aura_gpu_zone.leds_max      = 1;
+    aura_gpu_zone.leds_count    = 1;
+    aura_gpu_zone.matrix_map    = NULL;
+    zones.push_back(aura_gpu_zone);
+
+    /*---------------------------------------------------------*\
+    | Set up LED                                                |
+    \*---------------------------------------------------------*/
+    led aura_gpu_led;
+    aura_gpu_led.name           = "GPU";
+    leds.push_back(aura_gpu_led);
+
+    SetupColors();
+
+    /*---------------------------------------------------------*\
+    | Initialize color                                          |
+    \*---------------------------------------------------------*/
+    unsigned char red = controller->GetLEDRed();
+    unsigned char grn = controller->GetLEDGreen();
+    unsigned char blu = controller->GetLEDBlue();
+
+    colors[0] =  ToRGBColor(red, grn, blu);
+}
+
+void RGBController_AuraGPU::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AuraGPU::DeviceUpdateLEDs()
+{
+    for(std::size_t led = 0; led < colors.size(); led++)
+    {
+        unsigned char red = RGBGetRValue(colors[led]);
+        unsigned char grn = RGBGetGValue(colors[led]);
+        unsigned char blu = RGBGetBValue(colors[led]);
+
+        if (GetMode() == 0)
+        {
+            controller->SetLEDColorsDirect(red, grn, blu);
+        }
+        else 
+        {
+            controller->SetLEDColorsEffect(red, grn, blu);
+        }
+    }
+}
+
+void RGBController_AuraGPU::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraGPU::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraGPU::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_AuraGPU::DeviceUpdateMode()
+{
+    int new_mode       = modes[active_mode].value;
+    controller->direct = false;
+    
+    switch(new_mode)
+    {
+        // Set all LEDs to 0 and Mode to static as a workaround for the non existing Off Mode
+        case AURA_GPU_MODE_OFF:
+            controller->SetLEDColorsEffect(0, 0, 0);
+            new_mode           = AURA_GPU_MODE_STATIC;
+            break;
+        
+        // Direct mode is done by switching to Static and not applying color changes
+        case AURA_GPU_MODE_DIRECT:
+            controller->direct = true;
+            new_mode           = AURA_GPU_MODE_STATIC;
+            break;
+    }
+
+    controller->SetMode(new_mode);
+}

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.h

@@ -1,35 +1,35 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraGPU.h              |
-|                                           |
-|  Generic RGB Interface for Asus Aura GPU  |
-|                                           |
-|  Jan Rettig (Klapstuhl) 14.02.2020        |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AsusAuraGPUController.h"
-
-class RGBController_AuraGPU : public RGBController
-{
-public:
-    RGBController_AuraGPU(AuraGPUController* aura_gpu_ptr);
-    ~RGBController_AuraGPU();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    AuraGPUController* aura_gpu;
-
-    int        GetDeviceMode();
-};
+/*-----------------------------------------*\
+|  RGBController_AsusAuraGPU.h              |
+|                                           |
+|  Generic RGB Interface for Asus Aura GPU  |
+|                                           |
+|  Jan Rettig (Klapstuhl) 14.02.2020        |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AsusAuraGPUController.h"
+
+class RGBController_AuraGPU : public RGBController
+{
+public:
+    RGBController_AuraGPU(AuraGPUController* controller_ptr);
+    ~RGBController_AuraGPU();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    AuraGPUController* controller;
+
+    int        GetDeviceMode();
+};

Controllers/AsusAuraSMBusController/AsusAuraSMBusController.cpp

@@ -1,295 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraSMBusController.cpp              |
-|                                           |
-|  Driver for ASUS Aura RGB lighting        |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 8/19/2018   |
-\*-----------------------------------------*/
-
-#include "AsusAuraSMBusController.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;
-    this->dev = dev;
-
-    AuraUpdateDeviceName();
-
-    // Read the device configuration table
-    for (int i = 0; i < 64; i++)
-    {
-        config_table[i] = AuraRegisterRead(AURA_REG_CONFIG_TABLE + i);
-    }
-
-    // Read LED count from configuration table
-    led_count = config_table[AURA_CONFIG_LED_COUNT];
-
-    // LED-0116 - First generation motherboard controller
-    if (strcmp(device_name, "LED-0116") == 0)
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT;
-        effect_reg  = AURA_REG_COLORS_EFFECT;
-        channel_cfg = AURA_CONFIG_CHANNEL_V1;
-    }
-    // DIMM_LED-0102 - First generation DRAM controller (Trident Z RGB)
-    else if (strcmp(device_name, "DIMM_LED-0102") == 0)
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT;
-        effect_reg  = AURA_REG_COLORS_EFFECT;
-        channel_cfg = AURA_CONFIG_CHANNEL_V1;
-    }
-    // AUDA0-E6K5-0101 - Second generation DRAM controller (Geil Super Luce)
-    else if (strcmp(device_name, "AUDA0-E6K5-0101") == 0)
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT_V2;
-        effect_reg  = AURA_REG_COLORS_EFFECT_V2;
-        channel_cfg = AURA_CONFIG_CHANNEL_V1;
-    }
-    // AUMA0-E6K5-0106 - Second generation motherboard controller
-    else if (strcmp(device_name, "AUMA0-E6K5-0106") == 0)
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT_V2;
-        effect_reg  = AURA_REG_COLORS_EFFECT_V2;
-        channel_cfg = AURA_CONFIG_CHANNEL_V2;
-    }
-    // AUMA0-E6K5-0105 - Second generation motherboard controller
-    else if (strcmp(device_name, "AUMA0-E6K5-0105") == 0)
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT_V2;
-        effect_reg  = AURA_REG_COLORS_EFFECT_V2;
-        channel_cfg = AURA_CONFIG_CHANNEL_V2;
-    }
-    // AUMA0-E6K5-0104 - Second generation motherboard controller
-    else if (strcmp(device_name, "AUMA0-E6K5-0104") == 0)
-    {
-        direct_reg = AURA_REG_COLORS_DIRECT_V2;
-        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
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT;
-        effect_reg  = AURA_REG_COLORS_EFFECT;
-        channel_cfg = AURA_CONFIG_CHANNEL_V1;
-    }
-}
-
-AuraSMBusController::~AuraSMBusController()
-{
-
-}
-
-std::string AuraSMBusController::GetDeviceName()
-{
-    return(device_name);
-}
-
-std::string AuraSMBusController::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 AuraSMBusController::GetChannel(unsigned int led)
-{
-    return(config_table[channel_cfg + led]);
-}
-
-const char * AuraSMBusController::GetChannelName(unsigned int led)
-{
-    switch (config_table[channel_cfg + led])
-    {
-    case (unsigned char)AURA_LED_CHANNEL_AUDIO:
-        return(aura_channels[0]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_BACKPLATE:
-        return(aura_channels[1]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_BACK_IO:
-        return(aura_channels[2]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_CENTER:
-        return(aura_channels[3]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_CENTER_START:
-        return(aura_channels[4]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_DRAM:
-        return(aura_channels[5]);
-        break;
-    
-    case (unsigned char)AURA_LED_CHANNEL_PCIE:
-        return(aura_channels[6]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_RGB_HEADER:
-        return(aura_channels[7]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_RGB_HEADER_2:
-        return(aura_channels[8]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_RGB_HEADER_3:
-        return(aura_channels[9]);
-        break;
-
-    default:
-        return(aura_channels[10]);
-        break;
-    }
-}
-
-unsigned int AuraSMBusController::GetLEDCount()
-{
-    return(led_count);
-}
-
-unsigned char AuraSMBusController::GetLEDRed(unsigned int led)
-{
-    return(AuraRegisterRead(direct_reg + ( 3 * led )));
-}
-
-unsigned char AuraSMBusController::GetLEDGreen(unsigned int led)
-{
-    return(AuraRegisterRead(direct_reg + ( 3 * led ) + 2));
-}
-
-unsigned char AuraSMBusController::GetLEDBlue(unsigned int led)
-{
-    return(AuraRegisterRead(direct_reg + ( 3 * led ) + 1));
-}
-
-void AuraSMBusController::SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char* colors = new unsigned char[led_count * 3];
-
-    for (unsigned int i = 0; i < (led_count * 3); i += 3)
-    {
-        colors[i + 0] = red;
-        colors[i + 1] = blue;
-        colors[i + 2] = green;
-    }
-
-    AuraRegisterWriteBlock(direct_reg, colors, led_count * 3);
-
-    delete[] colors;
-}
-
-void AuraSMBusController::SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char* colors = new unsigned char[led_count * 3];
-
-    for (unsigned int i = 0; i < (led_count * 3); i += 3)
-    {
-        colors[i + 0] = red;
-        colors[i + 1] = blue;
-        colors[i + 2] = green;
-    }
-
-    AuraRegisterWriteBlock(effect_reg, colors, led_count * 3);
-    
-    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-
-    delete[] colors;
-}
-
-void AuraSMBusController::SetDirect(unsigned char direct)
-{
-    AuraRegisterWrite(AURA_REG_DIRECT, direct);
-    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-}
-
-void AuraSMBusController::SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char colors[3] = { red, blue, green };
-
-    AuraRegisterWriteBlock(direct_reg + ( 3 * led ), colors, 3);
-}
-
-void AuraSMBusController::SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char colors[3] = { red, blue, green };
-
-    AuraRegisterWriteBlock(effect_reg + (3 * led), colors, 3);
-
-    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-}
-
-void AuraSMBusController::SetMode(unsigned char mode)
-{
-    AuraRegisterWrite(AURA_REG_MODE, mode);
-    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-}
-
-void AuraSMBusController::AuraUpdateDeviceName()
-{
-    for (int i = 0; i < 16; i++)
-    {
-        device_name[i] = AuraRegisterRead(AURA_REG_DEVICE_NAME + i);
-    }
-}
-
-unsigned char AuraSMBusController::AuraRegisterRead(aura_register reg)
-{
-    //Write Aura register
-    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
-
-    //Read Aura value
-    return(bus->i2c_smbus_read_byte_data(dev, 0x81));
-
-}
-
-void AuraSMBusController::AuraRegisterWrite(aura_register reg, unsigned char val)
-{
-    //Write Aura register
-    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
-
-    //Write Aura value
-    bus->i2c_smbus_write_byte_data(dev, 0x01, val);
-
-}
-
-void AuraSMBusController::AuraRegisterWriteBlock(aura_register reg, unsigned char * data, unsigned char sz)
-{
-    //Write Aura register
-    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
-
-    //Write Aura block data
-    bus->i2c_smbus_write_block_data(dev, 0x03, sz, data);
-
-}

Controllers/AsusAuraSMBusController/AsusAuraSMBusController.h

@@ -1,113 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraSMBusController.h                |
-|                                           |
-|  Definitions and types for ASUS Aura RGB  |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 8/19/2018   |
-\*-----------------------------------------*/
-
-#include <string>
-#include "i2c_smbus.h"
-
-#pragma once
-
-typedef unsigned char	aura_dev_id;
-typedef unsigned short	aura_register;
-
-#define AURA_APPLY_VAL  0x01                /* Value for Apply Changes Register     */
-
-enum
-{
-    AURA_REG_DEVICE_NAME                = 0x1000,   /* Device String 16 bytes               */
-    AURA_REG_CONFIG_TABLE               = 0x1C00,   /* Start of LED configuration bytes     */
-    AURA_REG_COLORS_DIRECT              = 0x8000,   /* Colors for Direct Mode 15 bytes      */
-    AURA_REG_COLORS_EFFECT              = 0x8010,   /* Colors for Internal Effects 15 bytes */
-    AURA_REG_DIRECT                     = 0x8020,   /* "Direct Access" Selection Register   */
-    AURA_REG_MODE                       = 0x8021,   /* AURA Mode Selection Register         */
-    AURA_REG_APPLY                      = 0x80A0,   /* AURA Apply Changes Register          */
-    AURA_REG_SLOT_INDEX                 = 0x80F8,   /* AURA Slot Index Register (RAM only)  */
-    AURA_REG_I2C_ADDRESS                = 0x80F9,   /* AURA I2C Address Register (RAM only) */
-    AURA_REG_COLORS_DIRECT_V2           = 0x8100,   /* Direct Colors (v2) 30 bytes          */
-    AURA_REG_COLORS_EFFECT_V2           = 0x8160,   /* Internal Colors (v2) 30 bytes        */
-};
-
-enum
-{
-    AURA_MODE_OFF                       = 0,        /* OFF mode                             */
-    AURA_MODE_STATIC                    = 1,        /* Static color mode                    */
-    AURA_MODE_BREATHING                 = 2,        /* Breathing effect mode                */
-    AURA_MODE_FLASHING                  = 3,        /* Flashing effect mode                 */
-    AURA_MODE_SPECTRUM_CYCLE            = 4,        /* Spectrum Cycle mode                  */
-    AURA_MODE_RAINBOW                   = 5,        /* Rainbow effect mode                  */
-    AURA_MODE_SPECTRUM_CYCLE_BREATHING  = 6,        /* Rainbow Breathing effect mode        */
-    AURA_MODE_CHASE_FADE                = 7,        /* Chase with Fade effect mode          */
-    AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE = 8,        /* Chase with Fade, Rainbow effect mode */
-    AURA_MODE_CHASE                     = 9,        /* Chase effect mode                    */
-    AURA_MODE_SPECTRUM_CYCLE_CHASE      = 10,       /* Chase with Rainbow effect mode       */
-    AURA_MODE_SPECTRUM_CYCLE_WAVE       = 11,       /* Wave effect mode                     */
-    AURA_MODE_CHASE_RAINBOW_PULSE       = 12,       /* Chase with  Rainbow Pulse effect mode*/
-    AURA_MODE_RANDOM_FLICKER            = 13,       /* Random flicker effect mode           */
-    AURA_NUMBER_MODES                               /* Number of Aura modes                 */
-};
-
-enum
-{
-    AURA_LED_CHANNEL_DRAM_2             = 0x05,     /* DRAM LED channel                     */
-    AURA_LED_CHANNEL_CENTER_START       = 0x82,     /* Center zone first LED channel        */
-    AURA_LED_CHANNEL_CENTER             = 0x83,     /* Center zone LED channel              */
-    AURA_LED_CHANNEL_AUDIO              = 0x84,     /* Audio zone LED channel               */
-    AURA_LED_CHANNEL_BACK_IO            = 0x85,     /* Back I/O zone LED channel            */
-    AURA_LED_CHANNEL_RGB_HEADER         = 0x86,     /* RGB Header LED channel               */
-    AURA_LED_CHANNEL_RGB_HEADER_2       = 0x87,     /* RGB Header 2 LED channel             */
-    AURA_LED_CHANNEL_BACKPLATE          = 0x88,     /* Backplate zone LED channel           */
-    AURA_LED_CHANNEL_DRAM               = 0x8A,     /* DRAM LED channel                     */
-    AURA_LED_CHANNEL_PCIE               = 0x8B,     /* PCIe zone LED channel                */
-    AURA_LED_CHANNEL_RGB_HEADER_3       = 0x91,     /* RGB Header 3 LED channel             */
-};
-
-enum
-{
-    AURA_CONFIG_LED_COUNT               = 0x02,     /* LED Count configuration offset       */
-    AURA_CONFIG_CHANNEL_V1              = 0x13,     /* LED Channel configuration offset     */
-    AURA_CONFIG_CHANNEL_V2              = 0x1B,     /* LED Channel V2 configuration offset  */
-};
-
-class AuraSMBusController
-{
-public:
-    AuraSMBusController(i2c_smbus_interface* bus, aura_dev_id dev);
-    ~AuraSMBusController();
-
-    std::string   GetDeviceName();
-    std::string   GetDeviceLocation();
-    unsigned char GetChannel(unsigned int led);
-    const char*   GetChannelName(unsigned int led);
-    unsigned int  GetLEDCount();
-    unsigned char GetLEDRed(unsigned int led);
-    unsigned char GetLEDGreen(unsigned int led);
-    unsigned char GetLEDBlue(unsigned int led);
-    void          SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue);
-    void          SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue);
-    void          SetDirect(unsigned char direct);
-    void          SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
-    void          SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
-    void          SetMode(unsigned char mode);
-
-    void          AuraUpdateDeviceName();
-
-    unsigned char AuraRegisterRead(aura_register reg);
-    void          AuraRegisterWrite(aura_register reg, unsigned char val);
-    void          AuraRegisterWriteBlock(aura_register reg, unsigned char * data, unsigned char sz);
-
-private:
-    char                    device_name[16];
-    unsigned char           config_table[64];
-    unsigned int            led_count;
-    aura_register           direct_reg;
-    aura_register           effect_reg;
-    unsigned char           channel_cfg;
-    i2c_smbus_interface *   bus;
-    aura_dev_id             dev;
-
-};

Controllers/AsusAuraSMBusController/AsusAuraSMBusControllerDetect.cpp

@@ -1,226 +0,0 @@
-#include "Detector.h"
-#include "AsusAuraSMBusController.h"
-#include "LogManager.h"
-#include "RGBController.h"
-#include "RGBController_AsusAuraSMBus.h"
-#include "i2c_smbus.h"
-#include "pci_ids.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-#include "dependencies/dmiinfo.h"
-
-using namespace std::chrono_literals;
-
-/*----------------------------------------------------------------------*\
-| This list contains the available SMBus addresses for mapping Aura RAM  |
-\*----------------------------------------------------------------------*/
-#define AURA_RAM_ADDRESS_COUNT  23
-
-static const unsigned char aura_ram_addresses[] =
-{
-    0x70,
-    0x71,
-    0x72,
-    0x73,
-    0x74,
-    0x75,
-    0x76,
-    0x78,
-    0x79,
-    0x7A,
-    0x7B,
-    0x7C,
-    0x7D,
-    0x7E,
-    0x7F,
-    0x4F,
-    0x66,
-    0x67,
-    0x39,
-    0x3A,
-    0x3B,
-    0x3C,
-    0x3D
-};
-
-/*---------------------------------------------------------------------------------*\
-| This list contains the available SMBus addresses for mapping Aura motherboards    |
-\*---------------------------------------------------------------------------------*/
-#define AURA_MOBO_ADDRESS_COUNT 3
-
-static const unsigned char aura_mobo_addresses[] =
-{
-    0x40,
-    0x4E,
-    0x4F
-};
-
-/******************************************************************************************\
-*                                                                                          *
-*   AuraRegisterWrite                                                                      *
-*                                                                                          *
-*       A standalone version of the AuraSMBusController::AuraRegisterWrite function for    *
-*       access to Aura devices without instancing the AuraSMBusController class or reading *
-*       the config table from the device.                                                  *
-*                                                                                          *
-\******************************************************************************************/
-
-void AsusAuraRegisterWrite(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));
-
-    //Write Aura value
-    bus->i2c_smbus_write_byte_data(dev, 0x01, val);
-}
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForAuraSMBusController                                                                  *
-*                                                                                          *
-*       Tests the given address to see if an Aura controller exists there.  First does a   *
-*       quick write to test for a response, and if so does a simple read at 0xA0 to test   *
-*       for incrementing values 0...F which was observed at this location during data dump *
-*                                                                                          *
-\******************************************************************************************/
-
-bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char address)
-{
-    bool pass = false;
-
-    LOG_DEBUG("[Aura SMBus] looking for devices at 0x%02X...", address);
-
-    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
-
-    if (res >= 0)
-    {
-        pass = true;
-
-        LOG_DEBUG("[Aura SMBus] Detected an I2C device at address %02X, testing register range", address);
-
-        for (int i = 0xA0; i < 0xB0; i++)
-        {
-            res = bus->i2c_smbus_read_byte_data(address, i);
-
-            if (res != (i - 0xA0))
-            {
-                LOG_VERBOSE("[Aura SMBus] Detection failed testing register %02X.  Expected %02X, got %02X.", i, (i - 0xA0), res);
-
-                pass = false;
-            }
-        }
-
-        if(pass)
-        {
-            LOG_VERBOSE("[Aura SMBus] Detection successful, address %02X", address);
-        }
-    }
-
-    return(pass);
-
-}   /* TestForAuraSMBusController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAuraSMBusControllers                                                             *
-*                                                                                          *
-*       Detect Aura controllers on the enumerated I2C busses.  Searches for Aura-enabled   *
-*       RAM at 0x77 and tries to initialize their slot addresses, then searches for them   *
-*       at their correct initialized addresses.  Also looks for motherboard controller at  *
-*       address 0x4E.                                                                      *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
-*           dev - I2C address of Aura device                                               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAsusAuraSMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busses)
-{
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        int address_list_idx = -1;
-
-        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
-        {
-            LOG_DEBUG("[ASUS Aura SMBus DRAM] Remapping Aura SMBus 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)
-                {
-                    LOG_DEBUG("[ASUS Aura SMBus DRAM] No device detected at 0x77, aborting remap");
-
-                    break;
-                }
-
-                do
-                {
-                    address_list_idx++;
-
-                    if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
-                    {
-                        LOG_DEBUG("[ASUS Aura SMBus DRAM] Testing address %02X to see if there is a device there", aura_ram_addresses[address_list_idx]);
-
-                        res = busses[bus]->i2c_smbus_write_quick(aura_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
-                    }
-                    else
-                    {
-                        break;
-                    }
-                } while (res >= 0);
-
-                if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
-                {
-                    LOG_DEBUG("[ASUS Aura SMBus DRAM] Remapping slot %d to address %02X", slot, aura_ram_addresses[address_list_idx]);
-
-                    AsusAuraRegisterWrite(busses[bus], 0x77, AURA_REG_SLOT_INDEX, slot);
-                    AsusAuraRegisterWrite(busses[bus], 0x77, AURA_REG_I2C_ADDRESS, (aura_ram_addresses[address_list_idx] << 1));
-                }
-            }
-
-            // 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]))
-                {
-                    AuraSMBusController* controller = new AuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]);
-                    RGBController_AuraSMBus* rgb_controller = new RGBController_AuraSMBus(controller);
-                    ResourceManager::get()->RegisterRGBController(rgb_controller);
-                }
-
-                std::this_thread::sleep_for(1ms);
-            }
-        }
-    }
-}   /* DetectAuraSMBusDRAMControllers() */
-
-void DetectAsusAuraSMBusMotherboardControllers(std::vector<i2c_smbus_interface*> &busses)
-{
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        // Add Aura-enabled motherboard controllers
-        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
-        {
-            for (unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
-            {
-                if (TestForAsusAuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
-                {
-                    DMIInfo dmi;
-                    AuraSMBusController* controller = new AuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]);
-                    RGBController_AuraSMBus* rgb_controller = new RGBController_AuraSMBus(controller);
-                    rgb_controller->name = "ASUS " + dmi.getMainboard();
-                    ResourceManager::get()->RegisterRGBController(rgb_controller);
-                }
-
-                std::this_thread::sleep_for(1ms);
-            }
-        }
-    }
-
-}   /* DetectAuraSMBusMotherboardControllers() */
-
-REGISTER_I2C_DETECTOR("ASUS Aura SMBus DRAM", DetectAsusAuraSMBusDRAMControllers);
-REGISTER_I2C_DETECTOR("ASUS Aura SMBus Motherboard", DetectAsusAuraSMBusMotherboardControllers);

Controllers/AsusAuraSMBusController/RGBController_AsusAuraSMBus.cpp

@@ -1,368 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraSMBus.cpp          |
-|                                           |
-|  Generic RGB Interface for OpenAuraSDK    |
-|  Asus Aura SMBus driver                   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/13/2019   |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraSMBus.h"
-
-int RGBController_AuraSMBus::GetDeviceMode()
-{
-    int  dev_mode  = aura->AuraRegisterRead(AURA_REG_MODE);
-    int color_mode = MODE_COLORS_PER_LED;
-
-    if (aura->AuraRegisterRead(AURA_REG_DIRECT))
-    {
-        dev_mode = 0xFFFF;
-    }
-
-    switch(dev_mode)
-    {
-    case AURA_MODE_OFF:
-    case AURA_MODE_RAINBOW:
-    case AURA_MODE_SPECTRUM_CYCLE:
-    case AURA_MODE_RANDOM_FLICKER:
-        color_mode = MODE_COLORS_NONE;
-        break;
-
-    case AURA_MODE_SPECTRUM_CYCLE_CHASE:
-        dev_mode   = AURA_MODE_CHASE;
-        color_mode = MODE_COLORS_RANDOM;
-        break;
-
-    case AURA_MODE_SPECTRUM_CYCLE_BREATHING:
-        dev_mode   = AURA_MODE_BREATHING;
-        color_mode = MODE_COLORS_RANDOM;
-        break;
-
-    case AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE:
-        dev_mode   = AURA_MODE_CHASE_FADE;
-        color_mode = MODE_COLORS_RANDOM;
-        break;
-    }
-
-    for(std::size_t mode = 0; mode < modes.size(); mode++)
-    {
-        if(modes[mode].value == dev_mode)
-        {
-            active_mode            = mode;
-            modes[mode].color_mode = color_mode;
-        }
-    }
-
-    return(active_mode);
-}
-
-void RGBController_AuraSMBus::DeviceUpdateLEDs()
-{
-    for(std::size_t led = 0; led < colors.size(); led++)
-    {
-        unsigned char red = RGBGetRValue(colors[led]);
-        unsigned char grn = RGBGetGValue(colors[led]);
-        unsigned char blu = RGBGetBValue(colors[led]);
-
-        if (GetMode() == 0)
-        {
-            aura->SetLEDColorDirect(led, red, grn, blu);
-        }
-        else
-        {
-            aura->SetLEDColorEffect(led, red, grn, blu);
-        }
-    }
-}
-
-void RGBController_AuraSMBus::UpdateZoneLEDs(int zone)
-{
-    for (std::size_t led_idx = 0; led_idx < zones[zone].leds_count; led_idx++)
-    {
-        int           led   = zones[zone].leds[led_idx].value;
-        RGBColor      color = colors[led];
-        unsigned char red   = RGBGetRValue(color);
-        unsigned char grn   = RGBGetGValue(color);
-        unsigned char blu   = RGBGetBValue(color);
-
-        if (GetMode() == 0)
-        {
-            aura->SetLEDColorDirect(led, red, grn, blu);
-        }
-        else
-        {
-            aura->SetLEDColorEffect(led, red, grn, blu);
-        }
-    }
-}
-
-void RGBController_AuraSMBus::UpdateSingleLED(int led)
-{
-    RGBColor color    = colors[led];
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    if (GetMode() == 0)
-    {
-        aura->SetLEDColorDirect(led, red, grn, blu);
-    }
-    else
-    {
-        aura->SetLEDColorEffect(led, red, grn, blu);
-    }
-}
-
-RGBController_AuraSMBus::RGBController_AuraSMBus(AuraSMBusController * aura_ptr)
-{
-    aura = aura_ptr;
-
-    version = aura->GetDeviceName();
-    location = aura->GetDeviceLocation();
-    if((version.find("DIMM_LED") != std::string::npos) || (version.find("AUDA") != std::string::npos) )
-    {
-        type = DEVICE_TYPE_DRAM;
-        name = "ASUS Aura DRAM";
-    }
-    else
-    {
-        type = DEVICE_TYPE_MOTHERBOARD;
-        name = "ASUS Aura Motherboard";
-    }
-    vendor      = "ASUS";
-    description = "ASUS Aura SMBus Device";
-
-    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);
-
-    mode Off;
-    Off.name       = "Off";
-    Off.value      = AURA_MODE_OFF;
-    Off.flags      = 0;
-    Off.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    mode Static;
-    Static.name       = "Static";
-    Static.value      = AURA_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      = AURA_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
-    Breathing.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Breathing);
-
-    mode Flashing;
-    Flashing.name       = "Flashing";
-    Flashing.value      = AURA_MODE_FLASHING;
-    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Flashing.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Flashing);
-
-    mode SpectrumCycle;
-    SpectrumCycle.name       = "Spectrum Cycle";
-    SpectrumCycle.value      = AURA_MODE_SPECTRUM_CYCLE;
-    SpectrumCycle.flags      = 0;
-    SpectrumCycle.color_mode = MODE_COLORS_NONE;
-    modes.push_back(SpectrumCycle);
-
-    mode Rainbow;
-    Rainbow.name       = "Rainbow";
-    Rainbow.value      = AURA_MODE_RAINBOW;
-    Rainbow.flags      = 0;
-    Rainbow.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Rainbow);
-
-    mode ChaseFade;
-    ChaseFade.name       = "Chase Fade";
-    ChaseFade.value      = AURA_MODE_CHASE_FADE;
-    ChaseFade.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
-    ChaseFade.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(ChaseFade);
-
-    mode Chase;
-    Chase.name       = "Chase";
-    Chase.value      = AURA_MODE_CHASE;
-    Chase.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
-    Chase.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Chase);
-
-    mode RandomFlicker;
-    RandomFlicker.name       = "Random Flicker";
-    RandomFlicker.value      = AURA_MODE_RANDOM_FLICKER;
-    RandomFlicker.flags      = 0;
-    RandomFlicker.color_mode = MODE_COLORS_NONE;
-    modes.push_back(RandomFlicker);
-
-    SetupZones();
-
-    // Initialize active mode
-    active_mode = GetDeviceMode();
-}
-
-RGBController_AuraSMBus::~RGBController_AuraSMBus()
-{
-    delete aura;
-}
-
-void RGBController_AuraSMBus::SetupZones()
-{
-    std::vector<int>    aura_led_map;
-
-    /*---------------------------------------------------------*\
-    | Search through all LEDs and create zones for each channel |
-    | type                                                      |
-    \*---------------------------------------------------------*/
-    for (std::size_t led_idx = 0; led_idx < aura->GetLEDCount(); led_idx++)
-    {
-        bool matched = false;
-
-        /*---------------------------------------------------------*\
-        | Search through existing zones to make sure we don't       |
-        | create a duplicate zone                                   |
-        \*---------------------------------------------------------*/
-        for (std::size_t existing_zone_idx = 0; existing_zone_idx < zones.size(); existing_zone_idx++)
-        {
-            if (aura->GetChannelName(led_idx) == zones[existing_zone_idx].name)
-            {
-                matched = true;
-            }
-        }
-
-        /*---------------------------------------------------------*\
-        | If zone does not already exist, create it                 |
-        \*---------------------------------------------------------*/
-        if (matched == false)
-        {
-            zone* new_zone = new zone();
-
-            /*---------------------------------------------------------*\
-            | Set zone name to channel name                             |
-            \*---------------------------------------------------------*/
-            new_zone->name = aura->GetChannelName(led_idx);
-
-            new_zone->leds_count = 0;
-
-            /*---------------------------------------------------------*\
-            | Find all LEDs with this channel type and add them to zone |
-            \*---------------------------------------------------------*/
-            for (std::size_t zone_led_idx = 0; zone_led_idx < aura->GetLEDCount(); zone_led_idx++)
-            {
-                if (aura->GetChannelName(zone_led_idx) == new_zone->name)
-                {
-                    new_zone->leds_count++;
-                    aura_led_map.push_back(zone_led_idx);
-                }
-            }
-
-            /*---------------------------------------------------------*\
-            | Aura zones have fixed size, so set min and max to count   |
-            \*---------------------------------------------------------*/
-            new_zone->leds_min = new_zone->leds_count;
-            new_zone->leds_max = new_zone->leds_count;
-
-            /*---------------------------------------------------------*\
-            | If this zone has more than one LED, mark it as linear type|
-            \*---------------------------------------------------------*/
-            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);
-        }
-    }
-
-    /*---------------------------------------------------------*\
-    | Create LED entries for each zone                          |
-    \*---------------------------------------------------------*/
-    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();
-
-            new_led->name = zones[zone_idx].name + " LED ";
-            new_led->name.append(std::to_string(led_idx + 1));
-
-            new_led->value = aura_led_map[led_idx];
-
-            leds.push_back(*new_led);
-        }
-    }
-
-    SetupColors();
-
-    /*---------------------------------------------------------*\
-    | Initialize colors for each LED                            |
-    \*---------------------------------------------------------*/
-    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
-    {
-        unsigned int  led = leds[led_idx].value;
-        unsigned char red = aura->GetLEDRed(led);
-        unsigned char grn = aura->GetLEDGreen(led);
-        unsigned char blu = aura->GetLEDBlue(led);
-
-        colors[led_idx] = ToRGBColor(red, grn, blu);
-    }
-}
-
-void RGBController_AuraSMBus::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AuraSMBus::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_AuraSMBus::DeviceUpdateMode()
-{
-    if (modes[active_mode].value == 0xFFFF)
-    {
-        aura->SetDirect(true);
-    }
-    else
-    {
-        int new_mode = modes[active_mode].value;
-
-        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
-        {
-            switch(new_mode)
-            {
-            case AURA_MODE_CHASE:
-                new_mode = AURA_MODE_SPECTRUM_CYCLE_CHASE;
-                break;
-            case AURA_MODE_BREATHING:
-                new_mode = AURA_MODE_SPECTRUM_CYCLE_BREATHING;
-                break;
-            case AURA_MODE_CHASE_FADE:
-                new_mode = AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE;
-                break;
-            }
-        }
-
-        aura->SetMode(new_mode);
-        aura->SetDirect(false);
-    }
-}

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.cpp

@@ -19,7 +19,7 @@ AuraHeadsetStandController::AuraHeadsetStandController(hid_device* dev_handle, c
 
 AuraHeadsetStandController::~AuraHeadsetStandController()
 {
-	hid_close(dev);
+    hid_close(dev);
 }
 
 std::string AuraHeadsetStandController::GetDeviceLocation()
@@ -43,6 +43,24 @@ std::string AuraHeadsetStandController::GetSerialString()
     return(return_string);
 }
 
+std::string AuraHeadsetStandController::GetVersion()
+{
+    unsigned char usb_buf[65];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x12;
+    usb_buf[0x02]   = 0x00;
+
+    hid_write(dev, usb_buf, 65);
+
+    unsigned char usb_buf_out[65];
+    hid_read(dev, usb_buf_out, 65);
+
+    char version[5];
+    snprintf(version, 5, "%04X", (usb_buf_out[6] << 8) | usb_buf_out[7]);
+    return std::string(version);
+}
+
 void AuraHeadsetStandController::UpdateLeds
     (
     std::vector<RGBColor>    colors
@@ -96,7 +114,7 @@ void AuraHeadsetStandController::UpdateDevice
     unsigned char   grn,
     unsigned char   blu,
     unsigned char   speed,
-    bool            save
+    unsigned char   brightness
     )
 {
     unsigned char usb_buf[65];
@@ -110,7 +128,7 @@ void AuraHeadsetStandController::UpdateDevice
     usb_buf[0x04]   = 0x00;
     usb_buf[0x05]   = mode;
     usb_buf[0x06]   = speed;
-    usb_buf[0x07]   = 0x04;
+    usb_buf[0x07]   = brightness;
     usb_buf[0x08]   = 0x00;
     usb_buf[0x09]   = 0x00;
     usb_buf[0x0a]   = red;
@@ -118,16 +136,17 @@ void AuraHeadsetStandController::UpdateDevice
     usb_buf[0x0c]   = blu;
     hid_write(dev, usb_buf, 65);
 
-    if(save)
-    {
-        unsigned char usb_save_buf[65];
-
-        memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
-        
-        usb_save_buf[0x00]   = 0x00;
-        usb_save_buf[0x01]   = 0x50;
-        usb_save_buf[0x02]   = 0x55;
-        
-        hid_write(dev, usb_save_buf, 65);
-    }
+}
+
+void AuraHeadsetStandController::SaveMode()
+{
+    unsigned char usb_save_buf[65];
+
+    memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
+
+    usb_save_buf[0x00]   = 0x00;
+    usb_save_buf[0x01]   = 0x50;
+    usb_save_buf[0x02]   = 0x55;
+
+    hid_write(dev, usb_save_buf, 65);
 }

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.h

@@ -37,6 +37,7 @@ public:
 
     std::string GetDeviceLocation();
     std::string GetSerialString();
+    std::string GetVersion();
 
     void UpdateLeds
         (
@@ -50,9 +51,11 @@ public:
         unsigned char   grn,
         unsigned char   blu,
         unsigned char   speed,
-        bool            save
+        unsigned char   brightness
         );
 
+    void SaveMode();
+
 private:
     hid_device*                 dev;
     std::string                 location;

Controllers/AsusAuraUSBController/AsusAuraMonitorController.cpp

@@ -0,0 +1,94 @@
+/*-----------------------------------------*\
+|  AsusAuraMonitorController.cpp            |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Mola19 08/03/2021                        |
+\*-----------------------------------------*/
+
+#include "AsusAuraMonitorController.h"
+
+#include <cstring>
+#include "LogManager.h"
+
+AuraMonitorController::AuraMonitorController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+AuraMonitorController::~AuraMonitorController()
+{
+    hid_close(dev);
+}
+
+std::string AuraMonitorController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AuraMonitorController::GetSerialString()
+{
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+void AuraMonitorController::UpdateLed
+    (
+    int             led,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    unsigned char usb_buf[8];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x03;
+    usb_buf[0x01]   = 0x02;
+    usb_buf[0x02]   = 0xa1;
+    usb_buf[0x03]   = 0x80;
+
+    usb_buf[0x04]   = 16 + led * 3;
+    usb_buf[0x05]   = red;
+    
+    hid_send_feature_report(dev, usb_buf, 8);
+
+    usb_buf[0x04]   = 16 + led * 3 + 1;
+    usb_buf[0x05]   = blue;
+    
+    hid_send_feature_report(dev, usb_buf, 8);
+
+    usb_buf[0x04]   = 16 + led * 3 + 2;
+    usb_buf[0x05]   = green;
+    
+    hid_send_feature_report(dev, usb_buf, 8);
+}
+
+void AuraMonitorController::ApplyChanges()
+{
+    unsigned char usb_buf[8];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x03;
+    usb_buf[0x01]   = 0x02;
+    usb_buf[0x02]   = 0xa1;
+    usb_buf[0x03]   = 0x80;
+    usb_buf[0x04]   = 0xa0;
+    usb_buf[0x05]   = 0x01;
+    
+    hid_send_feature_report(dev, usb_buf, 8);
+}

Controllers/AsusAuraUSBController/AsusAuraMonitorController.h

@@ -0,0 +1,31 @@
+/*-----------------------------------------*\
+|  AsusAuraMonitorController.h              |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Mola19 08/03/2023                        |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+class AuraMonitorController
+{
+public:
+    AuraMonitorController(hid_device* dev_handle, const char* path);
+    virtual ~AuraMonitorController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void UpdateLed(int led, unsigned char red, unsigned char green, unsigned char blue);
+    void ApplyChanges();
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+};

Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp

@@ -44,6 +44,58 @@ std::string AuraMouseController::GetSerialString()
     return(return_string);
 }
 
+std::string AuraMouseController::GetVersion(bool wireless, int protocol)
+{
+    unsigned char usb_buf[ASUS_AURA_MOUSE_PACKET_SIZE];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x12;
+    hid_write(dev, usb_buf, ASUS_AURA_MOUSE_PACKET_SIZE);
+
+    unsigned char usb_buf_out[ASUS_AURA_MOUSE_PACKET_SIZE];
+    hid_read(dev, usb_buf_out, ASUS_AURA_MOUSE_PACKET_SIZE);
+
+    std::string str;
+
+    switch(protocol)
+    {
+        case 0:
+            {
+                unsigned char* offset = usb_buf_out + (wireless ? 13 : 4);
+                str = std::string(offset, offset + 4);
+            }
+            break;
+
+        case 1:
+            {
+                char version[9];
+                int offset = (wireless ? 13 : 4);
+                snprintf(version, 9, "%2X.%02X.%02X", usb_buf_out[offset + 2], usb_buf_out[offset + 1], usb_buf_out[offset]);
+                str = std::string(version);
+            }
+            break;
+
+        case 2:
+            {
+                unsigned char* offset = usb_buf_out + (wireless ? 13 : 4);
+                str = std::string(offset, offset + 4);
+                str = "0." + str.substr(0, 2) + "." + str.substr(2, 2);
+            }
+            break;
+
+        case 3:
+            {
+                char version[9];
+                int offset = (wireless ? 13 : 4);
+                snprintf(version, 9, "%2d.%02d.%02d", usb_buf_out[offset + 1], usb_buf_out[offset + 2], usb_buf_out[offset + 3]);
+                str = std::string(version);
+            }
+            break;
+    }
+
+    return str;
+}
+
 void AuraMouseController::SaveMode()
 {
     unsigned char usb_save_buf[ASUS_AURA_MOUSE_PACKET_SIZE] = { 0x00, 0x50, 0x03 };
@@ -60,9 +112,18 @@ void AuraMouseController::SendUpdate
     unsigned char   blu,
     unsigned char   dir,
     bool            random,
-    unsigned char   speed
+    unsigned char   speed,
+    unsigned char   brightness
     )
 {
+    int bytes_read = 1;
+    unsigned char usb_buf_flush[ASUS_AURA_MOUSE_PACKET_SIZE];
+
+    while(bytes_read > 0)
+    {
+      bytes_read = hid_read_timeout(dev, usb_buf_flush, ASUS_AURA_MOUSE_PACKET_SIZE, 0);
+    }
+
     unsigned char usb_buf[ASUS_AURA_MOUSE_PACKET_SIZE];
 
     /*-----------------------------------------------------*\
@@ -73,27 +134,41 @@ void AuraMouseController::SendUpdate
     /*-----------------------------------------------------*\
     | 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;
+    
     if (device_pid == AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID)
     {
-        usb_buf[0x0A]   = 0;
-        usb_buf[0x0B]   = 0;
-        usb_buf[0x0C]   = 0;
-        usb_buf[0x0D]   = dir;
-        usb_buf[0x0E]   = random;
-        usb_buf[0x0F]   = speed;
+        // this device supports 2 color for breathing,
+        // but since this mode is per led and openrgb doesn't support 2 colors per led this feature is not implemented
+        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]   = brightness;
+        usb_buf[0x07]   = 0x00; // boolean signaling if the 2nd set of colors is in use
+        usb_buf[0x08]   = red;
+        usb_buf[0x09]   = grn;
+        usb_buf[0x0A]   = blu;
+        usb_buf[0x0B]   = 0; // 2nd red
+        usb_buf[0x0C]   = 0; // 2nd green
+        usb_buf[0x0D]   = 0; // 2nd blue
+        usb_buf[0x0E]   = dir;
+        usb_buf[0x0F]   = random;
+        usb_buf[0x10]   = speed;
     }
     else
     {
+        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]   = brightness;
+        usb_buf[0x07]   = red;
+        usb_buf[0x08]   = grn;
+        usb_buf[0x09]   = blu;
         usb_buf[0x0A]   = dir;
         usb_buf[0x0B]   = random;
         usb_buf[0x0C]   = speed;
@@ -103,4 +178,7 @@ void AuraMouseController::SendUpdate
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, ASUS_AURA_MOUSE_PACKET_SIZE);
+
+    unsigned char usb_buf_out[ASUS_AURA_MOUSE_PACKET_SIZE];
+    hid_read_timeout(dev, usb_buf_out, ASUS_AURA_MOUSE_PACKET_SIZE, 10);
 }

Controllers/AsusAuraUSBController/AsusAuraMouseController.h

@@ -26,6 +26,7 @@ public:
 
     std::string GetDeviceLocation();
     std::string GetSerialString();
+    std::string GetVersion(bool wireless, int protocol);
 
     void SaveMode();
     void SendUpdate
@@ -37,8 +38,9 @@ public:
         unsigned char   blu,
         unsigned char   dir,
         bool            random,
-        unsigned char   speed
-	);
+        unsigned char   speed,
+        unsigned char   brightness
+        );
 
     uint16_t                    device_pid;
 

Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h

@@ -20,13 +20,18 @@
 #define AURA_ROG_GLADIUS_II_WIRELESS_2_PID      0x18A0
 #define AURA_ROG_CHAKRAM_WIRELESS_PID           0x18E5
 #define AURA_ROG_CHAKRAM_WIRED_1_PID            0x18E3
-#define AURA_ROG_CHAKRAM_WIRED_2_PID            0x1958
+#define AURA_ROG_CHAKRAM_CORE_PID               0x1958
 #define AURA_ROG_PUGIO_PID                      0x1846
 #define AURA_ROG_PUGIO_II_WIRED_PID             0x1906
 #define AURA_ROG_PUGIO_II_WIRELESS_PID          0x1908
+#define AURA_ROG_STRIX_IMPACT_PID               0x1847
 #define AURA_ROG_STRIX_IMPACT_II_PID            0x18E1
+#define AURA_ROG_KERIS                          0x195C
+#define AURA_ROG_KERIS_WIRELESS_USB_PID         0x195E
+#define AURA_ROG_KERIS_WIRELESS_2_4_PID         0x1960
+#define AURA_ROG_KERIS_WIRELESS_BT_PID          0x1962
 #define AURA_TUF_M3_PID                         0x1910
-#define AURA_TUF_M5_PID                         0x1910
+#define AURA_TUF_M5_PID                         0x1898
 
 enum
 {
@@ -44,13 +49,16 @@ enum
     AURA_MOUSE_MODE_WAVE        = 3,
     AURA_MOUSE_MODE_REACTIVE    = 4,
     AURA_MOUSE_MODE_COMET       = 5,
-    AURA_MOUSE_MODE_BATTERY     = 6
+    AURA_MOUSE_MODE_BATTERY     = 6,
+    AURA_MOUSE_MODE_NONE        = 255,
 };
 
 typedef struct
 {
     uint8_t                 speed_min;
     uint8_t                 speed_max;
+    bool                    wireless;
+    int                     version_protocol;
     std::vector<uint8_t>    mouse_zones;
     std::vector<uint8_t>    mouse_modes;
 } mouse_type;
@@ -68,8 +76,10 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_ROG_GLADIUS_II_CORE_PID, // ROG Gladius II Core
         {
-            255,    //Speed Min - The Asus Mouse protocol defines larger numbers as slow
-            1,      //Speed Max
+            0,    //Speed Min - The Asus Mouse protocol defines larger numbers as slow
+            0,    //Speed Max
+            false,
+            1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
@@ -79,6 +89,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             255,
             1,
+            false,
+            0,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
         }
@@ -88,6 +100,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             255,
             1,
+            false,
+            0,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
         }
@@ -97,6 +111,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             255,
             1,
+            false,
+            0,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
         }
@@ -106,6 +122,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             255,
             1,
+            false,
+            0,
             { AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
         }
@@ -113,25 +131,31 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_ROG_GLADIUS_II_WIRELESS_1_PID, // ROG Gladius II Wireless
         {
-            255,
+            0,
+            0,
+            true,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
     },
     {
         AURA_ROG_GLADIUS_II_WIRELESS_2_PID, // ROG Gladius II Wireless
         {
-            255,
+            0,
+            0,
+            true,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_BATTERY }
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
     },
     {
         AURA_ROG_CHAKRAM_WIRELESS_PID, // ROG Chakram Wireless
         {
-            255,
+            15,
+            1,
+            true,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
@@ -140,19 +164,23 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_ROG_CHAKRAM_WIRED_1_PID,  // ROG Chakram Wired 1
         {
-            255,
+            15,
+            1,
+            false,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
         }
     },
     {
-        AURA_ROG_CHAKRAM_WIRED_2_PID, // ROG Chakram Wired 2
+        AURA_ROG_CHAKRAM_CORE_PID, // ROG Chakram Core
         {
-            255,
+            0,
+            0,
+            false,
             1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
     },
     {
@@ -160,14 +188,18 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             255,
             1,
+            false,
+            0,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
         }
     },
     {
         AURA_ROG_PUGIO_II_WIRED_PID, // ROG Pugio II Wired
         {
-            255,
+            15,
+            1,
+            false,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
@@ -176,25 +208,86 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_ROG_PUGIO_II_WIRELESS_PID, // ROG Pugio II Wireless
         {
-            255,
+            15,
+            1,
+            true,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
         }
     },
+    {
+        AURA_ROG_STRIX_IMPACT_PID, // ROG Strix Impact
+        {
+            0,
+            0,
+            false,
+            3,
+            { AURA_MOUSE_ZONE_LOGO },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM }
+        }
+    },
     {
         AURA_ROG_STRIX_IMPACT_II_PID, // ROG Strix Impact II
         {
-            255,
+            0,
+            0,
+            false,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
     },
+    {
+        AURA_ROG_KERIS, // ROG Keris
+        {
+            0,
+            0,
+            false,
+            1, // might be the wrong protocol for version
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
+        }
+    },
+    {
+        AURA_ROG_KERIS_WIRELESS_USB_PID, // ROG Keris
+        {
+            0,
+            0,
+            true,
+            1, // might be the wrong protocol for version
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
+    {
+        AURA_ROG_KERIS_WIRELESS_2_4_PID, // ROG Keris
+        {
+            0,
+            0,
+            true,
+            1, // might be the wrong protocol for version
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
+    {
+        AURA_ROG_KERIS_WIRELESS_BT_PID, // ROG Keris
+        {
+            0,
+            0,
+            true,
+            1, // might be the wrong protocol for version
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
     {
         AURA_TUF_M3_PID, // TUF M3
         {
-            255,
+            0,
+            0,
+            false,
             1,
             { AURA_MOUSE_ZONE_LOGO },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
@@ -203,8 +296,10 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_TUF_M5_PID, // TUF M5
         {
-            255,
-            1,
+            0,
+            0,
+            false,
+            2,
             { AURA_MOUSE_ZONE_LOGO },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }

Controllers/AsusAuraUSBController/AsusAuraMousematController.cpp

@@ -0,0 +1,134 @@
+/*-----------------------------------------*\
+|  AsusAuraMousematController.cpp           |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/10/2022   |
+\*-----------------------------------------*/
+
+#include "AsusAuraMousematController.h"
+#include <cstring>
+
+AuraMousematController::AuraMousematController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+AuraMousematController::~AuraMousematController()
+{
+    hid_close(dev);
+}
+
+std::string AuraMousematController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AuraMousematController::GetSerialString()
+{
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+std::string AuraMousematController::GetVersion()
+{
+    unsigned char usb_buf[65];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    usb_buf[0x00]   = 0xEE;
+    usb_buf[0x01]   = 0x12;
+    usb_buf[0x02]   = 0x00;
+
+    hid_write(dev, usb_buf, 65);
+
+    unsigned char usb_buf_out[65];
+    hid_read(dev, usb_buf_out, 65);
+
+    char version[5];
+    snprintf(version, 5, "%04X", (usb_buf_out[6] << 8) | usb_buf_out[7]);
+    return std::string(version);
+}
+
+void AuraMousematController::UpdateLeds
+    (
+    std::vector<RGBColor>    colors
+    )
+{
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0xEE;
+    usb_buf[0x01]   = 0xC0;
+    usb_buf[0x02]   = 0x81;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = 0x00;
+
+    for(unsigned int i = 0; i < 60; i += 4)
+    {
+        usb_buf[5 + i]   = 0x00;
+        usb_buf[6 + i]   = RGBGetRValue(colors[i / 4]);
+        usb_buf[7 + i]   = RGBGetGValue(colors[i / 4]);
+        usb_buf[8 + i]   = RGBGetBValue(colors[i / 4]);
+    }
+
+    hid_write(dev, usb_buf, 65);
+}
+
+void AuraMousematController::UpdateDevice
+    (
+    unsigned char           mode,
+    std::vector<RGBColor>   colors,
+    unsigned char           speed,
+    unsigned char           brightness,
+    unsigned char           pattern
+    )
+{
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0xEE;
+    usb_buf[0x01]   = 0x51;
+    usb_buf[0x02]   = 0x28;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = 0x00;
+    usb_buf[0x05]   = mode;
+    usb_buf[0x06]   = speed;
+    usb_buf[0x07]   = brightness;
+    usb_buf[0x08]   = pattern;
+    usb_buf[0x09]   = 0x00;
+
+    for(int i = 0; i < colors.size(); i++)
+    {
+        usb_buf[0x0a + i * 3]   = RGBGetRValue(colors[i]);
+        usb_buf[0x0b + i * 3]   = RGBGetGValue(colors[i]);
+        usb_buf[0x0c + i * 3]   = RGBGetBValue(colors[i]);
+    }
+    
+    hid_write(dev, usb_buf, 65);
+}
+
+void AuraMousematController::SaveMode()
+{
+    unsigned char usb_save_buf[65];
+
+    memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
+
+    usb_save_buf[0x00]   = 0xEE;
+    usb_save_buf[0x01]   = 0x50;
+    usb_save_buf[0x02]   = 0x55;
+
+    hid_write(dev, usb_save_buf, 65);
+}

Controllers/AsusAuraUSBController/AsusAuraMousematController.h

@@ -0,0 +1,59 @@
+/*-----------------------------------------*\
+|  AsusAuraMousematController.h             |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/10/2022   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+
+enum
+{
+    AURA_MOUSEMAT_MODE_STATIC           = 0,
+    AURA_MOUSEMAT_MODE_BREATHING        = 1,
+    AURA_MOUSEMAT_MODE_COLOR_CYCLE      = 2,
+    AURA_MOUSEMAT_MODE_WAVE             = 3,
+    AURA_MOUSEMAT_MODE_WAVE_PLANE       = 4,
+    AURA_MOUSEMAT_MODE_COMET            = 5,
+    AURA_MOUSEMAT_MODE_GLOWING_YOYO     = 6,
+    AURA_MOUSEMAT_MODE_CROSS            = 7,
+    AURA_MOUSEMAT_MODE_STARRY_NIGHT     = 8,
+    AURA_MOUSEMAT_MODE_DIRECT           = 0xFF,
+};
+
+class AuraMousematController
+{
+public:
+    AuraMousematController(hid_device* dev_handle, const char* path);
+    virtual ~AuraMousematController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+    std::string GetVersion();
+
+    void UpdateLeds
+        (
+        std::vector<RGBColor>    colors
+        );
+
+    void UpdateDevice
+        (
+        unsigned char           mode,
+        std::vector<RGBColor>   colors,
+        unsigned char           speed,
+        unsigned char           brightness,
+        unsigned char           pattern
+        );
+
+    void SaveMode();
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+};

Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.cpp

@@ -0,0 +1,146 @@
+/*-----------------------------------------*\
+|  AsusAuraStrixEvolveController.cpp        |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Mola19 11/30/2021                        |
+\*-----------------------------------------*/
+
+#include "AsusAuraStrixEvolveController.h"
+
+#include <cstring>
+#include <chrono>
+#include <thread>
+
+AuraStrixEvolveController::AuraStrixEvolveController(hid_device* dev_handle, const char* path, uint16_t pid)
+{
+    dev         = dev_handle;
+    location    = path;
+    device_pid  = pid;
+}
+
+AuraStrixEvolveController::~AuraStrixEvolveController()
+{
+    hid_close(dev);
+}
+
+std::string AuraStrixEvolveController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AuraStrixEvolveController::GetSerialString()
+{
+    wchar_t serial_string[HID_MAX_STR];
+    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
+
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+std::string AuraStrixEvolveController::GetVersion()
+{
+    unsigned char usb_buf[9] = { 0x0c, 0xc4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+    hid_send_feature_report(dev, usb_buf, 9);
+
+    unsigned char usb_buf_out[9] = { 0x0c };
+    hid_get_feature_report(dev, usb_buf_out, 9);
+
+    return std::string("1." +  std::to_string(usb_buf_out[3]));
+}
+
+int AuraStrixEvolveController::GetActiveProfile()
+{
+    int profile;
+
+    do
+    {
+        unsigned char usb_buf[9] = { 0x0c, 0xdf, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+        hid_send_feature_report(dev, usb_buf, 9);
+
+        unsigned char usb_buf_out[9] = { 0x0c };
+        hid_get_feature_report(dev, usb_buf_out, 9);
+
+        profile = usb_buf_out[4] % 16;
+    } while (profile > 2);
+
+    return profile + 1;
+}
+
+void AuraStrixEvolveController::SendUpdate
+    (
+    unsigned char   key,
+    unsigned char   value
+    )
+{
+    unsigned char usb_buf[9];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, 9);
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x0c;
+    usb_buf[0x01]   = 0xc4;
+    usb_buf[0x02]   = 0x0f;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = key;
+    usb_buf[0x05]   = value;
+    hid_send_feature_report(dev, usb_buf, 9);
+}
+
+
+void AuraStrixEvolveController::UpdateProfile
+    (
+    unsigned char   key,
+    unsigned char   profile,
+    unsigned char   value
+    )
+{
+    unsigned char usb_buf[9];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, 9);
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x0c;
+    usb_buf[0x01]   = 0xde;
+    usb_buf[0x02]   = key;
+    usb_buf[0x03]   = profile;
+    usb_buf[0x04]   = value;
+    hid_send_feature_report(dev, usb_buf, 9);
+    std::this_thread::sleep_for(std::chrono::milliseconds(5));
+}
+
+void AuraStrixEvolveController::SendSavePacket()
+{
+    unsigned char usb_buf[9];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, 9);
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x0c;
+    usb_buf[0x01]   = 0xc4;
+
+    hid_send_feature_report(dev, usb_buf, 9);
+}

Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.h

@@ -0,0 +1,50 @@
+/*-----------------------------------------*\
+|  AsusAuraStrixEvolveController.h          |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Mola19 11/30/2021                        |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+#define HID_MAX_STR 255
+
+class AuraStrixEvolveController
+{
+public:
+    AuraStrixEvolveController(hid_device* dev_handle, const char* path, uint16_t pid);
+    virtual ~AuraStrixEvolveController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+    std::string GetVersion();
+    int GetActiveProfile();
+
+    void SendUpdate
+        (
+        unsigned char   key,
+        unsigned char   value
+        );
+
+    void UpdateProfile
+        (
+        unsigned char   key,
+        unsigned char   profile,
+        unsigned char   value
+        );
+
+    void SendSavePacket();
+
+    uint16_t                    device_pid;
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+};

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp

@@ -15,12 +15,13 @@
 #include <math.h>
 #include <stdio.h>
 #include <string.h>
-#include <iostream>
+#include <cmath>
 
-AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path)
+AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid)
 {
     dev         = dev_handle;
     location    = path;
+    device_pid  = pid;
 }
 
 AuraTUFKeyboardController::~AuraTUFKeyboardController()
@@ -36,7 +37,12 @@ std::string AuraTUFKeyboardController::GetDeviceLocation()
 std::string AuraTUFKeyboardController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());
@@ -44,6 +50,61 @@ std::string AuraTUFKeyboardController::GetSerialString()
     return(return_string);
 }
 
+std::string AuraTUFKeyboardController::GetVersion()
+{
+    unsigned char usb_buf[65];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x12;
+    usb_buf[0x02]   = 0x00;
+
+    hid_write(dev, usb_buf, 65);
+
+    unsigned char usb_buf_out[65];
+    hid_read(dev, usb_buf_out, 65);
+
+    char version[9];
+    if (device_pid == AURA_TUF_K3_GAMING_PID)
+    {
+        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
+    }
+    else
+    {
+        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
+    }
+    
+    return std::string(version);
+}
+
+int AuraTUFKeyboardController::GetLayout()
+{
+    unsigned char usb_buf[65];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x12;
+    usb_buf[0x02]   = 0x12;
+
+    hid_write(dev, usb_buf, 65);
+
+    unsigned char usb_buf_out[65];
+    hid_read(dev, usb_buf_out, 65);
+
+    return(usb_buf_out[4] * 100 + usb_buf_out[5]);
+}
+
+void AuraTUFKeyboardController::SaveMode()
+{
+    unsigned char usb_save_buf[65];
+
+    memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
+
+    usb_save_buf[0x00]   = 0x00;
+    usb_save_buf[0x01]   = 0x50;
+    usb_save_buf[0x02]   = 0x55;
+
+    hid_write(dev, usb_save_buf, 65);
+}
+
 void AuraTUFKeyboardController::UpdateSingleLed
     (
     int             led,
@@ -141,7 +202,8 @@ void AuraTUFKeyboardController::UpdateDevice
     std::vector<RGBColor>   colors,
     unsigned char           dir,
     unsigned char           color_mode,
-    unsigned char           speed
+    unsigned char           speed,
+    unsigned char           brightness
     )
 {
     unsigned char usb_buf[65];
@@ -154,21 +216,21 @@ void AuraTUFKeyboardController::UpdateDevice
     usb_buf[0x03]   = mode;
     usb_buf[0x04]   = 0x00;
     usb_buf[0x05]   = speed;
-    usb_buf[0x06]   = 0x64;
+    usb_buf[0x06]   = brightness;
     usb_buf[0x07]   = color_mode;
     usb_buf[0x08]   = dir;
     usb_buf[0x09]   = 0x02;
 
-	if(mode == 4 || mode == 5)
-	{
-	    /*-----------------------------------------------------*\
+    if(mode == 4 || mode == 5)
+    {
+        /*-----------------------------------------------------*\
         | If mode is Rainbow or Ripple                          |
-	    \*-----------------------------------------------------*/
-	    usb_buf[0x0A]   = colors.size();
+        \*-----------------------------------------------------*/
+        usb_buf[0x0A]   = colors.size();
 
-	    /*-----------------------------------------------------*\
-	    | Loop over every color given                           |
-	    \*-----------------------------------------------------*/
+        /*-----------------------------------------------------*\
+        | Loop over every color given                           |
+        \*-----------------------------------------------------*/
         for(unsigned int i = 0; i / 4 < colors.size(); i += 4)
         {
             if(colors[i / 4])
@@ -179,13 +241,13 @@ void AuraTUFKeyboardController::UpdateDevice
                 usb_buf[14 + i] = RGBGetBValue(colors[i/4]);
             }
         }
-	}
+    }
     else
     {
-	    /*-----------------------------------------------------*\
-	    | Loop over Color1, Color2 and Background if there      |
-	    \*-----------------------------------------------------*/
-	    for(unsigned int i = 0; i / 3 != colors.size(); i += 3)
+        /*-----------------------------------------------------*\
+        | Loop over Color1, Color2 and Background if there      |
+        \*-----------------------------------------------------*/
+        for(unsigned int i = 0; i / 3 != colors.size(); i += 3)
         {
             if(colors[i / 3])
             {
@@ -194,25 +256,28 @@ void AuraTUFKeyboardController::UpdateDevice
                 usb_buf[12 + i] = RGBGetBValue(colors[i/3]);
             }
         }
-			
-	}
+            
+    }
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
+}
 
-    /*-----------------------------------------------------*\
-    | Set up and send packet save Packet                    |
-    \*-----------------------------------------------------*/
-    unsigned char usb_save_buf[65];
+void AuraTUFKeyboardController::AwaitResponse()
+{
+    unsigned char usb_buf_out[65];
+    hid_read(dev, usb_buf_out, 65);
+}
 
-    memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
-
-    usb_save_buf[0x00]   = 0x00;
-    usb_save_buf[0x01]   = 0x50;
-    usb_save_buf[0x02]   = 0x55;
-    
-    hid_write(dev, usb_save_buf, 65);
+void AuraTUFKeyboardController::ClearResponses()
+{
+    int result = 1;
+    unsigned char usb_buf_flush[65];
+    while(result > 0)
+    {
+      result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
+    }
 }
 

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h

@@ -8,6 +8,7 @@
 \*-----------------------------------------*/
 
 #include "RGBController.h"
+#include "AsusAuraTUFKeyboardLayouts.h"
 
 #include <string>
 #include <vector>
@@ -38,14 +39,24 @@ enum
     AURA_KEYBOARD_MODE_DIRECT       = 15,
 };
 
+enum
+{
+    AURA_TUF_K7_GAMING_PID          = 0x18AA,
+    AURA_TUF_K3_GAMING_PID          = 0x194B,
+};
+
+
 class AuraTUFKeyboardController
 {
 public:
-    AuraTUFKeyboardController(hid_device* dev_handle, const char* path);
+    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid);
     ~AuraTUFKeyboardController();
 
     std::string GetDeviceLocation();
     std::string GetSerialString();
+    std::string GetVersion();
+    int         GetLayout();
+    void        SaveMode();
 
     void UpdateSingleLed
         (
@@ -55,7 +66,7 @@ public:
         unsigned char   blue
         );
 
-	void UpdateLeds
+    void UpdateLeds
         (
         std::vector<RGBColor>    colors
         );
@@ -66,8 +77,13 @@ public:
         std::vector<RGBColor>   colors,
         unsigned char           dir,
         unsigned char           color_mode,
-        unsigned char           speed
+        unsigned char           speed,
+        unsigned char           brightness
         );
+    void AwaitResponse();
+    void ClearResponses();
+
+    uint16_t                    device_pid;
 
 private:
     hid_device*                 dev;

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardLayouts.h

@@ -0,0 +1,412 @@
+/*-----------------------------------------*\
+|  AsusAuraTUFKeyboardController.h          |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Mola19 10/02/2021                        |
+\*-----------------------------------------*/
+
+#include "RGBControllerKeyNames.h"
+#include <vector>
+#include <map>
+#include "RGBController.h"
+
+#pragma once
+
+enum
+{
+    ASUS_TUF_K7_LAYOUT_CA    = 1,
+    ASUS_TUF_K7_LAYOUT_AR    = 2,
+    ASUS_TUF_K7_LAYOUT_DE    = 3,
+    ASUS_TUF_K7_LAYOUT_UK    = 4,
+    ASUS_TUF_K7_LAYOUT_FR    = 5,
+    ASUS_TUF_K7_LAYOUT_CN    = 6,
+    ASUS_TUF_K7_LAYOUT_HU    = 7,
+    ASUS_TUF_K7_LAYOUT_IT    = 8,
+    ASUS_TUF_K7_LAYOUT_TH    = 9,
+    ASUS_TUF_K7_LAYOUT_UA    = 10,
+    ASUS_TUF_K7_LAYOUT_NO    = 11,
+    ASUS_TUF_K7_LAYOUT_PT    = 12,
+    ASUS_TUF_K7_LAYOUT_HE    = 13,
+    ASUS_TUF_K7_LAYOUT_RU    = 14,
+    ASUS_TUF_K7_LAYOUT_ES    = 15,
+    ASUS_TUF_K7_LAYOUT_TW    = 16,
+    ASUS_TUF_K7_LAYOUT_US    = 17,
+    ASUS_TUF_K7_LAYOUT_TR    = 18,
+    ASUS_TUF_K7_LAYOUT_CZ    = 19,
+    ASUS_TUF_K7_LAYOUT_BE    = 20,
+    ASUS_TUF_K7_LAYOUT_JP    = 21,
+    ASUS_TUF_K7_LAYOUT_KR    = 22,
+    ASUS_TUF_K7_LAYOUT_IS    = 23,
+    ASUS_TUF_K7_LAYOUT_WB    = 24,
+    ASUS_TUF_K7_LAYOUT_SW_CH = 25
+};
+
+#define NA  0xFFFFFFFF
+
+typedef struct
+{
+    unsigned int *                matrix_map;
+    std::vector<std::string>      led_names;
+} layout_type;
+
+
+static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_104[6][23] = {
+    {   0,  NA,  18,  24,  30,  36,  NA,  48,  54,  60,  66,  72,  78,  84,  90,  NA,  96, 102, 108,  NA,  NA,  NA,  NA },
+    {   1,  13,  19,  25,  31,  37,  43,  49,  55,  61,  67,  73,  79,  91,  NA,  NA,  97, 103, 109, 115, 121, 127, 133 },
+    {   2,  NA,  14,  20,  26,  32,  38,  44,  50,  56,  62,  68,  74,  80,  92,  NA,  98, 104, 110, 116, 122, 128, 134 },
+    {   3,  NA,  15,  21,  27,  33,  39,  45,  51,  57,  63,  69,  75,  NA,  93,  NA,  NA,  NA,  NA, 117, 123, 129,  NA },
+    {   4,  NA,  16,  22,  28,  34,  40,  46,  52,  58,  64,  70,  NA,  94,  NA,  NA,  NA, 106,  NA, 118, 124, 130, 136 },
+    {   5,  11,  17,  NA,  NA,  NA,  41,  NA,  NA,  NA,  59,  71,  77,  NA,  95,  NA, 101, 107, 113, 119,  NA, 131,  NA }
+};
+
+static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_105[6][23] = {
+    {   0,  NA,  18,  24,  30,  36,  NA,  48,  54,  60,  66,  72,  78,  84,  90,  NA,  96, 102, 108,  NA,  NA,  NA,  NA },
+    {   1,  13,  19,  25,  31,  37,  43,  49,  55,  61,  67,  73,  79,  91,  NA,  NA,  97, 103, 109, 115, 121, 127, 133 },
+    {   2,  NA,  14,  20,  26,  32,  38,  44,  50,  56,  62,  68,  74,  80,  NA,  NA,  98, 104, 110, 116, 122, 128, 134 },
+    {   3,  NA,  15,  21,  27,  33,  39,  45,  51,  57,  63,  69,  75,  81,  93,  NA,  NA,  NA,  NA, 117, 123, 129,  NA },
+    {   4,  10,  16,  22,  28,  34,  40,  46,  52,  58,  64,  70,  NA,  94,  NA,  NA,  NA, 106,  NA, 118, 124, 130, 136 },
+    {   5,  11,  17,  NA,  NA,  NA,  41,  NA,  NA,  NA,  59,  71,  77,  NA,  95,  NA, 101, 107, 113, 119,  NA, 131,  NA }
+};
+
+
+static std::map<int,layout_type> AsusTUFK7Layouts =
+{
+    {
+        ASUS_TUF_K7_LAYOUT_UK,
+        {
+            (unsigned int *) ASUS_TUF_K7_LAYOUT_KEYS_105,
+            {
+                KEY_EN_ESCAPE,
+                KEY_EN_BACK_TICK,
+                KEY_EN_TAB,
+                KEY_EN_CAPS_LOCK,
+                KEY_EN_LEFT_SHIFT,
+                KEY_EN_LEFT_CONTROL,
+
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                "Key: \\",
+                KEY_EN_LEFT_WINDOWS,
+
+                KEY_EN_UNUSED,
+                KEY_EN_1,
+                KEY_EN_Q,
+                KEY_EN_A,
+                KEY_EN_Z,
+                KEY_EN_LEFT_ALT,
+
+                KEY_EN_F1,
+                KEY_EN_2,
+                KEY_EN_W,
+                KEY_EN_S,
+                KEY_EN_X,
+                KEY_EN_UNUSED,
+
+                KEY_EN_F2,
+                KEY_EN_3,
+                KEY_EN_E,
+                KEY_EN_D,
+                KEY_EN_C,
+                KEY_EN_UNUSED,
+
+                KEY_EN_F3,
+                KEY_EN_4,
+                KEY_EN_R,
+                KEY_EN_F,
+                KEY_EN_V,
+                KEY_EN_UNUSED,
+
+                KEY_EN_F4,
+                KEY_EN_5,
+                KEY_EN_T,
+                KEY_EN_G,
+                KEY_EN_B,
+                KEY_EN_SPACE,
+
+                KEY_EN_UNUSED,
+                KEY_EN_6,
+                KEY_EN_Y,
+                KEY_EN_H,
+                KEY_EN_N,
+                KEY_EN_UNUSED,
+
+                KEY_EN_F5,
+                KEY_EN_7,
+                KEY_EN_U,
+                KEY_EN_J,
+                KEY_EN_M,
+                KEY_EN_UNUSED,
+
+                KEY_EN_F6,
+                KEY_EN_8,
+                KEY_EN_I,
+                KEY_EN_K,
+                KEY_EN_COMMA,
+                KEY_EN_RIGHT_ALT,
+
+                KEY_EN_F7,
+                KEY_EN_9,
+                KEY_EN_O,
+                KEY_EN_L,
+                KEY_EN_PERIOD,
+                KEY_EN_UNUSED,
+
+                KEY_EN_F8,
+                KEY_EN_0,
+                KEY_EN_P,
+                KEY_EN_SEMICOLON,
+                KEY_EN_FORWARD_SLASH,
+                KEY_EN_RIGHT_FUNCTION,
+
+                KEY_EN_F9,
+                KEY_EN_MINUS,
+                KEY_EN_LEFT_BRACKET,
+                KEY_EN_QUOTE,
+                KEY_EN_UNUSED,
+                KEY_EN_MENU,
+
+                KEY_EN_F10,
+                KEY_EN_EQUALS,
+                KEY_EN_RIGHT_BRACKET,
+                KEY_EN_POUND,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+
+                KEY_EN_F11,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+
+                KEY_EN_F12,
+                KEY_EN_BACKSPACE,
+                KEY_EN_UNUSED,
+                KEY_EN_ANSI_ENTER,
+                KEY_EN_RIGHT_SHIFT,
+                KEY_EN_RIGHT_CONTROL,
+
+                KEY_EN_PRINT_SCREEN,
+                KEY_EN_INSERT,
+                KEY_EN_DELETE,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                KEY_EN_LEFT_ARROW,
+
+                KEY_EN_SCROLL_LOCK,
+                KEY_EN_HOME,
+                KEY_EN_END,
+                KEY_EN_UNUSED,
+                KEY_EN_UP_ARROW,
+                KEY_EN_DOWN_ARROW,
+
+                KEY_EN_PAUSE_BREAK,
+                KEY_EN_PAGE_UP,
+                KEY_EN_PAGE_DOWN,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                KEY_EN_RIGHT_ARROW,
+
+                KEY_EN_UNUSED,
+                KEY_EN_NUMPAD_LOCK,
+                KEY_EN_NUMPAD_7,
+                KEY_EN_NUMPAD_4,
+                KEY_EN_NUMPAD_1,
+                KEY_EN_NUMPAD_0,
+
+                KEY_EN_UNUSED,
+                KEY_EN_NUMPAD_DIVIDE,
+                KEY_EN_NUMPAD_8,
+                KEY_EN_NUMPAD_5,
+                KEY_EN_NUMPAD_2,
+                KEY_EN_UNUSED,
+
+                KEY_EN_UNUSED,
+                KEY_EN_NUMPAD_TIMES,
+                KEY_EN_NUMPAD_9,
+                KEY_EN_NUMPAD_6,
+                KEY_EN_NUMPAD_3,
+                "Key: Number Pad ,",
+
+                KEY_EN_UNUSED,
+                KEY_EN_NUMPAD_MINUS,
+                KEY_EN_NUMPAD_PLUS,
+                KEY_EN_UNUSED,
+                KEY_EN_NUMPAD_ENTER,
+                KEY_EN_UNUSED,
+            }
+        }
+    },
+    {
+        ASUS_TUF_K7_LAYOUT_US,
+        {
+            (unsigned int *) ASUS_TUF_K7_LAYOUT_KEYS_104,
+            {
+                KEY_EN_ESCAPE,
+                KEY_EN_BACK_TICK,
+                KEY_EN_TAB,
+                KEY_EN_CAPS_LOCK,
+                KEY_EN_LEFT_SHIFT,
+                KEY_EN_LEFT_CONTROL,
+
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                KEY_EN_LEFT_WINDOWS,
+
+                KEY_EN_UNUSED,
+                KEY_EN_1,
+                KEY_EN_Q,
+                KEY_EN_A,
+                KEY_EN_Z,
+                KEY_EN_LEFT_ALT,
+
+                KEY_EN_F1,
+                KEY_EN_2,
+                KEY_EN_W,
+                KEY_EN_S,
+                KEY_EN_X,
+                KEY_EN_UNUSED,
+
+                KEY_EN_F2,
+                KEY_EN_3,
+                KEY_EN_E,
+                KEY_EN_D,
+                KEY_EN_C,
+                KEY_EN_UNUSED,
+
+                KEY_EN_F3,
+                KEY_EN_4,
+                KEY_EN_R,
+                KEY_EN_F,
+                KEY_EN_V,
+                KEY_EN_UNUSED,
+
+                KEY_EN_F4,
+                KEY_EN_5,
+                KEY_EN_T,
+                KEY_EN_G,
+                KEY_EN_B,
+                KEY_EN_SPACE,
+
+                KEY_EN_UNUSED,
+                KEY_EN_6,
+                KEY_EN_Y,
+                KEY_EN_H,
+                KEY_EN_N,
+                KEY_EN_UNUSED,
+
+                KEY_EN_F5,
+                KEY_EN_7,
+                KEY_EN_U,
+                KEY_EN_J,
+                KEY_EN_M,
+                KEY_EN_UNUSED,
+
+                KEY_EN_F6,
+                KEY_EN_8,
+                KEY_EN_I,
+                KEY_EN_K,
+                KEY_EN_COMMA,
+                KEY_EN_RIGHT_ALT,
+
+                KEY_EN_F7,
+                KEY_EN_9,
+                KEY_EN_O,
+                KEY_EN_L,
+                KEY_EN_PERIOD,
+                KEY_EN_UNUSED,
+
+                KEY_EN_F8,
+                KEY_EN_0,
+                KEY_EN_P,
+                KEY_EN_SEMICOLON,
+                KEY_EN_FORWARD_SLASH,
+                KEY_EN_RIGHT_FUNCTION,
+
+                KEY_EN_F9,
+                KEY_EN_MINUS,
+                KEY_EN_LEFT_BRACKET,
+                KEY_EN_QUOTE,
+                KEY_EN_UNUSED,
+                KEY_EN_MENU,
+
+                KEY_EN_F10,
+                KEY_EN_EQUALS,
+                KEY_EN_RIGHT_BRACKET,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+
+                KEY_EN_F11,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+
+                KEY_EN_F12,
+                KEY_EN_BACKSPACE,
+                "Key: \\",
+                KEY_EN_ANSI_ENTER,
+                KEY_EN_RIGHT_SHIFT,
+                KEY_EN_RIGHT_CONTROL,
+
+                KEY_EN_PRINT_SCREEN,
+                KEY_EN_INSERT,
+                KEY_EN_DELETE,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                KEY_EN_LEFT_ARROW,
+
+                KEY_EN_SCROLL_LOCK,
+                KEY_EN_HOME,
+                KEY_EN_END,
+                KEY_EN_UNUSED,
+                KEY_EN_UP_ARROW,
+                KEY_EN_DOWN_ARROW,
+
+                KEY_EN_PAUSE_BREAK,
+                KEY_EN_PAGE_UP,
+                KEY_EN_PAGE_DOWN,
+                KEY_EN_UNUSED,
+                KEY_EN_UNUSED,
+                KEY_EN_RIGHT_ARROW,
+
+                KEY_EN_UNUSED,
+                KEY_EN_NUMPAD_LOCK,
+                KEY_EN_NUMPAD_7,
+                KEY_EN_NUMPAD_4,
+                KEY_EN_NUMPAD_1,
+                KEY_EN_NUMPAD_0,
+
+                KEY_EN_UNUSED,
+                KEY_EN_NUMPAD_DIVIDE,
+                KEY_EN_NUMPAD_8,
+                KEY_EN_NUMPAD_5,
+                KEY_EN_NUMPAD_2,
+                KEY_EN_UNUSED,
+
+                KEY_EN_UNUSED,
+                KEY_EN_NUMPAD_TIMES,
+                KEY_EN_NUMPAD_9,
+                KEY_EN_NUMPAD_6,
+                KEY_EN_NUMPAD_3,
+                "Key: Number Pad ,",
+
+                KEY_EN_UNUSED,
+                KEY_EN_NUMPAD_MINUS,
+                KEY_EN_NUMPAD_PLUS,
+                KEY_EN_UNUSED,
+                KEY_EN_NUMPAD_ENTER,
+                KEY_EN_UNUSED,
+            }
+        }
+    },
+};

Controllers/AsusAuraUSBController/AsusAuraUSBController.cpp

@@ -8,6 +8,8 @@
 \*-----------------------------------------*/
 
 #include "AsusAuraUSBController.h"
+#include "LogManager.h"
+
 #include <cstring>
 #include <stdexcept>
 
@@ -88,21 +90,23 @@ void AuraUSBController::GetConfigTable()
     {
         memcpy(config_table, &usb_buf[4], 60);
 
+        LOG_DEBUG("[%s] ASUS Aura USB config table:", device_name);
+
         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]);
+            LOG_DEBUG("[%s] %02X %02X %02X %02X %02X %02X", device_name,
+                                                            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
     {       
-        hid_close(dev);
-
-        throw std::runtime_error("Could not read config table");
+        LOG_INFO("[%s] Could not read config table, can not add device", device_name);
+        delete this;
     }
 }
 

Controllers/AsusAuraUSBController/AsusAuraUSBController.h

@@ -8,6 +8,7 @@
 \*-----------------------------------------*/
 
 #include "RGBController.h"
+#include "LogManager.h"
 
 #include <string>
 #include <vector>

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -5,12 +5,19 @@
 #include "AsusAuraTUFKeyboardController.h"
 #include "AsusAuraMainboardController.h"
 #include "AsusAuraMouseController.h"
+#include "AsusAuraMousematController.h"
+#include "AsusAuraStrixEvolveController.h"
+#include "AsusAuraMonitorController.h"
 #include "RGBController.h"
 #include "RGBController_AsusAuraUSB.h"
 #include "RGBController_AsusAuraHeadsetStand.h"
 #include "RGBController_AsusAuraKeyboard.h"
 #include "RGBController_AsusAuraTUFKeyboard.h"
 #include "RGBController_AsusAuraMouse.h"
+#include "RGBController_AsusAuraMousemat.h"
+#include "RGBController_ROGStrixLC_Controller.h"
+#include "RGBController_AsusAuraStrixEvolve.h"
+#include "RGBController_AsusAuraMonitor.h"
 #include <stdexcept>
 #include <hidapi/hidapi.h>
 #include "dependencies/dmiinfo.h"
@@ -39,18 +46,39 @@
 #define AURA_ROG_STRIX_SCOPE_RX_PID             0x1951
 #define AURA_ROG_STRIX_SCOPE_TKL_PID            0x190C
 #define AURA_TUF_K7_GAMING_PID                  0x18AA
+#define AURA_TUF_K3_GAMING_PID                  0x194B
 
 /*-----------------------------------------------------------------*\
 |  MICE - defined in AsusAuraMouseDevices.h                         |
 \*-----------------------------------------------------------------*/
 
+#define AURA_ROG_STRIX_EVOLVE_PID               0x185B
+
+/*-----------------------------------------------------------------*\
+| MOUSEMATS                                                         |
+\*-----------------------------------------------------------------*/
+#define AURA_ROG_BALTEUS_PID                    0x1891
+#define AURA_ROG_BALTEUS_QI_PID                 0x1890
+
+/*-----------------------------------------------------------------*\
+| MONITORS                                                          |
+\*-----------------------------------------------------------------*/
+
+#define AURA_ROG_STRIX_XG27AQ_PID               0x198C
+
+/*-----------------------------------------------------------------*\
+| HEADSETSTANDS                                                     |
+\*-----------------------------------------------------------------*/
+
+#define AURA_ROG_THRONE_PID                     0x18D9
+#define AURA_ROG_THRONE_QI_PID                  0x18C5
+#define AURA_ROG_THRONE_QI_GUNDAM_PID           0x1994
 
 /*-----------------------------------------------------------------*\
 |  OTHER                                                            |
 \*-----------------------------------------------------------------*/
 #define AURA_TERMINAL_PID                       0x1889
-#define AURA_ROG_THRONE_QI_PID                  0x18C5
-
+#define ROG_STRIX_LC120_PID                     0x879E
 
 AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
 {
@@ -84,9 +112,9 @@ void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
 
     if(dev)
     {
-        AuraAddressableController* controller = new AuraAddressableController(dev, info->path);
-        RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
-        rgb_controller->name = name;
+        AuraAddressableController* controller               = new AuraAddressableController(dev, info->path);
+        RGBController_AuraUSB*     rgb_controller           = new RGBController_AuraUSB(controller);
+        rgb_controller->name                                = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -98,9 +126,9 @@ void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& /*na
     if(dev)
     {
         DMIInfo dmi;
-        AuraAddressableController* controller = new AuraAddressableController(dev, info->path);
-        RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
-        rgb_controller->name = "ASUS " + dmi.getMainboard() + " Addressable";
+        AuraAddressableController* controller               = new AuraAddressableController(dev, info->path);
+        RGBController_AuraUSB*     rgb_controller           = new RGBController_AuraUSB(controller);
+        rgb_controller->name                                = "ASUS " + dmi.getMainboard() + " Addressable";
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -108,19 +136,21 @@ void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& /*na
 void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*name*/)
 {
     hid_device* dev = hid_open_path(info->path);
+
     if(dev)
     {
         try
         {
             DMIInfo dmi;
-            AuraMainboardController* controller = new AuraMainboardController(dev, info->path);
-            RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
-            rgb_controller->name = "ASUS " + dmi.getMainboard();
+            AuraMainboardController* controller             = new AuraMainboardController(dev, info->path);
+            RGBController_AuraUSB*   rgb_controller         = new RGBController_AuraUSB(controller);
+            rgb_controller->name                            = "ASUS " + dmi.getMainboard();
             ResourceManager::get()->RegisterRGBController(rgb_controller);
         }
-        catch(std::runtime_error&)
+        catch(const std::runtime_error& ex)
         {
             // reading the config table failed
+            LOG_ERROR("[AsusAuraUSB] An error occured while reading the config table: %s", ex.what());
         }
     }
 }
@@ -128,12 +158,13 @@ void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*n
 void DetectAsusAuraUSBKeyboards(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
+
     if(dev)
     {
-        AuraKeyboardController* controller         = new AuraKeyboardController(dev, info->path);
-        AuraKeyboardMappingLayoutType layout       = GetKeyboardMappingLayoutType(info->product_id);
-        RGBController_AuraKeyboard* rgb_controller = new RGBController_AuraKeyboard(controller, layout);
-        rgb_controller->name = name;
+        AuraKeyboardController*       controller            = new AuraKeyboardController(dev, info->path);
+        AuraKeyboardMappingLayoutType layout                = GetKeyboardMappingLayoutType(info->product_id);
+        RGBController_AuraKeyboard*   rgb_controller        = new RGBController_AuraKeyboard(controller, layout);
+        rgb_controller->name                                = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -141,11 +172,51 @@ void DetectAsusAuraUSBKeyboards(hid_device_info* info, const std::string& name)
 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, info->product_id);
-        RGBController_AuraMouse* rgb_controller = new RGBController_AuraMouse(controller);
-        rgb_controller->name = name;
+        AuraMouseController*     controller                 = new AuraMouseController(dev, info->path, info->product_id);
+        RGBController_AuraMouse* rgb_controller             = new RGBController_AuraMouse(controller);
+        rgb_controller->name                                = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectAsusAuraUSBMousemats(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AuraMousematController*     controller              = new AuraMousematController(dev, info->path);
+        RGBController_AuraMousemat* rgb_controller          = new RGBController_AuraMousemat(controller);
+        rgb_controller->name                                = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectAsusAuraUSBROGStrixLC(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        ROGStrixLC_Controller* controller                   = new ROGStrixLC_Controller(dev, info->path);
+        RGBController_ROGStrixLC_Controller* rgb_controller = new RGBController_ROGStrixLC_Controller(controller);
+        rgb_controller->name                                = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AuraStrixEvolveController*     controller           = new AuraStrixEvolveController(dev, info->path, info->product_id);
+        RGBController_AuraStrixEvolve* rgb_controller       = new RGBController_AuraStrixEvolve(controller);
+        rgb_controller->name                                = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -153,11 +224,12 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
 void DetectAsusAuraUSBHeadsetStand(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
+
     if(dev)
     {
-        AuraHeadsetStandController* controller = new AuraHeadsetStandController(dev, info->path);
-        RGBController_AuraHeadsetStand* rgb_controller = new RGBController_AuraHeadsetStand(controller);
-        rgb_controller->name = name;
+        AuraHeadsetStandController*     controller          = new AuraHeadsetStandController(dev, info->path);
+        RGBController_AuraHeadsetStand* rgb_controller      = new RGBController_AuraHeadsetStand(controller);
+        rgb_controller->name                                = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -165,11 +237,25 @@ void DetectAsusAuraUSBHeadsetStand(hid_device_info* info, const std::string& nam
 void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
+
     if(dev)
     {
-        AuraTUFKeyboardController* controller = new AuraTUFKeyboardController(dev, info->path);
-        RGBController_AuraTUFKeyboard* rgb_controller = new RGBController_AuraTUFKeyboard(controller);
-        rgb_controller->name = name;
+        AuraTUFKeyboardController*     controller           = new AuraTUFKeyboardController(dev, info->path, info->product_id);
+        RGBController_AuraTUFKeyboard* rgb_controller       = new RGBController_AuraTUFKeyboard(controller);
+        rgb_controller->name                                = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectAsusAuraUSBMonitor(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AuraMonitorController*     controller           = new AuraMonitorController(dev, info->path);
+        RGBController_AuraMonitor* rgb_controller       = new RGBController_AuraMonitor(controller);
+        rgb_controller->name                            = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -195,7 +281,8 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",        DetectAsusAuraUS
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID,                 1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX",             DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID,              1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL",            DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PID,             1,  0xFF00);
-REGISTER_HID_DETECTOR_I ("ASUS TUF Gaming K7",                  DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID,                   1);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K7",                  DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID,                   1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3",                  DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K3_GAMING_PID,                   1,  0xFF00);
 
 /*-----------------------------------------------------------------*\
 |  MICE                                                             |
@@ -204,21 +291,42 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core",            DetectAsusAuraUS
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_PID,                  2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin",          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID,           2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD",  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID,   2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD",      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_COD_PID,       1,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD",      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_COD_PID,       2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID,       1,  0xFF13);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID,       2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",         DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRELESS_PID,            0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,             0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_2_PID,             0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Chakram Core",               DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_CORE_PID,                0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio",                      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_PID,                       2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID,              1,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wireless)",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRELESS_PID,           1,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PID,             1,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID,              0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wireless)",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRELESS_PID,           0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact",               DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_PID,                0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PID,             0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris",                      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS,                           0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless USB",         DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_USB_PID,          0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless 2.4Ghz",      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_2_4_PID,          0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless Bluetooth",   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_BT_PID,           0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M3",                  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M3_PID,                          1,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5",                  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M5_PID,                          1,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5",                  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M5_PID,                          2,  0xFF01);
+
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Evolve",               DetectAsusAuraUSBStrixEvolve,   AURA_USB_VID, AURA_ROG_STRIX_EVOLVE_PID,                1,  0x0008);
+
+/*-----------------------------------------------------------------*\
+| MOUSEMATS                                                         |
+\*-----------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus",                    DetectAsusAuraUSBMousemats,     AURA_USB_VID, AURA_ROG_BALTEUS_PID,                     0xFF06, 1);
+REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus Qi",                 DetectAsusAuraUSBMousemats,     AURA_USB_VID, AURA_ROG_BALTEUS_QI_PID,                  0xFF06, 1);
+
+/*-----------------------------------------------------------------*\
+| MONITORS                                                          |
+\*-----------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQ",               DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27AQ_PID,                0xFFA0, 1);
 
 /*-----------------------------------------------------------------*\
 |  OTHER                                                            |
 \*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR   ("ASUS ROG AURA Terminal",              DetectAsusAuraUSBTerminal,      AURA_USB_VID, AURA_TERMINAL_PID);
-REGISTER_HID_DETECTOR_I ("ASUS ROG Throne QI",                  DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_PID,                   0);
+REGISTER_HID_DETECTOR    ("ASUS ROG AURA Terminal",             DetectAsusAuraUSBTerminal,      AURA_USB_VID, AURA_TERMINAL_PID);
+REGISTER_HID_DETECTOR_PU ("ASUS ROG Strix LC",                  DetectAsusAuraUSBROGStrixLC,    AURA_USB_VID, ROG_STRIX_LC120_PID,                      0x00FF, 1);
+REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne",                    DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_PID,                      0);
+REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI",                 DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_PID,                   0);
+REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI GUNDAM",          DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_GUNDAM_PID,            0);

Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.cpp

@@ -9,16 +9,27 @@
 
 #include "RGBController_AsusAuraHeadsetStand.h"
 
-RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandController* aura_ptr)
+/**------------------------------------------------------------------*\
+    @name Asus Aura Headset Stand
+    @type USB
+    @save :white_check_mark:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAsusAuraUSBHeadsetStand
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandController* controller_ptr)
 {
-    aura        = aura_ptr;
+    controller  = controller_ptr;
 
     name        = "ASUS Aura Headset Stand";
     vendor      = "ASUS";
     type        = DEVICE_TYPE_HEADSET_STAND;
     description = "ASUS Aura Headset Stand Device";
-    location    = aura->GetDeviceLocation();
-    serial      = aura->GetSerialString();
+    version     = controller->GetVersion();
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
 
     mode Direct;
     Direct.name       = "Direct";
@@ -28,62 +39,77 @@ RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandC
     modes.push_back(Direct);
 
     mode Static;
-    Static.name       = "Static";
-    Static.value      = AURA_HEADSET_STAND_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors_min = 1;
-    Static.colors_max = 1;
+    Static.name           = "Static";
+    Static.value          = AURA_HEADSET_STAND_MODE_STATIC;
+    Static.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Static.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
+    Static.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
+    Static.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
+    Static.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min     = 1;
+    Static.colors_max     = 1;
     Static.colors.resize(1);
     modes.push_back(Static);
 
     mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = AURA_HEADSET_STAND_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.speed_min  = 0;
-    Breathing.speed_max  = 255;
-    Breathing.speed      = 127;
-    Breathing.colors_min = 1;
-    Breathing.colors_max = 1;
+    Breathing.name           = "Breathing";
+    Breathing.value          = AURA_HEADSET_STAND_MODE_BREATHING;
+    Breathing.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Breathing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed_min      = AURA_HEADSETSTAND_SPEED_MIN;
+    Breathing.speed_max      = AURA_HEADSETSTAND_SPEED_MAX;
+    Breathing.speed          = AURA_HEADSETSTAND_SPEED_DEFAULT;
+    Breathing.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
+    Breathing.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
+    Breathing.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
+    Breathing.colors_min     = 1;
+    Breathing.colors_max     = 1;
     Breathing.colors.resize(1);
     modes.push_back(Breathing);
 
     mode Strobing;
-    Strobing.name       = "Strobing";
-    Strobing.value      = AURA_HEADSET_STAND_MODE_STROBING;
-    Strobing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Strobing.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Strobing.colors_min = 1;
-    Strobing.colors_max = 1;
+    Strobing.name           = "Flashing";
+    Strobing.value          = AURA_HEADSET_STAND_MODE_STROBING;
+    Strobing.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Strobing.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
+    Strobing.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
+    Strobing.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
+    Strobing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Strobing.colors_min     = 1;
+    Strobing.colors_max     = 1;
     Strobing.colors.resize(1);
     modes.push_back(Strobing);
 
     mode SpectrumCycle;
-    SpectrumCycle.name       = "Spectrum Cycle";
-    SpectrumCycle.value      = AURA_HEADSET_STAND_MODE_COLOR_CYCLE;
-    SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED;
-    SpectrumCycle.speed_min  = 0;
-    SpectrumCycle.speed_max  = 255;
-    SpectrumCycle.speed      = 127;
-    SpectrumCycle.color_mode = MODE_COLORS_NONE;
+    SpectrumCycle.name           = "Spectrum Cycle";
+    SpectrumCycle.value          = AURA_HEADSET_STAND_MODE_COLOR_CYCLE;
+    SpectrumCycle.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    SpectrumCycle.speed_min      = AURA_HEADSETSTAND_SPEED_MIN;
+    SpectrumCycle.speed_max      = AURA_HEADSETSTAND_SPEED_MAX;
+    SpectrumCycle.speed          = AURA_HEADSETSTAND_SPEED_DEFAULT;
+    SpectrumCycle.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
+    SpectrumCycle.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
+    SpectrumCycle.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
+    SpectrumCycle.color_mode     = MODE_COLORS_NONE;
     modes.push_back(SpectrumCycle);
 
     mode Rainbow;
-    Rainbow.name       = "Rainbow";
-    Rainbow.value      = AURA_HEADSET_STAND_MODE_RAINBOW;
-    Rainbow.flags      = MODE_FLAG_HAS_SPEED;
-    Rainbow.speed_min  = 0;
-    Rainbow.speed_max  = 255;
-    Rainbow.speed      = 127;
+    Rainbow.name           = "Rainbow Wave";
+    Rainbow.value          = AURA_HEADSET_STAND_MODE_RAINBOW;
+    Rainbow.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Rainbow.speed_min      = AURA_HEADSETSTAND_SPEED_MIN;
+    Rainbow.speed_max      = AURA_HEADSETSTAND_SPEED_MAX;
+    Rainbow.speed          = AURA_HEADSETSTAND_SPEED_DEFAULT;
+    Rainbow.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
+    Rainbow.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
+    Rainbow.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
     modes.push_back(Rainbow);
     SetupZones();
 }
 
 RGBController_AuraHeadsetStand::~RGBController_AuraHeadsetStand()
 {
-	delete aura;
+    delete controller;
 }
 
 void RGBController_AuraHeadsetStand::SetupZones()
@@ -137,7 +163,7 @@ void RGBController_AuraHeadsetStand::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_AuraHeadsetStand::DeviceUpdateLEDs()
 {
-    aura->UpdateLeds(std::vector<RGBColor>(colors));
+    controller->UpdateLeds(std::vector<RGBColor>(colors));
 }
 
 void RGBController_AuraHeadsetStand::UpdateZoneLEDs(int /*zone*/)
@@ -164,7 +190,7 @@ void RGBController_AuraHeadsetStand::DeviceUpdateMode()
     switch(modes[active_mode].value)
     {
         case 0:
-            aura->UpdateLeds(std::vector<RGBColor>(colors));
+            controller->UpdateLeds(std::vector<RGBColor>(colors));
             break;
         case 1:
         case 2:
@@ -172,11 +198,17 @@ void RGBController_AuraHeadsetStand::DeviceUpdateMode()
             red = RGBGetRValue(modes[active_mode].colors[0]);
             grn = RGBGetGValue(modes[active_mode].colors[0]);
             blu = RGBGetBValue(modes[active_mode].colors[0]);
-            aura->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, false);
+            controller->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, modes[active_mode].brightness);
             break;
         case 4:
         case 5:
-            aura->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, false);
+            controller->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, modes[active_mode].brightness);
             break;
     }
 }
+
+void RGBController_AuraHeadsetStand::DeviceSaveMode()
+{
+    DeviceUpdateMode();
+    controller->SaveMode();
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.h

@@ -11,10 +11,20 @@
 #include "RGBController.h"
 #include "AsusAuraHeadsetStandController.h"
 
+enum
+{
+    AURA_HEADSETSTAND_BRIGHTNESS_MIN     = 0,
+    AURA_HEADSETSTAND_BRIGHTNESS_MAX     = 4,
+    AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT = 4,
+    AURA_HEADSETSTAND_SPEED_MIN          = 0,
+    AURA_HEADSETSTAND_SPEED_MAX          = 255,
+    AURA_HEADSETSTAND_SPEED_DEFAULT      = 127,
+};
+
 class RGBController_AuraHeadsetStand : public RGBController
 {
 public:
-    RGBController_AuraHeadsetStand(AuraHeadsetStandController* aura_ptr);
+    RGBController_AuraHeadsetStand(AuraHeadsetStandController* controller_ptr);
     ~RGBController_AuraHeadsetStand();
 
     void        SetupZones();
@@ -27,7 +37,8 @@ public:
 
     void        SetCustomMode();
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
-    AuraHeadsetStandController*  aura;
+    AuraHeadsetStandController*  controller;
 };

Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.cpp

@@ -7,6 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 3/19/2020   |
 \*-----------------------------------------*/
 
+#include "RGBControllerKeyNames.h"
 #include "RGBController_AsusAuraKeyboard.h"
 
 //0xFFFFFFFF indicates an unused entry in matrix
@@ -46,199 +47,199 @@ static unsigned int falchion_matrix_map[5][16] =
 static const std::vector<led_type> default_led_names =
 {
     /* Key Label                Index  */
-    { "Key: Escape",            0x00    },
-    { "Key: `",                 0x01    },
-    { "Key: Tab",               0x02    },
-    { "Key: Caps Lock",         0x03    },
-    { "Key: Left Shift",        0x04    },
-    { "Key: Left Control",      0x05    },
-    { "Key: \\ (ISO)",          0x0C    },
-    { "Key: 1",                 0x11    },
-    { "Key: Q",                 0x12    },
-    { "Key: A",                 0x13    },
-    { "Key: Z",                 0x14    },
-    { "Key: F1",                0x18    },
-    { "Key: 2",                 0x19    },
-    { "Key: W",                 0x1A    },
-    { "Key: S",                 0x1B    },
-    { "Key: X",                 0x1C    },
-    { "Key: F2",                0x20    },
-    { "Key: 3",                 0x21    },
-    { "Key: E",                 0x22    },
-    { "Key: D",                 0x23    },
-    { "Key: C",                 0x24    },
-    { "Key: F3",                0x28    },
-    { "Key: 4",                 0x29    },
-    { "Key: R",                 0x2A    },
-    { "Key: F",                 0x2B    },
-    { "Key: V",                 0x2C    },
-    { "Key: F4",                0x30    },
-    { "Key: 5",                 0x31    },
-    { "Key: T",                 0x32    },
-    { "Key: G",                 0x33    },
-    { "Key: B",                 0x34    },
-    { "Key: Space",             0x35    },
-    { "Key: 6",                 0x39    },
-    { "Key: Y",                 0x3A    },
-    { "Key: H",                 0x3B    },
-    { "Key: N",                 0x3C    },
-    { "Key: F5",                0x40    },
-    { "Key: 7",                 0x41    },
-    { "Key: U",                 0x42    },
-    { "Key: J",                 0x43    },
-    { "Key: M",                 0x44    },
-    { "Key: F6",                0x48    },
-    { "Key: 8",                 0x49    },
-    { "Key: I",                 0x4A    },
-    { "Key: K",                 0x4B    },
-    { "Key: ,",                 0x4C    },
-    { "Key: Right Alt",         0x4D    },
-    { "Key: F7",                0x50    },
-    { "Key: 9",                 0x51    },
-    { "Key: O",                 0x52    },
-    { "Key: L",                 0x53    },
-    { "Key: .",                 0x54    },
-    { "Key: F8",                0x58    },
-    { "Key: 0",                 0x59    },
-    { "Key: P",                 0x5A    },
-    { "Key: ;",                 0x5B    },
-    { "Key: /",                 0x5C    },
-    { "Key: Right Fn",          0x5D    },
-    { "Key: F9",                0x60    },
-    { "Key: -",                 0x61    },
-    { "Key: [",                 0x62    },
-    { "Key: '",                 0x63    },
-    { "Key: Menu",              0x65    },
-    { "Key: F10",               0x68    },
-    { "Key: =",                 0x69    },
-    { "Key: ]",                 0x6A    },
-    { "Key: #",                 0x6B    },
-    { "Key: F11",               0x70    },
-    { "Key: F12",               0x78    },
-    { "Key: Backspace",         0x79    },
-    { "Key: \\ (ANSI)",         0x7A    },
-    { "Key: Enter",             0x7B    },
-    { "Key: Right Shift",       0x7C    },
-    { "Key: Right Control",     0x7D    },
-    { "Key: Print Screen",      0x80    },
-    { "Key: Insert",            0x81    },
-    { "Key: Delete",            0x82    },
-    { "Key: Left Arrow",        0x85    },
-    { "Key: Scroll Lock",       0x88    },
-    { "Key: Home",              0x89    },
-    { "Key: End",               0x8A    },
-    { "Key: Up Arrow",          0x8C    },
-    { "Key: Down Arrow",        0x8D    },
-    { "Key: Pause/Break",       0x90    },
-    { "Key: Page Up",           0x91    },
-    { "Key: Page Down",         0x92    },
-    { "Key: Right Arrow",       0x95    },
-    { "Key: Num Lock",          0x99    },
-    { "Key: Number Pad 7",      0x9A    },
-    { "Key: Number Pad 4",      0x9B    },
-    { "Key: Number Pad 1",      0x9C    },
-    { "Key: Number Pad 0",      0x9D    },
-    { "Key: Number Pad /",      0xA1    },
-    { "Key: Number Pad 8",      0xA2    },
-    { "Key: Number Pad 5",      0xA3    },
-    { "Key: Number Pad 2",      0xA4    },
-    { "Key: Number Pad *",      0xA9    },
-    { "Key: Number Pad 9",      0xAA    },
-    { "Key: Number Pad 6",      0xAB    },
-    { "Key: Number Pad 3",      0xAC    },
-    { "Key: Number Pad .",      0xAD    },
-    { "Key: Number Pad -",      0xB1    },
-    { "Key: Number Pad +",      0xB2    },
-    { "Key: Number Pad Enter",  0xB4    },
+    { KEY_EN_ESCAPE,            0x00    },
+    { KEY_EN_BACK_TICK,         0x01    },
+    { KEY_EN_TAB,               0x02    },
+    { KEY_EN_CAPS_LOCK,         0x03    },
+    { KEY_EN_LEFT_SHIFT,        0x04    },
+    { KEY_EN_LEFT_CONTROL,      0x05    },
+    { KEY_EN_ISO_BACK_SLASH,    0x0C    },
+    { KEY_EN_1,                 0x11    },
+    { KEY_EN_Q,                 0x12    },
+    { KEY_EN_A,                 0x13    },
+    { KEY_EN_Z,                 0x14    },
+    { KEY_EN_F1,                0x18    },
+    { KEY_EN_2,                 0x19    },
+    { KEY_EN_W,                 0x1A    },
+    { KEY_EN_S,                 0x1B    },
+    { KEY_EN_X,                 0x1C    },
+    { KEY_EN_F2,                0x20    },
+    { KEY_EN_3,                 0x21    },
+    { KEY_EN_E,                 0x22    },
+    { KEY_EN_D,                 0x23    },
+    { KEY_EN_C,                 0x24    },
+    { KEY_EN_F3,                0x28    },
+    { KEY_EN_4,                 0x29    },
+    { KEY_EN_R,                 0x2A    },
+    { KEY_EN_F,                 0x2B    },
+    { KEY_EN_V,                 0x2C    },
+    { KEY_EN_F4,                0x30    },
+    { KEY_EN_5,                 0x31    },
+    { KEY_EN_T,                 0x32    },
+    { KEY_EN_G,                 0x33    },
+    { KEY_EN_B,                 0x34    },
+    { KEY_EN_SPACE,             0x35    },
+    { KEY_EN_6,                 0x39    },
+    { KEY_EN_Y,                 0x3A    },
+    { KEY_EN_H,                 0x3B    },
+    { KEY_EN_N,                 0x3C    },
+    { KEY_EN_F5,                0x40    },
+    { KEY_EN_7,                 0x41    },
+    { KEY_EN_U,                 0x42    },
+    { KEY_EN_J,                 0x43    },
+    { KEY_EN_M,                 0x44    },
+    { KEY_EN_F6,                0x48    },
+    { KEY_EN_8,                 0x49    },
+    { KEY_EN_I,                 0x4A    },
+    { KEY_EN_K,                 0x4B    },
+    { KEY_EN_COMMA,             0x4C    },
+    { KEY_EN_RIGHT_ALT,         0x4D    },
+    { KEY_EN_F7,                0x50    },
+    { KEY_EN_9,                 0x51    },
+    { KEY_EN_O,                 0x52    },
+    { KEY_EN_L,                 0x53    },
+    { KEY_EN_PERIOD,            0x54    },
+    { KEY_EN_F8,                0x58    },
+    { KEY_EN_0,                 0x59    },
+    { KEY_EN_P,                 0x5A    },
+    { KEY_EN_SEMICOLON,         0x5B    },
+    { KEY_EN_FORWARD_SLASH,     0x5C    },
+    { KEY_EN_RIGHT_FUNCTION,    0x5D    },
+    { KEY_EN_F9,                0x60    },
+    { KEY_EN_MINUS,             0x61    },
+    { KEY_EN_LEFT_BRACKET,      0x62    },
+    { KEY_EN_QUOTE,             0x63    },
+    { KEY_EN_MENU,              0x65    },
+    { KEY_EN_F10,               0x68    },
+    { KEY_EN_EQUALS,            0x69    },
+    { KEY_EN_RIGHT_BRACKET,     0x6A    },
+    { KEY_EN_POUND,             0x6B    },
+    { KEY_EN_F11,               0x70    },
+    { KEY_EN_F12,               0x78    },
+    { KEY_EN_BACKSPACE,         0x79    },
+    { KEY_EN_ANSI_BACK_SLASH,   0x7A    },
+    { KEY_EN_ANSI_ENTER,        0x7B    },
+    { KEY_EN_RIGHT_SHIFT,       0x7C    },
+    { KEY_EN_RIGHT_CONTROL,     0x7D    },
+    { KEY_EN_PRINT_SCREEN,      0x80    },
+    { KEY_EN_INSERT,            0x81    },
+    { KEY_EN_DELETE,            0x82    },
+    { KEY_EN_LEFT_ARROW,        0x85    },
+    { KEY_EN_SCROLL_LOCK,       0x88    },
+    { KEY_EN_HOME,              0x89    },
+    { KEY_EN_END,               0x8A    },
+    { KEY_EN_UP_ARROW,          0x8C    },
+    { KEY_EN_DOWN_ARROW,        0x8D    },
+    { KEY_EN_PAUSE_BREAK,       0x90    },
+    { KEY_EN_PAGE_UP,           0x91    },
+    { KEY_EN_PAGE_DOWN,         0x92    },
+    { KEY_EN_RIGHT_ARROW,       0x95    },
+    { KEY_EN_NUMPAD_LOCK,       0x99    },
+    { KEY_EN_NUMPAD_7,          0x9A    },
+    { KEY_EN_NUMPAD_4,          0x9B    },
+    { KEY_EN_NUMPAD_1,          0x9C    },
+    { KEY_EN_NUMPAD_0,          0x9D    },
+    { KEY_EN_NUMPAD_DIVIDE,     0xA1    },
+    { KEY_EN_NUMPAD_8,          0xA2    },
+    { KEY_EN_NUMPAD_5,          0xA3    },
+    { KEY_EN_NUMPAD_2,          0xA4    },
+    { KEY_EN_NUMPAD_TIMES,      0xA9    },
+    { KEY_EN_NUMPAD_9,          0xAA    },
+    { KEY_EN_NUMPAD_6,          0xAB    },
+    { KEY_EN_NUMPAD_3,          0xAC    },
+    { KEY_EN_NUMPAD_PERIOD,     0xAD    },
+    { KEY_EN_NUMPAD_MINUS,      0xB1    },
+    { KEY_EN_NUMPAD_PLUS,       0xB2    },
+    { KEY_EN_NUMPAD_ENTER,      0xB4    },
 };
 
 static const std::vector<led_type> default_tkl_led_names =
 {
     /* Key Label                Index  */
-    { "Key: Escape",            0x00    },
-    { "Key: `",                 0x01    },
-    { "Key: Tab",               0x02    },
-    { "Key: Caps Lock",         0x03    },
-    { "Key: Left Shift",        0x04    },
-    { "Key: Left Control",      0x05    },
-    { "Key: \\ (ISO)",          0x0C    },
-    { "Key: 1",                 0x11    },
-    { "Key: Q",                 0x12    },
-    { "Key: A",                 0x13    },
-    { "Key: Z",                 0x14    },
-    { "Key: F1",                0x18    },
-    { "Key: 2",                 0x19    },
-    { "Key: W",                 0x1A    },
-    { "Key: S",                 0x1B    },
-    { "Key: X",                 0x1C    },
-    { "Key: F2",                0x20    },
-    { "Key: 3",                 0x21    },
-    { "Key: E",                 0x22    },
-    { "Key: D",                 0x23    },
-    { "Key: C",                 0x24    },
-    { "Key: F3",                0x28    },
-    { "Key: 4",                 0x29    },
-    { "Key: R",                 0x2A    },
-    { "Key: F",                 0x2B    },
-    { "Key: V",                 0x2C    },
-    { "Key: F4",                0x30    },
-    { "Key: 5",                 0x31    },
-    { "Key: T",                 0x32    },
-    { "Key: G",                 0x33    },
-    { "Key: B",                 0x34    },
-    { "Key: Space",             0x35    },
-    { "Key: 6",                 0x39    },
-    { "Key: Y",                 0x3A    },
-    { "Key: H",                 0x3B    },
-    { "Key: N",                 0x3C    },
-    { "Key: F5",                0x40    },
-    { "Key: 7",                 0x41    },
-    { "Key: U",                 0x42    },
-    { "Key: J",                 0x43    },
-    { "Key: M",                 0x44    },
-    { "Key: F6",                0x48    },
-    { "Key: 8",                 0x49    },
-    { "Key: I",                 0x4A    },
-    { "Key: K",                 0x4B    },
-    { "Key: ,",                 0x4C    },
-    { "Key: Right Alt",         0x4D    },
-    { "Key: F7",                0x50    },
-    { "Key: 9",                 0x51    },
-    { "Key: O",                 0x52    },
-    { "Key: L",                 0x53    },
-    { "Key: .",                 0x54    },
-    { "Key: F8",                0x58    },
-    { "Key: 0",                 0x59    },
-    { "Key: P",                 0x5A    },
-    { "Key: ;",                 0x5B    },
-    { "Key: /",                 0x5C    },
-    { "Key: Right Fn",          0x5D    },
-    { "Key: F9",                0x60    },
-    { "Key: -",                 0x61    },
-    { "Key: [",                 0x62    },
-    { "Key: '",                 0x63    },
-    { "Key: Menu",              0x65    },
-    { "Key: F10",               0x68    },
-    { "Key: =",                 0x69    },
-    { "Key: ]",                 0x6A    },
-    { "Key: #",                 0x6B    },
-    { "Key: F11",               0x70    },
-    { "Key: F12",               0x78    },
-    { "Key: Backspace",         0x79    },
-    { "Key: \\ (ANSI)",         0x7A    },
-    { "Key: Enter",             0x7B    },
-    { "Key: Right Shift",       0x7C    },
-    { "Key: Right Control",     0x7D    },
-    { "Key: Insert",            0x81    },
-    { "Key: Delete",            0x82    },
-    { "Key: Left Arrow",        0x85    },
-    { "Key: Home",              0x89    },
-    { "Key: End",               0x8A    },
-    { "Key: Up Arrow",          0x8C    },
-    { "Key: Down Arrow",        0x8D    },
-    { "Key: Page Up",           0x91    },
-    { "Key: Page Down",         0x92    },
-    { "Key: Right Arrow",       0x95    },
+    { KEY_EN_ESCAPE,            0x00    },
+    { KEY_EN_BACK_TICK,         0x01    },
+    { KEY_EN_TAB,               0x02    },
+    { KEY_EN_CAPS_LOCK,         0x03    },
+    { KEY_EN_LEFT_SHIFT,        0x04    },
+    { KEY_EN_LEFT_CONTROL,      0x05    },
+    { KEY_EN_ISO_BACK_SLASH,    0x0C    },
+    { KEY_EN_1,                 0x11    },
+    { KEY_EN_Q,                 0x12    },
+    { KEY_EN_A,                 0x13    },
+    { KEY_EN_Z,                 0x14    },
+    { KEY_EN_F1,                0x18    },
+    { KEY_EN_2,                 0x19    },
+    { KEY_EN_W,                 0x1A    },
+    { KEY_EN_S,                 0x1B    },
+    { KEY_EN_X,                 0x1C    },
+    { KEY_EN_F2,                0x20    },
+    { KEY_EN_3,                 0x21    },
+    { KEY_EN_E,                 0x22    },
+    { KEY_EN_D,                 0x23    },
+    { KEY_EN_C,                 0x24    },
+    { KEY_EN_F3,                0x28    },
+    { KEY_EN_4,                 0x29    },
+    { KEY_EN_R,                 0x2A    },
+    { KEY_EN_F,                 0x2B    },
+    { KEY_EN_V,                 0x2C    },
+    { KEY_EN_F4,                0x30    },
+    { KEY_EN_5,                 0x31    },
+    { KEY_EN_T,                 0x32    },
+    { KEY_EN_G,                 0x33    },
+    { KEY_EN_B,                 0x34    },
+    { KEY_EN_SPACE,             0x35    },
+    { KEY_EN_6,                 0x39    },
+    { KEY_EN_Y,                 0x3A    },
+    { KEY_EN_H,                 0x3B    },
+    { KEY_EN_N,                 0x3C    },
+    { KEY_EN_F5,                0x40    },
+    { KEY_EN_7,                 0x41    },
+    { KEY_EN_U,                 0x42    },
+    { KEY_EN_J,                 0x43    },
+    { KEY_EN_M,                 0x44    },
+    { KEY_EN_F6,                0x48    },
+    { KEY_EN_8,                 0x49    },
+    { KEY_EN_I,                 0x4A    },
+    { KEY_EN_K,                 0x4B    },
+    { KEY_EN_COMMA,             0x4C    },
+    { KEY_EN_RIGHT_ALT,         0x4D    },
+    { KEY_EN_F7,                0x50    },
+    { KEY_EN_9,                 0x51    },
+    { KEY_EN_O,                 0x52    },
+    { KEY_EN_L,                 0x53    },
+    { KEY_EN_PERIOD,            0x54    },
+    { KEY_EN_F8,                0x58    },
+    { KEY_EN_0,                 0x59    },
+    { KEY_EN_P,                 0x5A    },
+    { KEY_EN_SEMICOLON,         0x5B    },
+    { KEY_EN_FORWARD_SLASH,     0x5C    },
+    { KEY_EN_RIGHT_FUNCTION,    0x5D    },
+    { KEY_EN_F9,                0x60    },
+    { KEY_EN_MINUS,             0x61    },
+    { KEY_EN_LEFT_BRACKET,      0x62    },
+    { KEY_EN_QUOTE,             0x63    },
+    { KEY_EN_MENU,              0x65    },
+    { KEY_EN_F10,               0x68    },
+    { KEY_EN_EQUALS,            0x69    },
+    { KEY_EN_RIGHT_BRACKET,     0x6A    },
+    { KEY_EN_POUND,             0x6B    },
+    { KEY_EN_F11,               0x70    },
+    { KEY_EN_F12,               0x78    },
+    { KEY_EN_BACKSPACE,         0x79    },
+    { KEY_EN_ANSI_BACK_SLASH,   0x7A    },
+    { KEY_EN_ANSI_ENTER,        0x7B    },
+    { KEY_EN_RIGHT_SHIFT,       0x7C    },
+    { KEY_EN_RIGHT_CONTROL,     0x7D    },
+    { KEY_EN_INSERT,            0x81    },
+    { KEY_EN_DELETE,            0x82    },
+    { KEY_EN_LEFT_ARROW,        0x85    },
+    { KEY_EN_HOME,              0x89    },
+    { KEY_EN_END,               0x8A    },
+    { KEY_EN_UP_ARROW,          0x8C    },
+    { KEY_EN_DOWN_ARROW,        0x8D    },
+    { KEY_EN_PAGE_UP,           0x91    },
+    { KEY_EN_PAGE_DOWN,         0x92    },
+    { KEY_EN_RIGHT_ARROW,       0x95    },
     { "Logo 1",                 0x80    },
     { "Logo 2",                 0x90    },
     { "Underglow 1",            0x06    },
@@ -272,87 +273,97 @@ static const std::vector<led_type> default_tkl_led_names =
 static const std::vector<led_type> default_65pct_led_names =
 {
     /* Key Label                Index  */
-    { "Key: Escape",            0x00    },
-    { "Key: Tab",               0x01    },
-    { "Key: Caps Lock",         0x02    },
-    { "Key: Left Shift",        0x03    },
-    { "Key: Left Control",      0x04    },
-    { "Key: 1",                 0x08    },
-    { "Key: Q",                 0x09    },
-    { "Key: A",                 0x0A    },
-    { "Key: Left Windows",      0x0C    },
-    { "Key: 2",                 0x10    },
-    { "Key: W",                 0x11    },
-    { "Key: S",                 0x12    },
-    { "Key: Z",                 0x13    },
-    { "Key: Left Alt",          0x14    },
-    { "Key: 3",                 0x18    },
-    { "Key: E",                 0x19    },
-    { "Key: D",                 0x1A    },
-    { "Key: X",                 0x1B    },
-    { "Key: 4",                 0x20    },
-    { "Key: R",                 0x21    },
-    { "Key: F",                 0x22    },
-    { "Key: C",                 0x23    },
-    { "Key: 5",                 0x28    },
-    { "Key: T",                 0x29    },
-    { "Key: G",                 0x2A    },
-    { "Key: V",                 0x2B    },
-    { "Key: 6",                 0x30    },
-    { "Key: Y",                 0x31    },
-    { "Key: H",                 0x32    },
-    { "Key: B",                 0x33    },
-    { "Key: Space",             0x34    },
-    { "Key: 7",                 0x38    },
-    { "Key: U",                 0x39    },
-    { "Key: J",                 0x3A    },
-    { "Key: N",                 0x3B    },
-    { "Key: 8",                 0x40    },
-    { "Key: I",                 0x41    },
-    { "Key: K",                 0x42    },
-    { "Key: M",                 0x43    },
-    { "Key: 9",                 0x48    },
-    { "Key: O",                 0x49    },
-    { "Key: L",                 0x4A    },
-    { "Key: ,",                 0x4B    },
-    { "Key: Right Alt",         0x4C    },
-    { "Key: 0",                 0x50    },
-    { "Key: P",                 0x51    },
-    { "Key: ;",                 0x52    },
-    { "Key: .",                 0x53    },
-    { "Key: Right Fn",          0x54    },
-    { "Key: -",                 0x58    },
-    { "Key: [",                 0x59    },
-    { "Key: '",                 0x5A    },
-    { "Key: /",                 0x5B    },
-    { "Key: Right Control",     0x5C    },
-    { "Key: =",                 0x60    },
-    { "Key: ]",                 0x61    },
-    { "Key: Right Shift",       0x63    },
-    { "Key: Left Arrow",        0x64    },
-    { "Key: Backspace",         0x68    },
-    { "Key: \\ (ANSI)",         0x69    },
-    { "Key: Enter",             0x6A    },
-    { "Key: Up Arrow",          0x6B    },
-    { "Key: Down Arrow",        0x6C    },
-    { "Key: Insert",            0x70    },
-    { "Key: Delete",            0x71    },
-    { "Key: Page Up",           0x72    },
-    { "Key: Page Down",         0x73    },
-    { "Key: Right Arrow",       0x74    },
+    { KEY_EN_ESCAPE,            0x00    },
+    { KEY_EN_TAB,               0x01    },
+    { KEY_EN_CAPS_LOCK,         0x02    },
+    { KEY_EN_LEFT_SHIFT,        0x03    },
+    { KEY_EN_LEFT_CONTROL,      0x04    },
+    { KEY_EN_1,                 0x08    },
+    { KEY_EN_Q,                 0x09    },
+    { KEY_EN_A,                 0x0A    },
+    { KEY_EN_LEFT_WINDOWS,      0x0C    },
+    { KEY_EN_2,                 0x10    },
+    { KEY_EN_W,                 0x11    },
+    { KEY_EN_S,                 0x12    },
+    { KEY_EN_Z,                 0x13    },
+    { KEY_EN_LEFT_ALT,          0x14    },
+    { KEY_EN_3,                 0x18    },
+    { KEY_EN_E,                 0x19    },
+    { KEY_EN_D,                 0x1A    },
+    { KEY_EN_X,                 0x1B    },
+    { KEY_EN_4,                 0x20    },
+    { KEY_EN_R,                 0x21    },
+    { KEY_EN_F,                 0x22    },
+    { KEY_EN_C,                 0x23    },
+    { KEY_EN_5,                 0x28    },
+    { KEY_EN_T,                 0x29    },
+    { KEY_EN_G,                 0x2A    },
+    { KEY_EN_V,                 0x2B    },
+    { KEY_EN_6,                 0x30    },
+    { KEY_EN_Y,                 0x31    },
+    { KEY_EN_H,                 0x32    },
+    { KEY_EN_B,                 0x33    },
+    { KEY_EN_SPACE,             0x34    },
+    { KEY_EN_7,                 0x38    },
+    { KEY_EN_U,                 0x39    },
+    { KEY_EN_J,                 0x3A    },
+    { KEY_EN_N,                 0x3B    },
+    { KEY_EN_8,                 0x40    },
+    { KEY_EN_I,                 0x41    },
+    { KEY_EN_K,                 0x42    },
+    { KEY_EN_M,                 0x43    },
+    { KEY_EN_9,                 0x48    },
+    { KEY_EN_O,                 0x49    },
+    { KEY_EN_L,                 0x4A    },
+    { KEY_EN_COMMA,             0x4B    },
+    { KEY_EN_RIGHT_ALT,         0x4C    },
+    { KEY_EN_0,                 0x50    },
+    { KEY_EN_P,                 0x51    },
+    { KEY_EN_SEMICOLON,         0x52    },
+    { KEY_EN_PERIOD,            0x53    },
+    { KEY_EN_RIGHT_FUNCTION,    0x54    },
+    { KEY_EN_MINUS,             0x58    },
+    { KEY_EN_LEFT_BRACKET,      0x59    },
+    { KEY_EN_QUOTE,             0x5A    },
+    { KEY_EN_FORWARD_SLASH,     0x5B    },
+    { KEY_EN_RIGHT_CONTROL,     0x5C    },
+    { KEY_EN_EQUALS,            0x60    },
+    { KEY_EN_RIGHT_BRACKET,     0x61    },
+    { KEY_EN_RIGHT_SHIFT,       0x63    },
+    { KEY_EN_LEFT_ARROW,        0x64    },
+    { KEY_EN_BACKSPACE,         0x68    },
+    { KEY_EN_ANSI_BACK_SLASH,   0x69    },
+    { KEY_EN_ANSI_ENTER,        0x6A    },
+    { KEY_EN_UP_ARROW,          0x6B    },
+    { KEY_EN_DOWN_ARROW,        0x6C    },
+    { KEY_EN_INSERT,            0x70    },
+    { KEY_EN_DELETE,            0x71    },
+    { KEY_EN_PAGE_UP,           0x72    },
+    { KEY_EN_PAGE_DOWN,         0x73    },
+    { KEY_EN_RIGHT_ARROW,       0x74    },
 };
 
-RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* aura_ptr, AuraKeyboardMappingLayoutType keyboard_layout)
+/**------------------------------------------------------------------*\
+    @name Asus Aura Keyboard
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectAsusAuraUSBKeyboards
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* controller_ptr, AuraKeyboardMappingLayoutType keyboard_layout)
 {
-    aura        = aura_ptr;
+    controller  = controller_ptr;
     layout      = keyboard_layout;
 
     name        = "ASUS Aura Keyboard";
     vendor      = "ASUS";
     type        = DEVICE_TYPE_KEYBOARD;
     description = "ASUS Aura Keyboard Device";
-    location    = aura->GetDeviceLocation();
-    serial      = aura->GetSerialString();
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
 
     mode Direct;
     Direct.name       = "Direct";
@@ -373,7 +384,8 @@ RGBController_AuraKeyboard::~RGBController_AuraKeyboard()
             delete zones[zone_idx].matrix_map;
         }
     }
-    delete aura;
+
+    delete controller;
 }
 
 void RGBController_AuraKeyboard::SetupZones()
@@ -394,8 +406,8 @@ void RGBController_AuraKeyboard::SetupZones()
             led_names = default_led_names;
             led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
 
-            led_names.insert(led_names.begin() + 7,     {"Key: Left Windows", 0x15});
-            led_names.insert(led_names.begin() + 12,    {"Key: Left Alt", 0x1D});
+            led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x15});
+            led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x1D});
             break;
 
         case SCOPE_RX_LAYOUT:
@@ -403,8 +415,8 @@ void RGBController_AuraKeyboard::SetupZones()
             led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
             led_zones.push_back({"Logo",        ZONE_TYPE_SINGLE, 1});
 
-            led_names.insert(led_names.begin() + 7,     {"Key: Left Windows", 0x15});
-            led_names.insert(led_names.begin() + 12,    {"Key: Left Alt", 0x1D});
+            led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x15});
+            led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x1D});
             led_names.push_back({ "Logo", 0xB0});
             break;
 
@@ -414,8 +426,8 @@ void RGBController_AuraKeyboard::SetupZones()
             led_zones.push_back({"Logo",        ZONE_TYPE_LINEAR, 2});
             led_zones.push_back({"Underglow",   ZONE_TYPE_LINEAR, 26});
 
-            led_names.insert(led_names.begin() + 7,     {"Key: Left Windows", 0x15});
-            led_names.insert(led_names.begin() + 12,    {"Key: Left Alt", 0x1D});
+            led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x15});
+            led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x1D});
             break;
 
         case FLARE_LAYOUT:
@@ -424,8 +436,8 @@ void RGBController_AuraKeyboard::SetupZones()
             led_zones.push_back({"Logo",        ZONE_TYPE_SINGLE, 1});
             led_zones.push_back({"Underglow",   ZONE_TYPE_SINGLE, 2});
 
-            led_names.insert(led_names.begin() + 7,     {"Key: Left Windows", 0x0D});
-            led_names.insert(led_names.begin() + 12,    {"Key: Left Alt", 0x15});
+            led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x0D});
+            led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x15});
 
             led_names.push_back({ "Logo", 0xB8});
             led_names.push_back({ "Left Underglow",     0xB9});
@@ -501,7 +513,7 @@ void RGBController_AuraKeyboard::DeviceUpdateLEDs()
         frame_buf[(led_idx * 4) + 3] = RGBGetBValue(colors[led_idx]);
     }
 
-    aura->SendDirect(leds.size(), frame_buf.data());
+    controller->SendDirect(leds.size(), frame_buf.data());
 }
 
 void RGBController_AuraKeyboard::UpdateZoneLEDs(int /*zone*/)

Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.h

@@ -37,7 +37,7 @@ typedef struct
 class RGBController_AuraKeyboard : public RGBController
 {
 public:
-    RGBController_AuraKeyboard(AuraKeyboardController* aura_ptr, AuraKeyboardMappingLayoutType keyboard_layout);
+    RGBController_AuraKeyboard(AuraKeyboardController* controller_ptr, AuraKeyboardMappingLayoutType keyboard_layout);
     ~RGBController_AuraKeyboard();
 
     void        SetupZones();
@@ -52,6 +52,6 @@ public:
     void        DeviceUpdateMode();
 
 private:
-    AuraKeyboardController*         aura;
+    AuraKeyboardController*         controller;
     AuraKeyboardMappingLayoutType   layout;
 };

Controllers/AsusAuraUSBController/RGBController_AsusAuraMonitor.cpp

@@ -0,0 +1,128 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraMonitor.cpp        |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 08/03/2022                        |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusAuraMonitor.h"
+
+/**------------------------------------------------------------------*\
+    @name Asus Aura Monitor
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectAsusAuraUSBMonitor
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AuraMonitor::RGBController_AuraMonitor(AuraMonitorController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "ASUS Aura Monitor";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_LEDSTRIP;
+    description = "ASUS Aura Monitor Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+}
+
+RGBController_AuraMonitor::~RGBController_AuraMonitor()
+{
+    delete controller;
+}
+
+void RGBController_AuraMonitor::SetupZones()
+{
+    zone underglow_zone;
+
+    underglow_zone.name         = "Backlight";
+    underglow_zone.type         = ZONE_TYPE_LINEAR;
+    underglow_zone.leds_min     = 3;
+    underglow_zone.leds_max     = 3;
+    underglow_zone.leds_count   = 3;
+    underglow_zone.matrix_map   = NULL;
+
+    zones.push_back(underglow_zone);
+
+    for(unsigned int i = 0; i < 3; i++)
+    {
+        led underglow_led;
+
+        underglow_led.name      = "Backlight LED " + std::to_string(i + 1);
+
+        leds.push_back(underglow_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AuraMonitor::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AuraMonitor::DeviceUpdateLEDs()
+{
+    for (int i = 0; i < 3; i++)
+    {
+        unsigned char red   = RGBGetRValue(colors[i]);
+        unsigned char green = RGBGetGValue(colors[i]);
+        unsigned char blue  = RGBGetBValue(colors[i]);
+
+        controller->UpdateLed(i, red, green, blue);
+    }
+
+    controller->ApplyChanges();
+}
+
+void RGBController_AuraMonitor::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraMonitor::UpdateSingleLED(int led)
+{
+    unsigned char red   = RGBGetRValue(colors[led]);
+    unsigned char green = RGBGetGValue(colors[led]);
+    unsigned char blue  = RGBGetBValue(colors[led]);
+
+    controller->UpdateLed(led, red, green, blue);
+
+    controller->ApplyChanges();
+}
+
+void RGBController_AuraMonitor::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+
+void RGBController_AuraMonitor::DeviceUpdateMode()
+{
+    /*---------------------------------------------------------*\
+    | This device does not support Mode changing                |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AuraMonitor::DeviceSaveMode()
+{
+    /*---------------------------------------------------------*\
+    | This device does not support Mode saving                  |
+    \*---------------------------------------------------------*/
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraMonitor.h

@@ -0,0 +1,34 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraMonitor.h          |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 08/03/2022                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraMonitorController.h"
+
+class RGBController_AuraMonitor : public RGBController
+{
+public:
+    RGBController_AuraMonitor(AuraMonitorController* controller_ptr);
+    ~RGBController_AuraMonitor();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+    void        DeviceSaveMode();
+
+private:
+    AuraMonitorController*  controller;
+};

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp

@@ -16,20 +16,34 @@ static std::string aura_mouse_zone_names[3]
     "Underglow"
 };
 
-RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
+/**------------------------------------------------------------------*\
+    @name Asus Aura Mouse
+    @type USB
+    @save :white_check_mark:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAsusAuraUSBMice
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller_ptr)
 {
-    aura                    = aura_ptr;
+    controller              = controller_ptr;
+
+    uint16_t pid            = controller->device_pid;
 
     name                    = "ASUS Aura Mouse";
     vendor                  = "ASUS";
     type                    = DEVICE_TYPE_MOUSE;
     description             = "ASUS Aura Mouse Device";
-    location                = aura->GetDeviceLocation();
-    serial                  = aura->GetSerialString();
+    version                 = controller->GetVersion(aura_mouse_devices[pid].wireless, aura_mouse_devices[pid].version_protocol);
+    location                = controller->GetDeviceLocation();
+    serial                  = controller->GetSerialString();
 
-    uint16_t pid            = aura->device_pid;
     std::vector<uint8_t> mm = aura_mouse_devices[pid].mouse_modes;
 
+    int mode_value          = 0;
+
     for(std::vector<uint8_t>::iterator it = mm.begin(); it != mm.end(); it++)
     {
         switch(*it)
@@ -37,10 +51,13 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
             case AURA_MOUSE_MODE_STATIC:
                 {
                     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;
+                    Direct.name                 = "Direct";
+                    Direct.value                = mode_value;
+                    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+                    Direct.brightness_min       = AURA_MOUSE_BRIGHTNESS_MIN;
+                    Direct.brightness_max       = AURA_MOUSE_BRIGHTNESS_MAX;
+                    Direct.brightness           = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    Direct.color_mode           = MODE_COLORS_PER_LED;
                     modes.push_back(Direct);
                 }
                 break;
@@ -48,10 +65,13 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
             case AURA_MOUSE_MODE_BREATHING:
                 {
                     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;
+                    Breathing.name              = "Breathing";
+                    Breathing.value             = mode_value;
+                    Breathing.flags             = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+                    Breathing.brightness_min    = AURA_MOUSE_BRIGHTNESS_MIN;
+                    Breathing.brightness_max    = AURA_MOUSE_BRIGHTNESS_MAX;
+                    Breathing.brightness        = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    Breathing.color_mode        = MODE_COLORS_PER_LED;
                     modes.push_back(Breathing);
                 }
                 break;
@@ -59,10 +79,13 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
             case AURA_MOUSE_MODE_SPECTRUM:
                 {
                     mode ColorCycle;
-                    ColorCycle.name         = "Spectrum Cycle";
-                    ColorCycle.value        = AURA_MOUSE_MODE_SPECTRUM;
-                    ColorCycle.flags        = 0;
-                    ColorCycle.color_mode   = MODE_COLORS_NONE;
+                    ColorCycle.name             = "Spectrum Cycle";
+                    ColorCycle.value            = mode_value;
+                    ColorCycle.flags            = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE ;
+                    ColorCycle.brightness_min   = AURA_MOUSE_BRIGHTNESS_MIN;
+                    ColorCycle.brightness_max   = AURA_MOUSE_BRIGHTNESS_MAX;
+                    ColorCycle.brightness       = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    ColorCycle.color_mode       = MODE_COLORS_NONE;
                     modes.push_back(ColorCycle);
                 }
                 break;
@@ -70,14 +93,17 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
             case AURA_MOUSE_MODE_WAVE:
                 {
                     mode Wave;
-                    Wave.name               = "Wave";
-                    Wave.value              = AURA_MOUSE_MODE_WAVE;
-                    Wave.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-                    Wave.direction          = 0;
-                    Wave.speed_min          = aura_mouse_devices[pid].speed_min;
-                    Wave.speed_max          = aura_mouse_devices[pid].speed_max;
-                    Wave.speed              = 128;
-                    Wave.color_mode         = MODE_COLORS_NONE;
+                    Wave.name                   = "Rainbow Wave";
+                    Wave.value                  = mode_value;
+                    Wave.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+                    Wave.direction              = 0;
+                    Wave.speed_min              = aura_mouse_devices[pid].speed_min;
+                    Wave.speed_max              = aura_mouse_devices[pid].speed_max;
+                    Wave.speed                  = (aura_mouse_devices[pid].speed_min + aura_mouse_devices[pid].speed_max) / 2;
+                    Wave.brightness_min         = AURA_MOUSE_BRIGHTNESS_MIN;
+                    Wave.brightness_max         = AURA_MOUSE_BRIGHTNESS_MAX;
+                    Wave.brightness             = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    Wave.color_mode             = MODE_COLORS_NONE;
                     modes.push_back(Wave);
                 }
                 break;
@@ -85,10 +111,13 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
             case AURA_MOUSE_MODE_REACTIVE:
                 {
                     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;
+                    Reactive.name               = "Reactive";
+                    Reactive.value              = mode_value;
+                    Reactive.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+                    Reactive.brightness_min     = AURA_MOUSE_BRIGHTNESS_MIN;
+                    Reactive.brightness_max     = AURA_MOUSE_BRIGHTNESS_MAX;
+                    Reactive.brightness         = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    Reactive.color_mode         = MODE_COLORS_PER_LED;
                     modes.push_back(Reactive);
                 }
                 break;
@@ -96,13 +125,16 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
             case AURA_MOUSE_MODE_COMET:
                 {
                     mode Comet;
-                    Comet.name              = "Comet";
-                    Comet.value             = AURA_MOUSE_MODE_COMET;
-                    Comet.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
-                    Comet.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-                    Comet.direction         = 0;
-                    Comet.colors_min        = 1;
-                    Comet.colors_max        = 1;
+                    Comet.name                  = "Comet";
+                    Comet.value                 = mode_value;
+                    Comet.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+                    Comet.brightness_min        = AURA_MOUSE_BRIGHTNESS_MIN;
+                    Comet.brightness_max        = AURA_MOUSE_BRIGHTNESS_MAX;
+                    Comet.brightness            = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    Comet.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+                    Comet.direction             = 0;
+                    Comet.colors_min            = 1;
+                    Comet.colors_max            = 1;
                     Comet.colors.resize(1);
                     modes.push_back(Comet);
                 }
@@ -111,14 +143,18 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
             case AURA_MOUSE_MODE_BATTERY:
                 {
                     mode BatteryMode;
-                    BatteryMode.name       = "Battery";
-                    BatteryMode.value      = AURA_MOUSE_MODE_BATTERY;
-                    BatteryMode.flags      = 0;
-                    BatteryMode.color_mode = MODE_COLORS_NONE;
+                    BatteryMode.name            = "Battery";
+                    BatteryMode.value           = mode_value;
+                    BatteryMode.flags           = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+                    BatteryMode.brightness_min  = AURA_MOUSE_BRIGHTNESS_MIN;
+                    BatteryMode.brightness_max  = AURA_MOUSE_BRIGHTNESS_MAX;
+                    BatteryMode.brightness      = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    BatteryMode.color_mode      = MODE_COLORS_NONE;
                     modes.push_back(BatteryMode);
                 }
                 break;
         }
+        mode_value++;
     }
 
     SetupZones();
@@ -126,13 +162,12 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
 
 RGBController_AuraMouse::~RGBController_AuraMouse()
 {
-    delete aura;
+    delete controller;
 }
 
 void RGBController_AuraMouse::SetupZones()
 {
-
-    uint16_t pid                = aura->device_pid;
+    uint16_t pid                = controller->device_pid;
 
     for(std::vector<uint8_t>::iterator zone_it = aura_mouse_devices[pid].mouse_zones.begin(); zone_it != aura_mouse_devices[pid].mouse_zones.end(); zone_it++)
     {
@@ -165,9 +200,9 @@ void RGBController_AuraMouse::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_AuraMouse::DeviceUpdateLEDs()
 {
-    for(std::vector<led>::iterator led_it = leds.begin(); led_it != leds.end(); led_it++)
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
     {
-        UpdateSingleLED(led_it->value);
+        UpdateSingleLED(zone_index);
     }
 }
 
@@ -182,7 +217,7 @@ void RGBController_AuraMouse::UpdateSingleLED(int led)
     uint8_t grn = RGBGetGValue(colors[led]);
     uint8_t blu = RGBGetBValue(colors[led]);
 
-    aura->SendUpdate(leds[led].value, active_mode, red, grn, blu, 0, false, 0);
+    controller->SendUpdate(leds[led].value, modes[active_mode].value, red, grn, blu, 0, false, 0, modes[active_mode].brightness);
 }
 
 void RGBController_AuraMouse::SetCustomMode()
@@ -209,7 +244,12 @@ void RGBController_AuraMouse::DeviceUpdateMode()
             blu = RGBGetBValue(modes[active_mode].colors[0]);
         }
 
-        aura->SendUpdate(AURA_MOUSE_ZONE_ALL, active_mode, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed);
-        aura->SaveMode();
+        controller->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
     }
 }
+
+void RGBController_AuraMouse::DeviceSaveMode()
+{
+    DeviceUpdateMode();
+    controller->SaveMode();
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.h

@@ -11,10 +11,16 @@
 #include "RGBController.h"
 #include "AsusAuraMouseController.h"
 
+enum {
+    AURA_MOUSE_BRIGHTNESS_MIN     = 0,
+    AURA_MOUSE_BRIGHTNESS_MAX     = 4,
+    AURA_MOUSE_BRIGHTNESS_DEFAULT = 4
+};
+
 class RGBController_AuraMouse : public RGBController
 {
 public:
-    RGBController_AuraMouse(AuraMouseController* aura_ptr);
+    RGBController_AuraMouse(AuraMouseController* controller_ptr);
     ~RGBController_AuraMouse();
 
     void        SetupZones();
@@ -27,7 +33,8 @@ public:
 
     void        SetCustomMode();
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
-    AuraMouseController*  aura;
+    AuraMouseController*  controller;
 };

Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.cpp

@@ -0,0 +1,302 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraMousemat.cpp       |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/10/2022   |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusAuraMousemat.h"
+
+/**------------------------------------------------------------------*\
+    @name Asus Aura Mousemat
+    @type USB
+    @save :white_check_mark:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAsusAuraUSBMousemats
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "ASUS Aura Mousemat";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_MOUSEMAT;
+    description = "ASUS Aura Mousemat Device";
+    version     = controller->GetVersion();
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = AURA_MOUSEMAT_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = AURA_MOUSEMAT_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Static.brightness_min       = AURA_MOUSEMAT_BRIGHTNESS_MIN;
+    Static.brightness_max       = AURA_MOUSEMAT_BRIGHTNESS_MAX;
+    Static.brightness           = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = AURA_MOUSEMAT_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC | MODE_COLORS_RANDOM;
+    Breathing.speed_min         = AURA_MOUSEMAT_SPEED_MIN;
+    Breathing.speed_max         = AURA_MOUSEMAT_SPEED_MAX;
+    Breathing.speed             = AURA_MOUSEMAT_SPEED_DEFAULT_BREATHING;
+    Breathing.brightness_min    = AURA_MOUSEMAT_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = AURA_MOUSEMAT_BRIGHTNESS_MAX;
+    Breathing.brightness        = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 2;
+    Breathing.colors.resize(1);
+    modes.push_back(Breathing);
+
+    mode ColorCycle;
+    ColorCycle.name             = "Color Cycle";
+    ColorCycle.value            = AURA_MOUSEMAT_MODE_COLOR_CYCLE;
+    ColorCycle.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    ColorCycle.color_mode       = MODE_COLORS_NONE;
+    ColorCycle.speed_min        = AURA_MOUSEMAT_SPEED_MIN;
+    ColorCycle.speed_max        = AURA_MOUSEMAT_SPEED_MAX;
+    ColorCycle.speed            = AURA_MOUSEMAT_SPEED_DEFAULT_COLOR_CYCLE;
+    ColorCycle.brightness_min   = AURA_MOUSEMAT_BRIGHTNESS_MIN;
+    ColorCycle.brightness_max   = AURA_MOUSEMAT_BRIGHTNESS_MAX;
+    ColorCycle.brightness       = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
+    modes.push_back(ColorCycle);
+
+    mode Wave;
+    Wave.name                   = "Wave";
+    Wave.value                  = AURA_MOUSEMAT_MODE_WAVE;
+    Wave.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
+    Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Wave.speed_min              = AURA_MOUSEMAT_SPEED_MIN;
+    Wave.speed_max              = AURA_MOUSEMAT_SPEED_MAX;
+    Wave.speed                  = AURA_MOUSEMAT_SPEED_DEFAULT_WAVE;
+    Wave.brightness_min         = AURA_MOUSEMAT_BRIGHTNESS_MIN;
+    Wave.brightness_max         = AURA_MOUSEMAT_BRIGHTNESS_MAX;
+    Wave.brightness             = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
+    Wave.direction              = MODE_DIRECTION_LEFT;
+    Wave.colors_min             = 7;
+    Wave.colors_max             = 7;
+    Wave.colors.resize(7);
+    modes.push_back(Wave);
+
+    mode WavePlane;
+    WavePlane.name              = "Wave Plane";
+    WavePlane.value             = AURA_MOUSEMAT_MODE_WAVE_PLANE;
+    WavePlane.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE;
+    WavePlane.color_mode        = MODE_COLORS_NONE;
+    WavePlane.speed_min         = AURA_MOUSEMAT_SPEED_MIN;
+    WavePlane.speed_max         = AURA_MOUSEMAT_SPEED_MAX;
+    WavePlane.speed             = AURA_MOUSEMAT_SPEED_DEFAULT_WAVE_PLANE;
+    WavePlane.brightness_min    = AURA_MOUSEMAT_BRIGHTNESS_MIN;
+    WavePlane.brightness_max    = AURA_MOUSEMAT_BRIGHTNESS_MAX;
+    WavePlane.brightness        = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
+    WavePlane.direction         = MODE_DIRECTION_LEFT;
+    modes.push_back(WavePlane);
+
+    mode Comet;
+    Comet.name                  = "Comet";
+    Comet.value                 = AURA_MOUSEMAT_MODE_COMET;
+    Comet.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE;
+    Comet.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Comet.speed_min             = AURA_MOUSEMAT_SPEED_MIN;
+    Comet.speed_max             = AURA_MOUSEMAT_SPEED_MAX;
+    Comet.speed                 = AURA_MOUSEMAT_SPEED_DEFAULT_COMET;
+    Comet.brightness_min        = AURA_MOUSEMAT_BRIGHTNESS_MIN;
+    Comet.brightness_max        = AURA_MOUSEMAT_BRIGHTNESS_MAX;
+    Comet.brightness            = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
+    Comet.direction             = MODE_DIRECTION_LEFT;
+    Comet.colors_min            = 1;
+    Comet.colors_max            = 1;
+    Comet.colors.resize(1);
+    modes.push_back(Comet);
+
+    mode GlowingYoyo;
+    GlowingYoyo.name            = "Glowing Yoyo";
+    GlowingYoyo.value           = AURA_MOUSEMAT_MODE_GLOWING_YOYO;
+    GlowingYoyo.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
+    GlowingYoyo.color_mode      = MODE_COLORS_NONE;
+    GlowingYoyo.speed_min       = AURA_MOUSEMAT_SPEED_MIN;
+    GlowingYoyo.speed_max       = AURA_MOUSEMAT_SPEED_MAX;
+    GlowingYoyo.speed           = AURA_MOUSEMAT_SPEED_DEFAULT_GLOWING_YOYO;
+    GlowingYoyo.brightness_min  = AURA_MOUSEMAT_BRIGHTNESS_MIN;
+    GlowingYoyo.brightness_max  = AURA_MOUSEMAT_BRIGHTNESS_MAX;
+    GlowingYoyo.brightness      = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
+    GlowingYoyo.direction       = MODE_DIRECTION_LEFT;
+    modes.push_back(GlowingYoyo);
+
+    mode Cross;
+    Cross.name                  = "Cross";
+    Cross.value                 = AURA_MOUSEMAT_MODE_CROSS;
+    Cross.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Cross.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Cross.speed_min             = AURA_MOUSEMAT_SPEED_MIN;
+    Cross.speed_max             = AURA_MOUSEMAT_SPEED_MAX;
+    Cross.speed                 = AURA_MOUSEMAT_SPEED_DEFAULT_CROSS;
+    Cross.brightness_min        = AURA_MOUSEMAT_BRIGHTNESS_MIN;
+    Cross.brightness_max        = AURA_MOUSEMAT_BRIGHTNESS_MAX;
+    Cross.brightness            = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
+    Cross.colors_min            = 2;
+    Cross.colors_max            = 2;
+    Cross.colors.resize(2);
+    modes.push_back(Cross);
+
+    mode StarryNight;
+    StarryNight.name            = "Starry Night";
+    StarryNight.value           = AURA_MOUSEMAT_MODE_STARRY_NIGHT;
+    StarryNight.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    StarryNight.color_mode      = MODE_COLORS_MODE_SPECIFIC | MODE_COLORS_RANDOM;
+    StarryNight.speed_min       = AURA_MOUSEMAT_SPEED_MIN;
+    StarryNight.speed_max       = AURA_MOUSEMAT_SPEED_MAX;
+    StarryNight.speed           = AURA_MOUSEMAT_SPEED_DEFAULT_STARRY_NIGHT;
+    StarryNight.brightness_min  = AURA_MOUSEMAT_BRIGHTNESS_MIN;
+    StarryNight.brightness_max  = AURA_MOUSEMAT_BRIGHTNESS_MAX;
+    StarryNight.brightness      = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
+    StarryNight.colors_min      = 2;
+    StarryNight.colors_max      = 2;
+    StarryNight.colors.resize(2);
+    modes.push_back(StarryNight);
+
+    SetupZones();
+}
+
+RGBController_AuraMousemat::~RGBController_AuraMousemat()
+{
+    delete controller;
+}
+
+void RGBController_AuraMousemat::SetupZones()
+{
+    zone mousemat_zone;
+
+    mousemat_zone.name         = "Mousemat";
+    mousemat_zone.type         = ZONE_TYPE_LINEAR;
+    mousemat_zone.leds_min     = 15;
+    mousemat_zone.leds_max     = 15;
+    mousemat_zone.leds_count   = 15;
+    mousemat_zone.matrix_map   = NULL;
+
+    zones.push_back(mousemat_zone);
+
+    for(unsigned int i = 0; i < 15; i++)
+    {
+        led mousemat_led;
+
+        mousemat_led.name      = "Mousemat LED " + std::to_string(i);
+
+        leds.push_back(mousemat_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AuraMousemat::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AuraMousemat::DeviceUpdateLEDs()
+{
+    controller->UpdateLeds(std::vector<RGBColor>(colors));
+}
+
+void RGBController_AuraMousemat::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraMousemat::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraMousemat::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_AuraMousemat::DeviceUpdateMode()
+{
+    if(modes[active_mode].value == AURA_MOUSEMAT_MODE_DIRECT)
+    {
+        DeviceUpdateLEDs();
+    }
+    else
+    {
+        int pattern = 0;
+
+        switch(modes[active_mode].value)
+        {
+            case AURA_MOUSEMAT_MODE_BREATHING:
+                if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
+                {
+                    pattern = 2;
+                }
+                else
+                {
+                    pattern = modes[active_mode].colors.size() - 1;
+                }
+                break;
+            case AURA_MOUSEMAT_MODE_WAVE:
+                pattern = modes[active_mode].colors.size() * 16 + modes[active_mode].direction;
+                break;
+            case AURA_MOUSEMAT_MODE_WAVE_PLANE:       
+                switch(modes[active_mode].direction)
+                {
+                    case MODE_DIRECTION_LEFT:
+                        pattern = 2;
+                        break;
+                    case MODE_DIRECTION_RIGHT:
+                        pattern = 3;
+                        break;
+                    case MODE_DIRECTION_UP:
+                        pattern = 0;
+                        break;
+                    case MODE_DIRECTION_DOWN:
+                        pattern = 1;
+                        break;
+                }
+                break;
+            case AURA_MOUSEMAT_MODE_COMET:
+                pattern = modes[active_mode].direction;
+                if(pattern == MODE_DIRECTION_HORIZONTAL || pattern == MODE_DIRECTION_VERTICAL) pattern = 2;
+                break;
+            case AURA_MOUSEMAT_MODE_GLOWING_YOYO:
+                pattern = modes[active_mode].direction;
+                break;
+            case AURA_MOUSEMAT_MODE_STARRY_NIGHT:
+                pattern = 16 + (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+                break;
+            default:
+                pattern = 255;
+                break;
+        }
+
+        controller->UpdateDevice(modes[active_mode].value, std::vector<RGBColor>(modes[active_mode].colors), modes[active_mode].speed, modes[active_mode].brightness, pattern);
+    }
+}
+
+void RGBController_AuraMousemat::DeviceSaveMode()
+{
+    DeviceUpdateMode();
+    controller->SaveMode();
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.h

@@ -0,0 +1,52 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraMousemat.h         |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 06/04/2021                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraMousematController.h"
+
+enum
+{
+    AURA_MOUSEMAT_BRIGHTNESS_MIN                = 0,
+    AURA_MOUSEMAT_BRIGHTNESS_MAX                = 4,
+    AURA_MOUSEMAT_BRIGHTNESS_DEFAULT            = 4,
+    AURA_MOUSEMAT_SPEED_MIN                     = 127,
+    AURA_MOUSEMAT_SPEED_MAX                     = 0,
+    AURA_MOUSEMAT_SPEED_DEFAULT_STATIC          = 0,
+    AURA_MOUSEMAT_SPEED_DEFAULT_BREATHING       = 1,
+    AURA_MOUSEMAT_SPEED_DEFAULT_COLOR_CYCLE     = 1,
+    AURA_MOUSEMAT_SPEED_DEFAULT_WAVE            = 14,
+    AURA_MOUSEMAT_SPEED_DEFAULT_WAVE_PLANE      = 2,
+    AURA_MOUSEMAT_SPEED_DEFAULT_COMET           = 2,
+    AURA_MOUSEMAT_SPEED_DEFAULT_GLOWING_YOYO    = 4,
+    AURA_MOUSEMAT_SPEED_DEFAULT_CROSS           = 12,
+    AURA_MOUSEMAT_SPEED_DEFAULT_STARRY_NIGHT    = 2,
+};
+
+class RGBController_AuraMousemat : public RGBController
+{
+public:
+    RGBController_AuraMousemat(AuraMousematController* controller_ptr);
+    ~RGBController_AuraMousemat();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+    void        DeviceSaveMode();
+
+private:
+    AuraMousematController* controller;
+};

Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.cpp

@@ -0,0 +1,164 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraStrixEvolve.cpp    |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 11/30/2021                        |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusAuraStrixEvolve.h"
+
+/**------------------------------------------------------------------*\
+    @name Asus Aura Strix Evolve
+    @type USB
+    @save :white_check_mark:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAsusAuraUSBStrixEvolve
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AuraStrixEvolve::RGBController_AuraStrixEvolve(AuraStrixEvolveController* controller_ptr)
+{
+    controller                  = controller_ptr;
+
+    name                        = "ASUS ROG Strix Evolve";
+    vendor                      = "ASUS";
+    type                        = DEVICE_TYPE_MOUSE;
+    description                 = "ASUS Aura Mouse Device";
+    version                     = controller->GetVersion();
+    location                    = controller->GetDeviceLocation();
+    serial                      = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = 1;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.brightness_min       = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    Direct.brightness_max       = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    Direct.brightness           = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = 2;
+    Breathing.flags             = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.brightness_min    = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    Breathing.brightness        = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    Breathing.color_mode        = MODE_COLORS_PER_LED;
+    modes.push_back(Breathing);
+
+    mode ColorCycle;
+    ColorCycle.name             = "Spectrum Cycle";
+    ColorCycle.value            = 3;
+    ColorCycle.flags            = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    ColorCycle.brightness_min   = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    ColorCycle.brightness_max   = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    ColorCycle.brightness       = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    ColorCycle.color_mode       = MODE_COLORS_NONE;
+    modes.push_back(ColorCycle);
+
+    mode Reactive;
+    Reactive.name               = "Reactive";
+    Reactive.value              = 4;
+    Reactive.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Reactive.brightness_min     = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    Reactive.brightness_max     = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    Reactive.brightness         = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    Reactive.color_mode         = MODE_COLORS_PER_LED;
+    modes.push_back(Reactive);
+
+    SetupZones();
+}
+
+RGBController_AuraStrixEvolve::~RGBController_AuraStrixEvolve()
+{
+    delete controller;
+}
+
+void RGBController_AuraStrixEvolve::SetupZones()
+{
+    zone mouse_zone;
+
+    mouse_zone.name         = "Underglow";
+    mouse_zone.type         = ZONE_TYPE_SINGLE;
+    mouse_zone.leds_min     = 1;
+    mouse_zone.leds_max     = 1;
+    mouse_zone.leds_count   = 1;
+    mouse_zone.matrix_map   = NULL;
+
+    zones.push_back(mouse_zone);
+
+    led mouse_led;
+
+    mouse_led.name          = "Underglow";
+    mouse_led.value         = 1;
+
+    leds.push_back(mouse_led);
+
+    SetupColors();
+}
+
+void RGBController_AuraStrixEvolve::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
+void RGBController_AuraStrixEvolve::DeviceUpdateLEDs()
+{
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+
+    controller->SendUpdate(0x1C, red);
+    controller->SendUpdate(0x1D, grn);
+    controller->SendUpdate(0x1E, blu);
+}
+
+void RGBController_AuraStrixEvolve::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraStrixEvolve::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraStrixEvolve::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_AuraStrixEvolve::DeviceUpdateMode()
+{
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+
+    controller->SendUpdate(0x19, modes[active_mode].value);
+    controller->SendUpdate(0x1A, modes[active_mode].brightness);
+    controller->SendUpdate(0x1C, red);
+    controller->SendUpdate(0x1D, grn);
+    controller->SendUpdate(0x1E, blu);
+}
+
+void RGBController_AuraStrixEvolve::DeviceSaveMode()
+{
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+
+    unsigned int profile = controller->GetActiveProfile();
+
+    controller->UpdateProfile(0x19, profile, modes[active_mode].value);
+    controller->UpdateProfile(0x1A, profile, modes[active_mode].brightness);
+    controller->UpdateProfile(0x1C, profile, red);
+    controller->UpdateProfile(0x1D, profile, grn);
+    controller->UpdateProfile(0x1E, profile, blu);
+
+    controller->SendSavePacket();
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.h

@@ -0,0 +1,41 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraStrixEvolve.h      |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 11/30/2021                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraStrixEvolveController.h"
+
+enum
+{
+    AURA_STRIX_EVOLVE_BRIGHTNESS_MIN     = 0,
+    AURA_STRIX_EVOLVE_BRIGHTNESS_MAX     = 255,
+    AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT = 255
+};
+
+class RGBController_AuraStrixEvolve : public RGBController
+{
+public:
+    RGBController_AuraStrixEvolve(AuraStrixEvolveController* controller_ptr);
+    ~RGBController_AuraStrixEvolve();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+    void        DeviceSaveMode();
+
+private:
+    AuraStrixEvolveController*  controller;
+};

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp

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

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h

@@ -11,10 +11,20 @@
 #include "RGBController.h"
 #include "AsusAuraTUFKeyboardController.h"
 
+enum
+{
+    AURA_KEYBOARD_SPEED_MIN          = 0,
+    AURA_KEYBOARD_SPEED_MAX          = 15,
+    AURA_KEYBOARD_SPEED_DEFAULT      = 8,
+    AURA_KEYBOARD_BRIGHTNESS_MIN     = 0,
+    AURA_KEYBOARD_BRIGHTNESS_MAX     = 4,
+    AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 4
+};
+
 class RGBController_AuraTUFKeyboard : public RGBController
 {
 public:
-    RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* aura_ptr);
+    RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* controller_ptr);
     ~RGBController_AuraTUFKeyboard();
 
     void        SetupZones();
@@ -27,7 +37,8 @@ public:
 
     void        SetCustomMode();
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
-    AuraTUFKeyboardController*  aura;
+    AuraTUFKeyboardController*  controller;
 };

Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

@@ -1,264 +1,277 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraUSB.cpp            |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/18/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraUSB.h"
-
-RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* aura_ptr) :
-    initializedMode(false)
-{
-    aura = aura_ptr;
-
-    name        = "ASUS Aura USB";
-    vendor      = "ASUS";
-    version     = aura->GetDeviceName();
-    type        = DEVICE_TYPE_MOTHERBOARD;
-    description = "ASUS Aura USB Device";
-    location    = aura->GetDeviceLocation();
-    serial      = aura->GetSerialString();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = AURA_MODE_DIRECT;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Off;
-    Off.name       = "Off";
-    Off.value      = AURA_MODE_OFF;
-    Off.flags      = 0;
-    Off.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    mode Static;
-    Static.name       = "Static";
-    Static.value      = AURA_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Static.colors_min = 1;
-    Static.colors_max = 1;
-    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = AURA_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Breathing.colors_min = 1;
-    Breathing.colors_max = 1;
-    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors.resize(1);
-    modes.push_back(Breathing);
-
-    mode Flashing;
-    Flashing.name       = "Flashing";
-    Flashing.value      = AURA_MODE_FLASHING;
-    Flashing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Flashing.colors_min = 1;
-    Flashing.colors_max = 1;
-    Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Flashing.colors.resize(1);
-    modes.push_back(Flashing);
-
-    mode SpectrumCycle;
-    SpectrumCycle.name       = "Spectrum Cycle";
-    SpectrumCycle.value      = AURA_MODE_SPECTRUM_CYCLE;
-    SpectrumCycle.flags      = 0;
-    SpectrumCycle.color_mode = MODE_COLORS_NONE;
-    modes.push_back(SpectrumCycle);
-
-    mode Rainbow;
-    Rainbow.name       = "Rainbow";
-    Rainbow.value      = AURA_MODE_RAINBOW;
-    Rainbow.flags      = 0;
-    Rainbow.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Rainbow);
-
-    mode ChaseFade;
-    ChaseFade.name       = "Chase Fade";
-    ChaseFade.value      = AURA_MODE_CHASE_FADE;
-    ChaseFade.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    ChaseFade.colors_min = 1;
-    ChaseFade.colors_max = 1;
-    ChaseFade.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    ChaseFade.colors.resize(1);
-    modes.push_back(ChaseFade);
-
-    mode Chase;
-    Chase.name       = "Chase";
-    Chase.value      = AURA_MODE_CHASE;
-    Chase.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Chase.colors_min = 1;
-    Chase.colors_max = 1;
-    Chase.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Chase.colors.resize(1);
-    modes.push_back(Chase);
-
-    SetupZones();
-}
-
-RGBController_AuraUSB::~RGBController_AuraUSB()
-{
-    delete aura;
-}
-
-void RGBController_AuraUSB::SetupZones()
-{
-    /*-------------------------------------------------*\
-    | Only set LED count on the first run               |
-    \*-------------------------------------------------*/
-    bool first_run = false;
-
-    if(zones.size() == 0)
-    {
-        first_run = true;
-    }
-
-    /*-------------------------------------------------*\
-    | Clear any existing color/LED configuration        |
-    \*-------------------------------------------------*/
-    leds.clear();
-    colors.clear();
-    zones.resize(aura->GetChannelCount());
-
-    /*-------------------------------------------------*\
-    | Set zones and leds                                |
-    \*-------------------------------------------------*/
-    int addressableCounter = 1;
-    for (unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
-    {
-        AuraDeviceInfo device_info = aura->GetAuraDevices()[channel_idx];
-
-        zones[channel_idx].type     = ZONE_TYPE_LINEAR;
-
-        if(device_info.device_type == AuraDeviceType::FIXED)
-        {
-            zones[channel_idx].name       = "Aura Mainboard";
-            zones[channel_idx].leds_min   = device_info.num_leds;
-            zones[channel_idx].leds_max   = device_info.num_leds;
-            zones[channel_idx].leds_count = device_info.num_leds;
-        }
-        else
-        {
-            zones[channel_idx].name       = "Aura Addressable ";
-            zones[channel_idx].name.append(std::to_string(addressableCounter));
-            zones[channel_idx].leds_min   = 0;
-            zones[channel_idx].leds_max   = AURA_ADDRESSABLE_MAX_LEDS;
-
-            addressableCounter++;
-
-            if(first_run)
-            {
-                zones[channel_idx].leds_count = 0;
-            }
-        }
-
-        unsigned int num_mainboard_leds = device_info.num_leds - device_info.num_headers;
-        for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
-        {
-            unsigned led_idx = led_ch_idx + 1;
-            led new_led;
-
-            new_led.name = zones[channel_idx].name;
-            if(device_info.device_type == AuraDeviceType::FIXED && led_ch_idx >= num_mainboard_leds)
-            {
-                new_led.name.append(", RGB Header ");
-                led_idx -= num_mainboard_leds;
-            }
-            else
-            {
-                new_led.name.append(", LED ");
-            }
-            new_led.name.append(std::to_string(led_idx));
-
-            new_led.value = channel_idx;
-
-            leds.push_back(new_led);
-        }
-
-        zones[channel_idx].matrix_map = NULL;
-    }
-
-    SetupColors();
-}
-
-void RGBController_AuraUSB::ResizeZone(int zone, int new_size)
-{
-    if((size_t) zone >= zones.size())
-    {
-        return;
-    }
-
-    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
-    {
-        zones[zone].leds_count = new_size;
-
-        SetupZones();
-    }
-}
-
-void RGBController_AuraUSB::DeviceUpdateLEDs()
-{
-    if(!initializedMode)
-    {
-        DeviceUpdateMode();
-    }
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        aura->SetChannelLEDs(zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
-    }
-}
-
-void RGBController_AuraUSB::UpdateZoneLEDs(int zone)
-{
-    if(!initializedMode)
-    {
-        DeviceUpdateMode();
-    }
-    aura->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count);
-}
-
-void RGBController_AuraUSB::UpdateSingleLED(int led)
-{
-    if(!initializedMode)
-    {
-        DeviceUpdateMode();
-    }
-    unsigned int channel = leds[led].value;
-
-    aura->SetChannelLEDs(channel, zones[channel].colors, zones[channel].leds_count);
-}
-
-void RGBController_AuraUSB::SetCustomMode()
-{
-
-}
-
-void RGBController_AuraUSB::DeviceUpdateMode()
-{
-    initializedMode = true;
-    unsigned char red = 0;
-    unsigned char grn = 0;
-    unsigned char blu = 0;
-
-    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        red = RGBGetRValue(modes[active_mode].colors[0]);
-        grn = RGBGetGValue(modes[active_mode].colors[0]);
-        blu = RGBGetBValue(modes[active_mode].colors[0]);
-    }
-
-    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        if(zones[zone_idx].leds_count > 0)
-        {
-            aura->SetMode(zone_idx, modes[active_mode].value, red, grn, blu);
-        }
-    }
-}
+/*-----------------------------------------*\
+|  RGBController_AsusAuraUSB.cpp            |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/18/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusAuraUSB.h"
+
+/**------------------------------------------------------------------*\
+    @name Asus Aura USB
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAsusAuraUSBTerminal,DetectAsusAuraUSBAddressable,DetectAsusAuraUSBMotherboards
+    @comment The Asus AUra USB controller applies to most AMD and
+        Intel mainboards from the x470 and z390 chipsets onwards.
+\*-------------------------------------------------------------------*/
+
+RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* controller_ptr) :
+    initializedMode(false)
+{
+    controller  = controller_ptr;
+
+    name        = "ASUS Aura USB";
+    vendor      = "ASUS";
+    version     = controller->GetDeviceName();
+    type        = DEVICE_TYPE_MOTHERBOARD;
+    description = "ASUS Aura USB Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = AURA_MODE_DIRECT;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Off;
+    Off.name       = "Off";
+    Off.value      = AURA_MODE_OFF;
+    Off.flags      = 0;
+    Off.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Static;
+    Static.name       = "Static";
+    Static.value      = AURA_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min = 1;
+    Static.colors_max = 1;
+    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name       = "Breathing";
+    Breathing.value      = AURA_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Breathing.colors_min = 1;
+    Breathing.colors_max = 1;
+    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors.resize(1);
+    modes.push_back(Breathing);
+
+    mode Flashing;
+    Flashing.name       = "Flashing";
+    Flashing.value      = AURA_MODE_FLASHING;
+    Flashing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Flashing.colors_min = 1;
+    Flashing.colors_max = 1;
+    Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Flashing.colors.resize(1);
+    modes.push_back(Flashing);
+
+    mode SpectrumCycle;
+    SpectrumCycle.name       = "Spectrum Cycle";
+    SpectrumCycle.value      = AURA_MODE_SPECTRUM_CYCLE;
+    SpectrumCycle.flags      = 0;
+    SpectrumCycle.color_mode = MODE_COLORS_NONE;
+    modes.push_back(SpectrumCycle);
+
+    mode Rainbow;
+    Rainbow.name       = "Rainbow";
+    Rainbow.value      = AURA_MODE_RAINBOW;
+    Rainbow.flags      = 0;
+    Rainbow.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Rainbow);
+
+    mode ChaseFade;
+    ChaseFade.name       = "Chase Fade";
+    ChaseFade.value      = AURA_MODE_CHASE_FADE;
+    ChaseFade.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    ChaseFade.colors_min = 1;
+    ChaseFade.colors_max = 1;
+    ChaseFade.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ChaseFade.colors.resize(1);
+    modes.push_back(ChaseFade);
+
+    mode Chase;
+    Chase.name       = "Chase";
+    Chase.value      = AURA_MODE_CHASE;
+    Chase.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Chase.colors_min = 1;
+    Chase.colors_max = 1;
+    Chase.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Chase.colors.resize(1);
+    modes.push_back(Chase);
+
+    SetupZones();
+}
+
+RGBController_AuraUSB::~RGBController_AuraUSB()
+{
+    delete controller;
+}
+
+void RGBController_AuraUSB::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Only set LED count on the first run               |
+    \*-------------------------------------------------*/
+    bool first_run = false;
+
+    if(zones.size() == 0)
+    {
+        first_run = true;
+    }
+
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
+    leds.clear();
+    colors.clear();
+    zones.resize(controller->GetChannelCount());
+
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    int addressableCounter = 1;
+    for (unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+    {
+        AuraDeviceInfo device_info  = controller->GetAuraDevices()[channel_idx];
+
+        zones[channel_idx].type     = ZONE_TYPE_LINEAR;
+
+        if(device_info.device_type == AuraDeviceType::FIXED)
+        {
+            zones[channel_idx].name       = "Aura Mainboard";
+            zones[channel_idx].leds_min   = device_info.num_leds;
+            zones[channel_idx].leds_max   = device_info.num_leds;
+            zones[channel_idx].leds_count = device_info.num_leds;
+        }
+        else
+        {
+            zones[channel_idx].name       = "Aura Addressable ";
+            zones[channel_idx].name.append(std::to_string(addressableCounter));
+            zones[channel_idx].leds_min   = 0;
+            zones[channel_idx].leds_max   = AURA_ADDRESSABLE_MAX_LEDS;
+
+            addressableCounter++;
+
+            if(first_run)
+            {
+                zones[channel_idx].leds_count = 0;
+            }
+        }
+
+        unsigned int num_mainboard_leds = device_info.num_leds - device_info.num_headers;
+        for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
+        {
+            unsigned led_idx = led_ch_idx + 1;
+            led new_led;
+
+            new_led.name = zones[channel_idx].name;
+            if(device_info.device_type == AuraDeviceType::FIXED && led_ch_idx >= num_mainboard_leds)
+            {
+                new_led.name.append(", RGB Header ");
+                led_idx -= num_mainboard_leds;
+            }
+            else
+            {
+                new_led.name.append(", LED ");
+            }
+            new_led.name.append(std::to_string(led_idx));
+
+            new_led.value = channel_idx;
+
+            leds.push_back(new_led);
+        }
+
+        zones[channel_idx].matrix_map = NULL;
+    }
+
+    SetupColors();
+}
+
+void RGBController_AuraUSB::ResizeZone(int zone, int new_size)
+{
+    if((size_t) zone >= zones.size())
+    {
+        return;
+    }
+
+    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
+    {
+        zones[zone].leds_count = new_size;
+
+        SetupZones();
+    }
+}
+
+void RGBController_AuraUSB::DeviceUpdateLEDs()
+{
+    if(!initializedMode)
+    {
+        DeviceUpdateMode();
+    }
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        controller->SetChannelLEDs(zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
+    }
+}
+
+void RGBController_AuraUSB::UpdateZoneLEDs(int zone)
+{
+    if(!initializedMode)
+    {
+        DeviceUpdateMode();
+    }
+
+    controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count);
+}
+
+void RGBController_AuraUSB::UpdateSingleLED(int led)
+{
+    if(!initializedMode)
+    {
+        DeviceUpdateMode();
+    }
+
+    unsigned int channel = leds[led].value;
+
+    controller->SetChannelLEDs(channel, zones[channel].colors, zones[channel].leds_count);
+}
+
+void RGBController_AuraUSB::SetCustomMode()
+{
+
+}
+
+void RGBController_AuraUSB::DeviceUpdateMode()
+{
+    initializedMode   = true;
+    unsigned char red = 0;
+    unsigned char grn = 0;
+    unsigned char blu = 0;
+
+    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        red = RGBGetRValue(modes[active_mode].colors[0]);
+        grn = RGBGetGValue(modes[active_mode].colors[0]);
+        blu = RGBGetBValue(modes[active_mode].colors[0]);
+    }
+
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        if(zones[zone_idx].leds_count > 0)
+        {
+            controller->SetMode(zone_idx, modes[active_mode].value, red, grn, blu);
+        }
+    }
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.h

@@ -1,38 +1,38 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraUSB.h              |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/18/2020   |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusAuraUSBController.h"
-
-#define AURA_ADDRESSABLE_MAX_LEDS       120
-
-class RGBController_AuraUSB : public RGBController
-{
-public:
-    RGBController_AuraUSB(AuraUSBController* aura_ptr);
-    ~RGBController_AuraUSB();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    AuraUSBController*          aura;
-    std::vector<unsigned int>   leds_channel;
-    std::vector<unsigned int>   zones_channel;
-    bool                        initializedMode;
-};
+/*-----------------------------------------*\
+|  RGBController_AsusAuraUSB.h              |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/18/2020   |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraUSBController.h"
+
+#define AURA_ADDRESSABLE_MAX_LEDS       120
+
+class RGBController_AuraUSB : public RGBController
+{
+public:
+    RGBController_AuraUSB(AuraUSBController* controller_ptr);
+    ~RGBController_AuraUSB();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    AuraUSBController*          controller;
+    std::vector<unsigned int>   leds_channel;
+    std::vector<unsigned int>   zones_channel;
+    bool                        initializedMode;
+};

Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.cpp

@@ -0,0 +1,231 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_ROGStrixLC_Controller.cpp                            |
+|                                                                     |
+|  Driver for the ASUS Aura Liquid Cooler (LC) series                 |
+|    of lighting controllers                                          |
+|                                                                     |
+|  Chris M (Dr_No)          17 Jan 2022                               |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "RGBControllerKeyNames.h"
+#include "RGBController_ROGStrixLC_Controller.h"
+
+/**------------------------------------------------------------------*\
+    @name Asus ROG Strix Liquid Cooler
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAsusAuraUSBROGStrixLC
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_ROGStrixLC_Controller::RGBController_ROGStrixLC_Controller(ROGStrixLC_Controller *controller_ptr)
+{
+    controller                  = controller_ptr;
+    uint8_t speed               = ROGSTRIXLC_CONTROLLER_SPEED_NORMAL;
+
+    name                        = "ROG Strix LC";
+    vendor                      = "ASUS";
+    type                        = DEVICE_TYPE_COOLER;
+    description                 = "ASUS Liquid Cooler including 120mm, 140mm, 240mm, 280mm and 360mm radiators.";
+    version                     = KEY_EN_UNUSED;
+    serial                      = KEY_EN_UNUSED;
+    location                    = controller->GetLocation();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = ROGSTRIXLC_CONTROLLER_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = ROGSTRIXLC_CONTROLLER_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.colors.resize(Static.colors_max);
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = ROGSTRIXLC_CONTROLLER_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 1;
+    Breathing.colors.resize(Breathing.colors_max);
+    Breathing.brightness_min    = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
+    Breathing.brightness        = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
+    Breathing.speed_min         = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
+    Breathing.speed_max         = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed             = speed;
+    modes.push_back(Breathing);
+
+    mode Flashing;
+    Flashing.name               = "Flashing";
+    Flashing.value              = ROGSTRIXLC_CONTROLLER_MODE_FLASHING;
+    Flashing.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Flashing.colors_min         = 1;
+    Flashing.colors_max         = 1;
+    Flashing.colors.resize(Flashing.colors_max);
+    Flashing.brightness_min     = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
+    Flashing.brightness_max     = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
+    Flashing.brightness         = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
+    Flashing.speed_min          = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
+    Flashing.speed_max          = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
+    Flashing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    Flashing.speed              = speed;
+    modes.push_back(Flashing);
+
+    mode Spectrum;
+    Spectrum.name               = "Spectrum";
+    Spectrum.value              = ROGSTRIXLC_CONTROLLER_MODE_SPECTRUM;
+    Spectrum.flags              = MODE_FLAG_HAS_SPEED;
+    Spectrum.brightness_min     = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
+    Spectrum.brightness_max     = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
+    Spectrum.brightness         = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
+    Spectrum.speed_min          = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
+    Spectrum.speed_max          = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
+    Spectrum.color_mode         = MODE_COLORS_NONE;
+    Spectrum.speed              = speed;
+    modes.push_back(Spectrum);
+
+    mode Rainbow;
+    Rainbow.name                = "Rainbow";
+    Rainbow.value               = ROGSTRIXLC_CONTROLLER_MODE_RAINBOW;
+    Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    Rainbow.brightness_min      = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
+    Rainbow.brightness_max      = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
+    Rainbow.brightness          = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
+    Rainbow.speed_min           = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
+    Rainbow.speed_max           = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
+    Rainbow.color_mode          = MODE_COLORS_NONE;
+    Rainbow.speed               = speed;
+    modes.push_back(Rainbow);
+
+    mode FlashAndDash;
+    FlashAndDash.name           = "Flash and Dash";
+    FlashAndDash.value          = ROGSTRIXLC_CONTROLLER_MODE_FLASHANDDASH;
+    FlashAndDash.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    FlashAndDash.brightness_min = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
+    FlashAndDash.brightness_max = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
+    FlashAndDash.brightness     = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
+    FlashAndDash.speed_min      = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
+    FlashAndDash.speed_max      = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
+    FlashAndDash.color_mode     = MODE_COLORS_NONE;
+    FlashAndDash.speed          = speed;
+    modes.push_back(FlashAndDash);
+
+    SetupZones();
+}
+
+RGBController_ROGStrixLC_Controller::~RGBController_ROGStrixLC_Controller()
+{
+    delete controller;
+}
+
+void RGBController_ROGStrixLC_Controller::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Set up zones                                      |
+    \*-------------------------------------------------*/
+    LOG_DEBUG("[%s] - Get channel count: %i", name.c_str(), controller->GetChannelCount());
+
+    zones.resize(controller->GetChannelCount());
+
+    LOG_DEBUG("[%s] - Creating Zones and LEDs", name.c_str());
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        AuraDeviceInfo device_info = controller->GetAuraDevices()[zone_idx];
+        LOG_INFO("[%s] %s Zone %i - Header Count %i LED Count %i FX %02X Direct %02X", name.c_str(),
+                 ((device_info.device_type == AuraDeviceType::FIXED) ? "Fixed" : "Addressable"),
+                 zone_idx, device_info.num_headers, device_info.num_leds, device_info.effect_channel, device_info.direct_channel);
+
+        zones[zone_idx].name        = name + " Zone ";
+        zones[zone_idx].name.append(std::to_string(zone_idx));
+        zones[zone_idx].type        = ZONE_TYPE_LINEAR;
+        zones[zone_idx].leds_min    = device_info.num_leds;
+        zones[zone_idx].leds_max    = device_info.num_leds;
+        zones[zone_idx].leds_count  = device_info.num_leds;
+
+        for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
+        {
+            led new_led;
+
+            new_led.name    = zones[zone_idx].name;
+            new_led.name.append(" LED " + std::to_string(lp_idx));
+            new_led.value   = lp_idx;
+
+            leds.push_back(new_led);
+        }
+    }
+
+    LOG_DEBUG("[%s] - Device zones and LEDs set", name.c_str());
+    SetupColors();
+}
+
+void RGBController_ROGStrixLC_Controller::ResizeZone(int zone, int new_size)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_ROGStrixLC_Controller::DeviceUpdateLEDs()
+{
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        UpdateZoneLEDs(zone_idx);
+    }
+}
+
+void RGBController_ROGStrixLC_Controller::UpdateZoneLEDs(int zone)
+{
+    controller->SetLedsDirect( zones[zone].colors, zones[zone].leds_count );
+}
+
+void RGBController_ROGStrixLC_Controller::UpdateSingleLED(int led)
+{
+    UpdateZoneLEDs(GetLED_Zone(led));
+}
+
+void RGBController_ROGStrixLC_Controller::SetCustomMode()
+{
+    for(std::size_t mode_idx = 0; mode_idx < modes.size() ; mode_idx++)
+    {
+        if (modes[mode_idx].value == ROGSTRIXLC_CONTROLLER_MODE_DIRECT)
+        {
+            active_mode = mode_idx;
+            break;
+        }
+    }
+}
+
+void RGBController_ROGStrixLC_Controller::DeviceUpdateMode()
+{
+    RGBColor colour         = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
+
+    controller->SetMode( modes[active_mode].value, modes[active_mode].speed, modes[active_mode].direction, colour );
+}
+
+int RGBController_ROGStrixLC_Controller::GetLED_Zone(int led_idx)
+{
+    for(size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        int zone_start  = zones[zone_idx].start_idx;
+        int zone_end    = zone_start + zones[zone_idx].leds_count - 1;
+
+        if( zone_start <= led_idx && zone_end >= led_idx)
+        {
+            return(zone_idx);
+        }
+    }
+
+    return -1;
+}

Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.h

@@ -0,0 +1,37 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_ROGStrixLC_Controller.h                              |
+|                                                                     |
+|  Driver for the ASUS Aura Liquid Cooler (LC) series                 |
+|    of lighting controllers                                          |
+|                                                                     |
+|  Chris M (Dr_No)          17 Jan 2022                               |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+#include "LogManager.h"
+#include "RGBController.h"
+#include "ROGStrixLC_Controller.h"
+#include <vector>
+
+class RGBController_ROGStrixLC_Controller : public RGBController
+{
+public:
+    RGBController_ROGStrixLC_Controller(ROGStrixLC_Controller* controller_ptr);
+    ~RGBController_ROGStrixLC_Controller();
+
+    void                SetupZones();
+    void                ResizeZone(int zone, int new_size);
+
+    void                DeviceUpdateLEDs();
+    void                UpdateZoneLEDs(int zone);
+    void                UpdateSingleLED(int led);
+
+    void                SetCustomMode();
+    void                DeviceUpdateMode();
+private:
+    int                 GetDeviceMode();
+    int                 GetLED_Zone(int led_idx);
+
+    ROGStrixLC_Controller* controller;
+};

Controllers/AsusAuraUSBController/ROGStrixLC_Controller.cpp

@@ -0,0 +1,130 @@
+/*-------------------------------------------------------------------*\
+|  ROGStrixLC_Controller.cpp                                          |
+|                                                                     |
+|  Driver for the ASUS Aura Liquid Cooler (LC) series                 |
+|    of lighting controllers                                          |
+|                                                                     |
+|  Chris M (Dr_No)          17 Jan 2022                               |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "ROGStrixLC_Controller.h"
+
+ROGStrixLC_Controller::ROGStrixLC_Controller(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
+{
+    const int szTemp = HID_MAX_STR;
+    wchar_t tmpName[szTemp];
+
+    /*-----------------------------------------------------*\
+    | Add addressable devices                               |
+    |    Manually adding device info for now                |
+    |    TODO: Implement config table accurately            |
+    |    LC120 - 1F FF 05 05 04 00 00 00                    |
+    \*-----------------------------------------------------*/
+    device_info.push_back({0x00, 0x00, 4, 0, AuraDeviceType::FIXED});
+}
+
+ROGStrixLC_Controller::~ROGStrixLC_Controller()
+{
+    hid_close(dev);
+}
+
+std::string ROGStrixLC_Controller::GetLocation()
+{
+    return("HID: " + location);
+}
+
+void ROGStrixLC_Controller::SetMode(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu)
+{
+    /*---------------------------------------------------------*\
+    | This interface is not used in this controller however is  |
+    |   required by the abstract class                          |
+    \*---------------------------------------------------------*/
+}
+
+void ROGStrixLC_Controller::SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour)
+{
+    bool needs_update       = !( (current_mode == mode) && (ToRGBColor(current_red, current_green, current_blue) == colour) && (current_speed == speed) && (current_direction == direction));
+
+    if (needs_update)
+    {
+        current_mode        = mode;
+        current_speed       = speed;
+        current_direction   = direction;
+        current_red         = RGBGetRValue(colour);
+        current_green       = RGBGetGValue(colour);
+        current_blue        = RGBGetBValue(colour);
+        SendUpdate();
+    }
+}
+
+void ROGStrixLC_Controller::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
+{
+    /*---------------------------------------------------------*\
+    | This interface is not used in this controller however is  |
+    |   required by the abstract class                          |
+    \*---------------------------------------------------------*/
+}
+
+void ROGStrixLC_Controller::SetLedsDirect(RGBColor * led_colours, uint8_t led_count)
+{
+    uint8_t buffer[write_packet_size]   = { 0xEC, 0x40, 0x00, 0xFF, led_count };
+
+    /*---------------------------------------------------------*\
+    | Set the colour bytes in the packet                        |
+    \*---------------------------------------------------------*/
+    for(uint8_t index = 0; index < led_count; index++)
+    {
+        uint8_t offset      = (index * 3) + ROGSTRIXLC_GREEN_BYTE;
+
+        buffer[offset + 0]  = RGBGetRValue(led_colours[index]);
+        buffer[offset + 1]  = RGBGetGValue(led_colours[index]);
+        buffer[offset + 2]  = RGBGetBValue(led_colours[index]);
+    }
+
+    /*---------------------------------------------------------*\
+    | These 3 bytes might be timing bytes                       |
+    \*---------------------------------------------------------*/
+    uint8_t offset          = led_count * 3 + ROGSTRIXLC_GREEN_BYTE;
+    buffer[offset + 0]      = 0x77;
+    buffer[offset + 1]      = 0x10;
+    buffer[offset + 2]      = 0xF3;
+
+    hid_write(dev, buffer, write_packet_size);
+}
+
+void ROGStrixLC_Controller::GetStatus()
+{
+    uint8_t buffer[write_packet_size]   = { 0xEC, 0x01, 0x02 };
+
+    hid_write(dev, buffer, write_packet_size);
+    hid_read_timeout(dev, buffer, read_packet_size, ROGSTRIXLC_CONTROLLER_TIMEOUT);
+
+    current_red             = buffer[ROGSTRIXLC_RED_BYTE - 1];
+    current_green           = buffer[ROGSTRIXLC_GREEN_BYTE - 1];
+    current_blue            = buffer[ROGSTRIXLC_BLUE_BYTE - 1];
+}
+
+void ROGStrixLC_Controller::SendUpdate()
+{
+    uint8_t buffer[write_packet_size];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buffer, 0x00, write_packet_size);
+
+    buffer[ROGSTRIXLC_REPORTID_BYTE]    = rogstrixlc_reportid;
+    buffer[ROGSTRIXLC_COMMAND_BYTE]     = rogstrixlc_modefx;
+    buffer[ROGSTRIXLC_ZONE_BYTE]        = 0;
+    buffer[ROGSTRIXLC_MODE_BYTE]        = current_mode;
+    buffer[ROGSTRIXLC_RED_BYTE]         = current_red;
+    buffer[ROGSTRIXLC_GREEN_BYTE]       = current_green;
+    buffer[ROGSTRIXLC_BLUE_BYTE]        = current_blue;
+
+    buffer[ROGSTRIXLC_DIRECTION_BYTE]   = current_direction;
+    buffer[ROGSTRIXLC_SPEED_BYTE]       = current_speed;
+
+    hid_write(dev, buffer, write_packet_size);
+}
+

Controllers/AsusAuraUSBController/ROGStrixLC_Controller.h

@@ -0,0 +1,92 @@
+/*-------------------------------------------------------------------*\
+|  ROGStrixLC_Controller.h                                            |
+|                                                                     |
+|  Driver for the ASUS Aura Liquid Cooler (LC) series                 |
+|    of lighting controllers                                          |
+|                                                                     |
+|  Chris M (Dr_No)          17 Jan 2022                               |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include <string>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+#include "AsusAuraUSBController.h"
+
+#pragma once
+
+#define ROGSTRIXLC_CONTROLLER_TIMEOUT 250
+#define HID_MAX_STR 255
+
+#define ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN  0
+#define ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX  255
+
+enum
+{
+    ROGSTRIXLC_CONTROLLER_MODE_DIRECT       = 0xFF, //Direct Led Control - Independently set LEDs in zone
+    ROGSTRIXLC_CONTROLLER_MODE_STATIC       = 0x01, //Static Mode - Set entire zone to a single color.
+    ROGSTRIXLC_CONTROLLER_MODE_BREATHING    = 0x02, //Breathing Mode - Fades between fully off and fully on.
+    ROGSTRIXLC_CONTROLLER_MODE_FLASHING     = 0x03, //Flashing Mode - Abruptly changing between fully off and fully on.
+    ROGSTRIXLC_CONTROLLER_MODE_SPECTRUM     = 0x04, //Spectrum Cycle Mode - Cycles through the color spectrum on all lights on the device
+    ROGSTRIXLC_CONTROLLER_MODE_RAINBOW      = 0x05, //Rainbow Wave Mode - Cycle thru the color spectrum as a wave across all LEDs
+    ROGSTRIXLC_CONTROLLER_MODE_FLASHANDDASH = 0x0A, //Flash n Dash - Flash twice and then flash in direction
+};
+
+enum AsusAuraStrixLC_PacketMap
+{
+    ROGSTRIXLC_REPORTID_BYTE                = 0,
+    ROGSTRIXLC_COMMAND_BYTE                 = 1,
+    ROGSTRIXLC_ZONE_BYTE                    = 2,
+    ROGSTRIXLC_MODE_BYTE                    = 3,
+    ROGSTRIXLC_RED_BYTE                     = 4,
+    ROGSTRIXLC_GREEN_BYTE                   = 5,
+    ROGSTRIXLC_BLUE_BYTE                    = 6,
+    ROGSTRIXLC_DIRECTION_BYTE               = 7,
+    ROGSTRIXLC_SPEED_BYTE                   = 8,
+};
+
+enum
+{
+    ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST     = 0x04, // Slowest speed
+    ROGSTRIXLC_CONTROLLER_SPEED_SLOW        = 0x03, // Slower speed
+    ROGSTRIXLC_CONTROLLER_SPEED_NORMAL      = 0x02, // Normal speed
+    ROGSTRIXLC_CONTROLLER_SPEED_FAST        = 0x01, // Fast speed
+    ROGSTRIXLC_CONTROLLER_SPEED_FASTEST     = 0x00, // Fastest speed
+};
+
+class ROGStrixLC_Controller : public AuraUSBController
+{
+public:
+    ROGStrixLC_Controller(hid_device* dev_handle, const char* path);
+    ~ROGStrixLC_Controller();
+
+    std::string             GetLocation();
+
+    void                    SetChannelLEDs(unsigned char channel, RGBColor *colors, unsigned int num_colors);
+    void                    SetLedsDirect(RGBColor * led_colours, uint8_t led_count);
+
+    void                    SetMode(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu);
+    void                    SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour);
+private:
+    static const uint8_t    read_packet_size    = 64;
+    static const uint8_t    write_packet_size   = read_packet_size + 1;
+    static const uint8_t    rogstrixlc_modefx   = 0x3B;
+    static const uint8_t    rogstrixlc_direct   = 0x40;
+    static const uint8_t    rogstrixlc_reportid = 0xEC;
+
+    std::string             location;
+
+    uint8_t                 zone_index;
+    uint8_t                 current_mode;
+    uint8_t                 current_speed;
+
+    uint8_t                 current_red;
+    uint8_t                 current_green;
+    uint8_t                 current_blue;
+    uint8_t                 current_direction;
+
+    void                    GetStatus();
+    void                    SendUpdate();
+    void                    SendEffect(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu);
+    void                    SendDirectApply(unsigned char channel);
+};

Controllers/AsusTUFLaptopController/AsusTUFLaptopWMIDetect.cpp

@@ -16,7 +16,6 @@ static void DetectAsusTUFLaptopWMIControllers(std::vector<RGBController*>&)
     // For now, checking for "TUF Gaming" should suffice
 
     Wmi wmi;
-    wmi.init();
 
     std::vector<QueryObj> systemProduct;
     if (wmi.query("SELECT * FROM Win32_ComputerSystemProduct", systemProduct))

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopWMI.cpp

@@ -10,6 +10,16 @@
 
 using namespace std::chrono_literals;
 
+/**------------------------------------------------------------------*\
+    @name Asus TUF Laptop
+    @type WMI
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAsusTUFLaptopWMIControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
 RGBController_AsusTUFLaptopWMI::RGBController_AsusTUFLaptopWMI()
 {
     name        = "ASUS TUF Keyboard";

Controllers/BlinkyTapeController/RGBController_BlinkyTape.cpp

@@ -8,6 +8,16 @@
 
 #include "RGBController_BlinkyTape.h"
 
+/**------------------------------------------------------------------*\
+    @name Blinky Tape
+    @type Serial
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectBlinkyTapeControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
 RGBController_BlinkyTape::RGBController_BlinkyTape(BlinkyTapeController* controller_ptr)
 {
     controller  = controller_ptr;

Controllers/CoolerMasterController/CMARGBcontroller.cpp

@@ -8,17 +8,8 @@
 \*-------------------------------------------------------------------*/
 
 #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
-};
-
-CMARGBController::CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx)
+CMARGBController::CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx, std::shared_ptr<std::mutex> cm_mutex)
 {
     const int szTemp = 256;
     wchar_t tmpName[szTemp];
@@ -26,6 +17,7 @@ CMARGBController::CMARGBController(hid_device* dev_handle, char *_path, unsigned
     dev                     = dev_handle;
     location                = _path;
     zone_index              = _zone_idx;
+    mutex_ptr               = cm_mutex;
 
     hid_get_manufacturer_string(dev, tmpName, szTemp);
     std::wstring wName = std::wstring(tmpName);
@@ -66,6 +58,12 @@ void CMARGBController::GetStatus()
         rgb_offset                              = 1;
     }
 
+    /*---------------------------------------------*\
+    | Guard the writes to the controller until the  |
+    |   for loop has completed to avoid collisons   |
+    \*---------------------------------------------*/
+    std::lock_guard<std::mutex> guard(*mutex_ptr);
+
     /*---------------------------------------------------------*\
     | If this is the group then just return the first status    |
     \*---------------------------------------------------------*/
@@ -132,38 +130,6 @@ bool CMARGBController::GetRandomColours()
     return bool_random;
 }
 
-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 Cooler Master ARGB controller V0008 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::SetLedCount(int zone, int led_count)
 {
     unsigned char buffer[CM_ARGB_PACKET_SIZE]   = { 0x00, 0x80, 0x0D, 0x02 };
@@ -173,18 +139,24 @@ void CMARGBController::SetLedCount(int zone, int led_count)
     buffer[CM_ARGB_MODE_BYTE]                   = led_count;
     buffer[CM_ARGB_COLOUR_INDEX_BYTE]           = (0x0F - led_count > 0) ? 0x0F - led_count : 0x01;
 
+    /*---------------------------------------------*\
+    | Guard the writes to the controller until the  |
+    |   for loop has completed to avoid collisons   |
+    \*---------------------------------------------*/
+    std::lock_guard<std::mutex> guard(*mutex_ptr);
+
     hid_write(dev, buffer, buffer_size);
 }
 
-void CMARGBController::SetMode(unsigned char mode, unsigned char speed, RGBColor colour, bool random_colours)
+void CMARGBController::SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor colour, bool random_colours)
 {
-    bool needs_update   = !( (current_mode == mode) && (current_speed == speed) && (current_brightness == 0xFF) && (ToRGBColor(current_red, current_green, current_blue) == colour));
+    bool needs_update   = !( (current_mode == mode) && (current_speed == speed) && (current_brightness == brightness) && (ToRGBColor(current_red, current_green, current_blue) == colour));
 
     if (needs_update)
     {
         current_mode        = mode;
         current_speed       = speed;
-        current_brightness  = 0xFF;
+        current_brightness  = brightness;
         current_red         = RGBGetRValue(colour);
         current_green       = RGBGetGValue(colour);
         current_blue        = RGBGetBValue(colour);
@@ -197,9 +169,9 @@ void CMARGBController::SetMode(unsigned char mode, unsigned char speed, RGBColor
 void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_count)
 {
     const unsigned char buffer_size     = CM_ARGB_PACKET_SIZE;
-    unsigned char buffer[buffer_size]   = { 0x00, 0x10, 0x02 };
+    unsigned char buffer[buffer_size]   = { 0x00, 0x00, 0x07, 0x02 };
     unsigned char packet_count          = 0;
-    std::vector<unsigned char> colours;
+    std::vector<uint8_t> colours;
 
     /*---------------------------------------------*\
     | Set up the RGB triplets to send               |
@@ -213,11 +185,17 @@ void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_cou
         colours.push_back( RGBGetBValue(colour) );
     }
 
-    buffer[CM_ARGB_ZONE_BYTE]           = argb_header_data[zone_index].header;
-    buffer[CM_ARGB_MODE_BYTE]           = led_count;
-    unsigned char buffer_idx            = CM_ARGB_MODE_BYTE + 1;
+    buffer[CM_ARGB_FUNCTION_BYTE]       = zone_index - 1;
+    buffer[CM_ARGB_ZONE_BYTE]           = led_count;
+    unsigned char buffer_idx            = CM_ARGB_MODE_BYTE;
 
-    for(std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = 0)
+    /*---------------------------------------------*\
+    | Guard the writes to the controller until the  |
+    |   for loop has completed to avoid collisons   |
+    \*---------------------------------------------*/
+    std::lock_guard<std::mutex> guard(*mutex_ptr);
+
+    for(std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = CM_ARGB_COMMAND_BYTE)
     {
         /*-----------------------------------------------------------------*\
         | Fill the write buffer till its full or the colour buffer is empty |
@@ -230,8 +208,12 @@ void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_cou
             it++;
         }
 
+        if(it == colours.end())
+        {
+            buffer[CM_ARGB_REPORT_BYTE] += 0x80;
+        }
+
         hid_write(dev, buffer, buffer_size);
-        hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
 
         /*-----------------------------------------------------------------*\
         | Reset the write buffer                                            |
@@ -239,21 +221,15 @@ void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_cou
         memset(buffer, 0x00, buffer_size );
         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()
 {
+    /*---------------------------------------------*\
+    | Guard the writes to the controller            |
+    \*---------------------------------------------*/
+    std::lock_guard<std::mutex> guard(*mutex_ptr);
+
     unsigned char buffer[CM_ARGB_PACKET_SIZE]   = { 0x00 };
     int  buffer_size                            = (sizeof(buffer) / sizeof(buffer[0]));
     bool boolARGB_header                        = argb_header_data[zone_index].digital;
@@ -262,22 +238,29 @@ void CMARGBController::SendUpdate()
     unsigned char function                      = boolPassthru ? (boolARGB_header ? 0x02 : 0x04) : (boolARGB_header ? 0x01 : 0x03);
     buffer[CM_ARGB_REPORT_BYTE]                 = 0x80;
     buffer[CM_ARGB_COMMAND_BYTE]                = 0x01;
-    buffer[CM_ARGB_FUNCTION_BYTE]               = boolDirect ? 0x01 : function;
+
+    if(boolDirect)
+    {
+        buffer[CM_ARGB_FUNCTION_BYTE]           = 0x01;
+        buffer[CM_ARGB_ZONE_BYTE]               = 0x02;
+
+        hid_write(dev, buffer, buffer_size);
+        hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
+
+        /*-----------------------------------------------------------------*\
+        | Direct mode is now set up and no other mode packet is required    |
+        \*-----------------------------------------------------------------*/
+        return;
+    }
+
+    buffer[CM_ARGB_FUNCTION_BYTE]           = function;
 
     hid_write(dev, buffer, buffer_size);
     hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
 
-    /*-----------------------------------------------------------------*\
-    | Direct mode is now set up and no other mode packet is required    |
-    \*-----------------------------------------------------------------*/
-    if(boolDirect)
-    {
-        return;
-    }
-
     if(boolARGB_header)
     {
-        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0b;                                     //ARGB sends 0x0b (1011) RGB sends 0x04 (0100)
+        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0B;                                     //ARGB sends 0x0B (1011) RGB sends 0x04 (0100)
         buffer[CM_ARGB_FUNCTION_BYTE]           = (false) ? 0x01 : 0x02;                    //This controls direct mode TODO
         buffer[CM_ARGB_ZONE_BYTE]               = argb_header_data[zone_index].header;
         buffer[CM_ARGB_MODE_BYTE]               = current_mode;
@@ -287,9 +270,6 @@ void CMARGBController::SendUpdate()
         buffer[CM_ARGB_RED_BYTE]                = current_red;
         buffer[CM_ARGB_GREEN_BYTE]              = current_green;
         buffer[CM_ARGB_BLUE_BYTE]               = current_blue;
-
-        hid_write(dev, buffer, buffer_size);
-        hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
     }
     else
     {
@@ -301,8 +281,8 @@ void CMARGBController::SendUpdate()
         buffer[CM_ARGB_RED_BYTE + CM_RGB_OFFSET]            = current_red;
         buffer[CM_ARGB_GREEN_BYTE + CM_RGB_OFFSET]          = current_green;
         buffer[CM_ARGB_BLUE_BYTE + CM_RGB_OFFSET]           = current_blue;
-
-        hid_write(dev, buffer, buffer_size);
-        hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
     }
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
 }

Controllers/CoolerMasterController/CMARGBcontroller.h

@@ -10,8 +10,9 @@
 \*-------------------------------------------------------------------*/
 
 #include <string>
+#include <cstring>
 #include <array>
-#include <cmath>            //Needed by round()
+#include <memory>
 #include <hidapi/hidapi.h>
 #include "RGBController.h"  //Needed to set the direct mode
 
@@ -25,6 +26,10 @@
 #define CM_RGB_OFFSET -2
 #define HID_MAX_STR 255
 
+#define CM_ARGB_BRIGHTNESS_MAX  255
+#define CM_ARGB_FW0023          std::string("A202011171238")
+#define CM_ARGB_FW0028          std::string("A202105291658")
+
 enum
 {
     CM_ARGB_REPORT_BYTE         = 1,
@@ -48,14 +53,14 @@ struct argb_headers
     unsigned int    count;
 };
 
-static argb_headers argb_header_data[6] =
+static argb_headers argb_header_data[] =
 {
     { "RGB Header",         0xFE, 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 }
+    //{ "All Digital ARGB",   0xFF, true,  12 }
 };
 
 enum
@@ -96,7 +101,7 @@ enum
 class CMARGBController
 {
 public:
-    CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx);
+    CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx, std::shared_ptr<std::mutex> cm_mutex);
     ~CMARGBController();
 
     std::string GetDeviceName();
@@ -111,27 +116,26 @@ public:
     unsigned char GetLedSpeed();
     bool GetRandomColours();
     void SetLedCount(int zone, int led_count);
-    void SetMode(unsigned char mode, unsigned char speed, RGBColor colour, bool random_colours);
+    void SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor colour, bool random_colours);
     void SetLedsDirect(RGBColor * led_colours, unsigned int led_count);
 
 private:
-    std::string             device_name;
-    std::string             serial;
-    std::string             location;
-    hid_device*             dev;
+    std::string                 device_name;
+    std::string                 serial;
+    std::string                 location;
+    hid_device*                 dev;
+    std::shared_ptr<std::mutex> mutex_ptr;
 
-    unsigned char           zone_index;
-    unsigned char           current_mode;
-    unsigned char           current_speed;
+    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 char           current_brightness;
-    bool                    bool_random;
+    unsigned char               current_red;
+    unsigned char               current_green;
+    unsigned char               current_blue;
+    unsigned char               current_brightness;
+    bool                        bool_random;
 
-    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();
 };

Controllers/CoolerMasterController/CMMKController.cpp

@@ -12,24 +12,44 @@
 
 CMMKController::CMMKController(hid_device* dev, hid_device_info* dev_info)
 {
-    location        =  dev_info->path;
+    location            =  dev_info->path;
 
-    const int szTemp = 256;
+    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());
+    std::wstring wName  = std::wstring(tmpName);
+    vendor_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()));
+    device_name         = std::string(wName.begin(), wName.end());
 
     cmmk_attach_path(&cmmk_handle, dev_info->path, dev_info->product_id, -1);
 
     char buf[32] = {0};
     cmmk_get_firmware_version(&cmmk_handle, buf, 32);
 
+    /*--------------------------------------------------------------*\
+    | Adjust the row count for keyboards without the front light bar |
+    | Adjust the column count for TKL keyboards (i.e. x30 vs x50)    |
+    \*--------------------------------------------------------------*/
+    enum cmmk_product_type kb_type = cmmk_get_device_model(&cmmk_handle);
+    row_count = (kb_type == CMMK_PRODUCT_MASTERKEYS_MK750) ? CMMK_ROWS_MAX : CMMK_ROWS_MAX - 1;
+    switch(kb_type)
+    {
+        case CMMK_PRODUCT_MASTERKEYS_PRO_S:
+        case CMMK_PRODUCT_MASTERKEYS_SK630:
+            column_count = CMMK_COLS_MAX - 4;
+            break;
+
+        case CMMK_PRODUCT_MASTERKEYS_PRO_L:
+        case CMMK_PRODUCT_MASTERKEYS_MK750:
+        case CMMK_PRODUCT_MASTERKEYS_SK650:
+        default:
+            column_count = CMMK_COLS_MAX;
+    }
+
     firmware_version = buf;
 }
 
@@ -43,6 +63,11 @@ std::string CMMKController::GetDeviceName()
     return device_name;
 }
 
+std::string CMMKController::GetDeviceVendor()
+{
+    return vendor_name;
+}
+
 std::string CMMKController::GetLocation()
 {
     return location;
@@ -53,6 +78,16 @@ std::string CMMKController::GetFirmwareVersion()
     return firmware_version;
 }
 
+uint8_t CMMKController::GetRowCount()
+{
+    return row_count;
+}
+
+uint8_t CMMKController::GetColumnCount()
+{
+    return column_count;
+}
+
 void CMMKController::SetFirmwareControl()
 {
     ActivateMode(CMMK_FIRMWARE);

Controllers/CoolerMasterController/CMMKController.h

@@ -20,8 +20,11 @@ public:
     ~CMMKController();
 
     std::string GetDeviceName();
+    std::string GetDeviceVendor();
     std::string GetLocation();
     std::string GetFirmwareVersion();
+    uint8_t     GetRowCount();
+    uint8_t     GetColumnCount();
 
     void SetFirmwareControl();
     void SetManualControl();
@@ -51,8 +54,11 @@ private:
     int         current_effect  = -1;
 
     std::string device_name;
+    std::string vendor_name;
     std::string location;
     std::string firmware_version;
+    uint8_t     row_count;
+    uint8_t     column_count;
 
     mutable struct cmmk cmmk_handle;
 };

Controllers/CoolerMasterController/CMMM711Controller.cpp

@@ -58,13 +58,20 @@ void CMMM711Controller::GetColourStatus()
 void CMMM711Controller::GetCustomStatus()
 {
     uint8_t buffer[CM_MM711_PACKET_SIZE]    = { 0x00, 0x52, 0xA8 };
-    int buffer_size                         = (sizeof(buffer) / sizeof(buffer[0]));
+    int read_size                           = CM_MM711_PACKET_SIZE - 1;
+    int result                              = 0;
 
-    hid_write(dev, buffer, buffer_size);
-    hid_read_timeout(dev, buffer, buffer_size, CM_MM711_INTERRUPT_TIMEOUT);
+    hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+    do
+    {
+        result = hid_read_timeout(dev, buffer, read_size, CM_MM711_INTERRUPT_TIMEOUT);
+    }while(buffer[1] != 0xA8 && result == read_size);
 
-    wheel_colour            = ToRGBColor(buffer[4], buffer[5], buffer[6]);
-    logo_colour             = ToRGBColor(buffer[7], buffer[8], buffer[9]);
+    if(result == read_size)
+    {
+        wheel_colour            = ToRGBColor(buffer[4], buffer[5], buffer[6]);
+        logo_colour             = ToRGBColor(buffer[7], buffer[8], buffer[9]);
+    }
 }
 
 void CMMM711Controller::GetModeStatus()
@@ -140,8 +147,9 @@ void CMMM711Controller::SetLedsDirect(RGBColor wheel_colour, RGBColor logo_colou
     buffer[CM_MM711_BRIGHTNESS_BYTE]            = RGBGetBValue(logo_colour);
 
     hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM711_PACKET_SIZE, CM_MM711_INTERRUPT_TIMEOUT);
 
-    SendApplyPacket(0xB0);  //Apply custom mode
+    //SendApplyPacket(0xB0);  //Apply custom mode
 }
 
 void CMMM711Controller::SendUpdate(uint8_t mode, uint8_t speed, RGBColor colour, uint8_t brightness)
@@ -159,6 +167,7 @@ void CMMM711Controller::SendUpdate(uint8_t mode, uint8_t speed, RGBColor colour,
     buffer[CM_MM711_BLUE_BYTE]                  = RGBGetBValue(colour);
 
     hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM711_PACKET_SIZE, CM_MM711_INTERRUPT_TIMEOUT);
 
     SendApplyPacket(mode);
 }
@@ -168,6 +177,7 @@ void CMMM711Controller::SendInitPacket()
     unsigned char buffer[CM_MM711_PACKET_SIZE]  = { 0x00, 0x41, 0x80 };
 
     hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM711_PACKET_SIZE, CM_MM711_INTERRUPT_TIMEOUT);
 }
 
 void CMMM711Controller::SendApplyPacket(uint8_t mode)
@@ -177,4 +187,13 @@ void CMMM711Controller::SendApplyPacket(uint8_t mode)
     buffer[CM_MM711_MODE_BYTE]                  = mode;
 
     hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM711_PACKET_SIZE, CM_MM711_INTERRUPT_TIMEOUT);
+}
+
+void CMMM711Controller::SendSavePacket()
+{
+    unsigned char buffer[CM_MM711_PACKET_SIZE]  = { 0x00, 0x50, 0x55 };
+
+    hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM711_PACKET_SIZE, CM_MM711_INTERRUPT_TIMEOUT);
 }

Controllers/CoolerMasterController/CMMM711Controller.h

@@ -76,6 +76,7 @@ public:
 
     void        SendUpdate(uint8_t mode, uint8_t speed, RGBColor colour, uint8_t brightness);
     void        SetLedsDirect(RGBColor wheel_colour, RGBColor logo_colour);
+    void        SendSavePacket();
 private:
     std::string device_name;
     std::string serial;

Controllers/CoolerMasterController/CMMMController.cpp

@@ -0,0 +1,331 @@
+/*-------------------------------------------------------------------*\
+|  CMMMController.cpp                                                 |
+|                                                                     |
+|  Driver for Coolermaster MasterMouse                                |
+|                                                                     |
+|  Chris M (Dr_No)          14th Feb 2021   -  MM711 Base             |
+|  Dracrius                 12th Mar 2022                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "CMMMController.h"
+#include <cstring>
+
+CMMMController::CMMMController(hid_device* dev_handle, char *_path, uint16_t pid) : product_id(pid)
+{
+    const int szTemp = HID_MAX_STR;
+    wchar_t tmpName[szTemp];
+
+    dev                                  = dev_handle;
+    location                             = _path;
+    current_speed                        = CM_MM_SPEED_3;
+
+    hid_get_manufacturer_string(dev, tmpName, szTemp);
+    std::wstring wName = std::wstring(tmpName);
+    vendor = std::string(wName.begin(), wName.end());
+
+    hid_get_indexed_string(dev, 2, tmpName, szTemp);
+    wName = std::wstring(tmpName);
+    serial = std::string(wName.begin(), wName.end());
+
+    if(product_id == CM_MM530_PID || product_id == CM_MM531_PID)
+    {
+        command_code = CM_MM5XX_COMMAND;
+        if(pid == CM_MM530_PID)
+        {
+            buttons_bytes[0]             = CM_MM_MODE_BYTE;
+            buttons_bytes[1]             = CM_MM_SPEED_BYTE;
+            buttons_bytes[2]             = CM_MM_NFI_1;
+            wheel_bytes[0]               = CM_MM_RED_BYTE;
+            wheel_bytes[1]               = CM_MM_GREEN_BYTE;
+            wheel_bytes[2]               = CM_MM_BLUE_BYTE;
+        }
+        else if(product_id == CM_MM531_PID) //Still Need Captures for Proper Mapping From a MM531 User
+        {
+            buttons_bytes[0]             = CM_MM_MODE_BYTE;
+            buttons_bytes[1]             = CM_MM_SPEED_BYTE;
+            buttons_bytes[2]             = CM_MM_NFI_1;
+            wheel_bytes[0]               = CM_MM_RED_BYTE;
+            wheel_bytes[1]               = CM_MM_GREEN_BYTE;
+            wheel_bytes[2]               = CM_MM_BLUE_BYTE;
+        }
+    }
+    else
+    {
+        command_code                     = CM_MM7XX_COMMAND;
+
+        buttons_bytes[0]                 = CM_MM_RED_BYTE;
+        buttons_bytes[1]                 = CM_MM_GREEN_BYTE;
+        buttons_bytes[2]                 = CM_MM_BLUE_BYTE;
+        wheel_bytes[0]                   = CM_MM_MODE_BYTE;
+        wheel_bytes[1]                   = CM_MM_SPEED_BYTE;
+        wheel_bytes[2]                   = CM_MM_NFI_1;
+    }                                    
+                                         
+    logo_bytes[0]                        = CM_MM_NFI_2;
+    logo_bytes[1]                        = CM_MM_NFI_3;
+    logo_bytes[2]                        = CM_MM_BRIGHTNESS_BYTE;
+
+    SendInitPacket();
+    GetColourStatus();
+    GetCustomStatus();
+    GetModeStatus();
+}
+
+CMMMController::~CMMMController()
+{
+    hid_close(dev);
+}
+
+void CMMMController::GetColourStatus()
+{
+    uint8_t buffer[CM_MM_PACKET_SIZE]    = { 0x00, 0x52, command_code };
+
+    hid_write(dev, buffer, CM_MM_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
+
+    current_brightness                   = buffer[CM_MM_BRIGHTNESS_BYTE - 1];
+    current_red                          = buffer[CM_MM_RED_BYTE - 1];
+    current_green                        = buffer[CM_MM_GREEN_BYTE - 1];
+    current_blue                         = buffer[CM_MM_BLUE_BYTE - 1];
+}
+
+void CMMMController::GetCustomStatus()
+{
+    uint8_t buffer[CM_MM_PACKET_SIZE]    = { 0x00, 0x52, 0xA8 };
+    int read_size                        = CM_MM_PACKET_SIZE - 1;
+    int result                           = 0;
+
+    hid_write(dev, buffer, CM_MM_PACKET_SIZE);
+    do
+    {
+        result = hid_read_timeout(dev, buffer, read_size, CM_MM_INTERRUPT_TIMEOUT);
+    }while(buffer[1] != 0xA8 && result == read_size);
+
+    if(result == read_size)
+    {
+        buttons_colour                   = ToRGBColor(buffer[4], buffer[5], buffer[6]);
+        logo_colour                      = ToRGBColor(buffer[7], buffer[8], buffer[9]);
+        wheel_colour                     = ToRGBColor(buffer[10], buffer[11], buffer[12]);
+    }
+}
+
+void CMMMController::GetModeStatus()
+{
+    uint8_t buffer[CM_MM_PACKET_SIZE]    = { 0x00, 0x52, 0x28 };
+    int buffer_size                      = (sizeof(buffer) / sizeof(buffer[0]));
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_MM_INTERRUPT_TIMEOUT);
+
+    current_mode                         = buffer[CM_MM_MODE_BYTE - 1];
+}
+
+std::string CMMMController::GetDeviceVendor()
+{
+    return vendor;
+}
+
+std::string CMMMController::GetSerial()
+{
+    return serial;
+}
+
+std::string CMMMController::GetLocation()
+{
+    return("HID: " + location);
+}
+
+uint16_t CMMMController::GetProductID()
+{
+    return product_id;
+}
+
+unsigned char CMMMController::GetMode()
+{
+    return current_mode;
+}
+
+unsigned char CMMMController::GetLedRed()
+{
+    return current_red;
+}
+
+unsigned char CMMMController::GetLedGreen()
+{
+    return current_green;
+}
+
+unsigned char CMMMController::GetLedBlue()
+{
+    return current_blue;
+}
+
+unsigned char CMMMController::GetLedSpeed()
+{
+    return current_speed;
+}
+
+RGBColor CMMMController::GetWheelColour()
+{
+    return wheel_colour;
+}
+
+RGBColor CMMMController::GetButtonsColour()
+{
+    return buttons_colour;
+}
+
+RGBColor CMMMController::GetLogoColour()
+{
+    return logo_colour;
+}
+
+void CMMMController::SetLedsDirect(RGBColor wheel_colour, RGBColor buttons_colour, RGBColor logo_colour)
+{
+    unsigned char buffer[CM_MM_PACKET_SIZE] = { 0x00, 0x51, 0xA8, 0x00, 0x00 };
+
+    buffer[buttons_bytes[0]]                = RGBGetRValue(buttons_colour);
+    buffer[buttons_bytes[1]]                = RGBGetGValue(buttons_colour);
+    buffer[buttons_bytes[2]]                = RGBGetBValue(buttons_colour);
+    buffer[logo_bytes[0]]                   = RGBGetRValue(logo_colour);
+    buffer[logo_bytes[1]]                   = RGBGetGValue(logo_colour);
+    buffer[logo_bytes[2]]                   = RGBGetBValue(logo_colour);
+    buffer[wheel_bytes[0]]                  = RGBGetRValue(wheel_colour);
+    buffer[wheel_bytes[1]]                  = RGBGetGValue(wheel_colour);
+    buffer[wheel_bytes[2]]                  = RGBGetBValue(wheel_colour);
+
+    hid_write(dev, buffer, CM_MM_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
+}
+
+void CMMMController::SendUpdate(uint8_t mode, uint8_t speed, RGBColor colour, uint8_t brightness)
+{
+    if (mode == CM_MM_MODE_CUSTOM || mode == CM_MM_MODE_MULTILAYER)
+    {
+        SendUsingZonesPacket(mode);
+    }
+    else
+    {
+        SendInitPacket();
+        SendApplyPacket(mode);
+    }
+
+    uint8_t nfi_1                               = 0x20;
+
+    if (mode == CM_MM_MODE_STATIC || mode == CM_MM_MODE_SPECTRUM_CYCLE)
+    {
+        nfi_1                                   = 0x00;
+    }
+
+    if (mode != CM_MM_MODE_OFF)
+    {
+        unsigned char buffer[CM_MM_PACKET_SIZE] = { 0x00, 0x51, command_code, 0x00, 0x00 };
+
+        buffer[CM_MM_MODE_BYTE]                 = mode;
+        buffer[CM_MM_SPEED_BYTE]                = speed;
+        buffer[CM_MM_NFI_1]                     = nfi_1;
+        buffer[CM_MM_NFI_2]                     = 0xFF;
+        buffer[CM_MM_NFI_3]                     = 0xFF;
+        buffer[CM_MM_BRIGHTNESS_BYTE]           = brightness;
+        buffer[CM_MM_RED_BYTE]                  = RGBGetRValue(colour);
+        buffer[CM_MM_GREEN_BYTE]                = RGBGetGValue(colour);
+        buffer[CM_MM_BLUE_BYTE]                 = RGBGetBValue(colour);
+        buffer[CM_MM_SKY_RED_BYTE]              = 0x00;
+        buffer[CM_MM_SKY_GREEN_BYTE]            = 0x00;
+        buffer[CM_MM_SKY_BLUE_BYTE]             = 0x00;
+
+        for (int i = 17; i < CM_MM_PACKET_SIZE; i++)
+        {
+            buffer[i]                           = 0xFF;
+        }
+
+        hid_write(dev, buffer, CM_MM_PACKET_SIZE);
+        hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
+
+    }
+
+    if (mode == CM_MM_MODE_CUSTOM || mode == CM_MM_MODE_MULTILAYER)
+    {
+        SendApplyPacket(mode); //Post Apply for Zoned Modes
+    }
+}
+
+void CMMMController::SendUpdate(uint8_t mode, uint8_t speed, RGBColor mode_one, RGBColor mode_two, uint8_t brightness)
+{
+    SendApplyPacket(mode);
+
+    unsigned char buffer[CM_MM_PACKET_SIZE]  = { 0x00, 0x51, command_code, 0x00, 0x00 };
+
+    buffer[CM_MM_MODE_BYTE]                  = mode;
+    buffer[CM_MM_SPEED_BYTE]                 = speed;
+    buffer[CM_MM_NFI_1]                      = 0x00;
+    buffer[CM_MM_NFI_2]                      = 0x21;
+    buffer[CM_MM_NFI_3]                      = 0xFF;
+    buffer[CM_MM_BRIGHTNESS_BYTE]            = brightness;
+    buffer[CM_MM_RED_BYTE]                   = RGBGetRValue(mode_one);
+    buffer[CM_MM_GREEN_BYTE]                 = RGBGetGValue(mode_one);
+    buffer[CM_MM_BLUE_BYTE]                  = RGBGetBValue(mode_one);
+    buffer[CM_MM_SKY_RED_BYTE]               = RGBGetRValue(mode_two);
+    buffer[CM_MM_SKY_GREEN_BYTE]             = RGBGetGValue(mode_two);
+    buffer[CM_MM_SKY_BLUE_BYTE]              = RGBGetBValue(mode_two);
+
+    for (int i = 17; i < CM_MM_PACKET_SIZE; i++)
+    {
+        buffer[i] = 0xFF;
+    }
+
+    hid_write(dev, buffer, CM_MM_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
+}
+
+void CMMMController::SendInitPacket()
+{
+    unsigned char buffer[CM_MM_PACKET_SIZE]  = { 0x00, 0x41, 0x80 };
+
+    hid_write(dev, buffer, CM_MM_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
+}
+
+void CMMMController::SendUsingZonesPacket(uint8_t mode)
+{
+    unsigned char buffer[CM_MM_PACKET_SIZE] = { 0x00, 0x51, 0x30, 0x00, 0x00 };
+
+    if (mode == CM_MM_MODE_MULTILAYER)
+    {
+        buffer[CM_MM_MODE_BYTE] = 0x01;
+    }
+
+    hid_write(dev, buffer, CM_MM_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
+}
+
+void CMMMController::SendApplyPacket(uint8_t mode)
+{
+    unsigned char buffer[CM_MM_PACKET_SIZE]  = { 0x00, 0x51, 0x28, 0x00, 0x00 };
+
+    buffer[CM_MM_MODE_BYTE]                  = mode;
+
+    hid_write(dev, buffer, CM_MM_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
+}
+
+void CMMMController::SendMultilayerPacket(uint8_t zones[3])
+{
+    unsigned char buffer[CM_MM_PACKET_SIZE] = { 0x00, 0x51, 0xA0, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00 };
+
+    buffer[CM_MM_NFI_3]                     = zones[0];
+    buffer[CM_MM_BRIGHTNESS_BYTE]           = zones[1];
+    buffer[CM_MM_RED_BYTE]                  = zones[2];
+
+    hid_write(dev, buffer, CM_MM_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
+}
+
+void CMMMController::SendSavePacket()
+{
+    unsigned char buffer[CM_MM_PACKET_SIZE]  = { 0x00, 0x50, 0x55 };
+
+    hid_write(dev, buffer, CM_MM_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
+}

Controllers/CoolerMasterController/CMMMController.h

@@ -0,0 +1,147 @@
+/*-------------------------------------------------------------------*\
+|  CMMMController.h                                                   |
+|                                                                     |
+|  Driver for Coolermaster MasterMouse                                |
+|                                                                     |
+|  Chris M (Dr_No)          14th Feb 2021   -  MM711 Base             |
+|  Dracrius                 12th Mar 2022                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include <string>
+#include <array>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+
+#pragma once
+
+#define CM_MM_PACKET_SIZE 65
+#define CM_MM_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
+#define CM_MM_HEADER_DATA_SIZE (sizeof(argb_header_data) / sizeof(argb_headers) )
+#define CM_MM_INTERRUPT_TIMEOUT 250
+#define CM_MM_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
+#define HID_MAX_STR 255
+
+enum
+{
+    CM_MM530_PID                 = 0x0065,
+    CM_MM531_PID                 = 0x0097,
+    CM_MM711_PID                 = 0x0101,
+    CM_MM720_PID                 = 0x0141,
+};
+
+enum
+{
+    CM_MM_REPORT_BYTE            = 1,
+    CM_MM_COMMAND_BYTE           = 2,
+    CM_MM_FUNCTION_BYTE          = 3,
+    CM_MM_ZONE_BYTE              = 4,
+    CM_MM_MODE_BYTE              = 5,
+    CM_MM_SPEED_BYTE             = 6,
+    CM_MM_NFI_1                  = 7,
+    CM_MM_NFI_2                  = 8,
+    CM_MM_NFI_3                  = 9,
+    CM_MM_BRIGHTNESS_BYTE        = 10,
+    CM_MM_RED_BYTE               = 11,
+    CM_MM_GREEN_BYTE             = 12,
+    CM_MM_BLUE_BYTE              = 13,
+    CM_MM_SKY_RED_BYTE           = 14,
+    CM_MM_SKY_GREEN_BYTE         = 15,
+    CM_MM_SKY_BLUE_BYTE          = 16
+};
+
+enum
+{
+    CM_MM5XX_COMMAND             = 0x2C,
+    CM_MM7XX_COMMAND             = 0x2B
+};
+
+enum
+{
+    CM_MM_CUSTOM_APPLY           = 0x30, //Also Used for Multilayer Mode
+    CM_MM_APPLY                  = 0x28  //Sent Before Update, Unless using a Zoned Mode then UsingZones Before and Apply After
+};
+
+enum
+{
+    CM_MM_MODE_STATIC            = 0,    //Static Mode
+    CM_MM_MODE_BREATHING         = 1,    //Breathing Mode
+    CM_MM_MODE_SPECTRUM_CYCLE    = 2,    //Spectrum Cycle Mode
+    CM_MM_MODE_STARS             = 3,    //Stars Mode
+    CM_MM_MODE_INDICATOR         = 4,    //Indicator Mode
+    CM_MM_MODE_CUSTOM            = 176,  //Custom LED Control
+    CM_MM_MODE_MULTILAYER        = 224,  //Multilayer Mode, i.e. Effect per Zone.
+    CM_MM_MODE_OFF               = 254   //Turn Off
+};
+
+enum
+{
+    CM_MM_SPEED_1               = 0x3C,  // Slowest speed
+    CM_MM_SPEED_2               = 0x37,
+    CM_MM_SPEED_3               = 0x31,  // Normal speed
+    CM_MM_SPEED_4               = 0x2C,
+    CM_MM_SPEED_5               = 0x26  // Fastest speed
+};
+
+class CMMMController
+{
+public:
+    CMMMController(hid_device* dev_handle, char *_path, uint16_t pid);
+    ~CMMMController();
+
+    std::string GetDeviceVendor();
+    std::string GetSerial();
+    std::string GetLocation();
+
+    uint16_t    GetProductID();
+
+    uint8_t     GetZoneIndex();
+    uint8_t     GetMode();
+    uint8_t     GetLedRed();
+    uint8_t     GetLedGreen();
+    uint8_t     GetLedBlue();
+    uint8_t     GetLedSpeed();
+    RGBColor    GetWheelColour();
+    RGBColor    GetButtonsColour();
+    RGBColor    GetLogoColour();
+
+    void        SendUpdate(uint8_t mode, uint8_t speed, RGBColor colour, uint8_t brightness);
+    void        SendUpdate(uint8_t mode, uint8_t speed, RGBColor mode_one, RGBColor mode_two, uint8_t brightness);
+    void        SetLedsDirect(RGBColor wheel_colour, RGBColor buttons_colour, RGBColor logo_colour);
+    void        SendSavePacket();
+private:
+    std::string name;
+    std::string vendor;
+    std::string serial;
+    std::string location;
+    hid_device* dev;
+
+    uint16_t    product_id;
+
+    uint8_t     command_code;
+
+    uint8_t     current_mode;
+    uint8_t     current_speed;
+
+    uint8_t     current_brightness;
+    uint8_t     current_red;
+    uint8_t     current_green;
+    uint8_t     current_blue;
+
+    uint8_t     buttons_bytes[3];
+    uint8_t     logo_bytes[3];
+    uint8_t     wheel_bytes[3];
+
+    RGBColor    buttons_colour;
+    RGBColor    logo_colour;
+    RGBColor    wheel_colour;
+
+
+    void        GetColourStatus();
+    void        GetCustomStatus();
+    void        GetModeStatus();
+    void        SendInitPacket();
+    void        SendUsingZonesPacket(uint8_t mode);
+    void        SendApplyPacket(uint8_t mode);
+    void        SendMultilayerPacket(uint8_t zones[3]);
+};

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -7,6 +7,7 @@
 #include "CMR6000Controller.h"
 #include "CMMKController.h"
 #include "RGBController.h"
+#include "RGBController_CMMMController.h"
 #include "RGBController_CMMM711Controller.h"
 #include "RGBController_CMMP750Controller.h"
 #include "RGBController_CMARGBController.h"
@@ -18,19 +19,23 @@
 
 #define COOLERMASTER_VID                        0x2516
 
+#define COOLERMASTER_MM530_PID                  0x0065
+#define COOLERMASTER_MM531_PID                  0x0097
 #define COOLERMASTER_MM711_PID                  0x0101
+#define COOLERMASTER_MM720_PID                  0x0141
 #define COOLERMASTER_MP750_XL_PID               0x0109
+#define COOLERMASTER_MP750_L_PID                0x0107
 #define COOLERMASTER_MP750_MEDIUM_PID           0x0105
 #define COOLERMASTER_ARGB_PID                   0x1011
 #define COOLERMASTER_SMALL_ARGB_PID             0x1000
 #define COOLERMASTER_RGB_PID                    0x004F
 #define COOLERMASTER_RADEON_6000_PID            0x014D
-#define COOLERMASTER_MASTERKEYS_PRO_L_PID       CMMK_USB_MASTERKEYS_MK750
-#define COOLERMASTER_MASTERKEYS_PRO_L_WHITE_PID CMMK_USB_MASTERKEYS_PRO_L_WHITE
-#define COOLERMASTER_MASTERKEYS_PRO_S_PID       CMMK_USB_MASTERKEYS_PRO_S 
-#define COOLERMASTER_MASTERKEYS_MK750_PID       CMMK_USB_MASTERKEYS_MK750
-#define COOLERMASTER_MASTERKEYS_SK630_PID       CMMK_USB_MASTERKEYS_SK630
-#define COOLERMASTER_MASTERKEYS_SK650_PID       CMMK_USB_MASTERKEYS_SK650
+#define COOLERMASTER_MASTERKEYS_PRO_L_PID       0x003B
+#define COOLERMASTER_MASTERKEYS_PRO_L_WHITE_PID 0x0047
+#define COOLERMASTER_MASTERKEYS_PRO_S_PID       0x003C
+#define COOLERMASTER_MASTERKEYS_MK750_PID       0x0067
+#define COOLERMASTER_MASTERKEYS_SK630_PID       0x0089
+#define COOLERMASTER_MASTERKEYS_SK650_PID       0x008D
 
 /******************************************************************************************\
 *                                                                                          *
@@ -43,11 +48,18 @@
 void DetectCoolerMasterARGB(hid_device_info* info, const std::string&)
 {
     hid_device* dev = hid_open_path(info->path);
+
     if(dev)
     {
+        /*-------------------------------------------------*\
+        | Create mutex to prevent the controllers sharing a |
+        |   receiver from interfering with each other       |
+        \*-------------------------------------------------*/
+        std::shared_ptr<std::mutex>       cm_mutex = std::make_shared<std::mutex>();
+
         for(std::size_t i = 0; i < CM_ARGB_HEADER_DATA_SIZE; i++)
         {
-            CMARGBController* controller = new CMARGBController(dev, info->path, i);
+            CMARGBController*               controller     = new CMARGBController(dev, info->path, i, cm_mutex);
             RGBController_CMARGBController* rgb_controller = new RGBController_CMARGBController(controller);
             // Constructor sets the name
             ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -58,9 +70,10 @@ void DetectCoolerMasterARGB(hid_device_info* info, const std::string&)
 void DetectCoolerMasterGPU(hid_device_info* info, const std::string&)
 {
     hid_device* dev = hid_open_path(info->path);
+
     if(dev)
     {
-        CMR6000Controller* controller                   = new CMR6000Controller(dev, info->path);
+        CMR6000Controller*               controller     = new CMR6000Controller(dev, info->path);
         RGBController_CMR6000Controller* rgb_controller = new RGBController_CMR6000Controller(controller);
         // Constructor sets the name
         ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -69,35 +82,48 @@ void DetectCoolerMasterGPU(hid_device_info* info, const std::string&)
 
 void DetectCoolerMasterKeyboards(hid_device_info* info, const std::string&)
 {
-
     hid_device* dev = hid_open_path(info->path);
+
     if(dev)
     {
-        CMMKController* controller                   = new CMMKController(dev, info);
+        CMMKController*               controller     = new CMMKController(dev, info);
         RGBController_CMMKController* rgb_controller = new RGBController_CMMKController(controller);
         // Constructor sets the name
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
 
-void DetectCoolerMasterMouse(hid_device_info* info, const std::string&)
+void DetectCoolerMasterMouse(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
+
     if(dev)
     {
-        CMMM711Controller* controller                   = new CMMM711Controller(dev, info->path);
-        RGBController_CMMM711Controller* rgb_controller = new RGBController_CMMM711Controller(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        if(info->product_id == COOLERMASTER_MM530_PID || info->product_id == COOLERMASTER_MM531_PID)
+        {
+            CMMMController* controller                      = new CMMMController(dev, info->path, info->product_id);
+            RGBController_CMMMController* rgb_controller    = new RGBController_CMMMController(controller);
+            rgb_controller->name                            = name;
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+        else if(info->product_id == COOLERMASTER_MM711_PID)
+        {
+            CMMM711Controller*               controller     = new CMMM711Controller(dev, info->path);
+            RGBController_CMMM711Controller* rgb_controller = new RGBController_CMMM711Controller(controller);
+            // Constructor sets the name
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+
     }
 }
 
 void DetectCoolerMasterMousemats(hid_device_info* info, const std::string&)
 {
     hid_device* dev = hid_open_path(info->path);
+
     if(dev)
     {
-        CMMP750Controller* controller                   = new CMMP750Controller(dev, info->path);
+        CMMP750Controller*               controller     = new CMMP750Controller(dev, info->path);
         RGBController_CMMP750Controller* rgb_controller = new RGBController_CMMP750Controller(controller);
         // Constructor sets the name
         ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -107,9 +133,10 @@ void DetectCoolerMasterMousemats(hid_device_info* info, const std::string&)
 void DetectCoolerMasterRGB(hid_device_info* info, const std::string&)
 {
     hid_device* dev = hid_open_path(info->path);
+
     if(dev)
     {
-        CMRGBController* controller = new CMRGBController(dev, info->path);
+        CMRGBController*               controller     = new CMRGBController(dev, info->path);
         RGBController_CMRGBController* rgb_controller = new RGBController_CMRGBController(controller);
         // Constructor sets the name
         ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -119,17 +146,22 @@ void DetectCoolerMasterRGB(hid_device_info* info, const std::string&)
 void DetectCoolerMasterSmallARGB(hid_device_info* info, const std::string&)
 {
     hid_device* dev = hid_open_path(info->path);
+
     if(dev)
     {
-        CMSmallARGBController* controller = new CMSmallARGBController(dev, info->path, 0);
+        CMSmallARGBController*               controller     = new CMSmallARGBController(dev, info->path, 0);
         RGBController_CMSmallARGBController* rgb_controller = new RGBController_CMSmallARGBController(controller);
         // Constructor sets the name
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
 
+REGISTER_HID_DETECTOR_IPU("Cooler Master MM530",                    DetectCoolerMasterMouse,        COOLERMASTER_VID,   COOLERMASTER_MM530_PID,                     1,      0xFF00, 1);
+//REGISTER_HID_DETECTOR_IPU("Cooler Master MM531",                  DetectCoolerMasterMouse,        COOLERMASTER_VID,   COOLERMASTER_MM531_PID,                     1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MM711",                    DetectCoolerMasterMouse,        COOLERMASTER_VID,   COOLERMASTER_MM711_PID,                     1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master MM720",                    DetectCoolerMasterMouse,        COOLERMASTER_VID,   COOLERMASTER_MM720_PID,                     1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 XL",                 DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_XL_PID,                          0xFF00, 1);
+REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 Large",              DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_L_PID,                           0xFF00, 1);
 REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 Medium",             DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_MEDIUM_PID,                      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L",         DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_L_PID,          1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L White",   DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_L_WHITE_PID,    1,      0xFF00, 1);
@@ -137,7 +169,7 @@ REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro S",         DetectCooler
 REGISTER_HID_DETECTOR_IPU("Cooler Master MK570",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_MK750_PID,          1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master SK630",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_SK630_PID,          1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master SK650",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_SK650_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB",                     DetectCoolerMasterARGB,         COOLERMASTER_VID,   COOLERMASTER_ARGB_PID,         	        0,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master Small ARGB",               DetectCoolerMasterSmallARGB,    COOLERMASTER_VID,   COOLERMASTER_SMALL_ARGB_PID,   	        0,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master RGB",                      DetectCoolerMasterRGB,          COOLERMASTER_VID,   COOLERMASTER_RGB_PID,                       0,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB",                     DetectCoolerMasterARGB,         COOLERMASTER_VID,   COOLERMASTER_ARGB_PID,                      0,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master Small ARGB",               DetectCoolerMasterSmallARGB,    COOLERMASTER_VID,   COOLERMASTER_SMALL_ARGB_PID,                0,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master RGB",                      DetectCoolerMasterRGB,          COOLERMASTER_VID,   COOLERMASTER_RGB_PID,                       1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_I  ("Cooler Master Radeon 6000 GPU",          DetectCoolerMasterGPU,          COOLERMASTER_VID,   COOLERMASTER_RADEON_6000_PID,               1                );

Controllers/CoolerMasterController/RGBController_CMARGBController.cpp

@@ -9,215 +9,266 @@
 
 #include "RGBController_CMARGBController.h"
 
-RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController *cmargb_ptr)
+/**------------------------------------------------------------------*\
+    @name Coolermaster ARGB
+    @type USB
+    @save :warning:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectCoolerMasterARGB
+    @comment The Coolermaster ARGB device supports `Direct` mode from
+        firmware 0028 onwards. Check the serial number for the date
+        "A202105291658" or newer.
+\*-------------------------------------------------------------------*/
+
+RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController* controller_ptr)
 {
-    cmargb                  = cmargb_ptr;
-    unsigned char speed     = cmargb->GetLedSpeed();
+    controller                      = controller_ptr;
+    unsigned char speed             = controller->GetLedSpeed();
 
-    name                    = argb_header_data[cmargb->GetZoneIndex()].name;
-    vendor                  = "Cooler Master";
-    type                    = DEVICE_TYPE_LEDSTRIP;
-    description             = cmargb->GetDeviceName();
-    version                 = "2.0 for FW0023";
-    serial                  = cmargb->GetSerial();
-    location                = cmargb->GetLocation();
+    name                            = argb_header_data[controller->GetZoneIndex()].name;
+    vendor                          = "Cooler Master";
+    type                            = DEVICE_TYPE_LEDSTRIP;
+    description                     = controller->GetDeviceName();
+    version                         = "3.0 for FW0028";
+    serial                          = controller->GetSerial();
+    location                        = controller->GetLocation();
 
-    if(argb_header_data[cmargb->GetZoneIndex()].digital)
+    if(argb_header_data[controller->GetZoneIndex()].digital)
     {
         mode Off;
-        Off.name                = "Turn Off";
-        Off.value               = CM_ARGB_MODE_OFF;
-        Off.color_mode          = MODE_COLORS_NONE;
+        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.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 | MODE_FLAG_HAS_BRIGHTNESS;
+        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_MODE_SPECIFIC;
-        Reload.speed            = speed;
+        Reload.brightness_min       = 0;
+        Reload.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Reload.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Reload.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Reload.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Reload.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        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.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 | MODE_FLAG_HAS_BRIGHTNESS;
+        Recoil.colors_min           = 1;
+        Recoil.colors_max           = 1;
         Recoil.colors.resize(Recoil.colors_max);
-        Recoil.speed_min        = CM_ARGB_SPEED_SLOWEST;
-        Recoil.speed_max        = CM_ARGB_SPEED_FASTEST;
-        Recoil.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-        Recoil.speed            = speed;
+        Recoil.brightness_min       = 0;
+        Recoil.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Recoil.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Recoil.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Recoil.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Recoil.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        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.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 | MODE_FLAG_HAS_BRIGHTNESS;
+        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_MODE_SPECIFIC;
-        Breathing.speed         = speed;
+        Breathing.brightness_min    = 0;
+        Breathing.brightness_max    = CM_ARGB_BRIGHTNESS_MAX;
+        Breathing.brightness        = CM_ARGB_BRIGHTNESS_MAX;
+        Breathing.speed_min         = CM_ARGB_SPEED_SLOWEST;
+        Breathing.speed_max         = CM_ARGB_SPEED_FASTEST;
+        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+        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.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 | MODE_FLAG_HAS_BRIGHTNESS;
+        Refill.colors_min           = 1;
+        Refill.colors_max           = 1;
         Refill.colors.resize(Refill.colors_max);
-        Refill.speed_min        = CM_ARGB_SPEED_SLOWEST;
-        Refill.speed_max        = CM_ARGB_SPEED_FASTEST;
-        Refill.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-        Refill.speed            = speed;
+        Refill.brightness_min       = 0;
+        Refill.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Refill.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Refill.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Refill.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Refill.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        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;
+        Demo.name                   = "Demo";
+        Demo.value                  = CM_ARGB_MODE_DEMO;
+        Demo.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        Demo.brightness_min         = 0;
+        Demo.brightness_max         = CM_ARGB_BRIGHTNESS_MAX;
+        Demo.brightness             = CM_ARGB_BRIGHTNESS_MAX;
+        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;
+        Spectrum.name               = "Spectrum";
+        Spectrum.value              = CM_ARGB_MODE_SPECTRUM;
+        Spectrum.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        Spectrum.brightness_min     = 0;
+        Spectrum.brightness_max     = CM_ARGB_BRIGHTNESS_MAX;
+        Spectrum.brightness         = CM_ARGB_BRIGHTNESS_MAX;
+        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;
+        FillFlow.name               = "Fill Flow";
+        FillFlow.value              = CM_ARGB_MODE_FILLFLOW;
+        FillFlow.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        FillFlow.brightness_min     = 0;
+        FillFlow.brightness_max     = CM_ARGB_BRIGHTNESS_MAX;
+        FillFlow.brightness         = CM_ARGB_BRIGHTNESS_MAX;
+        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;
+        Rainbow.name                = "Rainbow";
+        Rainbow.value               = CM_ARGB_MODE_RAINBOW;
+        Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        Rainbow.brightness_min      = 0;
+        Rainbow.brightness_max      = CM_ARGB_BRIGHTNESS_MAX;
+        Rainbow.brightness          = CM_ARGB_BRIGHTNESS_MAX;
+        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 Static;
-        Static.name             = "Static";
-        Static.value            = CM_ARGB_MODE_STATIC;
-        Static.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-        Static.colors_min       = 1;
-        Static.colors_max       = 1;
+        Static.name                 = "Static";
+        Static.value                = CM_ARGB_MODE_STATIC;
+        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Static.colors_min           = 1;
+        Static.colors_max           = 1;
         Static.colors.resize(Static.colors_max);
-        Static.speed_min        = CM_ARGB_SPEED_SLOWEST;
-        Static.speed_max        = CM_ARGB_SPEED_FASTEST;
-        Static.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-        Static.speed            = speed;
+        Static.brightness_min       = 0;
+        Static.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Static.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Static.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Static.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Static.speed                = speed;
         modes.push_back(Static);
 
         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;
+        Direct.name                 = (serial >= CM_ARGB_FW0028) ? "Direct" : "Custom";
+        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.flags          = 0;
-        PassThru.color_mode     = MODE_COLORS_NONE;
+        PassThru.name               = "Pass Thru";
+        PassThru.value              = CM_ARGB_MODE_PASSTHRU;
+        PassThru.flags              = 0;
+        PassThru.color_mode         = MODE_COLORS_NONE;
         modes.push_back(PassThru);
     }
     else
     {
         mode Static;
-        Static.name             = "Static";
-        Static.value            = CM_RGB_MODE_STATIC;
-        Static.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-        Static.colors_min       = 1;
-        Static.colors_max       = 1;
+        Static.name                 = "Static";
+        Static.value                = CM_RGB_MODE_STATIC;
+        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Static.colors_min           = 1;
+        Static.colors_max           = 1;
         Static.colors.resize(Static.colors_max);
-        Static.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-        Static.speed            = 0;
+        Static.brightness_min       = 0;
+        Static.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Static.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Static.speed                = 0;
         modes.push_back(Static);
 
         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.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 | MODE_FLAG_HAS_BRIGHTNESS;
+        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_MODE_SPECIFIC;
-        Breathing.speed         = CM_ARGB_SPEED_NORMAL;
+        Breathing.brightness_min    = 0;
+        Breathing.brightness_max    = CM_ARGB_BRIGHTNESS_MAX;
+        Breathing.brightness        = CM_ARGB_BRIGHTNESS_MAX;
+        Breathing.speed_min         = CM_ARGB_SPEED_SLOWEST;
+        Breathing.speed_max         = CM_ARGB_SPEED_FASTEST;
+        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+        Breathing.speed             = CM_ARGB_SPEED_NORMAL;
         modes.push_back(Breathing);
 
         mode Flash;
-        Flash.name              = "Flash";
-        Flash.value             = CM_RGB_MODE_FLASH;
-        Flash.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Flash.colors_min        = 1;
-        Flash.colors_max        = 1;
+        Flash.name                  = "Flash";
+        Flash.value                 = CM_RGB_MODE_FLASH;
+        Flash.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Flash.colors_min            = 1;
+        Flash.colors_max            = 1;
         Flash.colors.resize(Flash.colors_max);
-        Flash.speed_min         = CM_ARGB_SPEED_SLOWEST;
-        Flash.speed_max         = CM_ARGB_SPEED_FASTEST;
-        Flash.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Flash.speed             = CM_ARGB_SPEED_NORMAL;
+        Flash.brightness_min        = 0;
+        Flash.brightness_max        = CM_ARGB_BRIGHTNESS_MAX;
+        Flash.brightness            = CM_ARGB_BRIGHTNESS_MAX;
+        Flash.speed_min             = CM_ARGB_SPEED_SLOWEST;
+        Flash.speed_max             = CM_ARGB_SPEED_FASTEST;
+        Flash.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+        Flash.speed                 = CM_ARGB_SPEED_NORMAL;
         modes.push_back(Flash);
 
         mode Mirage;
-        Mirage.name             = "Mirage";
-        Mirage.value            = CM_RGB_MODE_MIRAGE;
-        Mirage.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Mirage.colors_min       = 1;
-        Mirage.colors_max       = 1;
+        Mirage.name                 = "Mirage";
+        Mirage.value                = CM_RGB_MODE_MIRAGE;
+        Mirage.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Mirage.colors_min           = 1;
+        Mirage.colors_max           = 1;
         Mirage.colors.resize(Mirage.colors_max);
-        Mirage.speed_min        = CM_ARGB_SPEED_SLOWEST;
-        Mirage.speed_max        = CM_ARGB_SPEED_FASTEST;
-        Mirage.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-        Mirage.speed            = CM_ARGB_SPEED_NORMAL;
+        Mirage.brightness_min       = 0;
+        Mirage.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Mirage.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Mirage.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Mirage.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Mirage.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Mirage.speed                = CM_ARGB_SPEED_NORMAL;
         modes.push_back(Mirage);
 
         mode PassThru;
-        PassThru.name           = "Pass Thru";
-        PassThru.value          = CM_RGB_MODE_PASSTHRU;
-        PassThru.color_mode     = MODE_COLORS_NONE;
+        PassThru.name               = "Pass Thru";
+        PassThru.value              = CM_RGB_MODE_PASSTHRU;
+        PassThru.color_mode         = MODE_COLORS_NONE;
         modes.push_back(PassThru);
 
         mode Off;
-        Off.name                = "Turn Off";
-        Off.value               = CM_RGB_MODE_OFF;
-        Off.color_mode          = MODE_COLORS_NONE;
+        Off.name                    = "Turn Off";
+        Off.value                   = CM_RGB_MODE_OFF;
+        Off.color_mode              = MODE_COLORS_NONE;
         modes.push_back(Off);
     }
 
     Init_Controller();
     SetupZones();
 
-    int temp_mode   = cmargb->GetMode();
+    int temp_mode   = controller->GetMode();
     for(std::size_t mode_idx = 0; mode_idx < modes.size() ; mode_idx++)
     {
         if (temp_mode == modes[mode_idx].value)
@@ -228,23 +279,23 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
     }
     if (modes[active_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
     {
-        modes[active_mode].colors[0] = ToRGBColor(cmargb->GetLedRed(), cmargb->GetLedGreen(), cmargb->GetLedBlue());
+        modes[active_mode].colors[0] = ToRGBColor(controller->GetLedRed(), controller->GetLedGreen(), controller->GetLedBlue());
+        modes[active_mode].color_mode = (controller->GetRandomColours()) ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
     }
-    modes[active_mode].color_mode = (cmargb->GetRandomColours()) ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
     if (modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
     {
-        modes[active_mode].speed = cmargb->GetLedSpeed();
+        modes[active_mode].speed = controller->GetLedSpeed();
     }
 }
 
 RGBController_CMARGBController::~RGBController_CMARGBController()
 {
-    delete cmargb;
+    delete controller;
 }
 
 void RGBController_CMARGBController::Init_Controller()
 {
-    int zone_idx            = cmargb->GetZoneIndex();
+    int zone_idx            = controller->GetZoneIndex();
     int zone_led_count      = argb_header_data[zone_idx].count;
 
     /*-------------------------------------------------*\
@@ -280,7 +331,7 @@ void RGBController_CMARGBController::SetupZones()
 
         if (!boolSingleLED)
         {
-            cmargb->SetLedCount( std::stoi(zones[zone_idx].name), zones[zone_idx].leds_count);
+            controller->SetLedCount( std::stoi(zones[zone_idx].name), zones[zone_idx].leds_count);
         }
 
         for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
@@ -336,9 +387,9 @@ void RGBController_CMARGBController::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_CMARGBController::UpdateZoneLEDs(int /*zone*/)
+void RGBController_CMARGBController::UpdateZoneLEDs(int zone)
 {
-    //cmargb->SetLedsDirect( zones[zone].colors, zones[zone].leds_count );
+    controller->SetLedsDirect( zones[zone].colors, zones[zone].leds_count );
 }
 
 void RGBController_CMARGBController::UpdateSingleLED(int led)
@@ -360,10 +411,10 @@ void RGBController_CMARGBController::SetCustomMode()
 
 void RGBController_CMARGBController::DeviceUpdateMode()
 {
-    bool random_colours     = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+    bool     random_colours = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
     RGBColor colour         = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
 
-    cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed, colour, random_colours );
+    controller->SetMode( modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, colour, random_colours );
 }
 
 int RGBController_CMARGBController::GetLED_Zone(int led_idx)

Controllers/CoolerMasterController/RGBController_CMARGBController.h

@@ -1,40 +1,40 @@
-/*-------------------------------------------------------------------*\
-|  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>
-
-#define first_zone(zn)          ((zones.size() > 1) ? 1 : 0)
-#define last_zone(zn)           ((zones.size() > 1) ? 4 : 1)
-
-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();
-    int         GetLED_Zone(int led_idx);
-
-    CMARGBController* cmargb;
-};
+/*-------------------------------------------------------------------*\
+|  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>
+
+#define first_zone(zn)          ((zones.size() > 1) ? 1 : 0)
+#define last_zone(zn)           ((zones.size() > 1) ? 4 : 1)
+
+class RGBController_CMARGBController : public RGBController
+{
+public:
+    RGBController_CMARGBController(CMARGBController* controller_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();
+    int         GetLED_Zone(int led_idx);
+
+    CMARGBController*   controller;
+};

Controllers/CoolerMasterController/RGBController_CMMKController.cpp

@@ -4,7 +4,7 @@
 |  Driver for Coolermaster MasterKeys keyboards                       |
 |                                                                     |
 |  Lukas N (chmod222)          28th Jun 2020                          |
-|  Tam D (too.manyhobbies)  25th Apr 2021                             |
+|  Tam D (too.manyhobbies)     25th Apr 2021                          |
 |                                                                     |
 \*-------------------------------------------------------------------*/
 
@@ -14,141 +14,168 @@
 
 using namespace std::chrono_literals;
 
-#define CMMK_SPEED_MIN      CMMK_SPEED0
-#define CMMK_SPEED_MID      CMMK_SPEED2 
-#define CMMK_SPEED_MAX      CMMK_SPEED4
-#define CMMK_MODE_FIRMWARE  0xFF
-#define CMMK_MODE_MANUAL    0x7F
+#define CMMK_SPEED_MIN          CMMK_SPEED0
+#define CMMK_SPEED_MID          CMMK_SPEED2
+#define CMMK_SPEED_MAX          CMMK_SPEED4
+#define CMMK_MODE_FIRMWARE      0xFF
+#define CMMK_MODE_MANUAL        0x7F
 
-RGBController_CMMKController::RGBController_CMMKController(CMMKController* cmmk_ctrl)
+/**------------------------------------------------------------------*\
+    @name Coolermaster Masterkeys Keyboards
+    @type USB
+    @save :warning:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectCoolerMasterKeyboards
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_CMMKController::RGBController_CMMKController(CMMKController* controller_ptr)
 {
-    cmmk        = cmmk_ctrl;
+    controller                  = controller_ptr;
 
-    name        = cmmk->GetDeviceName();
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "Cooler Master MasterKeys Device";
-    version     = cmmk->GetFirmwareVersion();
-    serial      = "";
-    location    = cmmk->GetLocation();
+    name                        = controller->GetDeviceName();
+    vendor                      = controller->GetDeviceVendor();
+    type                        = DEVICE_TYPE_KEYBOARD;
+    description                 = "Cooler Master MasterKeys Device";
+    version                     = controller->GetFirmwareVersion();
+    serial                      = "";
+    location                    = controller->GetLocation();
     
     mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = CMMK_MODE_MANUAL;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name                 = "Direct";
+    Direct.value                = CMMK_MODE_MANUAL;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode Static;
-    Static.name       = "Static";
-    Static.value      = CMMK_EFFECT_FULLY_LIT;
-    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors_min = 1;
-    Static.colors_max = 1;
+    Static.name                 = "Static";
+    Static.value                = CMMK_EFFECT_FULLY_LIT;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
     Static.colors.resize(1);
     modes.push_back(Static);
     
     mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = CMMK_EFFECT_BREATHE;
-    Breathing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Breathing.speed_min  = 0x20;
-    Breathing.speed_max  = 0x20;
-    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors_min = 1;
-    Breathing.colors_max = 1;
+    Breathing.name              = "Breathing";
+    Breathing.value             = CMMK_EFFECT_BREATHE;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed_min         = CMMK_SPEED_MIN;
+    Breathing.speed_max         = CMMK_SPEED_MAX;
+    Breathing.speed             = CMMK_SPEED_MID;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 1;
     Breathing.colors.resize(1);
     modes.push_back(Breathing);
 
     mode Cycle;
-    Cycle.name       = "Spectrum Cycle";
-    Cycle.value      = CMMK_EFFECT_CYCLE;
-    Cycle.flags      = MODE_FLAG_HAS_SPEED;
-    Cycle.speed_min  = CMMK_SPEED_MIN;
-    Cycle.speed_max  = CMMK_SPEED_MAX;
-    Cycle.color_mode = MODE_COLORS_NONE;
+    Cycle.name                  = "Spectrum Cycle";
+    Cycle.value                 = CMMK_EFFECT_CYCLE;
+    Cycle.flags                 = MODE_FLAG_HAS_SPEED;
+    Cycle.color_mode            = MODE_COLORS_NONE;
+    Cycle.speed_min             = 2 * CMMK_SPEED_MIN; //Spectrum Cycle uses a unique speed range
+    Cycle.speed_max             = 2 * CMMK_SPEED_MAX;
+    Cycle.speed                 = 2 * CMMK_SPEED_MID;
     modes.push_back(Cycle);
 
     mode Reactive;
-    Reactive.name       = "Reactive";
-    Reactive.value      = CMMK_EFFECT_SINGLE;
-    Reactive.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Reactive.speed_min  = CMMK_SPEED_MIN;
-    Reactive.speed_max  = CMMK_SPEED_MAX;
-    Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Reactive.colors_min = 2;
-    Reactive.colors_max = 2;
+    Reactive.name               = "Reactive";
+    Reactive.value              = CMMK_EFFECT_SINGLE;
+    Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    Reactive.speed_min          = CMMK_SPEED_MIN;
+    Reactive.speed_max          = CMMK_SPEED_MAX;
+    Reactive.speed              = CMMK_SPEED_MID;
+    Reactive.colors_min         = 2;
+    Reactive.colors_max         = 2;
     Reactive.colors.resize(2);
     modes.push_back(Reactive);
 
     mode Wave;
-    Wave.name       = "Rainbow Wave";
-    Wave.value      = CMMK_EFFECT_WAVE;
-    Wave.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
-    Wave.speed_min  = CMMK_SPEED_MIN;
-    Wave.speed_max  = CMMK_SPEED_MAX;
-    Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Wave.colors_min = 1;
-    Wave.colors_max = 1;
+    Wave.name                   = "Rainbow Wave";
+    Wave.value                  = CMMK_EFFECT_WAVE;
+    Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
+    Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Wave.speed_min              = CMMK_SPEED_MIN;
+    Wave.speed_max              = CMMK_SPEED_MAX;
+    Wave.speed                  = CMMK_SPEED_MID;
+    Wave.direction              = MODE_DIRECTION_LEFT;
+    Wave.colors_min             = 1;
+    Wave.colors_max             = 1;
     Wave.colors.resize(1);
     modes.push_back(Wave);
     
     mode Ripple;
-    Ripple.name       = "Ripple Effect";
-    Ripple.value      = CMMK_EFFECT_RIPPLE;
-    Ripple.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
-    Ripple.speed_min  = CMMK_SPEED_MIN;
-    Ripple.speed_max  = CMMK_SPEED_MAX;
-    Ripple.colors_min = 2;
-    Ripple.colors_max = 2;
+    Ripple.name                 = "Ripple Effect";
+    Ripple.value                = CMMK_EFFECT_RIPPLE;
+    Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
+    Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Ripple.speed_min            = CMMK_SPEED_MIN;
+    Ripple.speed_max            = CMMK_SPEED_MAX;
+    Ripple.speed                = CMMK_SPEED_MID;
+    Ripple.colors_min           = 2;
+    Ripple.colors_max           = 2;
     Ripple.colors.resize(2);
     modes.push_back(Ripple);
     
     mode Cross;
-    Cross.name       = "Cross";
-    Cross.value      = CMMK_EFFECT_CROSS;
-    Cross.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Cross.speed_min  = CMMK_SPEED_MIN;
-    Cross.speed_max  = CMMK_SPEED_MAX;
-    Cross.colors_min = 2;
-    Cross.colors_max = 2;
+    Cross.name                  = "Cross";
+    Cross.value                 = CMMK_EFFECT_CROSS;
+    Cross.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Cross.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Cross.speed_min             = CMMK_SPEED_MIN;
+    Cross.speed_max             = CMMK_SPEED_MAX;
+    Cross.speed                 = CMMK_SPEED_MID;
+    Cross.colors_min            = 2;
+    Cross.colors_max            = 2;
     Cross.colors.resize(2);
     modes.push_back(Cross);
 
     mode Raindrops;
-    Raindrops.name       = "Raindrops";
-    Raindrops.value      = CMMK_EFFECT_RAINDROPS;
-    Raindrops.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Raindrops.speed_min  = CMMK_SPEED_MIN;
-    Raindrops.speed_max  = CMMK_SPEED_MAX;
-    Raindrops.colors_min = 2;
-    Raindrops.colors_max = 2;
+    Raindrops.name              = "Raindrops";
+    Raindrops.value             = CMMK_EFFECT_RAINDROPS;
+    Raindrops.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Raindrops.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Raindrops.speed_min         = CMMK_SPEED_MIN;
+    Raindrops.speed_max         = CMMK_SPEED_MAX;
+    Raindrops.speed             = CMMK_SPEED_MID;
+    Raindrops.colors_min        = 2;
+    Raindrops.colors_max        = 2;
     Raindrops.colors.resize(2);
     modes.push_back(Raindrops);
     
     mode Stars;
-    Stars.name       = "Starfield";
-    Stars.value      = CMMK_EFFECT_STARS;
-    Stars.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Stars.speed_min  = CMMK_SPEED_MIN;
-    Stars.speed_max  = CMMK_SPEED_MAX;
-    Stars.colors_min = 2;
+    Stars.name                  = "Starfield";
+    Stars.value                 = CMMK_EFFECT_STARS;
+    Stars.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Stars.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Stars.speed_min             = CMMK_SPEED_MIN;
+    Stars.speed_max             = CMMK_SPEED_MAX;
+    Stars.speed                 = CMMK_SPEED_MID;
+    Stars.colors_min            = 2;
     Stars.colors_max = 2;
     Stars.colors.resize(2);
     modes.push_back(Stars);
 
     mode Snake;
-    Snake.name      = "Snake";
-    Snake.value     = CMMK_EFFECT_SNAKE;
-    Snake.flags     = MODE_FLAG_HAS_SPEED;
-    Snake.speed_min = CMMK_SPEED_MIN;
-    Snake.speed_max = CMMK_SPEED_MAX;
+    Snake.name                  = "Snake";
+    Snake.value                 = CMMK_EFFECT_SNAKE;
+    Snake.flags                 = MODE_FLAG_HAS_SPEED;
+    Snake.color_mode            = MODE_COLORS_NONE;
+    Snake.speed_min             = CMMK_SPEED_MIN;
+    Snake.speed_max             = CMMK_SPEED_MAX;
+    Snake.speed                 = CMMK_SPEED_MID;
     modes.push_back(Snake);
 
     mode FirmwareControl;
-    FirmwareControl.name  = "Firmware Controlled";
-    FirmwareControl.value = 0xFF;
-    FirmwareControl.flags = 0;
+    FirmwareControl.name        = "Firmware Controlled";
+    FirmwareControl.value       = 0xFF;
+    FirmwareControl.flags       = 0;
+    FirmwareControl.color_mode  = MODE_COLORS_NONE;
     modes.push_back(FirmwareControl);
 
     SetupZones();
@@ -156,7 +183,7 @@ RGBController_CMMKController::RGBController_CMMKController(CMMKController* cmmk_
 
 RGBController_CMMKController::~RGBController_CMMKController()
 {
-    delete cmmk;
+    delete controller;
 }
 
 void RGBController_CMMKController::SetupMatrixMap()
@@ -182,11 +209,14 @@ void RGBController_CMMKController::SetupMatrixMap()
 
 void RGBController_CMMKController::SetupZones()
 {
-    for(int y = 0; y < CMMK_ROWS_MAX; y++)
+    uint8_t row_count       = controller->GetRowCount();
+    uint8_t column_count    = controller->GetColumnCount();
+
+    for(int y = 0; y < row_count; y++)
     {
-        for(int x = 0; x < CMMK_COLS_MAX; x++)
+        for(int x = 0; x < column_count; x++)
         {
-            if(!cmmk->PositionValid(y, x))
+            if(!controller->PositionValid(y, x))
             {
                 continue;
             }
@@ -211,8 +241,8 @@ void RGBController_CMMKController::SetupZones()
     KeyboardZone.leds_max           = leds.size();
     KeyboardZone.leds_count         = leds.size();
     KeyboardZone.matrix_map         = new matrix_map_type;
-    KeyboardZone.matrix_map->height = CMMK_ROWS_MAX;
-    KeyboardZone.matrix_map->width  = CMMK_COLS_MAX;
+    KeyboardZone.matrix_map->height = row_count;
+    KeyboardZone.matrix_map->width  = column_count;
     KeyboardZone.matrix_map->map    = (unsigned int *)&matrix_map;
 
     zones.push_back(KeyboardZone);
@@ -288,7 +318,7 @@ void RGBController_CMMKController::DeviceUpdateLEDs()
 
     if(force_update.load() || dirty.load())
     {
-        cmmk->SetAll(current_matrix);
+        controller->SetAll(current_matrix);
 
         force_update.store(false);
     }
@@ -302,7 +332,7 @@ void RGBController_CMMKController::UpdateZoneLEDs(int zone_idx)
 
     if(force_update.load() || dirty.load())
     {
-        cmmk->SetAll(current_matrix);
+        controller->SetAll(current_matrix);
 
         force_update.store(false);
     }
@@ -317,7 +347,7 @@ void RGBController_CMMKController::UpdateSingleLED(int led_idx)
 
     current_matrix.data[y][x] = map_to_cmmk_rgb(colors[led_idx]);
 
-    cmmk->SetSingle(y, x, map_to_cmmk_rgb(colors[led_idx]));
+    controller->SetSingle(y, x, map_to_cmmk_rgb(colors[led_idx]));
     dirty.store(false);
 }
 
@@ -333,11 +363,11 @@ void RGBController_CMMKController::DeviceUpdateMode()
     switch(modes[active_mode].value)
     {
         case CMMK_MODE_FIRMWARE:
-            cmmk->SetFirmwareControl();
+            controller->SetFirmwareControl();
             break;
         
         case CMMK_MODE_MANUAL:
-            cmmk->SetManualControl();
+            controller->SetManualControl();
             break;
 
         case CMMK_EFFECT_FULLY_LIT:
@@ -346,7 +376,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
 
                 fully_lit_effect.color  = map_to_cmmk_rgb(modes[active_mode].colors[0]);
 
-                cmmk->SetMode(fully_lit_effect);
+                controller->SetMode(fully_lit_effect);
             }
             break;
 
@@ -357,7 +387,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                 breathe_effect.speed    = (uint8_t)modes[active_mode].speed;
                 breathe_effect.color    = map_to_cmmk_rgb(modes[active_mode].colors[0]);
 
-                cmmk->SetMode(breathe_effect);
+                controller->SetMode(breathe_effect);
             }
             break;
 
@@ -367,7 +397,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
 
                 cycle_effect.speed  = (uint8_t)modes[active_mode].speed;
 
-                cmmk->SetMode(cycle_effect);
+                controller->SetMode(cycle_effect);
             }
             break;
         
@@ -379,7 +409,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                 single_effect.active    = map_to_cmmk_rgb(modes[active_mode].colors[0]);
                 single_effect.rest      = map_to_cmmk_rgb(modes[active_mode].colors[1]);
 
-                cmmk->SetMode(single_effect);
+                controller->SetMode(single_effect);
             }
             break;
         
@@ -391,7 +421,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                 wave_effect.direction   = map_to_cmmk_dir(modes[active_mode].direction);
                 wave_effect.start       = map_to_cmmk_rgb(modes[active_mode].colors[0]);
 
-                cmmk->SetMode(wave_effect);
+                controller->SetMode(wave_effect);
             }
             break;
         
@@ -412,7 +442,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                     ripple_effect.ripple_type   = CMMK_RIPPLE_GIVEN_COLOR;
                 }
 
-                cmmk->SetMode(ripple_effect);
+                controller->SetMode(ripple_effect);
             }
             break;
         
@@ -424,7 +454,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                 cross_effect.active = map_to_cmmk_rgb(modes[active_mode].colors[0]);
                 cross_effect.rest   = map_to_cmmk_rgb(modes[active_mode].colors[1]);
 
-                cmmk->SetMode(cross_effect);
+                controller->SetMode(cross_effect);
             }
             break;
         
@@ -437,7 +467,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                 raindrops_effect.active     = map_to_cmmk_rgb(modes[active_mode].colors[0]);
                 raindrops_effect.rest       = map_to_cmmk_rgb(modes[active_mode].colors[1]);
 
-                cmmk->SetMode(raindrops_effect);
+                controller->SetMode(raindrops_effect);
             }
             break;
 
@@ -450,7 +480,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                 stars_effect.active     = map_to_cmmk_rgb(modes[active_mode].colors[0]);
                 stars_effect.rest       = map_to_cmmk_rgb(modes[active_mode].colors[1]);
     
-                cmmk->SetMode(stars_effect);
+                controller->SetMode(stars_effect);
             }
             break;
 
@@ -460,7 +490,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                 
                 snake_effect.speed = (uint8_t)modes[active_mode].speed;
 
-                cmmk->SetMode(snake_effect);
+                controller->SetMode(snake_effect);
             }
             break;
     }

Controllers/CoolerMasterController/RGBController_CMMKController.h

@@ -1,42 +1,42 @@
-/*-------------------------------------------------------------------*\
-|  RGBController_CMMKController.h                                     |
-|                                                                     |
-|  Driver for Coolermaster MasterKeys keyboards                       |
-|                                                                     |
-|  Lukas N (chmod222)          28th Jun 2020                          |
-|  Tam D (too.manyhobbies)     25th Apr 2021                          |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "CMMKController.h"
-
-class RGBController_CMMKController : public RGBController
-{
-public:
-    RGBController_CMMKController(CMMKController* cmmk_ptr);
-    ~RGBController_CMMKController();
-
-    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 SetupMatrixMap();
-
-    CMMKController* cmmk;
-
-    int matrix_map[CMMK_ROWS_MAX][CMMK_COLS_MAX];
-    struct cmmk_color_matrix current_matrix;
-
-    std::atomic<bool> dirty;
-    std::atomic<bool> force_update;
-};
+/*-------------------------------------------------------------------*\
+|  RGBController_CMMKController.h                                     |
+|                                                                     |
+|  Driver for Coolermaster MasterKeys keyboards                       |
+|                                                                     |
+|  Lukas N (chmod222)          28th Jun 2020                          |
+|  Tam D (too.manyhobbies)     25th Apr 2021                          |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "CMMKController.h"
+
+class RGBController_CMMKController : public RGBController
+{
+public:
+    RGBController_CMMKController(CMMKController* controller_ptr);
+    ~RGBController_CMMKController();
+
+    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 SetupMatrixMap();
+
+    CMMKController*             controller;
+
+    int                         matrix_map[CMMK_ROWS_MAX][CMMK_COLS_MAX];
+    struct cmmk_color_matrix    current_matrix;
+
+    std::atomic<bool>           dirty;
+    std::atomic<bool>           force_update;
+};