Initial HyperX Pulsefire Haste support

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

.gitlab-ci.yml

@@ -16,6 +16,7 @@
   
 stages:
   - build
+  - test
 
 before_script:
  - echo "started by ${GITLAB_USER_NAME}"
@@ -23,15 +24,15 @@ before_script:
 #reusable templates
 .ccache_init: &ccache_init
   before_script:
-    - apt update
-    - apt install -y build-essential qtcreator qtbase5-dev libusb-1.0-0-dev libhidapi-dev pkgconf wget git file
+    - export QT_SELECT=qt5
+    - export APPIMAGE_EXTRACT_AND_RUN=1
 
 #-----------------------------------------------------------------------#
 # Linux (AppImage) 32-bit Build Target                                  #
 #-----------------------------------------------------------------------#
 "Linux 32 AppImage":
   <<: *ccache_init
-  image: i386/debian:bullseye
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
   stage: build
   script:
   - export $(dpkg-architecture)
@@ -50,7 +51,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 64 AppImage":
   <<: *ccache_init
-  image: debian:bullseye
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
   stage: build
   script:
   - export $(dpkg-architecture)
@@ -69,10 +70,9 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 32 deb":
   <<: *ccache_init
-  image: i386/debian:bullseye
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
   stage: build
   script:
-  - apt install -y debhelper
   - dpkg-architecture -l
   - dpkg-buildpackage --target-arch i386 -us -B
   - rm -v ../openrgb-dbgsym*.deb
@@ -91,10 +91,9 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 64 deb":
   <<: *ccache_init
-  image: debian:bullseye
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
   stage: build
   script:
-  - apt install -y debhelper
   - dpkg-architecture -l
   - dpkg-buildpackage -us -B
   - rm -v ../openrgb-dbgsym*.deb
@@ -134,7 +133,239 @@ before_script:
     paths:
     - openrgb*.rpm
     expire_in: 30 days
-    
+  
+#-----------------------------------------------------------------------#
+# Linux (.deb) Debian Bullseye 32-bit Build Target                      #
+#-----------------------------------------------------------------------#
+"Linux 32 deb Bullseye":
+  <<: *ccache_init
+  image: i386/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 --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 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
+    expire_in: 30 days
+
+#-----------------------------------------------------------------------#
+# Debian 32 Buster test                                                 #
+#-----------------------------------------------------------------------#
+"Debian 32 Buster":
+  image: i386/debian:buster
+  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 32 Bullseye test                                               #
+#-----------------------------------------------------------------------#
+"Debian 32 Bullseye":
+  image: i386/debian:bullseye
+  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"
+
+# #-----------------------------------------------------------------------#
+# # 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"
+
+#-----------------------------------------------------------------------#
+# Debian 64 Bullseye test                                               #
+#-----------------------------------------------------------------------#
+"Debian 64 Bullseye":
+  image: debian:bullseye
+  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"
+
+#-----------------------------------------------------------------------#
+# 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"
+
+#-----------------------------------------------------------------------#
+# Ubuntu 64 20.04LTS test                                               #
+#-----------------------------------------------------------------------#
+"Ubuntu 64 20.04LTS":
+  image: ubuntu:focal
+  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"
+
+#-----------------------------------------------------------------------#
+# Ubuntu 64 20.10 test                                                  #
+#-----------------------------------------------------------------------#
+"Ubuntu 64 20.10":
+  image: ubuntu:groovy
+  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"
+
+#-----------------------------------------------------------------------#
+# Mint 64 20.1 test                                                     #
+#-----------------------------------------------------------------------#
+"Mint 64 20.1":
+  image: linuxmintd/mint20.1-amd64
+  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"
+
 #-----------------------------------------------------------------------#
 # Windows (32-bit) Build Target                                         #
 #-----------------------------------------------------------------------#

60-openrgb.rules

@@ -56,15 +56,31 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18f3", TAG+="uacces
 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}=="18dd", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1845", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1875", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1877", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18cd", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18cf", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e5", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e3", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1958", 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)                                   #
@@ -80,6 +96,8 @@ ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /s
 #---------------------------------------------------------------#
 #  Cooler Master Peripheral Devices                             #
 #                                                               #
+#  Mice:                                                        #
+#       Cooler Master MM711                                     #
 #  Mousemats:                                                   #
 #       Cooler Master MP750                                     #
 #  Controllers:                                                 #
@@ -95,6 +113,7 @@ ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /s
 #       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"
@@ -236,6 +255,15 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b62", TAG+="uacces
 #---------------------------------------------------------------#
 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                                       #
 #                                                               #
@@ -338,6 +366,12 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0cf2", ATTR{idProduct}=="7750", TAG+="uacces
 #  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"
@@ -348,6 +382,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c331", TAG+="uacces
 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"
@@ -360,7 +395,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08b", TAG+="uacces
 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"
+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"
@@ -371,9 +406,16 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08c", TAG+="uacces
 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"
+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"
+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                                 #
@@ -427,6 +469,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C95", TAG+="uacces
 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"
 
@@ -456,6 +499,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2005", TAG+="uacces
 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                                                  #
@@ -487,6 +531,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0245", TAG+="uacces
 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"
@@ -507,6 +552,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="025E", TAG+="uacces
 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"
@@ -523,7 +569,11 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="005B", TAG+="uacces
 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"
@@ -593,6 +643,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0C04", TAG+="uacces
 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"
 
@@ -614,6 +665,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1e7d", ATTR{idProduct}=="2e27", TAG+="uacces
 #  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"
@@ -622,6 +674,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0c45", ATTR{idProduct}=="652f", TAG+="uacces
 
 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"
 
 #---------------------------------------------------------------#
@@ -665,7 +718,8 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="054c", ATTR{idProduct}=="0ba0", TAG+="uacces
 #       SteelSeries Rival 300 Blackops Edition                  #
 #       SteelSeries Rival 310                                   #
 #       SteelSeries Rival 310 CS:GO Howl Edition                #
-#       SteelSeries Rival 310 PubG 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                            #
@@ -700,6 +754,8 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1736", TAG+="uacces
 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"
 
@@ -712,6 +768,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="0616", TAG+="uacces
 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"
 
 #---------------------------------------------------------------#
@@ -735,8 +792,10 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="226[0-3]", TAG+="ua
 #---------------------------------------------------------------#
 #  Wooting Devices                                              #
 #---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="ff01", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="ff02", TAG+="uaccess"
+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                                         #

AutoStart/AutoStart-Linux.cpp

@@ -0,0 +1,212 @@
+#include "AutoStart-Linux.h"
+#include "LogManager.h"
+#include "filesystem.h"
+
+#include <fstream>
+#include <iostream>
+#include <unistd.h>
+#include <linux/limits.h>
+
+/*-----------------------------------------------------*\
+| Linux 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::string     desktop_file                = GenerateDesktopFile(autostart_info);
+        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));
+}
+
+/*-----------------------------------------------------*\
+| Linux AutoStart Implementation                        |
+| Private Methods                                       |
+\*-----------------------------------------------------*/
+
+std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
+{
+    /*-------------------------------------------------*\
+    | Generate a .desktop file from the AutoStart       |
+    | parameters                                        |
+    \*-------------------------------------------------*/
+    std::stringstream fileContents;
+
+    fileContents << "[Desktop Entry]"                               << std::endl;
+    fileContents << "Categories="        << autostart_info.category << std::endl;
+    fileContents << "Comment="           << autostart_info.desc     << std::endl;
+    fileContents << "Icon="              << autostart_info.icon     << std::endl;
+    fileContents << "Name="              << GetAutoStartName()      << std::endl;
+    fileContents << "StartupNotify=true"                            << std::endl;
+    fileContents << "Terminal=false"                                << std::endl;
+    fileContents << "Type=Application"                              << std::endl;
+
+    /*-------------------------------------------------*\
+    | Add the executable path and arguments             |
+    \*-------------------------------------------------*/
+    fileContents << "Exec="              << autostart_info.path;
+
+    if (autostart_info.args != "")
+    {
+        fileContents << " " << autostart_info.args;
+    }
+
+    fileContents << std::endl;
+    
+    return(fileContents.str());
+}
+
+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-Linux.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 GenerateDesktopFile(AutoStartInfo autostart_info);
+};

AutoStart/AutoStart-MacOS.cpp

@@ -0,0 +1,208 @@
+#include "AutoStart-MacOS.h"
+#include "LogManager.h"
+#include "filesystem.h"
+
+#include <fstream>
+#include <sstream>
+#include <iostream>
+#include <unistd.h>
+
+#include <mach-o/dyld.h>
+
+/*-----------------------------------------------------*\
+| MacOS 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::string     desktop_file                = GenerateLaunchAgentFile(autostart_info);
+        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 ];
+    uint32_t exesize = PATH_MAX;
+
+    int ret_val = _NSGetExecutablePath(exepath, &exesize);
+
+    return(std::string(exepath, (ret_val == 0) ? strlen(exepath) : 0));
+
+    return("");
+}
+
+/*-----------------------------------------------------*\
+| MacOS AutoStart Implementation                        |
+| Private Methods                                       |
+\*-----------------------------------------------------*/
+
+std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
+{
+    /*-------------------------------------------------*\
+    | Generate a .plist file from the AutoStart         |
+    | parameters                                        |
+    \*-------------------------------------------------*/
+    std::stringstream fileContents;
+
+    fileContents << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"                                                                    << std::endl;
+    fileContents << "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">"    << std::endl;
+    fileContents << "<plist version=\"1.0\">"                                                                                       << std::endl;
+    fileContents << "<dict>"                                                                                                        << std::endl;
+    fileContents << "    <key>Label</key>"                                                                                          << std::endl;
+    fileContents << "    <string>org.openrgb</string>"                                                                              << std::endl;
+    fileContents << "    <key>ProgramArguments</key>"                                                                               << std::endl;
+    fileContents << "    <array>"                                                                                                   << std::endl;
+    fileContents << "        <string>" << autostart_info.path << "</string>"                                                        << std::endl;
+    
+    if(autostart_info.args != "")
+    {
+        std::istringstream arg_parser(autostart_info.args);
+        std::string arg;
+
+        while(arg_parser >> arg)
+        {
+            fileContents << "        <string>" << arg << "</string>"                                                                << std::endl;
+        }
+    }
+    
+    fileContents << "    </array>"                                                                                                  << std::endl;
+    fileContents << "    <key>RunAtLoad</key><true/>"                                                                               << std::endl;
+    fileContents << "</dict>"                                                                                                       << std::endl;
+    fileContents << "</plist>"                                                                                                      << std::endl;
+    
+    return(fileContents.str());
+}
+
+void AutoStart::InitAutoStart(std::string name)
+{
+    std::string autostart_dir;
+
+    autostart_name = name;
+
+    /*-------------------------------------------------*\
+    | Determine where the autostart .desktop files are  |
+    | kept                                              |
+    \*-------------------------------------------------*/
+    autostart_dir = getenv("HOME");
+    autostart_dir = autostart_dir + "/Library/LaunchAgents/";
+
+    /*-------------------------------------------------*\
+    | 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 + ".plist";
+        }
+    }
+}
+

AutoStart/AutoStart-MacOS.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

@@ -0,0 +1,204 @@
+#include "AutoStart-Windows.h"
+#include "LogManager.h"
+#include "filesystem.h"
+
+#include <fstream>
+#include <iostream>
+
+#include "windows.h"
+#include <shlobj.h>
+
+/*-----------------------------------------------------*\
+| Windows 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("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 != "")
+    {
+        bool            weInitialised               = false;
+        HRESULT         result;
+        IShellLinkW*    shellLink                   = NULL;
+
+        std::wstring    exepathw                    = utf8_decode(autostart_info.path);
+        std::wstring    argumentsw                  = utf8_decode(autostart_info.args);
+        std::wstring    startupfilepathw            = utf8_decode(autostart_file);
+        std::wstring    descriptionw                = utf8_decode(autostart_info.desc);
+        std::wstring    iconw                       = utf8_decode(autostart_info.path);
+
+        result                                      = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_ALL, IID_IShellLinkW, (void**)&shellLink);
+
+        /*---------------------------------------------*\
+        | If not initialized, initialize                |
+        \*---------------------------------------------*/
+        if(result == CO_E_NOTINITIALIZED)
+        {
+            weInitialised                           = true;
+            CoInitializeEx(NULL, COINIT_MULTITHREADED);
+            result                                  = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_ALL, IID_IShellLinkW, (void**)&shellLink);
+        }
+
+        /*---------------------------------------------*\
+        | If successfully initialized, save a shortcut  |
+        | from the AutoStart parameters                 |
+        \*---------------------------------------------*/
+        if(SUCCEEDED(result))
+        {
+            shellLink->SetPath(exepathw.c_str());
+            shellLink->SetArguments(argumentsw.c_str());
+            shellLink->SetDescription(descriptionw.c_str());
+            shellLink->SetIconLocation(iconw.c_str(), 0);
+            
+            IPersistFile* persistFile;
+            
+            result                                  = shellLink->QueryInterface(IID_IPersistFile, (void**)&persistFile);
+            
+            if(SUCCEEDED(result))
+            {
+                result                              = persistFile->Save(startupfilepathw.c_str(), TRUE);
+                success                             = SUCCEEDED(result);
+                persistFile->Release();
+            }
+
+            shellLink->Release();
+        }
+
+        /*---------------------------------------------*\
+        | Uninitialize when done                        |
+        \*---------------------------------------------*/
+        if(weInitialised)
+        {
+            CoUninitialize();
+        }
+    }
+    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[MAX_PATH] = "";
+
+    DWORD count = GetModuleFileNameA(NULL, exepath, MAX_PATH);
+    
+    return(std::string(exepath, (count > 0) ? count : 0));
+}
+
+/*-----------------------------------------------------*\
+| Windows AutoStart Implementation                      |
+| Private Methods                                       |
+\*-----------------------------------------------------*/
+
+void AutoStart::InitAutoStart(std::string name)
+{
+    char startMenuPath[MAX_PATH];
+
+    autostart_name = name;
+
+    /*-------------------------------------------------*\
+    | Get startup applications path                     |
+    \*-------------------------------------------------*/
+    HRESULT result = SHGetFolderPathA(NULL, CSIDL_PROGRAMS, NULL, 0, startMenuPath);
+
+    if(SUCCEEDED(result))
+    {
+        autostart_file = std::string(startMenuPath);
+
+        autostart_file += "\\Startup\\" + autostart_name + ".lnk";
+    }
+    else
+    {
+        autostart_file.clear();
+    }
+}
+
+/*-----------------------------------------------------*\
+| Convert an UTF8 string to a wide Unicode String       |
+| (from wmi.cpp)                                        |
+\*-----------------------------------------------------*/
+std::wstring AutoStart::utf8_decode(const std::string& str)
+{
+    if(str.empty())
+    {
+        return std::wstring();
+    }
+
+    int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), nullptr, 0);
+
+    std::wstring wstrTo(size_needed, 0);
+    
+    MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), &wstrTo[0], size_needed);
+    
+    return(wstrTo);
+}

AutoStart/AutoStart-Windows.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::wstring    utf8_decode(const std::string& str);
+};

AutoStart/AutoStart.cpp

@@ -0,0 +1,16 @@
+#include "AutoStart.h"
+
+/*-----------------------------------------------------*\
+| Common AutoStart Implementation                       |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
+
+std::string AutoStartInterface::GetAutoStartFile()
+{
+    return(autostart_file);
+}
+
+std::string AutoStartInterface::GetAutoStartName()
+{
+    return(autostart_name);
+}

AutoStart/AutoStart.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <string>
+
+struct AutoStartInfo
+{
+    std::string path;
+    std::string args;
+    std::string desc;
+    std::string icon;
+    std::string category;
+};
+
+class AutoStartInterface
+{
+public:
+    virtual bool        DisableAutoStart()                              = 0;
+    virtual bool        EnableAutoStart(AutoStartInfo autostart_info)   = 0;
+    virtual bool        IsAutoStartEnabled()                            = 0;
+    virtual std::string GetExePath()                                    = 0;
+
+    std::string         GetAutoStartFile();
+    std::string         GetAutoStartName();
+
+protected:
+    std::string         autostart_file;
+    std::string         autostart_name;
+};
+
+#ifdef _WIN32
+#include "AutoStart-Windows.h"
+#endif
+
+#ifdef __linux__
+#include "AutoStart-Linux.h"
+#endif
+
+#ifdef __APPLE__
+#include "AutoStart-MacOS.h"
+#endif

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -52,7 +52,12 @@ char* AMDWraithPrismController::GetDeviceName()
 std::string AMDWraithPrismController::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());

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.cpp

@@ -10,6 +10,7 @@
 #include "ASRockPolychromeSMBusController.h"
 #include <cstring>
 #include "dependencies/dmiinfo.h"
+#include "LogManager.h"
 
 using namespace std::chrono_literals;
 
@@ -20,36 +21,39 @@ PolychromeController::PolychromeController(i2c_smbus_interface* bus, polychrome_
 
     DMIInfo dmi;
 
-    unsigned short fw_version    = ReadFirmwareVersion();
-    unsigned char  major_version = fw_version >> 8;
+    device_name =   "ASRock " + dmi.getMainboard();
+    fw_version =    ReadFirmwareVersion();
+    unsigned char   major_version = fw_version >> 8;
 
     /*-----------------------------------------------------*\
     | Determine whether the device uses ASR LED or          |
     | Polychrome protocol by checking firmware version.     |
-    | Versions 1.xx and 2.xx use ASR LED, 3.xx uses         |
-    | Polychrome                                            |
+    | Versions: 1.xx are ASR RGB LED                        |
+    |           2.xx are Polychrome v1                      |
+    |           3.xx are Polychrome v2                      |
     \*-----------------------------------------------------*/
     switch(major_version)
     {
         case ASROCK_TYPE_ASRLED:
-            device_name = "ASRock " + dmi.getMainboard();
+            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:
-            device_name = "ASRock " + dmi.getMainboard();
+            LOG_TRACE("%s Device type is Polychrome v1", ASROCK_CONTROLLER_NAME);
             asrock_type = ASROCK_TYPE_POLYCHROME_V1;
             ReadLEDConfiguration();
             break;
 
         case ASROCK_TYPE_POLYCHROME_V2:
-            device_name = "ASRock " + dmi.getMainboard();
+            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);
             asrock_type = ASROCK_TYPE_UNKNOWN;
             break;
     }
@@ -82,7 +86,6 @@ std::string PolychromeController::GetDeviceName()
 
 std::string PolychromeController::GetFirmwareVersion()
 {
-    unsigned short fw_version    = ReadFirmwareVersion();
     unsigned char  major_version = fw_version >> 8;
     unsigned char  minor_version = fw_version & 0xFF;
 
@@ -93,17 +96,20 @@ unsigned short PolychromeController::ReadFirmwareVersion()
 {
     // The firmware register holds two bytes, so the first read should return 2
     // If not, report invalid firmware revision FFFF
-    if (bus->i2c_smbus_read_byte_data(dev, ASROCK_REG_FIRMWARE_VER) == 0x02)
+    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)
     {
-        std::this_thread::sleep_for(1ms);
-        unsigned char major = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
-        unsigned char minor = bus->i2c_smbus_read_byte(dev);
+        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);
         return((major << 8) | minor);
     }
     else
     {
+        LOG_WARNING("%s Firmware readback failed; Returning 0xFFFF", ASROCK_CONTROLLER_NAME);
         return(0xFFFF);
     }
 }
@@ -114,23 +120,26 @@ void PolychromeController::ReadLEDConfiguration()
     | The LED configuration register holds 6 bytes, so the first read should return 6   |
     | If not, set all zone sizes to zero                                                |
     \*---------------------------------------------------------------------------------*/
-    if (bus->i2c_smbus_read_byte_data(dev, POLYCHROME_REG_LED_CONFIG) == 0x06)
+    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)
     {
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_1]           = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_2]           = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_3]           = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_4]           = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_5]           = bus->i2c_smbus_read_byte(dev);
-        std::this_thread::sleep_for(1ms);
-        zone_led_count[POLYCHROME_ZONE_ADDRESSABLE] = bus->i2c_smbus_read_byte(dev);
+        zone_led_count[POLYCHROME_ZONE_1]           = asrock_zone_count[0];
+        zone_led_count[POLYCHROME_ZONE_2]           = asrock_zone_count[1];
+        zone_led_count[POLYCHROME_ZONE_3]           = asrock_zone_count[2];
+        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]);
     }
     else
     {
+        LOG_WARNING("%s LED config read failed", ASROCK_CONTROLLER_NAME);
         memset(zone_led_count, 0, sizeof(zone_led_count));
     }
 }

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.h

@@ -15,6 +15,9 @@
 
 typedef unsigned char	polychrome_dev_id;
 
+#define ASROCK_CONTROLLER_NAME  "[ASRock Polychrome SMBus Controller]"
+#define ASROCK_DETECTOR_NAME    "[ASRock Polychrome SMBus Detect]"
+
 enum
 {
     ASROCK_TYPE_UNKNOWN                     = 0x00,     /* Unknown Type or Not ASRock Device    */
@@ -209,6 +212,7 @@ public:
     
 private:
     unsigned int            asrock_type;
+    unsigned short          fw_version;
     std::string             device_name;
     unsigned char           active_zone;
     unsigned char           active_mode;

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusControllerDetect.cpp

@@ -1,5 +1,6 @@
 #include "Detector.h"
 #include "ASRockPolychromeSMBusController.h"
+#include "LogManager.h"
 #include "RGBController.h"
 #include "RGBController_ASRockPolychromeSMBus.h"
 #include "i2c_smbus.h"
@@ -53,21 +54,33 @@ void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
     {
         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))
             {
+                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_TRACE("%s Found a known Polychrome device", ASROCK_DETECTOR_NAME);
                     new_controller = new RGBController_Polychrome(new_polychrome);
                     ResourceManager::get()->RegisterRGBController(new_controller);
                 }
                 else
                 {
+                    LOG_TRACE("%s Not a Polychrome device or unknown type", ASROCK_DETECTOR_NAME);
                     delete new_polychrome;
                 }
             }
+            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);
         }
     }
 

Controllers/ASRockPolychromeSMBusController/RGBController_ASRockPolychromeSMBus.cpp

@@ -46,7 +46,7 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
     {
         case ASROCK_TYPE_ASRLED:
             {
-                description = "ASRock ASR LED Device";
+                description = "ASRock ASR RGB LED Device";
 
                 mode Off;
                 Off.name                    = "Off";

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -54,8 +54,13 @@ std::string PolychromeUSBController::GetDeviceName()
 std::string PolychromeUSBController::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());
 

Controllers/AlienwareController/AlienwareController.cpp

@@ -0,0 +1,826 @@
+/*-----------------------------------------*\
+|  AlienwareController.cpp                  |
+|                                           |
+|  Driver for Alienware lighting controller |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/21/2021    |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include "AlienwareController.h"
+#include <cstring>
+#include <cstdint>
+#include <map>
+#include <thread>
+#include <chrono>
+#include <algorithm>
+#include <sstream>
+
+typedef uint32_t alienware_platform_id;
+
+/*---------------------------------------------------------*\
+| Some devices appear to report the wrong number of zones.  |
+| Record that here.                                         |
+\*---------------------------------------------------------*/
+static const std::map<alienware_platform_id, uint8_t> zone_quirks_table =
+{
+    { 0x0C01,   4 }, // Dell G5 SE 5505
+    { 0x0A01,  16 }  // Dell G7 15 7500
+};
+
+/*---------------------------------------------------------*\
+| Add zones for devices here, mapping the platform ID to    |
+| the zone names                                            |
+\*---------------------------------------------------------*/
+static const std::map<alienware_platform_id, std::vector<const char*>> zone_names_table =
+{
+    { 0x0C01,   { "Left",           "Middle",       "Right",        "Numpad"    } },
+    { 0x0A01,   { "Left",           "Center Left",  "Center Right", "Right",
+                  "Light Bar 1",    "Light Bar 2",  "Light Bar 3",
+                  "Light Bar 4",    "Light Bar 5",  "Light Bar 6",
+                  "Light Bar 7",    "Light Bar 8",  "Light Bar 9",
+                  "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } }
+};
+
+static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
+{
+    using namespace std::chrono_literals;
+
+    hid_send_feature_report(dev, usb_buf, usb_buf_size);
+
+    /*-----------------------------------------------------*\
+    | The controller really doesn't like really spammed by  |
+    | too many commands at once... the delay may be command |
+    | dependent also.  Delay for longer if the command is   |
+    | changing animation state                              |
+    \*-----------------------------------------------------*/
+    unsigned char command       = usb_buf[2];
+    unsigned char subcommand    = usb_buf[3];
+
+    if( ( command == ALIENWARE_COMMAND_USER_ANIM                    )
+     && ( ( subcommand == ALIENWARE_COMMAND_USER_ANIM_FINISH_PLAY )
+       || ( subcommand == ALIENWARE_COMMAND_USER_ANIM_FINISH_SAVE ) ) )
+    {
+        std::this_thread::sleep_for(1s);
+    }
+    else
+    {
+        std::this_thread::sleep_for(60ms);
+    }
+}
+
+AlienwareController::AlienwareController(hid_device* dev_handle, const hid_device_info& info, std::string name)
+{
+    HidapiAlienwareReport report;
+
+    dev                 = dev_handle;
+    device_name         = name;
+    location            = info.path;
+
+    /*-----------------------------------------------------*\
+    | Get serial number                                     |
+    \*-----------------------------------------------------*/
+    std::wstring tmp_serial_number;
+    tmp_serial_number   = info.serial_number;
+    serial_number       = std::string(tmp_serial_number.begin(), tmp_serial_number.end());
+
+    /*-----------------------------------------------------*\
+    | Get zone information by checking firmware             |
+    | configuration                                         |
+    \*-----------------------------------------------------*/
+    report              = Report(ALIENWARE_COMMAND_REPORT_CONFIG);
+    alienware_platform_id platform_id = report.data[4] << 8 | report.data[5];
+
+    /*-----------------------------------------------------*\
+    | Get firmware version                                  |
+    \*-----------------------------------------------------*/
+    report              = Report(ALIENWARE_COMMAND_REPORT_FIRMWARE);
+
+    std::stringstream fw_string;
+
+    fw_string << static_cast<unsigned>(report.data[4]) << '.' << static_cast<unsigned>(report.data[5]) << '.' << static_cast<unsigned>(report.data[6]);
+    version             = fw_string.str();
+
+    /*-----------------------------------------------------*\
+    | Check if the device reports the wrong number of zones |
+    \*-----------------------------------------------------*/
+    unsigned number_of_zones = zone_quirks_table.count(platform_id) ? zone_quirks_table.at(platform_id) : report.data[6];
+
+    /*-----------------------------------------------------*\
+    | Initialize Alienware zones                            |
+    \*-----------------------------------------------------*/
+    zones.resize(number_of_zones);
+
+    if(zone_names_table.count(platform_id))
+    {
+        zone_names = zone_names_table.at(platform_id);
+    }
+    else
+    {
+        /*-------------------------------------------------*\
+        | If this is an unknown controller, set the name of |
+        | all regions to "Unknown"                          |
+        \*-------------------------------------------------*/
+        for(size_t i = 0; i < number_of_zones; i++)
+        {
+            zone_names.emplace_back("Unknown");
+        }
+    }
+
+    /*-----------------------------------------------------*\
+    | Set defaults for all zones                            |
+    | It doesn't seem possible to read the controller's     |
+    | current state, hence the default value being set here.|
+    \*-----------------------------------------------------*/
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        zones[zone_idx].color[0]    = 0x000000;
+        zones[zone_idx].color[1]    = 0x000000;
+        zones[zone_idx].mode        = ALIENWARE_MODE_COLOR;
+
+        /*-------------------------------------------------*\
+        | Default period value from ACC                     |
+        \*-------------------------------------------------*/
+        zones[zone_idx].period      = 2000;
+        zones[zone_idx].tempo       = ALIENWARE_TEMPO_MAX;
+        zones[zone_idx].dim         = 0;
+    }
+
+    /*-----------------------------------------------------*\
+    | Initialize dirty flags                                |
+    \*-----------------------------------------------------*/
+    dirty               = true;
+    dirty_dim           = true;
+}
+
+AlienwareController::~AlienwareController()
+{
+
+}
+
+unsigned int AlienwareController::GetZoneCount()
+{
+    return(zones.size());
+}
+
+std::vector<const char*> AlienwareController::GetZoneNames()
+{
+    return(zone_names);
+}
+
+std::string AlienwareController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AlienwareController::GetDeviceName()
+{
+    return(device_name);
+}
+
+std::string AlienwareController::GetSerialString()
+{
+    return(serial_number);
+}
+
+std::string AlienwareController::GetFirmwareVersion()
+{
+    return(version);
+}
+
+AlienwareController::HidapiAlienwareReport AlienwareController::GetResponse()
+{
+    /*-----------------------------------------------------*\
+    | Zero init. This is not updated if there's a problem.  |
+    \*-----------------------------------------------------*/
+    HidapiAlienwareReport result;
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(result.data, 0x00, sizeof(result.data));
+
+
+    hid_get_feature_report(dev, result.data, HIDAPI_ALIENWARE_REPORT_SIZE);
+
+    return(result);
+}
+
+AlienwareController::HidapiAlienwareReport AlienwareController::Report(uint8_t subcommand)
+{
+    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00, per hidapi     |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00] = 0x00;
+    usb_buf[0x01] = 0x03;
+    usb_buf[0x02] = ALIENWARE_COMMAND_REPORT;
+    usb_buf[0x03] = subcommand;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+    return(GetResponse());
+}
+
+AlienwareReport AlienwareController::GetStatus(uint8_t subcommand)
+{
+    HidapiAlienwareReport   data    = Report(subcommand);
+    AlienwareReport         result  = AlienwareReport{};
+
+    /*-----------------------------------------------------*\
+    | Skip first byte, as that's the report number, which   |
+    | should be 0                                           |
+    \*-----------------------------------------------------*/
+    memcpy(result.data, &data.data[1], sizeof(result.data));
+
+    return(result);
+}
+
+bool AlienwareController::Dim(std::vector<uint8_t> zones, double percent)
+{
+    /*-----------------------------------------------------*\
+    | Bail out if there are no zones to update              |
+    \*-----------------------------------------------------*/
+    if(!zones.size())
+    {
+        return(true);
+    }
+
+    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00, per hidapi     |
+    \*-----------------------------------------------------*/
+    uint16_t num_zones  = zones.size();
+
+    usb_buf[0x00]       = 0x00;
+    usb_buf[0x01]       = 0x03;
+    usb_buf[0x02]       = ALIENWARE_COMMAND_DIM;
+    usb_buf[0x03]       = static_cast<uint8_t>(percent);
+    usb_buf[0x04]       = num_zones >> 8;
+    usb_buf[0x05]       = num_zones & 0xFF;
+
+    for(size_t i = 0; i < num_zones; i++)
+    {
+        usb_buf[0x06+i] = zones[i];
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+    HidapiAlienwareReport response = GetResponse();
+
+    /*-----------------------------------------------------*\
+    | For this command, error is if the output equals the   |
+    | input                                                 |
+    \*-----------------------------------------------------*/
+    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
+}
+
+bool AlienwareController::UserAnimation(uint16_t subcommand, uint16_t animation, uint16_t duration)
+{
+    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00 per hidapi      |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]       = 0x00;
+    usb_buf[0x01]       = 0x03;
+    usb_buf[0x02]       = ALIENWARE_COMMAND_USER_ANIM;
+    usb_buf[0x03]       = subcommand >> 8;
+    usb_buf[0x04]       = subcommand & 0xFF;
+    usb_buf[0x05]       = animation >> 8;
+    usb_buf[0x06]       = animation & 0xFF;
+    usb_buf[0x07]       = duration >> 8;
+    usb_buf[0x08]       = duration & 0xFF;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Every subcommand appears to report its result on a    |
+    | different byte                                        |
+    \*-----------------------------------------------------*/
+    HidapiAlienwareReport response = GetResponse();
+
+    /*-----------------------------------------------------*\
+    | The only time the 0x03 byte is zero is if the         |
+    | controller has crashed                                |
+    \*-----------------------------------------------------*/
+    if(response.data[1] == 0)
+    {
+        return(false);
+    }
+
+    switch(subcommand)
+    {
+        case ALIENWARE_COMMAND_USER_ANIM_FINISH_SAVE:
+            return(!response.data[7]);
+        case ALIENWARE_COMMAND_USER_ANIM_FINISH_PLAY:
+            return(!response.data[5]);
+        case ALIENWARE_COMMAND_USER_ANIM_PLAY:
+            return(!response.data[7]);
+        default:
+            return(true);
+    }
+}
+
+bool AlienwareController::SelectZones(const std::vector<uint8_t>& zones)
+{
+    /*-----------------------------------------------------*\
+    | Bail if zones is empty, and return false to indicate  |
+    | nothing has changed                                   |
+    \*-----------------------------------------------------*/
+    if(!zones.size())
+    {
+        return(false);
+    }
+
+    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00, per hidapi     |
+    \*-----------------------------------------------------*/
+    uint16_t num_zones  = zones.size();
+
+    usb_buf[0x00]       = 0x00;
+    usb_buf[0x01]       = 0x03;
+    usb_buf[0x02]       = ALIENWARE_COMMAND_SELECT_ZONES;
+    usb_buf[0x03]       = 1; // loop?
+    usb_buf[0x04]       = num_zones >> 8;
+    usb_buf[0x05]       = num_zones & 0xFF;
+
+    for(size_t i = 0; i < num_zones; i++)
+    {
+        usb_buf[0x06+i] = zones[i];
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+    HidapiAlienwareReport response = GetResponse();
+
+    /*-----------------------------------------------------*\
+    | For this command, error is if the output equals the   |
+    | input                                                 |
+    \*-----------------------------------------------------*/
+    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
+}
+
+bool AlienwareController::ModeAction(uint8_t mode, uint16_t duration, uint16_t tempo, RGBColor color)
+{
+    return(ModeAction(&mode, &duration, &tempo, &color, 1));
+}
+
+bool AlienwareController::ModeAction
+    (
+    const uint8_t*  mode,
+    const uint16_t* duration,
+    const uint16_t* tempo,
+    const RGBColor* color,
+    unsigned        amount
+    )
+{
+    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Amount must be 3 or less, as that's how many          |
+    | subcommands can fit into one report                   |
+    \*-----------------------------------------------------*/
+    if(amount > 3)
+    {
+        return(false);
+    }
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00, per hidapi     |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]               = 0x00;
+    usb_buf[0x01]               = 0x03;
+    usb_buf[0x02]               = ALIENWARE_COMMAND_ADD_ACTION;
+
+    for(unsigned int i = 0; i < amount; i++)
+    {
+        usb_buf[0x03 + (8 * i)] = mode[i];
+        usb_buf[0x04 + (8 * i)] = duration[i] >> 8;
+        usb_buf[0x05 + (8 * i)] = duration[i] & 0xFF;
+        usb_buf[0x06 + (8 * i)] = tempo[i] >> 8;
+        usb_buf[0x07 + (8 * i)] = tempo[i] & 0xFF;
+        usb_buf[0x08 + (8 * i)] = RGBGetRValue(color[i]);
+        usb_buf[0x09 + (8 * i)] = RGBGetGValue(color[i]);
+        usb_buf[0x0A + (8 * i)] = RGBGetBValue(color[i]);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+    HidapiAlienwareReport response = GetResponse();
+
+    /*-----------------------------------------------------*\
+    | For this command, error is if the output equals the   |
+    | input                                                 |
+    \*-----------------------------------------------------*/
+    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
+}
+
+bool AlienwareController::MultiModeAction
+    (
+    const uint8_t*  mode,
+    const uint16_t* duration,
+    const uint16_t* tempo,
+    const RGBColor* color,
+    unsigned        amount
+    )
+{
+    bool         result = true;
+    unsigned int left   = amount;
+
+    while(left && result)
+    {
+        unsigned int tmp_amount;
+
+        tmp_amount          = std::min(left, 3u);
+        result             &= ModeAction(mode, duration, tempo, color, tmp_amount);
+        mode               += tmp_amount;
+        duration           += tmp_amount;
+        tempo              += tmp_amount;
+        color              += tmp_amount;
+        left               -= tmp_amount;
+    }
+
+    return(result);
+}
+
+bool AlienwareController::SetColorDirect(RGBColor color, std::vector<uint8_t> zones)
+{
+    /*-----------------------------------------------------*\
+    | Bail if zones is empty                                |
+    \*-----------------------------------------------------*/
+    if(zones.empty())
+    {
+        return(true);
+    }
+
+    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00, per hidapi     |
+    \*-----------------------------------------------------*/
+    uint16_t num_zones      = zones.size();
+
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x03;
+    usb_buf[0x02]           = ALIENWARE_COMMAND_SET_COLOR;
+    usb_buf[0x03]           = RGBGetRValue(color);
+    usb_buf[0x04]           = RGBGetGValue(color);
+    usb_buf[0x05]           = RGBGetBValue(color);
+    usb_buf[0x06]           = num_zones >> 8;
+    usb_buf[0x07]           = num_zones & 0xFF;
+
+    for(size_t i = 0; i < num_zones; i++)
+    {
+        usb_buf[0x08 + i]   = zones[i];
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+    HidapiAlienwareReport response = GetResponse();
+
+    /*-----------------------------------------------------*\
+    | For this command, error is if the output equals the   |
+    | input                                                 |
+    \*-----------------------------------------------------*/
+    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
+}
+
+bool AlienwareController::Reset()
+{
+    /*-----------------------------------------------------*\
+    | Bail if zones is empty                                |
+    \*-----------------------------------------------------*/
+    if(zones.empty())
+    {
+        return(true);
+    }
+
+    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00, per hidapi     |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]       = 0x00;
+    usb_buf[0x01]       = 0x03;
+    usb_buf[0x02]       = ALIENWARE_COMMAND_RESET;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+    HidapiAlienwareReport response = GetResponse();
+
+    /*-----------------------------------------------------*\
+    | For this command, error is if the output equals the   |
+    | input                                                 |
+    \*-----------------------------------------------------*/
+    return(response.data[1] == 0x03);
+}
+
+void AlienwareController::SetMode(uint8_t zone, uint8_t mode)
+{
+    if(mode != zones[zone].mode)
+    {
+        zones[zone].mode        = mode;
+        dirty                   = true;
+    }
+}
+
+void AlienwareController::SetColor(uint8_t zone, RGBColor color)
+{
+    SetColor(zone, color, zones[zone].color[1]);
+}
+
+void AlienwareController::SetColor(uint8_t zone, RGBColor color1, RGBColor color2)
+{
+    dirty = ((color1 != zones[zone].color[0]) || (color2 != zones[zone].color[1]));
+
+	if(dirty)
+	{
+		zones[zone].color[0] = color1;
+        zones[zone].color[1] = color2;
+	}
+}
+
+void AlienwareController::SetPeriod(uint8_t zone, uint16_t period)
+{
+    if(period != zones[zone].period)
+    {
+        zones[zone].period      = period;
+        dirty                   = true;
+    }
+}
+
+void AlienwareController::SetTempo(uint8_t zone, uint16_t tempo)
+{
+    if(tempo != zones[zone].tempo)
+    {
+        zones[zone].tempo       = tempo;
+        dirty                   = true;
+    }
+}
+
+void AlienwareController::SetDim(uint8_t zone, uint8_t dim)
+{
+    if(dim != zones[zone].dim)
+    {
+        zones[zone].dim         = dim;
+        dirty_dim               = true;
+    }
+}
+
+void AlienwareController::UpdateDim()
+{
+    if(!dirty_dim)
+    {
+        return;
+    }
+
+    /*-----------------------------------------------------*\
+    | Collect all zones that share dim settings, and update |
+    | them together                                         |
+    \*-----------------------------------------------------*/
+    std::map<uint8_t, std::vector<uint8_t>> dim_zone_map;
+
+    for(size_t i = 0; i < zones.size(); i++)
+    {
+        dim_zone_map[zones[i].dim].emplace_back(i);
+    }
+
+    for(std::pair<const uint8_t, std::vector<uint8_t>> &pair : dim_zone_map)
+    {
+        /*-------------------------------------------------*\
+        | Bail on an error...                               |
+        \*-------------------------------------------------*/
+        if(!Dim(pair.second, pair.first))
+        {
+            return;
+        }
+    }
+
+    dirty_dim = false;
+}
+
+bool AlienwareController::UpdateDirect()
+{
+    /*-----------------------------------------------------*\
+    | Collect all zones that share dim settings, and update |
+    | them together                                         |
+    \*-----------------------------------------------------*/
+    std::map<RGBColor, std::vector<uint8_t>> color_zone_map;
+
+    for(size_t i = 0; i < zones.size(); i++)
+    {
+        color_zone_map[zones[i].color[0]].emplace_back(i);
+    }
+
+    for(std::pair<const RGBColor, std::vector<uint8_t>> &pair : color_zone_map)
+    {
+        /*-------------------------------------------------*\
+        | Bail on an error...                               |
+        \*-------------------------------------------------*/
+        if(!SetColorDirect(pair.first, pair.second))
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+static const RGBColor rainbow_colors[4][7] =
+{
+    { 0xFF0000, 0xFFA500, 0xFFFF00, 0x008000, 0x00BFFF, 0x0000FF, 0x800080 },
+    { 0x800080, 0xFF0000, 0xFFA500, 0xFFFF00, 0x008000, 0x00BFFF, 0x0000FF },
+    { 0x0000FF, 0x800080, 0xFF0000, 0xFFA500, 0xFFFF00, 0x008000, 0x00BFFF },
+    { 0x00BFFF, 0x0000FF, 0x800080, 0xFF0000, 0xFFA500, 0xFFFF00, 0x008000 }
+};
+
+void AlienwareController::UpdateMode()
+{
+    /*-----------------------------------------------------*\
+    | If there are no updates, don't bother running this    |
+    \*-----------------------------------------------------*/
+    if(!dirty)
+    {
+        return;
+    }
+
+    bool result = UserAnimation(ALIENWARE_COMMAND_USER_ANIM_NEW, ALIENWARE_COMMAND_USER_ANIM_KEYBOARD, 0);
+
+    if(!result)
+    {
+        return;
+    }
+
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        alienware_zone zone = zones[zone_idx];
+
+        result = SelectZones({static_cast<uint8_t>(zone_idx)});
+
+        if(!result)
+        {
+            return;
+        }
+
+        /*-------------------------------------------------*\
+        | Some modes use 0x07D0 for their duration as sent  |
+        | by AWCC traces, maybe 2000ms?                     |
+        \*-------------------------------------------------*/
+        switch (zone.mode)
+        {
+            case ALIENWARE_MODE_COLOR:
+                result = ModeAction(zone.mode, 2000, ALIENWARE_TEMPO_MAX, zone.color[0]);
+                break;
+
+            case ALIENWARE_MODE_PULSE:
+                result = ModeAction(zone.mode, zone.period, zone.tempo, zone.color[0]);
+                break;
+
+            case ALIENWARE_MODE_MORPH:
+                {
+                    uint8_t  zones[2]   = { zone.mode,              zone.mode     };
+                    uint16_t periods[2] = { zone.period,            zone.period   };
+                    uint16_t tempos[2]  = { zone.tempo,             zone.tempo    };
+                    RGBColor colors[2]  = { zone.color[0],          zone.color[1] };
+
+                    result = MultiModeAction(zones, periods, tempos, colors, 2);
+                }
+                break;
+
+            case ALIENWARE_MODE_SPECTRUM:
+                {
+                    uint8_t  zones[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH };
+                    uint16_t periods[7] = { zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period };
+                    uint16_t tempos[7] = {  zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo };
+
+                    result = MultiModeAction(zones, periods, tempos, rainbow_colors[0], 7);
+                }
+                break;
+
+            case ALIENWARE_MODE_RAINBOW:
+                {
+                    uint8_t  zones[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH };
+                    uint16_t periods[7] = { zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period };
+                    uint16_t tempos[7]  = { zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo };
+
+                    result = MultiModeAction(zones, periods, tempos, rainbow_colors[zone_idx], 7);
+                }
+                break;
+
+            case ALIENWARE_MODE_BREATHING:
+                {
+                    uint8_t  zones[2]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH };
+                    uint16_t periods[2] = { zone.period,            zone.period          };
+                    uint16_t tempos[2]  = { zone.tempo,             zone.tempo           };
+                    RGBColor colors[2]  = { zone.color[0],          0x0                  };
+
+                    result = MultiModeAction(zones, periods, tempos, colors, 2);
+                }
+                break;
+
+            default:
+                result = false;
+        }
+
+        if(!result)
+        {
+            return;
+        }
+    }
+
+    result = UserAnimation(ALIENWARE_COMMAND_USER_ANIM_FINISH_PLAY, ALIENWARE_COMMAND_USER_ANIM_KEYBOARD, 0);
+
+    /*-------------------------------------------------*\
+    | Don't update dirty flag if there's an error       |
+    \*-------------------------------------------------*/
+    if(!result)
+    {
+        return;
+    }
+
+    dirty = false;
+}
+
+void AlienwareController::UpdateController()
+{
+    UpdateMode();
+    UpdateDim();
+}

Controllers/AlienwareController/AlienwareController.h

@@ -0,0 +1,161 @@
+/*-----------------------------------------*\
+|  AlienwareController.h                    |
+|                                           |
+|  Driver for Dell Alienware RGB USB        |
+|  controller                               |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/19/2021    |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>
+
+#pragma once
+
+/*----------------------------------------------------------------------------------------------*\
+| Definitions for Alienware Controller                                                           |
+\*----------------------------------------------------------------------------------------------*/
+
+#define ALIENWARE_REPORT_SIZE               33
+#define HIDAPI_ALIENWARE_REPORT_SIZE        (ALIENWARE_REPORT_SIZE + 1)
+
+enum
+{
+    ALIENWARE_COMMAND_REPORT                = 0x20,     /* Set report type to get               */
+    ALIENWARE_COMMAND_USER_ANIM             = 0x21,     /* Set user animation settings          */
+    ALIENWARE_COMMAND_POWER_ANIM            = 0x22,     /* Set power animation settings         */
+    ALIENWARE_COMMAND_SELECT_ZONES          = 0x23,     /* Select zones to apply actions to     */
+    ALIENWARE_COMMAND_ADD_ACTION            = 0x24,     /* Set actions to apply                 */
+    ALIENWARE_COMMAND_UNKNOWN1              = 0x25,     /* Supposedly set event?                */
+    ALIENWARE_COMMAND_DIM                   = 0x26,     /* Set dim percentage                   */
+    ALIENWARE_COMMAND_SET_COLOR             = 0x27,     /* Unclear (causes color flash)         */
+    ALIENWARE_COMMAND_RESET                 = 0x28,     /* Reset                                */
+    ALIENWARE_COMMAND_ERASE_FLASH           = 0xFF,     /* Erases flash memory on controller    */
+};
+
+enum
+{
+    ALIENWARE_COMMAND_REPORT_FIRMWARE       = 0x00,     /* Get firmware verion                  */
+    ALIENWARE_COMMAND_REPORT_STATUS         = 0x01,     /* Get status                           */
+    ALIENWARE_COMMAND_REPORT_CONFIG         = 0x02,     /* Get firmware config                  */
+    ALIENWARE_COMMAND_REPORT_ANIMATION      = 0x03,     /* Get animation count and last id      */
+    ALIENWARE_COMMAND_REPORT_UNKNOWN1       = 0x04,     /* Get ELC animation by ID              */
+    ALIENWARE_COMMAND_REPORT_UNKNOWN2       = 0x05,     /* Read series???                       */
+    ALIENWARE_COMMAND_REPORT_UNKNOWN3       = 0x06,     /* Get action???                        */
+    ALIENWARE_COMMAND_REPORT_UNKNOWN4       = 0x07,     /* Get Caldera status???                */
+};
+
+enum
+{
+    ALIENWARE_COMMAND_USER_ANIM_NEW         = 0x0001,   /* Start new animation                  */
+    ALIENWARE_COMMAND_USER_ANIM_FINISH_SAVE = 0x0002,   /* Finish and save animation            */
+    ALIENWARE_COMMAND_USER_ANIM_FINISH_PLAY = 0x0003,   /* Finish and play animation            */
+    ALIENWARE_COMMAND_USER_ANIM_REMOVE      = 0x0004,   /* Remove/erase animation               */
+    ALIENWARE_COMMAND_USER_ANIM_PLAY        = 0x0005,   /* Play animation                       */
+    ALIENWARE_COMMAND_USER_ANIM_DEFAULT     = 0x0006,   /* Set default animation                */
+    ALIENWARE_COMMAND_USER_ANIM_STARTUP     = 0x0007,   /* Set startup animation                */
+};
+
+enum
+{
+    ALIENWARE_ANIM_DEFAULT_STARTUP          = 0x0008,   /* Default slot for startup             */
+    ALIENWARE_ANIM_DEFAULT                  = 0x0061,   /* Default slot                         */
+    ALIENWARE_COMMAND_USER_ANIM_KEYBOARD    = 0xFFFF,   /* Non-saved animation slot             */
+};
+
+enum
+{
+    ALIENWARE_MODE_COLOR                    = 0x00,     /* Action to set color mode             */
+    ALIENWARE_MODE_PULSE                    = 0x01,     /* Action to set pulse mode             */
+    ALIENWARE_MODE_MORPH                    = 0x02,     /* Action to set morph mode             */
+    ALIENWARE_MODE_SPECTRUM,                            /* Abitrary code for spectrum mode      */
+    ALIENWARE_MODE_RAINBOW,                             /* Arbitrary code for rainbow wave mode */
+    ALIENWARE_MODE_BREATHING,                           /* Arbitrary code for rainbow wave mode */
+};
+
+enum
+{
+    ALIENWARE_TEMPO_MIN                     = 0x0064,   /* Min tempo (as used by AWCC)          */
+    ALIENWARE_TEMPO_MAX                     = 0x00FA,   /* Max tempo (as used by AWCC)          */
+    ALIENWARE_TEMPO_SPECTRUM                = 0x000F,   /* Used by Spectrum mode                */
+};
+
+enum
+{
+    ALIENWARE_DURATION_LONG                 = 0x09C4,   /* Min tempo (as used by AWCC)          */
+    ALIENWARE_DURATION_MED                  = 0x05DC,   /* Max tempo (as used by AWCC)          */
+    ALIENWARE_DURATION_SHORT                = 0x01F3,   /* Max tempo (as used by AWCC)          */
+    ALIENWARE_DURATION_SPECTRUM             = 0x01AC,   /* Used by Spectrum mode                */
+};
+
+typedef struct
+{
+    unsigned char           data[ALIENWARE_REPORT_SIZE];
+} AlienwareReport;
+
+class AlienwareController
+{
+public:
+    AlienwareController(hid_device* dev_handle, const hid_device_info& info, std::string name);
+    ~AlienwareController();
+
+    std::string                 GetSerialString();
+    std::string                 GetDeviceLocation();
+    std::string                 GetDeviceName();
+    std::string                 GetFirmwareVersion();
+    unsigned                    GetZoneCount();
+    std::vector<const char*>    GetZoneNames();
+
+    void                        SetColor(uint8_t zone, RGBColor color);
+    void                        SetColor(uint8_t zone, RGBColor color1, RGBColor color2);
+    void                        SetMode(uint8_t zone, uint8_t mode);
+    void                        SetPeriod(uint8_t zone, uint16_t period);
+    void                        SetTempo(uint8_t zone, uint16_t tempo);
+    void                        SetDim(uint8_t zone, uint8_t dim);
+    AlienwareReport             GetStatus(uint8_t subcommand);
+
+    void                        UpdateDim();
+    void                        UpdateMode();
+    void                        UpdateController();
+
+protected:
+    hid_device* dev;
+
+private:
+    typedef struct
+    {
+        RGBColor                color[2];
+        uint8_t                 mode;
+        uint16_t                period;
+        uint16_t                tempo;
+        uint8_t                 dim;
+    } alienware_zone;
+
+    typedef struct
+    {
+        unsigned char           data[HIDAPI_ALIENWARE_REPORT_SIZE];
+    } HidapiAlienwareReport;
+
+    std::string                 device_name;
+    std::string                 location;
+    std::vector<alienware_zone> zones;
+    std::string                 serial_number;
+    std::string                 version;
+    std::vector<const char*>    zone_names;
+    bool                        dirty;
+    bool                        dirty_dim;
+
+    HidapiAlienwareReport       GetResponse();
+    HidapiAlienwareReport       Report(uint8_t subcommand);
+
+    bool                        Dim(std::vector<uint8_t> zones, double percent);
+    bool                        UserAnimation(uint16_t subcommand, uint16_t animation, uint16_t duration);
+    bool                        SelectZones(const std::vector<uint8_t>& zones);
+    bool                        ModeAction(uint8_t mode, uint16_t duration, uint16_t tempo, RGBColor color);
+    bool                        ModeAction(const uint8_t *mode, const uint16_t *duration, const uint16_t *tempo, const RGBColor *color, unsigned amount);
+    bool                        MultiModeAction(const uint8_t *mode, const uint16_t *duration, const uint16_t *tempo, const RGBColor *color, unsigned amount);
+    bool                        SetColorDirect(RGBColor color, std::vector<uint8_t> zones);
+    bool                        UpdateDirect();
+    bool                        Reset();
+};

Controllers/AlienwareController/AlienwareControllerDetect.cpp

@@ -0,0 +1,29 @@
+#include "Detector.h"
+#include "AlienwareController.h"
+#include "RGBController.h"
+#include "RGBController_Alienware.h"
+
+/*---------------------------------------------------------*\
+| Alienware vendor ID                                       |
+\*---------------------------------------------------------*/
+#define ALIENWARE_VID                               0x187C
+
+/*---------------------------------------------------------*\
+| Alienware product ID                                      |
+\*---------------------------------------------------------*/
+#define ALIENWARE_G_SERIES_PID                         0x0550
+
+void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AlienwareController*     controller     = new AlienwareController(dev, *info, name);
+        RGBController_Alienware* rgb_controller = new RGBController_Alienware(controller);
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID);

Controllers/AlienwareController/RGBController_Alienware.cpp

@@ -0,0 +1,278 @@
+/*-----------------------------------------*\
+|  RGBController_Alienware.cpp              |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Alienware USB Driver                     |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/19/2021    |
+\*-----------------------------------------*/
+
+#include "RGBController_Alienware.h"
+
+#include <thread>
+#include <chrono>
+
+RGBController_Alienware::RGBController_Alienware(AlienwareController* alienware_ptr)
+{
+    alienware                   = alienware_ptr;
+
+    name                        = alienware->GetDeviceName();
+    vendor                      = "Alienware Corporation";
+    type                        = DEVICE_TYPE_KEYBOARD;
+    description                 = "Alienware USB Device";
+    location                    = alienware->GetDeviceLocation();
+    serial                      = alienware->GetSerialString();
+    version                     = alienware->GetFirmwareVersion();
+
+    mode Color;
+    Color.name                 = "Static";
+    Color.value                = ALIENWARE_MODE_COLOR;
+    Color.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Color.color_mode           = MODE_COLORS_PER_LED;
+    Color.colors_min           = 1;
+    Color.colors_max           = 1;
+    Color.brightness_min       = 100;
+    Color.brightness_max       = 0;
+    Color.brightness           = 0;
+    modes.push_back(Color);
+
+    mode Pulse;
+    Pulse.name                 = "Flashing";
+    Pulse.value                = ALIENWARE_MODE_PULSE;
+    Pulse.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Pulse.color_mode           = MODE_COLORS_PER_LED;
+    Pulse.colors_min           = 1;
+    Pulse.colors_max           = 1;
+    Pulse.speed_min            = ALIENWARE_TEMPO_MIN;
+    Pulse.speed_max            = ALIENWARE_TEMPO_MAX;
+    Pulse.speed                = ALIENWARE_TEMPO_MIN;
+    Pulse.brightness_min       = 100;
+    Pulse.brightness_max       = 0;
+    Pulse.brightness           = 0;
+    modes.push_back(Pulse);
+
+    mode Morph;
+    Morph.name                 = "Morph";
+    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_max           = Morph.colors_min;
+    Morph.colors.resize(Morph.colors_max);
+    Morph.speed_min            = ALIENWARE_TEMPO_MIN;
+    Morph.speed_max            = ALIENWARE_TEMPO_MAX;
+    Morph.speed                = ALIENWARE_TEMPO_MIN;
+    Morph.brightness_min       = 100;
+    Morph.brightness_max       = 0;
+    Morph.brightness           = 0;
+    modes.push_back(Morph);
+
+    mode Spectrum;
+    Spectrum.name              = "Spectrum Cycle";
+    Spectrum.value             = ALIENWARE_MODE_SPECTRUM;
+    Spectrum.flags             = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Spectrum.color_mode        = MODE_COLORS_NONE;
+    Spectrum.speed_min         = ALIENWARE_TEMPO_SPECTRUM;
+    Spectrum.speed_max         = ALIENWARE_TEMPO_MAX;
+    Spectrum.speed             = ALIENWARE_TEMPO_SPECTRUM;
+    Spectrum.brightness_min    = 100;
+    Spectrum.brightness_max    = 0;
+    Spectrum.brightness        = 0;
+    modes.push_back(Spectrum);
+
+    mode Rainbow;
+    Rainbow.name               = "Rainbow Wave";
+    Rainbow.value              = ALIENWARE_MODE_RAINBOW;
+    Rainbow.flags              = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Rainbow.color_mode         = MODE_COLORS_NONE;
+    Rainbow.speed_min          = ALIENWARE_TEMPO_SPECTRUM;
+    Rainbow.speed_max          = ALIENWARE_TEMPO_MAX;
+    Rainbow.speed              = ALIENWARE_TEMPO_SPECTRUM;
+    Rainbow.brightness_min     = 100;
+    Rainbow.brightness_max     = 0;
+    Rainbow.brightness         = 0;
+    modes.push_back(Rainbow);
+
+    mode Breathing;
+    Breathing.name             = "Breathing";
+    Breathing.value            = ALIENWARE_MODE_BREATHING;
+    Breathing.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode       = MODE_COLORS_PER_LED;
+    Breathing.colors_min       = 1;
+    Breathing.colors_max       = 1;
+    Breathing.speed_min        = ALIENWARE_TEMPO_MIN;
+    Breathing.speed_max        = ALIENWARE_TEMPO_MAX;
+    Breathing.speed            = ALIENWARE_TEMPO_MIN;
+    Breathing.brightness_min   = 100;
+    Breathing.brightness_max   = 0;
+    Breathing.brightness       = 0;
+    modes.push_back(Breathing);
+
+    SetupZones();
+
+    alienware->UpdateDim();
+}
+
+void RGBController_Alienware::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    std::vector<const char*> zone_names = alienware->GetZoneNames();
+
+    for(unsigned int zone_idx = 0; zone_idx < alienware->GetZoneCount(); zone_idx++)
+    {
+        zone new_zone;
+
+        new_zone.name       = zone_names[zone_idx];
+        new_zone.type       = ZONE_TYPE_SINGLE;
+        new_zone.leds_min   = 1;
+        new_zone.leds_max   = 1;
+        new_zone.leds_count = 1;
+        new_zone.matrix_map = nullptr;
+
+        zones.emplace_back(new_zone);
+    }
+
+    for(unsigned int led_idx = 0; led_idx < zones.size(); led_idx++)
+    {
+        led new_led;
+        
+        new_led.name        = zones[led_idx].name + std::string(" LED");
+
+        leds.emplace_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_Alienware::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_Alienware::DeviceUpdateLEDs()
+{
+    DeviceUpdateMode();
+}
+
+void RGBController_Alienware::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_Alienware::UpdateSingleLED(int led)
+{
+    UpdateZoneLEDs(led);
+}
+
+void RGBController_Alienware::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+static bool modes_eq(const mode& mode1, const mode& mode2)
+{
+    return( ( mode1.name           == mode2.name       )
+         && ( mode1.value          == mode2.value      )
+         && ( mode1.flags          == mode2.flags      )
+         && ( mode1.speed_min      == mode2.speed_min  )
+         && ( mode1.speed_max      == mode2.speed_max  )
+         && ( mode1.colors_min     == mode2.colors_min )
+         && ( mode1.colors_max     == mode2.colors_max )
+         && ( mode1.speed          == mode2.speed      )
+         && ( mode1.direction      == mode2.direction  )
+         && ( mode1.color_mode     == mode2.color_mode )
+         && ( mode1.colors         == mode2.colors     )
+         && ( mode1.brightness     == mode2.brightness )
+         && ( mode1.brightness_min == mode2.brightness_min )
+         && ( mode1.brightness_max == mode2.brightness_max ) );
+}
+
+void RGBController_Alienware::DeviceUpdateMode()
+{
+    /*---------------------------------------------------------*\
+    | Copy mode to get the current state-- this is racy, as the |
+    | UI thread can be actively modifying this variable         |
+    \*---------------------------------------------------------*/
+    int  current_mode_idx = active_mode;
+    mode current_mode     = modes[current_mode_idx];
+
+    bool done             = false;
+
+    while(!done)
+    {
+        /*-----------------------------------------------------*\
+        | Setup state per zone                                  |
+        \*-----------------------------------------------------*/
+        for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+        {
+            zone current_zone = zones[zone_idx];
+
+            /*-------------------------------------------------*\
+            | Some modes use 2000ms (0x07D0) for their duration,|
+            | per traces                                        |
+            \*-------------------------------------------------*/
+            uint16_t period = 0x07d0;
+
+            alienware->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);
+                    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);
+                    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);
+                    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);
+                    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);
+                    break;
+            }
+        }
+
+        /*-----------------------------------------------------*\
+        | Due to rate-limiting, this can take more than one     |
+        | second to execute                                     |
+        \*-----------------------------------------------------*/
+        alienware->UpdateController();
+
+        /*-----------------------------------------------------*\
+        | Re-run update if there's anything that's changed from |
+        | under us...                                           |
+        \*-----------------------------------------------------*/
+        int  new_current_mode_idx = active_mode;
+        mode new_current_mode     = modes[current_mode_idx];
+
+        done                      = (current_mode_idx == new_current_mode_idx && modes_eq(new_current_mode, current_mode));
+        current_mode_idx          = new_current_mode_idx;
+        current_mode              = new_current_mode;
+    }
+}

Controllers/AlienwareController/RGBController_Alienware.h

@@ -0,0 +1,37 @@
+/*-----------------------------------------*\
+|  RGBController_Alienware.h                |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Alienware RGB USB Driver                 |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/19/2021    |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AlienwareController.h"
+
+#include <chrono>
+
+class RGBController_Alienware : public RGBController
+{
+public:
+    RGBController_Alienware(AlienwareController* alienware_ptr);
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+    void        SetCustomMode();
+
+private:
+    AlienwareController*                    alienware;
+    std::chrono::steady_clock::time_point   last_packet_ts;
+};

Controllers/AnnePro2Controller/AnnePro2Controller.cpp

@@ -0,0 +1,122 @@
+/*-----------------------------------------*\
+|  AnnePro2Controller.cpp                   |
+|                                           |
+|  Driver for Obins Lab AnnePro2 keyboard   |
+|                                           |
+|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
+\*-----------------------------------------*/
+
+#include "AnnePro2Controller.h"
+
+using namespace std::chrono_literals;
+
+AnnePro2Controller::AnnePro2Controller(hid_device* dev_handle, const char* path) 
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+AnnePro2Controller::~AnnePro2Controller() 
+{
+    hid_close(dev);
+}
+
+std::string AnnePro2Controller::GetDeviceLocation() 
+{
+    return("HID: " + location);
+}
+
+std::string AnnePro2Controller::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 AnnePro2Controller::SendDirect(unsigned char frame_count, unsigned char * frame_data) 
+{
+    /*-------------------------------------------------------------*\
+    | Reverse engineered by https://github.com/manualmanul/Annemone |
+    \*-------------------------------------------------------------*/
+
+    const unsigned char hid_cmd_service_data_length                             = 4;
+    const unsigned char hid_cmd_service_data[hid_cmd_service_data_length]       = {0, 123, 16, 65};
+
+    const unsigned char hid_cmd_static_message_length                           = 3;
+    const unsigned char hid_cmd_static_message[hid_cmd_static_message_length]   = {0, 0, 125};
+
+    const unsigned char hid_cmd_command_info_length                             = 3;
+    const unsigned char hid_cmd_command_info[hid_cmd_command_info_length]       = {32, 3, 255};
+
+    const unsigned char real_command_info_length                                = hid_cmd_command_info_length + 1;
+    const unsigned char max_hid_length                                          = 64;
+
+    const unsigned char max_command_length                                      = max_hid_length - hid_cmd_service_data_length - 2 - hid_cmd_static_message_length;
+    const unsigned char max_message_length                                      = max_command_length - real_command_info_length;
+    const unsigned char messages_to_send_amount                                 = frame_count / max_message_length + 1;
+    const unsigned char val_1                                                   = frame_count % max_message_length;
+    const unsigned char val_2                                                   = (0 == val_1) ? max_message_length : val_1;
+
+    unsigned char hid_command[max_hid_length];
+
+    unsigned char led_data = 0;
+
+    for(unsigned char p = 0; p < messages_to_send_amount; p++)
+    {
+        const unsigned char e = (messages_to_send_amount << 4) + p;
+        const unsigned char a = ((messages_to_send_amount - 1) == p) ? val_2 + real_command_info_length : max_message_length + real_command_info_length;
+        
+        /*---------------------------------------------------------*\
+        | Service data                                              |
+        \*---------------------------------------------------------*/
+        hid_command[0] = hid_cmd_service_data[0];
+        hid_command[1] = hid_cmd_service_data[1];
+        hid_command[2] = hid_cmd_service_data[2];
+        hid_command[3] = hid_cmd_service_data[3];
+
+        hid_command[4] = e;
+        hid_command[5] = a;
+
+        /*---------------------------------------------------------*\
+        | Static message                                            |
+        \*---------------------------------------------------------*/
+        hid_command[6] = hid_cmd_static_message[0];
+        hid_command[7] = hid_cmd_static_message[1];
+        hid_command[8] = hid_cmd_static_message[2];
+
+        /*---------------------------------------------------------*\
+        | Command info                                              |
+        \*---------------------------------------------------------*/
+        hid_command[9] = hid_cmd_command_info[0];
+        hid_command[10] = hid_cmd_command_info[1];
+        hid_command[11] = hid_cmd_command_info[2];
+
+        hid_command[12] = 2;
+
+        /*---------------------------------------------------------*\
+        | LED data                                                  |
+        \*---------------------------------------------------------*/
+        for(uint8_t i = 0; i < max_message_length; i++)
+        {
+            hid_command[13 + i] = frame_data[led_data];
+            led_data++;
+        }
+
+        hid_write(dev, hid_command, max_hid_length);
+
+        /*---------------------------------------------------------*\
+        | Needed due to Anne Pro 2 ignoring commands when they're   |
+        | sent faster than 50ms apart from each other.              |
+        \*---------------------------------------------------------*/
+        std::this_thread::sleep_for(50ms);
+    }
+}

Controllers/AnnePro2Controller/AnnePro2Controller.h

@@ -0,0 +1,36 @@
+/*-----------------------------------------*\
+|  AnnePro2Controller.h                     |
+|                                           |
+|  Driver for Obins Lab AnnePro2 keyboard   |
+|                                           |
+|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+
+#include <string>
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+class AnnePro2Controller
+{
+public:
+    AnnePro2Controller(hid_device* dev_handle, const char* path);
+    ~AnnePro2Controller();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void SendDirect
+        (
+        unsigned char       frame_count,
+        unsigned char *     frame_data
+        );
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+};

Controllers/AnnePro2Controller/AnnePro2ControllerDetect.cpp

@@ -0,0 +1,36 @@
+#include "Detector.h"
+#include "AnnePro2Controller.h"
+#include "RGBController.h"
+#include "RGBController_AnnePro2.h"
+#include <hidapi/hidapi.h>
+
+#define ANNE_PRO_2_VID 0x04D9
+#define ANNE_PRO_2_PID_1 0x8008
+#define ANNE_PRO_2_PID_2 0x8009
+#define ANNE_PRO_2_PID_3 0xA292
+#define ANNE_PRO_2_PID_4 0xA293
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAnnePro2Controllers                                                              *
+*                                                                                          *
+*       Tests the USB address to see if an Obins Lab AnnePro2 keyboard exists there.       *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
+    {
+        AnnePro2Controller*     controller     = new AnnePro2Controller(dev, info->path);
+        RGBController_AnnePro2* rgb_controller = new RGBController_AnnePro2(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_1, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_2, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_3, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_4, 1);

Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp

@@ -0,0 +1,235 @@
+/*-----------------------------------------*\
+|  RGBController_AnnePro2.cpp               |
+|                                           |
+|  Generic RGB Interface for Obins Lab      |
+|  AnnePro2 keyboard                        |
+|                                           |
+|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
+\*-----------------------------------------*/
+
+#include "RGBController_AnnePro2.h"
+
+#define NA              0xFFFFFFFF
+#define LED_REAL_COUNT  (5*14)
+#define LED_COUNT       (LED_REAL_COUNT - 9)
+
+static unsigned int matrix_map[5][14] =
+    { { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13 },
+      { 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27 },
+      { 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, NA },
+      { 41, NA, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, NA }, 
+      { 53, NA, 54, 55, NA, NA, 56, NA, NA, 57, 58, 59, 60, NA } };
+
+static const char* zone_names[] =
+{
+    "Keyboard",
+};
+
+static zone_type zone_types[] =
+{
+    ZONE_TYPE_MATRIX
+};
+
+static const unsigned int zone_sizes[] =
+{
+    LED_COUNT,
+};
+
+typedef struct
+{
+    const char *        name;
+    const unsigned char idx;
+} led_type;
+
+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      },
+};
+
+RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* annepro2_ptr) 
+{
+    annepro2    = annepro2_ptr;
+
+    name        = "Anne Pro 2";
+    vendor      = "Obinslab";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "Obinslab Anne Pro 2 Device";
+    location    = annepro2->GetDeviceLocation();
+    serial      = annepro2->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_AnnePro2::~RGBController_AnnePro2() 
+{
+    delete annepro2;
+}
+
+void RGBController_AnnePro2::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 = 5;
+            new_zone.matrix_map->width  = 14;
+            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_AnnePro2::ResizeZone(int /*zone*/, int /*new_size*/) 
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AnnePro2::DeviceUpdateLEDs() 
+{
+    const unsigned char frame_buf_length = LED_REAL_COUNT * 3;
+    unsigned char frame_buf[frame_buf_length];
+
+    /*---------------------------------------------------------*\
+    | TODO: Send packets with multiple LED frames               |
+    \*---------------------------------------------------------*/
+    std::size_t led_real_idx = 0;
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        frame_buf[(led_real_idx * 3) + 0] = RGBGetRValue(colors[led_idx]);
+        frame_buf[(led_real_idx * 3) + 1] = RGBGetGValue(colors[led_idx]);
+        frame_buf[(led_real_idx * 3) + 2] = RGBGetBValue(colors[led_idx]);
+
+        if(led_idx == 40 || led_idx == 41 || led_idx == 52 || led_idx == 53 || led_idx == 60)
+        {
+            led_real_idx++;
+        }
+        else if(led_idx == 55 || led_idx == 56)
+        {
+            led_real_idx++;
+            led_real_idx++;
+        }
+
+        led_real_idx++;
+    }
+
+    annepro2->SendDirect(frame_buf_length, frame_buf);
+}
+
+void RGBController_AnnePro2::UpdateZoneLEDs(int /*zone*/) 
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AnnePro2::UpdateSingleLED(int /*led*/) 
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AnnePro2::SetCustomMode() 
+{
+    active_mode = 0;
+}
+
+void RGBController_AnnePro2::DeviceUpdateMode() 
+{
+    
+}

Controllers/AnnePro2Controller/RGBController_AnnePro2.h

@@ -0,0 +1,32 @@
+/*-----------------------------------------*\
+|  RGBController_AnnePro2.h                 |
+|                                           |
+|  Generic RGB Interface for Obins Lab      |
+|  AnnePro2 keyboard                        |
+|                                           |
+|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AnnePro2Controller.h"
+
+class RGBController_AnnePro2 : public RGBController
+{
+public:
+    RGBController_AnnePro2(AnnePro2Controller* annepro2_ptr);
+    ~RGBController_AnnePro2();
+
+    void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    AnnePro2Controller*   annepro2;
+};

Controllers/AsusAuraCoreController/AsusAuraCoreController.cpp

@@ -40,7 +40,12 @@ std::string AuraCoreController::GetDeviceLocation()
 std::string AuraCoreController::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());

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -33,17 +33,28 @@ typedef struct
 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,                     0x29,   "ASUS GTX 1070 Strix OC"                    },
+    { 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"               }
 };  
 

Controllers/AsusAuraSMBusController/AsusAuraSMBusController.cpp

@@ -194,38 +194,38 @@ unsigned char AuraSMBusController::GetLEDBlue(unsigned int led)
     return(AuraRegisterRead(direct_reg + ( 3 * led ) + 1));
 }
 
-void AuraSMBusController::SetAllColorsDirect(RGBColor* colors)
+void AuraSMBusController::SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue)
 {
-    unsigned char* color_buf = new unsigned char[led_count * 3];
+    unsigned char* colors = new unsigned char[led_count * 3];
 
     for (unsigned int i = 0; i < (led_count * 3); i += 3)
     {
-        color_buf[i + 0] = RGBGetRValue(colors[i / 3]);
-        color_buf[i + 1] = RGBGetBValue(colors[i / 3]);
-        color_buf[i + 2] = RGBGetGValue(colors[i / 3]);
+        colors[i + 0] = red;
+        colors[i + 1] = blue;
+        colors[i + 2] = green;
     }
 
-    AuraRegisterWriteBlock(direct_reg, color_buf, led_count * 3);
+    AuraRegisterWriteBlock(direct_reg, colors, led_count * 3);
 
-    delete color_buf;
+    delete[] colors;
 }
 
-void AuraSMBusController::SetAllColorsEffect(RGBColor* colors)
+void AuraSMBusController::SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
 {
-    unsigned char* color_buf = new unsigned char[led_count * 3];
+    unsigned char* colors = new unsigned char[led_count * 3];
 
     for (unsigned int i = 0; i < (led_count * 3); i += 3)
     {
-        color_buf[i + 0] = RGBGetRValue(colors[i / 3]);
-        color_buf[i + 1] = RGBGetBValue(colors[i / 3]);
-        color_buf[i + 2] = RGBGetGValue(colors[i / 3]);
+        colors[i + 0] = red;
+        colors[i + 1] = blue;
+        colors[i + 2] = green;
     }
 
-    AuraRegisterWriteBlock(effect_reg, color_buf, led_count * 3);
-
+    AuraRegisterWriteBlock(effect_reg, colors, led_count * 3);
+    
     AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
 
-    delete[] color_buf;
+    delete[] colors;
 }
 
 void AuraSMBusController::SetDirect(unsigned char direct)

Controllers/AsusAuraSMBusController/AsusAuraSMBusController.h

@@ -7,8 +7,6 @@
 |  Adam Honse (CalcProgrammer1) 8/19/2018   |
 \*-----------------------------------------*/
 
-#include "RGBController.h"
-
 #include <string>
 #include "i2c_smbus.h"
 
@@ -89,8 +87,8 @@ public:
     unsigned char GetLEDRed(unsigned int led);
     unsigned char GetLEDGreen(unsigned int led);
     unsigned char GetLEDBlue(unsigned int led);
-    void          SetAllColorsDirect(RGBColor* colors);
-    void          SetAllColorsEffect(RGBColor* colors);
+    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);

Controllers/AsusAuraSMBusController/AsusAuraSMBusControllerDetect.cpp

@@ -89,7 +89,7 @@ bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char addr
 {
     bool pass = false;
 
-    LOG_DEBUG("Testing address %02X for Aura SMBus controller", address);
+    LOG_DEBUG("[Aura SMBus] looking for devices at 0x%02X...", address);
 
     int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
 
@@ -97,7 +97,7 @@ bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char addr
     {
         pass = true;
 
-        LOG_DEBUG("Detected an I2C device at address %02X, testing register range for Aura SMBus", address);
+        LOG_DEBUG("[Aura SMBus] Detected an I2C device at address %02X, testing register range", address);
 
         for (int i = 0xA0; i < 0xB0; i++)
         {
@@ -105,7 +105,7 @@ bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char addr
 
             if (res != (i - 0xA0))
             {
-                LOG_DEBUG("Detection failed testing register %02X.  Expected %02X, got %02X.", i, (i - 0xA0), res);
+                LOG_VERBOSE("[Aura SMBus] Detection failed testing register %02X.  Expected %02X, got %02X.", i, (i - 0xA0), res);
 
                 pass = false;
             }
@@ -113,7 +113,7 @@ bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char addr
 
         if(pass)
         {
-            LOG_DEBUG("Detection successful, address %02X appears to be an Aura SMBus controller", address);
+            LOG_VERBOSE("[Aura SMBus] Detection successful, address %02X", address);
         }
     }
 
@@ -143,7 +143,7 @@ void DetectAsusAuraSMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busse
 
         IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            LOG_DEBUG("Remapping Aura SMBus RAM modules on 0x77");
+            LOG_DEBUG("[ASUS Aura SMBus DRAM] Remapping Aura SMBus RAM modules on 0x77");
 
             for (unsigned int slot = 0; slot < 8; slot++)
             {
@@ -151,7 +151,7 @@ void DetectAsusAuraSMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busse
 
                 if (res < 0)
                 {
-                    LOG_DEBUG("No device detected at address 0x77, aborting remap");
+                    LOG_DEBUG("[ASUS Aura SMBus DRAM] No device detected at 0x77, aborting remap");
 
                     break;
                 }
@@ -162,7 +162,7 @@ void DetectAsusAuraSMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busse
 
                     if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
                     {
-                        LOG_DEBUG("Testing address %02X to see if there is a device there", aura_ram_addresses[address_list_idx]);
+                        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);
                     }
@@ -174,7 +174,7 @@ void DetectAsusAuraSMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busse
 
                 if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
                 {
-                    LOG_DEBUG("Remapping slot %d to address %02X", slot, aura_ram_addresses[address_list_idx]);
+                    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));
@@ -199,13 +199,8 @@ void DetectAsusAuraSMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busse
 
 void DetectAsusAuraSMBusMotherboardControllers(std::vector<i2c_smbus_interface*> &busses)
 {
-    AuraSMBusController* new_aura;
-    RGBController_AuraSMBus* new_controller;
-
     for (unsigned int bus = 0; bus < busses.size(); bus++)
     {
-        int address_list_idx = -1;
-
         // Add Aura-enabled motherboard controllers
         IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {

Controllers/AsusAuraSMBusController/RGBController_AsusAuraSMBus.cpp

@@ -58,13 +58,20 @@ int RGBController_AuraSMBus::GetDeviceMode()
 
 void RGBController_AuraSMBus::DeviceUpdateLEDs()
 {
-    if(GetMode() == 0)
+    for(std::size_t led = 0; led < colors.size(); led++)
     {
-        aura->SetAllColorsDirect(&colors[0]);
-    }
-    else
-    {
-        aura->SetAllColorsEffect(&colors[0]);
+        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);
+        }
     }
 }
 

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.cpp

@@ -0,0 +1,133 @@
+/*-----------------------------------------*\
+|  AsusAuraHeadsetStandController.cpp       |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Mola19 06/04/2021                        |
+\*-----------------------------------------*/
+
+#include "AsusAuraHeadsetStandController.h"
+
+#include <cstring>
+
+AuraHeadsetStandController::AuraHeadsetStandController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+AuraHeadsetStandController::~AuraHeadsetStandController()
+{
+	hid_close(dev);
+}
+
+std::string AuraHeadsetStandController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AuraHeadsetStandController::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 AuraHeadsetStandController::UpdateLeds
+    (
+    std::vector<RGBColor>    colors
+    )
+{
+    unsigned char usb_buf_0[365];
+
+    memset(usb_buf_0, 0x00, sizeof(usb_buf_0));
+
+    usb_buf_0[0x00]   = 0x00;
+    usb_buf_0[0x01]   = 0xC0;
+    usb_buf_0[0x02]   = 0x81;
+    usb_buf_0[0x03]   = 0x00;
+    usb_buf_0[0x04]   = 0x00;
+
+    for(unsigned int i = 0; i < 60; i += 4)
+    {
+        usb_buf_0[5 + i]   = 0x00;
+        usb_buf_0[6 + i]   = RGBGetRValue(colors[i / 4]);
+        usb_buf_0[7 + i]   = RGBGetGValue(colors[i / 4]);
+        usb_buf_0[8 + i]   = RGBGetBValue(colors[i / 4]);
+    }
+
+    hid_write(dev, usb_buf_0, 65);
+
+    unsigned char usb_buf_1[65];
+
+    memset(usb_buf_1, 0x00, sizeof(usb_buf_1));
+
+    usb_buf_1[0x00]   = 0x00;
+    usb_buf_1[0x01]   = 0xC0;
+    usb_buf_1[0x02]   = 0x81;
+    usb_buf_1[0x03]   = 0x01;
+    usb_buf_1[0x04]   = 0x00;
+
+    for(unsigned int i = 0; i < 12; i += 4)
+    {
+        usb_buf_1[5 + i]   = 0x00;
+        usb_buf_1[6 + i]   = RGBGetRValue(colors[(i / 4) + 15]);
+        usb_buf_1[7 + i]   = RGBGetGValue(colors[(i / 4) + 15]);
+        usb_buf_1[8 + i]   = RGBGetBValue(colors[(i / 4) + 15]);
+    }
+
+    hid_write(dev, usb_buf_1, 65);
+}
+
+void AuraHeadsetStandController::UpdateDevice
+    (
+    unsigned char   mode,
+    unsigned char   red,
+    unsigned char   grn,
+    unsigned char   blu,
+    unsigned char   speed,
+    bool            save
+    )
+{
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x00;
+    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]   = 0x04;
+    usb_buf[0x08]   = 0x00;
+    usb_buf[0x09]   = 0x00;
+    usb_buf[0x0a]   = red;
+    usb_buf[0x0b]   = grn;
+    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);
+    }
+}

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.h

@@ -0,0 +1,59 @@
+/*-----------------------------------------*\
+|  AsusAuraHeadsetStandController.h         |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Mola19 06/04/2021                        |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    AURA_HEADSET_STAND_ZONE_UNDERGLOW   = 0,
+    AURA_HEADSET_STAND_ZONE_LOGO        = 1
+};
+
+enum
+{
+    AURA_HEADSET_STAND_MODE_DIRECT      = 0,
+    AURA_HEADSET_STAND_MODE_STATIC      = 1,
+    AURA_HEADSET_STAND_MODE_BREATHING   = 2,
+    AURA_HEADSET_STAND_MODE_STROBING    = 3,
+    AURA_HEADSET_STAND_MODE_COLOR_CYCLE = 4,
+    AURA_HEADSET_STAND_MODE_RAINBOW     = 5
+};
+
+class AuraHeadsetStandController
+{
+public:
+    AuraHeadsetStandController(hid_device* dev_handle, const char* path);
+    virtual ~AuraHeadsetStandController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void UpdateLeds
+        (
+        std::vector<RGBColor>    colors
+        );
+
+    void UpdateDevice
+        (
+        unsigned char   mode,
+        unsigned char   red,
+        unsigned char   grn,
+        unsigned char   blu,
+        unsigned char   speed,
+        bool            save
+        );
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+};

Controllers/AsusAuraUSBController/AsusAuraKeyboardController.cpp

@@ -30,7 +30,12 @@ std::string AuraKeyboardController::GetDeviceLocation()
 std::string AuraKeyboardController::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());

Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp

@@ -11,10 +11,11 @@
 
 #include <cstring>
 
-AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path)
+AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid)
 {
     dev         = dev_handle;
     location    = path;
+    device_pid  = pid;
 }
 
 AuraMouseController::~AuraMouseController()
@@ -29,8 +30,13 @@ std::string AuraMouseController::GetDeviceLocation()
 
 std::string AuraMouseController::GetSerialString()
 {
-    wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
+    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());
@@ -38,21 +44,31 @@ std::string AuraMouseController::GetSerialString()
     return(return_string);
 }
 
+void AuraMouseController::SaveMode()
+{
+    unsigned char usb_save_buf[ASUS_AURA_MOUSE_PACKET_SIZE] = { 0x00, 0x50, 0x03 };
+
+    hid_write(dev, usb_save_buf, ASUS_AURA_MOUSE_PACKET_SIZE);
+}
+
 void AuraMouseController::SendUpdate
     (
     unsigned char   zone,
     unsigned char   mode,
     unsigned char   red,
     unsigned char   grn,
-    unsigned char   blu
+    unsigned char   blu,
+    unsigned char   dir,
+    bool            random,
+    unsigned char   speed
     )
 {
-    unsigned char usb_buf[65];
+    unsigned char usb_buf[ASUS_AURA_MOUSE_PACKET_SIZE];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
     \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
+    memset(usb_buf, 0x00, ASUS_AURA_MOUSE_PACKET_SIZE);
 
     /*-----------------------------------------------------*\
     | Set up message packet                                 |
@@ -67,9 +83,24 @@ void AuraMouseController::SendUpdate
     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;
+    }
+    else
+    {
+        usb_buf[0x0A]   = dir;
+        usb_buf[0x0B]   = random;
+        usb_buf[0x0C]   = speed;
+    }
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, usb_buf, ASUS_AURA_MOUSE_PACKET_SIZE);
 }

Controllers/AsusAuraUSBController/AsusAuraMouseController.h

@@ -8,46 +8,39 @@
 \*-----------------------------------------*/
 
 #include "RGBController.h"
+#include "AsusAuraMouseDevices.h"
 
 #include <string>
-#include <vector>
 #include <hidapi/hidapi.h>
 
 #pragma once
 
-enum
-{
-    AURA_MOUSE_ZONE_LOGO        = 0,
-    AURA_MOUSE_ZONE_SCROLL      = 1,
-    AURA_MOUSE_ZONE_UNDERGLOW   = 2,
-    AURA_MOUSE_ZONE_ALL         = 3,
-};
-
-enum
-{
-    AURA_MOUSE_MODE_STATIC      = 0,
-    AURA_MOUSE_MODE_BREATHING   = 1,
-    AURA_MOUSE_MODE_COLOR_CYCLE = 2,
-    AURA_MOUSE_MODE_REACTIVE    = 3,
-};
+#define ASUS_AURA_MOUSE_PACKET_SIZE 65
+#define HID_MAX_STR 255
 
 class AuraMouseController
 {
 public:
-    AuraMouseController(hid_device* dev_handle, const char* path);
+    AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid);
     virtual ~AuraMouseController();
 
     std::string GetDeviceLocation();
     std::string GetSerialString();
 
+    void SaveMode();
     void SendUpdate
         (
         unsigned char   zone,
         unsigned char   mode,
         unsigned char   red,
         unsigned char   grn,
-        unsigned char   blu
-        );
+        unsigned char   blu,
+        unsigned char   dir,
+        bool            random,
+        unsigned char   speed
+	);
+
+    uint16_t                    device_pid;
 
 private:
     hid_device*                 dev;

Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h

@@ -0,0 +1,212 @@
+/*-------------------------------------------------------------------*\
+|  AsusAuraMouseDevices.h                                             |
+|                                                                     |
+|  Asus Aura Mouse definitions and mapping                            |
+|                                                                     |
+|  Chris M (Dr_No)         11th July 2021                             |
+\*-------------------------------------------------------------------*/
+
+#include <vector>
+#include <map>
+
+#pragma once
+
+#define AURA_ROG_GLADIUS_II_CORE_PID            0x18DD
+#define AURA_ROG_GLADIUS_II_PID                 0x1845
+#define AURA_ROG_GLADIUS_II_ORIGIN_PID          0x1877
+#define AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID  0x18CD
+#define AURA_ROG_GLADIUS_II_ORIGIN_COD_PID      0x18B1
+#define AURA_ROG_GLADIUS_II_WIRELESS_1_PID      0x189E
+#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_PUGIO_PID                      0x1846
+#define AURA_ROG_PUGIO_II_WIRED_PID             0x1906
+#define AURA_ROG_PUGIO_II_WIRELESS_PID          0x1908
+#define AURA_ROG_STRIX_IMPACT_II_PID            0x18E1
+#define AURA_TUF_M3_PID                         0x1910
+#define AURA_TUF_M5_PID                         0x1910
+
+enum
+{
+    AURA_MOUSE_ZONE_LOGO        = 0,
+    AURA_MOUSE_ZONE_SCROLL      = 1,
+    AURA_MOUSE_ZONE_UNDERGLOW   = 2,
+    AURA_MOUSE_ZONE_ALL         = 3,
+};
+
+enum
+{
+    AURA_MOUSE_MODE_STATIC      = 0,
+    AURA_MOUSE_MODE_BREATHING   = 1,
+    AURA_MOUSE_MODE_SPECTRUM    = 2,
+    AURA_MOUSE_MODE_WAVE        = 3,
+    AURA_MOUSE_MODE_REACTIVE    = 4,
+    AURA_MOUSE_MODE_COMET       = 5,
+    AURA_MOUSE_MODE_BATTERY     = 6
+};
+
+typedef struct
+{
+    uint8_t                 speed_min;
+    uint8_t                 speed_max;
+    std::vector<uint8_t>    mouse_zones;
+    std::vector<uint8_t>    mouse_modes;
+} mouse_type;
+
+/*-----------------------------------------------------------------*\
+|  DEVICE MAP                                                       |
+|                                                                   |
+|    This structure maps the OpenRGB modes to the mode values       |
+|    sent to each mouse. As not all modes are present on each       |
+|    mouse the "mode index" is different. Eg. "Reactive" is mode    |
+|    4 on the Gladius II and mode 3 on the Gladius II wireless      |
+\*-----------------------------------------------------------------*/
+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
+            { 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_GLADIUS_II_PID, // ROG Gladius II
+        {
+            255,
+            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_ROG_GLADIUS_II_ORIGIN_PID, // ROG Gladius II Origin
+        {
+            255,
+            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_ROG_GLADIUS_II_ORIGIN_COD_PID, // ROG Gladius II COD
+        {
+            255,
+            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_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID, // ROG Gladius II PNK LTD
+        {
+            255,
+            1,
+            { 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_ROG_GLADIUS_II_WIRELESS_1_PID, // ROG Gladius II Wireless
+        {
+            255,
+            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_ROG_GLADIUS_II_WIRELESS_2_PID, // ROG Gladius II Wireless
+        {
+            255,
+            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_ROG_CHAKRAM_WIRELESS_PID, // ROG Chakram Wireless
+        {
+            255,
+            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_1_PID,  // ROG Chakram Wired 1
+        {
+            255,
+            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
+        {
+            255,
+            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_PUGIO_PID, // ROG Pugio
+        {
+            255,
+            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_PUGIO_II_WIRED_PID, // ROG Pugio II Wired
+        {
+            255,
+            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_PUGIO_II_WIRELESS_PID, // ROG Pugio II Wireless
+        {
+            255,
+            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_II_PID, // ROG Strix Impact II
+        {
+            255,
+            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_TUF_M3_PID, // TUF M3
+        {
+            255,
+            1,
+            { AURA_MOUSE_ZONE_LOGO },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
+        }
+    },
+    {
+        AURA_TUF_M5_PID, // TUF M5
+        {
+            255,
+            1,
+            { AURA_MOUSE_ZONE_LOGO },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
+        }
+    },
+};

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp

@@ -0,0 +1,218 @@
+/*-----------------------------------------*\
+|  AsusAuraTUFKeyboardController.cpp        |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Mola19 03/03/2021                        |
+\*-----------------------------------------*/
+
+#include "AsusAuraTUFKeyboardController.h"
+
+#include <cstring>
+#include <string>
+#include <vector>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+
+AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+AuraTUFKeyboardController::~AuraTUFKeyboardController()
+{
+    hid_close(dev);
+}
+
+std::string AuraTUFKeyboardController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AuraTUFKeyboardController::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 AuraTUFKeyboardController::UpdateSingleLed
+    (
+    int             led,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    /*-----------------------------------------------------*\
+    | Set up message packet for single LED                  |
+    \*-----------------------------------------------------*/
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0] = 0x00;
+    usb_buf[1] = 0xc0;
+    usb_buf[2] = 0x81;
+    usb_buf[3] = 0x01;
+    usb_buf[4] = 0x00;
+
+    /*-----------------------------------------------------*\
+    | Convert LED index                                     |
+    \*-----------------------------------------------------*/
+    usb_buf[5] = floor(led/6)*8 + led%6;
+    usb_buf[6] = red;
+    usb_buf[7] = green;
+    usb_buf[8] = blue;
+
+    hid_write(dev, usb_buf, 65);
+}
+
+void AuraTUFKeyboardController::UpdateLeds
+    (
+    std::vector<RGBColor>    colors
+    )
+{
+    /*-----------------------------------------------------*\
+    | Loop over every column (optimisation needed)          |
+    \*-----------------------------------------------------*/
+    for(unsigned int i = 0; i < 192; i += 16)
+    {
+        unsigned char usb_buf[69];
+
+        memset(usb_buf, 0x00, sizeof(usb_buf));
+
+        usb_buf[0] = 0x00;
+        usb_buf[1] = 0xc0;
+        usb_buf[2] = 0x81;
+        usb_buf[3] = (138 - i / 16 * 12);
+        usb_buf[4] = 0x00;
+
+        for(unsigned int n = 0; n < 6; n++)
+        {
+            usb_buf[n * 4 + 5] = i + n;
+            usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n]);
+            usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n]);
+            usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n]);
+        }
+
+        for(unsigned int n = 6; n < 8; n++)
+        {
+            usb_buf[n * 4 + 5] = i + n;
+            usb_buf[n * 4 + 6] = 0;
+            usb_buf[n * 4 + 7] = 0;
+            usb_buf[n * 4 + 8] = 0;
+        }
+
+        if(i != 176)
+        {
+            for(unsigned int n = 8; n < 14; n++)
+            {
+                usb_buf[n * 4 + 5] = i + n;
+                usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n-2]);
+                usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n-2]);
+                usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n-2]);
+            }
+
+            for(unsigned int n = 14; n < 16; n++)
+            {
+                usb_buf[n * 4 + 5] = i + n;
+                usb_buf[n * 4 + 6] = 0;
+                usb_buf[n * 4 + 7] = 0;
+                usb_buf[n * 4 + 8] = 0;
+            }
+        }
+
+        hid_write(dev, usb_buf, 69);
+    }
+}
+
+void AuraTUFKeyboardController::UpdateDevice
+    (
+    unsigned char           mode,
+    std::vector<RGBColor>   colors,
+    unsigned char           dir,
+    unsigned char           color_mode,
+    unsigned char           speed
+    )
+{
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x51;
+    usb_buf[0x02]   = 0x2C;
+    usb_buf[0x03]   = mode;
+    usb_buf[0x04]   = 0x00;
+    usb_buf[0x05]   = speed;
+    usb_buf[0x06]   = 0x64;
+    usb_buf[0x07]   = color_mode;
+    usb_buf[0x08]   = dir;
+    usb_buf[0x09]   = 0x02;
+
+	if(mode == 4 || mode == 5)
+	{
+	    /*-----------------------------------------------------*\
+        | If mode is Rainbow or Ripple                          |
+	    \*-----------------------------------------------------*/
+	    usb_buf[0x0A]   = colors.size();
+
+	    /*-----------------------------------------------------*\
+	    | Loop over every color given                           |
+	    \*-----------------------------------------------------*/
+        for(unsigned int i = 0; i / 4 < colors.size(); i += 4)
+        {
+            if(colors[i / 4])
+            {
+                usb_buf[11 + i] = 100/(double)colors.size()*(i/4+1);
+                usb_buf[12 + i] = RGBGetRValue(colors[i/4]);
+                usb_buf[13 + i] = RGBGetGValue(colors[i/4]);
+                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)
+        {
+            if(colors[i / 3])
+            {
+                usb_buf[10 + i] = RGBGetRValue(colors[i/3]);
+                usb_buf[11 + i] = RGBGetGValue(colors[i/3]);
+                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];
+
+    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/AsusAuraTUFKeyboardController.h

@@ -0,0 +1,76 @@
+/*-----------------------------------------*\
+|  AsusAuraTUFKeyboardController.h          |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Mola19 03/03/2021                        |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    AURA_KEYBOARD_ZONE_LOGO         = 0,
+    AURA_KEYBOARD_ZONE_SCROLL       = 1,
+    AURA_KEYBOARD_ZONE_UNDERGLOW    = 2,
+    AURA_KEYBOARD_ZONE_ALL          = 3,
+};
+
+enum
+{
+    AURA_KEYBOARD_MODE_STATIC       =  0,
+    AURA_KEYBOARD_MODE_BREATHING    =  1,
+    AURA_KEYBOARD_MODE_COLOR_CYCLE  =  2,
+    AURA_KEYBOARD_MODE_REACTIVE     =  3,
+    AURA_KEYBOARD_MODE_WAVE         =  4,
+    AURA_KEYBOARD_MODE_RIPPLE       =  5,
+    AURA_KEYBOARD_MODE_STARRY_NIGHT =  6,
+    AURA_KEYBOARD_MODE_QUICKSAND    =  7,
+    AURA_KEYBOARD_MODE_CURRENT      =  8,
+    AURA_KEYBOARD_MODE_RAIN_DROP    =  9,
+    AURA_KEYBOARD_MODE_DIRECT       = 15,
+};
+
+class AuraTUFKeyboardController
+{
+public:
+    AuraTUFKeyboardController(hid_device* dev_handle, const char* path);
+    ~AuraTUFKeyboardController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void UpdateSingleLed
+        (
+        int             led,
+        unsigned char   red,
+        unsigned char   green,
+        unsigned char   blue
+        );
+
+	void UpdateLeds
+        (
+        std::vector<RGBColor>    colors
+        );
+
+    void UpdateDevice
+        (
+        unsigned char           mode,
+        std::vector<RGBColor>   colors,
+        unsigned char           dir,
+        unsigned char           color_mode,
+        unsigned char           speed
+        );
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+};
+

Controllers/AsusAuraUSBController/AsusAuraUSBController.cpp

@@ -42,7 +42,12 @@ std::string AuraUSBController::GetDeviceName()
 std::string AuraUSBController::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());

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -1,18 +1,25 @@
 #include "Detector.h"
 #include "AsusAuraAddressableController.h"
+#include "AsusAuraHeadsetStandController.h"
 #include "AsusAuraKeyboardController.h"
+#include "AsusAuraTUFKeyboardController.h"
 #include "AsusAuraMainboardController.h"
 #include "AsusAuraMouseController.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 <stdexcept>
 #include <hidapi/hidapi.h>
 #include "dependencies/dmiinfo.h"
 
 #define AURA_USB_VID                            0x0B05
-#define AURA_TERMINAL_PID                       0x1889
+
+/*-----------------------------------------------------------------*\
+|  MOTHERBOARDS                                                     |
+\*-----------------------------------------------------------------*/
 #define AURA_ADDRESSABLE_1_PID                  0x1867
 #define AURA_ADDRESSABLE_2_PID                  0x1872
 #define AURA_ADDRESSABLE_3_PID                  0x18A3
@@ -20,15 +27,56 @@
 #define AURA_MOTHERBOARD_1_PID                  0x18F3
 #define AURA_MOTHERBOARD_2_PID                  0x1939
 #define AURA_MOTHERBOARD_3_PID                  0x19AF
-#define AURA_ROG_GLADIUS_II_CORE_PID            0x18DD
-#define AURA_ROG_GLADIUS_II_PID                 0x1845
+
+/*-----------------------------------------------------------------*\
+|  KEYBOARDS                                                        |
+\*-----------------------------------------------------------------*/
+#define AURA_ROG_FALCHION_WIRED_PID             0x193C
+#define AURA_ROG_FALCHION_WIRELESS_PID          0x193E
 #define AURA_ROG_STRIX_FLARE_PID                0x1875
-#define AURA_ROG_GLADIUS_II_ORIGIN_PID          0x1877
-#define AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID  0x18CD
 #define AURA_ROG_STRIX_FLARE_PNK_LTD_PID        0x18CF
-#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_STRIX_SCOPE_PID                0x18F8
+#define AURA_ROG_STRIX_SCOPE_RX_PID             0x1951
+#define AURA_ROG_STRIX_SCOPE_TKL_PID            0x190C
+#define AURA_TUF_K7_GAMING_PID                  0x18AA
+
+/*-----------------------------------------------------------------*\
+|  MICE - defined in AsusAuraMouseDevices.h                         |
+\*-----------------------------------------------------------------*/
+
+
+/*-----------------------------------------------------------------*\
+|  OTHER                                                            |
+\*-----------------------------------------------------------------*/
+#define AURA_TERMINAL_PID                       0x1889
+#define AURA_ROG_THRONE_QI_PID                  0x18C5
+
+
+AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
+{
+    switch(pid)
+    {
+        case AURA_ROG_STRIX_FLARE_PID:
+        case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
+            return FLARE_LAYOUT;
+
+        case AURA_ROG_STRIX_SCOPE_PID:
+            return SCOPE_LAYOUT;
+
+        case AURA_ROG_STRIX_SCOPE_RX_PID:
+            return SCOPE_RX_LAYOUT;
+
+        case AURA_ROG_STRIX_SCOPE_TKL_PID:
+            return SCOPE_TKL_LAYOUT;
+
+        case AURA_ROG_FALCHION_WIRED_PID:
+        case AURA_ROG_FALCHION_WIRELESS_PID:
+            return FALCHION_LAYOUT;
+
+        default:
+            return FLARE_LAYOUT;
+    }
+}
 
 void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
 {
@@ -43,7 +91,7 @@ void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
     }
 }
 
-void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& name)
+void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& /*name*/)
 {
     hid_device* dev = hid_open_path(info->path);
 
@@ -57,7 +105,7 @@ void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& name
     }
 }
 
-void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& name)
+void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*name*/)
 {
     hid_device* dev = hid_open_path(info->path);
     if(dev)
@@ -82,8 +130,9 @@ 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);
-        RGBController_AuraKeyboard* rgb_controller = new RGBController_AuraKeyboard(controller);
+        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);
     }
@@ -94,14 +143,40 @@ 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);
+        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);
     }
 }
 
-REGISTER_HID_DETECTOR   ("ASUS ROG AURA Terminal",              DetectAsusAuraUSBTerminal,      AURA_USB_VID, AURA_TERMINAL_PID);
+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;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+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;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+/*-----------------------------------------------------------------*\
+|  MOTHERBOARDS                                                     |
+\*-----------------------------------------------------------------*/
 REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_1_PID);
 REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_2_PID);
 REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_3_PID);
@@ -109,12 +184,41 @@ REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUS
 REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",               DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_1_PID);
 REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",               DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_2_PID);
 REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",               DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_3_PID);
+
+/*-----------------------------------------------------------------*\
+|  KEYBOARDS                                                        |
+\*-----------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)",           DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID,              1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)",        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID,           1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                 1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,         1,  0xFF00);
+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);
+
+/*-----------------------------------------------------------------*\
+|  MICE                                                             |
+\*-----------------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID,             0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_PID,                  2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin",          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID,           2,  0xFF01);
 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 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 Strix Flare",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                 1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,         1,  0xFF00);
+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 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);
+
+/*-----------------------------------------------------------------*\
+|  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);

Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.cpp

@@ -0,0 +1,182 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraHeadsetStand.cpp   |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 06/04/2021                        |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusAuraHeadsetStand.h"
+
+RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandController* aura_ptr)
+{
+    aura        = aura_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();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = AURA_HEADSET_STAND_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_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.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.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.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;
+    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;
+    modes.push_back(Rainbow);
+    SetupZones();
+}
+
+RGBController_AuraHeadsetStand::~RGBController_AuraHeadsetStand()
+{
+	delete aura;
+}
+
+void RGBController_AuraHeadsetStand::SetupZones()
+{
+    zone underglow_zone;
+
+    underglow_zone.name         = "Underglow";
+    underglow_zone.type         = ZONE_TYPE_LINEAR;
+    underglow_zone.leds_min     = 17;
+    underglow_zone.leds_max     = 17;
+    underglow_zone.leds_count   = 17;
+    underglow_zone.matrix_map   = NULL;
+
+    zones.push_back(underglow_zone);
+
+    for(unsigned int i = 0; i < 17; i++)
+    {
+        led underglow_led;
+
+        underglow_led.name      = "Underglow LED " + std::to_string(i);
+
+        leds.push_back(underglow_led);
+    }
+
+    zone logo_zone;
+
+    logo_zone.name              = "Logo";
+    logo_zone.type              = ZONE_TYPE_SINGLE;
+    logo_zone.leds_min          = 1;
+    logo_zone.leds_max          = 1;
+    logo_zone.leds_count        = 1;
+    logo_zone.matrix_map        = NULL;
+
+    zones.push_back(logo_zone);
+
+    led logo_led;
+
+    logo_led.name               = "Logo LED";
+
+    leds.push_back(logo_led);
+
+    SetupColors();
+}
+
+void RGBController_AuraHeadsetStand::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AuraHeadsetStand::DeviceUpdateLEDs()
+{
+    aura->UpdateLeds(std::vector<RGBColor>(colors));
+}
+
+void RGBController_AuraHeadsetStand::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraHeadsetStand::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraHeadsetStand::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+
+void RGBController_AuraHeadsetStand::DeviceUpdateMode()
+{
+    unsigned char red = 0;
+    unsigned char grn = 0;
+    unsigned char blu = 0;
+    switch(modes[active_mode].value)
+    {
+        case 0:
+            aura->UpdateLeds(std::vector<RGBColor>(colors));
+            break;
+        case 1:
+        case 2:
+        case 3:
+            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);
+            break;
+        case 4:
+        case 5:
+            aura->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, false);
+            break;
+    }
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraHeadsetStand.h     |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 06/04/2021                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraHeadsetStandController.h"
+
+class RGBController_AuraHeadsetStand : public RGBController
+{
+public:
+    RGBController_AuraHeadsetStand(AuraHeadsetStandController* aura_ptr);
+    ~RGBController_AuraHeadsetStand();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    AuraHeadsetStandController*  aura;
+};

Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.cpp

@@ -12,42 +12,38 @@
 //0xFFFFFFFF indicates an unused entry in matrix
 #define NA  0xFFFFFFFF
 
-static unsigned int matrix_map[6][22] =
+static unsigned int flare_matrix_map[6][22] =
     { {   0,  NA,  13,  18,  23,  28,  38,  43,  49,  54,  60,  65,  69,  70,  NA,  76,  80,  85,  NA,  NA,  NA,  NA },
       {   1,   8,  14,  19,  24,  29,  34,  39,  44,  50,  55,  61,  66,  71,  NA,  77,  81,  86,  89,  94,  98, 103 },
       {   2,  NA,   9,  15,  20,  25,  30,  35,  40,  45,  51,  56,  62,  67,  72,  78,  82,  87,  90,  95,  99, 104 },
       {   3,  NA,  10,  16,  21,  26,  31,  36,  41,  46,  52,  57,  63,  68,  73,  NA,  NA,  NA,  91,  96, 100,  NA },
-      {   4,   6,  11,  17,  22,  27,  32,  37,  42,  47,  53,  58,  NA,  NA,  74,  NA,  83,  NA,  92,  97, 101, 105 },
+      {   4,   6,  11,  17,  22,  27,  32,  37,  42,  47,  53,  58,  74,  NA,  NA,  NA,  83,  NA,  92,  97, 101, 105 },
       {   5,   7,  12,  NA,  NA,  NA,  NA,  33,  NA,  48,  NA,  59,  64,  75,  NA,  79,  84,  88,  93,  NA, 102,  NA } };
 
-static const char* zone_names[] =
-{
-    "Keyboard",
-    "Logo",
-    "Underglow"
-};
+static unsigned int scope_matrix_map[6][22] =
+    { {   0,  NA,  13,  18,  23,  28,  38,  43,  49,  54,  60,  65,  69,  70,  NA,  76,  80,  85,  NA,  NA,  NA,  NA },
+      {   1,   8,  14,  19,  24,  29,  34,  39,  44,  50,  55,  61,  66,  71,  NA,  77,  81,  86,  89,  94,  98, 103 },
+      {   2,  NA,   9,  15,  20,  25,  30,  35,  40,  45,  51,  56,  62,  67,  72,  78,  82,  87,  90,  95,  99, 104 },
+      {   3,  NA,  10,  16,  21,  26,  31,  36,  41,  46,  52,  57,  63,  68,  73,  NA,  NA,  NA,  91,  96, 100,  NA },
+      {   4,   6,  11,  17,  22,  27,  32,  37,  42,  47,  53,  58,  74,  NA,  NA,  NA,  83,  NA,  92,  97, 101, 105 },
+      {   5,   NA,  7,  12,  NA,  NA,  NA,  33,  NA,  48,  NA,  59,  64,  75,  NA,  79,  84,  88,  93,  NA, 102,  NA } };
 
-static zone_type zone_types[] =
-{
-    ZONE_TYPE_MATRIX,
-    ZONE_TYPE_SINGLE,
-    ZONE_TYPE_SINGLE
-};
+static unsigned int scope_tkl_matrix_map[6][18] =
+    { {   0,  NA,  13,  18,  23,  28,  38,  43,  49,  54,  60,  65,  69,  70,  NA,  NA,  NA,  NA },
+      {   1,   8,  14,  19,  24,  29,  34,  39,  44,  50,  55,  61,  66,  71,  NA,  76,  79,  83 },
+      {   2,  NA,   9,  15,  20,  25,  30,  35,  40,  45,  51,  56,  62,  67,  72,  77,  80,  84 },
+      {   3,  NA,  10,  16,  21,  26,  31,  36,  41,  46,  52,  57,  63,  68,  73,  NA,  NA,  NA },
+      {   4,   6,  11,  17,  22,  27,  32,  37,  42,  47,  53,  58,  74,  NA,  NA,  NA,  81,  NA },
+      {   5,   NA,  7,  12,  NA,  NA,  NA,  33,  NA,  48,  NA,  59,  64,  75,  NA,  78,  82,  85 } };
 
-static const unsigned int zone_sizes[] =
-{
-    106,
-    1,
-    2,
-};
+static unsigned int falchion_matrix_map[5][16] =
+    { {   0,   5,   9,  14,  18,  22,  26,  31,  35,  39,  44,  49,  54,  58,  NA,  63 },
+      {   1,  NA,   6,  10,  15,  19,  23,  27,  32,  36,  40,  45,  50,  55,  59,  64 },
+      {   2,  NA,   7,  11,  16,  20,  24,  28,  33,  37,  41,  46,  51,  60,  NA,  65 }, 
+      {   3,  NA,  12,  17,  21,  25,  29,  34,  38,  42,  47,  52,  56,  NA,  61,  66 },
+      {   4,   8,  13,  NA,  NA,  NA,  30,  NA,  NA,  NA,  43,  48,  53,  57,  62,  67 } };
 
-typedef struct
-{
-    const char *        name;
-    const unsigned char idx;
-} led_type;
-
-static const led_type led_names[] =
+static const std::vector<led_type> default_led_names =
 {
     /* Key Label                Index  */
     { "Key: Escape",            0x00    },
@@ -57,12 +53,10 @@ static const led_type led_names[] =
     { "Key: Left Shift",        0x04    },
     { "Key: Left Control",      0x05    },
     { "Key: \\ (ISO)",          0x0C    },
-    { "Key: Left Windows",      0x0D    },
     { "Key: 1",                 0x11    },
     { "Key: Q",                 0x12    },
     { "Key: A",                 0x13    },
     { "Key: Z",                 0x14    },
-    { "Key: Left Alt",          0x15    },
     { "Key: F1",                0x18    },
     { "Key: 2",                 0x19    },
     { "Key: W",                 0x1A    },
@@ -156,14 +150,202 @@ static const led_type led_names[] =
     { "Key: Number Pad -",      0xB1    },
     { "Key: Number Pad +",      0xB2    },
     { "Key: Number Pad Enter",  0xB4    },
-    { "Logo",                   0xB8    },
-    { "Left Underglow",         0xB9    },
-    { "Right Underglow",        0xBA    },
 };
 
-RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* aura_ptr)
+static const std::vector<led_type> default_tkl_led_names =
 {
-    aura = aura_ptr;
+    /* 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    },
+    { "Logo 1",                 0x80    },
+    { "Logo 2",                 0x90    },
+    { "Underglow 1",            0x06    },
+    { "Underglow 2",            0x0E    },
+    { "Underglow 3",            0x16    },
+    { "Underglow 4",            0x1E    },
+    { "Underglow 5",            0x26    },
+    { "Underglow 6",            0x2E    },
+    { "Underglow 7",            0x36    },
+    { "Underglow 8",            0x3E    },
+    { "Underglow 9",            0x46    },
+    { "Underglow 10",           0x4E    },
+    { "Underglow 11",           0x56    },
+    { "Underglow 12",           0x5E    },
+    { "Underglow 13",           0x66    },
+    { "Underglow 14",           0x6E    },
+    { "Underglow 15",           0x76    },
+    { "Underglow 16",           0x7E    },
+    { "Underglow 17",           0x86    },
+    { "Underglow 18",           0x8E    },
+    { "Underglow 19",           0x96    },
+    { "Underglow 20",           0x9E    },
+    { "Underglow 21",           0xA6    },
+    { "Underglow 22",           0xAE    },
+    { "Underglow 23",           0xB6    },
+    { "Underglow 24",           0xBE    },
+    { "Underglow 25",           0xC6    },
+    { "Underglow 26",           0xCE    },
+};
+
+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    },
+};
+
+RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* aura_ptr, AuraKeyboardMappingLayoutType keyboard_layout)
+{
+    aura        = aura_ptr;
+    layout      = keyboard_layout;
 
     name        = "ASUS Aura Keyboard";
     vendor      = "ASUS";
@@ -184,6 +366,13 @@ RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* a
 
 RGBController_AuraKeyboard::~RGBController_AuraKeyboard()
 {
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        if(zones[zone_idx].type == ZONE_TYPE_MATRIX)
+        {
+            delete zones[zone_idx].matrix_map;
+        }
+    }
     delete aura;
 }
 
@@ -192,22 +381,76 @@ void RGBController_AuraKeyboard::SetupZones()
     /*---------------------------------------------------------*\
     | Set up zones                                              |
     \*---------------------------------------------------------*/
+    std::vector<led_zone> led_zones;
+    std::vector<led_type> led_names;
+
+    switch(layout)
+    {
+        /*-----------------------------------------------------*\
+        | On the ROG Scope keyboards Ctrl key is double sized,  |
+        | so there is a layout shift                            |
+        \*-----------------------------------------------------*/
+        case SCOPE_LAYOUT:
+            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});
+            break;
+
+        case SCOPE_RX_LAYOUT:
+            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_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.push_back({ "Logo", 0xB0});
+            break;
+
+        case SCOPE_TKL_LAYOUT:
+            led_names = default_tkl_led_names;
+            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 86, new matrix_map_type{6, 18, (unsigned int *)&scope_tkl_matrix_map}});
+            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});
+            break;
+
+        case FLARE_LAYOUT:
+            led_names = default_led_names;
+            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&flare_matrix_map}});
+            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.push_back({ "Logo", 0xB8});
+            led_names.push_back({ "Left Underglow",     0xB9});
+            led_names.push_back({ "Right Underglow",    0xBA});
+            break;
+
+        case FALCHION_LAYOUT:
+            led_names = default_65pct_led_names;
+            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 68, new matrix_map_type{5, 16, (unsigned int *)&falchion_matrix_map}});
+            break;
+    }
+
     unsigned int total_led_count = 0;
-    for(unsigned int zone_idx = 0; zone_idx < 3; zone_idx++)
+    for(unsigned int zone_idx = 0; zone_idx < led_zones.size(); 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.name                   = led_zones[zone_idx].name;
+        new_zone.type                   = led_zones[zone_idx].type;
+        new_zone.leds_min               = led_zones[zone_idx].size;
+        new_zone.leds_max               = led_zones[zone_idx].size;
+        new_zone.leds_count             = led_zones[zone_idx].size;
 
-        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
+        if(led_zones[zone_idx].type == ZONE_TYPE_MATRIX)
         {
-            new_zone.matrix_map         = new matrix_map_type;
-            new_zone.matrix_map->height = 6;
-            new_zone.matrix_map->width  = 22;
-            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+            new_zone.matrix_map         = led_zones[zone_idx].matrix;
         }
         else
         {
@@ -216,7 +459,7 @@ void RGBController_AuraKeyboard::SetupZones()
 
         zones.push_back(new_zone);
 
-        total_led_count += zone_sizes[zone_idx];
+        total_led_count += led_zones[zone_idx].size;
     }
 
     for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
@@ -224,6 +467,7 @@ void RGBController_AuraKeyboard::SetupZones()
         led new_led;
         new_led.name  = led_names[led_idx].name;
         new_led.value = led_names[led_idx].idx;
+
         leds.push_back(new_led);
     }
 
@@ -239,20 +483,25 @@ void RGBController_AuraKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_AuraKeyboard::DeviceUpdateLEDs()
 {
-unsigned char frame_buf[109 * 4];
+    std::vector<unsigned char> frame_buf;
 
-/*---------------------------------------------------------*\
-| TODO: Send packets with multiple LED frames               |
-\*---------------------------------------------------------*/
-for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
-{
-    frame_buf[(led_idx * 4) + 0] = leds[led_idx].value;
-    frame_buf[(led_idx * 4) + 1] = RGBGetRValue(colors[led_idx]);
-    frame_buf[(led_idx * 4) + 2] = RGBGetGValue(colors[led_idx]);
-    frame_buf[(led_idx * 4) + 3] = RGBGetBValue(colors[led_idx]);
-}
+    /*---------------------------------------------------------*\
+    | Resize the frame buffer, 4 bytes per LED                  |
+    \*---------------------------------------------------------*/
+    frame_buf.resize(leds.size() * 4);
 
-aura->SendDirect(109, frame_buf);
+    /*---------------------------------------------------------*\
+    | TODO: Send packets with multiple LED frames               |
+    \*---------------------------------------------------------*/
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        frame_buf[(led_idx * 4) + 0] = leds[led_idx].value;
+        frame_buf[(led_idx * 4) + 1] = RGBGetRValue(colors[led_idx]);
+        frame_buf[(led_idx * 4) + 2] = RGBGetGValue(colors[led_idx]);
+        frame_buf[(led_idx * 4) + 3] = RGBGetBValue(colors[led_idx]);
+    }
+
+    aura->SendDirect(leds.size(), frame_buf.data());
 }
 
 void RGBController_AuraKeyboard::UpdateZoneLEDs(int /*zone*/)

Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.h

@@ -11,10 +11,33 @@
 #include "RGBController.h"
 #include "AsusAuraKeyboardController.h"
 
+enum AuraKeyboardMappingLayoutType
+{
+    FLARE_LAYOUT,
+    SCOPE_LAYOUT,
+    SCOPE_RX_LAYOUT,
+    SCOPE_TKL_LAYOUT,
+    FALCHION_LAYOUT,
+};
+
+typedef struct
+{
+    const char*         name;
+    unsigned char       idx;
+} led_type;
+
+typedef struct
+{
+    const char*         name;
+    const zone_type     type;
+    const unsigned int  size;
+    matrix_map_type*    matrix;
+} led_zone;
+
 class RGBController_AuraKeyboard : public RGBController
 {
 public:
-    RGBController_AuraKeyboard(AuraKeyboardController* aura_ptr);
+    RGBController_AuraKeyboard(AuraKeyboardController* aura_ptr, AuraKeyboardMappingLayoutType keyboard_layout);
     ~RGBController_AuraKeyboard();
 
     void        SetupZones();
@@ -29,5 +52,6 @@ public:
     void        DeviceUpdateMode();
 
 private:
-    AuraKeyboardController* aura;
+    AuraKeyboardController*         aura;
+    AuraKeyboardMappingLayoutType   layout;
 };

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp

@@ -9,44 +9,117 @@
 
 #include "RGBController_AsusAuraMouse.h"
 
+static std::string aura_mouse_zone_names[3]
+{
+    "Logo",
+    "Scroll Wheel",
+    "Underglow"
+};
+
 RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
 {
-    aura = aura_ptr;
+    aura                    = aura_ptr;
 
-    name        = "ASUS Aura Mouse";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_MOUSE;
-    description = "ASUS Aura Mouse Device";
-    location    = aura->GetDeviceLocation();
-    serial      = aura->GetSerialString();
+    name                    = "ASUS Aura Mouse";
+    vendor                  = "ASUS";
+    type                    = DEVICE_TYPE_MOUSE;
+    description             = "ASUS Aura Mouse Device";
+    location                = aura->GetDeviceLocation();
+    serial                  = aura->GetSerialString();
 
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = AURA_MOUSE_MODE_STATIC;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
+    uint16_t pid            = aura->device_pid;
+    std::vector<uint8_t> mm = aura_mouse_devices[pid].mouse_modes;
 
-    mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = AURA_MOUSE_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Breathing.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Breathing);
+    for(std::vector<uint8_t>::iterator it = mm.begin(); it != mm.end(); it++)
+    {
+        switch(*it)
+        {
+            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;
+                    modes.push_back(Direct);
+                }
+                break;
 
-    mode SpectrumCycle;
-    SpectrumCycle.name       = "Spectrum Cycle";
-    SpectrumCycle.value      = AURA_MOUSE_MODE_COLOR_CYCLE;
-    SpectrumCycle.flags      = 0;
-    SpectrumCycle.color_mode = MODE_COLORS_NONE;
-    modes.push_back(SpectrumCycle);
+            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;
+                    modes.push_back(Breathing);
+                }
+                break;
 
-    mode Reactive;
-    Reactive.name       = "Reactive";
-    Reactive.value      = AURA_MOUSE_MODE_REACTIVE;
-    Reactive.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Reactive.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Reactive);
+            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;
+                    modes.push_back(ColorCycle);
+                }
+                break;
+
+            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;
+                    modes.push_back(Wave);
+                }
+                break;
+
+            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;
+                    modes.push_back(Reactive);
+                }
+                break;
+
+            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.colors.resize(1);
+                    modes.push_back(Comet);
+                }
+                break;
+
+            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;
+                    modes.push_back(BatteryMode);
+                }
+                break;
+        }
+    }
 
     SetupZones();
 }
@@ -58,56 +131,29 @@ RGBController_AuraMouse::~RGBController_AuraMouse()
 
 void RGBController_AuraMouse::SetupZones()
 {
-    zone logo_zone;
 
-    logo_zone.name          = "Logo";
-    logo_zone.type          = ZONE_TYPE_SINGLE;
-    logo_zone.leds_min      = 1;
-    logo_zone.leds_max      = 1;
-    logo_zone.leds_count    = 1;
-    logo_zone.matrix_map    = NULL;
+    uint16_t pid                = aura->device_pid;
 
-    zones.push_back(logo_zone);
+    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++)
+    {
+        zone mouse_zone;
 
-    led logo_led;
+        mouse_zone.name         = aura_mouse_zone_names[*zone_it];
+        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;
 
-    logo_led.name           = "Logo";
+        zones.push_back(mouse_zone);
 
-    leds.push_back(logo_led);
+        led mouse_led;
 
-    zone scroll_zone;
+        mouse_led.name          = mouse_zone.name + " LED";
+        mouse_led.value         = *zone_it;
 
-    scroll_zone.name        = "Scroll Wheel";
-    scroll_zone.type        = ZONE_TYPE_SINGLE;
-    scroll_zone.leds_min    = 1;
-    scroll_zone.leds_max    = 1;
-    scroll_zone.leds_count  = 1;
-    scroll_zone.matrix_map  = NULL;
-
-    zones.push_back(scroll_zone);
-
-    led scroll_led;
-
-    scroll_led.name         = "Scroll Wheel";
-
-    leds.push_back(scroll_led);
-
-    zone underglow_zone;
-
-    underglow_zone.name       = "Underglow";
-    underglow_zone.type       = ZONE_TYPE_SINGLE;
-    underglow_zone.leds_min   = 1;
-    underglow_zone.leds_max   = 1;
-    underglow_zone.leds_count = 1;
-    underglow_zone.matrix_map = NULL;
-
-    zones.push_back(underglow_zone);
-
-    led underglow_led;
-
-    underglow_led.name        = "Underglow";
-
-    leds.push_back(underglow_led);
+        leds.push_back(mouse_led);
+    }
 
     SetupColors();
 }
@@ -119,7 +165,10 @@ void RGBController_AuraMouse::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_AuraMouse::DeviceUpdateLEDs()
 {
-    DeviceUpdateMode();
+    for(std::vector<led>::iterator led_it = leds.begin(); led_it != leds.end(); led_it++)
+    {
+        UpdateSingleLED(led_it->value);
+    }
 }
 
 void RGBController_AuraMouse::UpdateZoneLEDs(int zone)
@@ -129,41 +178,11 @@ void RGBController_AuraMouse::UpdateZoneLEDs(int zone)
 
 void RGBController_AuraMouse::UpdateSingleLED(int led)
 {
-    unsigned char red = 0;
-    unsigned char grn = 0;
-    unsigned char blu = 0;
+    uint8_t red = RGBGetRValue(colors[led]);
+    uint8_t grn = RGBGetGValue(colors[led]);
+    uint8_t blu = RGBGetBValue(colors[led]);
 
-    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
-    {
-        if(led == 0)
-        {
-            red = RGBGetRValue(colors[led]);
-            grn = RGBGetGValue(colors[led]);
-            blu = RGBGetBValue(colors[led]);
-
-            aura->SendUpdate(AURA_MOUSE_ZONE_LOGO, modes[active_mode].value, red, grn, blu);
-        }
-        else if(led == 1)
-        {
-            red = RGBGetRValue(colors[led]);
-            grn = RGBGetGValue(colors[led]);
-            blu = RGBGetBValue(colors[led]);
-
-            aura->SendUpdate(AURA_MOUSE_ZONE_SCROLL, modes[active_mode].value, red, grn, blu);
-        }
-        else
-        {
-            red = RGBGetRValue(colors[led]);
-            grn = RGBGetGValue(colors[led]);
-            blu = RGBGetBValue(colors[led]);
-
-            aura->SendUpdate(AURA_MOUSE_ZONE_UNDERGLOW, modes[active_mode].value, red, grn, blu);
-        }
-    }
-    else
-    {
-        aura->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu);
-    }
+    aura->SendUpdate(leds[led].value, active_mode, red, grn, blu, 0, false, 0);
 }
 
 void RGBController_AuraMouse::SetCustomMode()
@@ -173,32 +192,24 @@ void RGBController_AuraMouse::SetCustomMode()
 
 void RGBController_AuraMouse::DeviceUpdateMode()
 {
-    unsigned char red = 0;
-    unsigned char grn = 0;
-    unsigned char blu = 0;
-
     if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
     {
-        red = RGBGetRValue(colors[0]);
-        grn = RGBGetGValue(colors[0]);
-        blu = RGBGetBValue(colors[0]);
-
-        aura->SendUpdate(AURA_MOUSE_ZONE_LOGO, modes[active_mode].value, red, grn, blu);
-
-        red = RGBGetRValue(colors[1]);
-        grn = RGBGetGValue(colors[1]);
-        blu = RGBGetBValue(colors[1]);
-
-        aura->SendUpdate(AURA_MOUSE_ZONE_SCROLL, modes[active_mode].value, red, grn, blu);
-
-        red = RGBGetRValue(colors[2]);
-        grn = RGBGetGValue(colors[2]);
-        blu = RGBGetBValue(colors[2]);
-
-        aura->SendUpdate(AURA_MOUSE_ZONE_UNDERGLOW, modes[active_mode].value, red, grn, blu);
+        DeviceUpdateLEDs();
     }
     else
     {
-        aura->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu);
+        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]);
+        }
+
+        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();
     }
 }

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -0,0 +1,470 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraTUFKeyboard.cpp    |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 03/03/2020                        |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusAuraTUFKeyboard.h"
+#include <vector>
+
+#define NA  0xFFFFFFFF
+
+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[] =
+{
+    "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;
+
+    name        = "ASUS Aura Keyboard";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "ASUS Aura Keyboard Device";
+    location    = aura->GetDeviceLocation();
+    serial      = aura->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;
+    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.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.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;
+    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.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.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.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.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.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.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.colors.resize(1);
+    modes.push_back(Rain_Drop);
+
+    SetupZones();
+}
+
+RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
+{
+    delete aura;
+}
+
+void RGBController_AuraTUFKeyboard::SetupZones()
+{
+    unsigned int total_led_count = 0;
+
+    for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
+    {
+        zone new_zone;
+        new_zone.name               = zone_names[zone_idx];
+        new_zone.type               = zone_types[zone_idx];
+        new_zone.leds_min           = zone_sizes[zone_idx];
+        new_zone.leds_max           = zone_sizes[zone_idx];
+        new_zone.leds_count         = zone_sizes[zone_idx];
+        new_zone.matrix_map         = new matrix_map_type;
+        new_zone.matrix_map->height = 6;
+        new_zone.matrix_map->width  = 23;
+        new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+        zones.push_back(new_zone);
+
+        total_led_count += zone_sizes[zone_idx];
+    }
+
+    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
+    {
+        led new_led;
+        new_led.name = led_names[led_idx];
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
+void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
+{
+    DeviceUpdateMode();
+}
+
+void RGBController_AuraTUFKeyboard::UpdateZoneLEDs(int /*zone*/)
+{
+    aura->UpdateLeds(colors);
+}
+
+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);
+}
+
+void RGBController_AuraTUFKeyboard::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
+{   
+    unsigned char color_mode;
+    std::vector<RGBColor> mode_colors;
+
+    if(modes[active_mode].value == AURA_KEYBOARD_MODE_DIRECT)
+    {
+        aura->UpdateLeds(colors);
+    }
+    else
+    {
+        bool mode_with_double = (modes[active_mode].value == 1 || modes[active_mode].value == 3 || modes[active_mode].value == 6 || modes[active_mode].value == 8 || modes[active_mode].value == 9);
+
+        if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && mode_with_double && modes[active_mode].colors.size() > 1)
+        {
+            if(modes[active_mode].colors[1] == 000)
+            {
+                color_mode = 0;
+            }
+            else
+            {
+                color_mode = 16;
+            }
+        }
+        else
+        {
+            color_mode = modes[active_mode].color_mode == MODE_COLORS_RANDOM ? 1 : 0;
+        }
+
+        int direction = 0;
+
+        switch (modes[active_mode].direction)
+        {
+            case MODE_DIRECTION_LEFT:
+                direction = 0;
+                break;
+            case MODE_DIRECTION_RIGHT:
+                direction = 4;
+                break;
+            case MODE_DIRECTION_UP:
+                direction = 6;
+                break;
+            case MODE_DIRECTION_DOWN:
+                direction = 2;
+                break;
+            case MODE_DIRECTION_HORIZONTAL:
+                direction = 8;
+                break;
+            case MODE_DIRECTION_VERTICAL:
+                direction = 1;
+                break;
+        }
+
+        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));
+    }
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraTUFKeyboard.h      |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 03/03/2021                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraTUFKeyboardController.h"
+
+class RGBController_AuraTUFKeyboard : public RGBController
+{
+public:
+    RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* aura_ptr);
+    ~RGBController_AuraTUFKeyboard();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    AuraTUFKeyboardController*  aura;
+};

Controllers/BlinkyTapeController/BlinkyTapeController.cpp

@@ -0,0 +1,104 @@
+/*---------------------------------------------------------*\
+|  BlinkyTapeController.cpp                                 |
+|                                                           |
+|  BlinkyTape controller interface                          |
+|                                                           |
+|  Matt Mets (matt@blinkinlabs.com), 07/01/2021             |
+\*---------------------------------------------------------*/
+
+#include "BlinkyTapeController.h"
+
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <string>
+
+#ifndef WIN32
+#define LPSTR           char *
+#define strtok_s        strtok_r
+#endif
+
+BlinkyTapeController::BlinkyTapeController()
+{
+}
+
+BlinkyTapeController::~BlinkyTapeController()
+{
+    if(serialport != nullptr)
+    {
+        serialport->serial_close();
+        delete serialport;
+    }
+}
+
+void BlinkyTapeController::Initialize(const std::string &portname)
+{
+    port_name   = portname;
+
+    serialport  = new serial_port();
+
+    if(!serialport->serial_open(port_name.c_str(), 115200))
+    {
+        delete serialport;
+        serialport = nullptr;
+    }
+}
+
+std::string BlinkyTapeController::GetLocation()
+{
+    if(serialport == nullptr)
+    {
+        return("");
+    }
+
+    return("COM: " + port_name);
+}
+
+char* BlinkyTapeController::GetLEDString()
+{
+    return(led_string);
+}
+
+void BlinkyTapeController::SetLEDs(std::vector<RGBColor> colors)
+{
+    if(serialport == nullptr)
+    {
+        return;
+    }
+
+    /*-------------------------------------------------------------*\
+    | BlinkyTape Protocol                                           |
+    |                                                               |
+    |   Packet size: Number of data bytes + 1                       |
+    |                                                               |
+    |   0-n: Data Byte (0-254)                                      |
+    |   n+1: Packet End Byte (0xFF)                                 |
+    \*-------------------------------------------------------------*/
+    const unsigned int payload_size     = (colors.size() * 3);
+    const unsigned int packet_size      = payload_size + 1;
+
+    std::vector<unsigned char> serial_buf(packet_size);
+
+    /*-------------------------------------------------------------*\
+    | Set up end byte                                               |
+    \*-------------------------------------------------------------*/
+    serial_buf[packet_size - 1] = 0xFF;
+
+    /*-------------------------------------------------------------*\
+    | Copy in color data in RGB order                               |
+    \*-------------------------------------------------------------*/
+    for(unsigned int color_idx = 0; color_idx < colors.size(); color_idx++)
+    {
+        const unsigned int color_offset = color_idx * 3;
+
+        serial_buf[0x00 + color_offset] = std::min((unsigned int)254, RGBGetRValue(colors[color_idx]));
+        serial_buf[0x01 + color_offset] = std::min((unsigned int)254, RGBGetGValue(colors[color_idx]));
+        serial_buf[0x02 + color_offset] = std::min((unsigned int)254, RGBGetBValue(colors[color_idx]));
+    }
+
+    /*-------------------------------------------------------------*\
+    | Send the packet                                               |
+    \*-------------------------------------------------------------*/
+    serialport->serial_write((char *)serial_buf.data(), packet_size);
+}
+

Controllers/BlinkyTapeController/BlinkyTapeController.h

@@ -0,0 +1,38 @@
+/*---------------------------------------------------------*\
+|  Definitions for BlinkyTape Interface                     |
+|                                                           |
+|  Matt Mets (matt@blinkinlabs.com), 07/01/2021             |
+\*---------------------------------------------------------*/
+
+#ifndef BLINKYTAPE_H
+#define BLINKYTAPE_H
+
+#include "RGBController.h"
+#include "serial_port.h"
+
+struct BlinkyTapeDevice
+{
+    std::string     port;
+    unsigned int    num_leds;
+};
+
+class BlinkyTapeController
+{
+public:
+    BlinkyTapeController();
+    ~BlinkyTapeController();
+
+    void        Initialize(const std::string &portname);
+
+    char*       GetLEDString();
+    std::string GetLocation();
+
+    void        SetLEDs(std::vector<RGBColor> colors);
+
+private:
+    char led_string[1024];
+    std::string port_name;
+    serial_port *serialport = nullptr;
+};
+
+#endif

Controllers/BlinkyTapeController/BlinkyTapeControllerDetect.cpp

@@ -0,0 +1,36 @@
+#include "Detector.h"
+#include "BlinkyTapeController.h"
+#include "RGBController.h"
+#include "RGBController_BlinkyTape.h"
+#include "SettingsManager.h"
+#include "find_usb_serial_port.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define BLINKINLABS_VID     0x1D50
+#define BLINKYTAPE_PID      0x605E
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectBlinkyTapeControllers                                                            *
+*                                                                                          *
+*       Detect BlinkyTape devices                                                          *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectBlinkyTapeControllers(std::vector<RGBController*> &rgb_controllers)
+{
+    std::vector<std::string *> device_locations = find_usb_serial_port(BLINKINLABS_VID, BLINKYTAPE_PID);
+
+    for(unsigned int device_idx = 0; device_idx < device_locations.size(); device_idx++)
+    {
+        BlinkyTapeController*     controller     = new BlinkyTapeController();
+        controller->Initialize(*device_locations[device_idx]);
+
+        RGBController_BlinkyTape* rgb_controller = new RGBController_BlinkyTape(controller);
+        rgb_controllers.push_back(rgb_controller);
+    }
+}
+
+REGISTER_DETECTOR("BlinkyTape", DetectBlinkyTapeControllers);

Controllers/BlinkyTapeController/RGBController_BlinkyTape.cpp

@@ -0,0 +1,137 @@
+/*---------------------------------------------------------*\
+|  RGBController_BlinkyTape.cpp                             |
+|                                                           |
+|  Generic RGB Interface for BlinkyTape Led controller      |
+|                                                           |
+|  Matt Mets (matt@blinkinlabs.com), 07/01/2021             |
+\*---------------------------------------------------------*/
+
+#include "RGBController_BlinkyTape.h"
+
+RGBController_BlinkyTape::RGBController_BlinkyTape(BlinkyTapeController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "BlinkyTape";
+    vendor      = "Blinkinlabs";
+    type        = DEVICE_TYPE_LEDSTRIP;
+    description = "BlinkyTape Controller Device";
+    location    = controller->GetLocation();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+}
+
+RGBController_BlinkyTape::~RGBController_BlinkyTape()
+{
+    delete controller;
+}
+
+void RGBController_BlinkyTape::SetupZones()
+{
+    zones.clear();
+    leds.clear();
+
+    zone led_zone;
+    led_zone.name       = "LED Strip";
+    led_zone.type       = ZONE_TYPE_LINEAR;
+    led_zone.leds_min   = 0;
+    led_zone.leds_max   = 512;
+    led_zone.leds_count = 0;
+    led_zone.matrix_map = NULL;
+    zones.push_back(led_zone);
+
+    ResizeZone(0, led_zone.leds_count);
+}
+
+void RGBController_BlinkyTape::ResizeZone(int zone, int new_size)
+{
+    /*-------------------------------------------------*\
+    | Explicitly cast these to avoid compiler warnings  |
+    \*-------------------------------------------------*/
+    const unsigned int zone_u       = static_cast<unsigned int>(zone);
+    const unsigned int new_size_u   = static_cast<unsigned int>(new_size);
+
+    /*-------------------------------------------------*\
+    | Check that the zone is in bounds                  |
+    \*-------------------------------------------------*/
+    if((zone_u > zones.size()) || (zone < 0))
+    {
+        return;
+    }
+
+    /*-------------------------------------------------*\
+    | And that the new size is in bounds                |
+    \*-------------------------------------------------*/
+    if((new_size_u > zones.at(zone).leds_max) || (new_size_u < zones.at(zone).leds_min))
+    {
+        return;
+    }
+
+    /*-------------------------------------------------*\
+    | And that there's actually a change                |
+    \*-------------------------------------------------*/
+    if(zones.at(zone).leds_count == new_size_u)
+    {
+        return;
+    }
+
+    /*-------------------------------------------------*\
+    | If the new size is less than the current size,    |
+    | just chop off the end                             |
+    \*-------------------------------------------------*/
+    if(leds.size() > new_size_u)
+    {
+        leds.resize(new_size);
+    }
+
+    /*-------------------------------------------------*\
+    | Otherwise, add new LEDs to the end                |
+    \*-------------------------------------------------*/
+    if(leds.size() < new_size_u)
+    {
+        for(size_t led_idx = leds.size(); led_idx < new_size_u; led_idx++)
+        {
+            led new_led;
+            new_led.name = "LED ";
+            new_led.name.append(std::to_string(led_idx));
+
+            leds.push_back(new_led);
+        }
+    }
+
+    zones.at(zone).leds_count = new_size;
+
+    SetupColors();
+}
+
+void RGBController_BlinkyTape::DeviceUpdateLEDs()
+{
+    controller->SetLEDs(colors);
+}
+
+void RGBController_BlinkyTape::UpdateZoneLEDs(int /*zone*/)
+{
+    controller->SetLEDs(colors);
+}
+
+void RGBController_BlinkyTape::UpdateSingleLED(int /*led*/)
+{
+    controller->SetLEDs(colors);
+}
+
+void RGBController_BlinkyTape::SetCustomMode()
+{
+
+}
+
+void RGBController_BlinkyTape::DeviceUpdateMode()
+{
+
+}

Controllers/BlinkyTapeController/RGBController_BlinkyTape.h

@@ -0,0 +1,33 @@
+/*---------------------------------------------------------*\
+|  RGBController_BlinkyTape.h                               |
+|                                                           |
+|  Generic RGB Interface for BlinkyTape Led controller      |
+|                                                           |
+|  Matt Mets (matt@blinkinlabs.com), 07/01/2021             |
+\*---------------------------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "serial_port.h"
+#include "BlinkyTapeController.h"
+
+class RGBController_BlinkyTape : public RGBController
+{
+public:
+    RGBController_BlinkyTape(BlinkyTapeController* controller_ptr);
+    ~RGBController_BlinkyTape();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    BlinkyTapeController*   controller;
+};

Controllers/CoolerMasterController/CMMM711Controller.cpp

@@ -0,0 +1,180 @@
+/*-------------------------------------------------------------------*\
+|  CMMM711Controller.cpp                                              |
+|                                                                     |
+|  Driver for Coolermaster Master Mouse 711                           |
+|                                                                     |
+|  Chris M (Dr_No)          14th Feb 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "CMMM711Controller.h"
+#include <cstring>
+
+CMMM711Controller::CMMM711Controller(hid_device* dev_handle, char *_path)
+{
+    const int szTemp = HID_MAX_STR;
+    wchar_t tmpName[szTemp];
+
+    dev                     = dev_handle;
+    location                = _path;
+    current_speed           = CM_MM711_SPEED_NORMAL;
+
+    hid_get_manufacturer_string(dev, tmpName, szTemp);
+    std::wstring wName = std::wstring(tmpName);
+    device_name = std::string(wName.begin(), wName.end());
+
+    hid_get_product_string(dev, tmpName, szTemp);
+    wName = std::wstring(tmpName);
+    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
+
+    hid_get_indexed_string(dev, 2, tmpName, szTemp);
+    wName = std::wstring(tmpName);
+    serial = std::string(wName.begin(), wName.end());
+
+    SendInitPacket();
+    GetColourStatus();
+    GetCustomStatus();
+    GetModeStatus();
+}
+
+CMMM711Controller::~CMMM711Controller()
+{
+    hid_close(dev);
+}
+
+void CMMM711Controller::GetColourStatus()
+{
+    uint8_t buffer[CM_MM711_PACKET_SIZE]    = { 0x00, 0x52, 0x2B };
+
+    hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM711_PACKET_SIZE, CM_MM711_INTERRUPT_TIMEOUT);
+
+    current_brightness      = buffer[CM_MM711_BRIGHTNESS_BYTE - 1];
+    current_red             = buffer[CM_MM711_RED_BYTE - 1];
+    current_green           = buffer[CM_MM711_GREEN_BYTE - 1];
+    current_blue            = buffer[CM_MM711_BLUE_BYTE - 1];
+}
+
+void CMMM711Controller::GetCustomStatus()
+{
+    uint8_t buffer[CM_MM711_PACKET_SIZE]    = { 0x00, 0x52, 0xA8 };
+    int buffer_size                         = (sizeof(buffer) / sizeof(buffer[0]));
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_MM711_INTERRUPT_TIMEOUT);
+
+    wheel_colour            = ToRGBColor(buffer[4], buffer[5], buffer[6]);
+    logo_colour             = ToRGBColor(buffer[7], buffer[8], buffer[9]);
+}
+
+void CMMM711Controller::GetModeStatus()
+{
+    uint8_t buffer[CM_MM711_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_MM711_INTERRUPT_TIMEOUT);
+
+    current_mode            = buffer[CM_MM711_MODE_BYTE - 1];
+}
+
+std::string CMMM711Controller::GetDeviceName()
+{
+    return device_name;
+}
+
+std::string CMMM711Controller::GetSerial()
+{
+    return serial;
+}
+
+std::string CMMM711Controller::GetLocation()
+{
+    return("HID: " + location);
+}
+
+unsigned char CMMM711Controller::GetMode()
+{
+    return current_mode;
+}
+
+unsigned char CMMM711Controller::GetLedRed()
+{
+    return current_red;
+}
+
+unsigned char CMMM711Controller::GetLedGreen()
+{
+    return current_green;
+}
+
+unsigned char CMMM711Controller::GetLedBlue()
+{
+    return current_blue;
+}
+
+unsigned char CMMM711Controller::GetLedSpeed()
+{
+    return current_speed;
+}
+
+RGBColor CMMM711Controller::GetWheelColour()
+{
+    return wheel_colour;
+}
+
+RGBColor CMMM711Controller::GetLogoColour()
+{
+    return logo_colour;
+}
+
+void CMMM711Controller::SetLedsDirect(RGBColor wheel_colour, RGBColor logo_colour)
+{
+    unsigned char buffer[CM_MM711_PACKET_SIZE]  = { 0x00, 0x51, 0xA8, 0x00, 0x00 };
+
+    buffer[CM_MM711_MODE_BYTE]                  = RGBGetRValue(wheel_colour);
+    buffer[CM_MM711_SPEED_BYTE]                 = RGBGetGValue(wheel_colour);
+    buffer[CM_MM711_NFI_1]                      = RGBGetBValue(wheel_colour);
+    buffer[CM_MM711_NFI_2]                      = RGBGetRValue(logo_colour);
+    buffer[CM_MM711_NFI_3]                      = RGBGetGValue(logo_colour);
+    buffer[CM_MM711_BRIGHTNESS_BYTE]            = RGBGetBValue(logo_colour);
+
+    hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+
+    SendApplyPacket(0xB0);  //Apply custom mode
+}
+
+void CMMM711Controller::SendUpdate(uint8_t mode, uint8_t speed, RGBColor colour, uint8_t brightness)
+{
+    unsigned char buffer[CM_MM711_PACKET_SIZE]  = { 0x00, 0x51, 0x2B, 0x00, 0x00 };
+
+    buffer[CM_MM711_MODE_BYTE]                  = mode;
+    buffer[CM_MM711_SPEED_BYTE]                 = speed;
+    buffer[CM_MM711_NFI_1]                      = 0x20;
+    buffer[CM_MM711_NFI_2]                      = 0xFF;
+    buffer[CM_MM711_NFI_3]                      = 0xFF;
+    buffer[CM_MM711_BRIGHTNESS_BYTE]            = brightness;
+    buffer[CM_MM711_RED_BYTE]                   = RGBGetRValue(colour);
+    buffer[CM_MM711_GREEN_BYTE]                 = RGBGetGValue(colour);
+    buffer[CM_MM711_BLUE_BYTE]                  = RGBGetBValue(colour);
+
+    hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+
+    SendApplyPacket(mode);
+}
+
+void CMMM711Controller::SendInitPacket()
+{
+    unsigned char buffer[CM_MM711_PACKET_SIZE]  = { 0x00, 0x41, 0x80 };
+
+    hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+}
+
+void CMMM711Controller::SendApplyPacket(uint8_t mode)
+{
+    unsigned char buffer[CM_MM711_PACKET_SIZE]  = { 0x00, 0x51, 0x28, 0x00, 0x00 };
+
+    buffer[CM_MM711_MODE_BYTE]                  = mode;
+
+    hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+}

Controllers/CoolerMasterController/CMMM711Controller.h

@@ -0,0 +1,100 @@
+/*-------------------------------------------------------------------*\
+|  CMMM711Controller.h                                                |
+|                                                                     |
+|  Driver for Coolermaster Master Mouse 711                           |
+|                                                                     |
+|  Chris M (Dr_No)          14th Feb 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include <string>
+#include <array>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+
+#pragma once
+
+#define CM_MM711_PACKET_SIZE 65
+#define CM_MM711_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
+#define CM_MM711_HEADER_DATA_SIZE (sizeof(argb_header_data) / sizeof(argb_headers) )
+#define CM_MM711_INTERRUPT_TIMEOUT 250
+#define CM_MM711_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
+#define HID_MAX_STR 255
+
+enum
+{
+    CM_MM711_REPORT_BYTE            = 1,
+    CM_MM711_COMMAND_BYTE           = 2,
+    CM_MM711_FUNCTION_BYTE          = 3,
+    CM_MM711_ZONE_BYTE              = 4,
+    CM_MM711_MODE_BYTE              = 5,
+    CM_MM711_SPEED_BYTE             = 6,
+    CM_MM711_NFI_1                  = 7,
+    CM_MM711_NFI_2                  = 8,
+    CM_MM711_NFI_3                  = 9,
+    CM_MM711_BRIGHTNESS_BYTE        = 10,
+    CM_MM711_RED_BYTE               = 11,
+    CM_MM711_GREEN_BYTE             = 12,
+    CM_MM711_BLUE_BYTE              = 13,
+};
+
+enum
+{
+    CM_MM711_MODE_STATIC            = 0,    //Static Mode
+    CM_MM711_MODE_BREATHING         = 1,    //Breathing Mode
+    CM_MM711_MODE_SPECTRUM_CYCLE    = 2,    //Spectrum Cycle Mode
+    CM_MM711_MODE_INDICATOR         = 4,    //Indicator Mode
+    CM_MM711_MODE_CUSTOM            = 176,  //Custom LED Control
+    CM_MM711_MODE_OFF               = 254   //Turn Off
+};
+
+enum
+{
+    CM_MM711_SPEED_SLOWEST          = 0x5F, // Slowest speed
+    CM_MM711_SPEED_NORMAL           = 0x38, // Normal speed
+    CM_MM711_SPEED_FASTEST          = 0x20, // Fastest speed
+};
+
+class CMMM711Controller
+{
+public:
+    CMMM711Controller(hid_device* dev_handle, char *_path);
+    ~CMMM711Controller();
+
+    std::string GetDeviceName();
+    std::string GetSerial();
+    std::string GetLocation();
+
+    uint8_t     GetZoneIndex();
+    uint8_t     GetMode();
+    uint8_t     GetLedRed();
+    uint8_t     GetLedGreen();
+    uint8_t     GetLedBlue();
+    uint8_t     GetLedSpeed();
+    RGBColor    GetWheelColour();
+    RGBColor    GetLogoColour();
+
+    void        SendUpdate(uint8_t mode, uint8_t speed, RGBColor colour, uint8_t brightness);
+    void        SetLedsDirect(RGBColor wheel_colour, RGBColor logo_colour);
+private:
+    std::string device_name;
+    std::string serial;
+    std::string location;
+    hid_device* dev;
+
+    uint8_t     current_mode;
+    uint8_t     current_speed;
+
+    uint8_t     current_brightness;
+    uint8_t     current_red;
+    uint8_t     current_green;
+    uint8_t     current_blue;
+    RGBColor    wheel_colour;
+    RGBColor    logo_colour;
+
+    void        GetColourStatus();
+    void        GetCustomStatus();
+    void        GetModeStatus();
+    void        SendInitPacket();
+    void        SendApplyPacket(uint8_t mode);
+};

Controllers/CoolerMasterController/CMR6000Controller.cpp

@@ -29,7 +29,6 @@ CMR6000Controller::CMR6000Controller(hid_device* dev_handle, char *_path)
     wName  = std::wstring(tmpName);
     serial = std::string(wName.begin(), wName.end());
 
-    GetStatus();        //When setting up device get current status
 }
 
 CMR6000Controller::~CMR6000Controller()
@@ -40,30 +39,6 @@ CMR6000Controller::~CMR6000Controller()
     }
 }
 
-void CMR6000Controller::GetStatus()
-{
-    unsigned char buffer[CM_6K_PACKET_SIZE]     = { 0x00, 0x52, 0xA0, 0x01, 0x00, 0x00, 0x03 };
-    int buffer_size                             = (sizeof(buffer) / sizeof(buffer[0]));
-
-    // Request mode
-    hid_write(dev, buffer, buffer_size);
-    hid_read(dev, buffer, buffer_size);
-
-    unsigned char cmdbuffer[CM_6K_PACKET_SIZE]  = { 0x00, 0x52, 0x2C, 0x01, 0x00 };
-    int cmdbuffer_size                          = (sizeof(cmdbuffer) / sizeof(cmdbuffer[0]));
-
-    current_mode    = buffer[0x0A];
-    cmdbuffer[0x05] = current_mode;
-    hid_write(dev, cmdbuffer, cmdbuffer_size);
-    hid_read(dev, cmdbuffer, cmdbuffer_size);
-
-    current_speed       = cmdbuffer[0x05];
-    current_brightness  = cmdbuffer[0x09];
-    current_red         = cmdbuffer[0x0A];
-    current_green       = cmdbuffer[0x0B];
-    current_blue        = cmdbuffer[0x0C];
-}
-
 std::string CMR6000Controller::GetDeviceName()
 {
     return device_name;
@@ -104,12 +79,17 @@ unsigned char CMR6000Controller::GetLedSpeed()
     return current_speed;
 }
 
+unsigned char CMR6000Controller::GetBrightness()
+{
+    return current_brightness;
+}
+
 bool CMR6000Controller::GetRandomColours()
 {
     return current_random;
 }
 
-void CMR6000Controller::SetMode(unsigned char mode, unsigned char speed, unsigned char red, unsigned char green, unsigned char blue, unsigned char random)
+void CMR6000Controller::SetMode(unsigned char mode, unsigned char speed, unsigned char red, unsigned char green, unsigned char blue, unsigned char random, unsigned char brightness)
 {
     current_mode        = mode;
     current_speed       = speed;
@@ -117,7 +97,7 @@ void CMR6000Controller::SetMode(unsigned char mode, unsigned char speed, unsigne
     current_green       = green;
     current_blue        = blue;
     current_random      = random;
-    current_brightness  = (current_mode == CM_MR6000_MODE_COLOR_CYCLE) ? 0x7F : 0xFF;    //Color_Cycle brightness needs to be clamped to 0x7F to avoid wash out
+    current_brightness  = brightness;
 
     SendUpdate();
 }
@@ -144,7 +124,7 @@ void CMR6000Controller::SendUpdate()
         buffer[0x03] = 0x01;
         buffer[0x04] = 0x00;
         buffer[0x05] = current_mode;
-        buffer[0x06] = (current_mode == CM_MR6000_MODE_STATIC) ? 0xFF: current_speed;
+        buffer[0x06] = (current_mode == CM_MR6000_MODE_DIRECT) ? 0xFF: current_speed;
         buffer[0x07] = (current_mode == CM_MR6000_MODE_BREATHE)? current_random : 0x00; //random (A0)
         buffer[0x08] = (current_mode == CM_MR6000_MODE_BREATHE)? 0x03 : 0xFF;
         //buffer[0x09] = 0xFF;

Controllers/CoolerMasterController/CMR6000Controller.h

@@ -20,7 +20,7 @@
 
 enum
 {
-    CM_MR6000_MODE_STATIC        = 0x00, //Static Mode
+    CM_MR6000_MODE_DIRECT        = 0x00, //Direct Mode
     CM_MR6000_MODE_BREATHE       = 0x01, //Breathe Mode
     CM_MR6000_MODE_COLOR_CYCLE   = 0x02, //Color cycle
     CM_MR6000_MODE_OFF           = 0xFF, //Off
@@ -56,8 +56,9 @@ public:
     unsigned char GetLedGreen();
     unsigned char GetLedBlue();
     unsigned char GetLedSpeed();
+    unsigned char GetBrightness();
     bool          GetRandomColours();
-    void          SetMode(unsigned char mode, unsigned char speed, unsigned char red, unsigned char green, unsigned char blue, unsigned char random);
+    void          SetMode(unsigned char mode, unsigned char speed, unsigned char red, unsigned char green, unsigned char blue, unsigned char random, unsigned char brightness);
 
 private:
     std::string             device_name;
@@ -74,7 +75,6 @@ private:
     unsigned char           current_blue;
     unsigned char           current_brightness;
 
-    void GetStatus();
     void SendUpdate();
     void SendEnableCommand();
     void SendApplyCommand();

Controllers/CoolerMasterController/CMRGBController.cpp

@@ -0,0 +1,367 @@
+/*-------------------------------------------------------------------*\
+|  CMRGBController.cpp                                                |
+|                                                                     |
+|  Driver for Coolermaster RGB USB Controller                         |
+|                                                                     |
+|  Nic W (midgetspy)        13th Apr 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "RGBController_CMRGBController.h"
+#include "CMRGBController.h"
+#include <cstring>
+
+CMRGBController::CMRGBController(hid_device* dev_handle, char* path)
+{
+    const int szTemp = 256;
+    wchar_t tmpName[szTemp];
+
+    dev         = dev_handle;
+    location    = path;
+
+    hid_get_manufacturer_string(dev, tmpName, szTemp);
+    std::wstring wName = std::wstring(tmpName);
+    device_name = std::string(wName.begin(), wName.end());
+
+    hid_get_product_string(dev, tmpName, szTemp);
+    wName = std::wstring(tmpName);
+    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
+
+    hid_get_serial_number_string(dev, tmpName, szTemp);
+    wName = std::wstring(tmpName);
+    serial = std::string(wName.begin(), wName.end());
+
+    ReadCurrentMode();
+}
+
+void CMRGBController::SendFlowControl(unsigned char byte_flag)
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { 0x00, CM_RGBC_OPCODE_OP_FLOW_CONTROL }; //Packets on Windows need a 0x00 if they don't use ReportIDs
+
+    buffer[0x02] = byte_flag;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+}
+
+void CMRGBController::SendApply()
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { 0x00, CM_RGBC_OPCODE_OP_UNKNOWN_50, CM_RGBC_OPCODE_TYPE_UNKNOWN_55 }; //Packets on Windows need a 0x00 if they don't use ReportIDs
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+}
+
+void CMRGBController::SendReadMode()
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { };
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_OP]     = CM_RGBC_OPCODE_OP_READ;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_TYPE]   = CM_RGBC_OPCODE_TYPE_MODE;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+
+    current_mode = buffer[CM_RGBC_PACKET_OFFSET_MODE];
+}
+
+void CMRGBController::SendSetMode(unsigned char mode)
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { };
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_OP]     = CM_RGBC_OPCODE_OP_WRITE;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_TYPE]   = CM_RGBC_OPCODE_TYPE_MODE;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MODE]   = mode;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+}
+
+void CMRGBController::SendSetCustomColors(RGBColor color_1, RGBColor color_2, RGBColor color_3, RGBColor color_4)
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { };
+
+    current_port1_color = color_1;
+    current_port2_color = color_2;
+    current_port3_color = color_3;
+    current_port4_color = color_4;
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_OP]                     = CM_RGBC_OPCODE_OP_WRITE;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_TYPE]                   = CM_RGBC_OPCODE_TYPE_LED_INFO;
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_1]       = RGBGetRValue(color_1);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_1 + 1]   = RGBGetGValue(color_1);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_1 + 2]   = RGBGetBValue(color_1);
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_2]       = RGBGetRValue(color_2);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_2 + 1]   = RGBGetGValue(color_2);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_2 + 2]   = RGBGetBValue(color_2);
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_3]       = RGBGetRValue(color_3);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_3 + 1]   = RGBGetGValue(color_3);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_3 + 2]   = RGBGetBValue(color_3);
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_4]       = RGBGetRValue(color_4);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_4 + 1]   = RGBGetGValue(color_4);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_4 + 2]   = RGBGetBValue(color_4);
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+}
+
+void CMRGBController::SendReadCustomColors()
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { };
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_OP]     = CM_RGBC_OPCODE_OP_READ;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_TYPE]   = CM_RGBC_OPCODE_TYPE_LED_INFO;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+
+    current_port1_color = ToRGBColor(
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_1],
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_1 + 1],
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_1 + 2]);
+    current_port2_color = ToRGBColor(
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_2],
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_2 + 1],
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_2 + 2]);
+    current_port3_color = ToRGBColor(
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_3],
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_3 + 1],
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_3 + 2]);
+    current_port4_color = ToRGBColor(
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_4],
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_4 + 1],
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_4 + 2]);
+}
+
+void CMRGBController::SendSetConfig(unsigned char mode, unsigned char speed, unsigned char brightness, RGBColor color_1, RGBColor color_2, bool simplified=false, bool multilayer=false)
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { };
+
+    current_mode            = mode;
+    current_speed           = speed;
+    current_brightness      = brightness;
+    current_mode_color_1    = color_1;
+    current_mode_color_2    = color_2;
+
+    /*---------------------------------------------*\
+    | Handle special cases                          |
+    \*---------------------------------------------*/
+    switch(mode)
+    {
+        case CM_RGBC_MODE_COLOR_CYCLE:
+            brightness  = 0xDF;
+            color_1     = 0xFFFFFF;
+            color_2     = 0x000000;
+            break;
+
+        case CM_RGBC_MODE_OFF:
+            brightness  = 0x03;
+            break;
+    }
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_OP]                 = CM_RGBC_OPCODE_OP_WRITE;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_TYPE]               = simplified ? CM_RGBC_OPCODE_TYPE_CONFIG_SIMPLIFIED : CM_RGBC_OPCODE_TYPE_CONFIG_FULL;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MODE]               = mode;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_SPEED]              = speed;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_BRIGHTNESS]         = brightness;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_COLOR_1]            = RGBGetRValue(color_1);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_COLOR_1 + 1]        = RGBGetGValue(color_1);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_COLOR_1 + 2]        = RGBGetBValue(color_1);
+
+    /*---------------------------------------------*\
+    | Magic values, meaning unknown                 |
+    \*---------------------------------------------*/
+    buffer[REPORT_ID_OFFSET + 0x06] = (mode == CM_RGBC_MODE_BREATHING)  ? 0x20 : 0x00;
+    buffer[REPORT_ID_OFFSET + 0x07] = (mode == CM_RGBC_MODE_STAR)       ? 0x19 : 0xFF;
+    buffer[REPORT_ID_OFFSET + 0x08]                                     = 0xFF;
+
+    if(!simplified)
+    {
+        buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTILAYER]     = multilayer ? 0x01 : 0x00;
+        buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_COLOR_2]        = RGBGetRValue(color_2);
+        buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_COLOR_2 + 1]    = RGBGetGValue(color_2);
+        buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_COLOR_2 + 2]    = RGBGetBValue(color_2);
+
+        for(int i = REPORT_ID_OFFSET + 16; i < CM_RGBC_PACKET_SIZE; i++)
+        {
+            buffer[i] = 0xFF;
+        }
+    }
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+}
+
+void CMRGBController::SendReadConfig(unsigned char mode)
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { };
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_OP]             = CM_RGBC_OPCODE_OP_READ;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_TYPE]           = CM_RGBC_OPCODE_TYPE_CONFIG_FULL;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MODE]           = mode;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+
+    current_mode            = mode;
+    current_speed           = buffer[CM_RGBC_PACKET_OFFSET_SPEED];
+    current_brightness      = buffer[CM_RGBC_PACKET_OFFSET_BRIGHTNESS];
+
+    current_mode_color_1    = ToRGBColor(
+        buffer[CM_RGBC_PACKET_OFFSET_COLOR_1],
+        buffer[CM_RGBC_PACKET_OFFSET_COLOR_1 + 1],
+        buffer[CM_RGBC_PACKET_OFFSET_COLOR_1 + 2]);
+    current_mode_color_2    = ToRGBColor(
+        buffer[CM_RGBC_PACKET_OFFSET_COLOR_2],
+        buffer[CM_RGBC_PACKET_OFFSET_COLOR_2 + 1],
+        buffer[CM_RGBC_PACKET_OFFSET_COLOR_2 + 2]);
+}
+
+void CMRGBController::SendCustomColorStart()
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { };
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_OP]     = CM_RGBC_OPCODE_OP_WRITE;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_TYPE]   = CM_RGBC_OPCODE_TYPE_UNKNOWN_30;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+}
+
+void CMRGBController::ReadCurrentMode()
+{
+    SendFlowControl(CM_RGBC_OPCODE_FLOW_01);
+
+    SendReadMode();
+}
+
+void CMRGBController::ReadModeConfig(unsigned char mode)
+{
+    SendFlowControl(CM_RGBC_OPCODE_FLOW_00);
+
+    SendReadConfig(mode);
+
+    if(mode == CM_RGBC_MODE_MULTIPLE)
+    {
+        SendReadCustomColors();
+    }
+}
+
+void CMRGBController::SetMode(unsigned char mode, unsigned char speed, unsigned char brightness, RGBColor color_1, RGBColor color_2)
+{
+    SendFlowControl(CM_RGBC_OPCODE_FLOW_01);
+
+    SendSetConfig(mode, speed, brightness, color_1, color_2, false);
+
+    SendSetMode(mode);
+
+    SendApply();
+
+    SendFlowControl(CM_RGBC_OPCODE_FLOW_00);
+}
+
+void CMRGBController::SetLedsDirect(RGBColor color_1, RGBColor color_2, RGBColor color_3, RGBColor color_4)
+{
+    SendFlowControl(CM_RGBC_OPCODE_FLOW_80);
+
+    SendCustomColorStart();
+
+    SendSetCustomColors(color_1, color_2, color_3, color_4);
+
+    SendSetMode(CM_RGBC_MODE_MULTIPLE);
+
+    SendCustomColorStart();
+
+    SendSetConfig(CM_RGBC_MODE_MULTIPLE, 0x00, 0xFF, color_1, 0x000000, false);
+
+    SendApply();
+
+    SendFlowControl(CM_RGBC_OPCODE_FLOW_00);
+}
+
+std::string CMRGBController::GetDeviceName()
+{
+    return(device_name);
+}
+
+std::string CMRGBController::GetSerial()
+{
+    return(serial);
+}
+
+std::string CMRGBController::GetLocation()
+{
+    return("HID: " + location);
+}
+
+unsigned char CMRGBController::GetMode()
+{
+    return(current_mode);
+}
+
+unsigned char CMRGBController::GetSpeed()
+{
+    return(current_speed);
+}
+
+unsigned char CMRGBController::GetBrightness()
+{
+    return(current_brightness);
+}
+
+RGBColor CMRGBController::GetModeColor(int color_number)
+{
+    switch(color_number)
+    {
+        case 0:
+            return(current_mode_color_1);
+        
+        case 1:
+            return(current_mode_color_2);
+        
+        default:
+            return(ToRGBColor(0, 0, 0));
+    }
+}
+
+RGBColor CMRGBController::GetPortColor(int port_number)
+{
+    switch(port_number)
+    {
+        case 0:
+            return(current_port1_color);
+        
+        case 1:
+            return(current_port2_color);
+        
+        case 2:
+            return(current_port3_color);
+        
+        case 3:
+            return(current_port4_color);
+        
+        default:
+            return(ToRGBColor(0, 0, 0));
+    }
+}
+
+CMRGBController::~CMRGBController()
+{
+    if(dev)
+    {
+        hid_close(dev);
+    }
+}

Controllers/CoolerMasterController/CMRGBController.h

@@ -0,0 +1,149 @@
+/*-------------------------------------------------------------------*\
+|  CMRGBController.h                                                  |
+|                                                                     |
+|  Driver for Coolermaster RGB USB Controller                         |
+|                                                                     |
+|  Nic W (midgetspy)        13th Apr 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include <string>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+
+#pragma once
+#define CM_RGBC_NUM_LEDS 4
+
+#define REPORT_ID_OFFSET                        1
+#define CM_RGBC_PACKET_SIZE                     64 + REPORT_ID_OFFSET //This needs to have one byte extra for the report ID thing
+#define CM_RGBC_PACKET_OFFSET_OP                0x00
+#define CM_RGBC_PACKET_OFFSET_TYPE              0x01
+#define CM_RGBC_PACKET_OFFSET_MULTILAYER        0x02
+#define CM_RGBC_PACKET_OFFSET_MODE              0x04
+#define CM_RGBC_PACKET_OFFSET_SPEED             0x05
+#define CM_RGBC_PACKET_OFFSET_BRIGHTNESS        0x09
+#define CM_RGBC_PACKET_OFFSET_COLOR_1           0x0A
+#define CM_RGBC_PACKET_OFFSET_COLOR_2           0x0D
+
+#define CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_1  0x04
+#define CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_2  0x07
+#define CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_3  0x0A
+#define CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_4  0x0D
+
+#define CM_RGBC_INTERRUPT_TIMEOUT               250
+
+#define CM_RGBC_SPEED_NONE                      0x05
+#define CM_RGBC_BRIGHTNESS_OFF                  0x03
+
+/*-------------------------------------------------*\
+| OP OPCODES                                        |
+\*-------------------------------------------------*/
+enum
+{
+    CM_RGBC_OPCODE_OP_FLOW_CONTROL          = 0x41,
+    CM_RGBC_OPCODE_OP_UNKNOWN_50            = 0x50,
+    CM_RGBC_OPCODE_OP_WRITE                 = 0x51,
+    CM_RGBC_OPCODE_OP_READ                  = 0x52,
+};
+
+/*-------------------------------------------------*\
+| CONTROL FLOW OPCODES                              |
+\*-------------------------------------------------*/
+enum
+{
+    CM_RGBC_OPCODE_FLOW_00                  = 0x00,
+    CM_RGBC_OPCODE_FLOW_01                  = 0x01,
+    CM_RGBC_OPCODE_FLOW_80                  = 0x80,
+};
+
+/*-------------------------------------------------*\
+| OP TYPE OPCODES                                   |
+\*-------------------------------------------------*/
+enum
+{
+    CM_RGBC_OPCODE_TYPE_MODE                = 0x28,
+    CM_RGBC_OPCODE_TYPE_CONFIG_SIMPLIFIED   = 0x2B,
+    CM_RGBC_OPCODE_TYPE_CONFIG_FULL         = 0x2C,
+    CM_RGBC_OPCODE_TYPE_UNKNOWN_30          = 0x30,
+    CM_RGBC_OPCODE_TYPE_UNKNOWN_55          = 0x55,
+    CM_RGBC_OPCODE_TYPE_LED_INFO            = 0xA8,
+};
+
+/*-------------------------------------------------*\
+| MODES                                             |
+\*-------------------------------------------------*/
+enum
+{
+    CM_RGBC_MODE_STATIC                     = 0x00,
+    CM_RGBC_MODE_BREATHING                  = 0x01,
+    CM_RGBC_MODE_COLOR_CYCLE                = 0x02,
+    CM_RGBC_MODE_STAR                       = 0x03,
+    CM_RGBC_MODE_MULTIPLE                   = 0x04,
+    CM_RGBC_MODE_MULTILAYER                 = 0xE0,
+    CM_RGBC_MODE_OFF                        = 0xFE,
+};
+
+/*-------------------------------------------------*\
+| SPEED                                             |
+\*-------------------------------------------------*/
+enum
+{
+    CM_RGBC_SPEED_BREATHING_SLOWEST         = 0x3C,
+    CM_RGBC_SPEED_BREATHING_FASTEST         = 0x26,
+    CM_RGBC_SPEED_COLOR_CYCLE_SLOWEST       = 0x96,
+    CM_RGBC_SPEED_COLOR_CYCLE_FASTEST       = 0x68,
+    CM_RGBC_SPEED_STAR_SLOWEST              = 0x46,
+    CM_RGBC_SPEED_STAR_FASTEST              = 0x32,
+};
+
+class CMRGBController
+{
+public:
+    CMRGBController(hid_device* dev_handle, char* path);
+    ~CMRGBController();
+
+    std::string         GetDeviceName();
+    std::string         GetSerial();
+    std::string         GetLocation();
+
+    unsigned char       GetMode();
+    unsigned char       GetSpeed();
+    unsigned char       GetBrightness();
+    RGBColor            GetModeColor(int color_number);
+    RGBColor            GetPortColor(int port_number);
+
+    void                SetMode(unsigned char mode, unsigned char speed, unsigned char brightness, RGBColor color_1, RGBColor color_2);
+    void                SetLedsDirect(RGBColor color_1, RGBColor color_2, RGBColor color_3, RGBColor color_4);
+
+    void                ReadCurrentMode();
+    void                ReadModeConfig(unsigned char mode);
+
+private:
+    std::string         device_name;
+    std::string         serial;
+    std::string         location;
+    hid_device*         dev;
+
+    unsigned char       current_mode;
+    unsigned char       current_speed;
+    unsigned char       current_brightness;
+    RGBColor            current_mode_color_1;
+    RGBColor            current_mode_color_2;
+    RGBColor            current_port1_color;
+    RGBColor            current_port2_color;
+    RGBColor            current_port3_color;
+    RGBColor            current_port4_color;
+
+    void                SendFlowControl(unsigned char byte_flag);
+    void                SendApply();
+    void                SendCustomColorStart();
+
+    void                SendReadMode();
+    void                SendSetMode(unsigned char mode);
+
+    void                SendReadCustomColors();
+    void                SendSetCustomColors(RGBColor color_1, RGBColor color_2, RGBColor color_3, RGBColor color_4);
+
+    void                SendReadConfig(unsigned char mode);
+    void                SendSetConfig(unsigned char mode, unsigned char speed, unsigned char brightness, RGBColor color_1, RGBColor color_2, bool simplified, bool multilayer);
+};

Controllers/CoolerMasterController/CMSmallARGBController.cpp

@@ -135,50 +135,47 @@ void CMSmallARGBController::SetLedCount(int zone, int led_count)
     hid_write(dev, buffer, buffer_size);
 }
 
-void CMSmallARGBController::SetMode(unsigned char mode, unsigned char speed, RGBColor colour, bool random_colours)
+void CMSmallARGBController::SetMode(unsigned char mode, unsigned char speed, unsigned char brightness, RGBColor colour, bool random_colours)
 {
-    current_mode    = mode;
-    current_speed   = speed;
-    current_red     = RGBGetRValue(colour);
-    current_green   = RGBGetGValue(colour);
-    current_blue    = RGBGetBValue(colour);
-    bool_random     = random_colours;
+    current_mode        = mode;
+    current_speed       = speed;
+    current_brightness  = brightness;
+    current_red         = RGBGetRValue(colour);
+    current_green       = RGBGetGValue(colour);
+    current_blue        = RGBGetBValue(colour);
+    bool_random         = random_colours;
 
     SendUpdate();
 }
 
-void CMSmallARGBController::SetLedsDirect(RGBColor* /*led_colours*/, unsigned int /*led_count*/)
+void CMSmallARGBController::SetLedsDirect(RGBColor* led_colours, unsigned int led_count)
 {
-    // Mode not yet Tested
-    /*
-    const unsigned char buffer_size     = 0x41;
-    unsigned char buffer[buffer_size]   = { 0x00 };
-    unsigned char packet_count          = 0x00;
-    std::vector<unsigned char> colours;
+    const unsigned char buffer_size     = CM_SMALL_ARGB_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { 0x00, 0x00, 0x10, 0x02 };
+    unsigned char packet_count          = 0;
+    std::vector<uint8_t> colours;
 
-    //Set up the RGB triplets to send
-    for(int i = 0; i < led_count; i++)
+    /*---------------------------------------------*\
+    | Set up the RGB triplets to send               |
+    \*---------------------------------------------*/
+    for(unsigned int i = 0; i < led_count; i++)
     {
         RGBColor      colour            = led_colours[i];
-        unsigned char r                 = RGBGetRValue(colour);
-        unsigned char g                 = RGBGetGValue(colour);
-        unsigned char b                 = RGBGetBValue(colour);
 
-        colours.push_back(r);
-        colours.push_back(g);
-        colours.push_back(b);
+        colours.push_back( RGBGetRValue(colour) );
+        colours.push_back( RGBGetGValue(colour) );
+        colours.push_back( RGBGetBValue(colour) );
     }
 
-    //buffer[CM_ARGB_REPORT_BYTE]       = packet_count;
-    buffer[CM_SMALL_ARGB_COMMAND_BYTE]  = 0x10;
-    buffer[CM_SMALL_ARGB_FUNCTION_BYTE] = 0x02;
-    buffer[CM_SMALL_ARGB_ZONE_BYTE]     = small_argb_header_data[zone_index].header;
-    buffer[CM_SMALL_ARGB_MODE_BYTE]     = 0x30; //30 might be the LED count??
-    unsigned char buffer_idx            = CM_SMALL_ARGB_MODE_BYTE + 1;    //Start colour info from
+    buffer[CM_SMALL_ARGB_ZONE_BYTE]     = zone_index - 1; //argb_header_data[zone_index].header;
+    buffer[CM_SMALL_ARGB_MODE_BYTE]     = led_count;
+    unsigned char buffer_idx            = CM_SMALL_ARGB_MODE_BYTE + 1;
 
-    for (std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = 0)
+    for(std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = CM_SMALL_ARGB_COMMAND_BYTE)
     {
-        //Fill the write buffer till its full or the colour buffer is empty
+        /*-----------------------------------------------------------------*\
+        | Fill the write buffer till its full or the colour buffer is empty |
+        \*-----------------------------------------------------------------*/
         buffer[CM_SMALL_ARGB_REPORT_BYTE] = packet_count;
         while (( buffer_idx < buffer_size) && ( it != colours.end() ))
         {
@@ -187,24 +184,19 @@ void CMSmallARGBController::SetLedsDirect(RGBColor* /*led_colours*/, unsigned in
             it++;
         }
 
-        hid_write(dev, buffer, buffer_size);
-        hid_read_timeout(dev, buffer, buffer_size, CM_SMALL_ARGB_INTERRUPT_TIMEOUT);
+        if(it == colours.end())
+        {
+            buffer[CM_SMALL_ARGB_REPORT_BYTE] += 0x80;
+        }
 
-        //reset the write buffer
-        memset(buffer, 0x00, sizeof(buffer) );
+        hid_write(dev, buffer, buffer_size);
+
+        /*-----------------------------------------------------------------*\
+        | Reset the write buffer                                            |
+        \*-----------------------------------------------------------------*/
+        memset(buffer, 0x00, buffer_size );
         packet_count++;
     }
-    buffer[CM_SMALL_ARGB_REPORT_BYTE]         = 0x82;
-    buffer[CM_SMALL_ARGB_COMMAND_BYTE]        = 0x62;
-    buffer[CM_SMALL_ARGB_FUNCTION_BYTE]       = 0x00;
-    buffer[CM_SMALL_ARGB_ZONE_BYTE]           = 0x73;
-    buffer[CM_SMALL_ARGB_MODE_BYTE]           = 0x00;
-    buffer[CM_SMALL_ARGB_SPEED_BYTE]          = 0x33;
-    buffer[CM_SMALL_ARGB_COLOUR_INDEX_BYTE]   = 0x18;
-
-    hid_write(dev, buffer, buffer_size);
-    hid_read_timeout(dev, buffer, buffer_size, CM_SMALL_ARGB_INTERRUPT_TIMEOUT);
-    */
 }
 
 void CMSmallARGBController::SendUpdate()
@@ -227,7 +219,7 @@ void CMSmallARGBController::SendUpdate()
     buffer[CM_SMALL_ARGB_MODE_BYTE]                     = current_mode;
     buffer[CM_SMALL_ARGB_SPEED_BYTE]                    = current_speed;
     buffer[CM_SMALL_ARGB_COLOUR_INDEX_BYTE]             = (bool_random) ? 0x00 : 0x10; //This looks to still be the colour index and controls random colours
-    buffer[CM_SMALL_ARGB_BRIGHTNESS_BYTE]               = 0xFF;
+    buffer[CM_SMALL_ARGB_BRIGHTNESS_BYTE]               = current_brightness;
     buffer[CM_SMALL_ARGB_RED_BYTE]                      = current_red;
     buffer[CM_SMALL_ARGB_GREEN_BYTE]                    = current_green;
     buffer[CM_SMALL_ARGB_BLUE_BYTE]                     = current_blue;

Controllers/CoolerMasterController/CMSmallARGBController.h

@@ -16,7 +16,7 @@
 
 #pragma once
 
-#define CM_SMALL_ARGB_PACKET_SIZE 65
+#define CM_SMALL_ARGB_PACKET_SIZE       65
 #define CM_SMALL_ARGB_INTERRUPT_TIMEOUT 250
 
 enum
@@ -88,7 +88,7 @@ public:
     bool                GetRandomColours();
 
     void                SetLedCount(int zone, int led_count);
-    void                SetMode(unsigned char mode, unsigned char speed, RGBColor colour, bool random_colours);
+    void                SetMode(unsigned char mode, unsigned char speed, unsigned char brightness, RGBColor colour, bool random_colours);
     void                SetLedsDirect(RGBColor * led_colours, unsigned int led_count);
 private:
     std::string         device_name;

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -1,23 +1,29 @@
 #include "Detector.h"
+#include "CMMM711Controller.h"
 #include "CMMP750Controller.h"
 #include "CMARGBcontroller.h"
 #include "CMSmallARGBController.h"
+#include "CMRGBController.h"
 #include "CMR6000Controller.h"
 #include "CMMKController.h"
 #include "RGBController.h"
+#include "RGBController_CMMM711Controller.h"
 #include "RGBController_CMMP750Controller.h"
 #include "RGBController_CMARGBController.h"
 #include "RGBController_CMSmallARGBController.h"
+#include "RGBController_CMRGBController.h"
 #include "RGBController_CMR6000Controller.h"
 #include "RGBController_CMMKController.h"
 #include <hidapi/hidapi.h>
 
 #define COOLERMASTER_VID                        0x2516
 
+#define COOLERMASTER_MM711_PID                  0x0101
 #define COOLERMASTER_MP750_XL_PID               0x0109
 #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
@@ -34,18 +40,6 @@
 *                                                                                          *
 \******************************************************************************************/
 
-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);
-        RGBController_CMMP750Controller* rgb_controller = new RGBController_CMMP750Controller(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
 void DetectCoolerMasterARGB(hid_device_info* info, const std::string&)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -61,18 +55,6 @@ void DetectCoolerMasterARGB(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);
-        RGBController_CMSmallARGBController* rgb_controller = new RGBController_CMSmallARGBController(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
 void DetectCoolerMasterGPU(hid_device_info* info, const std::string&)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -98,14 +80,64 @@ void DetectCoolerMasterKeyboards(hid_device_info* info, const std::string&)
     }
 }
 
-REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 XL",                 DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_XL_PID,                  0xFF00, 1        );
-REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 Medium",             DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_MEDIUM_PID,              0xFF00, 1        );
+void DetectCoolerMasterMouse(hid_device_info* info, const std::string&)
+{
+    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);
+    }
+}
+
+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);
+        RGBController_CMMP750Controller* rgb_controller = new RGBController_CMMP750Controller(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+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);
+        RGBController_CMRGBController* rgb_controller = new RGBController_CMRGBController(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+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);
+        RGBController_CMSmallARGBController* rgb_controller = new RGBController_CMSmallARGBController(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR_IPU("Cooler Master MM711",                    DetectCoolerMasterMouse,        COOLERMASTER_VID,   COOLERMASTER_MM711_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 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);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro S",         DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_S_PID,          1,      0xFF00, 1);
 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 Smalll ARGB",              DetectCoolerMasterSmallARGB,    COOLERMASTER_VID,   COOLERMASTER_SMALL_ARGB_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,                       0,      0xFF00, 1);
 REGISTER_HID_DETECTOR_I  ("Cooler Master Radeon 6000 GPU",          DetectCoolerMasterGPU,          COOLERMASTER_VID,   COOLERMASTER_RADEON_6000_PID,               1                );

Controllers/CoolerMasterController/RGBController_CMMM711Controller.cpp

@@ -0,0 +1,191 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMMM711Controller.cpp                                |
+|                                                                     |
+|  Driver for Coolermaster MM711 Controller                           |
+|                                                                     |
+|  Chris M (Dr_No)          14th Feb 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "RGBController_CMMM711Controller.h"
+
+RGBController_CMMM711Controller::RGBController_CMMM711Controller(CMMM711Controller *cmmm711_ptr)
+{
+    cmmm711                         = cmmm711_ptr;
+    uint8_t speed                   = cmmm711->GetLedSpeed();
+
+    name                            = cmmm711->GetDeviceName();
+    vendor                          = "Cooler Master";
+    type                            = DEVICE_TYPE_MOUSE;
+    description                     = cmmm711->GetDeviceName();
+    version                         = "1.0";
+    serial                          = cmmm711->GetSerial();
+    location                        = cmmm711->GetLocation();
+
+    mode Custom;
+    Custom.name                     = "Direct";
+    Custom.value                    = CM_MM711_MODE_CUSTOM;
+    Custom.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Custom.brightness_min           = CM_MM_ARGB_BRIGHTNESS_MIN;
+    Custom.brightness_max           = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
+    Custom.brightness               = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
+    Custom.color_mode               = MODE_COLORS_PER_LED;
+    modes.push_back(Custom);
+
+    mode Static;
+    Static.name                     = "Static";
+    Static.value                    = CM_MM711_MODE_STATIC;
+    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.brightness_min           = CM_MM_ARGB_BRIGHTNESS_MIN;
+    Static.brightness_max           = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
+    Static.brightness               = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
+    Static.colors_min               = 1;
+    Static.colors_max               = 1;
+    Static.colors.resize(Static.colors_max);
+    Static.speed_min                = CM_MM711_SPEED_SLOWEST;
+    Static.speed_max                = CM_MM711_SPEED_FASTEST;
+    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+    Static.speed                    = CM_MM711_SPEED_NORMAL;
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name                  = "Breathing";
+    Breathing.value                 = CM_MM711_MODE_BREATHING;
+    Breathing.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.brightness_min        = CM_MM_ARGB_BRIGHTNESS_MIN;
+    Breathing.brightness_max        = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
+    Breathing.brightness            = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
+    Breathing.colors_min            = 1;
+    Breathing.colors_max            = 1;
+    Breathing.colors.resize(Breathing.colors_max);
+    Breathing.speed_min             = CM_MM711_SPEED_SLOWEST;
+    Breathing.speed_max             = CM_MM711_SPEED_FASTEST;
+    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed                 = CM_MM711_SPEED_NORMAL;
+    modes.push_back(Breathing);
+
+    mode Spectrum_Cycle;
+    Spectrum_Cycle.name             = "Spectrum Cycle";
+    Spectrum_Cycle.value            = CM_MM711_MODE_SPECTRUM_CYCLE;
+    Spectrum_Cycle.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Spectrum_Cycle.brightness_min   = CM_MM_ARGB_BRIGHTNESS_MIN;
+    Spectrum_Cycle.brightness_max   = CM_MM_ARGB_BRIGHTNESS_MAX_SPECTRUM;
+    Spectrum_Cycle.brightness       = CM_MM_ARGB_BRIGHTNESS_MAX_SPECTRUM;
+    Spectrum_Cycle.speed_min        = CM_MM711_SPEED_SLOWEST;
+    Spectrum_Cycle.speed_max        = CM_MM711_SPEED_FASTEST;
+    Spectrum_Cycle.color_mode       = MODE_COLORS_NONE;
+    Spectrum_Cycle.speed            = CM_MM711_SPEED_NORMAL;
+    modes.push_back(Spectrum_Cycle);
+
+    mode Indicator;
+    Indicator.name                  = "Indicator";
+    Indicator.value                 = CM_MM711_MODE_INDICATOR;
+    Indicator.color_mode            = MODE_COLORS_NONE;
+    modes.push_back(Indicator);
+
+    mode Off;
+    Off.name                        = "Turn Off";
+    Off.value                       = CM_MM711_MODE_OFF;
+    Off.color_mode                  = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    Init_Controller();         //Only processed on first run
+    SetupZones();
+
+    uint8_t temp_mode           = cmmm711->GetMode();
+    for(std::size_t mode_index = 0; mode_index < modes.size(); mode_index++)
+    {
+        if (modes[mode_index].value == temp_mode)
+        {
+            active_mode = mode_index;
+            break;
+        }
+    }
+    if (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        modes[active_mode].colors[0] = ToRGBColor(cmmm711->GetLedRed(),cmmm711->GetLedGreen(),cmmm711->GetLedBlue());
+    }
+    colors[0] = cmmm711->GetWheelColour();
+    colors[1] = cmmm711->GetLogoColour();
+}
+
+RGBController_CMMM711Controller::~RGBController_CMMM711Controller()
+{
+    delete cmmm711;
+}
+
+void RGBController_CMMM711Controller::Init_Controller()
+{
+    zone mouse_zone;
+    mouse_zone.name         = "Master Mouse 711";
+    mouse_zone.type         = ZONE_TYPE_LINEAR;
+    mouse_zone.leds_min     = 2;
+    mouse_zone.leds_max     = 2;
+    mouse_zone.leds_count   = 2;
+    mouse_zone.matrix_map   = NULL;
+    zones.push_back(mouse_zone);
+
+    led wheel_led;
+    wheel_led.name          = "Scroll Wheel LED";
+    wheel_led.value         = 0;
+    leds.push_back(wheel_led);
+
+    led logo_led;
+    logo_led.name           = "Logo LED";
+    logo_led.value          = 1;
+    leds.push_back(logo_led);
+}
+
+void RGBController_CMMM711Controller::SetupZones()
+{
+    SetupColors();
+}
+
+void RGBController_CMMM711Controller::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_CMMM711Controller::DeviceUpdateLEDs()
+{
+    cmmm711->SetLedsDirect( colors[0], colors[1] );
+}
+
+void RGBController_CMMM711Controller::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CMMM711Controller::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CMMM711Controller::SetCustomMode()
+{
+    for(std::size_t mode_index = 0; mode_index < modes.size(); mode_index++)
+    {
+        if (modes[mode_index].value == CM_MM711_MODE_CUSTOM)
+        {
+            active_mode = mode_index;
+            break;
+        }
+    }
+}
+
+void RGBController_CMMM711Controller::DeviceUpdateMode()
+{
+    RGBColor colour = 0;
+
+    if (modes[active_mode].value != CM_MM711_MODE_CUSTOM)
+    {
+        if( modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC )
+        {
+            colour = modes[active_mode].colors[0];
+        }
+
+        cmmm711->SendUpdate(modes[active_mode].value, modes[active_mode].speed, colour, modes[active_mode].brightness);
+    }
+}

Controllers/CoolerMasterController/RGBController_CMMM711Controller.h

@@ -0,0 +1,39 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMMM711Controller.h                                  |
+|                                                                     |
+|  Driver for Coolermaster MM711 Controller                           |
+|                                                                     |
+|  Chris M (Dr_No)          14th Feb 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "CMMM711Controller.h"
+#include <vector>
+
+#define CM_MM_ARGB_BRIGHTNESS_MIN           0x00
+#define CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT   0xFF
+#define CM_MM_ARGB_BRIGHTNESS_MAX_SPECTRUM  0x7F
+
+class RGBController_CMMM711Controller : public RGBController
+{
+public:
+    RGBController_CMMM711Controller(CMMM711Controller* cmargb_ptr);
+    ~RGBController_CMMM711Controller();
+
+    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();
+
+    CMMM711Controller* cmmm711;
+};

Controllers/CoolerMasterController/RGBController_CMR6000Controller.cpp

@@ -28,35 +28,41 @@ RGBController_CMR6000Controller::RGBController_CMR6000Controller(CMR6000Controll
     Off.color_mode      = MODE_COLORS_NONE;
     modes.push_back(Off);
 
-    mode Static;
-    Static.name         = "Static";
-    Static.value        = CM_MR6000_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.colors.resize(1);
-    modes.push_back(Static);
+    mode Direct;
+    Direct.name         = "Direct";
+    Direct.value        = CM_MR6000_MODE_DIRECT;
+    Direct.flags        = MODE_FLAG_HAS_PER_LED_COLOR| MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.color_mode   = MODE_COLORS_PER_LED;
+    Direct.colors_min   = 1;
+    Direct.colors_max   = 1;
+    Direct.colors.resize(1);
+    Direct.brightness_min   = 0x00;
+    Direct.brightness_max   = 0xFF;
+    Direct.brightness       = 0xFF;
+    modes.push_back(Direct);
 
     mode ColorCycle;
-    ColorCycle.name       = "Color Cycle";
-    ColorCycle.value      = CM_MR6000_MODE_COLOR_CYCLE;
-    ColorCycle.flags      = MODE_FLAG_HAS_SPEED;
-    ColorCycle.speed_min  = MR6000_CYCLE_SPEED_SLOWEST;
-    ColorCycle.speed      = MR6000_CYCLE_SPEED_NORMAL;
-    ColorCycle.speed_max  = MR6000_CYCLE_SPEED_FASTEST;
-    ColorCycle.color_mode = MODE_COLORS_NONE;
-    ColorCycle.speed      = speed;
+    ColorCycle.name             = "Color Cycle";
+    ColorCycle.value            = CM_MR6000_MODE_COLOR_CYCLE;
+    ColorCycle.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    ColorCycle.speed_min        = MR6000_CYCLE_SPEED_SLOWEST;
+    ColorCycle.speed            = MR6000_CYCLE_SPEED_NORMAL;
+    ColorCycle.speed_max        = MR6000_CYCLE_SPEED_FASTEST;
+    ColorCycle.color_mode       = MODE_COLORS_NONE;
+    ColorCycle.speed            = speed;
+    ColorCycle.brightness_min   = 0x00;
+    ColorCycle.brightness_max   = 0xFF;
+    ColorCycle.brightness       = 0x7F;
     modes.push_back(ColorCycle);
 
     mode Breathing;
     Breathing.name       = "Breathing";
     Breathing.value      = CM_MR6000_MODE_BREATHE;
-    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
     Breathing.speed_min  = MR6000_BREATHE_SPEED_SLOWEST;
     Breathing.speed      = MR6000_BREATHE_SPEED_NORMAL;
     Breathing.speed_max  = MR6000_BREATHE_SPEED_FASTEST;
-    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
     Breathing.colors_min = 1;
     Breathing.colors_max = 1;
     Breathing.colors.resize(1);
@@ -64,19 +70,7 @@ RGBController_CMR6000Controller::RGBController_CMR6000Controller(CMR6000Controll
     modes.push_back(Breathing);    
 
     SetupZones();
-    active_mode = cmr6000->GetMode();
-    if (modes[active_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
-    {
-        modes[active_mode].colors[0] = ToRGBColor(cmr6000->GetLedRed(), cmr6000->GetLedGreen(), cmr6000->GetLedBlue());
-    }
-    if (modes[active_mode].flags & MODE_FLAG_HAS_RANDOM_COLOR)
-    {
-        modes[active_mode].color_mode = (cmr6000->GetRandomColours()) ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
-    }
-    if (modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
-    {
-        modes[active_mode].speed = cmr6000->GetLedSpeed();
-    }
+    active_mode = 1;
 }
 
 RGBController_CMR6000Controller::~RGBController_CMR6000Controller()
@@ -97,6 +91,7 @@ void RGBController_CMR6000Controller::SetupZones()
 
     led GP_led;
     GP_led.name = "Logo";
+    GP_led.value = 0;
     leds.push_back(GP_led);
 
     SetupColors();
@@ -116,16 +111,17 @@ void RGBController_CMR6000Controller::DeviceUpdateLEDs()
     unsigned char grn = 0;
     unsigned char blu = 0;
 
-    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
     {
-        red = RGBGetRValue(modes[active_mode].colors[0]);
-        grn = RGBGetGValue(modes[active_mode].colors[0]);
-        blu = RGBGetBValue(modes[active_mode].colors[0]);
+        red = RGBGetRValue(colors[0]);
+        grn = RGBGetGValue(colors[0]);
+        blu = RGBGetBValue(colors[0]);
     }
 
     unsigned char rnd = (modes[active_mode].color_mode == MODE_COLORS_RANDOM) ? 0xA0 : 0x20;
+    unsigned char bri = (modes[active_mode].flags & MODE_FLAG_HAS_BRIGHTNESS) ? modes[active_mode].brightness : 0xFF;
 
-    cmr6000->SetMode(modes[active_mode].value, modes[active_mode].speed, red, grn, blu, rnd);
+    cmr6000->SetMode(modes[active_mode].value, modes[active_mode].speed, red, grn, blu, rnd, bri);
 }
 
 void RGBController_CMR6000Controller::UpdateZoneLEDs(int /*zone*/)

Controllers/CoolerMasterController/RGBController_CMRGBController.cpp

@@ -0,0 +1,274 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMRGBController.cpp                                  |
+|                                                                     |
+|  Driver for Coolermaster RGB USB Controller                         |
+|                                                                     |
+|  Nic W (midgetspy)        13th Apr 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "RGBController_CMRGBController.h"
+
+/*-----------------------------------------------------------------------------------------------------------------------------------------*\
+| This controller has 4 ports, each for a 12v non-addressable LED item.                                                                     |
+|                                                                                                                                           |
+| It supports the following modes:                                                                                                          |
+|   Static: All 4 ports a single color. Has brightness option.                                                                              |
+|   Breathing: All ports a single color, fading in and out. Has brightness and speed option.                                                |
+|   Star: Some weird effect using all 4 ports and a single color. Has brightness and speed option.                                          |
+|   Color Cycle: All ports cycle through the rainbow in unison. Has brightness and speed option.                                            |
+|   Off: All 4 ports off                                                                                                                    |
+|                                                                                                                                           |
+| Plus some "special" modes:                                                                                                                |
+|   Multilayer: Each of the 4 ports can have any of the modes above applied individually                                                    |
+|   Multiple Color/Customize: Each port can be set to its own static color                                                                  |
+|   Mirage: A strobe effect that varies the LED pulse frequency which affects any of the above modes                                        |
+|                                                                                                                                           |
+| Note:                                                                                                                                     |
+|  Multiple Color/Customize is equivalent to Multilayer + Static, but the device supports both separately                                   |
+|  Static is equivalent to Multiple Color/Customize with the same color on each port, but the device supports both separately               |
+|                                                                                                                                           |
+| It can be controlled with 2 different pieces of software: MasterPlus+ or "RGB LED Controller". They appear to use different protocols.    |
+|                                                                                                                                           |
+| RGB LED Controller:                                                                                                                       |
+|   Sets changes temporarily and then applies them or cancels the changes separately                                                        |
+|   Supports all modes above                                                                                                                |
+|   Has 3 brightness increments                                                                                                             |
+|   Has two different colors for the Star effect (Star/Sky)                                                                                 |
+|                                                                                                                                           |
+| MasterPlus+:                                                                                                                              |
+|   Sets changes permanently as soon as you change anything in the UI                                                                       |
+|   Doesn't support Multilayer or Mirage                                                                                                    |
+|   Has 5 brightness increments                                                                                                             |
+|   Single color for Star                                                                                                                   |
+\*-----------------------------------------------------------------------------------------------------------------------------------------*/
+
+RGBController_CMRGBController::RGBController_CMRGBController(CMRGBController *cmrgb_ptr)
+{
+    cmrgb                       = cmrgb_ptr;
+
+    name                        = "Cooler Master RGB Controller";
+    vendor                      = "Cooler Master";
+    type                        = DEVICE_TYPE_LEDSTRIP;
+    description                 = cmrgb->GetDeviceName();
+    version                     = "";
+    serial                      = cmrgb->GetSerial();
+    location                    = cmrgb->GetLocation();
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = CM_RGBC_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_BRIGHTNESS | 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;
+    Static.brightness_min       = 0x00;
+    Static.brightness_max       = 0xFF;
+    Static.brightness           = 0xFF;
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = CM_RGBC_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 1;
+    Breathing.colors.resize(Breathing.colors_max);
+    Breathing.speed_min         = CM_RGBC_SPEED_BREATHING_SLOWEST;
+    Breathing.speed_max         = CM_RGBC_SPEED_BREATHING_FASTEST;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed             = CM_RGBC_SPEED_BREATHING_SLOWEST;
+    Breathing.brightness_min    = 0x00;
+    Breathing.brightness_max    = 0xFF;
+    Breathing.brightness        = 0xFF;
+    modes.push_back(Breathing);
+
+    mode ColorCycle;
+    ColorCycle.name             = "Spectrum Cycle";
+    ColorCycle.value            = CM_RGBC_MODE_COLOR_CYCLE;
+    ColorCycle.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorCycle.speed_min        = CM_RGBC_SPEED_COLOR_CYCLE_SLOWEST;
+    ColorCycle.speed_max        = CM_RGBC_SPEED_COLOR_CYCLE_FASTEST;
+    ColorCycle.color_mode       = MODE_COLORS_RANDOM;
+    ColorCycle.speed            = CM_RGBC_SPEED_COLOR_CYCLE_SLOWEST;
+    ColorCycle.brightness_min   = 0x00;
+    ColorCycle.brightness_max   = 0xFF;
+    ColorCycle.brightness       = 0xFF;
+    modes.push_back(ColorCycle);
+
+    mode Star;
+    Star.name                   = "Star";
+    Star.value                  = CM_RGBC_MODE_STAR;
+    Star.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Star.colors_min             = 2;
+    Star.colors_max             = 2;
+    Star.colors.resize(Star.colors_max);
+    Star.speed_min              = CM_RGBC_SPEED_STAR_SLOWEST;
+    Star.speed_max              = CM_RGBC_SPEED_STAR_FASTEST;
+    Star.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Star.speed                  = CM_RGBC_SPEED_STAR_SLOWEST;
+    Star.brightness_min         = 0x00;
+    Star.brightness_max         = 0xFF;
+    Star.brightness             = 0xFF;
+    modes.push_back(Star);
+
+    mode Multiple;
+    Multiple.name               = "Custom";
+    Multiple.value              = CM_RGBC_MODE_MULTIPLE;
+    Multiple.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Multiple.colors_min         = 1;
+    Multiple.colors_max         = 1;
+    Multiple.colors.resize(Multiple.colors_max);
+    Multiple.color_mode         = MODE_COLORS_PER_LED;
+    Multiple.speed              = 0;
+    Multiple.brightness_min     = 0x00;
+    Multiple.brightness_max     = 0xFF;
+    Multiple.brightness         = 0xFF;
+    modes.push_back(Multiple);
+
+    mode Off;
+    Off.name                = "Off";
+    Off.value               = CM_RGBC_MODE_OFF;
+    Off.color_mode          = MODE_COLORS_NONE;
+    Off.flags               = 0;
+    modes.push_back(Off);
+
+    SetupZones();
+
+    ReadAllModeConfigsFromDevice();
+}
+
+RGBController_CMRGBController::~RGBController_CMRGBController()
+{
+    delete cmrgb;
+}
+
+void RGBController_CMRGBController::ReadAllModeConfigsFromDevice()
+{
+    int device_mode = cmrgb->GetMode();
+
+    for(std::size_t mode_idx = 0; mode_idx < modes.size(); mode_idx++)
+    {
+        if(device_mode == modes[mode_idx].value)
+        {
+            active_mode = mode_idx;
+            continue;
+        }
+
+        if(!modes[mode_idx].flags)
+        {
+            continue;
+        }
+
+        cmrgb->ReadModeConfig(modes[mode_idx].value);
+        LoadConfigFromDeviceController(mode_idx);
+    }
+
+    /*---------------------------------------------------------*\
+    | Do the active mode last so the device controller state    |
+    | is left with the active mode's config                     |
+    \*---------------------------------------------------------*/
+    if(active_mode != -1)
+    {
+        cmrgb->ReadModeConfig(modes[active_mode].value);
+        LoadConfigFromDeviceController(active_mode);
+    }
+}
+
+void RGBController_CMRGBController::LoadConfigFromDeviceController(int mode_idx)
+{
+    for(std::size_t color_idx = 0; color_idx < modes[mode_idx].colors.size(); color_idx++)
+    {
+        modes[mode_idx].colors[0] = cmrgb->GetModeColor(color_idx);
+    }
+
+    if(modes[mode_idx].flags & MODE_FLAG_HAS_PER_LED_COLOR)
+    {
+        for (std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+        {
+            SetLED(led_idx, cmrgb->GetPortColor(led_idx));
+        }
+    }
+
+    if(modes[mode_idx].flags & MODE_FLAG_HAS_SPEED)
+    {
+        modes[mode_idx].speed = cmrgb->GetSpeed();
+    }
+
+    if(modes[mode_idx].flags & MODE_FLAG_HAS_BRIGHTNESS)
+    {
+        modes[active_mode].brightness = cmrgb->GetBrightness();
+    }
+}
+
+
+void RGBController_CMRGBController::SetupZones()
+{
+    leds.clear();
+    zones.clear();
+    colors.clear();
+
+    /*-----------------------------------------------------*\
+    | One zone, 4 leds. This might not actually work with   |
+    | the Multilayer mode, but we'll deal with that later   |
+    \*-----------------------------------------------------*/
+    zone* new_zone          = new zone();
+    new_zone->name          = "Controller";
+    new_zone->type          = ZONE_TYPE_SINGLE;
+    new_zone->leds_min      = 1;
+    new_zone->leds_max      = 4;
+    new_zone->leds_count    = 4;
+    new_zone->matrix_map    = NULL;
+
+    for(int i = 1; i <= CM_RGBC_NUM_LEDS; i++)
+    {
+        led*  new_led  = new led();
+        new_led->name  = "LED " + std::to_string(i);
+        leds.push_back(*new_led);
+    }
+
+    zones.push_back(*new_zone);
+    SetupColors();
+}
+
+void RGBController_CMRGBController::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+}
+
+void RGBController_CMRGBController::DeviceUpdateLEDs()
+{
+    for(size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        UpdateZoneLEDs(zone_idx);
+    }
+}
+
+void RGBController_CMRGBController::UpdateZoneLEDs(int zone)
+{
+    cmrgb->SetLedsDirect(zones[zone].colors[0], zones[zone].colors[1], zones[zone].colors[2], zones[zone].colors[3]);
+}
+
+void RGBController_CMRGBController::UpdateSingleLED(int /*led*/)
+{
+}
+
+void RGBController_CMRGBController::SetCustomMode()
+{
+    for(std::size_t mode_idx = 0; mode_idx < modes.size() ; mode_idx++)
+    {
+        if (modes[mode_idx].value == CM_RGBC_MODE_MULTIPLE)
+        {
+            active_mode = mode_idx;
+            break;
+        }
+    }
+}
+
+void RGBController_CMRGBController::DeviceUpdateMode()
+{
+    RGBColor color_1 = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
+    RGBColor color_2 = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && modes[active_mode].colors.size() > 1) ? modes[active_mode].colors[1] : 0;
+
+    cmrgb->SetMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, color_1, color_2);
+}

Controllers/CoolerMasterController/RGBController_CMRGBController.h

@@ -0,0 +1,35 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMRGBController.h                                    |
+|                                                                     |
+|  Driver for Coolermaster RGB USB Controller                         |
+|                                                                     |
+|  Nic W (midgetspy)        13th Apr 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "CMRGBController.h"
+#include <vector>
+
+class RGBController_CMRGBController : public RGBController
+{
+public:
+    RGBController_CMRGBController(CMRGBController* cmrgb_ptr);
+    ~RGBController_CMRGBController();
+
+    void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    CMRGBController*    cmrgb;
+    void                LoadConfigFromDeviceController(int device_mode);
+    void                ReadAllModeConfigsFromDevice();
+};

Controllers/CoolerMasterController/RGBController_CMSmallARGBController.cpp

@@ -11,106 +11,127 @@
 
 RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmallARGBController *cmargb_ptr)
 {
-    cmargb                  = cmargb_ptr;
-    unsigned char speed     = cmargb->GetLedSpeed();
+    cmargb                      = cmargb_ptr;
+    unsigned char speed         = cmargb->GetLedSpeed();
 
-    name                    = small_argb_header_data[cmargb->GetZoneIndex()].name;
-    vendor                  = "Cooler Master";
-    type                    = DEVICE_TYPE_LEDSTRIP;
-    description             = cmargb->GetDeviceName();
-    version                 = "1.0";
-    serial                  = cmargb->GetSerial();
-    location                = cmargb->GetLocation();
+    name                        = small_argb_header_data[cmargb->GetZoneIndex()].name;
+    vendor                      = "Cooler Master";
+    type                        = DEVICE_TYPE_LEDSTRIP;
+    description                 = cmargb->GetDeviceName();
+    version                     = "2.0 for FW0012";
+    serial                      = cmargb->GetSerial();
+    location                    = cmargb->GetLocation();
 
     mode Off;
-    Off.name                = "Turn Off";
-    Off.value               = CM_SMALL_ARGB_MODE_OFF;
-    Off.color_mode          = MODE_COLORS_NONE;
+    Off.name                    = "Turn Off";
+    Off.value                   = CM_SMALL_ARGB_MODE_OFF;
+    Off.color_mode              = MODE_COLORS_NONE;
     modes.push_back(Off);
 
     mode Reload;
-    Reload.name             = "Reload";
-    Reload.value            = CM_SMALL_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_SMALL_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_SMALL_ARGB_SPEED_SLOWEST;
-    Reload.speed_max        = CM_SMALL_ARGB_SPEED_FASTEST;
-    Reload.color_mode       = MODE_COLORS_RANDOM;
-    Reload.speed            = speed;
+    Reload.brightness_min       = 0;
+    Reload.brightness_max       = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Reload.brightness           = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Reload.speed_min            = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Reload.speed_max            = CM_SMALL_ARGB_SPEED_FASTEST;
+    Reload.color_mode           = MODE_COLORS_RANDOM;
+    Reload.speed                = speed;
     modes.push_back(Reload);
 
     mode Recoil;
-    Recoil.name             = "Recoil";
-    Recoil.value            = CM_SMALL_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_SMALL_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_SMALL_ARGB_SPEED_SLOWEST;
-    Recoil.speed_max        = CM_SMALL_ARGB_SPEED_FASTEST;
-    Recoil.color_mode       = MODE_COLORS_RANDOM;
-    Recoil.speed            = speed;
+    Recoil.brightness_min       = 0;
+    Recoil.brightness_max       = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Recoil.brightness           = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Recoil.speed_min            = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Recoil.speed_max            = CM_SMALL_ARGB_SPEED_FASTEST;
+    Recoil.color_mode           = MODE_COLORS_RANDOM;
+    Recoil.speed                = speed;
     modes.push_back(Recoil);
 
     mode Breathing;
-    Breathing.name          = "Breathing";
-    Breathing.value         = CM_SMALL_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_SMALL_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_SMALL_ARGB_SPEED_SLOWEST;
-    Breathing.speed_max     = CM_SMALL_ARGB_SPEED_FASTEST;
-    Breathing.color_mode    = MODE_COLORS_RANDOM;
-    Breathing.speed         = speed;
+    Breathing.brightness_min    = 0;
+    Breathing.brightness_max    = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Breathing.brightness        = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Breathing.speed_min         = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Breathing.speed_max         = CM_SMALL_ARGB_SPEED_FASTEST;
+    Breathing.color_mode        = MODE_COLORS_RANDOM;
+    Breathing.speed             = speed;
     modes.push_back(Breathing);
 
     mode Refill;
-    Refill.name             = "Refill";
-    Refill.value            = CM_SMALL_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_SMALL_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_SMALL_ARGB_SPEED_SLOWEST;
-    Refill.speed_max        = CM_SMALL_ARGB_SPEED_FASTEST;
-    Refill.color_mode       = MODE_COLORS_RANDOM;
-    Refill.speed            = speed;
+    Refill.brightness_min       = 0;
+    Refill.brightness_max       = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Refill.brightness           = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Refill.speed_min            = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Refill.speed_max            = CM_SMALL_ARGB_SPEED_FASTEST;
+    Refill.color_mode           = MODE_COLORS_RANDOM;
+    Refill.speed                = speed;
     modes.push_back(Refill);
 
     mode Demo;
-    Demo.name               = "Demo";
-    Demo.value              = CM_SMALL_ARGB_MODE_DEMO;
-    Demo.flags              = MODE_FLAG_HAS_SPEED;
-    Demo.speed_min          = CM_SMALL_ARGB_SPEED_SLOWEST;
-    Demo.speed_max          = CM_SMALL_ARGB_SPEED_FASTEST;
-    Demo.color_mode         = MODE_COLORS_NONE;
-    Demo.speed              = speed;
+    Demo.name                   = "Demo";
+    Demo.value                  = CM_SMALL_ARGB_MODE_DEMO;
+    Demo.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Demo.brightness_min         = 0;
+    Demo.brightness_max         = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Demo.brightness             = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Demo.speed_min              = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Demo.speed_max              = CM_SMALL_ARGB_SPEED_FASTEST;
+    Demo.color_mode             = MODE_COLORS_NONE;
+    Demo.speed                  = speed;
     modes.push_back(Demo);
 
     mode Spectrum;
-    Spectrum.name           = "Spectrum";
-    Spectrum.value          = CM_SMALL_ARGB_MODE_SPECTRUM;
-    Spectrum.flags          = MODE_FLAG_HAS_SPEED;
-    Spectrum.speed_min      = CM_SMALL_ARGB_SPEED_SLOWEST;
-    Spectrum.speed_max      = CM_SMALL_ARGB_SPEED_FASTEST;
-    Spectrum.color_mode     = MODE_COLORS_NONE;
-    Spectrum.speed          = speed;
+    Spectrum.name               = "Spectrum";
+    Spectrum.value              = CM_SMALL_ARGB_MODE_SPECTRUM;
+    Spectrum.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Spectrum.brightness_min     = 0;
+    Spectrum.brightness_max     = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Spectrum.brightness         = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Spectrum.speed_min          = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Spectrum.speed_max          = CM_SMALL_ARGB_SPEED_FASTEST;
+    Spectrum.color_mode         = MODE_COLORS_NONE;
+    Spectrum.speed              = speed;
     modes.push_back(Spectrum);
 
     mode Direct;
-    Direct.name             = "Direct";
-    Direct.value            = CM_SMALL_ARGB_MODE_DIRECT;
-    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode       = MODE_COLORS_PER_LED;
+    Direct.name                 = "Direct";
+    Direct.value                = CM_SMALL_ARGB_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.brightness_min       = 0;
+    Direct.brightness_max       = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Direct.brightness           = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode PassThru;
-    PassThru.name           = "Pass Thru";
-    PassThru.value          = CM_SMALL_ARGB_MODE_PASSTHRU;
-    PassThru.color_mode     = MODE_COLORS_NONE;
+    PassThru.name               = "Pass Thru";
+    PassThru.value              = CM_SMALL_ARGB_MODE_PASSTHRU;
+    PassThru.color_mode         = MODE_COLORS_NONE;
     modes.push_back(PassThru);
 
     Init_Controller();         //Only processed on first run
@@ -224,17 +245,17 @@ void RGBController_CMSmallARGBController::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_CMSmallARGBController::UpdateZoneLEDs(int /*zone*/)
+void RGBController_CMSmallARGBController::UpdateZoneLEDs(int zone)
 {
-    //bool random_colours     = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
-
-    //cmargb->SetLedsDirect(zones[zone].colors, random_colours);
+    if(serial >= CM_SMALL_ARGB_FW0012)
+    {
+        cmargb->SetLedsDirect( zones[zone].colors, zones[zone].leds_count );
+    }
 }
 
-void RGBController_CMSmallARGBController::UpdateSingleLED(int /*led*/)
+void RGBController_CMSmallARGBController::UpdateSingleLED(int led)
 {
-    //cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed );
-    //cmargb->SetLedsDirect( zones[0].colors, zones[0].leds_count );
+    UpdateZoneLEDs(led);
 }
 
 void RGBController_CMSmallARGBController::SetCustomMode()
@@ -247,5 +268,5 @@ void RGBController_CMSmallARGBController::DeviceUpdateMode()
     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 );
+    cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, colour, random_colours);
 }

Controllers/CoolerMasterController/RGBController_CMSmallARGBController.h

@@ -12,8 +12,10 @@
 #include "CMSmallARGBController.h"
 #include <vector>
 
-#define CM_SMALL_ARGB_MIN_LEDS 4
-#define CM_SMALL_ARGB_MAX_LEDS 48
+#define CM_SMALL_ARGB_MIN_LEDS          4
+#define CM_SMALL_ARGB_MAX_LEDS          48
+#define CM_SMALL_ARGB_BRIGHTNESS_MAX    0xFF
+#define CM_SMALL_ARGB_FW0012            "A202104052336"
 
 class RGBController_CMSmallARGBController : public RGBController
 {

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreController.cpp

@@ -0,0 +1,276 @@
+/*---------------------------------------------------------*\
+|  CorsairCommanderCoreController.cpp                       |
+|                                                           |
+|  Processing Code for Corsair Commander Core               |
+|                                                           |
+|  Jeff P.                                                  |
+\*---------------------------------------------------------*/
+
+#include "CorsairCommanderCoreController.h"
+
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+
+using namespace std::chrono_literals;
+
+CorsairCommanderCoreController::CorsairCommanderCoreController(hid_device* dev_handle, const char* path)
+{
+    dev                     = dev_handle;
+    location                = path;
+    keepalive_thread_run    = 1;
+    controller_ready        = 0;
+
+    /*-----------------------------------------------------*\
+    | Initialize controller                                 |
+    \*-----------------------------------------------------*/
+    InitController();
+
+    /*-----------------------------------------------------*\
+    | Start keepalive thread                                |
+    \*-----------------------------------------------------*/
+    keepalive_thread = new std::thread(&CorsairCommanderCoreController::KeepaliveThread, this);
+}
+
+CorsairCommanderCoreController::~CorsairCommanderCoreController()
+{
+    /*-----------------------------------------------------*\
+    | Close keepalive thread                                |
+    \*-----------------------------------------------------*/
+    keepalive_thread_run = 0;
+    keepalive_thread->join();
+    delete keepalive_thread;
+
+    /*-----------------------------------------------------*\
+    | Close HID device                                      |
+    \*-----------------------------------------------------*/
+    hid_close(dev);
+}
+
+void CorsairCommanderCoreController::InitController()
+{
+    /*-----------------------------------------------------*\
+    | Packet sequence to put controller into direct mode    |
+    \*-----------------------------------------------------*/
+    unsigned char buffarray[][5] =
+    {
+        {0x08, 0x01, 0x03, 0x00, 0x02},
+        {0x08, 0x0D, 0x00, 0x22, 0x00},
+    };
+
+    SendMultiPkt(buffarray, sizeof(buffarray) / sizeof(buffarray[0]), sizeof(buffarray)[0] / sizeof(buffarray[0][0]));
+    SetFanMode();
+}
+
+std::string CorsairCommanderCoreController::GetLocationString()
+{
+    return("HID: " + location);
+}
+
+void CorsairCommanderCoreController::KeepaliveThread()
+{
+    while(keepalive_thread_run.load())
+    {
+        if (controller_ready)
+        {
+            if((std::chrono::steady_clock::now() - last_commit_time) > std::chrono::seconds(10))
+            {
+                SendCommit();
+            }
+        }
+        std::this_thread::sleep_for(1s);
+    }
+}
+
+void CorsairCommanderCoreController::SendCommit()
+{
+    if(!lastcolors.empty())
+    {
+        /*-----------------------------------------------------*\
+        | If colors remain to be sent, send them                |
+        \*-----------------------------------------------------*/
+        SetDirectColor(lastcolors, lastzones);
+    }
+    else
+    {
+        unsigned char   usb_buf[1025];
+
+        /*-----------------------------------------------------*\
+        | Zero out buffer                                       |
+        \*-----------------------------------------------------*/
+        memset(usb_buf, 0x00, sizeof(usb_buf));
+
+        /*-----------------------------------------------------*\
+        | Update last commit time                               |
+        \*-----------------------------------------------------*/
+        last_commit_time    = std::chrono::steady_clock::now();
+
+        /*-----------------------------------------------------*\
+        | Set up Commit packet                                  |
+        \*-----------------------------------------------------*/
+        memset(usb_buf, 0, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+
+        usb_buf[0]          = 0x00;
+        usb_buf[1]          = 0x08;
+        usb_buf[2]          = 0x06;
+        usb_buf[4]          = 0xBD;
+        usb_buf[5]          = 0x02;
+        usb_buf[8]          = 0x12;
+
+        hid_write(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    }
+}
+
+
+void CorsairCommanderCoreController::SendMultiPkt(unsigned char buffarray[][5], int r, int c)
+{
+    /*---------------------------------------------------------*\
+    | Private function to send multiple packets                 |
+    \*---------------------------------------------------------*/
+    unsigned char* hidtemp = new unsigned char[CORSAIR_COMMANDER_CORE_PACKET_SIZE];
+
+    for(unsigned int i = 0; i < r; i++)
+    {
+        memset(hidtemp, 0, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    
+        for(unsigned int j = 0; j < c; j++)
+        {
+            hidtemp[j+1] = buffarray[i][j];
+        }
+
+        hid_write(dev, hidtemp, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+        hid_read(dev, hidtemp, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    }
+}
+
+void CorsairCommanderCoreController::SetDirectColor
+    (
+        std::vector<RGBColor> colors,
+        std::vector<zone> zones
+    )
+{
+    if(controller_ready == 1 && ((std::chrono::steady_clock::now() - last_commit_time) > std::chrono::milliseconds(33)))
+    {
+        lastcolors              = colors;
+        lastzones               = zones;
+        int packet_offset       = CORSAIR_COMMANDER_CORE_PREAMBLE_OFFSET;
+        int led_idx             = 0;
+        int channel_idx         = 0;
+        unsigned char* usb_buf  = new unsigned char[CORSAIR_COMMANDER_CORE_PACKET_SIZE];
+
+        memset(usb_buf, 0, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+
+        /*-----------------------------------------------------*\
+        | Prepare color information packet                      |
+        \*-----------------------------------------------------*/
+        usb_buf[0]              = 0x00;
+        usb_buf[1]              = 0x08;
+        usb_buf[2]              = 0x06;
+        usb_buf[4]              = 0xBD;
+        usb_buf[5]              = 0x02;
+        usb_buf[8]              = 0x12;
+
+        for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+        {
+            /*-------------------------------------------------*\
+            | Add led colors                                    |
+            \*-------------------------------------------------*/
+            for(unsigned int i = led_idx; i < led_idx + zones[zone_idx].leds_count; i++)
+            {
+                usb_buf[packet_offset]   = RGBGetRValue(colors[i]);
+                usb_buf[packet_offset+1] = RGBGetGValue(colors[i]);
+                usb_buf[packet_offset+2] = RGBGetBValue(colors[i]);
+
+                packet_offset = packet_offset + 3;
+            }
+
+            led_idx = led_idx + zones[zone_idx].leds_count;
+
+            /*-------------------------------------------------*\
+            | Move offset for pump zone with less than 29 LEDs  |
+            \*-------------------------------------------------*/
+            if(zone_idx == 0)
+            {
+                packet_offset = packet_offset + 3 * (29 - zones[zone_idx].leds_count);
+            }
+
+            /*-------------------------------------------------*\
+            | Move offset for fans with less than 34 LEDs       |
+            \*-------------------------------------------------*/
+            if(zone_idx != 0)
+            {
+                packet_offset = packet_offset + 3 * (34 - zones[zone_idx].leds_count);
+            }
+
+            channel_idx++;
+        }
+
+        /*-----------------------------------------------------*\
+        | Sending a direct mode color packet resets the timeout |
+        \*-----------------------------------------------------*/
+        last_commit_time = std::chrono::steady_clock::now();
+
+        hid_write(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    }
+}
+
+void CorsairCommanderCoreController::SetFanMode()
+{
+    /*--------------------------------------------------------------------------------------------------*\
+    | Force controller to 6 QL fan mode to expose maximum number of LEDs per rgb port (34 LEDs per port) |
+    \*--------------------------------------------------------------------------------------------------*/
+
+    unsigned char usb_buf[1025];
+
+    unsigned char buffarray4[][5] =
+    {
+        {0x08, 0x05, 0x01, 0x01, 0x00},
+        {0x08, 0x0D, 0x01, 0x1E, 0x00},
+        {0x08, 0x09, 0x01, 0x00, 0x00}
+    };
+
+    SendMultiPkt(buffarray4, sizeof(buffarray4) / sizeof(buffarray4[0]), sizeof(buffarray4)[0] / sizeof(buffarray4[0][0]));
+
+    memset(usb_buf, 0, sizeof(usb_buf));
+
+    usb_buf[0]          = 0x00;
+    usb_buf[1]          = 0x08;
+    usb_buf[2]          = 0x06;
+    usb_buf[3]          = 0x01;
+    usb_buf[4]          = 0x11;
+    usb_buf[8]          = 0x0D;
+    usb_buf[10]         = 0x07;
+    usb_buf[11]         = 0x01;
+    usb_buf[12]         = 0x08;
+
+    for(unsigned int i = 13; i < 25; i = i + 2)
+    {
+        usb_buf[i]      = 0x01;
+        usb_buf[i + 1]  = 0x06;
+    }
+
+    hid_write(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    hid_read(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+
+    unsigned char buffarray2[][5] =
+    {
+        {0x08, 0x05, 0x01, 0x01, 0x00},
+        {0x08, 0x15, 0x01, 0x00, 0x00}
+    };
+
+    SendMultiPkt(buffarray2, sizeof(buffarray2) / sizeof(buffarray2[0]), sizeof(buffarray2)[0] / sizeof(buffarray2[0][0]));
+
+    memset(usb_buf, 0, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+
+    usb_buf[0]          = 0x00;
+    usb_buf[1]          = 0x08;
+    usb_buf[2]          = 0x06;
+    usb_buf[4]          = 0xBD;
+    usb_buf[5]          = 0x02;
+    usb_buf[8]          = 0x12;
+
+    hid_write(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    hid_read(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    
+    controller_ready    = 1;
+}

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreController.h

@@ -0,0 +1,65 @@
+/*---------------------------------------------------------*\
+|  CorsairCommanderCoreController.h                         |
+|                                                           |
+|  Definitions for Corsair Commander Core                   |
+|  Based on code by:                                        |
+|  Adam Honse (calcprogrammer1@gmail.com), 8/17/2020        |
+|                                                           |
+|  Jeff P.                                                  |
+\*---------------------------------------------------------*/
+
+#include "RGBController.h"
+#include <vector>
+#include <chrono>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+#define CORSAIR_COMMANDER_CORE_PACKET_SIZE      1025
+#define CORSAIR_COMMANDER_CORE_PREAMBLE_OFFSET  10
+#define CORSAIR_ELITE_CAPELLIX_PUMP_LED_OFFSET  87
+#define CORSAIR_QL_FAN_ZONE_OFFSET              102
+#define CORSAIR_COMMANDER_CORE_NUM_CHANNELS     6
+
+enum
+{
+    CORSAIR_COMMANDER_CORE_MODE_DIRECT          = 0x00,
+};
+
+class CorsairCommanderCoreController
+{
+public:
+    CorsairCommanderCoreController(hid_device* dev_handle, const char* path);
+    ~CorsairCommanderCoreController();
+
+    std::string GetLocationString();
+
+    void        SetDirectColor
+                (
+                    std::vector<RGBColor>,
+                    std::vector<zone>
+                );
+
+    void        KeepaliveThread();
+    void        SetFanMode();
+
+private:
+    hid_device*             dev;
+    std::thread*            keepalive_thread;
+    std::atomic<bool>       keepalive_thread_run;
+    std::atomic<bool>       controller_ready;
+    std::string             location;
+    std::vector<RGBColor>   lastcolors;
+    std::vector<zone>       lastzones;
+    std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
+
+    void        SendMultiPkt
+                (
+                    unsigned char buffarray[][5],
+                    int r,
+                    int c
+                );
+
+    void        SendCommit();
+    void        InitController();
+};

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreControllerDetect.cpp

@@ -0,0 +1,41 @@
+#include "Detector.h"
+#include "CorsairCommanderCoreController.h"
+#include "RGBController.h"
+#include "RGBController_CorsairCommanderCore.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+/*-----------------------------------------------------*\
+| Corsair vendor ID                                     |
+\*-----------------------------------------------------*/
+#define CORSAIR_VID                         0x1B1C
+
+/*-----------------------------------------------------*\
+| Commander Core product IDs                            |
+\*-----------------------------------------------------*/
+#define CORSAIR_H150I_COMMANDER_CORE_PID    0x0C1C
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectCorsairCapellixControllers                                                       *
+*                                                                                          *
+*       Tests the USB address to see if a Corsair RGB Cooler controller exists there.      *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectCorsairCapellixHIDControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        CorsairCommanderCoreController*     controller     = new CorsairCommanderCoreController(dev, info->path);
+        RGBController_CorsairCommanderCore* rgb_controller = new RGBController_CorsairCommanderCore(controller);
+
+        rgb_controller->name = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR_PU("Corsair Commander Core",  DetectCorsairCapellixHIDControllers, CORSAIR_VID, CORSAIR_H150I_COMMANDER_CORE_PID, 0xFF42, 0x01);

Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.cpp

@@ -0,0 +1,125 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairCapellix.cpp        |
+|                                           |
+|  Generic RGB Interface for Corsair        |
+|  Commander Core                           |
+|                                           |
+|  Jeff P.                                  |
+\*-----------------------------------------*/
+
+#include "RGBController_CorsairCommanderCore.h"
+
+RGBController_CorsairCommanderCore::RGBController_CorsairCommanderCore(CorsairCommanderCoreController* corsair_ptr)
+{
+    corsair     = corsair_ptr;
+
+    vendor      = "Corsair";
+    description = "Corsair Commander Core";
+    type        = DEVICE_TYPE_COOLER;
+    location    = corsair->GetLocationString();
+
+    SetupZones();
+
+    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);
+}
+
+RGBController_CorsairCommanderCore::~RGBController_CorsairCommanderCore()
+{
+    delete corsair;
+}
+
+void RGBController_CorsairCommanderCore::SetupZones()
+{
+    std::atomic<bool> first_run;
+    first_run = 0;
+
+    if(zones.size() == 0)
+    {
+        first_run = 1;
+    }
+
+    zones.resize(7);
+    zones[0].name                   = "Pump";
+    zones[0].type                   = ZONE_TYPE_LINEAR;
+    zones[0].leds_min               = 0;
+    zones[0].leds_max               = 29;
+
+    for(unsigned int i = 1; i < (CORSAIR_COMMANDER_CORE_NUM_CHANNELS + 1); i++)
+    {
+        zones[i].name               = "RGB Port " + std::to_string(i);
+        zones[i].type               = ZONE_TYPE_LINEAR;
+        zones[i].leds_min           = 0;
+        zones[i].leds_max           = 34;
+
+        if(first_run)
+        {
+            zones[i].leds_count = 0;
+        }
+    }
+
+    leds.clear();
+    colors.clear();
+
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        for (unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
+        {
+            led new_led;
+            new_led.name            = zones[zone_idx].name + " LED " + std::to_string(led_idx+1);
+
+            leds.push_back(new_led);
+        }
+    }
+
+    SetupColors();
+}
+
+void RGBController_CorsairCommanderCore::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_CorsairCommanderCore::DeviceUpdateLEDs()
+{
+    DeviceUpdateMode();
+}
+
+void RGBController_CorsairCommanderCore::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CorsairCommanderCore::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CorsairCommanderCore::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_CorsairCommanderCore::DeviceUpdateMode()
+{
+    switch(modes[active_mode].value)
+    {
+        case CORSAIR_COMMANDER_CORE_MODE_DIRECT:
+            corsair->SetDirectColor(colors, zones);
+            break;
+    }
+}

Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairCapellix.h          |
+|                                           |
+|  Generic RGB Interface for Corsair        |
+|  Commander Core                           |
+|                                           |
+|  Jeff P.                                  |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "CorsairCommanderCoreController.h"
+
+class RGBController_CorsairCommanderCore : public RGBController
+{
+public:
+    RGBController_CorsairCommanderCore(CorsairCommanderCoreController* corsair_ptr);
+    ~RGBController_CorsairCommanderCore();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    CorsairCommanderCoreController*     corsair;
+    std::vector<int>                    fanleds{0};
+};

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

@@ -64,7 +64,12 @@ std::string CorsairLightingNodeController::GetLocationString()
 std::string CorsairLightingNodeController::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());
@@ -72,6 +77,14 @@ std::string CorsairLightingNodeController::GetSerialString()
     return(return_string);
 }
 
+void CorsairLightingNodeController::SetBrightness(unsigned char brightness)
+{
+    for(unsigned int channel = 0; channel < CORSAIR_LIGHTING_NODE_NUM_CHANNELS; channel++)
+    {
+        SendBrightness(channel, brightness);
+    }
+}
+
 void CorsairLightingNodeController::SetChannelEffect(unsigned char channel,
                                                 unsigned char num_leds,
                                                 unsigned char mode,
@@ -446,9 +459,40 @@ void CorsairLightingNodeController::SendPortState
     hid_read(dev, usb_buf, 17);
 }
 
-void CorsairLightingNodeController::SendBrightness()
+void CorsairLightingNodeController::SendBrightness
+    (
+    unsigned char   channel,
+    unsigned char   brightness
+    )
 {
+    unsigned char   usb_buf[65];
 
+    /*-----------------------------------------------------*\
+    | Brightness goes from 0-100                            |
+    \*-----------------------------------------------------*/
+    if(brightness > 100)
+    {
+        brightness = 100;
+    }
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Port State packet                              |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_BRIGHTNESS;
+    usb_buf[0x02]   = channel;
+    usb_buf[0x03]   = brightness;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 17);
 }
 
 void CorsairLightingNodeController::SendLEDCount()

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.h

@@ -88,6 +88,8 @@ public:
 
     unsigned int    GetStripsOnChannel(unsigned int channel);
 
+    void            SetBrightness(unsigned char brightness);
+    
     void            SetChannelEffect(unsigned char channel,
                                      unsigned char num_leds,
                                      unsigned char mode,
@@ -171,7 +173,11 @@ private:
                         unsigned char   state
                         );
 
-    void            SendBrightness();
+    void            SendBrightness
+                        (
+                        unsigned char   channel,
+                        unsigned char   brightness
+                        );
 
     void            SendLEDCount();
 

Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.cpp

@@ -23,145 +23,178 @@ RGBController_CorsairLightingNode::RGBController_CorsairLightingNode(CorsairLigh
     serial      = corsair->GetSerialString();
 
     mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0xFFFF;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    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 RainbowWave;
-    RainbowWave.name       = "Rainbow Wave";
-    RainbowWave.value      = CORSAIR_LIGHTING_NODE_MODE_RAINBOW_WAVE;
-    RainbowWave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    RainbowWave.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    RainbowWave.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    RainbowWave.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    RainbowWave.direction  = MODE_DIRECTION_RIGHT;
-    RainbowWave.color_mode = MODE_COLORS_NONE;
+    RainbowWave.name           = "Rainbow Wave";
+    RainbowWave.value          = CORSAIR_LIGHTING_NODE_MODE_RAINBOW_WAVE;
+    RainbowWave.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    RainbowWave.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    RainbowWave.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    RainbowWave.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    RainbowWave.direction      = MODE_DIRECTION_RIGHT;
+    RainbowWave.color_mode     = MODE_COLORS_NONE;
+    RainbowWave.brightness_min = 0;
+    RainbowWave.brightness_max = 100;
+    RainbowWave.brightness     = 100;
     modes.push_back(RainbowWave);
 
     mode ColorShift;
-    ColorShift.name       = "Color Shift";
-    ColorShift.value      = CORSAIR_LIGHTING_NODE_MODE_COLOR_SHIFT;
-    ColorShift.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    ColorShift.colors_min = 2;
-    ColorShift.colors_max = 2;
-    ColorShift.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    ColorShift.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    ColorShift.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    ColorShift.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorShift.name           = "Color Shift";
+    ColorShift.value          = CORSAIR_LIGHTING_NODE_MODE_COLOR_SHIFT;
+    ColorShift.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    ColorShift.colors_min     = 2;
+    ColorShift.colors_max     = 2;
+    ColorShift.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    ColorShift.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    ColorShift.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    ColorShift.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     ColorShift.colors.resize(2);
+    ColorShift.brightness_min = 0;
+    ColorShift.brightness_max = 100;
+    ColorShift.brightness     = 100;
     modes.push_back(ColorShift);
 
     mode ColorPulse;
-    ColorPulse.name       = "Color Pulse";
-    ColorPulse.value      = CORSAIR_LIGHTING_NODE_MODE_COLOR_PULSE;
-    ColorPulse.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    ColorPulse.colors_min = 2;
-    ColorPulse.colors_max = 2;
-    ColorPulse.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    ColorPulse.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    ColorPulse.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    ColorPulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorPulse.name           = "Color Pulse";
+    ColorPulse.value          = CORSAIR_LIGHTING_NODE_MODE_COLOR_PULSE;
+    ColorPulse.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    ColorPulse.colors_min     = 2;
+    ColorPulse.colors_max     = 2;
+    ColorPulse.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    ColorPulse.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    ColorPulse.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    ColorPulse.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     ColorPulse.colors.resize(2);
+    ColorPulse.brightness_min = 0;
+    ColorPulse.brightness_max = 100;
+    ColorPulse.brightness     = 100;
     modes.push_back(ColorPulse);
 
     mode ColorWave;
-    ColorWave.name       = "Color Wave";
-    ColorWave.value      = CORSAIR_LIGHTING_NODE_MODE_COLOR_WAVE;
-    ColorWave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    ColorWave.colors_min = 2;
-    ColorWave.colors_max = 2;
-    ColorWave.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    ColorWave.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    ColorWave.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    ColorWave.direction  = MODE_DIRECTION_RIGHT;
-    ColorWave.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorWave.name           = "Color Wave";
+    ColorWave.value          = CORSAIR_LIGHTING_NODE_MODE_COLOR_WAVE;
+    ColorWave.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    ColorWave.colors_min     = 2;
+    ColorWave.colors_max     = 2;
+    ColorWave.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    ColorWave.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    ColorWave.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    ColorWave.direction      = MODE_DIRECTION_RIGHT;
+    ColorWave.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     ColorWave.colors.resize(2);
+    ColorWave.brightness_min = 0;
+    ColorWave.brightness_max = 100;
+    ColorWave.brightness     = 100;
     modes.push_back(ColorWave);
 
     mode Static;
-    Static.name       = "Static";
-    Static.value      = CORSAIR_LIGHTING_NODE_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.name           = "Static";
+    Static.value          = CORSAIR_LIGHTING_NODE_MODE_STATIC;
+    Static.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Static.colors_min     = 1;
+    Static.colors_max     = 1;
+    Static.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Static.colors.resize(1);
+    Static.brightness_min = 0;
+    Static.brightness_max = 100;
+    Static.brightness     = 100;
     modes.push_back(Static);
 
     mode Temperature;
-    Temperature.name       = "Temperature";
-    Temperature.value      = CORSAIR_LIGHTING_NODE_MODE_TEMPERATURE;
-    Temperature.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Temperature.colors_min = 3;
-    Temperature.colors_max = 3;
-    Temperature.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Temperature.name           = "Temperature";
+    Temperature.value          = CORSAIR_LIGHTING_NODE_MODE_TEMPERATURE;
+    Temperature.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Temperature.colors_min     = 3;
+    Temperature.colors_max     = 3;
+    Temperature.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Temperature.colors.resize(3);
+    Temperature.brightness_min = 0;
+    Temperature.brightness_max = 100;
+    Temperature.brightness     = 100;
     modes.push_back(Temperature);
 
     mode Visor;
-    Visor.name       = "Visor";
-    Visor.value      = CORSAIR_LIGHTING_NODE_MODE_VISOR;
-    Visor.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Visor.colors_min = 2;
-    Visor.colors_max = 2;
-    Visor.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    Visor.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    Visor.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    Visor.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Visor.name           = "Visor";
+    Visor.value          = CORSAIR_LIGHTING_NODE_MODE_VISOR;
+    Visor.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Visor.colors_min     = 2;
+    Visor.colors_max     = 2;
+    Visor.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    Visor.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    Visor.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    Visor.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Visor.colors.resize(2);
+    Visor.brightness_min = 0;
+    Visor.brightness_max = 100;
+    Visor.brightness     = 100;
     modes.push_back(Visor);
 
     mode Marquee;
-    Marquee.name       = "Marquee";
-    Marquee.value      = CORSAIR_LIGHTING_NODE_MODE_MARQUEE;
-    Marquee.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Marquee.colors_min = 1;
-    Marquee.colors_max = 1;
-    Marquee.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    Marquee.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    Marquee.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    Marquee.direction  = MODE_DIRECTION_RIGHT;
-    Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Marquee.name           = "Marquee";
+    Marquee.value          = CORSAIR_LIGHTING_NODE_MODE_MARQUEE;
+    Marquee.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Marquee.colors_min     = 1;
+    Marquee.colors_max     = 1;
+    Marquee.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    Marquee.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    Marquee.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    Marquee.direction      = MODE_DIRECTION_RIGHT;
+    Marquee.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Marquee.colors.resize(1);
+    Marquee.brightness_min = 0;
+    Marquee.brightness_max = 100;
+    Marquee.brightness     = 100;
     modes.push_back(Marquee);
 
     mode Blink;
-    Blink.name       = "Blink";
-    Blink.value      = CORSAIR_LIGHTING_NODE_MODE_BLINK;
-    Blink.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Blink.colors_min = 2;
-    Blink.colors_max = 2;
-    Blink.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    Blink.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    Blink.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    Blink.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Blink.name           = "Blink";
+    Blink.value          = CORSAIR_LIGHTING_NODE_MODE_BLINK;
+    Blink.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Blink.colors_min     = 2;
+    Blink.colors_max     = 2;
+    Blink.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    Blink.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    Blink.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    Blink.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Blink.colors.resize(2);
+    Blink.brightness_min = 0;
+    Blink.brightness_max = 100;
+    Blink.brightness     = 100;
     modes.push_back(Blink);
 
     mode Sequential;
-    Sequential.name       = "Sequential";
-    Sequential.value      = CORSAIR_LIGHTING_NODE_MODE_SEQUENTIAL;
-    Sequential.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Sequential.colors_min = 1;
-    Sequential.colors_max = 1;
-    Sequential.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    Sequential.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    Sequential.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    Sequential.direction  = MODE_DIRECTION_RIGHT;
-    Sequential.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Sequential.name           = "Sequential";
+    Sequential.value          = CORSAIR_LIGHTING_NODE_MODE_SEQUENTIAL;
+    Sequential.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Sequential.colors_min     = 1;
+    Sequential.colors_max     = 1;
+    Sequential.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    Sequential.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    Sequential.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    Sequential.direction      = MODE_DIRECTION_RIGHT;
+    Sequential.color_mode     = MODE_COLORS_MODE_SPECIFIC;
     Sequential.colors.resize(1);
+    Sequential.brightness_min = 0;
+    Sequential.brightness_max = 100;
+    Sequential.brightness     = 100;
     modes.push_back(Sequential);
 
     mode Rainbow;
-    Rainbow.name       = "Rainbow";
-    Rainbow.value      = CORSAIR_LIGHTING_NODE_MODE_RAINBOW;
-    Rainbow.flags      = MODE_FLAG_HAS_SPEED;
-    Rainbow.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    Rainbow.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    Rainbow.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    Rainbow.color_mode = MODE_COLORS_NONE;
+    Rainbow.name           = "Rainbow";
+    Rainbow.value          = CORSAIR_LIGHTING_NODE_MODE_RAINBOW;
+    Rainbow.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Rainbow.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    Rainbow.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    Rainbow.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    Rainbow.color_mode     = MODE_COLORS_NONE;
+    Rainbow.brightness_min = 0;
+    Rainbow.brightness_max = 100;
+    Rainbow.brightness     = 100;
     modes.push_back(Rainbow);
 
     SetupZones();
@@ -324,4 +357,13 @@ void RGBController_CorsairLightingNode::DeviceUpdateMode()
                                       mode_colors[8]);
         }
     }
+
+    if(modes[active_mode].flags & MODE_FLAG_HAS_BRIGHTNESS)
+    {
+        corsair->SetBrightness(modes[active_mode].brightness);
+    }
+    else
+    {
+        corsair->SetBrightness(100);
+    }
 }

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

@@ -59,18 +59,18 @@ CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle,
     ReadFirmwareInfo();
 
     /*-----------------------------------------------------*\
-    | K95 Platinum requires additional steps                |
+    | K55 and K95 Platinum require additional steps         |
     \*-----------------------------------------------------*/
-    if (logical_layout == CORSAIR_TYPE_K95_PLAT)
+    if (logical_layout == CORSAIR_TYPE_K55 || logical_layout == CORSAIR_TYPE_K95_PLAT)
     {
         SpecialFunctionControl();
     }
 
     LightingControl();
 
-    if (logical_layout == CORSAIR_TYPE_K95_PLAT)
+    if (logical_layout == CORSAIR_TYPE_K55 || logical_layout == CORSAIR_TYPE_K95_PLAT)
     {
-        SetupK95LightingControl();
+        SetupK55AndK95LightingControl();
     }
 }
 
@@ -112,7 +112,12 @@ std::string CorsairPeripheralController::GetName()
 std::string CorsairPeripheralController::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());
@@ -232,7 +237,6 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
     SubmitKeyboardFullColors(3, 3, 2);
 }
 
-
 void CorsairPeripheralController::SetLEDsMouse(std::vector<RGBColor> colors)
 {
     SubmitMouseColors(colors.size(), &colors[0]);
@@ -370,7 +374,7 @@ void CorsairPeripheralController::LightingControl()
 | Probably a key mapping packet?                        |
 \*-----------------------------------------------------*/
 
-void CorsairPeripheralController::SetupK95LightingControl()
+void CorsairPeripheralController::SetupK55AndK95LightingControl()
 {
     char usb_buf[65];
 
@@ -535,7 +539,6 @@ void CorsairPeripheralController::ReadFirmwareInfo()
 
                     case 0x1B3D:
                     logical_layout = CORSAIR_TYPE_K55;
-                    SpecialFunctionControl();
                     break;
 
                     default:

Controllers/CorsairPeripheralController/CorsairPeripheralController.h

@@ -97,7 +97,7 @@ private:
     int                     logical_layout;    //Normal, K95 or K95 Platinum
 
     void    LightingControl();
-    void    SetupK95LightingControl();
+    void    SetupK55AndK95LightingControl();
     void    SpecialFunctionControl();
 
     void    ReadFirmwareInfo();

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -91,7 +91,7 @@ void DetectCorsairPeripheralControllers(hid_device_info* info, const std::string
 /*-----------------------------------------------------------------------------------------------------*\
 | Keyboards                                                                                             |
 \*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Corsair K55 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K55_RGB_PID,           1, 0xFFC2); // Not per-key, disabled for now
+REGISTER_HID_DETECTOR_IP("Corsair K55 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K55_RGB_PID,           1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K65 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_PID,           1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K65 LUX RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_LUX_RGB_PID,       1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K65 RGB RAPIDFIRE",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_RAPIDFIRE_PID, 1, 0xFFC2);

Controllers/CorsairWirelessController/CorsairWirelessController.cpp

@@ -51,7 +51,12 @@ std::string CorsairWirelessController::GetName()
 std::string CorsairWirelessController::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());

Controllers/DasKeyboardController/DasKeyboardController.cpp

@@ -38,7 +38,7 @@ std::string DasKeyboardController::GetSerialString()
     int     err                = hid_get_serial_number_string(dev, serial_string, 128);
 
     std::string return_string;
-    if(!err)
+    if(err == 0)
     {
         std::wstring return_wstring = serial_string;
         return_string = std::string(return_wstring.begin(), return_wstring.end());

Controllers/DuckyKeyboardController/DuckyKeyboardController.cpp

@@ -31,7 +31,12 @@ std::string DuckyKeyboardController::GetDeviceLocation()
 std::string DuckyKeyboardController::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());

Controllers/E131Controller/E131ControllerDetect.cpp

@@ -87,39 +87,42 @@ void DetectE131Controllers(std::vector<RGBController*> &rgb_controllers)
 
             if(e131_settings["devices"][device_idx].contains("matrix_order"))
             {
-                std::string matrix_order_val = e131_settings["devices"][device_idx]["matrix_order"];
+                if(e131_settings["devices"][device_idx]["matrix_order"].is_string())
+                {
+                    std::string matrix_order_val = e131_settings["devices"][device_idx]["matrix_order"];
 
-                if(matrix_order_val == "HORIZONTAL_TOP_LEFT")
-                {
-                    dev.matrix_order = E131_MATRIX_ORDER_HORIZONTAL_TOP_LEFT;
-                }
-                else if(matrix_order_val == "HORIZONTAL_TOP_RIGHT")
-                {
-                    dev.matrix_order = E131_MATRIX_ORDER_HORIZONTAL_TOP_RIGHT;
-                }
-                else if(matrix_order_val == "HORIZONTAL_BOTTOM_LEFT")
-                {
-                    dev.matrix_order = E131_MATRIX_ORDER_HORIZONTAL_BOTTOM_LEFT;
-                }
-                else if(matrix_order_val == "HORIZONTAL_BOTTOM_RIGHT")
-                {
-                    dev.matrix_order = E131_MATRIX_ORDER_HORIZONTAL_BOTTOM_RIGHT;
-                }
-                else if(matrix_order_val == "VERTICAL_TOP_LEFT")
-                {
-                    dev.matrix_order = E131_MATRIX_ORDER_VERTICAL_TOP_LEFT;
-                }
-                else if(matrix_order_val == "VERTICAL_TOP_RIGHT")
-                {
-                    dev.matrix_order = E131_MATRIX_ORDER_VERTICAL_TOP_RIGHT;
-                }
-                else if(matrix_order_val == "VERTICAL_BOTTOM_LEFT")
-                {
-                    dev.matrix_order = E131_MATRIX_ORDER_VERTICAL_BOTTOM_LEFT;
-                }
-                else if(matrix_order_val == "VERTICAL_BOTTOM_RIGHT")
-                {
-                    dev.matrix_order = E131_MATRIX_ORDER_VERTICAL_BOTTOM_RIGHT;
+                    if(matrix_order_val == "HORIZONTAL_TOP_LEFT")
+                    {
+                        dev.matrix_order = E131_MATRIX_ORDER_HORIZONTAL_TOP_LEFT;
+                    }
+                    else if(matrix_order_val == "HORIZONTAL_TOP_RIGHT")
+                    {
+                        dev.matrix_order = E131_MATRIX_ORDER_HORIZONTAL_TOP_RIGHT;
+                    }
+                    else if(matrix_order_val == "HORIZONTAL_BOTTOM_LEFT")
+                    {
+                        dev.matrix_order = E131_MATRIX_ORDER_HORIZONTAL_BOTTOM_LEFT;
+                    }
+                    else if(matrix_order_val == "HORIZONTAL_BOTTOM_RIGHT")
+                    {
+                        dev.matrix_order = E131_MATRIX_ORDER_HORIZONTAL_BOTTOM_RIGHT;
+                    }
+                    else if(matrix_order_val == "VERTICAL_TOP_LEFT")
+                    {
+                        dev.matrix_order = E131_MATRIX_ORDER_VERTICAL_TOP_LEFT;
+                    }
+                    else if(matrix_order_val == "VERTICAL_TOP_RIGHT")
+                    {
+                        dev.matrix_order = E131_MATRIX_ORDER_VERTICAL_TOP_RIGHT;
+                    }
+                    else if(matrix_order_val == "VERTICAL_BOTTOM_LEFT")
+                    {
+                        dev.matrix_order = E131_MATRIX_ORDER_VERTICAL_BOTTOM_LEFT;
+                    }
+                    else if(matrix_order_val == "VERTICAL_BOTTOM_RIGHT")
+                    {
+                        dev.matrix_order = E131_MATRIX_ORDER_VERTICAL_BOTTOM_RIGHT;
+                    }
                 }
                 else
                 {
@@ -129,31 +132,34 @@ void DetectE131Controllers(std::vector<RGBController*> &rgb_controllers)
 
             if(e131_settings["devices"][device_idx].contains("rgb_order"))
             {
-                std::string rgb_order_val = e131_settings["devices"][device_idx]["rgb_order"];
+                if(e131_settings["devices"][device_idx]["rgb_order"].is_string())
+                {
+                    std::string rgb_order_val = e131_settings["devices"][device_idx]["rgb_order"];
 
-                if(rgb_order_val == "RGB")
-                {
-                    dev.rgb_order = E131_RGB_ORDER_RGB;
-                }
-                else if(rgb_order_val == "RBG")
-                {
-                    dev.rgb_order = E131_RGB_ORDER_RBG;
-                }
-                else if(rgb_order_val == "GRB")
-                {
-                    dev.rgb_order = E131_RGB_ORDER_GRB;
-                }
-                else if(rgb_order_val == "GBR")
-                {
-                    dev.rgb_order = E131_RGB_ORDER_GBR;
-                }
-                else if(rgb_order_val == "BRG")
-                {
-                    dev.rgb_order = E131_RGB_ORDER_BGR;
-                }
-                else if(rgb_order_val == "BGR")
-                {
-                    dev.rgb_order = E131_RGB_ORDER_BGR;
+                    if(rgb_order_val == "RGB")
+                    {
+                        dev.rgb_order = E131_RGB_ORDER_RGB;
+                    }
+                    else if(rgb_order_val == "RBG")
+                    {
+                        dev.rgb_order = E131_RGB_ORDER_RBG;
+                    }
+                    else if(rgb_order_val == "GRB")
+                    {
+                        dev.rgb_order = E131_RGB_ORDER_GRB;
+                    }
+                    else if(rgb_order_val == "GBR")
+                    {
+                        dev.rgb_order = E131_RGB_ORDER_GBR;
+                    }
+                    else if(rgb_order_val == "BRG")
+                    {
+                        dev.rgb_order = E131_RGB_ORDER_BGR;
+                    }
+                    else if(rgb_order_val == "BGR")
+                    {
+                        dev.rgb_order = E131_RGB_ORDER_BGR;
+                    }
                 }
                 else
                 {
@@ -178,19 +184,22 @@ void DetectE131Controllers(std::vector<RGBController*> &rgb_controllers)
             
             if(e131_settings["devices"][device_idx].contains("type"))
             {
-                std::string type_val = e131_settings["devices"][device_idx]["type"];
+                if(e131_settings["devices"][device_idx]["type"].is_string())
+                {
+                    std::string type_val = e131_settings["devices"][device_idx]["type"];
 
-                if(type_val == "SINGLE")
-                {
-                    dev.type = ZONE_TYPE_SINGLE;
-                }
-                else if(type_val == "LINEAR")
-                {
-                    dev.type = ZONE_TYPE_LINEAR;
-                }
-                else if(type_val == "MATRIX")
-                {
-                    dev.type = ZONE_TYPE_MATRIX;
+                    if(type_val == "SINGLE")
+                    {
+                        dev.type = ZONE_TYPE_SINGLE;
+                    }
+                    else if(type_val == "LINEAR")
+                    {
+                        dev.type = ZONE_TYPE_LINEAR;
+                    }
+                    else if(type_val == "MATRIX")
+                    {
+                        dev.type = ZONE_TYPE_MATRIX;
+                    }
                 }
                 else
                 {

Controllers/EVGAGPUController/EVGAGPUControllerDetect.cpp

@@ -30,18 +30,20 @@ typedef struct
 
 static const gpu_pci_device device_list[] =
 {
-    { NVIDIA_VEN,   NVIDIA_GTX1070_DEV,       EVGA_SUB_VEN,   EVGA_GTX1070_FTW_SUB_DEV,               EVGA_RGB_V1,    "EVGA GeForce GTX 1070 FTW"               },
-    { NVIDIA_VEN,   NVIDIA_GTX1070TI_DEV,     EVGA_SUB_VEN,   EVGA_GTX1070TI_FTW2_SUB_DEV,            EVGA_RGB_V1,    "EVGA GeForce GTX 1070 Ti FTW2"           },
-    { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,       EVGA_SUB_VEN,   EVGA_GTX1080_FTW_SUB_DEV,               EVGA_RGB_V1,    "EVGA GeForce GTX 1080 FTW"               },
-    { NVIDIA_VEN,   NVIDIA_RTX2070_OC_DEV,    EVGA_SUB_VEN,   EVGA_RTX2070_XC_GAMING_SUB_DEV,         EVGA_RGB_V2,    "EVGA GeForce RTX 2070 XC Gaming"         },
-    { NVIDIA_VEN,   NVIDIA_RTX2070_OC_DEV,    EVGA_SUB_VEN,   EVGA_RTX2070_XC_OC_SUB_DEV,             EVGA_RGB_V2,    "EVGA GeForce RTX 2070 XC OC"             },
-    { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,      EVGA_SUB_VEN,   EVGA_RTX2070S_XC_ULTRA_SUB_DEV,         EVGA_RGB_V2,    "EVGA GeForce RTX 2070 SUPER XC Ultra"    },
-    { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,      EVGA_SUB_VEN,   EVGA_RTX2070S_XC_ULTRA_PLUS_SUB_DEV,    EVGA_RGB_V2,    "EVGA GeForce RTX 2070 SUPER XC Ultra+"   },
-    { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_BLACK_SUB_DEV,          EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Black"          },
-    { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_GAMING_SUB_DEV,         EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Gaming"         },
-    { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_ULTRA_GAMING_SUB_DEV,   EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Ultra Gaming"   },
-    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080TI_XC_ULTRA_GAMING_SUB_DEV, EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti XC Ultra"        },
-    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080TI_FTW3_ULTRA_SUB_DEV     , EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti FTW3 Ultra"      },
+    { NVIDIA_VEN,   NVIDIA_GTX1070_DEV,       EVGA_SUB_VEN,   EVGA_GTX1070_FTW_SUB_DEV,                 EVGA_RGB_V1,    "EVGA GeForce GTX 1070 FTW"               },
+    { NVIDIA_VEN,   NVIDIA_GTX1070TI_DEV,     EVGA_SUB_VEN,   EVGA_GTX1070TI_FTW2_SUB_DEV,              EVGA_RGB_V1,    "EVGA GeForce GTX 1070 Ti FTW2"           },
+    { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,       EVGA_SUB_VEN,   EVGA_GTX1080_FTW_SUB_DEV,                 EVGA_RGB_V1,    "EVGA GeForce GTX 1080 FTW"               },
+    { NVIDIA_VEN,   NVIDIA_RTX2070_OC_DEV,    EVGA_SUB_VEN,   EVGA_RTX2070_XC_GAMING_SUB_DEV,           EVGA_RGB_V2,    "EVGA GeForce RTX 2070 XC Gaming"         },
+    { NVIDIA_VEN,   NVIDIA_RTX2070_OC_DEV,    EVGA_SUB_VEN,   EVGA_RTX2070_XC_OC_SUB_DEV,               EVGA_RGB_V2,    "EVGA GeForce RTX 2070 XC OC"             },
+    { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,      EVGA_SUB_VEN,   EVGA_RTX2070S_XC_ULTRA_SUB_DEV,           EVGA_RGB_V2,    "EVGA GeForce RTX 2070 SUPER XC Ultra"    },
+    { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,      EVGA_SUB_VEN,   EVGA_RTX2070S_XC_ULTRA_PLUS_SUB_DEV,      EVGA_RGB_V2,    "EVGA GeForce RTX 2070 SUPER XC Ultra+"   },
+    { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_BLACK_SUB_DEV,            EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Black"          },
+    { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_GAMING_SUB_DEV,           EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Gaming"         },
+    { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_ULTRA_GAMING_SUB_DEV,     EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Ultra Gaming"   },
+    { NVIDIA_VEN,   NVIDIA_RTX2080S_DEV,      EVGA_SUB_VEN,   EVGA_RTX2080S_FTW3_ULTRA_SUB_DEV,         EVGA_RGB_V2,    "EVGA GeForce RTX 2080 SUPER FTW3 Ultra"  },
+    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080TI_XC_ULTRA_GAMING_SUB_DEV,   EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti XC Ultra"        },
+    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080TI_XC_HYBRID_GAMING_SUB_DEV,  EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti XC HYBRID GAMING"},
+    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080TI_FTW3_ULTRA_SUB_DEV,        EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti FTW3 Ultra"      },
 
 };
 

Controllers/EVisionKeyboardController/EVisionKeyboardController.cpp

@@ -33,7 +33,12 @@ std::string EVisionKeyboardController::GetDeviceLocation()
 std::string EVisionKeyboardController::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());

Controllers/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp

@@ -9,12 +9,15 @@
 | Keyboard product IDs                                  |
 \*-----------------------------------------------------*/
 #define EVISION_KEYBOARD_VID            0x0C45
+#define WOMIER_K87_VID                  0x320F
 #define EVISION_KEYBOARD_USAGE_PAGE     0xFF1C
 #define REDRAGON_K550_PID               0x5204
 #define REDRAGON_K552_PID               0x5104
 #define REDRAGON_K556_PID               0x5004
 #define TECWARE_PHANTOM_ELITE_PID       0x652F
 #define WARRIOR_KANE_TC235              0x8520
+#define WOMIER_K87_PID                  0x502A
+#define WOMIER_K66_PID                  0x7698
 
 /******************************************************************************************\
 *                                                                                          *
@@ -44,3 +47,5 @@ REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5104",  DetectEVisionKeyboards,
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5004",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   REDRAGON_K556_PID,         1, EVISION_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:652F",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   TECWARE_PHANTOM_ELITE_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:8520",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   WARRIOR_KANE_TC235,        1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:502A",  DetectEVisionKeyboards, WOMIER_K87_VID,         WOMIER_K87_PID,            1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:7698",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   WOMIER_K66_PID,            1, EVISION_KEYBOARD_USAGE_PAGE);

Controllers/EVisionKeyboardController/RGBController_EVisionKeyboard.cpp

@@ -34,14 +34,14 @@ RGBController_EVisionKeyboard::RGBController_EVisionKeyboard(EVisionKeyboardCont
     mode Custom;
     Custom.name       = "Custom";
     Custom.value      = EVISION_KB_MODE_CUSTOM;
-    Custom.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Custom.flags      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
     Custom.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Custom);
 
     mode ColorWave;
     ColorWave.name       = "Color Wave";
     ColorWave.value      = EVISION_KB_MODE_COLOR_WAVE_LONG;
-    ColorWave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorWave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
     ColorWave.speed_min  = EVISION_KB_SPEED_SLOWEST;
     ColorWave.speed_max  = EVISION_KB_SPEED_FASTEST;
     ColorWave.speed      = EVISION_KB_SPEED_NORMAL;
@@ -54,7 +54,7 @@ RGBController_EVisionKeyboard::RGBController_EVisionKeyboard(EVisionKeyboardCont
     mode ColorWheel;
     ColorWheel.name       = "Color Wheel";
     ColorWheel.value      = EVISION_KB_MODE_COLOR_WHEEL;
-    ColorWheel.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorWheel.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
     ColorWheel.speed_min  = EVISION_KB_SPEED_SLOWEST;
     ColorWheel.speed_max  = EVISION_KB_SPEED_FASTEST;
     ColorWheel.speed      = EVISION_KB_SPEED_NORMAL;
@@ -67,7 +67,7 @@ RGBController_EVisionKeyboard::RGBController_EVisionKeyboard(EVisionKeyboardCont
     mode SpectrumCycle;
     SpectrumCycle.name       = "Spectrum Cycle";
     SpectrumCycle.value      = EVISION_KB_MODE_SPECTRUM_CYCLE;
-    SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED;
+    SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
     SpectrumCycle.speed_min  = EVISION_KB_SPEED_SLOWEST;
     SpectrumCycle.speed_max  = EVISION_KB_SPEED_FASTEST;
     SpectrumCycle.speed      = EVISION_KB_SPEED_NORMAL;
@@ -77,7 +77,7 @@ RGBController_EVisionKeyboard::RGBController_EVisionKeyboard(EVisionKeyboardCont
     mode Breathing;
     Breathing.name       = "Breathing";
     Breathing.value      = EVISION_KB_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
     Breathing.speed_min  = EVISION_KB_SPEED_SLOWEST;
     Breathing.speed_max  = EVISION_KB_SPEED_FASTEST;
     Breathing.speed      = EVISION_KB_SPEED_NORMAL;
@@ -90,7 +90,7 @@ RGBController_EVisionKeyboard::RGBController_EVisionKeyboard(EVisionKeyboardCont
     mode Hurricane;
     Hurricane.name       = "Hurricane";
     Hurricane.value      = EVISION_KB_MODE_HURRICANE;
-    Hurricane.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Hurricane.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
     Hurricane.speed_min  = EVISION_KB_SPEED_SLOWEST;
     Hurricane.speed_max  = EVISION_KB_SPEED_FASTEST;
     Hurricane.speed      = EVISION_KB_SPEED_NORMAL;
@@ -103,7 +103,7 @@ RGBController_EVisionKeyboard::RGBController_EVisionKeyboard(EVisionKeyboardCont
     mode Accumulate;
     Accumulate.name       = "Accumulate";
     Accumulate.value      = EVISION_KB_MODE_ACCUMULATE;
-    Accumulate.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Accumulate.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
     Accumulate.speed_min  = EVISION_KB_SPEED_SLOWEST;
     Accumulate.speed_max  = EVISION_KB_SPEED_FASTEST;
     Accumulate.speed      = EVISION_KB_SPEED_NORMAL;
@@ -116,7 +116,7 @@ RGBController_EVisionKeyboard::RGBController_EVisionKeyboard(EVisionKeyboardCont
     mode Starlight;
     Starlight.name       = "Starlight";
     Starlight.value      = EVISION_KB_MODE_STARLIGHT_FAST;
-    Starlight.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Starlight.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
     Starlight.speed_min  = EVISION_KB_SPEED_SLOWEST;
     Starlight.speed_max  = EVISION_KB_SPEED_FASTEST;
     Starlight.speed      = EVISION_KB_SPEED_NORMAL;
@@ -129,7 +129,7 @@ RGBController_EVisionKeyboard::RGBController_EVisionKeyboard(EVisionKeyboardCont
     mode Visor;
     Visor.name       = "Visor";
     Visor.value      = EVISION_KB_MODE_VISOR;
-    Visor.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Visor.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
     Visor.speed_min  = EVISION_KB_SPEED_SLOWEST;
     Visor.speed_max  = EVISION_KB_SPEED_FASTEST;
     Visor.speed      = EVISION_KB_SPEED_NORMAL;
@@ -142,7 +142,7 @@ RGBController_EVisionKeyboard::RGBController_EVisionKeyboard(EVisionKeyboardCont
     mode Static;
     Static.name       = "Static";
     Static.value      = EVISION_KB_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
     Static.colors_min = 1;
     Static.colors_max = 1;
     Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
@@ -152,14 +152,14 @@ RGBController_EVisionKeyboard::RGBController_EVisionKeyboard(EVisionKeyboardCont
     mode RainbowCircle;
     RainbowCircle.name       = "Rainbow Circle";
     RainbowCircle.value      = EVISION_KB_MODE_RAINBOW_WAVE_CIRCLE;
-    RainbowCircle.flags      = 0;
+    RainbowCircle.flags      = MODE_FLAG_AUTOMATIC_SAVE;
     RainbowCircle.color_mode = MODE_COLORS_NONE;
     modes.push_back(RainbowCircle);
 
     mode Blooming;
     Blooming.name       = "Blooming";
     Blooming.value      = EVISION_KB_MODE_BLOOMING;
-    Blooming.flags      = MODE_FLAG_HAS_SPEED;
+    Blooming.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
     Blooming.speed_min  = EVISION_KB_SPEED_SLOWEST;
     Blooming.speed_max  = EVISION_KB_SPEED_FASTEST;
     Blooming.speed      = EVISION_KB_SPEED_NORMAL;
@@ -169,7 +169,7 @@ RGBController_EVisionKeyboard::RGBController_EVisionKeyboard(EVisionKeyboardCont
     mode Reactive;
     Reactive.name       = "Reactive";
     Reactive.value      = EVISION_KB_MODE_REACTIVE;
-    Reactive.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Reactive.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
     Reactive.speed_min  = EVISION_KB_SPEED_SLOWEST;
     Reactive.speed_max  = EVISION_KB_SPEED_FASTEST;
     Reactive.speed      = EVISION_KB_SPEED_NORMAL;
@@ -182,7 +182,7 @@ RGBController_EVisionKeyboard::RGBController_EVisionKeyboard(EVisionKeyboardCont
     mode ReactiveRipple;
     ReactiveRipple.name       = "Reactive Ripple";
     ReactiveRipple.value      = EVISION_KB_MODE_REACTIVE_RIPPLE;
-    ReactiveRipple.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ReactiveRipple.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
     ReactiveRipple.speed_min  = EVISION_KB_SPEED_SLOWEST;
     ReactiveRipple.speed_max  = EVISION_KB_SPEED_FASTEST;
     ReactiveRipple.speed      = EVISION_KB_SPEED_NORMAL;
@@ -195,7 +195,7 @@ RGBController_EVisionKeyboard::RGBController_EVisionKeyboard(EVisionKeyboardCont
     mode ReactiveLine;
     ReactiveLine.name       = "Reactive Line";
     ReactiveLine.value      = EVISION_KB_MODE_REACTIVE_LINE;
-    ReactiveLine.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ReactiveLine.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
     ReactiveLine.speed_min  = EVISION_KB_SPEED_SLOWEST;
     ReactiveLine.speed_max  = EVISION_KB_SPEED_FASTEST;
     ReactiveLine.speed      = EVISION_KB_SPEED_NORMAL;

Controllers/GigabyteAorusCPUCoolerController/ATC800Controller.cpp

@@ -30,7 +30,12 @@ std::string ATC800Controller::GetDeviceLocation()
 std::string ATC800Controller::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());

Controllers/GigabyteRGBFusion2SMBusController/GigabyteRGBFusion2SMBusController.cpp

@@ -122,6 +122,62 @@ void RGBFusion2SMBusController::SetLEDEffect
         led_data[led][RGB_FUSION_2_TIMER_2_MSB] = 0x03 * speed;
         break;
 
+        case RGB_FUSION_2_MODE_DIGITAL_WAVE:
+        // Timer 1: On time
+        // Timer 2: Off time
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x50 * speed;
+        led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x01;
+        break;
+
+        case RGB_FUSION_2_MODE_DIGITAL_A:
+        // Timer 1: Directly controls speed of LED sections
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x39 * speed;
+        led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00;  // Setting this to any number other than 0 slows down the effect
+        led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x01;    // Doesn't do anything, but always defaults to 0x01
+        break;
+
+        case RGB_FUSION_2_MODE_DIGITAL_B:
+        // Timer 1: Direct control of section speed and pulsing
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x2d * speed; // Main effect speed
+        led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00;         // Only sets to 0x01 in min speed. Makes light section blink for shorter periods
+        led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x04;           // Changes between 0x01 and 0x04 along with speed. Controls light trail length.
+        break;
+
+        case RGB_FUSION_2_MODE_DIGITAL_C:
+        // Timer 1: Effect Speed
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x2d * speed;
+        led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00;  // Like Digital A, slows down the effect, but never sets to another number.
+        led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x04;    // Fixed at 0x04. Does nothing.
+        break;
+
+        case RGB_FUSION_2_MODE_DIGITAL_D:
+        // Timer 1: Effect Speed
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x2d * speed;
+        led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00;  // Like Digital A, slows down the effect, but never sets to another number.
+        led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x04;    // Fixed at 0x04. Does nothing.
+        break;
+
+        case RGB_FUSION_2_MODE_DIGITAL_E:
+        // Timer 1: Effect Speed
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x25 * speed;
+        led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0;     // Like Digital A, slows down the effect, but never sets to another number.
+        led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x04;    // Fixed at 0x04. Does nothing.
+        break;
+
+        case RGB_FUSION_2_MODE_DIGITAL_F:
+        // Timer 1: Effect Speed
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x2d * speed;
+        led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00;  // Like Digital A, slows down the effect, but never sets to another number.
+        led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x04;    // Fixed at 0x04. Does nothing.
+        break;
+
+        case RGB_FUSION_2_MODE_DIGITAL_G:
+        // Timer 1: Effect Speed
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x23 * speed;
+        led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00;  // Like Digital A, slows down the effect, but never sets to another number.
+        led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x04;    // Fixed at 0x04. Does nothing.
+        break;
+
         case RGB_FUSION_2_MODE_COLOR_CYCLE:
             // Timer 1: Cycle time
             led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x00;

Controllers/GigabyteRGBFusion2SMBusController/GigabyteRGBFusion2SMBusController.h

@@ -54,15 +54,16 @@ enum
     RGB_FUSION_2_MODE_STATIC        = 0x04,     /* Static color mode                */
     RGB_FUSION_2_MODE_FLASHING      = 0x05,     /* Flashing / Double Flashing mode  */
     RGB_FUSION_2_MODE_TRANSITION    = 0x09,	    /* Gradual transition from current  */
-    RGB_FUSION_2_MODE_DIGITAL_A	    = 0x0A,	    /* Wave mode			            */
-    RGB_FUSION_2_MODE_DIGITAL_B	    = 0x0B,	    /* 				                    */
-    RGB_FUSION_2_MODE_DIGITAL_C	    = 0x0C,	    /* 				                    */
-    RGB_FUSION_2_MODE_DIGITAL_D	    = 0x0D,	    /* 				                    */
-    RGB_FUSION_2_MODE_DIGITAL_E	    = 0x0E,	    /* 				                    */
-    RGB_FUSION_2_MODE_DIGITAL_F	    = 0x0F,	    /* 				                    */
-    RGB_FUSION_2_MODE_DIGITAL_G	    = 0x10,	    /* 				                    */
-    RGB_FUSION_2_MODE_DIGITAL_H	    = 0x11,	    /* 				                    */
-    RGB_FUSION_2_MODE_DIGITAL_I	    = 0x12,	    /* 				                    */
+    RGB_FUSION_2_MODE_DIGITAL_WAVE	= 0x0A,	    /* Wave mode			            */
+    RGB_FUSION_2_MODE_DIGITAL_A	    = 0x0B,	    /* 				                    */
+    RGB_FUSION_2_MODE_DIGITAL_B	    = 0x0C,	    /* 				                    */
+    RGB_FUSION_2_MODE_DIGITAL_C	    = 0x0D,	    /* 				                    */
+    RGB_FUSION_2_MODE_DIGITAL_D	    = 0x0F,	    /* 				                    */
+    RGB_FUSION_2_MODE_DIGITAL_E	    = 0x10,	    /* 				                    */
+    RGB_FUSION_2_MODE_DIGITAL_F	    = 0x11,	    /* 				                    */
+    RGB_FUSION_2_MODE_DIGITAL_G	    = 0x12,	    /* 				                    */
+//    RGB_FUSION_2_MODE_DIGITAL_H	    = 0x11,
+//    RGB_FUSION_2_MODE_DIGITAL_I       = 0x12,   They are variants of DIGITAL F and G
 };
 
 enum

Controllers/GigabyteRGBFusion2SMBusController/RGBController_GigabyteRGBFusion2SMBus.cpp

@@ -85,6 +85,86 @@ RGBController_RGBFusion2SMBus::RGBController_RGBFusion2SMBus(RGBFusion2SMBusCont
     ColorCycle.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(ColorCycle);
 
+    mode DigitalWave;
+    DigitalWave.name       = "Digital Wave";
+    DigitalWave.value      = RGB_FUSION_2_MODE_DIGITAL_WAVE;
+    DigitalWave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    DigitalWave.speed_min  = RGB_FUSION_2_SPEED_SLOW;
+    DigitalWave.speed_max  = RGB_FUSION_2_SPEED_FAST;
+    DigitalWave.speed      = RGB_FUSION_2_SPEED_NORMAL;
+    DigitalWave.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(DigitalWave);
+
+    mode DigitalA;
+    DigitalA.name       = "Digital A";
+    DigitalA.value      = RGB_FUSION_2_MODE_DIGITAL_A;
+    DigitalA.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    DigitalA.speed_min  = RGB_FUSION_2_SPEED_SLOW;
+    DigitalA.speed_max  = RGB_FUSION_2_SPEED_FAST;
+    DigitalA.speed      = RGB_FUSION_2_SPEED_NORMAL;
+    DigitalA.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(DigitalA);
+
+    mode DigitalB;
+    DigitalB.name       = "Digital B";
+    DigitalB.value      = RGB_FUSION_2_MODE_DIGITAL_B;
+    DigitalB.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    DigitalB.speed_min  = RGB_FUSION_2_SPEED_SLOW;
+    DigitalB.speed_max  = RGB_FUSION_2_SPEED_FAST;
+    DigitalB.speed      = RGB_FUSION_2_SPEED_NORMAL;
+    DigitalB.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(DigitalB);
+
+    mode DigitalC;
+    DigitalC.name       = "Digital C";
+    DigitalC.value      = RGB_FUSION_2_MODE_DIGITAL_C;
+    DigitalC.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    DigitalC.speed_min  = RGB_FUSION_2_SPEED_SLOW;
+    DigitalC.speed_max  = RGB_FUSION_2_SPEED_FAST;
+    DigitalC.speed      = RGB_FUSION_2_SPEED_NORMAL;
+    DigitalC.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(DigitalC);
+
+    mode DigitalD;
+    DigitalD.name       = "Digital D";
+    DigitalD.value      = RGB_FUSION_2_MODE_DIGITAL_D;
+    DigitalD.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    DigitalD.speed_min  = RGB_FUSION_2_SPEED_SLOW;
+    DigitalD.speed_max  = RGB_FUSION_2_SPEED_FAST;
+    DigitalD.speed      = RGB_FUSION_2_SPEED_NORMAL;
+    DigitalD.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(DigitalD);
+
+    mode DigitalE;
+    DigitalE.name       = "Digital E";
+    DigitalE.value      = RGB_FUSION_2_MODE_DIGITAL_E;
+    DigitalE.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    DigitalE.speed_min  = RGB_FUSION_2_SPEED_SLOW;
+    DigitalE.speed_max  = RGB_FUSION_2_SPEED_FAST;
+    DigitalE.speed      = RGB_FUSION_2_SPEED_NORMAL;
+    DigitalE.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(DigitalE);
+
+    mode DigitalF;
+    DigitalF.name       = "Digital F";
+    DigitalF.value      = RGB_FUSION_2_MODE_DIGITAL_F;
+    DigitalF.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    DigitalF.speed_min  = RGB_FUSION_2_SPEED_SLOW;
+    DigitalF.speed_max  = RGB_FUSION_2_SPEED_FAST;
+    DigitalF.speed      = RGB_FUSION_2_SPEED_NORMAL;
+    DigitalF.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(DigitalF);
+
+    mode DigitalG;
+    DigitalG.name       = "Digital G";
+    DigitalG.value      = RGB_FUSION_2_MODE_DIGITAL_G;
+    DigitalG.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    DigitalG.speed_min  = RGB_FUSION_2_SPEED_SLOW;
+    DigitalG.speed_max  = RGB_FUSION_2_SPEED_FAST;
+    DigitalG.speed      = RGB_FUSION_2_SPEED_NORMAL;
+    DigitalG.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(DigitalG);
+
     SetupZones();
 
     // Initialize active mode

Controllers/GigabyteRGBFusion2USBController/GigabyteRGBFusion2USBController.cpp

@@ -354,7 +354,7 @@ static const std::array< std::array<int, 3>, 5> speeds =
     },
 };
 
-void RGBFusion2USBController::SetLEDEffect(unsigned int led, int mode, unsigned int speed, bool random, unsigned char r, unsigned char g, unsigned char b)
+void RGBFusion2USBController::SetLEDEffect(unsigned int led, int mode, unsigned int speed, unsigned char brightness, bool random, unsigned char r, unsigned char g, unsigned char b)
 {
     PktEffect pkt;
 
@@ -371,6 +371,8 @@ void RGBFusion2USBController::SetLEDEffect(unsigned int led, int mode, unsigned
         pkt.e.period2 = s[2];
     }
 
+    pkt.e.max_brightness = brightness;
+
     switch(mode)
     {
         case 0:

Controllers/GigabyteRGBFusion2USBController/GigabyteRGBFusion2USBController.h

@@ -35,7 +35,7 @@ const uint8_t LED8          = 0x27;
 
 /*-------------------------------------------------------------*\
 | LED "headers" 0x20..0x27, As seen on Gigabyte X570 Elite board|
-| Internal legacy shorthand naming and possibly depracated      |
+| Internal legacy shorthand naming and possibly deprecated      |
 \*-------------------------------------------------------------*/
 const uint8_t HDR_BACK_IO   = LED1;
 const uint8_t HDR_CPU       = LED2;
@@ -219,7 +219,7 @@ public:
                         int             single_led      = -1
                         );
 
-    void            SetLEDEffect(unsigned int led, int mode, unsigned int speed, bool random, unsigned char red, unsigned char green, unsigned char blue);
+    void            SetLEDEffect(unsigned int led, int mode, unsigned int speed, unsigned char brightness, bool random, unsigned char red, unsigned char green, unsigned char blue);
     void            SetLedCount(unsigned int led, unsigned int count);
     void            SetMode(int mode);
     bool            ApplyEffect();

Controllers/GigabyteRGBFusion2USBController/RGBController_GigabyteRGBFusion2USB.cpp

@@ -204,67 +204,85 @@ RGBController_RGBFusion2USB::RGBController_RGBFusion2USB(RGBFusion2USBController
     mode Direct;
     Direct.name             = "Direct";
     Direct.value            = 0xFFFF;
-    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.flags            = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.brightness_min   = RGBFUSION2_BRIGHTNESS_MIN;
+    Direct.brightness_max   = RGBFUSION2_BRIGHTNESS_MAX;
+    Direct.brightness       = RGBFUSION2_BRIGHTNESS_MAX;
     Direct.color_mode       = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode Static;
-    Static.name             = "Static";
-    Static.value            = EFFECT_STATIC;
-    Static.flags            = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Static.colors_min       = 1;
-    Static.colors_max       = 1;
-    Static.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    Static.name                 = "Static";
+    Static.value                = EFFECT_STATIC;
+    Static.flags                = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.brightness_min       = RGBFUSION2_BRIGHTNESS_MIN;
+    Static.brightness_max       = RGBFUSION2_BRIGHTNESS_MAX;
+    Static.brightness           = RGBFUSION2_BRIGHTNESS_MAX;
+    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         = EFFECT_PULSE;
-    Breathing.flags         = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Breathing.speed_min     = 0;
-    Breathing.speed_max     = 4;
-    Breathing.colors_min    = 1;
-    Breathing.colors_max    = 1;
-    Breathing.color_mode    = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.name              = "Breathing";
+    Breathing.value             = EFFECT_PULSE;
+    Breathing.flags             = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Breathing.brightness_min    = RGBFUSION2_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = RGBFUSION2_BRIGHTNESS_MAX;
+    Breathing.brightness        = RGBFUSION2_BRIGHTNESS_MAX;
+    Breathing.speed_min         = 0;
+    Breathing.speed_max         = 4;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 1;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
     Breathing.colors.resize(1);
-    Breathing.speed         = 2;
+    Breathing.speed             = 2;
     modes.push_back(Breathing);
 
     mode Blinking;
-    Blinking.name           = "Blinking";
-    Blinking.value          = EFFECT_BLINKING;
-    Blinking.flags          = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Blinking.speed_min      = 0;
-    Blinking.speed_max      = 4;
-    Blinking.colors_min     = 1;
-    Blinking.colors_max     = 1;
-    Blinking.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Blinking.name               = "Blinking";
+    Blinking.value              = EFFECT_BLINKING;
+    Blinking.flags              = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Blinking.brightness_min     = RGBFUSION2_BRIGHTNESS_MIN;
+    Blinking.brightness_max     = RGBFUSION2_BRIGHTNESS_MAX;
+    Blinking.brightness         = RGBFUSION2_BRIGHTNESS_MAX;
+    Blinking.speed_min          = 0;
+    Blinking.speed_max          = 4;
+    Blinking.colors_min         = 1;
+    Blinking.colors_max         = 1;
+    Blinking.color_mode         = MODE_COLORS_MODE_SPECIFIC;
     Blinking.colors.resize(1);
-    Blinking.speed          = 2;
+    Blinking.speed              = 2;
     modes.push_back(Blinking);
 
     mode ColorCycle;
-    ColorCycle.name         = "Color Cycle";
-    ColorCycle.value        = EFFECT_COLORCYCLE;
-    ColorCycle.flags        = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    ColorCycle.speed_min    = 0;
-    ColorCycle.speed_max    = 4;
-    ColorCycle.color_mode   = MODE_COLORS_NONE;
-    ColorCycle.speed        = 2;
+    ColorCycle.name             = "Color Cycle";
+    ColorCycle.value            = EFFECT_COLORCYCLE;
+    ColorCycle.flags            = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    ColorCycle.brightness_min   = RGBFUSION2_BRIGHTNESS_MIN;
+    ColorCycle.brightness_max   = RGBFUSION2_BRIGHTNESS_MAX;
+    ColorCycle.brightness       = RGBFUSION2_BRIGHTNESS_MAX;
+    ColorCycle.speed_min        = 0;
+    ColorCycle.speed_max        = 4;
+    ColorCycle.color_mode       = MODE_COLORS_NONE;
+    ColorCycle.speed            = 2;
     modes.push_back(ColorCycle);
 
     mode Flashing;
-    Flashing.name           = "Flashing";
-    Flashing.value          = 10;
-    Flashing.flags          = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Flashing.speed_min      = 0;
-    Flashing.speed_max      = 4;
-    Flashing.colors_min     = 1;
-    Flashing.colors_max     = 1;
-    Flashing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Flashing.name               = "Flashing";
+    Flashing.value              = 10;
+    Flashing.flags              = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Flashing.brightness_min     = RGBFUSION2_BRIGHTNESS_MIN;
+    Flashing.brightness_max     = RGBFUSION2_BRIGHTNESS_MAX;
+    Flashing.brightness         = RGBFUSION2_BRIGHTNESS_MAX;
+    Flashing.speed_min          = 0;
+    Flashing.speed_max          = 4;
+    Flashing.colors_min         = 1;
+    Flashing.colors_max         = 1;
+    Flashing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
     Flashing.colors.resize(1);
-    Flashing.speed          = 2;
+    Flashing.speed              = 2;
     modes.push_back(Flashing);
 
     Load_Device_Config();
@@ -559,7 +577,7 @@ void RGBController_RGBFusion2USB::UpdateZoneLEDs(int zone)
             /*---------------------------------------------------------*\
             | Apply the mode and color to the zone                      |
             \*---------------------------------------------------------*/
-            controller->SetLEDEffect(zones[zone].leds[led_idx].value, mode_value, modes[active_mode].speed, random, red, grn, blu);
+            controller->SetLEDEffect(zones[zone].leds[led_idx].value, mode_value, modes[active_mode].speed, modes[active_mode].brightness, random, red, grn, blu);
         }
         
         controller->ApplyEffect();
@@ -605,7 +623,7 @@ void RGBController_RGBFusion2USB::UpdateZoneLEDs(int zone)
                 | Apply built-in effects to LED strips                      |
                 \*---------------------------------------------------------*/
                 controller->DisableBuiltinEffect(0, hdr == HDR_D_LED1 ? 0x01 : 0x02);
-                controller->SetLEDEffect(hdr, modes[active_mode].value, modes[active_mode].speed, random, red, grn, blu);
+                controller->SetLEDEffect(hdr, modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, random, red, grn, blu);
                 controller->ApplyEffect();
             }
         }
@@ -652,7 +670,7 @@ void RGBController_RGBFusion2USB::UpdateSingleLED(int led)
             blu = RGBGetBValue(modes[active_mode].colors[0]);
         }
 
-        controller->SetLEDEffect(leds[led].value, mode_value, modes[active_mode].speed, random, red, grn, blu);
+        controller->SetLEDEffect(leds[led].value, mode_value, modes[active_mode].speed, modes[active_mode].brightness, random, red, grn, blu);
         controller->ApplyEffect();
     }
     /*---------------------------------------------------------*\

Controllers/GigabyteRGBFusion2USBController/RGBController_GigabyteRGBFusion2USB.h

@@ -16,6 +16,8 @@
 
 #define RGBFusion2_Digital_LEDS_Min         0;
 #define RGBFusion2_Digital_LEDS_Max         1024;
+#define RGBFUSION2_BRIGHTNESS_MIN           0;
+#define RGBFUSION2_BRIGHTNESS_MAX           100;
 #define RGBFusion2_Digital_Direct_Offset    (HDR_D_LED1_RGB - HDR_D_LED1);
 
 template<typename K, typename V>

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUController.cpp

@@ -36,12 +36,30 @@ void RGBFusionGPUController::SetColor(unsigned char red, unsigned char green, un
     bus->i2c_smbus_write_byte(dev, red);
     bus->i2c_smbus_write_byte(dev, green);
     bus->i2c_smbus_write_byte(dev, blue);
+
+    // Pad commands with 4 zero-bytes for NVIDIA_RTX3060_DEV
+    if (dev == 0x62)
+    {
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+    }
 }
 
-void RGBFusionGPUController::SetMode(unsigned char mode, unsigned char speed)
+void RGBFusionGPUController::SetMode(unsigned char mode, unsigned char speed, unsigned char brightness)
 {
     bus->i2c_smbus_write_byte(dev, RGB_FUSION_GPU_REG_MODE);
     bus->i2c_smbus_write_byte(dev, mode);
     bus->i2c_smbus_write_byte(dev, speed);
-    bus->i2c_smbus_write_byte(dev, 0x63);
+    bus->i2c_smbus_write_byte(dev, brightness);
+
+    // Pad commands with 4 zero-bytes for NVIDIA_RTX3060_DEV
+    if (dev == 0x62)
+    {
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+    }
 }

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUController.h

@@ -36,6 +36,12 @@ enum
     RGB_FUSION_GPU_SPEED_FASTEST        = 0x09
 };
 
+enum
+{
+    RGB_FUSION_GPU_BRIGHTNESS_MIN       = 0x00,
+    RGB_FUSION_GPU_BRIGHTNESS_MAX       = 0x63
+};
+
 class RGBFusionGPUController
 {
 public:
@@ -45,7 +51,7 @@ public:
     std::string     GetDeviceLocation();
 
     void            SetColor(unsigned char red, unsigned char green, unsigned char blue);
-    void            SetMode(unsigned char mode, unsigned char speed);
+    void            SetMode(unsigned char mode, unsigned char speed, unsigned char brightness);
 
 private:
     i2c_smbus_interface*    bus;

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUControllerDetect.cpp

@@ -23,8 +23,10 @@ typedef struct
 static const gpu_pci_device device_list[] =
 {
     { NVIDIA_VEN,   NVIDIA_GTX1050TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1050TI_G1_GAMING_SUB_DEV,           0x48,   "Gigabyte GTX1050 Ti G1 Gaming"                 },
+    { NVIDIA_VEN,   NVIDIA_GTX1060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1060_G1_GAMING_OC_SUB_DEV,          0x47,   "Gigabyte GTX1060 G1 Gaming 6G OC"              },
     { NVIDIA_VEN,   NVIDIA_GTX1060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1060_XTREME_SUB_DEV,                0x47,   "Gigabyte GTX1060 Xtreme Gaming"                },
     { NVIDIA_VEN,   NVIDIA_GTX1070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1070_XTREME_SUB_DEV,                0x47,   "Gigabyte GTX1070 Xtreme Gaming"                },
+    { NVIDIA_VEN,   NVIDIA_GTX1070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1070TI_GAMING_SUB_DEV,              0x47,   "Gigabyte GTX1070 Ti 8G Gaming"                 },
     { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080_G1_GAMING_SUB_DEV,             0x48,   "Gigabyte GTX1080 G1 Gaming"                    },
     { NVIDIA_VEN,   NVIDIA_GTX1080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080TI_SUB_DEV,                     0x47,   "Gigabyte GTX1080 Ti 11G"                       },
     { NVIDIA_VEN,   NVIDIA_GTX1080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080TI_GAMING_OC_SUB_DEV,           0x47,   "Gigabyte GTX1080 Ti Gaming OC 11G"             },
@@ -34,15 +36,25 @@ static const gpu_pci_device device_list[] =
     { NVIDIA_VEN,   NVIDIA_GTX1650_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1650_GAMING_OC_SUB_DEV,             0x55,   "Gigabyte GTX1650 Gaming OC"                    },
     { NVIDIA_VEN,   NVIDIA_GTX1660S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_GTX1660S_GAMING_OC_SUB_DEV,            0x47,   "Gigabyte GTX1660 SUPER Gaming OC"              },
     { NVIDIA_VEN,   NVIDIA_RTX2060_TU106_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060_GAMING_OC_SUB_DEV,             0x47,   "Gigabyte RTX2060 Gaming OC"                    },
-    { NVIDIA_VEN,   NVIDIA_RTX2060S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060S_GAMING_SUB_DEV,               0x47,   "Gigabyte RTX2060 SUPER Gaming"                 },
+    { NVIDIA_VEN,   NVIDIA_RTX2060_TU106_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060_GAMING_OC_PRO_SUB_DEV,         0x47,   "Gigabyte RTX2060 Gaming OC PRO"                },
+    { NVIDIA_VEN,   NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060S_GAMING_SUB_DEV,               0x47,   "Gigabyte RTX2060 SUPER Gaming"                 },
+    { NVIDIA_VEN,   NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060S_GAMING_OC_SUB_DEV,            0x47,   "Gigabyte RTX2060 SUPER Gaming OC"              },
+    { NVIDIA_VEN,   NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060S_GAMING_OC_WHITE_SUB_DEV,      0x47,   "Gigabyte RTX2060 SUPER Gaming OC 3X White 8G"  },
     { NVIDIA_VEN,   NVIDIA_RTX2070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070_GAMING_OC_SUB_DEV,             0x47,   "Gigabyte RTX2070 Gaming OC 8G"                 },
     { NVIDIA_VEN,   NVIDIA_RTX2070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070_WINDFORCE_SUB_DEV,             0x47,   "Gigabyte RTX2070 Windforce 8G"                 },
     { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070S_GAMING_OC_SUB_DEV,            0x47,   "Gigabyte RTX2070S Gaming OC"                   },
     { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070S_GAMING_OC_3X_SUB_DEV,         0x55,   "Gigabyte RTX2070S Gaming OC 3X"                },
     { NVIDIA_VEN,   NVIDIA_RTX2080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2080_GAMING_OC_SUB_DEV,             0x47,   "Gigabyte RTX2080 Gaming OC 8G"                 },
     { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX2080_A_GAMING_OC_SUB_DEV,           0x47,   "Gigabyte RTX2080 Gaming OC 8G"                 },
-    { NVIDIA_VEN,   NVIDIA_RTX3060TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_EAGLE_OC_SUB_DEV,            0x63,   "Gigabyte RTX3060 EAGLE OC 8G"                  },
+    { NVIDIA_VEN,   NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX2080S_GAMING_OC_SUB_DEV,            0x47,   "Gigabyte RTX2080S Gaming OC 8G"                },
+    { NVIDIA_VEN,   NVIDIA_RTX3060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_GAMING_OC_12GB_SUB_DEV,        0x62,   "Gigabyte RTX3060 Gaming OC 12G"                },
+    { NVIDIA_VEN,   NVIDIA_RTX3060_V2_DEV,      GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_GAMING_OC_12GB_SUB_DEV,        0x62,   "Gigabyte RTX3060 Gaming OC 12G"                },
+    { NVIDIA_VEN,   NVIDIA_RTX3060TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_EAGLE_OC_SUB_DEV,            0x63,   "Gigabyte RTX3060 Ti EAGLE OC 8G"               },
+    { NVIDIA_VEN,   NVIDIA_RTX3060TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_GAMING_OC_SUB_DEV,           0x62,   "Gigabyte RTX3060 Ti Gaming OC 8G"              },
+    { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_GAMING_OC_SUB_DEV,             0x62,   "Gigabyte RTX3070 Gaming OC 8G"                 },
     { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_VISION_OC_SUB_DEV,             0x63,   "Gigabyte RTX3070 Vision 8G"                    },
+    { NVIDIA_VEN,   NVIDIA_RTX3070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070TI_GAMING_OC_SUB_DEV,           0x62,   "Gigabyte RTX3070 Ti Gaming OC 8G"              },
+    { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3090_GAMING_OC_24GB_SUB_DEV,        0x62,   "Gigabyte RTX3090 Gaming OC 24G"                },
 };
 
 /******************************************************************************************\
@@ -67,6 +79,15 @@ bool TestForGigabyteRGBFusionGPUController(i2c_smbus_interface* bus, unsigned ch
         bus->i2c_smbus_write_byte(address, 0x00);
         bus->i2c_smbus_write_byte(address, 0x00);
         bus->i2c_smbus_write_byte(address, 0x00);
+        
+        // NVIDIA_RTX3060_DEV requires additional bytes to initialise
+        if (address == 0x62)
+        {
+            bus->i2c_smbus_write_byte(address, 0x00);
+            bus->i2c_smbus_write_byte(address, 0x00);
+            bus->i2c_smbus_write_byte(address, 0x00);
+            bus->i2c_smbus_write_byte(address, 0x00);
+        }
 
         pass = true;